Android開發: 分享利用好Kotlin的特點提高開發效率

 

 

Kotlin-first but not kotlin-must

谷歌在 I/O 大會上宣佈，Kotlin 編程語言現在是 Android 應用程序開發人員的首選語言後，有更多的安卓程序投入Kotlin的懷抱。 Kotlin的語法糖更加提高了開發的效率，加快了開發速度，使開發工作變得有趣，也讓我們有更多時間寫註釋了（笑）。但是其實對於Kotlin和Java在Android開發上的選擇，個人覺得這個除了開發人員對語言的喜好的，同時也會應該到各自語言的魅力和特點，甚至項目的需求以及後續維護等等各個因素，沒有絕對的選擇的。我們要做到的是放大不同語言優點並加以拓展，不是一味只選擇某個語言，語言不是問題，用的那個人怎麼用纔是關鍵。

利用Lazy幫助實現初始化

lazy() 是一個函數, 接受一個 Lambda 表達式作爲參數, 返回一個 Lazy<T> 實例的函數，返回的實例可以作爲實現延遲屬性的委託： 第一次調用 get() 會執行已傳遞給 lazy() 的 lamda 表達式並記錄結果， 後續調用 get() 只是返回記錄的結果。 先貼上代碼：

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
2、CountDownTimer
3、Timer+TimerTask
4、線程

這些都是屬於常見的可行方案，相關對應使用時候的坑這裏就不展開，各有各的。 那我們藉助協程這個工具，我們可以自己實現其中一種方案，優雅地編寫代碼，一樣貼代碼

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 來自這裏，有興趣的童鞋可以深入研究，其實這塊知識和源碼不難理解的，

androidx.lifecycle:lifecycle-runtime-ktx

二、超時等待任務

在平時的開發中，或多或少遇到一種需求就是，我需要執行一個超時任務，然後這個任務有個最大超時時間，超過了這個時間，任務作廢或執行另一個任務，超時之內的我要提前執行其他邏輯等等。例如不少的啓動頁拿廣告的，無論是廣告來自你家的還是第三方的，涉及到網絡獲取，總有遇到延時問題，我要拿到廣告才能進入主頁面，我也不能等太長時間，影響正常的功能使用，而我的確需要這個廣告的相關收益。那隻好執行類似的超時任務,我個人的解決方案是如下：
還是藉助協程來進行，同樣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…

在適應位置跳出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優化使用

下面代碼一大坨，有時候真不想寫代碼了(狗頭)，先貼一下：

一、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)
            }
        })
    }
}

二、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的優雅，適當的方法命名，恰當的設計，能讓開發者或者維護人員更好地理解你的代碼，畢竟如果是一大段代碼放在那裏，維護起來確實是有點累人的。

總結

總體而言，分享的內容並不多，都是一些我們日常經常用到的，平時多敲多寫會有很多不同發現。

 

粉絲扣扣羣：