shekhar23/claude-zero-to-hero-android-kmp/android-dynamic-feature-modules

android {
    dynamicFeatures += setOf(":feature-camera", ":feature-admin")
}

plugins {
    id("com.android.dynamic-feature")
    id("org.jetbrains.kotlin.android")
}
 
android {
    namespace = "com.example.feature.camera"
    compileSdk = 35
 
    defaultConfig {
        minSdk = 26
    }
}
 
dependencies {
    // depend on :app, not the other way around
    implementation(project(":app"))
    // your feature dependencies
}

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:dist="http://schemas.android.com/apk/distribution">
 
    <dist:module
        dist:instant="false"
        dist:title="@string/title_feature_camera">
        <dist:delivery>
            <dist:on-demand />
        </dist:delivery>
        <dist:fusing dist:include="true" />
    </dist:module>
 
</manifest>

class DynamicFeatureLoader(private val activity: Activity) {
 
    private val splitInstallManager = SplitInstallManagerFactory.create(activity)
 
    fun installCameraFeature(
        onInstalled: () -> Unit,
        onProgress: (Int) -> Unit,
        onFailure: (Int) -> Unit,
    ) {
        // Already installed — proceed immediately
        if (splitInstallManager.installedModules.contains("feature-camera")) {
            onInstalled()
            return
        }
 
        val request = SplitInstallRequest.newBuilder()
            .addModule("feature-camera")
            .build()
 
        splitInstallManager.registerListener { state ->
            when (state.status()) {
                SplitInstallSessionStatus.DOWNLOADING -> {
                    val progress = (state.bytesDownloaded() * 100 / state.totalBytesToDownload()).toInt()
                    onProgress(progress)
                }
                SplitInstallSessionStatus.INSTALLED -> onInstalled()
                SplitInstallSessionStatus.FAILED -> onFailure(state.errorCode())
                SplitInstallSessionStatus.REQUIRES_USER_CONFIRMATION -> {
                    // Large modules require user confirmation
                    splitInstallManager.startConfirmationDialogForResult(state, activity, REQUEST_CODE)
                }
                else -> Unit
            }
        }
 
        splitInstallManager.startInstall(request)
            .addOnFailureListener { exception ->
                val errorCode = (exception as? SplitInstallException)?.errorCode
                    ?: SplitInstallErrorCode.INTERNAL_ERROR
                onFailure(errorCode)
            }
    }
}

fun handleInstallError(errorCode: Int): UiText = when (errorCode) {
    SplitInstallErrorCode.NETWORK_ERROR ->
        UiText.StringResource(R.string.error_no_network)
    SplitInstallErrorCode.INSUFFICIENT_STORAGE ->
        UiText.StringResource(R.string.error_no_storage)
    SplitInstallErrorCode.MODULE_UNAVAILABLE ->
        UiText.StringResource(R.string.error_feature_unavailable)
    SplitInstallErrorCode.ACCESS_DENIED ->
        UiText.StringResource(R.string.error_access_denied)
    else ->
        UiText.StringResource(R.string.error_generic)
}

// After install confirmed:
val intent = Intent().setClassName(
    packageName,
    "com.example.feature.camera.CameraActivity"
)
startActivity(intent)

<!-- nav graph in :app -->
<include-dynamic
    android:id="@+id/camera_graph"
    app:moduleName="feature-camera"
    app:graphResName="camera_nav_graph"
    app:progressDestination="@id/installProgressFragment" />

@Composable
fun CameraEntryPoint(loader: DynamicFeatureLoader) {
    var installState by remember { mutableStateOf<InstallState>(InstallState.Idle) }
 
    when (installState) {
        is InstallState.Idle -> {
            Button(onClick = {
                installState = InstallState.Installing(0)
                loader.installCameraFeature(
                    onInstalled = { installState = InstallState.Installed },
                    onProgress = { installState = InstallState.Installing(it) },
                    onFailure = { installState = InstallState.Failed(it) },
                )
            }) { Text("Open Camera") }
        }
        is InstallState.Installing -> LinearProgressIndicator(
            progress = { (installState as InstallState.Installing).progress / 100f }
        )
        is InstallState.Installed -> CameraScreen() // loaded via reflection or class reference
        is InstallState.Failed -> ErrorView(
            message = handleInstallError((installState as InstallState.Failed).errorCode)
        )
    }
}
 
sealed interface InstallState {
    data object Idle : InstallState
    data class Installing(val progress: Int) : InstallState
    data object Installed : InstallState
    data class Failed(val errorCode: Int) : InstallState
}

# Build app bundle
./gradlew :app:bundleDebug
 
# Install with bundletool (simulates Play delivery)
bundletool build-apks \
    --bundle=app/build/outputs/bundle/debug/app-debug.aab \
    --output=app.apks \
    --local-testing
 
bundletool install-apks --apks=app.apks

class FakeSplitInstallManager : SplitInstallManager {
    private val _installedModules = mutableSetOf<String>()
    override fun getInstalledModules(): Set<String> = _installedModules
 
    fun simulateInstall(moduleName: String) {
        _installedModules.add(moduleName)
    }
    // implement other interface methods as no-ops
}