bitmovin-player-react-native 1.20.1 → 1.21.0

package/plugin/src/withAppGradleDependencies.ts

@@ -9,16 +9,138 @@ export type PluginProps = {
   dependencies?: string[];
 };
 
+const DEFAULT_SPACING = '    ';
+
 const defaultProps: PluginProps = {
-  spacing: '    ',
+  spacing: DEFAULT_SPACING,
   dependencies: [],
 };
 
+const CORE_LIBRARY_DESUGARING_DEPENDENCY =
+  "coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.1.5'";
+const CORE_LIBRARY_DESUGARING_ARTIFACT = 'com.android.tools:desugar_jdk_libs';
+
+const hasCoreLibraryDesugaringEnabled = (contents: string) =>
+  /^\s*(?:set)?CoreLibraryDesugaringEnabled\b.*?\btrue\b/m.test(contents);
+
+const escapeRegExp = (value: string) =>
+  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const hasGradleDependencyDeclaration = (
+  contents: string,
+  dependency: string,
+  configuration?: string,
+  allowVersionSuffix = false
+) => {
+  const dependencyPattern = escapeRegExp(dependency);
+  const configurationPattern = configuration
+    ? escapeRegExp(configuration)
+    : '[A-Za-z_][\\w.-]*';
+  const versionSuffixPattern = allowVersionSuffix ? `(?::[^'"]*)?` : '';
+  const declarationPattern = new RegExp(
+    `^${configurationPattern}\\s*(?:\\(\\s*)?['"]${dependencyPattern}${versionSuffixPattern}['"]`
+  );
+  let nestedBlockDepth = 0;
+
+  return contents.split('\n').some((line) => {
+    const trimmedLine = line.trim();
+    if (trimmedLine.startsWith('//')) {
+      return false;
+    }
+
+    if (/^dependencies\s*\{$/.test(trimmedLine)) {
+      return false;
+    }
+
+    const isTopLevelDependency =
+      nestedBlockDepth === 0 && declarationPattern.test(trimmedLine);
+    const openBlockCount = (trimmedLine.match(/\{/g) || []).length;
+    const closeBlockCount = (trimmedLine.match(/\}/g) || []).length;
+    nestedBlockDepth += openBlockCount - closeBlockCount;
+
+    return isTopLevelDependency;
+  });
+};
+
+// Matches any pinned version of the desugaring artifact so an existing
+// declaration is never duplicated, even when it pins a different version.
+const hasCoreLibraryDesugaringDependency = (contents: string) =>
+  hasGradleDependencyDeclaration(
+    contents,
+    CORE_LIBRARY_DESUGARING_ARTIFACT,
+    'coreLibraryDesugaring',
+    true
+  );
+
+const replaceDisabledCoreLibraryDesugaringSettings = (contents: string) =>
+  contents
+    .replace(
+      /^(\s*)setCoreLibraryDesugaringEnabled\s*\(\s*false\s*\)/gm,
+      '$1setCoreLibraryDesugaringEnabled(true)'
+    )
+    .replace(
+      /^(\s*)coreLibraryDesugaringEnabled(\s*=\s*)false\b/gm,
+      '$1coreLibraryDesugaringEnabled$2true'
+    )
+    .replace(
+      /^(\s*)coreLibraryDesugaringEnabled(\s+)false\b/gm,
+      '$1coreLibraryDesugaringEnabled$2true'
+    );
+
+const ensureCoreLibraryDesugaringCompileOptions = (
+  contents: string,
+  spacing: string,
+  androidBlockStart: number,
+  androidPosition: number
+) => {
+  const androidBlock = contents.slice(androidBlockStart, androidPosition);
+  const updatedAndroidBlock =
+    replaceDisabledCoreLibraryDesugaringSettings(androidBlock);
+  const updatedContents = [
+    contents.slice(0, androidBlockStart),
+    updatedAndroidBlock,
+    contents.slice(androidPosition),
+  ].join('');
+  const updatedAndroidPosition =
+    androidPosition + updatedAndroidBlock.length - androidBlock.length;
+
+  if (hasCoreLibraryDesugaringEnabled(updatedAndroidBlock)) {
+    return updatedContents;
+  }
+
+  const compileOptionsRelativeStart = updatedAndroidBlock.search(
+    /^[^\S\r\n]*compileOptions\s*\{$/m
+  );
+  if (compileOptionsRelativeStart === -1) {
+    const compileOptions = [
+      `${spacing}compileOptions {`,
+      `${spacing}${spacing}setCoreLibraryDesugaringEnabled(true)`,
+      `${spacing}}`,
+      '',
+    ].join('\n');
+    return [
+      updatedContents.slice(0, updatedAndroidPosition),
+      compileOptions,
+      updatedContents.slice(updatedAndroidPosition),
+    ].join('');
+  }
+
+  const compileOptionsStart = androidBlockStart + compileOptionsRelativeStart;
+  const compileOptionsLineEnd =
+    updatedContents.indexOf('\n', compileOptionsStart) + 1;
+  return [
+    updatedContents.slice(0, compileOptionsLineEnd),
+    `${spacing}${spacing}setCoreLibraryDesugaringEnabled(true)\n`,
+    updatedContents.slice(compileOptionsLineEnd),
+  ].join('');
+};
+
 const withAppGradleDependencies: ConfigPlugin<PluginProps> = (
   config,
   props: PluginProps
 ) => {
   const combinedProps = { ...defaultProps, ...(props || {}) };
+  const spacing = combinedProps.spacing || DEFAULT_SPACING;
   config = withAppBuildGradle(config, (config) => {
     if (config.modResults.language !== 'groovy') {
       WarningAggregator.addWarningAndroid(
@@ -28,16 +150,6 @@ const withAppGradleDependencies: ConfigPlugin<PluginProps> = (
       return config;
     }
 
-    const deduplicatedDependencies = Array.from(
-      new Set(combinedProps.dependencies)
-    );
-    const filteredDependencies = deduplicatedDependencies.filter((dep) => {
-      return config.modResults.contents.indexOf(dep) === -1;
-    });
-    if (filteredDependencies.length === 0) {
-      return config;
-    }
-
     const androidBlockStart =
       config.modResults.contents.search(/^android \{$/m);
     if (androidBlockStart === -1) {
@@ -56,21 +168,6 @@ const withAppGradleDependencies: ConfigPlugin<PluginProps> = (
       );
       return config;
     }
-    const androidPosition = androidBlockStart + androidBlockEnd;
-    const compileOptions = [];
-    compileOptions.push(`${combinedProps.spacing}compileOptions {`);
-    compileOptions.push('\n');
-    compileOptions.push(
-      `${combinedProps.spacing}setCoreLibraryDesugaringEnabled(true)`
-    );
-    compileOptions.push('\n');
-    compileOptions.push(`${combinedProps.spacing}}`);
-    compileOptions.push('\n');
-    config.modResults.contents = [
-      config.modResults.contents.slice(0, androidPosition),
-      ...compileOptions,
-      config.modResults.contents.slice(androidPosition),
-    ].join('');
 
     const dependenciesBlockStart =
       config.modResults.contents.search(/^dependencies \{$/m);
@@ -92,22 +189,43 @@ const withAppGradleDependencies: ConfigPlugin<PluginProps> = (
       );
       return config;
     }
-    const position = dependenciesBlockStart + dependenciesBlockEnd;
-    let insertedDependencies: string[] = [];
-    insertedDependencies.push('\n');
-    insertedDependencies.push(
-      `${combinedProps.spacing}coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.1.5'`
+    const androidPosition = androidBlockStart + androidBlockEnd;
+    config.modResults.contents = ensureCoreLibraryDesugaringCompileOptions(
+      config.modResults.contents,
+      spacing,
+      androidBlockStart,
+      androidPosition
     );
-    insertedDependencies.push('\n');
-    filteredDependencies.forEach((dependency) => {
-      insertedDependencies.push(
-        `${combinedProps.spacing}implementation '${dependency}'\n`
-      );
-    });
-    insertedDependencies.push('\n');
+
+    const updatedDependenciesBlockStart =
+      config.modResults.contents.search(/^dependencies \{$/m);
+    const updatedFromDependencies = config.modResults.contents.substring(
+      updatedDependenciesBlockStart
+    );
+    const updatedDependenciesBlockEnd = updatedFromDependencies.search(/^\}$/m);
+    const position =
+      updatedDependenciesBlockStart + updatedDependenciesBlockEnd;
+    const dependenciesBlock = config.modResults.contents.slice(
+      updatedDependenciesBlockStart,
+      position
+    );
+    const dependencyDeclarations = [
+      ...(!hasCoreLibraryDesugaringDependency(dependenciesBlock)
+        ? [`${spacing}${CORE_LIBRARY_DESUGARING_DEPENDENCY}`]
+        : []),
+      ...Array.from(new Set(combinedProps.dependencies))
+        .filter(
+          (dependency) =>
+            !hasGradleDependencyDeclaration(dependenciesBlock, dependency)
+        )
+        .map((dependency) => `${spacing}implementation '${dependency}'`),
+    ];
+    if (dependencyDeclarations.length === 0) {
+      return config;
+    }
     config.modResults.contents = [
       config.modResults.contents.slice(0, position),
-      ...insertedDependencies,
+      `\n${dependencyDeclarations.join('\n')}\n`,
       config.modResults.contents.slice(position),
     ].join('');
     return config;

package/scripts/test-with-app-gradle-dependencies.js

@@ -0,0 +1,150 @@
+const assert = require('node:assert/strict');
+
+const withAppGradleDependencies =
+  require('../plugin/build/withAppGradleDependencies').default;
+
+const desugaringDependency =
+  "coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.1.5'";
+const featureDependency = 'com.example:feature:1.0';
+
+const countOccurrences = (contents, needle) =>
+  contents.split(needle).length - 1;
+
+const applyPlugin = async (contents, props = {}) => {
+  const config = withAppGradleDependencies(
+    { name: 'test-app', slug: 'test-app' },
+    props
+  );
+  const appBuildGradleMod = config.mods?.android?.appBuildGradle;
+  assert.equal(typeof appBuildGradleMod, 'function');
+
+  const result = await appBuildGradleMod({
+    ...config,
+    modResults: {
+      language: 'groovy',
+      contents,
+    },
+    modRequest: {
+      projectRoot: process.cwd(),
+      platform: 'android',
+      modName: 'appBuildGradle',
+      introspect: true,
+    },
+  });
+
+  return result.modResults.contents;
+};
+
+const gradle = ({
+  android = "    namespace 'com.example'",
+  dependencies = '',
+}) => `plugins {
+    id 'com.android.application'
+}
+
+android {
+${android}
+}
+
+dependencies {
+    implementation 'com.facebook.react:react-android'
+${dependencies}
+}
+`;
+
+const tests = [];
+
+const test = (name, run) => {
+  tests.push({ name, run });
+};
+
+test('adds desugaring when no feature dependencies are requested', async () => {
+  const result = await applyPlugin(gradle({}));
+
+  assert.match(result, /setCoreLibraryDesugaringEnabled\(true\)/);
+  assert.ok(result.includes(desugaringDependency));
+});
+
+test('inserts desugaring inside existing compileOptions with surrounding whitespace', async () => {
+  const result = await applyPlugin(
+    gradle({
+      android: `    namespace 'com.example'
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+    }`,
+    })
+  );
+
+  assert.equal(countOccurrences(result, 'compileOptions {'), 1);
+  assert.match(
+    result,
+    /compileOptions \{\n        setCoreLibraryDesugaringEnabled\(true\)\n        sourceCompatibility/
+  );
+  assert.doesNotMatch(
+    result,
+    /namespace 'com\.example'\n\n        setCoreLibraryDesugaringEnabled/
+  );
+});
+
+test('does not duplicate existing desugaring dependency', async () => {
+  const result = await applyPlugin(
+    gradle({
+      android: `    namespace 'com.example'
+    compileOptions {
+        setCoreLibraryDesugaringEnabled(true)
+    }`,
+      dependencies:
+        "    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.4'",
+    })
+  );
+
+  assert.equal(
+    countOccurrences(
+      result,
+      "coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs"
+    ),
+    1
+  );
+  assert.doesNotMatch(result, /desugar_jdk_libs:2\.1\.5/);
+});
+
+test('ignores comments and constraints when checking feature dependencies', async () => {
+  const result = await applyPlugin(
+    gradle({
+      dependencies: `    // ${featureDependency} is added by the plugin
+    constraints {
+        implementation('${featureDependency}') {
+            because 'pins the version when another dependency requests it'
+        }
+    }`,
+    }),
+    { dependencies: [featureDependency] }
+  );
+
+  assert.match(result, /implementation 'com\.example:feature:1\.0'/);
+});
+
+const run = async () => {
+  const failures = [];
+
+  for (const { name, run } of tests) {
+    try {
+      await run();
+      console.log(`PASS ${name}`);
+    } catch (error) {
+      failures.push({ name, error });
+      console.error(`FAIL ${name}`);
+      console.error(error);
+    }
+  }
+
+  if (failures.length > 0) {
+    process.exitCode = 1;
+  }
+};
+
+run().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/src/events.ts

@@ -746,6 +746,70 @@ export interface PlaybackSpeedChangedEvent extends Event {
   to: number;
 }
 
+/**
+ * The `line` field of a {@link SubtitleCueLayout}.
+ *
+ * `{ value: 'auto' }` defers placement to the renderer.
+ * `{ value: number; unit: 'percent' }` places the cue as a percentage of the viewport.
+ * `{ value: number; unit: 'line' }` places the cue by counting rendered text-line slots.
+ *
+ * @platform Android
+ */
+export type SubtitleCueLayoutLine =
+  | { value: 'auto' }
+  | { value: number; unit: 'line' | 'percent' };
+
+/**
+ * Normalized cue-box geometry.
+ *
+ * Values reflect native cue data including platform defaults, not only explicitly authored
+ * subtitle settings. Omitted fields were not set or not applicable for this cue.
+ *
+ * @platform Android
+ */
+export interface SubtitleCueLayout {
+  /**
+   * Cue position on the axis perpendicular to the text flow.
+   *
+   * For horizontal captions this controls vertical placement:
+   * - `{ value: 85, unit: 'percent' }` — 85% down the viewport.
+   * - `{ value: 12, unit: 'line' }` — 12 rendered text-line slots from the edge.
+   * - `{ value: 'auto' }` — renderer chooses placement.
+   *
+   * For vertical captions this controls horizontal placement.
+   */
+  line?: SubtitleCueLayoutLine;
+  /**
+   * Which edge of the cue box is anchored at `line`.
+   *
+   * Does not control text alignment inside the box; see `textAlign` for that.
+   */
+  lineAlign?: 'start' | 'center' | 'end';
+  /**
+   * Cue box position as a percentage of the viewport on the axis orthogonal to `line`.
+   *
+   * `'auto'` defers to the renderer.
+   */
+  position?: number | 'auto';
+  /**
+   * Which edge of the cue box is anchored at `position`.
+   */
+  positionAlign?: 'line-left' | 'center' | 'line-right' | 'auto';
+  /**
+   * Width of the cue box as a percentage of the viewport dimension in the writing direction.
+   */
+  size?: number;
+  /**
+   * Text alignment inside the cue box.
+   */
+  textAlign?: 'start' | 'center' | 'end' | 'left' | 'right';
+  /**
+   * Writing direction of the cue text; affects how `line`, `position`, and `size` are interpreted.
+   * When absent, the cue uses the default horizontal writing direction.
+   */
+  writingMode?: 'vertical-lr' | 'vertical-rl';
+}
+
 /**
  * Emitted when a subtitle entry transitions into the active status.
  */
@@ -759,13 +823,27 @@ export interface CueEnterEvent extends Event {
    */
   end: number;
   /**
-   * The textual content of this subtitle.
+   * Plain-text content of this subtitle.
    */
   text?: string;
   /**
-   * Data URI for image data of this subtitle.
+   * Data URI for image subtitle data.
    */
   image?: string;
+  /**
+   * HTML cue text, which may include styling generated by the native SDK.
+   *
+   * Treat as renderer input, not plain text.
+   *
+   * @platform Android
+   */
+  html?: string;
+  /**
+   * Normalized cue-box geometry.
+   *
+   * @platform Android
+   */
+  layout?: SubtitleCueLayout;
 }
 
 /**
@@ -781,13 +859,27 @@ export interface CueExitEvent extends Event {
    */
   end: number;
   /**
-   * The textual content of this subtitle.
+   * Plain-text content of this subtitle.
    */
   text?: string;
   /**
-   * Data URI for image data of this subtitle.
+   * Data URI for image subtitle data.
    */
   image?: string;
+  /**
+   * HTML cue text, which may include styling generated by the native SDK.
+   *
+   * Treat as renderer input, not plain text.
+   *
+   * @platform Android
+   */
+  html?: string;
+  /**
+   * Normalized cue-box geometry.
+   *
+   * @platform Android
+   */
+  layout?: SubtitleCueLayout;
 }
 
 /**

package/src/mediaControlConfig.ts

@@ -13,8 +13,6 @@ export interface MediaControlConfig {
    * For a detailed list of the supported features in the **default behavior**,
    * check the **Default Supported Features** section.
    *
-   * @remarks Enabling this flag will automatically treat {@link TweaksConfig.updatesNowPlayingInfoCenter} as `false`.
-   *
    * ## Limitations
    * ---
    * - Android: If an app creates multiple player instances, the player shown in media controls is the latest one created having media controls enabled.

package/src/modules/PlayerModule.ts

@@ -152,6 +152,11 @@ declare class PlayerModule extends NativeModule<PlayerModuleEvents> {
    */
   isAirPlayAvailable(nativeId: string): Promise<boolean | null>;
 
+  /**
+   * Display the AirPlay route selection menu for nativeId's player (iOS only).
+   */
+  showAirPlayTargetPicker(nativeId: string): Promise<void>;
+
   /**
    * Resolve nativeId's cast availability state.
    */

package/src/player.ts

@@ -395,6 +395,22 @@ export class Player extends NativeInstance<PlayerConfig> {
     return (await PlayerModule.isAirPlayAvailable(this.nativeId)) ?? false;
   };
 
+  /**
+   * Displays the system AirPlay route selection menu, allowing the user to pick
+   * an AirPlay target for the current playback.
+   *
+   * @platform iOS
+   */
+  showAirPlayTargetPicker = () => {
+    if (Platform.OS !== 'ios' || Platform.isTV) {
+      console.warn(
+        `[Player ${this.nativeId}] Method showAirPlayTargetPicker is only available on iOS (not Android/tvOS).`
+      );
+      return;
+    }
+    void PlayerModule.showAirPlayTargetPicker(this.nativeId);
+  };
+
   /**
    * @returns The currently selected audio track or `null`.
    */

package/src/tweaksConfig.ts

@@ -174,19 +174,6 @@ export interface TweaksConfig {
    * @platform Android
    */
   enableDrmLicenseRenewRetry?: boolean;
-  /**
-   * Determines whether `AVKit` should update Now Playing information automatically when using System UI.
-   *
-   * - If set to `false`, the automatic updates of Now Playing Info sent by `AVKit` are disabled.
-   *   This prevents interference with manual updates you may want to perform.
-   * - If set to `true`, the default behaviour is maintained, allowing `AVKit` to handle Now Playing updates.
-   *
-   * Default is `true`.
-   *
-   * @deprecated To enable the Now Playing information use {@link MediaControlConfig.isEnabled}
-   * @platform iOS
-   */
-  updatesNowPlayingInfoCenter?: boolean;
 
   /**
    * When switching between video formats (eg: adapting between video qualities)