class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        setupStrictMode()
    }

    private fun setupStrictMode() {
        if (BuildConfig.DEBUG) {
            StrictMode.setThreadPolicy(
                StrictMode.ThreadPolicy.Builder()
                    .detectDiskReads()
                    .detectDiskWrites()
                    .penaltyLog()
                    .build()
            )

            StrictMode.setVmPolicy(
                StrictMode.VmPolicy.Builder()
                    .detectLeakedSqlLiteObjects() // 檢測(cè)數(shù)據(jù)庫泄露
                    .detectLeakedClosableObjects() // 檢測(cè)未關(guān)閉資源
                    .detectActivityLeaks() // 檢測(cè)Activity泄露
                    .penaltyLog()
                    .penaltyDeath() // 測(cè)試環(huán)境直接崩潰便于定位
                    .build()
            )
        }
    }
}

class TracedDBHelper(
    context: Context,
    name: String,
    factory: SQLiteDatabase.CursorFactory?,
    version: Int
) : SQLiteOpenHelper(context, name, factory, version) {

    companion object {
        private val openCounter = AtomicInteger(0)
        private val openStackTraces = ConcurrentHashMap<Int, String>()

        fun getOpenCount() = openCounter.get()
        
        fun printOpenConnections() {
            if (openCounter.get() > 0) {
                Log.w("DB_TRACKER", "?? 未關(guān)閉的數(shù)據(jù)庫連接: ${openCounter.get()}")
                openStackTraces.values.forEach { 
                    Log.w("DB_TRACKER", "打開堆棧:\n$it") 
                }
            }
        }
    }

    override fun getWritableDatabase(): SQLiteDatabase {
        return trace(super.getWritableDatabase())
    }

    override fun getReadableDatabase(): SQLiteDatabase {
        return trace(super.getReadableDatabase())
    }

    private fun trace(db: SQLiteDatabase): SQLiteDatabase {
        openCounter.incrementAndGet()
        val stack = Throwable().stackTrace
            .drop(1) // 去掉當(dāng)前方法
            .take(10) // 取前10個(gè)堆棧幀
            .joinToString("\n") { "    at ${it.className}.${it.methodName}(${it.fileName}:${it.lineNumber})" }
        
        openStackTraces[db.hashCode()] = stack
        Log.d("DB_TRACKER", "?? 數(shù)據(jù)庫連接打開. 總數(shù): ${openCounter.get()}\n$stack")
        
        return db
    }

    override fun close() {
        super.close()
        openCounter.decrementAndGet()
        Log.d("DB_TRACKER", "?? 數(shù)據(jù)庫連接關(guān)閉. 剩余: ${openCounter.get()}")
    }
}

class MainActivity : AppCompatActivity() {
    private lateinit var dbHelper: TracedDBHelper

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        dbHelper = TracedDBHelper(this, "my_db", null, 1)
        
        // 測(cè)試使用
        val db = dbHelper.writableDatabase
        // 模擬忘記關(guān)閉
    }

    override fun onDestroy() {
        TracedDBHelper.printOpenConnections()
        // 實(shí)際項(xiàng)目中應(yīng)該在這里關(guān)閉數(shù)據(jù)庫
        // dbHelper.close()
        super.onDestroy()
    }
}

// 在Application類中
class DebugApp : Application() {
    override fun onCreate() {
        super.onCreate()
        setupLeakCanary()
    }

    private fun setupLeakCanary() {
        if (BuildConfig.DEBUG) {
            // 自定義配置
            val config = LeakCanary.config.copy(
                dumpHeap = true,
                retainedVisibleThreshold = 3,
                referenceMatchers = listOf(
                    // 特別監(jiān)控SQLiteDatabase
                    IgnoredMatcher(
                        className = "android.database.sqlite.SQLiteDatabase"
                    )
                )
            )
            
            LeakCanary.config = config
        }
    }
}

// 在數(shù)據(jù)庫操作處
fun performDatabaseOperation() {
    val db = dbHelper.writableDatabase
    
    try {
        // 數(shù)據(jù)庫操作
        db.execSQL("CREATE TABLE IF NOT EXISTS Users (id INTEGER PRIMARY KEY, name TEXT)")
    } finally {
        db.close()
        
        // 主動(dòng)監(jiān)控?cái)?shù)據(jù)庫對(duì)象
        AppWatcher.objectWatcher.watch(
            watchedObject = db,
            description = "SQLiteDatabase實(shí)例應(yīng)被回收"
        )
    }
}

try (val db = dbHelper.writableDatabase) {
    // 執(zhí)行操作 - 自動(dòng)關(guān)閉
    db.insert("Users", null, ContentValues().apply {
        put("name", "John")
    })
} // 自動(dòng)調(diào)用db.close()

fun <T> SQLiteOpenHelper.useDatabase(block: (SQLiteDatabase) -> T): T {
    val db = writableDatabase
    try {
        return block(db)
    } finally {
        db.close()
    }
}

// 使用示例
dbHelper.useDatabase { db ->
    db.query("Users", null, null, null, null, null, null)
        .use { cursor ->
            while (cursor.moveToNext()) {
                // 處理數(shù)據(jù)
            }
        }
}

class DatabaseLifecycleObserver(private val dbHelper: SQLiteOpenHelper) : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun closeDatabase() {
        dbHelper.close()
        Log.d("DB_LIFECYCLE", "數(shù)據(jù)庫連接已關(guān)閉")
    }
}

// 在Activity/Fragment中
lifecycle.addObserver(DatabaseLifecycleObserver(dbHelper))

dbHelper.writableDatabase.use { db ->
    try {
        db.beginTransaction()
        // 批量操作
        repeat(100) { i ->
            val values = ContentValues().apply {
                put("name", "User$i")
            }
            db.insert("Users", null, values)
        }
        db.setTransactionSuccessful()
    } catch (e: Exception) {
        Log.e("DB_ERROR", "事務(wù)失敗", e)
    } finally {
        db.endTransaction()
    }
}

object DatabaseManager {
    private const val MAX_POOL_SIZE = 5
    private val connectionPool = ArrayBlockingQueue<SQLiteDatabase>(MAX_POOL_SIZE)
    
    fun getConnection(dbHelper: SQLiteOpenHelper): SQLiteDatabase {
        return connectionPool.poll() ?: dbHelper.writableDatabase.apply {
            // 新連接初始化設(shè)置
            enableWriteAheadLogging()
        }
    }
    
    fun releaseConnection(db: SQLiteDatabase) {
        if (!connectionPool.offer(db)) {
            db.close() // 連接池滿時(shí)直接關(guān)閉
        }
    }
}

// 使用示例
val db = DatabaseManager.getConnection(dbHelper)
try {
    // 使用數(shù)據(jù)庫
} finally {
    DatabaseManager.releaseConnection(db)
}

fun getUsers(): List<User> {
    val users = mutableListOf<User>()
    
    dbHelper.readableDatabase.use { db ->
        db.query("Users", null, null, null, null, null, null).use { cursor ->
            val idIndex = cursor.getColumnIndex("id")
            val nameIndex = cursor.getColumnIndex("name")
            
            while (cursor.moveToNext()) {
                users.add(User(
                    id = cursor.getLong(idIndex),
                    name = cursor.getString(nameIndex)
                ))
            }
        }
    }
    
    return users
}

@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
    
    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null
        
        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java, "app_db"
                )
                .addCallback(object : RoomDatabase.Callback() {
                    override fun onOpen(db: SupportSQLiteDatabase) {
                        // 連接打開追蹤
                    }
                })
                .build()
                .also { INSTANCE = it }
            }
        }
    }
}

// 檢測(cè)關(guān)閉情況
val db = AppDatabase.getDatabase(context)
// ...使用數(shù)據(jù)庫...
db.close() // 顯式關(guān)閉
db.isOpen // 檢查狀態(tài)