Compose MultiplatformとSwiftUIで作るハイブリッドモバイルアプリ（Part 2）：実装ガイド

my-cmp-app/
├── composeApp/
│   ├── src/
│   │   ├── commonMain/           // CMP Shared code
│   │   ├── androidMain/          // Android-specific
│   │   └── iosMain/              // iOS-specific
├── iosApp/
│   ├── Views/                    // SwiftUI views
│   ├── Screens/                  // Native screens
│   └── ComposeViewContainer.swift
└── shared/                       // KMP domain layer
    ├── viewmodels/
    └── models/

// Routes.kt - Navigation routes defined in shared code
object Routes {
    const val LOGIN = "login"
    const val SCREEN_A = "screen_a"
    const val SCREEN_B = "screen_b"
    const val SCREEN_C = "screen_c"
    const val SCREEN_D = "screen_d"
}

// ComposeViewController.kt
fun createComposeViewController(
    initialRoute: String,
    onCallback: (Boolean) -> Unit = {}
): UIViewController {
    return ComposeUIViewController {
        MyAppTheme {
            when (initialRoute) {
                "login" -> LoginNavigation(onLoginSuccess = onCallback)
                "screen_a" -> ScreenANavigation()
                "screen_b" -> ScreenBNavigation(iosCallback = onCallback)
                "screen_c" -> ScreenCNavigation()
                "screen_d" -> ScreenDNavigation()
                else -> FallbackNavigation() // default fallback
            }
        }
    }
}

// ComposeViewContainer.swift
struct ComposeViewContainer: UIViewControllerRepresentable {
    let initialRoute: String
    let onCallback: (Bool) -> Void

    func makeUIViewController(context: Context) -> UIViewController {
        // Wrap the Swift callback into the KotlinBoolean signature
        let kotlinCallback: (KotlinBoolean) -> Void = { kotlinBool in
            onCallback(kotlinBool.boolValue)
        }
        // Create the Compose UIViewController, passing the wrapped callback
        return ComposeViewControllerKt.createComposeViewController(
            initialRoute: initialRoute,
            onCallback: kotlinCallback
        )
    }

    func updateUIViewController(_ uiViewController: UIViewController, context: Context) {
        // No dynamic updates needed here
    }
}

// MainScreen.swift
struct MainScreen: View {
    var body: some View {
        TabView {
            // Tab 1~3: CMP screen
            NavigationView {
                ComposeViewContainer(initialRoute: "screen_a", onCallback: { _ in })
            }.tabItem {
                Label("Application", systemImage: "doc.plaintext")
            }
            ...
            // Tab 4: SwiftUI screen
            NavigationView {
                SettingsScreen()
            }.tabItem {
                Label("Settings", systemImage: "gearshape.fill")
            }
        }
    }
}

// commonMain/di/AppModule.kt
val appModule = module {
    single { NetworkClient() }
    single { AuthRepository(get()) }
    viewModel { HomeViewModel(get()) }
    viewModel { ProductViewModel(get()) }
    factory<Validator> {
        ValidatorImpl(get(), get())
    }
}

// iosMain/di/PlatformModule.ios.kt
val iosModule = module {
    single<HttpClientEngine> { Darwin.create {} }
    single<DataStore<Preferences>> { createDataStore() }
    single { IOSLocationService() as LocationService }
    single { AppStoreConnectTracker() as AnalyticsTracker }
}

// androidMain/di/PlatformModule.android.kt
val androidModule = module {
    single<HttpClientEngine> { OkHttp.create {} }
    single<DataStore<Preferences>> { createDataStore(androidContext()) }
    single { AndroidLocationService() as LocationService }
    single { FirebaseAnalyticsTracker() as AnalyticsTracker }
}

// commonMain/di/KoinSetup.kt
fun initKoin(platformModule: Module) = startKoin {
    modules(appModule, networkModule, platformModule, ...)
}

// Android Application class
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        initKoin(androidModule)
    }
}

// iOS AppDelegate
func application(_ application: UIApplication, didFinishLaunchingWithOptions...) {
    KoinKt.doInitKoin(platformModule: IOSPlatformModuleKt.iosModule)
    return true
}

// Feature module definition
val featureModule = module {
    viewModel { FeatureViewModel(get(), get()) }
    factory { FeatureValidator() }
    single { FeatureRepository(get()) }
}

// Register dynamically after the Koin's initialization
loadKoinModules(featureModule)