PureFlow 简析：用 Kotlin 跨平台构建 RSS 阅读器

PureFlow/
├── composeApp/          # UI 层 - Compose Multiplatform 应用
├── shared/              # 共享业务逻辑层 (一次编写，逻辑共享)
├── server/              # 服务端 API (Ktor - 目前还未集成)
├── webApp/              # Web 前端 (React/TypeScript - 待完善或探索)
└── iosApp/              # iOS 特异性代码 (主要用于启动和平台特有集成)

// shared/build.gradle.kts
kotlin {
    androidTarget {
        compilations.all { kotlinOptions { jvmTarget = "11" } }
    }
    iosArm64() // iOS ARM64 设备
    iosSimulatorArm64() // iOS 模拟器
    jvm() // Desktop (Windows, macOS, Linux)
    js {
        moduleName = "shared"
        browser() // 浏览器环境
        binaries.library() // 打包成 JS 库
        generateTypeScriptDefinitions() // Web 集成，自动生成 TS 定义
        compilerOptions { target = "es2015" } // 兼容性考虑
    }
}

// composeApp/build.gradle.kts 关键配置
kotlin {
    androidTarget { /* ... */ }
    listOf(iosArm64(), iosSimulatorArm64()).forEach { iosTarget ->
        iosTarget.binaries.framework {
            baseName = "ComposeApp"
            isStatic = true // 静态库便于集成
        }
    }
    jvm() // Desktop 应用
}

// shared/build.gradle.kts
sqldelight {
    databases {
        create("PureFlowDatabase") {
            packageName.set("com.grtsinry43.pureflow.database")
        }
    }
}

-- rssItem 表索引
CREATE INDEX idx_rss_source_url ON rssItem(sourceUrl);
CREATE INDEX idx_rss_created_at ON rssItem(createdAt);

-- subscription 表索引
CREATE INDEX idx_subscription_url ON subscription(url);

-- favorite 表索引
CREATE INDEX idx_favorite_guid ON favorite(guid);
CREATE INDEX idx_favorite_created_at ON favorite(createdAt);

// shared 模块中声明期望
expect object DatabaseModule {
    fun provideDatabaseDriverFactory(): DatabaseDriverFactory
}

// 各平台模块中提供实际实现
// Android: AndroidSqliteDriver
// iOS: NativeSqliteDriver  
// Desktop: SqliteDriver

commonMain.dependencies {
    implementation(compose.runtime)
    implementation(compose.foundation)
    implementation(compose.material3)
    implementation(compose.ui)
    implementation(compose.components.resources)
    implementation(compose.components.uiToolingPreview)
    implementation(compose.materialIconsExtended)
    implementation(libs.androidx.lifecycle.viewmodelCompose)
    implementation(libs.androidx.lifecycle.runtimeCompose)
    implementation(libs.ksoup)  // HTML解析
    implementation(libs.coil.compose)  // 图片加载
    implementation(libs.coil.network.ktor)
    implementation(projects.shared)
}

class FeedParser(
    private val httpClient: HttpClient,
    private val rssParser: RssParser
) {
    suspend fun parseFeed(url: String): List<RssItem> {
        return try {
            // 1. 使用 Ktor 发起 GET 请求，获取 RSS 源的 XML 文本内容
            val xmlContent = httpClient.get(url).bodyAsText()

            // 2. 使用 RssParser 解析 XML 文本
            // 这个库会自动识别是 RSS 还是 Atom 格式
            val channel = rssParser.parse(xmlContent)

            // 3. 将解析后的数据模型映射到我们自己的 RssItem
            val rssItems = channel.items.map { feedItem ->
                RssItem(
                    title = feedItem.title,
                    link = feedItem.link,
                    description = feedItem.description,
                    author = feedItem.author,
                    categories = feedItem.categories,
                    guid = feedItem.guid,
                    pubDate = feedItem.pubDate,
                    imageUrl = feedItem.image,
                    content = feedItem.content
                )
            }
            rssItems
        } catch (e: Exception) {
            emptyList()
        }
    }
}

// 平台特异性实现
androidMain.dependencies {
    implementation(libs.ktor.client.android)
}
iosMain.dependencies {
    implementation(libs.ktor.client.darwin)
}
jvmMain.dependencies {
    implementation(libs.ktor.client.okhttp)
}

class RssRepository(
    databaseDriverFactory: DatabaseDriverFactory,
    private val feedParser: FeedParser
) {
    private val database = PureFlowDatabase(databaseDriverFactory.createDriver())
    private val queries = database.rssDatabaseQueries

    suspend fun fetchAndCacheRssFeed(url: String): Result<List<RssItem>> {
        return try {
            // 1. 从网络获取RSS数据
            val networkItems = feedParser.parseFeed(url)

            // 2. 缓存到本地数据库（使用事务确保数据完整性）
            database.transaction {
                cacheRssItems(networkItems, url)
            }

            Result.success(networkItems)
        } catch (e: Exception) {
            Result.failure(e)
        }
    }

    fun getRssItemsFromCache(url: String): Flow<List<RssItem>> {
        return queries.selectBySourceUrl(url)
            .asFlow()
            .mapToList(Dispatchers.IO)
            .map { dbItems ->
                dbItems.map { dbItem ->
                    // 映射数据库对象到业务模型
                    RssItem(/* ... */)
                }
            }
    }
}

class RssServiceManager private constructor(
    private val databaseDriverFactory: DatabaseDriverFactory,
    private val feedParser: FeedParser
) {
    companion object {
        fun getInstance(
            databaseDriverFactory: DatabaseDriverFactory,
            feedParser: FeedParser
        ): RssServiceManager {
            // 单例模式实现
        }
    }

    val repository: RssRepository by lazy {
        RssRepository(databaseDriverFactory, feedParser)
    }

    // 各种业务服务的懒加载实例
    private val subscriptionService: SubscriptionService by lazy { /* ... */ }
    private val incrementalUpdateService: IncrementalUpdateService by lazy { /* ... */ }
    private val scheduledSyncService: ScheduledSyncService by lazy { /* ... */ }
}

expect object DatabaseModule {
    fun provideDatabaseDriverFactory(): DatabaseDriverFactory
}

expect object NetworkModule {
    fun provideHttpClient(): HttpClient
}

object ServiceModule {
    private var serviceManager: RssServiceManager? = null

    fun provideRssServiceManager(): RssServiceManager {
        return serviceManager ?: run {
            val databaseDriverFactory = DatabaseModule.provideDatabaseDriverFactory()
            val httpClient = NetworkModule.provideHttpClient()
            val rssParser = RssParser()
            val feedParser = FeedParser(httpClient, rssParser)

            val newServiceManager = RssServiceManager.getInstance(
                databaseDriverFactory = databaseDriverFactory,
                feedParser = feedParser
            )
            serviceManager = newServiceManager
            newServiceManager
        }
    }
}

if [[ "$OSTYPE" == "darwin"* ]]; then
    AVAILABLE_FORMATS="dmg"
elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
    AVAILABLE_FORMATS="deb rpm appimage"
elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]]; then
    AVAILABLE_FORMATS="msi exe"
fi

case $FORMAT in
    "dmg")
        ./gradlew packageDmg
        ;;
    "linux")
        ./gradlew packageDeb packageRpm packageAppImage
        ;;
    "windows")
        ./gradlew packageMsi packageExe
        ;;
    "all")
        ./gradlew packageDistributionForCurrentOS
        ;;
esac