buildscript {
    ext.kotlin_version = '1.5.31'
    ext.hilt_version = '2.40'
    repositories {
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:7.0.3'
        //kotlin編譯插件
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
        //hilt編譯插件
        classpath "com.google.dagger:hilt-android-gradle-plugin:$hilt_version"
    }
}

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'kotlin-parcelize'
    id 'kotlin-kapt'
    id 'dagger.hilt.android.plugin'
}
android {
    compileSdkVersion 31
    buildToolsVersion "30.0.3"
    defaultConfig {
        applicationId "com.example.android.hilt"
        minSdkVersion 16
        targetSdkVersion 31
        versionCode 1
        versionName "1.0"
        javaCompileOptions {
            annotationProcessorOptions {
                arguments["room.incremental"] = "true"
            }
        }
    }
    compileOptions {
        sourceCompatibility 1.8
        targetCompatibility 1.8
    }
}
dependencies {
    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
    implementation 'androidx.appcompat:appcompat:1.3.1'
    implementation 'androidx.core:core-ktx:1.7.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.1'
    implementation 'androidx.recyclerview:recyclerview:1.2.1'
    // Room
    implementation "androidx.room:room-runtime:2.3.0"
    kapt "androidx.room:room-compiler:2.3.0"
    // Hilt dependencies
    implementation "com.google.dagger:hilt-android:$hilt_version"
    kapt "com.google.dagger:hilt-android-compiler:$hilt_version"
}

@HiltAndroidApp 
class LogApplication : Application()

@AndroidEntryPoint 
class LogsFragment : Fragment() { .... }

@AndroidEntryPoint
class LogsFragment : Fragment() {
    @Inject lateinit var logger: LoggerLocalDataSource
    @Inject lateinit var dateFormatter: DateFormatter
    ...
}

/**
 * 通過構(gòu)造器創(chuàng)建依賴
 */
class DateFormatter @Inject constructor() {
    @SuppressLint("SimpleDateFormat")
    private val formatter = SimpleDateFormat("d MMM yyyy HH:mm:ss")
    fun formatDate(timestamp: Long): String {
        return formatter.format(Date(timestamp))
    }
}

@Singleton
class LoggerLocalDataSource @Inject constructor(private val logDao: LogDao) {
    ...
}

@InstallIn(SingletonComponent::class)
@Module
object DatabaseModule {
//這個可以是個class，但是在 Kotlin 中，只包含 @Provides 函數(shù)的模塊可以是 object 類。
//這樣，提供程序即會得到優(yōu)化，并幾乎可以內(nèi)聯(lián)在生成的代碼中。
    /**
     * 用 @Provides 提供實(shí)例。我們可以在 Hilt 模塊中用 @Provides 注釋函數(shù)，
     * 以告訴 Hilt 如何提供無法注入構(gòu)造函數(shù)的 類型。
     */
    @Provides
    fun provideLogDao(database: AppDatabase): LogDao {
//
        return database.logDao()
        //Hilt 可從上述代碼中得知，在提供 LogDao 的實(shí)例時需要執(zhí)行 database.logDao()。
        //由于我們擁有 AppDatabase 作為傳遞依賴項，因此我們還需要告訴 Hilt 如何提供這種類型的實(shí)例。
    }
    //因為我們一直希望 Hilt 提供相同的數(shù)據(jù)庫實(shí)例，所以我們用 @Singleton 注釋 @Provides provideDatabase 方法。
    @Provides
    @Singleton
    fun provideDatabase(@ApplicationContext context: Context):AppDatabase{
        return Room.databaseBuilder(
            context,
            AppDatabase::class.java,
            "logging.db"
        ).build()
    }
}

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject
    lateinit var navigator: AppNavigator
    ....
}

//我們的新導(dǎo)航信息（即 AppNavigator）需要特定于 Activity 的信息
//（因為 AppNavigatorImpl 擁有 Activity 作為依賴項）。
// 因此，我們必須將其安裝在 Activity 容器中，而不是安裝在 Application 容器中，因為這是有關(guān) Activity 的信息所在。
@InstallIn(ActivityComponent::class)
@Module
abstract class NavigationModule {
    @Binds
    abstract fun provideNavigator(impl: AppNavigatorImpl):AppNavigator
    //參數(shù)為具體的實(shí)現(xiàn)類，所以要告知hilt如何提供實(shí)現(xiàn)類的實(shí)例。下面的實(shí)現(xiàn)類通過構(gòu)造函數(shù)提供實(shí)例
}
//======AppNavigatorImpl.ktx========//
//AppNavigatorImpl 會依賴于 FragmentActivity。由于系統(tǒng)會在 Activity 容器中提供 AppNavigator 實(shí)例
// （亦可用于 Fragment 容器和 View 容器，因為 NavigationModule 會安裝在 ActivityComponent 中），所以 FragmentActivity 目前可用
class AppNavigatorImpl @Inject constructor(private val activity: FragmentActivity) : AppNavigator {
    override fun navigateTo(screen: Screens) {
        val fragment = when (screen) {
            Screens.BUTTONS -> ButtonsFragment()
            Screens.LOGS -> LogsFragment()
        }
        activity.supportFragmentManager.beginTransaction()
            .replace(R.id.main_container, fragment)
            .addToBackStack(fragment::class.java.canonicalName)
            .commit()
    }
}

@Qualifier 
annotation class InMemoryLogger 
@Qualifier 
annotation class DatabaseLogger

interface LogDataSource {
    fun addLog(msg: String)
    fun getAllLogs(callback: (List<Log>) -> Unit)
    fun removeLogs()
}

@Singleton
class LoggerLocalDataSource @Inject constructor(private val logDao: LogDao):LogDataSource {
    private val executorService: ExecutorService = Executors.newFixedThreadPool(4)
    private val mainThreadHandler by lazy {
        Handler(Looper.getMainLooper())
    }
    override fun addLog(msg: String) {
        executorService.execute {
            logDao.insertAll(
                Log(
                    msg,
                    System.currentTimeMillis()
                )
            )
        }
    }
    override fun getAllLogs(callback: (List<Log>) -> Unit) {
        executorService.execute {
            val logs = logDao.getAll()
            mainThreadHandler.post { callback(logs) }
        }
    }
    override fun removeLogs() {
        executorService.execute {
            logDao.nukeTable()
        }
    }
}

@ActivityScoped
class LoggerInMemoryDataSource @Inject constructor():LogDataSource {
    private val logs = LinkedList<Log>()
    override fun addLog(msg: String) {
        logs.addFirst(Log(msg, System.currentTimeMillis()))
    }
    override fun getAllLogs(callback: (List<Log>) -> Unit) {
        callback(logs)
    }
    override fun removeLogs() {
        logs.clear()
    }
}

@Module
@InstallIn(SingletonComponent::class)
abstract class LoggingDatabaseModule {
    @DatabaseLogger
    @Binds
    @Singleton
    abstract fun bindDatabaseLogger(impl: LoggerLocalDataSource): LogDataSource
}
@Module
@InstallIn(ActivityComponent::class)
abstract class LoggingInMemoryModule {
    @InMemoryLogger
    @Binds
    @ActivityScoped
    abstract fun bindInMemoryLogger(impl: LoggerInMemoryDataSource): LogDataSource
}

class ButtonsFragment : Fragment() {
    @InMemoryLogger
    @Inject lateinit var logger: LogDataSource
    ...
}