// src/main/java/com/example/runtimepermissiontest/MainActivity.kt
package com.example.runtimepermissiontest

import android.content.Intent
import android.net.Uri
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.example.runtimepermissiontest.databinding.ActivityMainBinding

private lateinit var binding : ActivityMainBinding

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        binding = ActivityMainBinding.inflate(layoutInflater)
        val view = binding.root
        setContentView(view)
		
        // 为按钮添加触发器
        binding.makeCall.setOnClickListener {
            try {
                val intent = Intent(Intent.ACTION_CALL)
                intent.data = Uri.parse("tel:10086")
                startActivity(intent)
            }
            catch (e: SecurityException) { e.printStackTrace() }
        }
    }
}

// src/main/java/com/example/runtimepermissiontest/MainActivity.kt
package com.example.runtimepermissiontest

import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Toast
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.core.content.PackageManagerCompat
import com.example.runtimepermissiontest.databinding.ActivityMainBinding
import java.util.jar.Manifest

private lateinit var binding: ActivityMainBinding

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        ......

        binding.makeCall.setOnClickListener {
            // 修改内容：
            if (ContextCompat.checkSelfPermission(
                    this, "android.Manifest.permission.CALL_PHONE"
                ) != PackageManager.PERMISSION_GRANTED
            ) {
                ActivityCompat.requestPermissions(this, arrayOf(android.Manifest.permission.CALL_PHONE), 1)
            } else {
                call()
            }
        }
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        // 重写新增：
        when (requestCode) {
            1 -> {
                if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    call()
                } else {
                    Toast.makeText(this, "You denied the permission",Toast.LENGTH_LONG).show()
                }
            }
        }
    }

    private fun call() {
        try {
            val intent = Intent(Intent.ACTION_CALL)
            intent.data = Uri.parse("tel:10086")
            startActivity(intent)
        } catch (e: SecurityException) {
            e.printStackTrace()
        }
    }
}

content://com.example.app.provider/table1 
content://com.example.app.provider/table2

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

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 = contentValuesOf("column1" to "text", "column2" to 1) 
contentResolver.insert(uri, values)

val values = contentValuesOf("column1" to "") 
contentResolver.update(uri, values, "column1 = ? and column2 = ?", arrayOf("text", "1"))

contentResolver.delete(uri, "column2 = ?", arrayOf("1"))

// src/main/java/com/example/contactstest/MainActivity.kt
package com.example.contactstest

import android.annotation.SuppressLint
import android.content.pm.PackageManager
import android.os.Bundle
import android.provider.ContactsContract
import android.widget.ArrayAdapter
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import com.example.contactstest.databinding.ActivityMainBinding

private lateinit var binding: ActivityMainBinding

class MainActivity : AppCompatActivity() {

    private val contactsList = ArrayList<String>()
    private lateinit var adapter: ArrayAdapter<String>

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

        binding = ActivityMainBinding.inflate(layoutInflater)
        val view = binding.root
        setContentView(view)

        // 首先按照ListView的标准用法对其初始化，然后开始调用运行时权限的处理逻辑，因为READ_CONTACTS权限属于危险权限。
        // 所以在用户授权之后，才能调用readContacts()方法读取系统联系人信息。
        adapter = ArrayAdapter(this, android.R.layout.simple_list_item_1, contactsList)
        binding.contactsView.adapter = adapter
        if (ContextCompat.checkSelfPermission(this, android.Manifest.permission.READ_CONTACTS)
            != PackageManager.PERMISSION_GRANTED
        ) {
            ActivityCompat.requestPermissions(
                this,
                arrayOf(android.Manifest.permission.READ_CONTACTS),
                1
            )
        } else {
            readContacts()
        }
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        when (requestCode) {
            1 -> {
                if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    readContacts()
                } else {
                    Toast.makeText(this, "You denied the permission", Toast.LENGTH_LONG).show()
                }
            }
        }
    }

    @SuppressLint("Range")
    private fun readContacts() {
        // 查询联系人数据
        // 使用了ContentResolver的 query()方法查询系统的联系人数据。不过传入的Uri参数怎么有些奇怪啊？
        // 为什么没有调用Uri.parse()方法去解析一个内容URI字符串呢？
        // 这是因为ContactsContract.CommonDataKinds.Phone类已经帮我们做好了封装，提供了一个 CONTENT_URI常量，
        // 而这个常量就是使用Uri.parse()方法解析出来的结果。
        // 接着对 query()方法返回的Cursor对象进行遍历，这里使用了?.操作符和apply函数来简化遍历的代码。
        contentResolver.query(
            ContactsContract.CommonDataKinds.Phone.CONTENT_URI,
            null,
            null,
            null,
            null
        )?.apply {
            // 将联系人姓名和手机号逐个取出：
            while (moveToNext()) {
                // 获取联系人姓名
                // 联系人姓名这一列对应的常量是 ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME
                val displayName =
                    getString(getColumnIndex(ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME))  // 需要 @SuppressLint("Range")
                // 获取联系人手机号
                // 联系人手机号这一列对 应的常量是ContactsContract.CommonDataKinds.Phone.NUMBER。
                val number =
                    getString(getColumnIndex(ContactsContract.CommonDataKinds.Phone.NUMBER))    // 需要 @SuppressLint("Range")
                // 取出后进行拼接，并且在中间加上换行符，然后将拼接后的数据添加到ListView的数据源里
                contactsList.add("$displayName\n$number")
            }
            // 通知刷新一下ListView
            adapter.notifyDataSetChanged()
            // 最后千万不要忘记将Cursor对象关闭
            close()
        }
    }
}

class MyProvider : ContentProvider() {
    override fun onCreate(): Boolean {
        return false
    }

    override fun query(
        uri: Uri,
        projection: Array<String>?,
        selection: String?,
        selectionArgs: Array<String>?,
        sortOrder: String?
    ): Cursor? {
        return null
    }

    override fun insert(uri: Uri, values: ContentValues?): Uri? {
        return null
    }

    override fun update(
        uri: Uri,
        values: ContentValues?,
        selection: String?,
        selectionArgs: Array<String>?
    ): Int {
        return 0
    }

    override fun delete(uri: Uri, selection: String?, selectionArgs: Array<String>?): Int {
        return 0
    }

    override fun getType(uri: Uri): String? {
        return null
    }
}

content://com.example.app.provider/table1

content://com.example.app.provider/table1/1

content://com.example.app.provider/*

content://com.example.app.provider/table1/#

class MyProvider : ContentProvider() {
    private val table1Dir = 0	// table1Dir表示访问table1表中的所有数据
    private val table1Item = 1	// table1Item表示访问table1表中的单条数据
    private val table2Dir = 2	// table2Dir表示访问table2表中的所有数据
    private val table2Item = 3	// table2Item表示访问table2表中的单条数据

    private val uriMatcher = UriMatcher(UriMatcher.NO_MATCH)

    init {
        // 在MyProvider类实例化的时候立刻创建UriMatcher的实例，并调用addURI()方法，
        // 将期望匹配的内容URI格式传递进去，注意这里传入的路径参数是可以使用通配符(说明见上)的
        uriMatcher.addURI("com.example.app.provider","table1",table1Dir)		
        uriMatcher.addURI ("com.example.app.provider ", "table1/#", table1Item)	
        uriMatcher.addURI("com.example.app.provider ", "table2", table2Dir)		
        uriMatcher.addURI("com.example.app.provider ", "table2/#", table2Item)	
    }
    ...

    override fun query(
        // 当query()方法被调用的时候，就会通过UriMatcher的match()方法对传入的Uri对象进行匹配，
        // 如果发现UriMatcher中某个 内容URI格式成功匹配了该Uri对象，则会返回相应的自定义代码，
        // 然后我们就可以判断出调用方期望访问的到底是什么数据了。
        uri: Uri, projection: Array<String>?,  selection: String?, selectionArgs: Array<String>?, sortOrder: String?): Cursor? {
        when (uriMatcher.match(uri)) {
            table1Dir -> {
                // 查询table1表中的所有数据
            }
            table1Item -> {
                // 查询table1表中的单条数据
            }
            table2Dir -> {
                // 查询table2表中的所有数据
            }
            table2Item -> {
                // 查询table2表中的单条数据
            }
        }
        ...
    }
    ...
}

vnd.android.cursor.dir/vnd.com.example.app.provider.table1

vnd.android.cursor.item/vnd.com.example.app.provider.table1

class MyProvider : ContentProvider() { 
	...
	override fun getType(uri: Uri) = when (uriMatcher.match(uri)) {
        table1Dir -> "vnd.android.cursor.dir/vnd.com.example.app.provider.table1"
        table1Item -> "vnd.android.cursor.item/vnd.com.example.app.provider.table1"
        table2Dir -> "vnd.android.cursor.dir/vnd.com.example.app.provider.table2"
        table2Item -> "vnd.android.cursor.item/vnd.com.example.app.provider.table2"
        else -> null
    }
}

// src/main/java/com/example/databasetest/DatabaseProvider.kt
package com.example.databasetest

import android.content.ContentProvider
import android.content.ContentValues
import android.content.UriMatcher
import android.database.Cursor
import android.net.Uri

class DatabaseProvider : ContentProvider() {

    // 首先，在类的一开始，同样是定义了4个变量，分别用于表示访问Book表中的所有数据、
    // 访问Book表中的单条数据、访问Category表中的所有数据和访问Category表中的单条数据。
    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

    // 然后在一个by lazy代码块里对UriMatcher进行了初始化操作，将期望匹配的几种URI格式添加了进去。
    	// by lazy代码块是Kotlin提供的一种懒加载技术，代码块中的代码一开始并不会执行，
    	// 只有当uriMatcher变量首次被调用的时候才会执行，并且会将代码块中最后一 行代码的返回值赋给uriMatcher。
    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
    }

    // 综合利用了Getter方法语法糖、?.操作符、let函数、?:操作符以及单行代码函数语法糖。
    // 首先调用了getContext()方法并借助?.操作符和let函数判断它的返回值是否为空：
    // 如果为空就使用?:操作符返回false，表示 ContentProvider初始化失败；如果不为空就执行let函数中的代码。
    // 在let函数中创建了一个MyDatabaseHelper的实例，然后返回true表示ContentProvider初始化成功。
    // 由于我们借 助了多个操作符和标准函数，因此这段逻辑是在一行表达式内完成的，符合单行代码函数的语法糖要求，
    // 所以直接用等号连接返回值即可。其他几个方法的语法结构是类似的。
    override fun onCreate() = context?.let {
        dbHelper = MyDatabaseHelper(it, "BookStore.db", 2)
        true
    } ?: false

    // 这个方法中先获取了SQLiteDatabase的实例，然后根据传入的Uri参数判断用户想要访问哪张表，
    // 再调用SQLiteDatabase的query()进行查询，并将Cursor对象返回就好了。
    // 注意，当访问单条数据的时候，调用了Uri对象的getPathSegments()方法，它会将内容URI权限之后的部分以“/”符号进行分割，
    // 并把分割后的结果放入一个字符串列表中，那这个列表的第0个位置存放的就是路径，第1个位置存放的就是id了。
    // 得到了id之后，再通过selection和selectionArgs参数进行约束，就实现了查询单条数据的功能。
    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
    }

    // 先获取了SQLiteDatabase的实例，然后根据传入的Uri参数判断用户想要往哪张表里添加数据，再调用SQLiteDatabase的insert()方法进行添加就可以了。
    // 注意，insert()方法要求返回一个能够表示这条新增数据的URI，
    // 所以我们还需要调用 Uri.parse()方法，将一个内容URI解析成Uri对象，当然这个内容URI是以新增数据的id结尾的。
    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, categoryDir -> {
                val newCategoryId = db.insert("Category", null, values)
                Uri.parse("content://$authority/book/$newCategoryId")
            }
            else -> null
        }
        uriReturn
    }

    // 先获取 SQLiteDatabase的实例，然后根据传入的uri参数判断用户想要更新哪张表里的数据，
    // 再调用SQLiteDatabase的update()方法进行更新就好了，受影响的行数将作为返回值返回。
    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
    
    // 先获取SQLiteDatabase的实例，然后根据传入的uri参数判断用户想要删除哪张表里的数据，
    // 再调用SQLiteDatabase的delete()方法进行删除就好了，被删除的行数将作为返回值返回。
    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
    }
}

// src/main/java/com/example/providertest/MainActivity.kt
package com.example.providertest

import android.annotation.SuppressLint
import android.net.Uri
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import androidx.core.content.contentValuesOf
import com.example.providertest.databinding.ActivityMainBinding

private lateinit var binding: ActivityMainBinding

class MainActivity : AppCompatActivity() {

    // 定义变量
    var bookId: String? = null

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

        binding = ActivityMainBinding.inflate(layoutInflater)
        val view = binding.root
        setContentView(view)
        
        // 分别在这4个按钮的点击事件里面处理 增删改查 的逻辑。

        binding.addData.setOnClickListener {
            // 添加数据
            // 首先调用了Uri.parse()方法将一个内容URI解析成Uri对象，然后把要添加的数据都存放到 ContentValues对象中，
            // 接着调用ContentResolver的insert()方法执行添加操作就可以了。
            // 注意，insert()方法会返回一个Uri对象，这个对象中包含了新增数据的id，
            // 我们通过 getPathSegments()方法将这个id取出，稍后会用到它。 
            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)
        }
        
        binding.queryData.setOnClickListener {
            // 查询数据
            // 调用了Uri.parse()方法将一个内容URI解析成Uri对象，然后调用 ContentResolver的query()方法查询数据，
            // 查询的结果当然还是存放在Cursor对象中。之 后对Cursor进行遍历，从中取出查询结果，并打印出来。 
            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"))        // 需要 @SuppressLint("Range")
                    val author = getString(getColumnIndex("author"))    // 需要 @SuppressLint("Range")
                    val pages = getInt(getColumnIndex("pages"))         // 需要 @SuppressLint("Range")
                    val price = getDouble(getColumnIndex("price"))      // 需要 @SuppressLint("Range")
                    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()
            }
        }
        
        binding.updateData.setOnClickListener {
            // 更新数据
            // 将内容URI解析成Uri对象，然后把想要更新的数据存放到 ContentValues对象中，再调用ContentResolver的update()方法执行更新操作就可以了。
            // 注意，这里我们为了不想让Book表中的其他行受到影响，在调用Uri.parse()方法时， 给内容URI的尾部增加了一个id，
            // 而这个id正是添加数据时所返回的。这就表示我们只希望更新刚刚添加的那条数据，Book表中的其他行都不会受影响。 
            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)
            }
        }
        
        binding.deleteData.setOnClickListener {
            // 删除数据
            // 使用同样的方法解析了一个以id结尾的内容URI，然后调用ContentResolver的delete()方法执行删除操作就可以了。
            // 由于我们在内容URI里指定了一 个id，因此只会删掉拥有相应id的那行数据，Book表中的其他数据都不会受影响。
            bookId?.let {
                val uri = Uri.parse("content://com.example.databasetest.provider/book/$it")
                contentResolver.delete(uri, null, null)
            }
        }
    }
}