Skip to main content
Version: 1.x (beta)

Getting Started with Wemap SDKs

Location tracking, routing, and navigation for Android.

Overview​

The Wemap SDKs provide comprehensive location, routing, and navigation capabilities for Android apps. They are distributed as several libraries that share a single session:

  • WemapCoreSDK — common types and the foundation for all other SDKs (API access, routing, POIs).
  • WemapMapSDK — customizable, interactive maps built on MapLibre.
  • WemapMapComposeSDK — Jetpack Compose support for the Map SDK (WemapMap). Optional and separate, so View-based apps never depend on the Compose runtime.
  • WemapGeoARSDK — augmented-reality navigation and points of interest.
  • WemapGeoARComposeSDK — Jetpack Compose support for the GeoAR SDK (WemapGeoAR).
  • WemapPositioningSDK — indoor/outdoor positioning:
    • VPS ARCore — visual positioning system, camera-based (best for indoor).
    • VPS Local — offline visual positioning, camera-based, with no network. Alpha, on a version of its own, and needs a map database for your venue — see the note under Installation.
    • GPS — global positioning system (best for outdoor).
    • Fused GMS — Google Play Services fused location (best for outdoor).
    • Android Fused Adaptive — adaptive fused location (Google Play Services or system, best for outdoor).
  • WemapMapWidgetsSDK — ready-made map controls in Jetpack Compose and Views: the levels rail and the itinerary form. Versioned separately — see Map widgets.

Upgrading from 0.x​

v1 is a breaking release. Migrating to v1 walks through it in twelve steps, each of which leaves your project compiling, and ends with an index from compiler error to step number.

Requirements​

Wemap SDKcompileSdkminSdkKotlinJava/JVM
1.x3723 (Android 6.0)2.2+11

Four modules require minSdk 24, each because a hardware-gated dependency demands it: the GeoAR SDK and its Compose companion (ARCore/SceneView, which also need Java 17), and the two VPS positioning sources — wemap-vps-arcore (ARCore) and wemap-vps-local (LiteRT). All other modules target minSdk 23 and Java 11.

The two Compose modules additionally need a Compose BOM of 2026.06.01 or newer. They require no newer AGP or compileSdk than the rest of the SDK.

Installation​

Add the SDK as a dependency via Gradle.

  1. Declare the Wemap Maven repository in settings.gradle.kts:

    dependencyResolutionManagement {
        repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
        repositories {
            google()
            mavenCentral()
            // Wemap Maven repository
            maven("https://s3.eu-west-1.amazonaws.com/mobile.getwemap.com/releases/android")
        }
    }

  2. Add the modules you need to your module-level build.gradle.kts:

    dependencies {
        // interactive maps
        implementation("com.getwemap.sdk:map:<version>")
        // ...plus this one if you use Jetpack Compose
        implementation("com.getwemap.sdk:map-compose:<version>")

        // AR navigation
        implementation("com.getwemap.sdk:geo-ar:<version>")
        // ...plus this one if you use Jetpack Compose
        implementation("com.getwemap.sdk:geo-ar-compose:<version>")

        // positioning — VPS (indoor)
        implementation("com.getwemap.sdk.positioning:wemap-vps-arcore:<version>")
        // positioning — adaptive fused (outdoor)
        implementation("com.getwemap.sdk.positioning:android-fused-adaptive:<version>")

        // positioning — offline VPS (indoor, no network). Alpha, and on a version line of its own:
        // use its own `<alpha-version>`, NOT the one above. See the note below before adding it.
        implementation("com.getwemap.sdk.positioning:wemap-vps-local:<alpha-version>")
    }

    wemap-vps-local is alpha and needs data from us. Its whole public API requires an explicit opt-in, it does not follow semantic versioning — any declaration may change or disappear in any release, including a patch — and it carries its own -alpha.N version rather than the one every other module shares. It also positions against a pre-built map database for your venue, which we build and provide; without one the location source has nothing to match camera frames against. Talk to us before building on it.

  3. Ensure your app's minSdk is at least 23 (24 if you use the GeoAR SDK or either VPS positioning source):

    android {
        defaultConfig {
            minSdk = 23
        }
    }

Map widgets​

com.getwemap.sdk:map-widgets is on a 0.x version line of its own: any release may change its API, so declare an exact version. Each widgets release is built against one release of the SDKs, named under Dependencies in the widgets change log, and brings in com.getwemap.sdk:map at that version for you. If you also declare the SDKs, keep them at that version: Gradle resolves the higher of the two, and the widgets are only tested against their own.

dependencies {
    implementation("com.getwemap.sdk:map-widgets:0.1.0")
}

Creating a session​

Every Wemap SDK is driven by a session. A session loads a map's data once and owns the shared state the SDKs build on (routing, POIs, positioning). Create one session and pass it to each component you use — the shared instance is what keeps navigation, POI selection, and user location consistent across the map, AR, and positioning SDKs.

You must have a mapId and token to create a session. For more details, please contact the Wemap team.

create is a suspending function (it fetches the map from the backend), so call it from a coroutine. Below are examples of how to create a session using different SDKs.

WemapPositioningSDK or WemapCoreSDK​

lifecycleScope.launch {
    runCatching {
        CoreSession.create(context, 19158, "GUHTU6TYAWWQHUSR5Z5JZNMXX") // Specify your mapId and token here
    }.onSuccess { session ->
        // now you have a session and can use it to continue with any WemapSDK
    }.onFailure {
        println("Failed to create session with error - $it")
    }
}

WemapMapSDK​

lifecycleScope.launch {
    runCatching {
        MapSession.create(context, 19158, "GUHTU6TYAWWQHUSR5Z5JZNMXX") // Specify your mapId and token here
    }.onSuccess { session ->
        // now you have a session and can pass it to a WemapMapView
        mapView.configure(session)
    }.onFailure {
        println("Failed to create session with error - ${it.message}")
    }
}

The MapSDK guide goes on from there.

The session is the sole owner of its services. When the screen that owns it goes away, tear it down with session.deinit() — typically from the lifecycle owner that holds it (e.g. a ViewModel.onCleared()).

Examples​

For sample implementations, see the official sample-apps repository. Clone it and follow its README to run the sample apps.