prepare movie support

Author: DatL4g

composeApp/src/commonMain/kotlin/dev/datlag/mimasu/ui/navigation/detail/movie/MovieDetail.kt

@@ -1,5 +1,6 @@
 package dev.datlag.mimasu.ui.navigation.detail.movie
 
+import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
@@ -11,6 +12,7 @@ import androidx.compose.material3.LinearProgressIndicator
 import androidx.compose.material3.Scaffold
 import androidx.compose.material3.SnackbarHost
 import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
 import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.material3.rememberTopAppBarState
 import androidx.compose.runtime.Composable
@@ -21,13 +23,16 @@ import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.backhandler.BackHandler
 import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.input.nestedscroll.nestedScroll
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import dev.chrisbanes.haze.HazeState
 import dev.datlag.mimasu.tmdb.model.details.Movie
 import dev.datlag.mimasu.ui.custom.ErrorState
 import dev.datlag.mimasu.ui.navigation.detail.movie.components.MovieToolbar
 import dev.datlag.mimasu.ui.navigation.detail.movie.components.MovieWatchProviderFAB
+import dev.datlag.mimasu.ui.other.MovieState
+import dev.datlag.mimasu.ui.other.rememberMovieAvailability
 import dev.datlag.mimasu.ui.viewmodel.MovieViewModel
 import dev.datlag.mimasu.ui.viewmodel.accountViewModel
 import dev.datlag.mimasu.ui.viewmodel.kodeinViewModel
@@ -53,6 +58,10 @@ fun MovieDetail(
     val haze = remember { HazeState() }
     val listState = rememberLazyListState()
     val snackbarState = remember { SnackbarHostState() }
+    val movieAvailability = rememberMovieAvailability(
+        movie = movieState.getOrNull(),
+        initial = initial
+    )
 
     BackHandler(enabled = true) {
         onBack()
@@ -77,10 +86,22 @@ fun MovieDetail(
             )
         },
         floatingActionButton = {
-            MovieWatchProviderFAB(
-                movie = movieState.getOrNull(),
-                onWatchClick = onWatchClick
-            )
+            when (movieAvailability) {
+                is MovieState.Available -> {
+                    if (movieAvailability.state) {
+                        Text("Movie Available", modifier = Modifier.background(Color.Red), color = Color.White)
+                    } else {
+                        MovieWatchProviderFAB(
+                            movie = movieState.getOrNull(),
+                            onWatchClick = onWatchClick
+                        )
+                    }
+                }
+                else -> MovieWatchProviderFAB(
+                    movie = movieState.getOrNull(),
+                    onWatchClick = onWatchClick
+                )
+            }
         },
         snackbarHost = {
             SnackbarHost(hostState = snackbarState)

extension/src/androidMain/aidl/dev/datlag/mimasu/extension/IMovieProvider.aidl

@@ -0,0 +1,9 @@
+package dev.datlag.mimasu.extension;
+
+import dev.datlag.mimasu.extension.movie.MovieCallback;
+
+interface IMovieProvider {
+    const int VERSION = 1;
+
+    void requestMovieId(in byte[] request, in MovieCallback callback);
+}

extension/src/androidMain/aidl/dev/datlag/mimasu/extension/movie/MovieCallback.aidl

@@ -0,0 +1,5 @@
+package dev.datlag.mimasu.extension.movie;
+
+interface MovieCallback {
+    void onResult(in int id, in boolean available);
+}

extension/src/androidMain/kotlin/dev/datlag/mimasu/extension/ExtensionInitializer.kt

@@ -19,6 +19,11 @@ class ExtensionInitializer : Initializer<ExtensionInitializer.State> {
                 GlobalScope.launch {
                     it.initialize()
                 }
+            },
+            movieProviderAndroid = MovieProviderAndroid(context).also {
+                GlobalScope.launch {
+                    it.initialize()
+                }
             }
         ).also { result ->
             state.update { result }
@@ -31,7 +36,8 @@ class ExtensionInitializer : Initializer<ExtensionInitializer.State> {
 
     data class State(
         val updateProvider: UpdateProviderAndroid,
-        val showProviderAndroid: ShowProviderAndroid
+        val showProviderAndroid: ShowProviderAndroid,
+        val movieProviderAndroid: MovieProviderAndroid
     )
 
     companion object {
@@ -51,27 +57,40 @@ class ExtensionInitializer : Initializer<ExtensionInitializer.State> {
                 .showProviderAndroid
         }
 
+        fun getMovieProvider(context: Context): MovieProviderAndroid {
+            return state.value?.movieProviderAndroid ?: androidx.startup.AppInitializer
+                .getInstance(context)
+                .initializeComponent(ExtensionInitializer::class.java)
+                .movieProviderAndroid
+        }
+
         private fun nullableUpdateProvider(): UpdateProviderAndroid? = state.value?.updateProvider
 
         private fun nullableShowProvider(): ShowProviderAndroid? = state.value?.showProviderAndroid
 
+        private fun nullableMovieProvider(): MovieProviderAndroid? = state.value?.movieProviderAndroid
+
         fun unbindAll(context: Context) {
             nullableUpdateProvider()?.unbind(context)
             nullableShowProvider()?.unbind(context)
+            nullableMovieProvider()?.unbind(context)
         }
 
         suspend fun initialize(context: Context) {
             getShowProvider(context).initialize()
+            getMovieProvider(context).initialize()
         }
 
         suspend fun rebindAll(context: Context) {
             nullableUpdateProvider()?.rebind(context)
             nullableShowProvider()?.rebind(context)
+            nullableMovieProvider()?.rebind(context)
         }
 
         suspend fun rebindIfNoneAvailable(context: Context) {
             nullableUpdateProvider()?.rebindIfUnavailable(context)
             nullableShowProvider()?.rebindIfNoneAvailable(context)
+            nullableMovieProvider()?.rebindIfNoneAvailable(context)
         }
 
         fun rebindIfNoneAvailable(scope: CoroutineScope, context: Context) = scope.launch {

extension/src/androidMain/kotlin/dev/datlag/mimasu/extension/MovieProviderAndroid.kt

@@ -0,0 +1,75 @@
+package dev.datlag.mimasu.extension
+
+import android.content.Context
+import dev.datlag.mimasu.core.Virtual
+import dev.datlag.mimasu.extension.model.Movie
+import dev.datlag.mimasu.extension.service.MovieService
+import dev.datlag.tooling.async.suspendCatching
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.withContext
+
+class MovieProviderAndroid(private val context: Context) : MovieProvider {
+
+    private var extensionPackages = emptySet<String>()
+    private var services = bind(context)
+    private val boundServices: List<MovieService>
+        get() = services.filter { it.isBound }
+
+    override suspend fun initialize() {
+        if (extensionPackages.isEmpty()) {
+            extensionPackages = withContext(Dispatchers.IO) {
+                AIDLService.extensions(
+                    packageManager = context.packageManager,
+                    action = MovieService.ACTION
+                )
+            }
+        }
+    }
+
+    fun unbind(context: Context): Boolean {
+        return boundServices.map {
+            AIDLService.unbind(context, it)
+        }.all { it }
+    }
+
+    private fun bind(context: Context) = extensionPackages.map { packageName ->
+        MovieService(context).also { service ->
+            AIDLService.bind(context, service, packageName)
+        }
+    }
+
+    suspend fun rebind(context: Context) {
+        withContext(Dispatchers.Main) {
+            unbind(context)
+        }
+
+        extensionPackages = withContext(Dispatchers.Virtual ?: Dispatchers.IO) {
+            AIDLService.extensions(
+                packageManager = context.packageManager,
+                action = MovieService.ACTION
+            )
+        }
+        services = withContext(Dispatchers.Main) {
+            bind(context)
+        }
+    }
+
+    suspend fun rebindIfNoneAvailable(context: Context) {
+        if (boundServices.isEmpty()) {
+            rebind(context)
+        }
+    }
+
+    override suspend fun requestId(request: Movie.Request): Boolean = coroutineScope {
+        val bytes = request.toByteArray()
+
+        return@coroutineScope boundServices.map { async {
+            suspendCatching {
+                it.requestId(request.tmdbId, bytes)
+            }.getOrNull()
+        } }.awaitAll().filterNotNull().any { it }
+    }
+}

extension/src/androidMain/kotlin/dev/datlag/mimasu/extension/service/MovieService.kt

@@ -0,0 +1,52 @@
+package dev.datlag.mimasu.extension.service
+
+import android.content.Context
+import android.os.IBinder
+import dev.datlag.mimasu.extension.AIDLService
+import dev.datlag.mimasu.extension.IMovieProvider
+import dev.datlag.mimasu.extension.movie.MovieCallback
+import dev.datlag.tooling.scopeCatching
+import kotlinx.coroutines.suspendCancellableCoroutine
+import java.util.concurrent.ConcurrentHashMap
+
+internal class MovieService(context: Context) : AIDLService<IMovieProvider>(context) {
+    override val connectionAction: String = ACTION
+
+    private val mappedIds = ConcurrentHashMap<Int, Int>()
+
+    override fun bind(service: IBinder?): IMovieProvider? {
+        return scopeCatching {
+            IMovieProvider.Stub.asInterface(service)
+        }.getOrNull()
+    }
+
+    override fun onConnected(service: IMovieProvider) { }
+
+    override fun onDisconnected() { }
+
+    suspend fun requestId(tmdbId: Int?, bytes: ByteArray): Boolean = suspendCancellableCoroutine { continuation ->
+        if (!isBound) {
+            continuation.cancel()
+            return@suspendCancellableCoroutine
+        }
+
+        val connection = service ?: run {
+            continuation.cancel()
+            return@suspendCancellableCoroutine
+        }
+
+        connection.requestMovieId(bytes, object : MovieCallback.Stub() {
+            override fun onResult(id: Int, available: Boolean) {
+                if (tmdbId != null) {
+                    mappedIds[tmdbId] = id
+                }
+
+                continuation.resumeWith(Result.success(tmdbId != null && available))
+            }
+        })
+    }
+
+    companion object {
+        internal const val ACTION = "dev.datlag.mimasu.extension.IMovieProvider"
+    }
+}

extension/src/androidMain/kotlin/dev/datlag/mimasu/extension/service/ShowService.kt

@@ -11,11 +11,12 @@ import dev.datlag.mimasu.extension.show.StreamCallback
 import dev.datlag.tooling.scopeCatching
 import kotlinx.atomicfu.atomic
 import kotlinx.coroutines.suspendCancellableCoroutine
+import java.util.concurrent.ConcurrentHashMap
 
 internal class ShowService(context: Context) : AIDLService<IShowInfoProvider>(context) {
     override val connectionAction: String = ACTION
 
-    private val mappedIds by atomic<MutableMap<Int, Int>>(mutableMapOf())
+    private val mappedIds = ConcurrentHashMap<Int, Int>()
 
     override fun bind(service: IBinder?): IShowInfoProvider? {
         return scopeCatching {

extension/src/commonMain/kotlin/dev/datlag/mimasu/extension/MovieProvider.kt

@@ -0,0 +1,9 @@
+package dev.datlag.mimasu.extension
+
+import dev.datlag.mimasu.extension.model.Movie
+
+interface MovieProvider {
+
+    suspend fun initialize()
+    suspend fun requestId(request: Movie.Request): Boolean
+}

extension/src/commonMain/kotlin/dev/datlag/mimasu/extension/model/Movie.kt

@@ -0,0 +1,35 @@
+package dev.datlag.mimasu.extension.model
+
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.encodeToByteArray
+import kotlinx.serialization.protobuf.ProtoBuf
+
+@Serializable
+sealed interface Movie {
+
+    @Serializable
+    data class Request(
+        val tmdbId: Int? = null,
+        val imdbId: String? = null,
+        val wikidataId: String? = null,
+        val title: String? = null,
+        val originalTitle: String? = null,
+        val firstReleaseYear: Int? = null,
+        val isAnimation: Boolean? = null,
+        val appLocale: String? = null
+    ) : Movie {
+
+        @OptIn(ExperimentalSerializationApi::class)
+        fun toByteArray(): ByteArray {
+            return protobuf.encodeToByteArray(this)
+        }
+    }
+
+    companion object {
+        @OptIn(ExperimentalSerializationApi::class)
+        private val protobuf = ProtoBuf {
+            encodeDefaults = false
+        }
+    }
+}