Components

Components are functional units based on the internal building blocks that power the HERE SDK APIs. Each component focuses on a specific feature area, such as routing or search. Components are designed to be as decoupled as possible - so if you only need online search, you can skip including the offline search component entirely.

With modularization, we're making these modules available as public components that you can mix and match - like construction bricks - to suit your specific needs. At the same time, we continue to offer the bundled all-in-one version of the HERE SDK that you're already familiar with.

Note

While the HERE SDK (Navigate) is fully supported, not all components are compatible with the HERE SDK (Explore). On top, the map view is available as a separate component only for the HERE SDK for Android (Navigate).

What are the benefits of modularization?

Use only what you need: Select just the components relevant to your use case. This can lead to a smaller application size - though not always, as some components have dependencies. For example, an app that uses only HERE Positioning may be around 32 MB with modularization, compared to approximately 85 MB with the bundled HERE SDK.

More benefits:

• Control over API usage: When you have a clear app concept, you can limit your development team to a specific set of APIs, reducing complexity and potential misuse.
• Faster build times: Smaller dependency trees can lead to shorter compile times, especially during iterative development.
• Clearer dependencies: It's easier to understand what features are in use and what they rely on, which improves transparency for developers and project stakeholders.

When should you not use modularization?

Modularization is powerful, but it's not always the right choice for every project. You might prefer the bundled HERE SDK if:

• You want a simpler integration experience: The bundled Android Archive includes all HERE SDK features in a single package, making setup more straightforward.
• You're unsure which features you'll need: If you're still exploring or prototyping, starting with the full HERE SDK can save time by giving you access to everything without needing to manage dependencies.
• You prefer fewer build and dependency configurations: With the bundled HERE SDK, you avoid managing multiple modules and their potential interdependencies.

How does it work?

Components are hosted on HERE's Artifactory Maven repository at https://repo.platform.here.com/artifactory/here-sdk-android. You configure your project's build.gradle to point to this repository and then declare only the components your app actually needs. Maven's built-in dependency management resolves any transitive component dependencies automatically — you do not need to list them yourself.

For example, if your app requires here-sdk-search-online, Gradle will also automatically pull in here-sdk-core since it is a declared dependency of here-sdk-search-online. Similarly, adding here-sdk-routing-offline or here-sdk-routing-online will automatically bring in here-sdk-routing-core.

What components are available?

All major features are supported and organized into modular components, which are largely aligned with the existing packages documented in the API Reference.

• here-sdk-core: Mandatory module containing core functionality shared between different modules. Includes features from the Core package.
• here-sdk-map-advanced: Advanced map renderer ("HERE Rendering Engine") based on OCM data. Includes features from the MapView package. Only available for the HERE SDK (Navigate).
• here-sdk-map-data: Provides offline access to OCM map data, e.g. segment attributes based on the segment ID or around geographic coordinates via SegementDataLoader. Includes features from the MapData package. Only available for the HERE SDK (Navigate).
• here-sdk-map-loader: Takes care of installing and updating offline OCM maps in the persisted map storage. Includes features from the MapLoader package. Only available for the HERE SDK (Navigate).
• here-sdk-map-matcher: Responsible for SD and HD map-matching based on GPS and other sensor inputs (e.g. vehicle camera). Includes features from the MapMatcher package. Only available for the HERE SDK (Navigate).
• here-sdk-map-loader-remote-connection: Takes care of delivering map data via gRPC. Includes features from the ExternalMapDataSource package. Only available for the HERE SDK (Navigate).
• here-sdk-navigation: Provides headless guidance instructions to follow a route accompanied with an extensive warner system that provides all kind of information along the road. Includes the Navigator class. It also provides a junction view. Includes features from the Navigation package. Only available for the HERE SDK (Navigate).
• here-sdk-navigation-core: Provides shared functionality between here-sdk-mapmatcher, here-sdk-electronic-horizon and here-sdk-navigation components. Only available for the HERE SDK (Navigate).
• here-sdk-positioning: Implements a comprehensive location solution that works with several location sources such as GPS or other Global Navigation Satellite System (GNSS) receivers, mobile network signals and Wi-Fi network signals to determine accurate locations. Supports SD and HD positioning (depends on the hardware and customer license) via LocationEngine. Includes features from the Positioning package. Only available for the HERE SDK (Navigate).
• here-sdk-routing-core: Provides shared functionality between here-sdk-routing-online and here-sdk-routing-offline modules. Includes core features from the Routing package.
• here-sdk-routing-dynamic: Calculates better routes based on the current traffic situation. Includes features around the DynamicRoutingEngine. Only available for the HERE SDK (Navigate).
• here-sdk-routing-isoline: Calculates a reachable area from a center point using the HERE Routing Service via IsolineRoutingEngine. Requires an online connection. Includes features around the IsolineRoutingEngine.
• here-sdk-routing-offline: Calculates offline route directions from A to B, including multiple waypoints and localizable maneuver instructions for each turn using downloaded OCM data via OfflineRoutingEngine. Includes features around the OfflineRoutingEngine. Only available for the HERE SDK (Navigate).
• here-sdk-routing-online: Calculates online route directions from A to B, including multiple waypoints and localizable maneuver instructions for each turn using the HERE Routing Service via RoutingEngine. Includes features from the Routing package.
• here-sdk-routing-transit: Calculates routes for public transportation vehicles such as subways, trains, or public buses via TransitRoutingEngine. Includes features around the TransitRoutingEngine.
• here-sdk-search-offline: Enables offline search & geocoding based on downloaded OCM data via OfflineSearchEngine. Includes features around the OfflineSearchEngine. Only available for the HERE SDK (Navigate).
• here-sdk-search-online: Enables online search & geocoding using the HERE Search Service via SearchEngine. Includes features from the Search package.
• here-sdk-traffic-broadcast: Expects the RDS-TMC format and it can be used when there is no internet connection, so that the HERE SDK can utilize traffic data coming over a radio channel. Requires dedicated hardware support. Includes features from the TrafficBroadcast package. Only available for the HERE SDK (Navigate).
• here-sdk-traffic: Provides online traffic incidents and traffic flow data in a headless way via TrafficEngine. Includes features from the Traffic package.
• here-sdk-visual-navigation: Provides the same features as the headless here-sdk-navigation component, but offers a pre-configured 3D map view experience on top with different optional visual elements. Includes features around the VisualNavigator package. Only available for the HERE SDK (Navigate).
• here-sdk-electronic-horizon: Builds the model of the electronic horizon tree and tracks a position on this tree. Note: it doesn't implement any ADAS protocol (e.g. ADASIS or PSD). Includes features of the Electronic Horizon package. Only available for the HERE SDK (Navigate).

HERE SDK component dependencies

Some components, such as here-sdk-core, are always required but do not depend on other components. Other components, however, may have one or more dependencies. The table below provides an overview of these relationships, which are managed by Maven.

Try the example app

The Traffic example app on GitHub demonstrates how to build an app with only the components it needs (here-sdk-map-advanced, here-sdk-routing-online, here-sdk-traffic) fetched directly from Artifactory. Its build.gradle files show how to switch between a local AAR and the Artifactory components via a single flag. By default, the app is configured to use the local AAR bundle. Note that modularization support for this app is only available for the HERE SDK (Navigate), because the map view is only available for the Navigate license - here-sdk-map-advanced uses OCM, while the HERE SDK (Explore) requires a different map format which is not available as a separate component.

Integration steps

Follow the steps below to add Artifactory-based component support to your own application.

Step 1: Add the Artifactory Maven repository

Open the root-level build.gradle file and add the HERE Artifactory Maven repository inside the allprojects repositories block. Replace the placeholder credentials with the values obtained from https://platform.here.com/access/access-tokens.

allprojects {
    repositories {
        google()
        mavenCentral()
        maven {
            name = 'HERE_SDK_Artifactory_Repository'
            url = "https://repo.platform.here.com/artifactory/here-sdk-android"
            credentials {
                username = project.findProperty('HERESDKArtifactoryUsername') ?: "YOUR_USER_NAME"
                password = project.findProperty('HERESDKArtifactoryPassword') ?: "YOUR_ACCESS_TOKEN"
            }
            content {
                includeGroup "com.here.here-sdk.java.components"
            }
        }
    }
}

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven {
            name = "HERE_SDK_Artifactory_Repository"
            url = uri("https://repo.platform.here.com/artifactory/here-sdk-android")
            credentials {
                username = providers.gradleProperty("HERESDKArtifactoryUsername").orNull ?: "YOUR_USER_NAME"
                password = providers.gradleProperty("HERESDKArtifactoryPassword").orNull ?: "YOUR_ACCESS_TOKEN"
            }
            content {
                includeGroup("com.here.here-sdk.java.components")
            }
        }
    }
}

The content block restricts this repository to HERE SDK component artifacts only, preventing Gradle from querying Artifactory for unrelated dependencies.

Step 2: Store credentials securely

Avoid committing credentials to version control. Instead, store them in your global Gradle properties file at ~/.gradle/gradle.properties:

HERESDKArtifactoryUsername=your_username
HERESDKArtifactoryPassword=your_access_token

Gradle picks up these values automatically via project.findProperty() at build time.

Step 3: Declare only the components your app needs

Open the app-level build.gradle and replace the fileTree dependency (if present) with the specific HERE SDK components your app requires. Hardcode the version to keep your dependencies stable. Replace YOUR_SDK_VERSION with the desired HERE SDK version, e.g. 4.27.1.0.

dependencies {
    // Declare only the HERE SDK components your app requires.
    // Maven resolves transitive component dependencies automatically.
    // IMPORTANT: Do not mix components of different versions.
    def hereSDKVersion = "YOUR_SDK_VERSION"
    implementation "com.here.here-sdk.java.components:here-sdk-map-advanced:${hereSDKVersion}"
    implementation "com.here.here-sdk.java.components:here-sdk-search-offline:${hereSDKVersion}"
    implementation "com.here.here-sdk.java.components:here-sdk-search-online:${hereSDKVersion}"
}

dependencies {
    // Declare only the HERE SDK components your app requires.
    // Maven resolves transitive component dependencies automatically.
    // IMPORTANT: Do not mix components of different versions.
    val hereSDKVersion = "YOUR_SDK_VERSION"
    implementation("com.here.here-sdk.java.components:here-sdk-map-advanced:$hereSDKVersion")
    implementation("com.here.here-sdk.java.components:here-sdk-search-offline:$hereSDKVersion")
    implementation("com.here.here-sdk.java.components:here-sdk-search-online:$hereSDKVersion")
}

You only need to list the components your app directly uses. Transitive dependencies (for example, here-sdk-core required by here-sdk-search-online) are resolved and downloaded by Gradle automatically based on the component POM files published to Artifactory.

Step 4: Sync and build

In Android Studio sync and build the project as usual via File -> Sync Project Files with Gradle Files. Alternatively, execute:

./gradlew build

Gradle will fetch only the declared components and their transitive dependencies from Artifactory. No AAR file needs to be placed in app/libs.