Android开发: 分享利用好Kotlin的特色提升开发效率

时间 2020-05-30

标签 android 开发分享利用 kotlin 特色提升效率栏目 Android 繁體版

原文原文链接

Kotlin-first but not kotlin-must

谷歌在 I/O 大会上宣布，Kotlin 编程语言如今是 Android 应用程序开发人员的首选语言后，有更多的安卓程序投入Kotlin的怀抱。 Kotlin的语法糖更加提升了开发的效率，加快了开发速度，使开发工做变得有趣，也让咱们有更多时间写注释了（笑）。可是其实对于Kotlin和Java在Android开发上的选择，我的以为这个除了开发人员对语言的喜爱的，同时也会应该到各自语言的魅力和特色，甚至项目的需求以及后续维护等等各个因素，没有绝对的选择的。咱们要作到的是放大不一样语言优势并加以拓展，不是一味只选择某个语言，语言不是问题，用的那我的怎么用才是关键。java

利用Lazy帮助实现初始化

lazy() 是一个函数, 接受一个 Lambda 表达式做为参数, 返回一个 Lazy<T> 实例的函数，返回的实例能够做为实现延迟属性的委托：第一次调用 get() 会执行已传递给 lazy() 的 lamda 表达式并记录结果，后续调用 get() 只是返回记录的结果。先贴上代码：android

fun startInit(component: Components.()->Unit){
    component.invoke(Components.get())
}

class Components {

    companion object{

        private val entry = ArrayMap<String,Any?>()

        private val instant by lazy { Components() }

        fun get() = instant

        fun getEntry() = entry
    }


    inline fun <reified T>single(single: ()->T){
        val name = T::class.java.name
        getEntry()[name] = single()
    }


}

inline fun <reified T> get(name: String = T::class.java.name) : T{
   return Components.getEntry()[name] as T
}

inline fun <reified T> inject(name: String = T::class.java.name) : Lazy<T> {
    return lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) { Components.getEntry()[name]  as T }
}


// 使用例子
startInit {
            single {  RoomApi.getDao() }
            single {  RetroHttp.createApi(Main::class.java) }
        }

 
 private val  main : Main by inject()
 private val dao : MainDao by inject()

复制代码

总结：简单的代码优化，提升开发效率编程

借助协程实现倒计时和超时等待任务

1、倒计时

这个一直都是安卓开发的常见需求，广泛可采用以下方案
一、RxJava
二、CountDownTimer
三、Timer+TimerTask
四、线程
这些都是属于常见的可行方案，相关对应使用时候的坑这里就不展开，各有各的。那咱们借助协程这个工具，咱们能够本身实现其中一种方案，优雅地编写代码，同样贴代码bash

fun counter(dispatcher: CoroutineContext,start:Int, end:Int, delay:Long,
onProgress:((value:Int)->Unit),onFinish: (()->Unit)?= null){
    val out = flow<Int> {
        for (i in start..end) {
            emit(i)
            kotlinx.coroutines.delay(delay) 
        }
    }
    GlobalScope.launch {
        withContext(dispatcher) {
            out.collect {
                onProgress.invoke(it)
            }
            onFinish?.invoke()
        }
    }
}
复制代码

利用flow实现这种异步输出数字同时，达到每一个输出结果之间延迟，这样就能更好地计算出结果，其中的GlobalScope.launch这个方法我十分建议替换成lifecycleScope.launchWhenStarted在安卓上生命周期状态十分重要，也是近年Google推出这个框架的缘由：网络

androidx.lifecycle:lifecycle-***-***
复制代码

其中的lifecycleScope.launchWhenStarted 来自这里，有兴趣的童鞋能够深刻研究，其实这块知识和源码不难理解的，app

androidx.lifecycle:lifecycle-runtime-ktx
复制代码

2、超时等待任务

在平时的开发中，或多或少遇到一种需求就是，我须要执行一个超时任务，而后这个任务有个最大超时时间，超过了这个时间，任务做废或执行另外一个任务，超时以内的我要提早执行其余逻辑等等。例如很多的启动页拿广告的，不管是广告来自你家的仍是第三方的，涉及到网络获取，总有遇到延时问题，我要拿到广告才能进入主页面，我也不能等太长时间，影响正常的功能使用，而个人确须要这个广告的相关收益。那只好执行相似的超时任务,我我的的解决方案是以下：
仍是借助协程来进行，一样GlobalScope.launch这个方法我十分建议替换成lifecycleScope.launchWhenStarted框架

fun waitUtil(dispatcher: CoroutineContext,outTimeMills:Long,onTime:(result:Boolean)->Unit, doWork: suspend () ->Unit){
    GlobalScope.launch(dispatcher) {
        val result = withTimeoutOrNull(outTimeMills){
            doWork.invoke()
        }
        onTime.invoke(result != null)
    }
}
复制代码

利用协程里的超时方法来帮助判断任务的执行是否超时了。
总结：其实协程是一个对线程池封装的好框架，也不须要把它想象得是什么十分高大上很难理解的东西，慢慢分析源码很重要。异步

浮点变量转dp,px,sp等等

这个也是咱们平时开发常常用到，px转dp，px转sp,等等。先贴代码：编程语言

val Float.dp
   get() = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, this,Resources.getSystem().displayMetrics)

val Float.px
  get() = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, this,Resources.getSystem().displayMetrics)

val Float.sp
    get() = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP, this,Resources.getSystem().displayMetrics)
复制代码

其实这种拓展方法在平常的Kotlin开发常常用到，详细解疑可见大佬扔物线详细讲解视频：www.bilibili.com/video/BV16K…
ide

在适应位置跳出Kotlin的ForEach

这里说的ForEach是这种偷懒写法list.forEach{}，这种状况下用break跳出是有问题的，能够本身敲敲代码看看。我我的优化方案以下：

inline fun <T> Iterable<T>.forEachBreak(action: (T) -> Boolean ){
    kotlin.run breaking@{
        for (element in this)
            if(!action(element)){
                return@breaking
            }
    }
}
复制代码

利用最后的返回值为false的时候跳出去循环，固然其实你若是使用for (element in this)是能够正常使用break,countine的，我举个例子就知道了：

val list = ArrayList<Int>()
    for(i in 0..10){
        list.add(i)
    }

    list.forEach {
        if(it>5){
            break;//编译器会报错 'break' and 'continue' are only allowed inside a loop
        }
        print("Test 1 Loop in $it")
    }

    for(i in list){
        if(i>5){
            break
        }
        print("Test 2 Loop in $i")
    }
    
       list.forEachBreak {
        if(it>5){
           return@forEachBreak false
        }
        println("Test 3 Loop in $it")
        true
    }
    
复制代码

除了报错的那个下面两个输出的结果是同样的

Test 2 Loop in 0
Test 2 Loop in 1
Test 2 Loop in 2
Test 2 Loop in 3
Test 2 Loop in 4
Test 2 Loop in 5
Test 3 Loop in 0
Test 3 Loop in 1
Test 3 Loop in 2
Test 3 Loop in 3
Test 3 Loop in 4
Test 3 Loop in 5
复制代码

总结：不要懒了，写多几行代码吧，有时候懒得语法糖不必定好吃

EditText的addTextChangedListener和TabLayout的addOnTabSelectedListener优化使用

下面代码一大坨，有时候真不想写代码了(狗头)，先贴一下：

1、EditText的addTextChangedListener:

fun EditText.textWatcher(textWatch: SimpleTextWatcher.() -> Unit) {
    val simpleTextWatcher = SimpleTextWatcher(this)
    textWatch.invoke(simpleTextWatcher)
}

class SimpleTextWatcher(var view: EditText) {

    private var afterText: (Editable?.() -> Unit)? = null
    fun afterTextChanged(afterText: (Editable?.() -> Unit)) {
        this.afterText = afterText
    }

    private var beforeText: ((s: CharSequence?, start: Int, count: Int, after: Int) -> Unit)? = null
    fun beforeTextChanged(beforeText: ((s: CharSequence?, start: Int, count: Int, after: Int) -> Unit)) {
        this.beforeText = beforeText
    }

    private var onTextChanged: ((s: CharSequence?, start: Int, before: Int, count: Int) -> Unit)? =
        null

    fun onTextChanged(onTextChanged: ((s: CharSequence?, start: Int, before: Int, count: Int) -> Unit)) {
        this.onTextChanged = onTextChanged
    }

    init {
        view.addTextChangedListener(object : TextWatcher {
            override fun afterTextChanged(s: Editable?) {
                afterText?.invoke(s)
            }

            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {
                beforeText?.invoke(s, start, count, after)
            }

            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {
                onTextChanged?.invoke(s, start, before, count)
            }
        })
    }
}
复制代码

2、TabLayout的addOnTabSelectedListener

有了上面的基础，下面的就简单了：

fun TabLayout.onTabSelected(tabSelect: TabSelect.() -> Unit) {
    tabSelect.invoke(TabSelect(this))
}

class TabSelect(tab: TabLayout) {
    private var tabReselected: ((tab: TabLayout.Tab) -> Unit)? = null
    private var tabUnselected: ((tab: TabLayout.Tab) -> Unit)? = null
    private var tabSelected: ((tab: TabLayout.Tab) -> Unit)? = null

    fun onTabReselected(tabReselected: (TabLayout.Tab.() -> Unit)) {
        this.tabReselected = tabReselected
    }

    fun onTabUnselected(tabUnselected: (TabLayout.Tab.() -> Unit)) {
        this.tabUnselected = tabUnselected
    }

    fun onTabSelected(tabSelected: (TabLayout.Tab.() -> Unit)) {
        this.tabSelected = tabSelected
    }

    init {
        tab.addOnTabSelectedListener(object : TabLayout.OnTabSelectedListener {
            override fun onTabReselected(tab: TabLayout.Tab?) {
                tab?.apply { tabReselected?.invoke(tab) }
            }
            override fun onTabUnselected(tab: TabLayout.Tab?) {
                tab?.apply { tabUnselected?.invoke(tab) }
            }
            override fun onTabSelected(tab: TabLayout.Tab?) {
                tab?.apply { tabSelected?.invoke(tab) }
            }

        })
    }
}
  //使用
  tab.onTabSelected {
            onTabSelected {
                pos = position
            }
        }

复制代码

总结：其实上面这两个都是很典型的DSL语法，利用Kotlin的DSL，充分的发挥Kotlin的优雅，适当的方法命名，恰当的设计，能让开发者或者维护人员更好地理解你的代码，毕竟若是是一大段代码放在那里，维护起来确实是有点累人的。

总结

整体而言，分享的内容并很少，都是一些咱们平常常常用到的，平时多敲多写会有不少不一样发现。