Kotlin 编写好用的工具

Kotlin 提供的丰富语法特性给我们提供了无限扩展的可能，各种复杂的 API 经过特殊的封装处理后都能变得简单易用，因此我们要养成对 Kotlin 的各种特性进行灵活运用的意识。接下来对一些常用 API 的用法进行简化，从而编写出一些好用的工具。

求N个数的最大最小值

fun main(){
    val a = 10
    val b = 15
    val larger = max(a,b)
    println(larger)  // 15

    val c = 5
    val largest  = max(max(a,b),c)
    println(largest) // 15

    // 使用自定义函数 max() 来简化 max() 的嵌套。
    val largest1 = mMax(a,b,c)
    val lowest1 = mMin(a,b,c)
    println(largest1)  // 15
    println(lowest1)   // 5

    // 比较浮点型数字
    val d = 15.5
    val e = 16.5
    val largest2 = mMax(d,e)
    val lowest2 = mMin(d,e)
    println(largest2)  // 16.5
    println(lowest2)   // 15.5
}

/**
 * 简化多个数比较时的 max() 嵌套
 * 借助 vararg 关键字，它允许方法接收任意多个同等类型的参数。
 */
//fun mMax(vararg nums:Int):Int{
//    // 记录所有数中的最大值，并在一开始将它赋值成了整形范围的最小值。
//    var maxNum = Int.MIN_VALUE
//    for (num in nums){
//        maxNum = max(maxNum,num)
//    }
//    return maxNum
//}

/**
 * 上面的方法只能比较整型数字。
 * 那如果想要比较浮点型或长整型数字，可以重载多个 mMax()，来接收不同类型的参数。
 * 但在这里会使用一种更加巧妙的做法。
 * ------------------------------------------------------------------------------------------
 * Java 中规定，所有类型的数字都是可比较的，因为必须实现 Comparable 接口，
 * 这个规则在 Kotlin 中也同样成立。我们可借助泛型，将 mMax() 修改成接收任意多个实现 Comparable 接口 的参数。
 * ------------------------------------------------------------------------------------------
 * 这里将泛型 T 的上界指定成了 Comparable<T>，那么参数 T 就必然是 Comparable<T> 的子类型了。
 * 现在不管是双精度浮点型、单精度浮点型，还是短整型、整型、长整型，只要是实现 Comparable 接口的子类型，此函数都支持获取它们的最大值。
 */
fun <T:Comparable<T>> mMax(vararg nums:T):T{
    if (nums.isEmpty()) throw RuntimeException("Params can not be empty")
    var maxNum = nums[0]
    for (num in nums){
        if (num > maxNum){
            maxNum = num
        }
    }
    return maxNum
}

fun <T:Comparable<T>> mMin(vararg nums:T):T{
    if (nums.isEmpty()) throw RuntimeException("Params can not be empty")
    var minNum = nums[0]
    for (num in nums){
        if (num < minNum){
            minNum = num
        }
    }
    return minNum
}

---

全局获取 Context 的技巧

/**
 * Application 类要记得在 AndroidManifest.xml 中指定使用这个自定义的，而不是默认的 Application 类。
 */
class MyApplication :Application(){

    /**
     * 平时的很多操作都是在 Activity 中进行的，而 Activity 本身就是一个 Context 对象，所以不担心得不到 COntext 的问题，
     * 但有时会脱离 Activity 类，这时可使用 Application 类来管理程序内一些全局的状态信息，比如全局 Context。
     * 以静态变量的形式提供全局获取 Context
     * 使用方式：MyApplication.context
     */
    companion object{
        // 由于 Application 中的 Context 全局只会存在一份实例，并且在整个应用程序的生命周期内都不会回收，因此是不存在内存泄漏风险的，
        // 所以这里可以使用注解，让 Android Studio 忽略可能会产生内存泄漏的警告提示。
        @SuppressLint("StaticFieldLeak")
        lateinit var context:Context
    }

    override fun onCreate() {
        super.onCreate()
        context = applicationContext
    }

}

---

简化 Toast 的用法

/**
 * Toast 第二个参数是要显示的内容，可以传入字符串和字符串资源 id 两种类型，
 * 所以，可以给 String 和 Int 类各添加一个扩展函数。
 */
//fun String.showToast(context: Context){
//    Toast.makeText(context,this,Toast.LENGTH_SHORT).show()
//}
//
//fun Int.showToast(context: Context){
//    Toast.makeText(context,this,Toast.LENGTH_SHORT).show()
//}

/**
 * 指定 Toast 的显示时长
 * 通过给函数设定参数默认值，当需要 Toast.LENGTH_LONG 时可直接传入。
 */
fun String.showToast(context: Context,duration:Int = Toast.LENGTH_SHORT){
    Toast.makeText(context,this,duration).show()
}

fun Int.showToast(context: Context,duration:Int = Toast.LENGTH_SHORT){
    Toast.makeText(context,this,duration).show()
}

/**
 * 使用 MyApplication 提供的 context 来简化代码
 */
fun String.showToast(duration:Int = Toast.LENGTH_SHORT){
    Toast.makeText(context,this,duration).show()
}

fun Int.showToast(duration:Int = Toast.LENGTH_SHORT){
    Toast.makeText(context,this,duration).show()
}

// 直接弹出一段字符串文本
"This is Toast".showToast(context)
// 弹出一个定义在 strings.xml 中的字符串资源
R.string.app_name.showToast(context)

// 使用长显示
"This is Toast".showToast(context,Toast.LENGTH_LONG)
R.string.app_name.showToast(context,Toast.LENGTH_LONG)

// 使用全局 context 后的简化写法
"This is Toast".showToast()

---

简化 Snackbar 的用法

/**
 * 记得要添加依赖库：implementation 'com.google.android.material:material:1.1.0'
 * 将扩展函数添加到了 View 类中
 */
//fun View.showSnackbar(text:String, duration:Int = Snackbar.LENGTH_SHORT){
//    Snackbar.make(this,text,duration).show()
//}
//
//fun View.showSnackbar(resId:Int, duration:Int = Snackbar.LENGTH_SHORT){
//    Snackbar.make(this,resId,duration).show()
//}


/**
 * 通过高阶函数来添加对 setAction() 的支持
 * 这里将新增的两个参数都设置成可为空的类型，并将默认值都设置为空，然后只有当两个参数都不为空时才去调用 Snackbar 的 setAction() 来设置额外的点击事件。
 * 如果触发了点击事件，只需要调用函数类型参数将事件传递给外部的 Lambda 表达式即可。
 */
fun View.showSnackbar(text:String, actionText:String? = null, duration:Int = Snackbar.LENGTH_SHORT, block:(() -> Unit)? = null){
    val snackbar = Snackbar.make(this,text,duration)
    if (actionText != null && block != null){
        snackbar.setAction(actionText){
            block()
        }
    }
    snackbar.show()
}

fun View.showSnackbar(resId:Int, actionResId:Int? = null, duration:Int = Snackbar.LENGTH_SHORT, block:(() -> Unit)? = null){
    val snackbar = Snackbar.make(this,resId,duration)
    if (actionResId != null && block != null){
        snackbar.setAction(actionResId){
            block()
        }
    }
    snackbar.show()
}

// 使用方法如下：（Action 是按钮的名字）
view.showSnackbar("This is Snackbar","Action"){
    Toast.makeText(context,"showSnackbar",Toast.LENGTH_SHORT).show()
}

---

日志工具

/**
 * LogUtil 单例类，用来控制日志的打印。
 * 当存在过多的日志打印时，不仅会降低程序的运行效率，还可能泄露机密性的数据。
 * 所以，最好是在开发阶段就打印日志，当程序上线后就把日志屏蔽掉。
 */
object LogUtil {
    /**
     * 定义了 5 个整型常量，并且数值递增，表示日志级别。
     * 然后又定义了一个静态变量，可将它的值指定为这 5 个常量中的任意一个，用来控制打印日志。
     * --------------------------------------------------------------------------------------
     * 这样，当开发阶段将 level 设为 VERBOSE，当项目正式上线时将 level 设为 ERROR 表示只打印程序的错误日志。
     */
    private const val VERBOSE = 1

    private const val DEBUG = 2

    private const val INFO = 3

    private const val WARN = 4

    private const val ERROR = 5

    private var level = VERBOSE

    /**
     * 定义了 5 个日志方法，用来打印不同级别的日志。
     * ------------------------------------
     * 使用方法：
     * LogUtil.d("TAG","debug log")
     */
    fun v(tag: String, msg: String) {
        if (level <= VERBOSE) {
            Log.v(tag, msg)
        }
    }

    fun d(tag: String, msg: String) {
        if (level <= DEBUG) {
            Log.d(tag, msg)
        }
    }

    fun i(tag: String, msg: String) {
        if (level <= INFO) {
            Log.i(tag, msg)
        }
    }

    fun w(tag: String, msg: String) {
        if (level <= WARN) {
            Log.w(tag, msg)
        }
    }

    fun e(tag: String, msg: String) {
        if (level <= ERROR) {
            Log.e(tag, msg)
        }
    }

}

---

将背景图和状态栏融合到一起

class WeatherActivity : AppCompatActivity() {
  
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (Build.VERSION.SDK_INT >= 21) {
//            调用 getWindow().getDecorView() 拿到当前 Activity 的 DecorView，
//            在调用它的 setSystemUiVisibility() 改变系统 UI 的显示，
//            传入的 View.SYSTEM_UI_FLAG_LAYOUT_STABLE 和 View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN 表示 Activity 的布局会显示在状态栏上面
//            最后调用 setStatusBarColor() 将状态栏设置为透明色
            val decorView = window.decorView
            decorView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_STABLE or View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
            window.statusBarColor = Color.TRANSPARENT
        }
        setContentView(R.layout.activity_weather)
    }
}

通过上面的设置，系统状态栏已经成为布局的一部分了，因此会导致界面的布局整体向上偏移一些，可在相应布局中增加 android:fitsSystemWindows=”true” 属性，表示会为系统状态栏留出空间。

隐藏输入法

val manager = getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
manager.hideSoftInputFromWindow(drawerView.windowToken, InputMethodManager.HIDE_NOT_ALWAYS)

---

备注

参考资料：

第一行代码(第3版)

传送门：GitHub