private val uimodeManager =
        appContext.getSystemService(UI_MODE_SERVICE) as UiModeManager

mMainView.findViewById<Button>(R.id.btn_night).setOnClickListener {
    uimodeManager.nightMode = UiModeManager.MODE_NIGHT_YES
}

mMainView.findViewById<Button>(R.id.btn_light).setOnClickListener {
    uimodeManager.nightMode = UiModeManager.MODE_NIGHT_NO
}

    /**
     * 切换语言
     * @param language 语言
     */
    fun changeLanguageSettings(language: Locale) {
        try {
            val activityManagerNative = Class.forName("android.app.ActivityManager")
            val am = activityManagerNative.getMethod("getService").invoke(activityManagerNative)
            val config = am?.javaClass?.getMethod("getConfiguration")
                ?.invoke(am) as Configuration
            config.setLocale(language)
            config.javaClass.getDeclaredField("userSetLocale").setBoolean(config, true)
            am.javaClass.getMethod("updatePersistentConfiguration", config.javaClass)
                .invoke(am, config)
            BackupManager.dataChanged("com.android.providers.settings")
        } catch (e: Exception) {
            e.message?.let { error(it) }
        }
    }

mMainView.findViewById<Button>(R.id.btn_chinese).setOnClickListener {
    changeLanguageSettings(Locale.SIMPLIFIED_CHINESE)
}

mMainView.findViewById<Button>(R.id.btn_english).setOnClickListener {
    changeLanguageSettings(Locale.ENGLISH)
}

// LanguageService.kt
    private val mWmParams = WindowManager.LayoutParams().apply {
        //设置可以显示在状态栏上
        flags = (WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                or WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
                or WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
                or WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
                or WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH
                or WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL)
        type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
        //设置窗口长宽数据
        width = WindowManager.LayoutParams.WRAP_CONTENT
        height = WindowManager.LayoutParams.WRAP_CONTENT
        gravity = Gravity.CENTER_HORIZONTAL or Gravity.TOP
        x = 600
        y = 0
        format = PixelFormat.TRANSLUCENT
    }

    private val mWindowManager = appContext.getSystemService(WINDOW_SERVICE) as WindowManager

    private lateinit var mMainView: View

    fun showWindow(){
        mMainView = LayoutInflater.from(appContext).inflate(R.layout.layout_language_change, null, false)

        mWindowManager.addView(mMainView, mWmParams)
    }

    override fun onConfigurationChanged(newConfig: Configuration) {
        super.onConfigurationChanged(newConfig)
        LogUtils.i(TAG, "onConfigurationChanged")
        mMainView.findViewById<Button>(R.id.btn_chinese).text = getString(R.string.chinese)
        mMainView.findViewById<Button>(R.id.btn_english).text = getString(R.string.english)
    }

    override fun onConfigurationChanged(newConfig: Configuration) {
        super.onConfigurationChanged(newConfig)
        LogUtils.i(TAG, "onConfigurationChanged")
        mMainView.setBackgroundColor(
            ResourcesCompat.getColor(this.resources, R.color.theme_test, null)
        )
        mMainView.findViewById<ImageView>(R.id.iv_close)
            .setImageResource(R.drawable.ic_close_dialog)
    }

    override fun onConfigurationChanged(newConfig: Configuration) {
        super.onConfigurationChanged(newConfig)
        LogUtils.i(TAG, "onConfigurationChanged")
        mWindowManager.removeView(mMainView)
        mMainView = null
        mMainView =
            LayoutInflater.from(appContext)
                .inflate(R.layout.layout_language_change, null, false)
        initViews()
        mWindowManager.addView(mMainView, mWmParams)
    }

CoroutineScope(Dispatchers.IO).launch {
    val tesetData = Settings.Global.getInt(this@MainActivity.contentResolver, "audio_test_result")
    Log.i(TAG, "getGlobalData : $tesetData")
}

private val observer = object : ContentObserver(null) {
    override fun onChange(selfChange: Boolean) {
        val stringData =
            Settings.System.getString(
                appContext.contentResolver,
                ACTION_MUTUAL_NOTIFY
            )
        debugLog("onChange: data:$stringData")
    }
}

fun registerSystemSettingOberver() {
    appContext.contentResolver.registerContentObserver(
        Settings.System.getUriFor(ACTION_MUTUAL_NOTIFY),
        true,
        observer
    )
}

fun unRegisterSystemSettingOberver() {
    appContext.contentResolver.unregisterContentObserver(
        observer
    )
}

CoroutineScope(Dispatchers.IO).launch {
    Settings.Global.putInt(this@MainActivity.contentResolver, "audio_test_result", 2415)
}

fun changeSystemSettingData() {
    val tsStringData = "test string"
    Settings.System.putString(
        appContext.contentResolver,
        ACTION_MUTUAL_NOTIFY,
        tsStringData
    )
}

private val observer = object : ContentObserver(null) {
    override fun onChange(selfChange: Boolean) {
        val stringData =
            Settings.System.getString(
                appContext.contentResolver,
                ACTION_MUTUAL_NOTIFY
            )
        debugLog("onChange: data:$stringData")
    }
}

fun registerSystemSettingOberver() {
    appContext.contentResolver.registerContentObserver(
        Settings.System.getUriFor(ACTION_MUTUAL_NOTIFY),
        true,
        observer
    )
}

fun unRegisterSystemSettingOberver() {
    appContext.contentResolver.unregisterContentObserver(
        observer
    )
}

fun changeSystemSettingData() {
    val tsStringData = "same string"
    Settings.System.putString(
        appContext.contentResolver,
        ACTION_MUTUAL_NOTIFY,
        tsStringData
    )
    appContext.contentResolver.notifyChange(
        Settings.System.getUriFor(ACTION_MUTUAL_NOTIFY), null
    )
}

private val observer = object : ContentObserver(null) {
    override fun onChange(selfChange: Boolean) {
        val stringData =
            Settings.System.getString(
                appContext.contentResolver,
                ACTION_MUTUAL_NOTIFY
            )
        debugLog("onChange: data:$stringData selfchange:$selfChange")
    }

    override fun deliverSelfNotifications() = true
}

/**
 * 存储图标png到app内部目录
 */
private fun saveDrawableToFile(context: Context, drawable: Drawable, fileName: String) {
    val bitmap = drawable.toBitmap()
    val file = File(context.getExternalFilesDir(null), "$fileName.png")
    val fos = FileOutputStream(file)
    infoLog("path:${file.absolutePath}")
    bitmap.compress(Bitmap.CompressFormat.PNG, 100, fos)
    fos.flush()
    fos.close()
}

/**
 * 保存一个bitmap到本地sdcard的Pictures目录
 */
fun saveImageToGallery(
    context: Context,
    bitmap: Bitmap,
    filename: String = "FilmSimulation.jpg",
) {
    val values = ContentValues().apply {
        put(MediaStore.MediaColumns.DISPLAY_NAME, filename)
        put(MediaStore.Images.Media.MIME_TYPE, "image/jpeg") // 文件类型
        put(MediaStore.MediaColumns.RELATIVE_PATH, Environment.DIRECTORY_PICTURES)
    }
    runCatching {
        context.contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, values)
            ?.let {
                context.contentResolver.openOutputStream(it)?.apply {
                    bitmap.compress(Bitmap.CompressFormat.JPEG, 100, this)
                    flush()
                    close()
                }
                context.contentResolver.notifyChange(it, null)
            }
    }.onFailure {
        Log.e(TAG, "save image error:${it.message}")
    }
}

val room_version = "2.6.1"
implementation("androidx.room:room-runtime:$room_version")

/**
  * KSP (Kotlin Symbol Processing)是以 Kotlin 优先的 kapt 替代方案。
  * KSP 可直接分析 Kotlin 代码，使得速度提高多达 2 倍。
  * 此外，它还可以更好地了解 Kotlin 的语言结构。
  */
ksp("androidx.room:room-compiler:$room_version")

plugins {
    id("com.google.devtools.ksp") version "2.0.21-1.0.27" apply false
}

plugins {
    id("com.google.devtools.ksp")
}

@Entity
data class Camera (
    @PrimaryKey
    val cameraId: Int,
    @ColumnInfo(name = "brand_name") val brandName: String,
    @ColumnInfo(name = "camera_model") val cameraModel: String,
)

@Dao
interface CameraDao {
    @Query("SELECT * FROM camera")
    fun getAll(): List<Camera>

    @Query("SELECT * FROM camera WHERE cameraId IN (:cameraIds)")
    fun loadAllByIds(cameraIds: IntArray): List<Camera>

    @Query("SELECT * FROM camera WHERE brand_name LIKE :first AND " + "camera_model LIKE :last LIMIT 1")
    fun findByName(first: String, last: String): Camera
    
    @Insert
    fun insertAll(vararg cameras: Camera)

    @Delete
    fun delete(camera: Camera)
}

@Database(entities = [Camera::class], version = 1)
abstract class CameraDatabase : RoomDatabase() {
    abstract fun cameraDao(): CameraDao
}

CoroutineScope(Dispatchers.IO).launch {
    val db = Room.databaseBuilder(appContext, CameraDatabase::class.java, "camera_database").build()
    val camereDao = db.cameraDao()
    camereDao.insertAll(
        Camera(1000, "Canon", "EOS R6 II"),
        Camera(1001, "Sony", "A9 II"),
        Camera(1002, "LUMIX", "S5M2K")
    )
    delay(3000L)
    Log.i(TAG, "room database test: ${camereDao.getAll()}")
}

/**
 * SharedPreference存储工具类
 * 不会丢数据
 * 但是加回调不方便
 */
object SPHelper {

    private lateinit var share: SharedPreferences

    private lateinit var editor: SharedPreferences.Editor

    private const val SHARED_NAME = "SPHelper"

    fun init(context: Context) {
        share = context.getSharedPreferences(SHARED_NAME, Context.MODE_PRIVATE);
        editor = share.edit();
    }

    // 采用同步保存，获取保存成功与失败的result
    fun putString(key: String, value: String?): Boolean {
        infoLog("putString key: $key, value: $value")
        editor.putString(key, value)
        return editor.commit()
    }

    fun getString(key: String): String? {
        val value = share.getString(key, null)
        infoLog("getString key: $key, value: $value")
        return value
    }

    fun getString(key: String, defaultValue: String): String {
        val value = share.getString(key, null)
        infoLog("getString key: $key, value: $value, defaultValue: $defaultValue")
        return value ?: defaultValue
    }

    fun putLong(key: String?, value: Long): Boolean {
        infoLog("putLong key: $key, value: $value")
        editor.putLong(key, value)
        return editor.commit()
    }

    fun putFloat(key: String?, value: Float): Boolean {
        infoLog("putFloat key: $key, value: $value")
        editor.putFloat(key, value)
        return editor.commit()
    }

    fun putInt(key: String?, value: Int): Boolean {
        infoLog("putInt key: $key, value: $value")
        editor.putInt(key, value)
        return editor.commit()
    }

    fun putBoolean(key: String?, value: Boolean): Boolean {
        infoLog("putBoolean key: $key, value: $value")
        editor.putBoolean(key, value)
        return editor.commit()
    }

    fun getLong(key: String?): Long {
        val value = share.getLong(key, -1)
        infoLog("getLong key: $key, value: $value")
        return value
    }

    fun getInt(key: String?, defaultValue: Int): Int {
        val value = share.getInt(key, defaultValue)
        infoLog("getInt key: $key, value: $value")
        return value
    }

    fun getFloat(key: String?, defaultValue: Float): Float {
        val value = share.getFloat(key, defaultValue)
        infoLog("getFloat key: $key, value: $value")
        return value
    }

    fun getBoolean(key: String?, defaultValue: Boolean): Boolean {
        val value = share.getBoolean(key, defaultValue)
        infoLog("getBoolean key: $key, value: $value")
        return value
    }

    fun removeSharedPreferenceByKey(key: String?): Boolean {
        infoLog("removeSharedPreferenceByKey key: $key")
        editor.remove(key)
        return editor.commit()
    }
}

/**
 * 最适合同步写入小数据
 * 支持多进程，高频写入性能好
 * 但有可能丢数据
 */
object MMKVHelper {

    private lateinit var mmkv: MMKV

    fun init(context: Context,databaseId: String, isMultiProcess: Boolean) {
        val rootDir = MMKV.initialize(context)
        infoLog("MMKV rootDir: $rootDir")
        mmkv =
            if (isMultiProcess) MMKV.mmkvWithID(databaseId, MMKV.MULTI_PROCESS_MODE)
            else MMKV.mmkvWithID(databaseId)
    }

    fun putString(key: String, value: String?) {
        infoLog("putString key: $key, value: $value")
        mmkv.encode(key, value)
    }

    fun getString(key: String): String? {
        val value = mmkv.decodeString(key)
        infoLog("getString key: $key, value: $value")
        return value
    }

    fun getString(key: String, defaultValue: String): String {
        val value = mmkv.decodeString(key)
        infoLog("getString key: $key, value: $value, defaultValue: $defaultValue")
        return value ?: defaultValue
    }

    fun putLong(key: String?, value: Long) {
        infoLog("putLong key: $key, value: $value")
        mmkv.encode(key, value)
    }

    fun putFloat(key: String?, value: Float) {
        infoLog("putFloat key: $key, value: $value")
        mmkv.encode(key, value)
    }

    fun putInt(key: String?, value: Int) {
        infoLog("putInt key: $key, value: $value")
        mmkv.encode(key, value)
    }

    fun putBoolean(key: String?, value: Boolean) {
        infoLog("putBoolean key: $key, value: $value")
        mmkv.encode(key, value)
    }

    fun getLong(key: String?): Long {
        val value = mmkv.decodeLong(key, -1)
        infoLog("getLong key: $key, value: $value")
        return value
    }

    fun getInt(key: String?, defaultValue: Int): Int {
        val value = mmkv.decodeInt(key, defaultValue)
        infoLog("getInt key: $key, value: $value")
        return value
    }

    fun getFloat(key: String?, defaultValue: Float): Float {
        val value = mmkv.decodeFloat(key, defaultValue)
        infoLog("getFloat key: $key, value: $value")
        return value
    }

    fun getBoolean(key: String?, defaultValue: Boolean): Boolean {
        val value = mmkv.decodeBool(key, defaultValue)
        infoLog("getBoolean key: $key, value: $value")
        return value
    }
}

/**
 * 谷歌推荐的最新存储方式
 * 协程实现，可以方便地获取存储的结果回调
 */
object DataStoreHelper {
    // 定义一个 DataStore 实例
    val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "data_store_settings")

    private lateinit var outDataStore: DataStore<Preferences>

    /**
     * 初始化，使get和set不受Context域限制
     */
    fun init(context: Context) {
        outDataStore = context.dataStore
    }

    // 定义一个 suspend 函数，用于从 DataStore 中读取数据
    suspend fun <T> getData(key: Preferences.Key<T>, defaultValue: T): T {
        return (outDataStore.data.first()[key] ?: defaultValue)
    }

    // 定义一个 suspend 函数，用于将数据保存到 DataStore 中
    suspend fun <T> saveData(key: Preferences.Key<T>, value: T) {
        outDataStore.edit { preferences ->
            preferences[key] = value
        }
    }
}

CoroutineScope(Dispatchers.IO).launch {
    val INT_PREF_KEY = intPreferencesKey("IntKey")
    val FLOAT_PERF_KEY = floatPreferencesKey("FloatKey")
    val STRING_PREF_KEY = stringPreferencesKey("SteringKey")

    DataStoreHelper.saveData(INT_PREF_KEY, 45)
    DataStoreHelper.saveData(FLOAT_PERF_KEY, 45.0f)
    DataStoreHelper.saveData(STRING_PREF_KEY, "45")
    delay(1000L)
    // 拿取刚刚存的值
    Log.i(TAG, "intData: ${DataStoreHelper.getData(INT_PREF_KEY, -1)}")
    Log.i(TAG, "floatData: ${DataStoreHelper.getData(FLOAT_PERF_KEY, -1f)}")
    Log.i(TAG, "stringData: ${DataStoreHelper.getData(STRING_PREF_KEY, "default")}")
}

class MyFragment : Fragment() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Fragment 初始化逻辑
    }

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        // 膨胀 Fragment 的布局
        return inflater.inflate(R.layout.fragment_my, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // 初始化 View 组件
        // val myTextView = view.findViewById<TextView>(R.id.myTextView)
        // myTextView.text = "Hello from Fragment!"
    }
}

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 检查 Fragment 是否已经添加，避免重复添加（例如在配置变化后）
        if (savedInstanceState == null) {
            val fragmentManager: FragmentManager = supportFragmentManager
            val fragmentTransaction: FragmentTransaction = fragmentManager.beginTransaction()

            val myFragment = MyFragment()
            // 将 Fragment 添加到一个容器视图中 (例如一个 FrameLayout)
            fragmentTransaction.add(R.id.fragment_container, myFragment)
            // fragmentTransaction.addToBackStack(null) // 可选：添加到回退栈
            fragmentTransaction.commit()
        }
    }
}

// 启动一个显式 Activity (明确指定要启动的 Activity 类)
val intent = Intent(this, SecondActivity::class.java)
startActivity(intent)

// 启动 Activity 并传递数据
val dataIntent = Intent(this, DetailActivity::class.java).apply {
    putExtra("item_id", 123)
    putExtra("item_name", "Awesome Product")
}
startActivity(dataIntent)

// 在 DetailActivity 中获取 Intent 的数据
// override fun onCreate(savedInstanceState: Bundle?) {
//     super.onCreate(savedInstanceState)
//     val itemId = intent.getIntExtra("item_id", -1)
//     val itemName = intent.getStringExtra("item_name")
// }

// 4. 启动 Activity 并获取返回结果 (旧方法，现在推荐 Activity Result API)
// override fun onCreate(...) {
//     val startForResult = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
//         if (result.resultCode == Activity.RESULT_OK) {
//             val data: Intent? = result.data
//             val message = data?.getStringExtra("return_message")
//             // 处理返回的数据
//         }
//     }
//
//     // 在某个点击事件中启动
//     myButton.setOnClickListener {
//         val intent = Intent(this, ResultActivity::class.java)
//         startForResult.launch(intent)
//     }
// }

fun getConnectedScreenIds(context: Context): List<Int> {
    val displayManager = context.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager
    val displays = displayManager.displays
    val screenIds = mutableListOf<Int>()
    for (display in displays) {
        screenIds.add(display.displayId)
        display.name
        infoLog("displayId = ${display.displayId}, name = ${display.name}")
    }
    return screenIds
}

class MyPresentation(context: Context, display: Display) : Presentation(context, display) {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.presentation)
    }
}

val displayManager =
    this@MainActivity.getSystemService(DISPLAY_SERVICE) as DisplayManager
val display = displayManager.getDisplay(5)
val presentation = MyPresentation(this@MainActivity, display)
presentation.setCancelable(false)
presentation.show()

val uri = Uri.parse("content://com.example.app.provider/table1")

/** uri from table_name 指定查询某个应用程序下的某一张表
projection select column1, column2 指定查询的列名
selection where column = value 指定where的约束条件
selectionArgs - 为where中的占位符提供具体的值
sortOrder order by column1, column2 指定查询结果的排序方式
*/
val cursor = contentResolver.query(
 uri,
 projection,
 selection,
 selectionArgs,
 sortOrder) 

while (cursor.moveToNext()) {
 val column1 = cursor.getString(cursor.getColumnIndex("column1"))
 val column2 = cursor.getInt(cursor.getColumnIndex("column2"))
}
cursor.close() 

// 更新数据
val values = ContentValues()
values.put("column1", "value1")
values.put("column2", 1)
val rows = contentResolver.update(
 uri,
 values,
 selection, 
)

// 删除数据
val rows = contentResolver.delete(
 uri,
 selection,
 selectionArgs 
)
// 插入数据
val values = ContentValues()
values.put("column1", "value1")
values.put("column2", 1)
val uri = contentResolver.insert(
 uri,
 values
)

private fun readContacts() {
    // 查询联系人数据
    contentResolver.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
        null, null, null, null)?.apply {
        while (moveToNext()) {
            // 获取联系人姓名
            val displayName = getString(getColumnIndex(
                ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME))
            // 获取联系人手机号
            val number = getString(getColumnIndex(
                ContactsContract.CommonDataKinds.Phone.NUMBER))
            contactsList.add("$displayName\n$number")
        }
        adapter.notifyDataSetChanged()
        close()
    }
} 

public class MainActivity : AppCompatActivity() {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main) 
      if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS)
            != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this,
                arrayOf(Manifest.permission.READ_CONTACTS), 1)
        } else {
            readContacts()
        }
  }
}

class DatabaseProvider : ContentProvider() {
    private val bookDir = 0
    private val bookItem = 1
    private val categoryDir = 2
    private val categoryItem = 3
    private val authority = "com.example.databasetest.provider"
    private var dbHelper: MyDatabaseHelper? = null
    private val uriMatcher by lazy {
        val matcher = UriMatcher(UriMatcher.NO_MATCH)
        matcher.addURI(authority, "book", bookDir)
        matcher.addURI(authority, "book/#", bookItem)
        matcher.addURI(authority, "category", categoryDir)
        matcher.addURI(authority, "category/#", categoryItem)
        matcher
    }

    override fun onCreate() = context?.let {
        dbHelper = MyDatabaseHelper(it, "BookStore.db", 2)
        true
    } ?: false

    override fun query(
        uri: Uri, projection: Array<String>?, selection: String?,
        selectionArgs: Array<String>?, sortOrder: String?
    ) = dbHelper?.let {
        // 查询数据
        val db = it.readableDatabase
        val cursor = when (uriMatcher.match(uri)) {
            bookDir -> db.query(
                "Book", projection, selection, selectionArgs,
                null, null, sortOrder
            )

            bookItem -> {
                val bookId = uri.pathSegments[1]
                db.query(
                    "Book", projection, "id = ?", arrayOf(bookId), null, null,
                    sortOrder
                )
            }

            categoryDir -> db.query(
                "Category", projection, selection, selectionArgs,
                null, null, sortOrder
            )

            categoryItem -> {
                val categoryId = uri.pathSegments[1]
                db.query(
                    "Category", projection, "id = ?", arrayOf(categoryId),
                    null, null, sortOrder
                )
            }

            else -> null
        }
        cursor
    }

    override fun insert(uri: Uri, values: ContentValues?) = dbHelper?.let {
        // 添加数据
        val db = it.writableDatabase
        val uriReturn = when (uriMatcher.match(uri)) {
            bookDir, bookItem -> {
                val newBookId = db.insert("Book", null, values)
                Uri.parse("content://$authority/book/$newBookId")
            }

            categoryDir, categoryItem -> {
                val newCategoryId = db.insert("Category", null, values)
                Uri.parse("content://$authority/category/$newCategoryId")
            }

            else -> null
        }
        uriReturn
    }

    override fun update(
        uri: Uri, values: ContentValues?, selection: String?,
        selectionArgs: Array<String>?
    ) = dbHelper?.let {
        // 更新数据
        val db = it.writableDatabase
        val updatedRows = when (uriMatcher.match(uri)) {
            bookDir -> db.update("Book", values, selection, selectionArgs)
            bookItem -> {
                val bookId = uri.pathSegments[1]
                db.update("Book", values, "id = ?", arrayOf(bookId))
            }

            categoryDir -> db.update("Category", values, selection, selectionArgs)
            categoryItem -> {
                val categoryId = uri.pathSegments[1]
                db.update("Category", values, "id = ?", arrayOf(categoryId))
            }

            else -> 0
        }
        updatedRows
    } ?: 0

    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<String>?) =
        dbHelper?.let {
            // 删除数据
            val db = it.writableDatabase
            val deletedRows = when (uriMatcher.match(uri)) {
                bookDir -> db.delete("Book", selection, selectionArgs)
                bookItem -> {
                    val bookId = uri.pathSegments[1]
                    db.delete("Book", "id = ?", arrayOf(bookId))
                }

                categoryDir -> db.delete("Category", selection, selectionArgs)
                categoryItem -> {
                    val categoryId = uri.pathSegments[1]
                    db.delete("Category", "id = ?", arrayOf(categoryId))
                }

                else -> 0
            }
            deletedRows
        } ?: 0

    override fun getType(uri: Uri) = when (uriMatcher.match(uri)) {
        bookDir -> "vnd.android.cursor.dir/vnd.com.example.databasetest.provider.book"
        bookItem -> "vnd.android.cursor.item/vnd.com.example.databasetest.provider.book"
        categoryDir -> "vnd.android.cursor.dir/vnd.com.example.databasetest.provider.category"
            categoryItem -> "vnd.android.cursor.item/vnd.com.example.databasetest.provider.category"
        else -> null
    }
} 

class MainActivity : AppCompatActivity() {
    var bookId: String? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        addData.setOnClickListener {
            // 添加数据
            val uri = Uri.parse("content://com.example.databasetest.provider/book")
            val values = contentValuesOf("name" to "A Clash of Kings",
                "author" to "George Martin", "pages" to 1040, "price" to 22.85)
            val newUri = contentResolver.insert(uri, values)
            bookId = newUri?.pathSegments?.get(1)
        }
        queryData.setOnClickListener {
            // 查询数据
            val uri = Uri.parse("content://com.example.databasetest.provider/book")
            contentResolver.query(uri, null, null, null, null)?.apply {
                while (moveToNext()) {
                    val name = getString(getColumnIndex("name"))
                    val author = getString(getColumnIndex("author"))
                    val pages = getInt(getColumnIndex("pages"))
                    val price = getDouble(getColumnIndex("price"))
                    Log.d("MainActivity", "book name is $name")
                    Log.d("MainActivity", "book author is $author")
                    Log.d("MainActivity", "book pages is $pages")
                    Log.d("MainActivity", "book price is $price")
                }
                close()
            }
        }
        updateData.setOnClickListener {
            // 更新数据
            bookId?.let {
                val uri = Uri.parse("content://com.example.databasetest.provider/
                        book/$it")
                val values = contentValuesOf("name" to "A Storm of Swords",
                    "pages" to 1216, "price" to 24.05)
                contentResolver.update(uri, values, null, null)
            }
        }
        deleteData.setOnClickListener {
            // 删除数据
            bookId?.let {
                val uri = Uri.parse("content://com.example.databasetest.provider/
                        book/$it")
                contentResolver.delete(uri, null, null)
            }
        }
    }
}

class MyBroadcastReceiver : BroadcastReceiver() {
  override fun onReceive(context: Context, intent: Intent) {
    Toast.makeText(context, "received in MyBroadcastReceiver",Toast.LENGTH_SHORT).show()
  }
} 

class MainActivity : AppCompatActivity() {
    ...
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        button.setOnClickListener {
            val intent = Intent("com.example.broadcasttest.MY_BROADCAST")
            intent.setPackage(packageName)
            sendBroadcast(intent)
        }
        ...
    }
    ...
} 

class MyBroadcastReceiver : BroadcastReceiver() {
  override fun onReceive(context: Context, intent: Intent) {
    Toast.makeText(context, "received in MyBroadcastReceiver",Toast.LENGTH_SHORT).show()
  } 
}

class MainActivity : AppCompatActivity() {
   ...
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        button.setOnClickListener {
            val intent = Intent("com.example.broadcasttest.MY_BROADCAST")
            intent.setPackage(packageName)
            sendOrderedBroadcast(intent, null)
        }  
    } 
}