2024年8月

LiveDataをFlowにリプレースしてみて得た知見（StateFlow、SharedFlow、Channel） #Android – Qiita

そもそも、なぜ上の３手法を試したのかというと、Claude か Gemini か ChatGTP に「サービスの状態をアクティビティに通知するにはどういう方法がある？」って聞いた結果、3 つの方法が回答にあったのがキッカケだった。

でサンプルを探して作っていくうちに、Flow をイベントバスに使う方法もあるらしいということを探し当てたのでやってみる。

MainActivity はこんな感じになりました。

package red.txn.service_flow

import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.Bundle
import android.os.IBinder
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import red.txn.service_flow.ui.theme.ServiceflowTheme

class MainActivity : ComponentActivity() {
    companion object {
        const val TAG = "MainActivity"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            ServiceflowTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Greeting(
                        name = "Android",
                        modifier = Modifier.padding(innerPadding)
                    )
                }
            }
        }

        // launch service
        Intent(this, FlowService::class.java).also { intent ->
            startService(intent)
        }
        Log.d(TAG,"service launched")

        val scope = CoroutineScope(Dispatchers.IO)
        scope.launch {
            FlowService.BUS.collect {
                Log.d(TAG, "Received data: $it")
            }
        }
    }
}

@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello $name!",
        modifier = modifier
    )
}

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    ServiceflowTheme {
        Greeting("Android")
    }
}

LiveData の observe が Flow の cllect に変わった感じで極端な変化はないですね。わかりやすい。

サービスのインスタンスなしでアクセスできているのは BUS がサービスの中で companion ojbect として定義されているからです。（理解あってる？）

package red.txn.service_flow

import android.app.Service
import android.content.Intent
import android.os.Binder
import android.os.IBinder
import android.util.Log
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.flow.receiveAsFlow
import kotlinx.coroutines.launch

class FlowService : Service() {
    companion object {
        val TAG = "FlowService"
        private var _BUS = Channel<String>()
        val BUS = _BUS.receiveAsFlow()
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        Log.d(TAG, "onBind")
        Thread {
            for (i in 1..2) {
                Thread.sleep(2000)
                updateData("データ$i")
                Log.d(TAG, "データ$i")
            }
        }.start()

        return START_STICKY
    }

    override fun onBind(intent: Intent): IBinder? {
        return null
    }

    fun updateData(data: String) {
        val scope = CoroutineScope(Dispatchers.IO)
        scope.launch {
            _BUS.send(data)
        }
    }
}

BUS と _BUS は companion object から普通のメンバに変えてもいいかも。

AIチャットボットの回答で漏れていた方法をたまたま見つけたわけですが、現時点では AI の回答が網羅性があり、正しい（妥当か）を判断するには読み取る人間側がそもそもその答え知らないといけない例として覚えておきたい。

AIチャットボットに限らず検索の回答から漏れているものが認識されない、つまり存在しないことにされてしまうのはとても考えさせられると感じてしまう。

参考

Flat パッケージでファイルアクセスできない時

すぐに忘れてしまうので、完全に自分用メモ。

flat パックも snap も基本的にはホスト PC を汚染しない発想なのでインストールしただけの状態ではファイルアクセスが制限されすぎている場合、調整する必要がある。

Flatseal というツールを使うとインストールした flat パッケージの一覧からファイルアクセス権を調整できる。

Android でサービスと通信する-Messenger編

3 部作の最後です、Messanger を使ってみます。

アクティビティとハンドラーの定義です。

package red.txn.service_messenger

import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.Bundle
import android.os.Handler
import android.os.IBinder
import android.os.Looper
import android.os.Message
import android.os.Messenger
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import red.txn.service_messenger.MainActivity.Companion.TAG
import red.txn.service_messenger.ui.theme.ServicemessengerTheme



class MainActivity : ComponentActivity() {
    companion object {
        const val TAG = "MainActivity"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            ServicemessengerTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Greeting(
                        name = "Android",
                        modifier = Modifier.padding(innerPadding)
                    )
                }
            }
        }

        // launch service
        Intent(this, MessengerService::class.java).also { intent ->
            bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
        }
    }

    private lateinit var messenger: Messenger
    private val serviceConnection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
            messenger = Messenger(service)
        }

        override fun onServiceDisconnected(name: ComponentName?) {
            Log.d(TAG, "onServiceDisconnected()")
        }
    }
}

class MessageHandler: Handler(Looper.getMainLooper()) {
    override fun handleMessage(msg: Message) {
        when(msg.what) {
            MESSAGE_FROM_SERVICE-> {
                // handle the response message
                Log.d(TAG, "received: ${msg.data.toString()}")
            }
            else -> {
                Log.d(TAG, "received other: $msg")
            }
        }
    }
}

//***
//*** compsable functions
//***
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello $name!",
        modifier = modifier
    )
}

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    ServicemessengerTheme {
        Greeting("Android")
    }
}

class Handler はサービスでも参照します。


package red.txn.service_messenger

import android.app.Service
import android.content.Intent
import android.os.Binder
import android.os.Handler
import android.os.IBinder
import android.os.Looper
import android.os.Message
import android.os.Messenger
import android.util.Log
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.cancel
import kotlinx.coroutines.launch


const val MESSAGE_FROM_SERVICE: Int = 2

class MessengerService : Service() {
    companion object {
        const val TAG = "MessengerService"
    }

    private val messenger = Messenger(MessageHandler())


    override fun onBind(intent: Intent): IBinder {
        Log.d(TAG, "onBind()")
        Thread {
            for (i in 1..2) {
                Thread.sleep(2000)
                sendMessageFromService()
                Log.d(TAG, "sendBroadcast: $i")
            }
        }.start()
        return MyBinder()
    }

    inner class MyBinder: Binder() {
        fun getService(): MessengerService = this@MessengerService
    }

    private fun sendMessageFromService() {
        val message = Message.obtain()
        message.what = MESSAGE_FROM_SERVICE
        message.data.putString("message", "Hello from MessengerService")
        //message.replyTo = messenger
        messenger.send(message)
    }

    override fun onDestroy() {
        super.onDestroy()
        Log.d(TAG, "onDestroy(")
    }
}

普通はメッセージの場合、普通は双方向通信に使うことが多いようですが、message.replyTo が空でも問題ないようです。

ちょっと試していないのでなんともいえませんがこのサービスももしかすると、startService() 起動に書き換えることができるかもしれません。その場合は Messenger を Activity に渡す必要があるので、LiveData の時と同じようにMessenger を companion object にする必要がありそうです。

Android でサービスと通信する-LiveData編

その 2 今度は LiveData を使ってみます。

LiveData を使うならこんな感じ

package red.txn.service_livedata

import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.Bundle
import android.os.IBinder
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import red.txn.service_livedata.ui.theme.ServicelivedataTheme

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            ServicelivedataTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Greeting(
                        name = "Android",
                        modifier = Modifier.padding(innerPadding)
                    )
                }
            }
        }

        // launch service
        Intent(this, LiveDataService::class.java).also { intent ->
            bindService(intent, connection, Context.BIND_AUTO_CREATE)
        }
    }

    private var bound = false
    private lateinit var liveDataService: LiveDataService

    private val connection = object : ServiceConnection {
        override fun onServiceConnected(name: ComponentName?, service: IBinder) {
            val binder = service as LiveDataService.MyBinder
            liveDataService = binder.getService()
            bound = true
            observeData()
        }
        override fun onServiceDisconnected(name: ComponentName?) {
            bound = false
        }
    }

    fun observeData() {
        liveDataService.BUS.observe(this) { newData ->
            Log.d("AAA", "Activity:" + newData.toString())
        }
    }
}


//***
//*** Composable functions
//***
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello $name!",
        modifier = modifier
    )
}

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    ServicelivedataTheme {
        Greeting("Android")
    }
}

bindService() でサービス起動をしているので少し様子が異なるが、バインドしたとき observeData() で監視している。とっても簡単

package red.txn.service_livedata

import android.app.Service
import android.content.Intent
import android.os.Binder
import android.os.IBinder
import android.util.Log
import androidx.lifecycle.MutableLiveData
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class LiveDataService : Service() {
    companion object {
        const val TAG = "LiveDataService"
    }

    val BUS = MutableLiveData<String>()

    override fun onBind(intent: Intent): IBinder {
        Log.d(TAG, "serviee onBind()")
        Thread {
            for (i in 1..2) {
                Thread.sleep(2000)
                updateData("データ$i")
                Log.d(TAG, "データ$i")
            }
        }.start()

        val scope = CoroutineScope(Dispatchers.IO)
        scope.launch {
            for (i in 1..2) {
                Thread.sleep(2000)
                updateData("データ2$i")
                Log.d(TAG, "データ2$i")
            }
        }
        return MyBinder()
    }
    inner class MyBinder: Binder() {
        fun getService(): LiveDataService = this@LiveDataService
    }

    private fun updateData(newData: String) {
        BUS.postValue(newData)
    }
}

AndroidManifest.xml は生成されたものなので省略。

startService（）でサービス起動したい場合は、こんなふうになった。

package red.txn.service_livedata

import android.content.ComponentName
import android.content.Context
import android.content.Intent
import android.content.ServiceConnection
import android.os.Bundle
import android.os.IBinder
import android.util.Log
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import red.txn.service_livedata.ui.theme.ServicelivedataTheme

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            ServicelivedataTheme {
                Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Greeting(
                        name = "Android",
                        modifier = Modifier.padding(innerPadding)
                    )
                }
            }
        }

        // launch service
        Intent(this, LiveDataService::class.java).also { intent ->
            startService(intent)
        }
        LiveDataService.BUS.observe(this) {
            Log.d("BUS change:", "Activity:" + it.toString())
        }
    }
}


//***
//*** Composable functions
//***
@Composable
fun Greeting(name: String, modifier: Modifier = Modifier) {
    Text(
        text = "Hello $name!",
        modifier = modifier
    )
}

@Preview(showBackground = true)
@Composable
fun GreetingPreview() {
    ServicelivedataTheme {
        Greeting("Android")
    }
}

サービスの方では LiveData を companion object に入れてインスタンスなしでも取得できるようにしている。

package red.txn.service_livedata

import android.app.Service
import android.content.Intent
import android.os.Binder
import android.os.IBinder
import android.util.Log
import androidx.lifecycle.MutableLiveData
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class LiveDataService : Service() {
    companion object {
        const val TAG = "LiveDataService"
        val BUS = MutableLiveData<String>()
    }

    override fun onBind(intent: Intent): IBinder? {
        return null
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        super.onStartCommand(intent, flags, startId)

        Thread {
            for (i in 1..2) {
                Thread.sleep(2000)
                BUS.postValue("newData: $i")
            }
        }

        return START_STICKY
    }
}

Gemini を使ってみているが、前の文脈からの続きの質問したら流れをぶった切って新しい話題のように回答するのやめてほしい。Claude のほうがその辺楽かも。

Android でサービスと通信する-ブロードキャスト編

今回は3部作になり、その１です。

何をしたいかというとサービスで何か変更した状態をActivityに知らせる方法を試してみます。

Gemini に聞いてみると 3 つの方法があるようです。