Skip to content

Navigine/Indoor-Navigation-Android-Mobile-SDK-2.0

BranchesTags

Repository files navigation

Android SDK 2.0

📱 Quick Start: 🆕 Modern Compose Demo (Recommended) | Legacy Java/XML Demo

The following sections describe the contents of the Navigine Android SDK repository. The files in our public repository for Android are:

  • Sources of the Navigine Demo Applications for Android (Compose + Java)
  • Navigine SDK for Android in form of a AAR file

Useful Links

Values and benefits

Enhanced User Experience: An Indoor Navigation SDK for Android provides users with an intuitive and seamless navigation experience within indoor environments. It helps them easily navigate complex spaces such as shopping malls, airports, museums, or hospitals, reducing confusion and improving overall user satisfaction.

Accurate Positioning: The SDK utilizes advanced positioning technologies, such as Bluetooth Low Energy (BLE), Wi-Fi, UWB etc., to achieve high accuracy in indoor positioning. Users can rely on precise location information to navigate to specific destinations, find points of interest, and locate desired products or services within a venue.

Indoor Mapping and Wayfinding: The SDK offers indoor mapping capabilities, allowing developers to integrate detailed maps of indoor spaces into their Android applications. Users can benefit from interactive maps, highlighted routes, and turn-by-turn directions to efficiently navigate through the venue and reach their desired destinations.

Location-Based Services: With an Indoor Navigation SDK, developers can build Android applications that offer location-based services tailored to specific indoor environments. This opens up opportunities to provide personalized recommendations, targeted promotions, and context-aware information based on the user's location within the venue.

Integration with Existing Apps: The SDK can be seamlessly integrated into existing Android applications, enhancing their functionality with indoor navigation capabilities. This enables businesses and organizations to leverage their existing user base and infrastructure, saving time and resources while providing a value-added service to their customers.

Improved Operational Efficiency: For businesses and organizations, an Indoor Navigation SDK can optimize operational efficiency. It can assist in managing crowds, monitoring visitor flows, and optimizing resource allocation within a venue. This data-driven approach helps businesses streamline their operations, improve staff productivity, and enhance the overall visitor experience.

Analytics and Insights: An Indoor Navigation SDK often includes analytics and reporting functionalities, providing valuable insights into user behavior, traffic patterns, and popular areas within a venue. Businesses can leverage this data to make informed decisions, optimize space utilization, and identify opportunities for improvements or revenue generation.

Multi-Venue Support: Many Indoor Navigation SDKs offer support for multiple venues, allowing businesses to provide a consistent navigation experience across different locations. This flexibility is particularly beneficial for large retail chains, airports, or exhibition centers with multiple venues under their operation.

Customization and Branding: The SDK provides customization options, allowing developers to tailor the indoor navigation experience to match their branding and user interface guidelines. This ensures a consistent and cohesive user experience within the application, reinforcing brand identity and familiarity.

Developer-Friendly Tools and Support: Indoor Navigation SDKs come with comprehensive documentation, developer tools, and dedicated support channels. This empowers developers to efficiently integrate and utilize the SDK, accelerating the development process and ensuring a smooth implementation.

Android Demo Applications

We provide two demo applications to help you get started with Navigine SDK. Choose based on your tech stack:

🆕 NavigineDemoCompose - Modern Kotlin + Jetpack Compose

⭐ Recommended for new projects - Production-ready demo showcasing Navigine SDK with modern Android development.

Why choose the Compose version:

  • ✨ 50% less boilerplate - Clean Architecture with Kotlin-first approach
  • 🚀 Modern UI/UX - Material 3 design, intuitive navigation
  • 🎯 Production patterns - Hilt DI, Coroutines/Flow, proper state management
  • 🔧 Developer-friendly - Type-safe navigation, better testability, clear code structure
  • 📱 Latest standards - Follows current Android best practices (2024+)

Tech Stack: Kotlin, Jetpack Compose, Material 3, Hilt DI, Coroutines/Flow, Retrofit, DataStore

Get Started:

Screenshots:

Navigation  Locations  Debug  />

Quick Start:

git clone https://github.com/Navigine/Indoor-Navigation-Android-Mobile-SDK-2.0.git
cd Indoor-Navigation-Android-Mobile-SDK-2.0/NavigineDemoCompose
# Open in Android Studio and run

NavigineDemo - Legacy Java/XML

Our stable Java/XML demo application for developers working with legacy codebases or preferring traditional Android patterns.

Navigine Demo application enables you to test indoor navigation as well as measure your target location's radiomap.

Get the Java Demo:

For complete guidelines, refer to the Navigine User Manual.

Screenshots:

img/locations.png      img/navigation.png      img/debug.png

📊 Which Demo Should I Use?

Aspect NavigineDemoCompose NavigineDemo (Java)
UI Framework Jetpack Compose XML Views
Language Kotlin Java
Architecture Clean Architecture + MVVM Traditional Android
State Management Flow + Coroutines Callbacks
Dependency Injection Hilt Manual
Code Complexity ~2,500 lines ~5,000+ lines
Material Design Material 3 (2024) Material 2
Recommended For ⭐ New projects, modern apps Legacy codebases
Maintenance Actively maintained Stable, limited updates

Navigation SDK and Implementation

Navigine SDK for Android applications enables you to develop your own indoor navigation apps using the well-developed methods, classes, and functions created by the Navigine team. The SDK file resides in the libs folder.

Find formal description of Navigine-SDK API including the list of classes and their public fields and methods at Navigine SDK wiki.

Using .aar file in Android Studio

  • Download libnavigine.aar file from current repositories libs folder;
  • In your project choose File -> New -> New module -> Import .JAR/.AAR Package;
  • Select downloaded libnavigine.aar file and add it to your project as new module;
  • Add following lines inside dependencies module in your apps build.gradle file:
  implementation project(":libnavigine")
  • Start using Navigine SDK.

Using with Jitpack

JitPack lets you consume this repository (and its Gradle modules) directly from GitHub.

1) Add the JitPack repository

settings.gradle.kts (recommended) 
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven("https://jitpack.io")
    }
}
build.gradle.kts (legacy projects) 
repositories {
    google()
    mavenCentral()
    maven("https://jitpack.io")
}

2) Add a dependency

  • To depend on the root artifact (single-module publish):
dependencies {
    implementation("com.github.Navigine:Indoor-Navigation-Android-Mobile-SDK-2.0:<TAG>")
}
  • To depend on a specific module from this monorepo (multi-module publish), use:
dependencies {
    // Example: take a module named "libnavigine" (replace with actual module name)
    implementation("com.github.Navigine.Indoor-Navigation-Android-Mobile-SDK-2.0:libnavigine:<TAG>")
}

Use a Git tag/release (recommended) or a commit hash as <TAG>.

Jetpack Compose wrapper: LocationView Compose

A modern, production-ready Compose wrapper around Navigine’s LocationView — inspired by the quality bar of android-maps-compose. It provides idiomatic Compose APIs, lifecycle-aware state, and property updaters.

Highlights

  • Drop-in @Composable map container for Navigine SDK
  • Camera state with smooth, coroutine-friendly updates
  • Input & pick handlers (tap/long-press, feature/object picking)
  • Polylines/polygons/circles as declarative map objects
  • Proper cleanup across recompositions & lifecycle events

🎯 See it in a real app!

Want to see LocationViewCompose in action? Check out NavigineDemoCompose - a production-ready demo that showcases all features:

  • Camera state management & animations
  • Map objects (polylines, circles, polygons)
  • Input handlers (tap, long-press, feature picking)
  • Lifecycle-aware setup
  • Integration with Hilt & Clean Architecture

The demo is a perfect reference for building your own indoor navigation app with Compose!

Getting started

1) Add dependencies

dependencies {
    // Note: core sdk is pulled transitively with the library
    implementation("com.navigine:navigine-locationview-compose:2.24.1")
}

Make sure the MavenCentral and JitPack repositories is added to your project as shown above.

2) Initialize Navigine SDK once (e.g., in Application or an early Activity)

val sdk = com.navigine.idl.java.NavigineSdk.getInstance().apply {
    setServer("https://ips.navigine.com")
    setUserHash("<YOUR-USER-HASH>")
}
sdk.locationManager.locationId = <YOUR_LOCATION_ID>

3) Required permissions

Grant Location + Bluetooth (BLE) permissions according to your target SDK (foreground + background if needed).
Ensure the device supports BLE (Android 8.0+ as per SDK requirements).

Quick start (Compose)

@Composable
fun LocationSample() {
    val cameraState = com.navigine.locationview.camera.rememberNavCameraPositionState()

    com.navigine.locationview.compose.NavigineLocation(
        cameraPositionState = cameraState,
        onWindowReady = { window ->
            // Example: set initial sublocation if needed
            window.setSublocationId(<SUBLOCATION_ID>)
        }
    ) {
        // Optional: input handling & picking out of the box
        com.navigine.locationview.compose.InputHandlers(
            autoPickObjectOnTap = true,
            autoPickFeatureOnTap = true,
        )

        com.navigine.locationview.compose.PickHandlers(
            onObjectPicked = { result, viewPt ->
                // Handle object pick
            },
            onFeaturePicked = { attrs, viewPt ->
                // Handle feature pick (e.g., show bottom sheet)
            }
        )

        // Examples of shapes:
        // com.navigine.locationview.compose.Polyline(...)
        // com.navigine.locationview.compose.Polygon(...)
        // com.navigine.locationview.compose.Circle(...)
    }
}

Camera control

val camera = cameraState
LaunchedEffect(Unit) {
    // Animate or move camera (example API)
    camera.animateTo(
        target = com.navigine.locationview.model.NavPoint(x = 10.0, y = 20.0),
        zoom = 1.2f
    )
}

Samples

A sample app with bottom navigation shows 4 demos (Camera, Shapes, Input, Icons) that you can use as a reference for routing, drawing shapes, and handling taps. It’s a good starting point for your own project structure.

Notes

  • The wrapper takes care of resource cleanup and respects recomposition & lifecycle.
  • For release builds, remember to keep your SDK classes if using R8/Proguard (add rules as needed).

Android&HW compatibility

Indoor positioning SDK and applications require Android 8.0 or higher as well your smartphone should have BLE 4.0 or higher.

We are testing our SDK and Apps on the following smartphones: Nexus Pixel 3 (Android 12), Honor 30 pro (Android 10), Xiaomi Redmi 9C (Android 10), Samsung A20 (Android 10, 11), Huawei P20 lite (Android 9), Xiaomi Note (Android 8).

About

SDK for Android to develop own indoor navigation apps, and Navigine demo application for Android to test indoor navigation. Now you get one code for all types of devices with less resource use.

Topics

android sdk navigation demo-application indoor indoor-positioning sdk-android navigine-sdk

Resources

Readme

License

View license

Code of conduct

Code of conduct

Contributing

Contributing
Activity
Custom properties

Stars

63 stars

Watchers

4 watching

Forks

18 forks
Report repository

Releases 4

Release 2.24.5 Latest
Apr 14, 2026
+ 3 releases

Contributors

Languages