@erkamyaman/capacitor-foldable 7.0.0

package/android/src/main/kotlin/io/github/erkamyaman/foldable/DisplayModes.kt

@@ -0,0 +1,115 @@
+package io.github.erkamyaman.foldable
+
+import android.app.Activity
+import android.content.Context
+import android.view.View
+import androidx.core.content.ContextCompat
+import androidx.window.area.WindowAreaCapability
+import androidx.window.area.WindowAreaController
+import androidx.window.area.WindowAreaInfo
+import androidx.window.area.WindowAreaPresentationSessionCallback
+import androidx.window.area.WindowAreaSession
+import androidx.window.area.WindowAreaSessionCallback
+import androidx.window.area.WindowAreaSessionPresenter
+import androidx.window.core.ExperimentalWindowApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.onEach
+
+data class DisplayModeStatuses(val rearDisplay: String, val dualScreen: String) {
+    companion object {
+        val UNSUPPORTED = DisplayModeStatuses("unsupported", "unsupported")
+    }
+}
+
+@OptIn(ExperimentalWindowApi::class)
+class DisplayModes(private val activity: Activity) {
+
+    private val controller = WindowAreaController.getOrCreate()
+    private val executor = ContextCompat.getMainExecutor(activity)
+    private var rearDisplayArea: WindowAreaInfo? = null
+    private var rearDisplaySession: WindowAreaSession? = null
+    private var dualScreenSession: WindowAreaSessionPresenter? = null
+
+    fun statuses(): Flow<DisplayModeStatuses> =
+        controller.windowAreaInfos
+            .map { areas -> areas.firstOrNull { it.type == WindowAreaInfo.Type.TYPE_REAR_FACING } }
+            .onEach { rearDisplayArea = it }
+            .map { area ->
+                DisplayModeStatuses(
+                    rearDisplay = statusOf(area, WindowAreaCapability.Operation.OPERATION_TRANSFER_ACTIVITY_TO_AREA),
+                    dualScreen = statusOf(area, WindowAreaCapability.Operation.OPERATION_PRESENT_ON_AREA)
+                )
+            }
+            .distinctUntilChanged()
+
+    fun startRearDisplay(onStarted: () -> Unit, onEnded: (Throwable?) -> Unit) {
+        val area = rearDisplayArea ?: return onEnded(null)
+
+        controller.transferActivityToWindowArea(
+            area.token,
+            activity,
+            executor,
+            object : WindowAreaSessionCallback {
+                override fun onSessionStarted(session: WindowAreaSession) {
+                    rearDisplaySession = session
+                    onStarted()
+                }
+
+                override fun onSessionEnded(t: Throwable?) {
+                    rearDisplaySession = null
+                    onEnded(t)
+                }
+            }
+        )
+    }
+
+    fun stopRearDisplay() {
+        rearDisplaySession?.close()
+        rearDisplaySession = null
+    }
+
+    fun startDualScreen(createContent: (Context) -> View, onStarted: () -> Unit, onEnded: (Throwable?) -> Unit) {
+        dualScreenSession?.let { session ->
+            session.setContentView(createContent(session.context))
+            onStarted()
+            return
+        }
+
+        val area = rearDisplayArea ?: return onEnded(null)
+
+        controller.presentContentOnWindowArea(
+            area.token,
+            activity,
+            executor,
+            object : WindowAreaPresentationSessionCallback {
+                override fun onSessionStarted(session: WindowAreaSessionPresenter) {
+                    dualScreenSession = session
+                    session.setContentView(createContent(session.context))
+                    onStarted()
+                }
+
+                override fun onSessionEnded(t: Throwable?) {
+                    dualScreenSession = null
+                    onEnded(t)
+                }
+
+                override fun onContainerVisibilityChanged(isVisible: Boolean) = Unit
+            }
+        )
+    }
+
+    fun stopDualScreen() {
+        dualScreenSession?.close()
+        dualScreenSession = null
+    }
+
+    private fun statusOf(area: WindowAreaInfo?, operation: WindowAreaCapability.Operation): String =
+        when (area?.getCapability(operation)?.status) {
+            WindowAreaCapability.Status.WINDOW_AREA_STATUS_ACTIVE -> "active"
+            WindowAreaCapability.Status.WINDOW_AREA_STATUS_AVAILABLE -> "available"
+            WindowAreaCapability.Status.WINDOW_AREA_STATUS_UNAVAILABLE -> "unavailable"
+            else -> "unsupported"
+        }
+}

package/android/src/main/kotlin/io/github/erkamyaman/foldable/Foldable.kt

@@ -0,0 +1,189 @@
+package io.github.erkamyaman.foldable
+
+import android.app.Activity
+import android.content.Context
+import android.content.pm.PackageManager
+import android.graphics.Rect
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Build
+import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.window.layout.FoldingFeature
+import androidx.window.layout.SupportedPosture
+import androidx.window.layout.WindowInfoTracker
+import androidx.window.layout.WindowLayoutInfo
+import androidx.window.layout.WindowMetricsCalculator
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.emptyFlow
+import kotlin.math.roundToInt
+
+data class FoldBounds(val x: Int, val y: Int, val width: Int, val height: Int)
+
+data class FoldState(
+    val state: String,
+    val hingeOrientation: String? = null,
+    val hingeBounds: FoldBounds? = null,
+    val occludedBounds: FoldBounds? = null,
+    val isSeparating: Boolean = false,
+    val cameraBounds: List<FoldBounds> = emptyList(),
+    val posture: String = "flat"
+) {
+    companion object {
+        val FLAT = FoldState("flat")
+    }
+}
+
+data class SizeClass(
+    val horizontal: String,
+    val vertical: String,
+    val widthClass: String,
+    val heightClass: String
+)
+
+private const val MEDIUM_WIDTH_DP = 600f
+private const val EXPANDED_WIDTH_DP = 840f
+private const val LARGE_WIDTH_DP = 1200f
+private const val EXTRA_LARGE_WIDTH_DP = 1600f
+private const val MEDIUM_HEIGHT_DP = 480f
+private const val EXPANDED_HEIGHT_DP = 900f
+
+internal fun sizeClassOf(widthDp: Float, heightDp: Float) = SizeClass(
+    horizontal = if (widthDp >= MEDIUM_WIDTH_DP) "regular" else "compact",
+    vertical = if (heightDp >= MEDIUM_HEIGHT_DP) "regular" else "compact",
+    widthClass = when {
+        widthDp >= EXTRA_LARGE_WIDTH_DP -> "extraLarge"
+        widthDp >= LARGE_WIDTH_DP -> "large"
+        widthDp >= EXPANDED_WIDTH_DP -> "expanded"
+        widthDp >= MEDIUM_WIDTH_DP -> "medium"
+        else -> "compact"
+    },
+    heightClass = when {
+        heightDp >= EXPANDED_HEIGHT_DP -> "expanded"
+        heightDp >= MEDIUM_HEIGHT_DP -> "medium"
+        else -> "compact"
+    }
+)
+
+internal fun foldStateOf(
+    fold: FoldingFeature?,
+    density: Float,
+    offsetX: Int,
+    offsetY: Int,
+    cutouts: List<Rect> = emptyList()
+): FoldState {
+    val cameraBounds = cutouts.map { toCssPixels(it, density, offsetX, offsetY) }
+    fold ?: return FoldState.FLAT.copy(cameraBounds = cameraBounds)
+
+    val state = when (fold.state) {
+        FoldingFeature.State.HALF_OPENED -> "half-opened"
+        else -> "flat"
+    }
+
+    val orientation = when (fold.orientation) {
+        FoldingFeature.Orientation.HORIZONTAL -> "horizontal"
+        else -> "vertical"
+    }
+
+    val bounds = toCssPixels(fold.bounds, density, offsetX, offsetY)
+
+    val occluded = if (fold.occlusionType == FoldingFeature.OcclusionType.FULL) {
+        bounds
+    } else {
+        null
+    }
+
+    val posture = when {
+        fold.state != FoldingFeature.State.HALF_OPENED -> "flat"
+        fold.orientation == FoldingFeature.Orientation.HORIZONTAL -> "tabletop"
+        else -> "book"
+    }
+
+    return FoldState(state, orientation, bounds, occluded, fold.isSeparating, cameraBounds, posture)
+}
+
+private fun toCssPixels(rect: Rect, density: Float, offsetX: Int, offsetY: Int) = FoldBounds(
+    x = ((rect.left - offsetX) / density).roundToInt(),
+    y = ((rect.top - offsetY) / density).roundToInt(),
+    width = ((rect.right - rect.left) / density).roundToInt(),
+    height = ((rect.bottom - rect.top) / density).roundToInt()
+)
+
+class Foldable(private val activity: Activity, private val webView: View) {
+
+    private val tracker = WindowInfoTracker.getOrCreate(activity)
+    private val sensorManager = activity.getSystemService(Context.SENSOR_SERVICE) as SensorManager
+    private val hingeSensor: Sensor? =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            sensorManager.getDefaultSensor(Sensor.TYPE_HINGE_ANGLE)
+        } else {
+            null
+        }
+
+    fun isDeviceFoldable(): Boolean {
+        if (supportedPostures().isNotEmpty()) return true
+
+        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.R &&
+            activity.packageManager.hasSystemFeature(PackageManager.FEATURE_SENSOR_HINGE_ANGLE)
+    }
+
+    fun supportsTabletop(): Boolean = SupportedPosture.TABLETOP in supportedPostures()
+
+    fun hasHingeSensor(): Boolean = hingeSensor != null
+
+    fun sizeClass(): SizeClass {
+        val bounds = WindowMetricsCalculator.getOrCreate().computeCurrentWindowMetrics(activity).bounds
+        val density = activity.resources.displayMetrics.density
+        return sizeClassOf(bounds.width() / density, bounds.height() / density)
+    }
+
+    fun foldStates(): Flow<FoldState> =
+        combine(tracker.windowLayoutInfo(activity), webViewLayouts()) { info, _ -> toFoldState(info) }
+            .distinctUntilChanged()
+
+    private fun webViewLayouts(): Flow<Unit> = callbackFlow {
+        val listener = View.OnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> trySend(Unit) }
+        trySend(Unit)
+        webView.addOnLayoutChangeListener(listener)
+        awaitClose { webView.removeOnLayoutChangeListener(listener) }
+    }.conflate()
+
+    fun hingeAngles(): Flow<Float> {
+        val sensor = hingeSensor ?: return emptyFlow()
+
+        return callbackFlow {
+            val listener = object : SensorEventListener {
+                override fun onSensorChanged(event: SensorEvent) {
+                    if (event.values.isEmpty()) return
+                    trySend(event.values[0].coerceIn(0f, 360f))
+                }
+
+                override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) = Unit
+            }
+            sensorManager.registerListener(listener, sensor, SensorManager.SENSOR_DELAY_NORMAL)
+            awaitClose { sensorManager.unregisterListener(listener) }
+        }.distinctUntilChanged()
+    }
+
+    private fun supportedPostures(): List<SupportedPosture> =
+        runCatching { tracker.supportedPostures }.getOrDefault(emptyList())
+
+    private fun toFoldState(info: WindowLayoutInfo): FoldState {
+        val webViewOffset = IntArray(2).also(webView::getLocationInWindow)
+        val cutouts = ViewCompat.getRootWindowInsets(webView)?.displayCutout?.boundingRects.orEmpty()
+        return foldStateOf(
+            info.displayFeatures.filterIsInstance<FoldingFeature>().firstOrNull(),
+            activity.resources.displayMetrics.density,
+            webViewOffset[0],
+            webViewOffset[1],
+            cutouts
+        )
+    }
+}

package/android/src/main/kotlin/io/github/erkamyaman/foldable/FoldablePlugin.kt

@@ -0,0 +1,333 @@
+package io.github.erkamyaman.foldable
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.net.Uri
+import android.webkit.WebResourceRequest
+import android.webkit.WebResourceResponse
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.repeatOnLifecycle
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.conflate
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+import org.json.JSONObject
+import java.net.URL
+
+@CapacitorPlugin(name = "Foldable")
+class FoldablePlugin : Plugin() {
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+
+    private var implementation: Foldable? = null
+    private var displayModes: DisplayModes? = null
+    private var lastKnownState: FoldState? = null
+    private var hingeAngleJob: Job? = null
+    private var lastKnownAngle: Float? = null
+    private var lastSizeClass: SizeClass? = null
+    private var lastDisplayModes: DisplayModeStatuses? = null
+
+    override fun load() {
+        val activity = this.activity ?: return
+        val implementation = Foldable(activity, bridge.webView)
+        this.implementation = implementation
+        val displayModes = DisplayModes(activity)
+        this.displayModes = displayModes
+
+        lastSizeClass = implementation.sizeClass()
+        bridge.webView.addOnLayoutChangeListener { _, _, _, _, _, _, _, _, _ -> notifySizeClassIfChanged() }
+
+        val owner = activity as? LifecycleOwner ?: return
+        scope.launch {
+            owner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                implementation.foldStates().collect { state ->
+                    lastKnownState = state
+                    notifyListeners("foldStateChange", state.toJSObject())
+                }
+            }
+        }
+        scope.launch {
+            owner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                displayModes.statuses().collect { statuses ->
+                    lastDisplayModes = statuses
+                    notifyListeners(DISPLAY_MODE_CHANGE, statuses.toJSObject())
+                }
+            }
+        }
+    }
+
+    override fun handleOnDestroy() {
+        displayModes?.stopRearDisplay()
+        displayModes?.stopDualScreen()
+        scope.cancel()
+    }
+
+    @PluginMethod(returnType = PluginMethod.RETURN_NONE)
+    override fun addListener(call: PluginCall) {
+        super.addListener(call)
+        scope.launch { updateHingeAngleUpdates() }
+    }
+
+    @PluginMethod(returnType = PluginMethod.RETURN_NONE)
+    override fun removeListener(call: PluginCall) {
+        super.removeListener(call)
+        scope.launch { updateHingeAngleUpdates() }
+    }
+
+    @PluginMethod
+    override fun removeAllListeners(call: PluginCall) {
+        super.removeAllListeners(call)
+        scope.launch { updateHingeAngleUpdates() }
+    }
+
+    @PluginMethod
+    fun isDeviceFoldable(call: PluginCall) {
+        val implementation = this.implementation
+        call.resolve(
+            JSObject()
+                .put("foldable", implementation?.isDeviceFoldable() ?: false)
+                .put("supportsTabletop", implementation?.supportsTabletop() ?: false)
+        )
+    }
+
+    @PluginMethod
+    fun getFoldState(call: PluginCall) {
+        lastKnownState?.let {
+            call.resolve(it.toJSObject())
+            return
+        }
+
+        val implementation = this.implementation
+        if (implementation == null) {
+            call.resolve(FoldState.FLAT.toJSObject())
+            return
+        }
+
+        scope.launch {
+            val state = withTimeoutOrNull(FIRST_EMISSION_TIMEOUT_MS) {
+                implementation.foldStates().first()
+            } ?: FoldState.FLAT
+            lastKnownState = state
+            call.resolve(state.toJSObject())
+        }
+    }
+
+    @PluginMethod
+    fun getHingeAngle(call: PluginCall) {
+        lastKnownAngle?.let {
+            call.resolve(angleResult(it))
+            return
+        }
+
+        val implementation = this.implementation
+        if (implementation == null || !implementation.hasHingeSensor()) {
+            call.resolve(angleResult(null))
+            return
+        }
+
+        scope.launch {
+            val angle = withTimeoutOrNull(FIRST_EMISSION_TIMEOUT_MS) {
+                implementation.hingeAngles().firstOrNull()
+            }
+            call.resolve(angleResult(angle))
+        }
+    }
+
+    @PluginMethod
+    fun getSizeClass(call: PluginCall) {
+        val sizeClass = implementation?.sizeClass() ?: sizeClassOf(0f, 0f)
+        call.resolve(sizeClass.toJSObject())
+    }
+
+    @PluginMethod
+    fun getBarPlacement(call: PluginCall) {
+        call.resolve(JSObject().put("verticalBarEdge", JSONObject.NULL))
+    }
+
+    @PluginMethod
+    fun getDisplayModes(call: PluginCall) {
+        lastDisplayModes?.let {
+            call.resolve(it.toJSObject())
+            return
+        }
+
+        val displayModes = this.displayModes ?: return call.resolve(DisplayModeStatuses.UNSUPPORTED.toJSObject())
+
+        scope.launch {
+            val statuses = withTimeoutOrNull(FIRST_EMISSION_TIMEOUT_MS) {
+                displayModes.statuses().first()
+            } ?: DisplayModeStatuses.UNSUPPORTED
+            call.resolve(statuses.toJSObject())
+        }
+    }
+
+    @PluginMethod
+    fun startRearDisplay(call: PluginCall) {
+        val displayModes = this.displayModes ?: return call.unavailable("Rear display mode needs an activity.")
+
+        scope.launch {
+            when (lastDisplayModes?.rearDisplay) {
+                "active" -> call.resolve()
+                "available" -> {
+                    val settle = Settle(call, "Rear display mode")
+                    displayModes.startRearDisplay(settle::started, settle::ended)
+                }
+                else -> call.unavailable("Rear display mode is not available on this device right now.")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun stopRearDisplay(call: PluginCall) {
+        scope.launch {
+            displayModes?.stopRearDisplay()
+            call.resolve()
+        }
+    }
+
+    @PluginMethod
+    fun startDualScreen(call: PluginCall) {
+        val url = call.getString("url") ?: return call.reject("url is required.")
+        val displayModes = this.displayModes ?: return call.unavailable("Dual-screen mode needs an activity.")
+
+        scope.launch {
+            when (lastDisplayModes?.dualScreen) {
+                "available", "active" -> {
+                    val settle = Settle(call, "Dual-screen mode")
+                    displayModes.startDualScreen({ context -> dualScreenWebView(context, url) }, settle::started, settle::ended)
+                }
+                else -> call.unavailable("Dual-screen mode is not available on this device right now.")
+            }
+        }
+    }
+
+    @PluginMethod
+    fun stopDualScreen(call: PluginCall) {
+        scope.launch {
+            displayModes?.stopDualScreen()
+            call.resolve()
+        }
+    }
+
+    private fun notifySizeClassIfChanged() {
+        val sizeClass = implementation?.sizeClass() ?: return
+        if (sizeClass == lastSizeClass) return
+
+        lastSizeClass = sizeClass
+        notifyListeners(SIZE_CLASS_CHANGE, sizeClass.toJSObject())
+    }
+
+    private fun updateHingeAngleUpdates() {
+        if (!hasListeners(HINGE_ANGLE_CHANGE)) {
+            hingeAngleJob?.cancel()
+            hingeAngleJob = null
+            lastKnownAngle = null
+            return
+        }
+        if (hingeAngleJob != null) return
+
+        val implementation = this.implementation ?: return
+        val owner = activity as? LifecycleOwner ?: return
+        hingeAngleJob = scope.launch {
+            owner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                try {
+                    implementation.hingeAngles().conflate().collect { angle ->
+                        lastKnownAngle = angle
+                        notifyListeners(HINGE_ANGLE_CHANGE, angleResult(angle))
+                        delay(HINGE_ANGLE_FRAME_MS)
+                    }
+                } finally {
+                    lastKnownAngle = null
+                }
+            }
+        }
+    }
+
+    @SuppressLint("SetJavaScriptEnabled")
+    private fun dualScreenWebView(context: Context, url: String): WebView = WebView(context).apply {
+        settings.javaScriptEnabled = true
+        settings.domStorageEnabled = true
+        webViewClient = object : WebViewClient() {
+            override fun shouldInterceptRequest(view: WebView, request: WebResourceRequest): WebResourceResponse? =
+                bridge.localServer.shouldInterceptRequest(request)
+        }
+        loadUrl(resolveUrl(url))
+    }
+
+    private fun resolveUrl(url: String): String =
+        if (Uri.parse(url).scheme != null) url else URL(URL(bridge.appUrl), url).toString()
+
+    private inner class Settle(private val call: PluginCall, private val mode: String) {
+        private var settled = false
+
+        fun started() {
+            if (settled) return
+            settled = true
+            call.resolve()
+        }
+
+        fun ended(error: Throwable?) {
+            if (settled) return
+            settled = true
+            call.reject(error?.message ?: "$mode ended before it started.")
+        }
+    }
+
+    private fun angleResult(angle: Float?): JSObject =
+        JSObject().put("angle", angle?.toDouble() ?: JSONObject.NULL)
+
+    private fun FoldState.toJSObject(): JSObject = JSObject().apply {
+        put("state", state)
+        put("isSeparating", isSeparating)
+        put("posture", posture)
+        hingeOrientation?.let { put("hingeOrientation", it) }
+        hingeBounds?.let { put("hingeBounds", it.toJSObject()) }
+        occludedBounds?.let { put("occludedBounds", it.toJSObject()) }
+        if (cameraBounds.isNotEmpty()) {
+            put("cameraBounds", JSArray().apply { cameraBounds.forEach { put(it.toJSObject()) } })
+        }
+    }
+
+    private fun SizeClass.toJSObject(): JSObject = JSObject().apply {
+        put("horizontal", horizontal)
+        put("vertical", vertical)
+        put("widthClass", widthClass)
+        put("heightClass", heightClass)
+    }
+
+    private fun DisplayModeStatuses.toJSObject(): JSObject = JSObject().apply {
+        put("rearDisplay", rearDisplay)
+        put("dualScreen", dualScreen)
+    }
+
+    private fun FoldBounds.toJSObject(): JSObject = JSObject().apply {
+        put("x", x)
+        put("y", y)
+        put("width", width)
+        put("height", height)
+    }
+
+    private companion object {
+        const val FIRST_EMISSION_TIMEOUT_MS = 1_000L
+        const val HINGE_ANGLE_CHANGE = "hingeAngleChange"
+        const val HINGE_ANGLE_FRAME_MS = 16L
+        const val SIZE_CLASS_CHANGE = "sizeClassChange"
+        const val DISPLAY_MODE_CHANGE = "displayModeChange"
+    }
+}