Advanced Android Patterns

// ❌ Bad - Activity leaks through singleton
module {
    single { SomeService(get<Activity>()) }
}

// ✅ Good - Use Application context
module {
    single { SomeService(androidContext()) }
}

// ✅ Good - Use scoped for Activity-bound dependencies
module {
    activityScope {
        scoped { ActivityBoundService() }
    }
}

module {
    // Application context - safe for singletons
    single { DatabaseHelper(androidContext()) }

    // Application instance
    single { AppConfig(androidApplication()) }
}

fun createLogger(): Logger =
    if (BuildConfig.DEBUG) DebugLogger() else ReleaseLogger()

val loggingModule = module {
    single { create(::createLogger) }
}

@Module
class LoggingModule {
    @Single
    fun provideLogger(): Logger =
        if (BuildConfig.DEBUG) DebugLogger() else ReleaseLogger()
}

fun createAnalyticsService(): AnalyticsService =
    if (BuildConfig.ENABLE_ANALYTICS) GoogleAnalytics() else NoOpAnalytics()

val analyticsModule = module {
    single { create(::createAnalyticsService) }
}

@Singleton
class PaymentProcessor(
    private val featureFlags: FeatureFlagService,
    private val newProcessor: NewPaymentProcessor,
    private val legacyProcessor: LegacyPaymentProcessor
) {
    fun process(amount: Double) {
        if (featureFlags.isEnabled("new_payment_flow")) {
            newProcessor.process(amount)
        } else {
            legacyProcessor.process(amount)
        }
    }
}

@Factory
class DialogProvider(private val context: Context) {

    fun createConfirmDialog(title: String, onConfirm: () -> Unit): AlertDialog =
        AlertDialog.Builder(context)
            .setTitle(title)
            .setPositiveButton("OK") { _, _ -> onConfirm() }
            .create()

    fun createErrorDialog(message: String): AlertDialog =
        AlertDialog.Builder(context)
            .setTitle("Error")
            .setMessage(message)
            .setPositiveButton("OK", null)
            .create()
}

class MainActivity : AppCompatActivity() {
    private val dialogProvider: DialogProvider by inject()

    fun showConfirmation() {
        dialogProvider.createConfirmDialog("Confirm") { /* action */ }.show()
    }
}

val appModule = module {
    single { Database() }

    scope(named("session")) {
        scoped { UserSession() }
    }

    scope(named("shopping")) {
        scoped { ShoppingCart(get()) }
    }
}

// Create and link scopes
val sessionScope = getKoin().createScope("user_session", named("session"))
val shoppingScope = getKoin().createScope("cart", named("shopping"))
shoppingScope.linkTo(sessionScope)

// Shopping cart can access UserSession from linked scope
val cart = shoppingScope.get<ShoppingCart>()

@Singleton
class FeatureRegistry(private val config: AppConfig) : KoinComponent {

    fun getEnabledFeatures(): List<Feature> {
        return config.enabledFeatures.mapNotNull { name ->
            getKoin().getOrNull<Feature>(named(name))
        }
    }
}

// ⚠️ Lazy hides the cycle but infinite loop at runtime
class ServiceA : KoinComponent {
    private val serviceB: ServiceB by inject()
    fun doA() { serviceB.doB() }
}

class ServiceB : KoinComponent {
    private val serviceA: ServiceA by inject()
    fun doB() { serviceA.doA() }  // Infinite loop!
}

// ❌ Bad - ViewModel in activity scope loses state on rotation
module {
    activityScope {
        scoped { UserViewModel(get()) }
    }
}

// ✅ Good - Use viewModel for proper lifecycle
module {
    viewModel { UserViewModel(get()) }
}

// ❌ Memory leak - Activity reference in singleton
@Singleton
class ImageLoader(private val activity: Activity)

// ✅ Use Application context
@Singleton
class ImageLoader(private val context: Context)  // Application context via androidContext()