LimeLink Android SDK 1.0.0

Min SDK 24 · Compile SDK reference 33 · Java bytecode 8

LimeLink Android SDK handles direct links, App Links, deferred deep links, and explicit view tracking through Kotlin and Java facades. Version 1.0.0 is publicly resolvable from the LimeLink Maven repository; immutable GitHub tag and release provenance remains pending.

View previous Android SDK releases

Install

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven {
            url = uri("https://hellovelop.github.io/limelink-aos-sdk-binary/repository")
            content { includeGroup("org.limelink") }
        }
    }
}

dependencies {
    implementation("org.limelink:limelink-aos-sdk:1.0.0")
}

The public Maven repository supports credential-free Gradle resolution. JitPack, source dependencies, composite builds, Maven Local, debug AARs, and direct release-AAR installation are not production routes.

Initialize

class MyApp : Application() {
    private val listener = object : LimeLinkListener {
        override fun onDeeplinkReceived(result: LimeLinkResult) {
            if (isAllowedDestination(result.deeplinkUrl)) {
                navigateTo(result.deeplinkUrl)
            }
        }

        override fun onDeferredDeepLinkNotFound() = Unit

        override fun onDeeplinkError(error: LimeLinkError) {
            showSafeFallback(error.code, error.message)
        }
    }

    override fun onCreate() {
        super.onCreate()
        LimeLinkSDK.addLinkListener(listener)

        val config = LimeLinkConfig.Builder(
            "550e8400-e29b-41d4-a716-446655440000"
        ).setLogging(false).build()
        LimeLinkSDK.init(this, config)
    }
}

Use the public Project UUID in app configuration; Organization API credentials remain server-side credentials. Automatic deferred lookup starts for every eligible installation.

Manifest and lifecycle

Configure the Activity for the exact LimeLink or Custom Domain owned by the app. A typical App Link filter uses https, the registered host, and /link/ where applicable. Keep launchMode="singleTop" and update the current Intent:

override fun onNewIntent(intent: Intent) {
    super.onNewIntent(intent)
    setIntent(intent)
}

Normal Activity lifecycle handling owns cold and warm App Links. Only when the host explicitly owns a handoff, call:

LimeLinkSDK.handleIncomingLink(this, intent)

The API accepts actual ACTION_VIEW Intents. Direct links are absolute hierarchical non-web URLs resolved to the host app; HTTP(S) links use Dynamic Lookup. Unsafe, malformed, relative, whitespace, and control-character URLs are rejected. Direct links stay local to the app without resolve or Stats networking.

Receive results

The strongly retained listener registered before init receives Direct, App Link, and Deferred successes through onDeeplinkReceived.

All public callbacks run on the Android main thread. Parse deeplinkUrl and exactly compare its scheme and host against an app-owned allowlist before navigation.

Buffering, ordering, and deduplication

• Pre-initialization accepted links use a process-memory capacity-10, oldest-drop FIFO and start after successful initialization.
• Successful results completed without listeners use a separate capacity-10 FIFO and replay once to the first non-empty listener snapshot.
• Errors and deferred not-found outcomes are live-only and never replayed.
• Work completes independently; a direct result may overtake a network lookup.
• The dedupe key is source plus exact ingress URL. Pending/in-flight duplicates and successful duplicates within five monotonic seconds are suppressed without URL normalization.
• Process death clears in-memory queues.

Manual deferred handling

LimeLinkSDK.handleDeferredDeepLink(this) { result, error ->
    when {
        result != null && isAllowedDestination(result.deeplinkUrl) ->
            navigateTo(result.deeplinkUrl)
        error != null -> showSafeFallback(error.code, error.message)
        else -> Unit
    }
}

Matched, not-found, and failed outcomes reach both the completion and current listener. Their relative order is unspecified; choose one navigation owner.

Java facade

The Java facade exposes exactly:

LimeLinkJavaSDK.initialize(context, config, listener);
LimeLinkJavaSDK.handleIncomingLink(activity, intent);
LimeLinkJavaSDK.handleDeferredDeepLink(context, callback);
boolean initialized = LimeLinkJavaSDK.isInitialized();

Java initialization must run on the main thread. The Deferred callback provides onMatched, onNotFound, and onFailed.

Explicit stats

Use LimeLinkSDK.trackLinkStatus(context, intent) only for a separate app-owned view event. It is best effort; successful Dynamic Lookup already owns lookup attribution.

Migrating from 0.4.1

• Replace removed handleUniversalLink(activity, intent) with handleIncomingLink(activity, intent).
• Replace resolvedUri with required deeplinkUrl.
• Remove queryParams, pathParams, and PathParamResponse; parse deeplinkUrl when needed.
• Handle the required source and nullable originalUrl fields.
• Recompile consumers against 1.0.0 and apply native FIFO/deduplication semantics.