Jenly-AndroidKTXKotlin 工具类集合-轻识

AndroidKTX 一个简化 Android 开发的 Kotlin 工具类集合，通过 Kotlin 语法特性封装一些好用的方法和功能，可以使代码更加简洁易读，从而有效的提高开发效率。

引入

Gradle:

在Project的 build.gradle 里面添加远程仓库

allprojects {
    repositories {
        //...
        mavenCentral()
    }
}

在Module的 build.gradle 里面添加引入依赖项

// core-ktx（*必须）
implementation 'com.github.jenly1314.AndroidKTX:core-ktx:1.0.0'
// activity-ktx（可选）
implementation 'com.github.jenly1314.AndroidKTX:activity-ktx:1.0.0'
// fragment-ktx（可选）
implementation 'com.github.jenly1314.AndroidKTX:fragment-ktx:1.0.0'

示例

下面介绍一些部分常用的功能：

ActivityResultCaller 的 ActivityResultLauncher 使用示例（常在 Activity 或 Fragment 中使用）

    // 单个权限申请：只需在需要使用的地方调用：cameraPermissionLauncher.launch() 即可触发回调
    private val cameraPermissionLauncher = requestPermissionLauncher(Manifest.permission.CAMERA) { granted ->
        showToast("granted = $granted")
        log(msg = "granted = $granted")
        if (granted) {
            // 已授权，则进行拍照预览
            picturePreviewLauncher.launch()
        }
    }
    
    // 多个权限申请：只需在需要使用的地方调用：readWritePermissionLauncher.launch() 即可触发回调
    private val readWritePermissionLauncher = requestMultiplePermissionsLauncher(
        arrayOf(
            Manifest.permission.READ_EXTERNAL_STORAGE,
            Manifest.permission.WRITE_EXTERNAL_STORAGE
        )
    ) { allGranted, grantedPermissions, deniedPermissions ->
        showToast("allGranted = $allGranted")
        log(msg = "allGranted = $allGranted, grantedPermissions = $grantedPermissions, deniedPermissions = $deniedPermissions")
        if (allGranted) {
            // 已全部授权，则进行选择文件
            documentLauncher.launch()
        }
    }
    
    // 拍照预览
    private val picturePreviewLauncher = takePicturePreviewLauncher{
        binding.iv.setImageBitmap(it)
    }
    
    // 选择文件 (类型：image/*)
    private val documentLauncher = openDocumentLauncher(arrayOf("image/*")){
        binding.iv.setImageURI(it)
    }
    
    // startActivityForResult：只需在需要使用的地方调用：startActivityLauncher.launch(intent) 即可触发回调
    private val startActivityLauncher = startActivityForResultLauncher{
        log(msg = "resultCode = ${it.resultCode}")
        if(it.isResultOk()){
            // 成功
            showToast("Result Ok")
        }else{
            showToast("Result Cancel")
        }
    }

然后通过申明的 XXXLauncher 调用函数 launch 即可

    // 如：cameraPermissionLauncher
    cameraPermissionLauncher.launch()

    //如：startActivityLauncher
    startActivityLauncher.launch(
            intentOf(
                SampleActivity::class.java,
                "key1" to 2,
                "key2" to "Start Activity For Result"
            )
        )

startActivity 使用示例（常在 Activity 或 Fragment 中使用）

    // 相当于 startActivity(Intent(this, MainActivity::class.java))
    startActivity<MainActivity>()

或

    // 相当于 startActivity(Intent(this, MainActivity::class.java))
    startActivity(MainActivity::class.java)

或（带传递参数）

    // 相当于 startActivity(Intent(this, MainActivity::class.java).putExtra("key1", 1).putExtra("key2", "Start Activity")
    startActivity(SampleActivity::class.java, "key1" to 1, "key2" to "Start Activity")

然后在跳转后的界面接收数据

class SampleActivity : AppCompatActivity(R.layout.activity_sample) {

    // 懒加载：相当于懒加载的方式获取 getIntent().getExtras().get("key1"); 类型为：Int（有默认值，可保证不为空，并通过默认值的类型可自动推断出变量的类型）
    private val extra1 by lazyIntentExtra("key1", 0)

    // 属性委托：相当于 getIntent().getExtras().get("key2"); 类型为：String（有默认值，可保证不为空）
    private val extra2 by intentExtra("key2", "")


}

Intent 的 intentExtra 使用示例（常在 Activity 中使用）

    // 属性委托：相当于 getIntent().getExtras().get("extra1"); 类型为：Int?
    private val extra1: Int? by intentExtra<Int>("extra1")
    
    // 属性委托：相当于 getIntent().getExtras().get("extra2"); 类型为：Int?（有申明类型时，可以省略泛型）
    private val extra2: Int? by intentExtra("extra2")
    
    // 属性委托：相当于 getIntent().getExtras().get("extra3"); 类型为：Int?（有声明泛型时，可以省略类型）
    private val extra3 by intentExtra<Int>("extra3")
    
    // 属性委托：相当于 getIntent().getExtras().get("extra4"); 类型为：Int（有默认值，可保证不为空）
    private val extra4: Int by intentExtra("extra4", 1)
    
    // 属性委托：相当于 getIntent().getExtras().get("extra5"); 类型为：Int（有默认值，通过默认值的类型可自动推断出变量的类型）
    private val extra5 by intentExtra("extra5", 1)
    
    // 属性委托：相当于 getIntent().getExtras().get("extra6"); 类型为：Int（key的默认值如果忽略或为空时，则默认值为变量的名称）
    private val extra6 by intentExtra(defaultValue = 1)
    
    // 属性委托：相当于懒加载的方式获取 getIntent().getExtras().get("extra7"); 类型为：Int?
    private val extra7: Int? by intentExtra()
    
    // 懒加载：相当于懒加载的方式获取 getIntent().getExtras().get("extra8"); 类型为：Int?
    private val extra8: Int? by lazyIntentExtra("extra8")
    
    // 懒加载：相当于懒加载的方式获取 getIntent().getExtras().get("extra9"); 类型为：Int（有默认值，可保证不为空，并通过默认值的类型可自动推断出变量的类型）
    private val extra9 by lazyIntentExtra("extra9", 1)

Fragment 的 argument 使用示例（常在 Fragment 中使用）

    // 属性委托：相当于 fragment.getArguments().get("arg1"); 类型为：Int?
    private val arg1: Int? by argument<Int>("arg1")

    // 属性委托：相当于 fragment.getArguments().get("arg2"); 类型为：Int?（有申明类型时，可以省略泛型）
    private val arg2: Int? by argument("arg2")

    // 属性委托：相当于 fragment.getArguments().get("arg3"); 类型为：Int?（有声明泛型时，可以省略类型）
    private val arg3 by argument<Int>("arg3")

    // 属性委托：相当于 fragment.getArguments().get("arg4"); 类型为：Int（有默认值，可保证不为空）
    private val arg4: Int by argument("arg4", 1)

    // 属性委托：相当于 fragment.getArguments().get("arg5"); 类型为：Int（有默认值，通过默认值的类型可自动推断出变量的类型）
    private val arg5 by argument("arg5", 1)

    // 属性委托：相当于 fragment.getArguments().get("arg6"); 类型为：Int（key的默认值如果忽略或为空时，则默认值为变量的名称）
    private val arg6 by argument(defaultValue = 1)

    // 属性委托：相当于懒加载的方式获取 fragment.getArguments().get("arg7"); 类型为：Int?
    private val arg7: Int? by argument()

    // 懒加载：相当于懒加载的方式获取 fragment.getArguments().get("arg8"); 类型为：Int?
    private val arg8: Int? by lazyArgument("arg8")

    // 懒加载：相当于懒加载的方式获取 fragment.getArguments().get("arg9"); 类型为：Int（有默认值，可保证不为空，并通过默认值的类型可自动推断出变量的类型）
    private val arg9 by lazyArgument("arg9", 1)

argument 主要使用场景示例

    class SampleFragment : Fragment() {
        
        // 属性委托的方式传递参数
        private var argInt by argument(defaultValue = 0)
        private var argString: String? by argument()
        private var argBool by argument(defaultValue = false)
        
        companion object {
    
            fun newInstance(argInt: Int, argString: String, isBool: Boolean): SampleFragment {
                return SampleFragment().apply {
                    // 示例：属性委托的方式传递参数
                    this.argInt = argInt
                    this.argString = argString
                    this.argBool = isBool
                }
            }
        }
        
        //...
        
    }