<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Connie Lin on Medium]]></title>
        <description><![CDATA[Stories by Connie Lin on Medium]]></description>
        <link>https://medium.com/@tzuxlin?source=rss-581e4a0aec0a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*OCp4KIzhVOqsogC2aSmm8Q.png</url>
            <title>Stories by Connie Lin on Medium</title>
            <link>https://medium.com/@tzuxlin?source=rss-581e4a0aec0a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 14:40:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@tzuxlin/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[LiveData & Flow.asLiveData() 的差異]]></title>
            <link>https://tzuxlin.medium.com/livedata-flow-aslivedata-%E7%9A%84%E5%B7%AE%E7%95%B0-89b306ca8a35?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/89b306ca8a35</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[flow]]></category>
            <category><![CDATA[livedata]]></category>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Fri, 17 Feb 2023 07:52:56 GMT</pubDate>
            <atom:updated>2023-02-17T10:39:38.443Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>Hot flow 有自己的資源管理行為，例如幾秒都沒有 collector 就會進 inactive、shared flow 也考慮當下是否有 collector 來決定是否把資料放進 buffer。很好奇這些特性在 </em><em>asLiveData 之後會發生什麼事，也好奇 </em><em>asLiveData 究竟是在哪些時間點 collect flow、如何處理資料通知的時間點，於是就研究了一下</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*PezIj3qj_D4hXV1r6r_ihQ.png" /></figure><h3>LiveData 的 observe</h3><pre>LiveData&lt;T&gt;.observe(LifecycleOwner, Observer)</pre><p>LiveData 有管理通知資料變化的生命週期，只會在 lifecycle owner active 的期間（<strong>started</strong>, <strong>resumed</strong>），才會通知 observer，避免在沒有畫面的期間去取用 view 相關的物件：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/517/1*b4JMS3amLp4rz4Q9hEWJrg.png" /></figure><p>Owner inactive 期間的資料異動不會通知觀察者，直到 owner 恢復 active，observer 才會接收到最新的一筆資料，因此很適合用於畫面顯示。</p><h3>使用 flowWithLifecycle 來取得用於畫面顯示的 flow data</h3><p>Flow 本身並沒有限制生命週期，如果資料是要用於畫面顯示，可以使用 flowWithLifecycle，會幫忙在每次進入特定生命週期時 collect data，這個 API 的 State 預設為 State.STARTED，適用於畫面顯示。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/649/1*MwZC4A2KpwwbOHFfNKkWbA.png" /></figure><p>但因為 hot flow never ends，每個 hot flow 要在個別的 lifecycle scope collect 才不會阻塞，加上還得自己加 flowWithLifecycle才能限縮 lifecycle，有些人可能更喜歡在 asLiveData 之後改用觀察的方式。</p><pre>// 直接 collect flow<br><br>LifecycleScope.launch {<br>    hotFlowA.flowWithLifecycle(lifecycle)<br>         .collect { ... }<br>}<br>LifecycleScope.launch {<br>    hotFlowB.flowWithLifecycle(lifecycle)<br>        .collect { ... }<br>}<br><br>// 轉為 LiveData 之後改用 observe<br><br>hotFlowA.asLiveData().observe(viewLifecycleOwner) { <br>    ...<br>}<br>hotFlowB.asLiveData().observe(viewLifecycleOwner) { <br>    ...<br>}</pre><p>那就來看一下 Flow.asLiveData 有哪些注意事項吧。</p><h3>Flow.asLiveData.observe 是怎麼做 collect 的？</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/653/1*47t9UJ1bQe2dpzX-IGsxaA.png" /></figure><p>asLiveData() 會創建一個 LiveData，在 block 中 collect flow，取得新資料時，會呼叫底層 LiveDataScopeImpl 的 emit，將 emitted data 設定為 LiveData 的值，藉此將 Flow 轉成 LiveData。底層的 CoroutineLiveData 也會去控制只在 LiveData onActive() 的時候才開始 collect，並在 onInactive() 達 timeout 時，取消 flow collection。</p><p>大多的行為在底層都處理好了，篇幅關係就不貼出來了，有興趣的話可以去翻一下 code。關於 asLiveData，我們要知道的只有：</p><ul><li>透過 asLiveData() 將 Flow 轉為 LiveData，會在 active 期間開始 collect flow，並在 inactive timeout 之後取消 flow collection。</li><li>asLiveData() 傳入timeoutInMs 可以設定 timeout 時長，預設為五秒。</li></ul><h3>LiveData 和 Flow.asLiveData 有什麼差異？</h3><blockquote><strong>如果在 owner inactive 的期間 set value 的話⋯</strong></blockquote><blockquote><strong>LiveData.setValue</strong></blockquote><p>LiveData 本身的特性會把 pending 的資料暫存起來，直到 active state change 之後才會通知，恢復觀察時就可以拿到一筆最新的資料<strong>。</strong></p><blockquote><strong>StateFlow.setValue （hot flow）</strong></blockquote><p>StateFlow 的特性是可以存放一筆最新的 replay cache，因此資料會被暫存起來，直到 owner 恢復 active，asLiveData() 開始 collect flow 之後，observer 就可以拿到 replay cache 了，因此觀察時也可以拿到一筆最新的資料。</p><blockquote><strong>SharedFlow.emit（hot flow）</strong></blockquote><p>asLiveData() 只會在 owner active 期間去 collect，如果將 SharedFlow 的 replay 設定為 0（預設值就是如此），是不會拿到先前的資料的，<strong>因此沒有設定 replay，就不會透過 SharedFlow 拿到 inactive 期間的資料。</strong></p><p>不過有個要注意的地方是，前面提到 asLiveData 持續 inactive 五秒以上，才會取消 flow collection，而在 inactive 未達五秒的期間，flow 會將新資料 emit 給 LiveData，在 inactive 的狀態下，LiveData 不會通知 observer，而是把最新一筆 pending 資料暫存起來。恢復 active state 後，observer 拿到的資料是由 LiveData 暫存的，而非 shared flow 的 cache。</p><p><strong>❗️ </strong><strong>asLiveData() 讓我們有可能拿到由 LiveData 暫存的資料，但因為 inactive timeout 後 sharedFlow 的資料不會被記錄，有機會發生不預期的狀態（你以為的最新其實不是最新）️❗</strong></p><blockquote><strong>Flow（cold flow）</strong></blockquote><p>Cold flow 不能彈性 emit value，只會從定義好的行為中 emit 資料，並由 collect trigger，每一次的 collect 都會從頭 trigger 一次 cold flow 的流程。</p><p>雖然 asLiveData() 設定了 timeoutInMs，inactive timeout 前的資料會 emit 給 LiveData，但因為下一次恢復 active 的時候又會從頭 trigger 一次 cold flow，inactive 期間的資料其實不會被收到。</p><h3>整理一下</h3><p>非 hot flow 的 Flow.asLiveData().collect 會在每次 active 的時候重新 trigger flow，沒有 cache data 的問題，因此不在討論之列。下面表列了 LiveData、StateFlow 與 SharedFlow 不同情境下的行為。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*i9FGdOxHHb5c9bysbvJbyw.png" /></figure><p>首先，LiveData 和 StateFlow 使用以下方法來取得資料，體感是一樣的，差別在 StateFlow 確保會有預設值。</p><pre>LiveData.observe<br>StateFlow.asLiveData().observe<br>StateFlow.flowWithLifecycle(State.Started).collect</pre><p>如果是為了管理某些一次性的事件使用 SharedFlow.asLiveData() ，以下方式得到的資料可能會有差異，因此要注意使用情境會不會有 side effect。</p><pre>SharedFlow.asLiveData().observe<br>SharedFlow.flowWithLifecycle(State.Started).collect</pre><p>如果期望不要拿到先前的資料而使用 SharedFlow(replay = 0) ，直接 collect flow 會是比較乾淨的狀態，因為 LiveData 會把 inactive 未達 timeout 期間的最新一筆資料暫存起來。</p><h3>LiveData・StateFlow・SharedFlow，兜幾？</h3><blockquote><strong>如果資料需要用於畫面顯示⋯</strong></blockquote><p>只關心一筆最新的資料的話，LiveData &amp; StateFlow 都可以。觀察端使用 observe 會比較簡潔，生產端只做 setValue 的話，LiveData 也會比較簡單，根據情境需求，隨喜選用就可以。</p><p>另外，生產端需要因應多個來源產生資料變化的話，可以考慮使用：</p><ul><li>LiveData：有順序關係可使用 Transformation.map(source) ，因應 source 的改變去做 map，無順序關係可使用 MediatorLiveData 加入多個 source。</li><li>StateFlow ：使用 flow 的 operators 可以更彈性的處理資料源之間的因果、順序關係，且如果需參考兩個以上的資料源，或是資料源之間有複雜的運算的話，覺得用 flow 更適合。</li></ul><blockquote>用過即棄的一次性事件</blockquote><p>使用 SharedFlow(replay = 0).collect，只有在 collect 期間有變動的資料才會收到通知，且當下即焚，錯過不再 🔥</p><p>asLiveData 之後會受限於 LiveData 的特性，replay = 1以外的情境都不適合使用 asLiveData，不管是 replay = 0 或是 replay &gt; 1，都直接用 collect 會更為適合。</p><h3>更簡潔地 collect hot flow</h3><p>其實，如果是覺得 flow collection 毛很多而改用 LiveData 的話，我試著寫了一個 extension function 來簡化 collect hot flow 可能要寫很多行的痛點（其實我不知道夠不夠痛 😂）。</p><pre>fun &lt;T&gt; Flow&lt;T&gt;.launchCollection(<br>    lifecycleOwner: LifecycleOwner,<br>    collector: FlowCollector&lt;T&gt;,<br>) = lifecycleOwner.lifecycleScope.launch {<br>    this@launchCollection<br>        .flowWithLifecycle(lifecycleOwner.lifecycle)<br>        .collect(collector)<br>}</pre><p>這個 extension 會幫忙 launch CoroutineScope，並且在 scope 裏面做了Flow.repeateOnLifecycle.collect。這麼一來 collect flow 會變得比較精簡，尤其是多個 hot flow 的情境下不需要再自己 launch 一堆 CoroutineScope。</p><pre>lifecycleScope.launch {<br>    stateFlow<br>        .flowWithLifecycle(lifecycle)<br>        .collect {<br>            // TODO<br>        }<br>}<br><br>stateFlow.launchCollection(viewLifecycleOwner) {<br>    // TODO<br>}</pre><h3>同場加映：timeoutInMs 的好處？</h3><p>預設為五秒，可以在旋轉畫面或是短暫離開 app 的時候，讓 upstream flow 保持 active。如果單純一條 StateFlow 或 SharedFlow 作為 upstream flow，切換 inactive → active 可能沒什麼影響，但如果 upstream 有組合了多條 flow，inactive → active 會從頭 trigger 所有的 operation，如果是 cold flow 的話，還會再跑一次 flow 的流程，因此資源管理還是挺重要的。</p><p>這些地方都可以設定 timeoutInMs，可以思考當下的使用情境是否需要：</p><ul><li>Flow.asLiveData()：預設值 5000 ms</li><li>Flow.stateIn() / Flow.sharedIn() ：SharingStarted 設定為 WhileSubscribe，預設值為 0 ms</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89b306ca8a35" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[Android] Coroutines Hot Flow：希望我能早點知道的小事（3/3）]]></title>
            <link>https://tzuxlin.medium.com/android-coroutines-hot-flow-%E5%B8%8C%E6%9C%9B%E6%88%91%E8%83%BD%E6%97%A9%E9%BB%9E%E7%9F%A5%E9%81%93%E7%9A%84%E5%B0%8F%E4%BA%8B-3-3-ee11f99b9735?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/ee11f99b9735</guid>
            <category><![CDATA[kotlin-coroutines]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Tue, 17 May 2022 09:40:36 GMT</pubDate>
            <atom:updated>2023-01-12T16:21:18.868Z</atom:updated>
            <content:encoded><![CDATA[<p>這是 Coroutines Hot Flow 系列文的最後一篇，記錄了我希望自己一開始在使用 Hot Flow 時，就能知道的事 — 也就是當時碰到的盲點與地雷們。先前已經寫了兩篇文章，第一篇介紹了 cold flow 與 hot flow 的區別，以及 hot flow 老大 — SharedFlow 的基本特性；第二篇介紹 hot flow 小弟 — StateFlow，以及兩種 hot flow 的基本實作方式。如果你還沒看過，可以先去瞧瞧。</p><ul><li><a href="https://tzuxlin.medium.com/android-coroutines-hot-flow-1-2-a5f32752d10c">[Android] Coroutines Hot Flow（1/2）</a></li><li><a href="https://tzuxlin.medium.com/android-coroutines-hot-flow-2-3-b3f6451c275f">[Android] Coroutines Hot Flow：Show me the code.（2/3）</a></li></ul><p>當初在學習 hot flow，正也是用於新功能實作的時候。看完網路上的介紹文件，眼睛說懂了，寫下去卻不是那麼一回事。因為有時間上的壓力，學習起來並不是很全面，也是因為這些盲點而遇到了許多問題。得在有限的時間內見招拆招實在是很痛苦，雖然我的雷不一定是你的雷，但如果能有所幫助，我所浪費的那些時間也能夠有所欣慰了吧（？</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*UX2XgVQOzukmg6sJQiPAWA.png" /><figcaption>那些我希望能早點知道的事 🥺</figcaption></figure><h4>Cold flow 適合動態產生，hot flow 適合靜態宣告</h4><p>第一篇文章分別為兩種流給了比喻：cold flow 是私人管線，hot flow 是公共財。cold flow 透過 .collect() 來驅動，flow { } block 內的事情做完即結束，單一 cold flow 只能被 .collect() 一次 — 因此需要動態產生，讓每個需要資料的人各自去產生 instance 並做訂閱。</p><p>Hot flow 則是被創建出來之後，只要還是 active 狀態並且還有 reference 就會保存在記憶體中。為了讓多方可以取得同一個對象並作訂閱，很自然地就會用 reference 來管理。不過因為 cold flow 也能透過 Flow.sharedIn() 以及 Flow.stateIn() 來轉成 hot flow，那就要注意不能從 function call 中做轉型，而產生一堆 hot flow 了。最好是透過下列三種方式產生：</p><pre>val hotFlow1 = MutableSharedFlow&lt;T&gt;()<br>val hotFlow2 = coldFlow.sharedIn(viewModelScope)</pre><pre>fun coldFlow: Flow&lt;T&gt;() = flowOf {}</pre><p>當然，以上是理想世界的情境，人生就是有很多 <strong>BUT</strong>。真的需要動態產生 hot flow 的可能性不是沒有（例如不同 user 需要傳入不同的 id？），那千萬要記得管理 reference 呀。</p><h4>不能在同一個 CoroutineScope 中 collect 多個 hot flow</h4><p>應該要建立新的 coroutine scope 來 collect 多個 hot flow。collect() 是個 suspend function，直到 flow 結束後才會 resume。還記得第一篇文章中有提到 <strong><em>“Hot flow never ends”</em></strong> 嗎？ HotFlow.collect() 是不會結束的，因此它所在的 coroutine scope 會被 suspended，不會向下再執行下去。在下面的例子中， functionA() 是無法被執行的，hotFlowB 在另一個 scope 做 collect，就不會被影響到。</p><pre>viewModelScope.launch {<br>    hotFlowA.collect { // do something }<br>    functionA() // 不會執行到<br>}<br>viewModelScope.launch {<br>    hotFlowB.collect { // do something }<br>}</pre><h4>要建立新的 data instance 來更新 StateFlow</h4><p>第二篇文章提到，StateFlow 預設做了 distinctUntilChanged()，來比對舊值與新值的差異。如果新舊資料是同一個實體，即便有某些參數改變了，也會被過濾掉而不會通知訂閱者。因此要建立新的 instance 來更新 StateFlow。</p><pre>data class Message(val text: String)<br>_stateFlow.value = Message(&quot;Hello&quot;)</pre><pre>// 可以用下面這兩種方式更新資料<br>_stateFlow.value = Message(&quot;Bye&quot;)<br>_stateFlow.<em>update </em>{ it.copy(&quot;Bye&quot;) } // 好處是可以拿到舊的 cache 作修改</pre><p>stateFlow 有 conflated 的特性（容量為 0 且會拋棄舊值），所以直接同步更新資料即可（上面兩種做法都是同步的），不需要使用異步的 emit 。</p><h4>到底什麼時候要用 cold flow、什麼時候要用 hot flow 啊啊啊？</h4><p>收尾前，來做個最後的總結吧。Cold flow 的每個訂閱者都會獨自完整走過一次取得資料的流程，且能提供什麼資料的行為已經定義在 block 內了，無法外部改變。像是 API request 的回傳值通常就是使用 cold flow 來包裝，需要資料的人去 request 即可。</p><p>Hot flow 則是共用的，而能拿到 mutable reference 的人還能把資料丟進去，hot flow 就是通知事件、狀態的容器，生產方在某個時機點把資料丟進去，提供訂閱方使用。用 Observer pattern 實作的 listener 機制，就很適合用 hot flow 來改寫。</p><p>如果一定需要一筆資料，且只關心最新的資料，那就選用 StateFlow，簡單明瞭。但如果你的情境比較多元，就用 SharedFlow 來定義資料分享的情境，例如要不要為新的訂閱者留 cache？容量機制如何運作？容量爆掉如何處理等。</p><p>因應不同的資料邏輯、商業邏輯，選用最適合的 Flow 吧。</p><h4>Reference</h4><p>在學習時，主要是透過這兩份文件：<a href="https://developer.android.com/kotlin/flow/stateflow-and-sharedflow">Android Developer: StateFlow and SharedFlow</a> 、 <a href="https://www.raywenderlich.com/22030171-reactive-streams-on-kotlin-sharedflow-and-stateflow">Reactive Streams on Kotlin: SharedFlow and StateFlow</a> 建立比較全貌的認識。後者還蠻推薦有時間的話好好看一下的，還有一些 GIF 動畫幫助消化理解。</p><p>前面在講針對 hot flow 作 reference 管理的段落，我提到了可以透過 shareIn 與 stateIn來將 cold flow 轉為 hot flow，不過鑒於篇幅與主軸，沒有好好介紹他們。如果有興趣，除了上述文章之外，也可以透過這篇文章來好好認識他們：<a href="https://medium.com/androiddevelopers/things-to-know-about-flows-sharein-and-statein-operators-20e6ccb2bc74">Things to know about Flow’s shareIn and stateIn operators</a>。</p><h4>Murmuring..</h4><p>在草稿匣躺了半年，終於完成這篇文章了。算是第一次寫比較長篇的技術分享文，回過頭已經修了不少盲點、語病，發現好像還是摻雜了許多自己的意識在裡面，希望讀起來不會太辛苦 😂</p><p>任何不足之處與錯誤都歡迎指正，也可以留下意見或是想法，感謝你的閱讀。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ee11f99b9735" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[Android] Coroutines Hot Flow：Show me the code.（2/3）]]></title>
            <link>https://tzuxlin.medium.com/android-coroutines-hot-flow-2-3-b3f6451c275f?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3f6451c275f</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[coroutine]]></category>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Thu, 12 May 2022 09:20:22 GMT</pubDate>
            <atom:updated>2022-05-17T09:52:27.794Z</atom:updated>
            <content:encoded><![CDATA[<p>這是介紹 Coroutines Hot Flow 的系列文第二篇。在上一篇文章中，有聊到冷流與熱流的區別，也應該算是很詳盡、稍嫌囉唆的（？），用例子介紹了 SharedFlow 的幾種基本設定。如果還沒看過，請先服用：</p><p><a href="https://tzuxlin.medium.com/android-coroutines-hot-flow-1-2-a5f32752d10c">[Android] Coroutines Hot Flow（1/2）</a></p><p>而工程師，終究是要寫程式碼的，讓我們開始吧。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j5s5DmfmMFHgXMd_C6gN5w.png" /><figcaption>挖苦挖苦！</figcaption></figure><p>通常資料的提供方會是一個 Repository。與 LiveData 一樣，為了做到資料保護與職責分明，要在 Repository 內分別為生產者與訂閱者產生 Mutable 與 Immutable 的實體，並在類別內部向 MutableSharedFlow emit 資料。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/908011605a8c81a364c2b10789e7e3d7/href">https://medium.com/media/908011605a8c81a364c2b10789e7e3d7/href</a></iframe><p>任何一個需要這個資料的對象 — 就來個 WhateverViewModel 吧 ，會需要取得 MessageRepository.messageFlow 的 reference 來收集資料。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/62e15c8fb68ae76ac9be76cee7ae80dc/href">https://medium.com/media/62e15c8fb68ae76ac9be76cee7ae80dc/href</a></iframe><p>超級無敵簡單的寫法就完成了呢 （゜◇゜）！！（安妮雅驚訝.jpg）</p><h3>等等，我說那個 StateFlow 呢</h3><p>上一篇文章輕描淡寫了 StateFlow 是 SharedFlow 的客製版，其特性又與 LiveData 相似，但似乎還沒有好好的來介紹過它。在創建實體時，會發現它要求在建構子傳入 value。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/ddbfc86af02f73e1233c31efe698d985/href">https://medium.com/media/ddbfc86af02f73e1233c31efe698d985/href</a></iframe><p>官方文件提到，建立 MutableStateFlow(initialValue)<em> </em>其實就等同於對 SharedFlow 做了下面這些設定：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9396fd3d98f94c38b292716ebdb27882/href">https://medium.com/media/9396fd3d98f94c38b292716ebdb27882/href</a></iframe><p>StateFlow 一開始就會 emit 預設值，並且設定為 replay = 1，所以 StateFlow 中永遠都存放著一筆資料。</p><p>因為 BufferOverflow.DROP_OLDEST 的特性，生產者想要修改資料的話，可以直接做 setValue，而不用在 Coroutine Scope 中做異步的 emit，因為結果而言會是一樣的。</p><p>要特別注意的是，StateFlow 額外做了 distinctUntilChanged() 。這意味著如果要更新資料，要注意不能直接修改舊有資料的實體，而是要創建一個新的實體，以避免被忽略掉。</p><p>StateFlow 基本特性以及可以透過 setValue 賦值的方式，看起來都和 LiveData 很像。最大的差異點在於 LiveData 並沒有強制要給預設值，所以即便將資料型別設定為 non-null，還是有可能拿到 null，State Flow 就安全多了。</p><p>StateFlow 如其名，適合放置「唯一而最新的」的資料。不像 SharedFlow 的資料介於有和沒有之間，StateFlow 一定會給予一個最新的狀態，有可能是 Loading、Success 或 Error，通常可以用 Sealed Class 把所有狀態給包裝起來。</p><p>下面一樣是 MessageRepository 的例子，我將預設狀態設為 Loading，並且依據不同的資料結果，分別將 value 設為 Success 或是 Error。這當然只是個簡陋的例子，不過還是可以從中感受到他與 SharedFlow 用法上的差異吧？</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/184e6148911320b02f983264cb09f3f6/href">https://medium.com/media/184e6148911320b02f983264cb09f3f6/href</a></iframe><p>沒想到一下就寫完第二集了，簡短到還以為一切就是這麼單純無害呢。</p><p>不過往往都是在實際使用，或是案例變複雜時，才發現前方有詐。那就富奸一下，在這個系列的下一篇再來好好聊聊關於 SharedFlow 與 StateFlow ，那些不可不慎的事情吧。</p><p><a href="https://tzuxlin.medium.com/android-coroutines-hot-flow-%E5%B8%8C%E6%9C%9B%E6%88%91%E8%83%BD%E6%97%A9%E9%BB%9E%E7%9F%A5%E9%81%93%E7%9A%84%E5%B0%8F%E4%BA%8B-3-3-ee11f99b9735">[Android] Coroutines Hot Flow：希望我能早點知道的小事（3/3）</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3f6451c275f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[Android] Coroutines Hot Flow（1/2）]]></title>
            <link>https://tzuxlin.medium.com/android-coroutines-hot-flow-1-2-a5f32752d10c?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/a5f32752d10c</guid>
            <category><![CDATA[sharedflow]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[flow]]></category>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Thu, 12 May 2022 07:54:54 GMT</pubDate>
            <atom:updated>2023-01-12T16:18:26.586Z</atom:updated>
            <content:encoded><![CDATA[<h3>[Android] Coroutines Hot Flow：關於冷熱的一切～尤其是熱的那些（1/3）</h3><p>Coroutines Flow 可異步發送多筆資料，將源源不絕的資料以「流」的形式提供給訂閱對象作使用。同樣是異步處理的 suspend function，只能 return 單一個回傳值。因為 Flow 具有異步處理、持續更新的特性，還有便於資料處理的強大 opertator，使用 Flow 可以讓資料的處理與傳遞上更加順暢。</p><p>你知道嗎？ Flow 還有分成冷流、熱流。如標題所示，這個系列文一共有三篇，主要著重在熱流的介紹。這篇作為開場，會先聊一下冷流與熱流的基本差異，如此一來更能掌握什麼情境適用哪一種 Flow 。</p><h3>Cold flow v.s. hot flow</h3><p>Flow 有分成冷流（<em>cold</em> flow）與熱流（<em>hot</em> flow）。這兩者的差別在於，c<em>old</em> flow 是由單一對象透過 Flow.collect() 來驅動資料流，並將資料 emit 出來，每一個訂閱者都會從頭驅動資料變化。<em>Hot</em> flow 則是只要被創建出來後，不管有沒有被訂閱都可以持續 emit 資料，也可以提供給多個對象訂閱。相較起來，cold flow 像是一條私人管線，hot flow 則更像是個公共財。</p><p>一般常見的 Flow&lt;T&gt; 就是 cold flow，而本篇文章主要要介紹的 hot flow，有 StateFlow&lt;T&gt; 與 SharedFlow&lt;T&gt; 兩種型別。</p><p>🌟 <strong>Cold flow</strong> 像是一條私人管線，因為只有一個人可以從管線中拿到東西，因此需要資料的人都會取得新的 instance，只有這個 flow 本身可以 emit 資料，而 flow { } block 內的事情做完，這條 flow 也會終止。</p><pre>// 每個 collector 拿到的 flow 都會是不同的 instance<br>fun getFlow(): Flow&lt;T&gt; = flow {<br>    emit(1)<br>    delay(100)<br>    emit(2) <br>}</pre><pre>getFlow.collect() // collector A<br>getFlow.collect() // collector B<br></pre><p>🌟 <strong>Hot flow</strong> 就像一條公有管線，被創建出來之後，會一直保留在記憶體中，只要能取得 reference ，就可以從中訂閱資料，也可以向 Mutable 的 instance emit 資料。不像是 cold flow 事情做完就會結束，有句描述是 “<em>Hot flow never ends”</em>。</p><pre>private val _sharedFlow = MutableSharedFlow&lt;T&gt;() // 可以 emit data<br>val sharedFlow = _sharedFlow.asSharedFlow() // 開放給別人訂閱</pre><pre>// 訂閱者都會訂閱同一個 SharedFlow<br>sharedFlow.collect()</pre><pre>// 生產者可以對 MutableSharedFlow emit 資料<br>_sharedFlow.emit(T)</pre><p>接下來，就進入這個系列文的重點 — hot flow。可以想像 SharedFlow 是熱流的鼻祖，StateFlow 則屬於 SharedFlow 的延伸，那我們就從祖先開始聊起吧。接下來會以「管線」為例子，先透過具象化的情境來理解 SharedFlow 的基本特性。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*ENzQJC9dc92oA43mDeGXuQ.png" /></figure><h3>SharedFlow</h3><p>我們可以把 SharedFlow 當成是一條專門運送材料的水管，只要接上這條水管的工人（subscriber），都能夠拿到材料（data）。工人透過 .collect() 接上水管，從水管收集材料，並且在收到材料之後做任何想做的事情。</p><p>SharedFlow 有 replay、extraBufferCapacity 以及 onBufferOverflow 等設定，讓資料分享端能夠依需求情境，彈性設定資料分享行為。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7c5d900fd8a41f4ec2c1d68f200f2fbd/href">https://medium.com/media/7c5d900fd8a41f4ec2c1d68f200f2fbd/href</a></iframe><ul><li>replay：新訂閱者可以拿到多少舊的資料？</li><li>extraBufferCapacity：有多少額外容量，來放置未處理的新資料？</li><li>onBufferOverflow：管線實際容量是 replay + extraBufferCapacity。容量爆掉之後，要如何處理裝不下的資料？ 可以把機制設定為 SUSPEND 、DROP_LATEST 或 DROP_OLDEST 。</li></ul><p>來點例子吧。</p><blockquote>#1 SharedFlow 的預設值：講究的工頭</blockquote><p>(replay = 0, extraBufferCapacity = 0, onBufferOverflow = BufferOverflow.SUSPEND)</p><p>這是 MutableSharedFlow 的預設值。 replay = 0，代表「錯過不再」，新的工人拿不到先前釋出的材料。如果你希望為新工人留下舊材料，可以設定 replay = N ，可以想像是你多放了 N 個儲物桶在管線尾端。</p><p>extraBufferCapacity 代表想在「管線的額外空間」擱置多少沒被處理的材料。因為 collect 的行為是異步的，所以會有「無法及時處理的狀況」。預設值 extraBufferCapacity = 0 ，代表管線沒有額外空間，因此流進管線內的材料，都得即時地被工人處理。</p><p>儲物桶（replay）加上管線容量（extraBufferCapacity），等於整個管路的總容量。當總容量已滿，沒有額外空間，又有新的材料產生要怎麼辦？就是看 BufferOverflow 的設定了。以預設值 BufferOverflow.SUSPEND 來說，你會是一個講究的工頭，希望讓工人們都能摸過一遍流經水管的材料，所以你會先把新的材料擱置在一旁，直到所有的工人都有空，才將材料放進水管中。實際上，就是會先 suspend emit 下一個 data 的行為。</p><p>那其實也不難想像 BufferOverflow.DROP_LATEST 以及 DROP_OLDEST 的用處了。作為工頭，可以選擇擱置或拋棄，如果不希望老鼠屎卡住整個線路，就可以選擇當管線阻塞的時候拋棄材料，讓水管保持暢通。</p><p>藉由這個例子，應該能對三個參數有些基本概念了。想當初我看完參數定義後，以為自己懂了，但一思考操弄 <em>replay</em> 和 <em>extraBufferCapacity </em>的數值以後這條流會如何運作，又立馬茫了。</p><p>只好再多給幾個例子，繼續看下去。</p><blockquote>#2 在水管末端放一個儲物桶，儲存一份舊材料</blockquote><p>(replay = 1, extraBufferCapacity = 0, onBufferOverflow = BufferOverflow.SUSPEND)</p><p>與上個例子相同，工頭還是相當龜毛，希望所有工人都摸過材料，所以會擱置沒辦法被處理的新材料（BufferOverflow.SUSPEND）。不過，透過 replay = 1 的設定，工頭在水管的 <strong>出口<em> </em></strong>多放了一個水桶，來裝一份最新的材料，因此初來乍到的新工人不至於閒到沒事做。</p><p>不自量力的工人甲來接這根水管後，就去忙別的事情了，因此工人甲處理材料 A 的行為先被 suspended 了。這時即便新的材料 B 已經準備好，但因爲工人甲還沒回過神來（resume），管路總容量已滿，工頭也只能先把材料 B 擱置（suspend）在一旁。</p><p>若是工人乙在這個時候來接水管，他可以立即從水桶拿到材料 A（replay cache）。不過接下來，他可要當個薪水小倫，畢竟要等工人甲回過神，講究的工頭才會願意把材料 B 丟出來。</p><p>過一會，姍姍來遲的工人甲終於回過神來，立即處理了材料 A。材料被所有工人摸過一輪，工頭終於可以安心放進擱置的材料 B，兩位工人一起領收。同時，材料 B 也可以化作歷史，取代材料 A 乖乖進桶（replay cache）了。</p><p>🔥 如果工頭不要這麼講究，可以設定為 BufferOverflow.DROP_OLDEST ，那麼每份新材料都會即時替換水桶內的舊材料，而不會阻塞水管。也許大家工作完一輪，工人甲才回神，此時水桶已經是材料 Z 了呢。</p><blockquote>#3 複雜題：拿掉水桶，加長水管，工頭也不再講究</blockquote><p>(replay = 0, extraBufferCapacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)</p><p>現在我們拿掉水桶，但加長水管，拿來存放一份沒被處理完的材料。沒有水桶，代表工頭不會為後來才來的工人提供任何舊材料（replay = 0），不過水管內可以多放一份沒被處理的材料（extraBufferCapacity = 1），工頭也不再強求每個人都要做完工作，會適時放掉舊材料（BufferOverflow.DROP_OLDEST）。</p><p>有點複雜，因此我們延續上一個例子。</p><p>無能的工人甲先來接水管，工頭放行材料 A 的時候他恰巧沒空，不過因為水管還有一個位置可以放沒被處理完的材料（extraBufferCapacity = 1），材料 A 就先放在水管的額外空間，等待工人甲回神。</p><p>這時候工人乙來接水管了，但按規定，他拿不到先前的材料 A（replay = 0），所以什麼事也不會發生。</p><p>倘若這時工頭要把材料 B 放進水管，會發生什麼事呢？</p><p>因為工人甲還是沒空，而管線的額外空間只能容納一份材料，工頭索性丟掉材料 A （DROP_OLDEST），改放材料 B 在水管中。同時，有空閒的工人乙可以即時領收到材料 B 。</p><p>過一陣子，工人甲回神後領走了材料 B。如此一來，材料 B 便也船過水無痕了（replay = 0）。</p><p>透過以上三個例子，稍微畫畫圖、消化過後，應該就更能夠了解 SharedFlow 的基本特性，他就是一個可以自行客製化的水管，可以捏成自己想要的樣貌。</p><p>而 StateFlow 其實就是繼承了 SharedFlow，再針對特定情境來改良（replay = 1, extra = 0, onBufferOverflow = BufferOverflow.DROP_OLDEST），來做到類似 LiveData 的型態。</p><p>這篇文章說比較多故事，下一篇會再實際介紹用法與注意事項。</p><p><a href="https://tzuxlin.medium.com/android-coroutines-hot-flow-2-3-b3f6451c275f">[Android] Coroutines Hot Flow：Show me the code.（2/3）</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a5f32752d10c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[AdMob] 用 GitHub 架設免費網站並上傳 app-ads.txt 文件]]></title>
            <link>https://tzuxlin.medium.com/admob-%E5%BF%AB%E9%80%9F%E6%9E%B6%E8%A8%AD%E7%B6%B2%E7%AB%99%E4%B8%A6%E4%B8%8A%E5%82%B3-app-ads-txt-%E6%96%87%E4%BB%B6-70eec611a35b?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/70eec611a35b</guid>
            <category><![CDATA[admob]]></category>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Fri, 28 Jan 2022 14:02:35 GMT</pubDate>
            <atom:updated>2022-01-28T16:48:47.337Z</atom:updated>
            <content:encoded><![CDATA[<p>最近寫的 Side Project 使用了 AdMob 的廣告模組，申請成功過後幾天，突然收到要求「添加或更新 app-ads.txt」的通知：</p><blockquote>您的 app-ads.txt 文件缺失或無效。為避免損失大量廣告收入，請添加或更新您的 app-ads.txt</blockquote><p>原來使用 AdMob 還需要準備一個開發人員網站，並且把 app-ads.txt 放在指定路徑，提供給 AdMob 檢索及驗證。</p><p>app-ads.txt 的產生以及設定方法 ，其實官方文件已經寫得非常清楚（參考資料：<a href="https://support.google.com/admob/answer/9363762?hl=zh-Hant">為您的應用程式設定 app-ads.txt 檔案</a>）。</p><p>但問題是，究竟該如何架設開發人員網站？官方文件只有淡淡表示：<strong>「<em>啊現在網路資源很多啦，要錢的免費的都有，你自己去找齁⋯⋯</em>」（by 翻譯蒟蒻）</strong></p><p>網頁小白如我，最後決定選擇最簡便，也完全不需要任何費用的方法：依靠 GitHub 啦！這篇文章就來分享我是怎麼做的吧。</p><h3><strong>在 GitHub 架設靜態網頁</strong></h3><p>流程非常簡單：</p><p>▼ 首先，在 GitHub 建立公開的 Repository</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xN-RM0QTzuqkL2lKMK85bA.png" /></figure><p>▼ 在 Repository 的設定頁面找到「Pages」，點擊「Choose a theme」，隨喜挑選一個喜歡的 theme。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mh7Xm_stWPV5bdVQgvSRJw.png" /></figure><p>▼ 選完 theme 之後，GitHub 會自動新增 index.md 的檔案到 gh-pages 分支，只要按 Commit 就可以了。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mb0amAj-MVFCjSnGLnPs2A.png" /></figure><p>▼ 一眨眼，陽春的網頁就架設完成啦！瀏覽網址會是：<br>https://{ GitHub 帳號 }.github.io/{ Repo 名稱 }/</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a4s4TjgP_RIBbaYdrPRjtQ.png" /><figcaption>根據 theme 產生的預設頁。如果你一心想投入資本主義的懷抱，那麼首頁其實放飛即可。（誤）</figcaption></figure><p>▼ 在 gh-pages 的分支新增 app-ads.txt ，就能夠透過這個網址來檢視文件囉： https://{ GitHub 帳號 }.github.io/{ Repo 名稱 }/app-ads.txt</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-ockhSmV04MYL2VwS_Jjbg.png" /><figcaption>上傳 app-ads.txt</figcaption></figure><p>接著就可以到「<strong>應用程式商店」</strong>設定開發人員網頁，並等待 AdMob 檢查。</p><p>AdMob 在檢索時，會自動在網域後面加上 app-ads.txt 。開發人員網址只需填寫： https://{ GitHub 帳號 }.github.io/{ Repo 名稱 }/。</p><p>…</p><p>…</p><p>…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bgKAFgPgM43NxdGXWyq9Qg.png" /></figure><p>…</p><p>…</p><p>…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/568/1*JZFyfcGWP4RR7kkwehFjgw.png" /></figure><h3>…！？？</h3><blockquote>等等，為何還是沒通過！ (ಥ_ಥ)</blockquote><p>仔細看了規定，原來 AdMob 會直接使用 Domain 網址檢索，所以檢查過程其實是會直接忽略網址後面的 Repo 名稱的。</p><p>因此實際上，文件必須存放在這個位置：<br> https://{ GitHub 帳號 }.github.io/app-ads.txt</p><p><strong>歐都Ｋ唷？</strong></p><p>▼ 來吧，只要把 GitHub 的 repo 名稱改為 {GitHub 帳號}.github.io，萬事就解決囉。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/682/1*u4JLYJ-7WofzbwUDmuuFLg.png" /><figcaption>修改 Repository 名稱</figcaption></figure><p>將 repo 名稱改為 domain 就不會多一層路徑了。回到「<strong>應用程式商店」</strong>，將網站網址修改為 https://{ GitHub 帳號 }.github.io/ 。</p><p>到這邊為止，恭喜設定完成。好的，這次是真的了。可以順利地被 AdMob 檢核囉！</p><blockquote>為啥不要一開始就說呢？<br>因為⋯⋯踩過一次很冤枉，寫下來紀錄一下嘛 😂</blockquote><p>接下來，祈禱糖果爸爸的降臨吧 (๑¯∀¯๑)（這其實才是最難的吧！）</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*byWVlAdIBrRlPs3dbCTa1Q.png" /><figcaption>蒸香Ｒ～</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=70eec611a35b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[取消 Coroutines （2/4）]]></title>
            <link>https://tzuxlin.medium.com/%E5%8F%96%E6%B6%88-coroutines-2-4-e11c0281a8f3?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e11c0281a8f3</guid>
            <category><![CDATA[coroutine]]></category>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[kotlin-coroutines]]></category>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Wed, 24 Feb 2021 07:29:18 GMT</pubDate>
            <atom:updated>2021-02-24T07:32:32.506Z</atom:updated>
            <content:encoded><![CDATA[<h3>Coroutines 的第一件事｜取消的那些眉角（2/4）</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*Y791PGvfrFtYlLl3FAFgGA.gif" /></figure><p>作為開發者，我們都知道要避免讓應用程式做太多額外的任務，來節省記憶體與資源。因此，使用 coroutine 時要確保有妥善管理它的生命週期，並且適時的取消它。接下來會循序漸境地介紹 coroutine cancellation。</p><p>在開始前，請先確保你看過並理解 <a href="https://tzuxlin.medium.com/coroutines-%E7%9A%84%E7%AC%AC%E4%B8%80%E4%BB%B6%E4%BA%8B-1-4-2af93b19dd00">Part 1</a> 的相關概念。</p><h3>呼叫 cancel()</h3><blockquote>取消 scope 也會取消 scope 內的所有 children 。</blockquote><p>執行多個 coroutines 之後，要一一追蹤並且取消是很困難的。為此我們可以改以取消整個 scope 來連帶取消所屬於該 scope 的所有 coroutines 任務。</p><pre>// assume we have a scope defined for this layer of the app<br>val job1 = scope.launch { … }<br>val job2 = scope.launch { … }</pre><pre>**scope.cancel()**</pre><blockquote>取消任一 child job 並不會影響同個階層的其他 children job</blockquote><p>有時候可能只需要取消特定 coroutine，呼叫 job1.cancel() 可以結束 job1 並且不會影響其他同階層的任務。</p><p>Coroutines 是透過拋出 CancellationException 來處理 cancellation 的。你也可以在呼叫 .cancel() 時帶入 CancellationException 的 instance 來交代取消原因。</p><pre>fun cancel(cause: CancellationException? = null)</pre><p>若沒有帶入 CancellationException 的 instance，會改採預設的方式（詳細的程式碼 <a href="https://github.com/Kotlin/kotlinx.coroutines/blob/master/kotlinx-coroutines-core/common/src/JobSupport.kt#L612">請見此</a>）：</p><pre>public override fun cancel(cause: CancellationException?) {<br>	cancelInternal(cause ?: defaultCancellationException())<br>}</pre><p>Coroutines 是藉由拋出 CancellationException 的機制來處理 cancellation。接下來會說明取消機制可能帶來的幾項 side effects。</p><p>在底層，child job 的 cancellation 會透過 exception 來通知 parent 。Parent 會判別 cause 的類型來決定是否需要處理當下的例外，假如取消的原因是 CancellationException，parent 就不會再另做處理。</p><blockquote>一旦取消 scope ，就不能在 cancelled scope 內執行任何新的 coroutines。</blockquote><p>若因為使用情境而選擇採用 KTX Libraries 提供的 scope，就不需要處理 cancellation 了。例如要在 ViewModel 使用 coroutines 可以採用 viewModelScope ，或是想要一個會附屬於特定生命週期的 scope，則可以採用 lifecycleScope。這兩種都是實作好的 CoroutineScope 物件，已經處理好 cancellation 的職責了，像是 ViewModel.onCleared() 時會自動取消 viewModelScope 的所有 coroutines。</p><h3>為何 coroutine 沒有停止？</h3><p>即便呼叫了 .cancel() ，並不代表 coroutine 任務會在當下立即停止。如果當下正在進行一些複雜運算，例如讀取複數檔案，是沒有辦法讓它自動停止的。</p><p>來看看一個簡單的範例：我們運用 coroutines 來每秒印兩次 Hello ，並且在 coroutine 運行一秒後取消它。</p><pre>import kotlinx.coroutines.*<br> <br>fun main(args: Array&lt;String&gt;) = runBlocking&lt;Unit&gt; {<br>   val startTime = System.currentTimeMillis()<br>    val job = launch (Dispatchers.Default) {<br>        var nextPrintTime = startTime<br>        var i = 0<br>        while (i &lt; 5) {<br>            // print a message twice a second<br>            if (System.currentTimeMillis() &gt;= nextPrintTime) {<br>                println(&quot;Hello ${i++}&quot;)<br>                nextPrintTime += 500L<br>            }<br>        }<br>    }<br>    delay(1000L)<br>    println(&quot;Cancel!&quot;)<br>    job.cancel()<br>    println(&quot;Done!&quot;)<br>}</pre><p>一步步來看：呼叫 launch 的同時，會創建一個 <strong><em>Active</em></strong> state 的 coroutine，coroutine 運行到 1000ms 的當下，可以看到 terminal 有這些訊息：</p><pre>Hello 0<br>Hello 1<br>Hello 2</pre><p>因為這時候呼叫了 job.cancel() ，coroutine 也會立即進入 <strong><em>Cancelling</em></strong> state。但是接下來， Hello 3 和 Hello 4 也會被印下來，直到整個任務結束才會正式取消進入 <strong><em>Cancelled</em></strong> state。</p><p>Coroutine 任務並不會在 cancel 呼叫的當下立即取消，因此，我們需要在程式碼中定期地去確認 coroutine 的狀態。</p><blockquote>Coroutine 不會在中途自動取消，因此需要與程式碼配合</blockquote><h3>讓你的 coroutine 任務可以被取消</h3><p>你必須確保你實作的 coroutine 任務是可以被取消的，除此之外，你也必須定期或是在長時間任務前去確認 coroutine 的狀態。若是需要讀取大量檔案，那麼就在讀取任一檔案前去確認 coroutine 有沒有被取消，藉此才不會將 CPU 資源浪費在過時的工作上。</p><pre>val job = launch {<br>    for(file in files) {<br>        // TODO check for cancellation<br>        readFile(file)<br>    }<br>}</pre><p>所有 kotlinx.coroutines 的 suspend function 都可以被取消，因此使用 withContext 或 delay 等功能，就不需要確認 cancel 狀態來停止任務執行或是拋出 CancellationException。但若非使用這些方法，請透過下面擇一方式，讓你的 coroutine 可以配合取消。</p><ul><li>檢查 job.isActive 或是 ensureActive()</li><li>使用 yield() 來執行其他任務</li></ul><h3>檢查 job 的狀態</h3><p>其中一個方法是在 while(i &lt; 5) 加入 coroutine state 的判斷：while (i &lt; 5 &amp;&amp; isActive)。</p><p>這樣一來任務只會在 coroutine active 時執行，在跳離 while 之後，如果要在 job cancelled 的情況下再執行特定任務，例如記下 log ，便可以再加入一層 !isActive 的判斷。</p><p>另外也可以使用 coroutines library 提供的 ensureActive() 方法：</p><pre>fun Job.ensureActive(): Unit {<br>    if (!isActive) {<br>         throw getCancellationException()<br>    }<br>}</pre><p>這個方法會在 !isActive 時立即拋出 exception，因此可以在 while loop 開始時先做檢查。</p><pre>while (i &lt; 5) {<br>    ensureActive()<br>    …<br>}</pre><p>藉由 ensureActive() 可以減少你的程式碼，不需要再去處理 if isActive 的判斷式；但因為會直接拋出例外，就不會像前一個例子那麼彈性，可以在取消之後再依據情況處理其他行為。</p><h3>使用 yield() 來執行其他任務</h3><p>如果你要執行的任務 容易耗費 CPU 資源 或是 佔據線程 ，或是你希望 線程可以執行其他任務，但不用使用新的線程 ，那麼 yield() 就是你的選擇。yield 完成第一個任務之後會確認狀態，假如 job 處於 <strong><em>Completed</em></strong> state 便拋出 CancellationException。如同 ensureActive() ，在執行週期性任務前可以先 call yield()。</p><h3>Job.join() vs Deferred.await() 的取消</h3><p>有兩種等待 coroutine 任務完成的方法：</p><ul><li>使用 join() 來等待 launch 返回的 job</li><li>使用 await() 來等待 async 返回的 deferred （也是一種 job）</li></ul><p>Job.join() 會暫停 coroutine 直到任務完成，搭配 job.cancel() 的預期行為是這樣子的：</p><ul><li>先呼叫 job.join() 再呼叫 job.cancel()，job 完成後才會中斷 coroutine。</li><li>在 job.join() 之後才呼叫 job.cancel() 是沒有效果的，因為 cancel 作用時 job 就已經完成了。</li></ul><p>需要回傳值時的情境，會使用 async 與 deferred 的搭配，並且在 coroutine 任務結束時，透過 Deferred.await() 來取得資料。Deferred 是 Job 的一種類型，也可以被取消。</p><p>要是對已經取消的 deferred 呼叫 await() ，會拋出 JobCancellationException 的例外。</p><pre>val deferred = async { … }<br>deferred.cancel()<br>val result = deferred.await() // throws JobCancellationException!</pre><p>Await 的職責是暫停 coroutine ，直到有結果可以回傳。因此在 cancelled 後才 call await ，也會導致例外拋出：JobCancellationException: Job was cancelled 。</p><p>另一方面，如果在 deferred.await() 之後才呼叫 deferred.cancel() 是沒有效果的，因為 cancel 作用時 coroutine 任務就已經完成了。</p><h3>處理與 cancellation 相關的 side effects</h3><p>假設你需要在 coroutine 中斷之後再做某些事情（如關掉使用的資源、記下 log 或是其他你需要的 cleanup 任務），那麼你可以採取這些方法：</p><h3>確認 !isActive</h3><p>如果你會定期確認 isActive 的狀態，那麼一旦跳出迴圈就可以準備清理資源了。</p><h3>Try-catch-finally</h3><p>我們可以使用 try/catch 來包住 suspend function，當 coroutine 中斷並拋出 CancellationException 之後，就會執行寫在 finally 內的 cleanup 方法。</p><pre>val job = launch {<br>   try {<br>      work()<br>   } catch (e: CancellationException){<br>      println(“Work cancelled!”)<br>    } finally {<br>      println(“Clean up!”)<br>    }<br>}</pre><pre>delay(1000L)<br>println(“Cancel!”)<br>job.cancel()<br>println(“Done!”)</pre><p>但要留意的是，如果 cleanup 任務也是 suspend function，上述的流程就沒有用了。一旦 coroutine 進入 <strong><em>Cancelling</em></strong> state，就不能執行 suspend 任務了。</p><p>為了在 <strong><em>Cancelling</em></strong> state 執行 suspend function，我們必須將 cleanup 任務轉交給 NonCancellableCoroutineContext ，如此一來便可以執行 suspend function ，coroutine 也會保持在 <strong><em>Cancelling</em></strong> state 直到任務結束。</p><pre>val job = launch {<br>   try {<br>      work()<br>   } catch (e: CancellationException){<br>      println(“Work cancelled!”)<br>    } finally {<br>      withContext(NonCancellable){<br>         delay(1000L) // or some other suspend fun <br>         println(“Cleanup done!”)<br>      }<br>    }<br>}<br>delay(1000L)<br>println(“Cancel!”)<br>job.cancel()<br>println(“Done!”)</pre><p>可以從 <a href="https://pl.kotl.in/ufZRQSa7o">這邊</a> 查看程式碼的運作方式。</p><h3>suspendCancellableCoroutine 與 invokeOnCancellation</h3><p>如果你是運用 suspendCoroutine 的方法來將 callback 轉換為 coroutines，那麼請使用 suspendCancellableCoroutine，並且用 continuation.invokeOnCancellation 來定義 coroutine 取消後要執行的任務：</p><pre>suspend fun work() {<br>   return suspendCancellableCoroutine { continuation -&gt;<br>       continuation.invokeOnCancellation { <br>          // do cleanup<br>       }<br>   // rest of the implementation<br>}</pre><p>請確保你實作的 coroutine 是可以被取消的，如此才能充分顯現 結構性並行 （structure concurrency）的優點，並確保不會做多餘的工作。</p><p>你可以使用 Jetpack 提供的 CoroutineScope：viewModelScope 以及 lifecycleScope 來為你在 scope 結束時也取消 coroutine 任務。</p><p>但要是使用了自己定義的 CoroutineScope，請確保你有將它與 Job 綁定，必且有在程式碼內去做 coroutine 狀態的相關確認，才能適時地取消任務以避免做多餘的事。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e11c0281a8f3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Coroutines 的第一件事（1/4）]]></title>
            <link>https://tzuxlin.medium.com/coroutines-%E7%9A%84%E7%AC%AC%E4%B8%80%E4%BB%B6%E4%BA%8B-1-4-2af93b19dd00?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/2af93b19dd00</guid>
            <category><![CDATA[kotlin]]></category>
            <category><![CDATA[coroutine]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Fri, 22 Jan 2021 08:11:08 GMT</pubDate>
            <atom:updated>2021-02-24T07:30:59.194Z</atom:updated>
            <content:encoded><![CDATA[<h3>Coroutines 的第一件事｜Scope, Job 與Context（1/4）</h3><p>這是官方在 Android Developers blog 上發表關於 Coroutines 系列文，將深入解釋 Coroutines 關於 cancellation 與 exceptions 的處理 —— 適時的 <strong>取消任務</strong> 可以避免因為做太多需求外的工作而浪費記憶體或資源，而合適的 <strong>例外處理</strong> 則可以改善使用者體驗。</p><p>在接下來的系列文開始以前 ，本篇將會釐清幾個 coroutine 的重要概念，包含：CoroutineScope、Job 以及 CoroutineContext。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*f_AKflkwgcQOUqX3TJJMLQ.png" /></figure><h3>CoroutineScope</h3><p>CoroutineScope 用以管理範圍內的 coroutine 行為，包括在該 scope 中呼叫 launch 或 async 所執行的 coroutine 任務。 scope 內現行的 coroutine 可以使用 scope.cancel() 來取消。</p><p>使用 CoroutineScope 的好處在於可以在特定 layer 內管理 coroutine 的生命週期，而 Android 也有官方的 KTX Library ，提供合適的 CoroutineScope給特定情況使用 ，例如 viewModelScope 和 lifecycleScope。</p><p>若你需要自行創建 CoroutineScope ，需要建構子 CoroutineContext ：</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/0222815ac97f15d0bc085f8938b956b2/href">https://medium.com/media/0222815ac97f15d0bc085f8938b956b2/href</a></iframe><h3>Job</h3><p>可以使用 Job 來管理 coroutine 的運行。任一透過 launch 或 async 創建的 coroutine 都會返回 Job instance ，用以識別單一 coroutine 並管理其生命週期。也可以選擇將 Job 傳入 CoroutineScope 來處理它的生命週期。</p><h3>CoroutineContext</h3><p>CoroutineContext 包含了定義 coroutine 行為的一系列元件。</p><ul><li>Job - 管理 coroutine 的生命週期</li><li>CoroutineDispatcher - 將任務分派給適合的 thread</li><li>CoroutineName - 為 coroutine 命名（適合 debug 用途）</li><li>CoroutineExceptionHandler - 處理過程中漏接的 exception，會在此系列文的第三篇提及</li></ul><p>新建立的 coroutine 會有什麼樣的 CoroutineContext 呢？</p><p>我們知道新的 coroutine 會有新的 job instance，剩下的部分則會繼承自其 parent 的 CoroutineContext 。Coroutines 是有階層關係的，其 parent 可以是 CoroutineScope 或是另外一個 coroutine，端看新的 coroutine 是在什麼狀況下建立。</p><p>下面這段程式碼是示範如何在 coroutine 內創建更多的 coroutine 任務。</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4fad73f7d6aa9e0f4e31d85d16ae3234/href">https://medium.com/media/4fad73f7d6aa9e0f4e31d85d16ae3234/href</a></iframe><pre>無論有多少 coroutines 階層，階層的根節點通常會是一個 CoroutineScope。</pre><h3>Job Lifecycle</h3><p>Job 有 <strong><em>New</em></strong>、<strong><em>Active</em></strong>、<strong><em>Completing</em></strong>、<strong><em>Completed</em></strong> 、<strong><em>Cancelling</em></strong> 以及 <strong><em>Cancelled</em></strong> 六個階段，但我們並不會直接使用這些階段，只會透過 isActive、isCancelled 以及 isCompleted 來得知 job 的狀態。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JD6r-EilravQc-lyoPAlBg.png" /></figure><p>如果 coroutine 正處於 <strong><em>Active</em></strong> 階段，coroutine 執行錯誤或是呼叫 job.cancel() 都會將 job 移至 <strong><em>Cancelling</em></strong> 階段（isActive = false, isCancelled = true）。一旦所有子任務都完成後便會進入 Cancelled 狀態（isCompleted = true）。</p><h3>關於 parent CoroutineContext …</h3><p>因為有任務階層的關係，任一 coroutine 都會有一個 parent ，這個 parent 可以是 CoroutineScope 或是另一個 coroutine。但是 coroutine 最後的 parent CoroutineContext ，有可能會不同於其 parent 的 CoroutineContext。聽起來有點難懂，可以先看下面這個計算方式：</p><blockquote><strong><em>Parent context</em></strong><em> = </em>Defaults<em> + </em>inherited <em>CoroutineContext + </em>arguments</blockquote><ul><li>有些元件會有預設值，例如 CoroutineDispatcher 預設為 <em>Dispatcher.Default</em> ，CoroutineName 預設為 <em>coroutine</em> 。</li><li>Child coroutine 的 CoroutineContext 會繼承自 parent 的 CoroutineContext。</li><li>帶入 coroutine builder 的參數對於 child CoroutineContext 的影響會優先於上述預設行為。</li></ul><blockquote><strong>📔 Note <br></strong>CoroutineContext 可以使用 + 來結合。因為 CoroutineContext 是一系列元件的總和，結合後的 CoroutineContext 會是右邊的被左邊複寫，例如：</blockquote><p>(Dispatchers.Main, “name”) + Dispatchers.IO = (Dispatchers.IO, “name”)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*87biMgFDu5DcEF2gsRML7w.png" /></figure><p>在 CoroutineScope 內執行的 coroutine 都至少會有以上四種要素，灰色部分是因為這邊宣告的 scope 未指定 CoroutineName ，使用了預設值。</p><p>現在我們知道新建立 coroutine 的 parent CoroutineContext 是什麼了，那麼實際上 coroutine 的 CoroutineContext 會是：</p><blockquote><strong><em>New coroutine context</em></strong><em> = </em>parent CoroutineContext<em> + </em>Job()</blockquote><p>假如我們在上圖這個 CoroutineScope 之中再建立新的 coroutine：</p><pre>val job = scope.launch(Dispatchers.IO) {<br>	// new coroutine<br>}</pre><p>階層關係就會變成下圖這樣：</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oM1g4NkgKlRqITuzYQc8Dg.png" /></figure><ul><li>Parent context 與 Coroutine context 的 Job 並不相同，因為每個 coroutine 都會個別返回一個新的 Job instance。</li><li>最後的 parent CoroutineContext 會改為 Dispatcher.IO 而非前一張圖的 Dispatcher.Main，是因為從 coroutine builder 帶入的參數會複寫原本的設定。</li><li>此外，這邊也會產生兩個不同的 Job instance。</li></ul><p>此系列文的 Part 3 將會介紹 CoroutineScope 中， Job 的另一種實作方法：SupervisorJob。SupervisorJob 可以特別針對 CoroutineScope 內的 exception 進行例外處理。因此 scope 內產生新的 coroutine 任務可以使用 SupervisorJob 作為 parent job，但要是 parent 是另一個 coroutine 的情況，parent job 就只會是 Job 了。</p><p>現在你已具備 coroutines 的基礎知識，可以透過接下來的系列文瞭解如何處理 coroutines cancellation（Part. 2） 與 exceptions （Part. 3），以及一些實務運用上的建議（Part. 4）。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2af93b19dd00" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[嘿，把你的委派委派給 Kotlin 吧]]></title>
            <link>https://tzuxlin.medium.com/%E5%98%BF-%E6%8A%8A%E4%BD%A0%E7%9A%84%E5%A7%94%E6%B4%BE%E5%A7%94%E6%B4%BE%E7%B5%A6-kotlin-%E5%90%A7-6b34860bdfd0?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b34860bdfd0</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Mon, 11 Jan 2021 06:09:03 GMT</pubDate>
            <atom:updated>2021-01-11T06:40:28.735Z</atom:updated>
            <content:encoded><![CDATA[<pre>本文譯自 <a href="https://medium.com/@yenerm?source=post_page-----ee0a0b21c52b--------------------------------">Murat Yener</a> 於 2020 年 10 月 8 日在 Android Developers 社群上發表的 <a href="https://medium.com/androiddevelopers/delegating-delegates-to-kotlin-ee0a0b21c52b">Delegating Delegates to Kotlin</a> ，以下將介紹使用 Kotlin 進行類別委派與屬性委派的方法，以及在底層的運作方式。如有任何問題或勘誤，歡迎在底下留言告知。</pre><h3>▍Kotlin Vocabulary: Delegates</h3><p>你知道嗎？<strong>有一種做事的方法，就是把任務交付給其他人完成 ⋯</strong>嗯、不是指甩鍋給朋友啦。我是指我們可以把某個物件要做的事情，<strong>委派給另外一個物件</strong>去完成。</p><p>委派（Delegation）這概念並不新鮮了。委派是一種軟體設計模式，可以讓物件將外部需求轉交給另一個物件，而代為處理需求的受委派方，會負責將結果提供給委派方。</p><p>Kotlin 支援 <strong>類別</strong>（class） 與 <strong>屬性</strong>（property） 的委派，並提供一些原生方法，使委派設計模式的運用更加容易上手。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*7PhlJurHGYDx56bPz6gp3A.jpeg" /><figcaption>善用 Kotlin Delegation ，把委派甩鍋給 Kotlin 吧。</figcaption></figure><h3>▍類別委派 （Class Delegates）</h3><p>假設有個需求是要讓 ArrayList 可以復原最後一個移除的 item （以下簡稱 <strong>trash</strong>），那麼只要讓 ArrayList 可以引用到 trash 就可以達成這個需求了。而實際上，要怎麼做到這件事呢？</p><p>有一種做法是去擴充 ArrayList 的類別。但這麼做是去擴充 ArrayList 的實體而非實作 MutableList 的介面，會與實體 ArrayList 的實作產生耦合。而要是可以直接去修改 MutableList.remove() 的方法，加入與最後刪除項目的 reference，並且將剩下有關 MutableList 的空實作都委派給其他物件，這樣會乾淨許多。</p><p>Kotlin 讓我們可以把其餘任務委派給內部產生的 ArrayList 實體，讓你客製你想要的行為。要做到第二種做法，可以使用強大的 by 。</p><pre>&lt;!-- Copyright 2019 Google LLC.<br>SPDX-License-Identifier: Apache-2.0 --&gt;</pre><pre>class ListWithTrash &lt;T&gt;(<br>   private val innerList: MutableList&lt;T&gt; = ArrayList&lt;T&gt;()<br>) : MutableCollection&lt;T&gt; by innerList {</pre><pre>   var deletedItem : T? = null</pre><pre>   override fun remove(element: T): Boolean {<br>       deletedItem = element<br>       return innerList.remove(element)<br>   }</pre><pre>   fun recover(): T? {<br>       return deletedItem</pre><pre>   }<br>}</pre><p>innerList 是接受 MutableList 介面實作委派的內部 ArrayList 實體 。藉由 by 這個方法，Kotlin 會產生 delegation code 並讓 innerList 作為被委派方，藉此將其餘的介面實作直接轉介給 innerList，使得 ListWithTrash 能夠完整實作 MutableList 介面的功能。這麼一來就可以輕易地客製化預期的行為了。</p><h3>▍Under the hood</h3><p>來看看底層是如何運作的。如果你看過由 ListWithTrash byte code 反編譯的 Java code，會發現 Kotlin 編譯器實際上創建了包裝函式（wrapper functions），來呼叫內部 ArrayList 物件的相應函式。</p><pre>public final class ListWithTrash implements Collection, KMutableCollection {<br>  @Nullable<br>  private Object deletedItem;<br>  private final List innerList;</pre><pre>  @Nullable<br>  public final Object getDeletedItem() {<br>     return this.deletedItem;<br>  }</pre><pre>  public final void setDeletedItem(@Nullable Object var1) {<br>     this.deletedItem = var1;<br>  }</pre><pre>  public boolean remove(Object element) {<br>     this.deletedItem = element;<br>     return this.innerList.remove(element);<br>  }</pre><pre>  @Nullable<br>  public final Object recover() {<br>     return this.deletedItem;<br>  }</pre><pre>  public ListWithTrash() {<br>     this((List)null, 1, (DefaultConstructorMarker)null);<br>  }</pre><pre>  public int getSize() {<br>     return this.innerList.size();<br>  }</pre><pre>  // $FF: bridge method<br>  public final int size() {<br>     return this.getSize();<br>  }<br>  //...and so on<br>}</pre><blockquote>註：Kotlin 編譯器是採用裝飾者模式（Decorator Pattern）來進行類別委派。裝飾者類別 會與 被裝飾者類別 共享同個介面。裝飾者類別 持有目標類別的引用，並且包裝（或裝飾）該介面的所有公開方法。</blockquote><p>當你無法繼承某些特定類別的時候，改採委派就是很好的方法。藉由類別委派，你的類別不會隸屬於其他的類別層次，但卻可以共享相同的介面，並且修飾內部物件的原生方法。這意味著你不需要冒著破壞公開 API 的風險，就可以簡單地修改實作。</p><h3>▍屬性委派（Delegating properties）</h3><p>除了委派類別， by 也可以用來委派屬性。受委派方會負責處理該屬性的 get ／ set 的方法，非常適合不同物件需要重用 getter 與 setter 邏輯的情況，讓你可以簡易擴充功能而不會使 backing field 太過複雜。</p><p>來看看這樣的使用情境：</p><pre><strong>class</strong> Person(<strong>var</strong> name: String, <strong>var</strong> lastname: String)</pre><p>假設我們今天有個有關於 Person 的類別，想要對於 name 的格式有些限制，我們希望在 set name 的時候去確保除了英文字首是大寫之外，其餘字母都要是小寫。此外，當 name 被更新的時候，也要自動增加修改次數的計數。</p><p>你可以這樣寫：</p><pre>&lt;!-- Copyright 2019 Google LLC.<br>SPDX-License-Identifier: Apache-2.0 --&gt;</pre><pre>class Person(name: String, var lastName: String) {<br>   var name: String = name<br>       set(value) {<br>           name = value.toLowerCase().capitalize()<br>           updateCount++<br>       }<br>   var updateCount = 0<br>}</pre><p>這樣寫也沒什麼錯，但若需求一改，也得在 lastName 變化時更新 updateCount 又該怎麼辦呢？雖然也可以將邏輯複製到 lastName 的 setter，但這樣 name 與 lastName 的 setter 基本上是做一樣的事情，就不該重複程式碼。</p><p>這種情況，轉而透過屬性委派將 getter 與 setter 委派給另一方，就可以解決了。如同委派類別，你也可以使用 by 來讓 Kotlin 幫你委派屬性：</p><pre>&lt;!-- Copyright 2019 Google LLC.<br>SPDX-License-Identifier: Apache-2.0 --&gt;</pre><pre>class Person(name: String, lastname: String) {<br>   var name: String by FormatDelegate()<br>   var lastname: String by FormatDelegate()<br>   var updateCount = 0<br>}</pre><p>現在已經把 name 和 lastname 這兩個屬性委派給 FormatDelegate 類別了，那就來看看 FormatDelegate 是怎麼寫的：</p><pre>&lt;!-- Copyright 2019 Google LLC.<br>SPDX-License-Identifier: Apache-2.0 --&gt;</pre><pre>class FormatDelegate : ReadWriteProperty&lt;Any?, String&gt; {<br>   private var formattedString: String = &quot;&quot;</pre><pre>   override fun getValue(<br>       thisRef: Any?,<br>       property: KProperty&lt;*&gt;<br>   ): String {<br>       return formattedString<br>   }</pre><pre>   override fun setValue(<br>       thisRef: Any?,<br>       property: KProperty&lt;*&gt;,<br>       value: String<br>   ) {<br>       formattedString = value.toLowerCase().capitalize()<br>   }<br>}</pre><p>如果你只想委派 getter ，需要去實作 ReadProperty&lt;Any?, String&gt;。在我們的情況是需要委派 getter 與 setter ，因此實作了 ReadWriteProperty&lt;Any?, String&gt; 。</p><p>你可能注意到了，getter 和 setter 方法裡面有兩個額外的參數，thisRef 和 KProperty&lt;*&gt; 。 thisRef 代表擁有屬性的物件，目的在需要檢查其他屬性或是呼叫其他類別的方法時，可以用來訪問物件本身。KProperty&lt;*&gt; 則用來訪問受委派方的屬性的 metadata 。回到需求，我們使用 thisRef 來訪問 updateCount，並且在這邊來增加它的數值。</p><h3>▍Under the hood</h3><p>來看看反編譯的 Java code 。Kotlin 編譯器讓 name 與 lastName 個別引用 FormatDelegate 物件，便能訪問到 getter／setter 的邏輯。編譯器產生 KProperty[] 來儲存受委託的屬性，你可以發現 index 0 和 1 分別為 name 和 lastname 所產生的 getter 和 setter。</p><pre>public final class Person {<br>  // $FF: synthetic field<br>  static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person.class), &quot;name&quot;, &quot;getName()Ljava/lang/String;&quot;)), (KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person.class), &quot;lastname&quot;, &quot;getlastname()Ljava/lang/String;&quot;))};<br>  @NotNull<br>  private final FormatDelegate name$delegate;<br>  @NotNull<br>  private final FormatDelegate lastname$delegate;<br>  private int updateCount;</pre><pre>  @NotNull<br>  public final String getName() {<br>     return this.name$delegate.getValue(this, $$delegatedProperties[0]);<br>  }</pre><pre>  public final void setName(@NotNull String var1) {<br>     Intrinsics.checkParameterIsNotNull(var1, &quot;&lt;set-?&gt;&quot;);<br>     this.name$delegate.setValue(this, $$delegatedProperties[0], var1);<br>  }<br>  //...<br>}</pre><p>這麼一來，任何的呼叫者透過一般屬性語法，就可以使用到受委派的屬性了。</p><pre>person.lastname = “Smith” // calls generated setter, increments count</pre><pre>println(“Update count is $person.count”)</pre><p>Kotlin 不僅支援委派，還提供原生委派方法，未來 <a href="https://medium.com/androiddevelopers">我們</a> 會在其他文章中進一步分享。</p><p>委派可以讓你將任務交給其他物件，減少重複程式碼。而透過 by 這個關鍵字來委派類別或是屬性，Kotlin 編譯器會在底層產生所需的程式碼，幫助你無縫地完成委派，也完全不會有影響公開 API 的風險。</p><p>簡單地說，Kotlin 官方會負責維護委派的程式碼，<strong>你只要把你的委派任務委派給 Kotlin 就好了</strong>。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b34860bdfd0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[歡迎使用 Noted !]]></title>
            <link>https://tzuxlin.medium.com/%E6%AD%A1%E8%BF%8E%E4%BD%BF%E7%94%A8-noted-e688856f07f1?source=rss-581e4a0aec0a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e688856f07f1</guid>
            <dc:creator><![CDATA[Connie Lin]]></dc:creator>
            <pubDate>Wed, 29 Jul 2020 08:27:40 GMT</pubDate>
            <atom:updated>2020-08-21T05:23:20.685Z</atom:updated>
            <content:encoded><![CDATA[<h3>歡迎使用 Noted !</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*tyOqOQPKrDGDZFun3FcAKg.png" /><figcaption>Noted!</figcaption></figure><p>看到任何你感興趣的網路文章，影片，地標，只要一鍵分享，就可以將它存入 Noted 。這樣一來，就不用再害怕找不到喜歡的網路內容囉！</p><h3><strong>如何儲存筆記？</strong></h3><p>點擊網路資源的「<strong>分享</strong>」按鈕，選擇「<strong>分享到 Noted! </strong>」，資料會自動匯入到 Noted! 裡面儲存。這樣一來你可以直接在 Noted! 裡面檢視內容，也可以跳轉到原始的頁面查看更完整的資訊。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/312/1*GQkwjR82mJblmLqqSC8uDQ.gif" /><figcaption>▲ 點擊內容來源的分享按鈕，分享到 <strong>Noted!</strong> 。</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qZNxjKi2E0-upndMdn9jJw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*REJLIB67Fnv6itA83-UAlA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IIAwEAazFmxIA291L_Yofw.png" /><figcaption>▲ 可以存下多種類型的筆記內容</figcaption></figure><h3>筆記可以怎麼整理？</h3><p><strong>「長按」</strong>筆記列表的筆記，可以進入綠色的編輯模式。你可以選擇 <strong>刪除筆記</strong>，或是將筆記 <strong>加入到分類板</strong>。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/306/1*8X9PPfvl-cDxexSfBBc2CA.gif" /><figcaption>▲ 將筆記加入分類板</figcaption></figure><h3>分類板是什麼呢？</h3><p>Noted! 期望能夠讓使用者依照主題去整理筆記資源。舉例來說，你可以創建一個「<strong>台北咖啡地圖</strong>」，裡面收藏相關的文章、影片或是地標。這樣一來，日後查看這個主題的資源時會更加有系統。</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*9CMNsyE2aofFlP5iOeLH0Q.png" /><figcaption>▲ 「台北咖啡地圖 📍☕️」分類板</figcaption></figure><p>另外，只要你將分類板設為公開，並且為文章加上主題性的標籤（例如下圖的「<strong><em>#Taipei」與</em></strong>「<strong><em>#coffee」</em></strong><em>等）</em>，就可以讓對這個主題有興趣的人也能瀏覽到你的分類板，並且加入他的收藏清單裡面。</p><p>你可以去探索感興趣的公開分類板，並且將喜歡的分類板加入收藏。</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e688856f07f1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>