@tiledev/sdk-apptile-live-selling 0.2.5 → 0.3.1

package/android/src/main/java/expo/modules/livepip/LivePipModule.kt

@@ -1,310 +0,0 @@
-package expo.modules.livepip
-
-import android.app.PictureInPictureParams
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.os.Build
-import android.os.Bundle
-import android.os.Handler
-import android.os.Looper
-import android.util.Rational
-import androidx.activity.ComponentActivity
-import androidx.annotation.RequiresApi
-import androidx.core.app.PictureInPictureModeChangedInfo
-import androidx.core.os.bundleOf
-import androidx.core.util.Consumer
-import androidx.lifecycle.Lifecycle
-import com.facebook.react.bridge.ReactContext
-import expo.modules.kotlin.modules.Module
-import expo.modules.kotlin.modules.ModuleDefinition
-
-/**
- * System picture-in-picture for the live stream, Android side.
- *
- * The API is the one iOS already speaks — `configure` / `setStream` / `setArmed` / `start` / `stop`
- * and four events — so `modules/live-pip/index.ts` and every caller stay platform-agnostic. What
- * happens underneath is not the same shape at all, and it is worth saying why.
- *
- * On iOS a PIP window is a piece of *content*: AVKit wants a sample-buffer layer, the engine's own
- * texture view is not one, and so `LivePipController` intercepts Zego's frames and re-enqueues them.
- * On Android a PIP window is the *activity itself*, scaled down. There is nothing to intercept — the
- * `ZegoTextureView` already on screen keeps drawing, because an activity in PIP is paused but still
- * visible and never reaches `onStop`. So this file is only ever asking the OS to shrink the window,
- * and the "show video, hide everything else" half of the job is React's: see `LivePipBubble`, which
- * fills the window with the stream while `pipMode` is `system`.
- *
- * That is also why `configure` and `setStream` are no-ops here rather than missing. They exist on
- * iOS to build and steer a frame pipeline this platform does not have, and the shared JS calls them
- * unconditionally.
- */
-class LivePipModule : Module() {
-  /** Whether backgrounding the app should hand over to a PIP window. Mirrors iOS's meaning exactly. */
-  private var armed = false
-
-  /**
-   * Our view of `Activity.isInPictureInPictureMode`, so a listener firing twice for one transition
-   * cannot emit `onPipStart` twice.
-   */
-  private var inPip = false
-
-  /**
-   * The activity the listener below is attached to, so it can be detached from the same one. An
-   * activity is recreated on a process restart or a config change we do not handle, and leaving the
-   * listener on a dead one means emitting events for a window nobody can see.
-   */
-  private var listeningTo: ComponentActivity? = null
-
-  private val pipListener = Consumer<PictureInPictureModeChangedInfo> { info ->
-    handleModeChange(info.isInPictureInPictureMode)
-  }
-
-  private val activity: ComponentActivity?
-    get() = appContext.currentActivity as? ComponentActivity
-
-  override fun definition() = ModuleDefinition {
-    Name("LivePip")
-
-    Events("onPipStart", "onPipStop", "onPipRestore", "onPipError")
-
-    /** No-op: nothing to configure without a frame pipeline. See the note at the top of the file. */
-    AsyncFunction("configure") {}
-
-    /** No-op: the window renders whatever the activity renders, so it needs no stream id. */
-    AsyncFunction("setStream") { _: String? -> }
-
-    AsyncFunction("setArmed") { next: Boolean -> setArmed(next) }
-
-    AsyncFunction("start") { start() }
-
-    AsyncFunction("stop") { stop() }
-
-    /**
-     * The pre-Android-12 half of auto-enter.
-     *
-     * From API 31 the OS does this itself off `setAutoEnterEnabled`, which is the only version that
-     * gets a genuinely seamless handoff — the transition happens with no app code in the loop, the
-     * same property iOS's `canStartPictureInPictureAutomaticallyFromInline` has. Below that, the last
-     * callback before the app leaves is this one, so it is where the request has to go. Not
-     * `onPause`: that also fires when the screen turns off, and a PIP window opened because someone
-     * pocketed their phone is not what "keep watching" means.
-     */
-    OnUserLeavesActivity {
-      if (armed && Build.VERSION.SDK_INT < Build.VERSION_CODES.S) start()
-    }
-
-    /**
-     * Fires when React Native pauses the host — which, entering PIP, happens either just before or
-     * just after the mode change, depending on the OS version and on whether auto-enter or an
-     * explicit call opened the window. Whichever order it lands in, the pause must not be the last
-     * word while a window is up, so the un-pause is re-applied from both sides.
-     */
-    OnActivityEntersBackground {
-      if (inPip) keepRenderingWhileInPip()
-    }
-
-    OnDestroy { detach() }
-  }
-
-  // MARK: - Entry points
-  //
-  // Each one re-tests the version rather than trusting the guard in the last one. The whole file
-  // below API 26 is unreachable — `enterPictureInPictureMode(params)` does not exist there — and a
-  // helper that establishes the version is invisible to lint's `NewApi` check, so the test has to
-  // sit where the call is or the release build fails on it.
-
-  private fun setArmed(next: Boolean) {
-    armed = next
-    if (!available()) {
-      // Only worth saying when something was actually asked for. A device without the feature is a
-      // live stream without picture-in-picture, which is still a working live stream — the in-app
-      // bubble carries on regardless.
-      if (next) fail("Picture-in-picture is not available on this device")
-      return
-    }
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
-    applyArmed(next)
-  }
-
-  private fun start() {
-    if (!available() || Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return
-    enterPip()
-  }
-
-  private fun stop() {
-    val activity = this.activity ?: return
-    activity.runOnUiThread {
-      if (!activity.isInPictureInPictureMode) return@runOnUiThread
-      leavePip(activity)
-    }
-  }
-
-  // MARK: - The window
-
-  @RequiresApi(Build.VERSION_CODES.O)
-  private fun applyArmed(next: Boolean) {
-    val activity = this.activity ?: return
-    activity.runOnUiThread {
-      attach(activity)
-      // Below API 31 there are no params to keep current — `enterPictureInPictureMode` carries them
-      // at the moment it is called, from `OnUserLeavesActivity` above.
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-        runCatching { activity.setPictureInPictureParams(params(autoEnter = next)) }
-          .onFailure { fail(it.message ?: "Could not arm picture-in-picture") }
-      }
-      // Deliberately *not* leaving an open window when disarmed. Disarming happens when the session
-      // ends — the host hangs up, or the viewer closes the window — and the two cases that reach
-      // here mid-window both end with the OS taking the window down anyway. The one that does not is
-      // a stream ending while the user watches in PIP, and yanking the whole app to the foreground
-      // for that is worse than leaving a window they can dismiss themselves: Android has no
-      // counterpart to `stopPictureInPicture()`, so foregrounding is the only "close" available.
-    }
-  }
-
-  @RequiresApi(Build.VERSION_CODES.O)
-  private fun enterPip() {
-    val activity = this.activity ?: return
-    activity.runOnUiThread {
-      if (activity.isInPictureInPictureMode) return@runOnUiThread
-      attach(activity)
-      // Not merely a failed transition: the OS also throws here when the user has revoked the app's
-      // picture-in-picture access in settings, which is a state nothing else reports.
-      runCatching { activity.enterPictureInPictureMode(params(autoEnter = armed)) }
-        .onFailure { fail(it.message ?: "Could not start picture-in-picture") }
-    }
-  }
-
-  /**
-   * Comes back out of the window and into the app.
-   *
-   * Android has no counterpart to `stopPictureInPicture()` — the only way out is to bring the task
-   * forward, which is exactly what the window's own expand button does. So this takes the expand
-   * path, and the listener below reports it as a restore rather than as a dismissal. iOS's `stop()`
-   * means the other thing (dismiss, and stop playing); nothing in the app calls either, and the JS
-   * wrapper documents the split.
-   */
-  private fun leavePip(activity: ComponentActivity) {
-    val intent = Intent(activity, activity.javaClass)
-      .addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-    runCatching { activity.startActivity(intent) }
-  }
-
-  /**
-   * Portrait 9:16 — the shape the hosts publish in, and the same one the in-app bubble uses. Without
-   * it the window inherits the activity's aspect ratio, which is the phone's, and the stream sits in
-   * a tall window with black down both sides.
-   */
-  @RequiresApi(Build.VERSION_CODES.O)
-  private fun params(autoEnter: Boolean): PictureInPictureParams {
-    val builder = PictureInPictureParams.Builder().setAspectRatio(Rational(9, 16))
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-      builder.setAutoEnterEnabled(autoEnter)
-      // Seamless resize is for content that can be re-laid-out mid-transition; a video surface
-      // cross-fades instead, which is what turning it off asks for — and the cross-fade is also what
-      // covers React swapping the app's UI for the full-bleed stream on the way in.
-      builder.setSeamlessResizeEnabled(false)
-    }
-    return builder.build()
-  }
-
-  /**
-   * API 26, not the manifest's own 24: picture-in-picture existed at 24 for Android TV only, and the
-   * params overload does not exist before O. The feature check covers the rest — a handset can ship
-   * without it, and low-memory devices routinely do.
-   */
-  private fun available(): Boolean {
-    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) return false
-    val activity = this.activity ?: return false
-    return activity.packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
-  }
-
-  // MARK: - Transitions
-
-  private fun attach(activity: ComponentActivity) {
-    if (listeningTo === activity) return
-    detach()
-    activity.addOnPictureInPictureModeChangedListener(pipListener)
-    listeningTo = activity
-    inPip = activity.isInPictureInPictureMode
-  }
-
-  private fun detach() {
-    listeningTo?.removeOnPictureInPictureModeChangedListener(pipListener)
-    listeningTo = null
-  }
-
-  private fun handleModeChange(isInPip: Boolean) {
-    if (isInPip == inPip) return
-    inPip = isInPip
-
-    if (isInPip) {
-      keepRenderingWhileInPip()
-      emit("onPipStart", Bundle())
-      return
-    }
-
-    /*
-     * Expanded, or closed? Both leave PIP and neither carries a flag saying which.
-     *
-     * The lifecycle answers it. Tapping the window's close button stops the activity *before* this
-     * callback runs, so the state has already fallen below STARTED; tapping expand brings it
-     * forward, so it is at least STARTED. This is the check Google's own PIP sample uses, and this
-     * callback is the last moment the two paths are still distinguishable.
-     */
-    val restored = listeningTo?.lifecycle?.currentState?.isAtLeast(Lifecycle.State.STARTED) ?: false
-    // Hand the lifecycle back. Restoring brings a real `onResume` along behind this, so only the
-    // close needs saying: there the activity stops without ever pausing again — it already paused on
-    // the way *into* the window — so nothing else would undo the un-pause below, and the app would
-    // go on rendering a screen no one is looking at.
-    if (!restored) resumeReactHostRendering(resumed = false)
-    // Same order as iOS: the restore first, then the stop it caused. The JS ignores a stop that
-    // carries `restored`, so the pair reads as one event on either platform.
-    if (restored) emit("onPipRestore", Bundle())
-    emit("onPipStop", bundleOf("restored" to restored))
-  }
-
-  /**
-   * Keeps React Native drawing while the app is in a picture-in-picture window.
-   *
-   * Without this the window is a still photograph. An activity in PIP is *paused* — visible, but
-   * paused — and React Native reads that pause as "nobody is looking": `FabricUIManager.onHostPause`
-   * stops `DispatchUIFrameCallback`, so mount items queue up and are never applied. React goes on
-   * computing perfectly correct layouts that never reach a native view.
-   *
-   * Measured, not inferred, and worth repeating if this ever regresses: an opaque full-window view
-   * rendered from JS reported the right layout through `onLayout` — the PIP window's own size, to the
-   * decimal — and did not draw a single pixel of itself. Layout was fine; mounting was frozen. (Do
-   * not reach for `dumpsys gfxinfo` to check this. Its frame counter sits still for a paused activity
-   * whether or not the window is updating, so it reads the same before and after this fix. Take a
-   * screenshot instead.)
-   *
-   * So the pause is contradicted for exactly as long as a window is up. That is not a trick — the
-   * app genuinely is on screen, and every native app in PIP keeps rendering. The cost is that JS
-   * sees `AppState: 'active'` while in PIP, which is also the truthful answer.
-   *
-   * Posted rather than called inline: this runs from inside React Native's own lifecycle dispatch,
-   * which is iterating its listener list at the time, and re-entering it there is how you get a
-   * concurrent modification out of a list nobody expected to change mid-loop.
-   */
-  private fun keepRenderingWhileInPip() = resumeReactHostRendering(resumed = true)
-
-  private fun resumeReactHostRendering(resumed: Boolean) {
-    val context = appContext.reactContext as? ReactContext ?: return
-    val activity = this.activity
-    Handler(Looper.getMainLooper()).post {
-      runCatching {
-        if (resumed) context.onHostResume(activity) else context.onHostPause()
-      }.onFailure { fail(it.message ?: "Could not keep rendering in picture-in-picture") }
-    }
-  }
-
-  private fun fail(message: String) = emit("onPipError", bundleOf("message" to message))
-
-  /**
-   * Best-effort by design. Closing the window finishes the activity and the React host goes with it,
-   * so the last event of a session is routinely sent into a runtime that is already tearing down.
-   * That throws, and it is not a failure worth reporting to anyone.
-   */
-  private fun emit(name: String, body: Bundle) {
-    runCatching { sendEvent(name, body) }
-  }
-}

package/app.plugin.js

@@ -1,3 +0,0 @@
-// Expo resolves a package's config plugin through this file. Points at the compiled plugin so a
-// consumer never needs TypeScript at prebuild time.
-module.exports = require('./plugin/build');

package/dist/pip.d.ts

@@ -1,14 +0,0 @@
-/**
- * System picture-in-picture — DEFAULT / non-native build (no-op).
- *
- * The window is an OS surface fed by a native module, so there is nothing web, the editor preview or
- * any Node runtime could do with it. Metro resolves `pip.native.ts` on iOS/Android and this file
- * everywhere else, which is also why a pure `tsc --noEmit` never needs `expo` installed.
- *
- * Keep every signature here in lock-step with `pip.native.ts`.
- */
-import type { LivePipController } from './sessionTypes';
-/** False off-device, so the session never arms a handover that cannot happen. */
-export declare const isLivePipSupported = false;
-export declare const livePip: LivePipController;
-//# sourceMappingURL=pip.d.ts.map

package/dist/pip.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pip.d.ts","sourceRoot":"","sources":["../src/pip.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAIxD,iFAAiF;AACjF,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC,eAAO,MAAM,OAAO,EAAE,iBAOrB,CAAC"}

package/dist/pip.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.livePip = exports.isLivePipSupported = void 0;
-const noop = async () => undefined;
-/** False off-device, so the session never arms a handover that cannot happen. */
-exports.isLivePipSupported = false;
-exports.livePip = {
-    configure: noop,
-    setStream: noop,
-    setArmed: noop,
-    start: noop,
-    stop: noop,
-    addListener: () => undefined,
-};
-//# sourceMappingURL=pip.js.map

package/dist/pip.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pip.js","sourceRoot":"","sources":["../src/pip.ts"],"names":[],"mappings":";;;AAWA,MAAM,IAAI,GAAG,KAAK,IAAmB,EAAE,CAAC,SAAS,CAAC;AAElD,iFAAiF;AACpE,QAAA,kBAAkB,GAAG,KAAK,CAAC;AAE3B,QAAA,OAAO,GAAsB;IACxC,SAAS,EAAE,IAAI;IACf,SAAS,EAAE,IAAI;IACf,QAAQ,EAAE,IAAI;IACd,KAAK,EAAE,IAAI;IACX,IAAI,EAAE,IAAI;IACV,WAAW,EAAE,GAAG,EAAE,CAAC,SAAS;CAC7B,CAAC"}

package/dist/pip.native.d.ts

@@ -1,11 +0,0 @@
-import type { LivePipController } from './sessionTypes';
-/**
- * Whether picture-in-picture can be used at all on this build.
- *
- * This says the module is *in the binary*, not that the device will grant a window — an Android
- * handset can ship without the picture-in-picture feature, and the user can revoke the permission in
- * settings. Those surface as `onPipError`, because they cannot be known until a window is asked for.
- */
-export declare const isLivePipSupported: boolean;
-export declare const livePip: LivePipController;
-//# sourceMappingURL=pip.native.d.ts.map

package/dist/pip.native.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pip.native.d.ts","sourceRoot":"","sources":["../src/pip.native.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,gBAAgB,CAAC;AAgBvE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,SAAiB,CAAC;AAEjD,eAAO,MAAM,OAAO,EAAE,iBAoBrB,CAAC"}

package/dist/pip.native.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.livePip = exports.isLivePipSupported = void 0;
-/**
- * System picture-in-picture — the native build.
- *
- * The window is an OS surface, not a React view, so the module below feeds it frames (iOS) or marks
- * the activity as PIP-capable (Android) and reports the transitions back. `plugin/` writes the
- * manifest and Info.plist entries this needs; without the config plugin the module loads and the OS
- * simply never grants a window.
- */
-const expo_1 = require("expo");
-/**
- * `requireOptionalNativeModule` rather than the throwing variant: a bundle running against a binary
- * built before this package was added should get a missing module, not a crash on import.
- */
-const native = (0, expo_1.requireOptionalNativeModule)('LivePip');
-/**
- * Whether picture-in-picture can be used at all on this build.
- *
- * This says the module is *in the binary*, not that the device will grant a window — an Android
- * handset can ship without the picture-in-picture feature, and the user can revoke the permission in
- * settings. Those surface as `onPipError`, because they cannot be known until a window is asked for.
- */
-exports.isLivePipSupported = native != null;
-exports.livePip = {
-    configure: async () => {
-        await (native === null || native === void 0 ? void 0 : native.configure());
-    },
-    setStream: async (streamId) => {
-        await (native === null || native === void 0 ? void 0 : native.setStream(streamId));
-    },
-    setArmed: async (armed) => {
-        await (native === null || native === void 0 ? void 0 : native.setArmed(armed));
-    },
-    start: async () => {
-        await (native === null || native === void 0 ? void 0 : native.start());
-    },
-    stop: async () => {
-        await (native === null || native === void 0 ? void 0 : native.stop());
-    },
-    addListener: (event, listener) => {
-        const subscription = native === null || native === void 0 ? void 0 : native.addListener(event, listener);
-        return subscription ? () => subscription.remove() : undefined;
-    },
-};
-//# sourceMappingURL=pip.native.js.map

package/dist/pip.native.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pip.native.js","sourceRoot":"","sources":["../src/pip.native.ts"],"names":[],"mappings":";;;AAAA;;;;;;;GAOG;AACH,+BAAsE;AAYtE;;;GAGG;AACH,MAAM,MAAM,GAAG,IAAA,kCAA2B,EAAsB,SAAS,CAAC,CAAC;AAE3E;;;;;;GAMG;AACU,QAAA,kBAAkB,GAAG,MAAM,IAAI,IAAI,CAAC;AAEpC,QAAA,OAAO,GAAsB;IACxC,SAAS,EAAE,KAAK,IAAI,EAAE;QACpB,MAAM,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,SAAS,EAAE,CAAA,CAAC;IAC5B,CAAC;IACD,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE;QAC5B,MAAM,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,SAAS,CAAC,QAAQ,CAAC,CAAA,CAAC;IACpC,CAAC;IACD,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QACxB,MAAM,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,QAAQ,CAAC,KAAK,CAAC,CAAA,CAAC;IAChC,CAAC;IACD,KAAK,EAAE,KAAK,IAAI,EAAE;QAChB,MAAM,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,KAAK,EAAE,CAAA,CAAC;IACxB,CAAC;IACD,IAAI,EAAE,KAAK,IAAI,EAAE;QACf,MAAM,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,IAAI,EAAE,CAAA,CAAC;IACvB,CAAC;IACD,WAAW,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE;QAC/B,MAAM,YAAY,GAAG,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC1D,OAAO,YAAY,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAChE,CAAC;CACF,CAAC"}

package/expo-module.config.json

@@ -1,9 +0,0 @@
-{
-  "platforms": ["apple", "android"],
-  "apple": {
-    "modules": ["LivePipModule"]
-  },
-  "android": {
-    "modules": ["expo.modules.livepip.LivePipModule"]
-  }
-}

package/ios/LivePip.podspec

@@ -1,20 +0,0 @@
-Pod::Spec.new do |s|
-  s.name           = 'LivePip'
-  s.version        = '1.0.0'
-  s.summary        = 'System picture-in-picture for the Zego live stream'
-  s.description    = 'Feeds Zego custom-render frames into an AVPictureInPictureController.'
-  s.author         = 'Apptile'
-  s.homepage       = 'https://apptile.io'
-  s.license        = 'MIT'
-  # AVPictureInPictureController only accepts a sample-buffer content source from iOS 15.
-  s.platforms      = { :ios => '15.1' }
-  s.source         = { git: '' }
-  s.static_framework = true
-
-  s.dependency 'ExpoModulesCore'
-  # Same pod the React Native wrapper pulls in, so this resolves to the one installed engine
-  # rather than a second copy.
-  s.dependency 'ZegoExpressEngine'
-
-  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
-end