spactureai-mobile-player 1.0.30

package/nitrogen/generated/shared/c++/onVolumeChangeData.hpp

@@ -0,0 +1,87 @@
+///
+/// onVolumeChangeData.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::unifiedplayer {
+
+  /**
+   * A struct which can be represented as a JavaScript object (onVolumeChangeData).
+   */
+  struct onVolumeChangeData final {
+  public:
+    double volume     SWIFT_PRIVATE;
+    bool muted     SWIFT_PRIVATE;
+
+  public:
+    onVolumeChangeData() = default;
+    explicit onVolumeChangeData(double volume, bool muted): volume(volume), muted(muted) {}
+
+  public:
+    friend bool operator==(const onVolumeChangeData& lhs, const onVolumeChangeData& rhs) = default;
+  };
+
+} // namespace margelo::nitro::unifiedplayer
+
+namespace margelo::nitro {
+
+  // C++ onVolumeChangeData <> JS onVolumeChangeData (object)
+  template <>
+  struct JSIConverter<margelo::nitro::unifiedplayer::onVolumeChangeData> final {
+    static inline margelo::nitro::unifiedplayer::onVolumeChangeData fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::unifiedplayer::onVolumeChangeData(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "volume"))),
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "muted")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::unifiedplayer::onVolumeChangeData& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "volume"), JSIConverter<double>::toJSI(runtime, arg.volume));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "muted"), JSIConverter<bool>::toJSI(runtime, arg.muted));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "volume")))) return false;
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "muted")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/package.json

@@ -0,0 +1,180 @@
+{
+  "name": "spactureai-mobile-player",
+  "version": "1.0.30",
+  "description": "Spacture AI Mobile Player",
+  "source": "./src/index.tsx",
+  "main": "./lib/module/index.js",
+  "types": "./lib/typescript/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/typescript/src/index.d.ts",
+      "default": "./lib/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "nitrogen",
+    "nitro.json",
+    "*.podspec",
+    "react-native.config.js",
+    "!ios/build",
+    "!android/build",
+    "!android/gradle",
+    "!android/gradlew",
+    "!android/gradlew.bat",
+    "!android/local.properties",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!**/.*"
+  ],
+  "scripts": {
+    "example": "yarn workspace react-native-unified-player-example",
+    "test": "jest",
+    "typecheck": "tsc",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "prepare": "bob build",
+    "prepare-publish": "yarn clean && yarn prepare",
+    "release": "release-it",
+    "specs": "nitrogen"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Spacture-AI/react-native-unified-player.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/Spacture-AI/react-native-unified-player/issues"
+  },
+  "homepage": "https://github.com/Spacture-AI/react-native-unified-player#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@commitlint/config-conventional": "^19.6.0",
+    "@eslint/compat": "^1.2.7",
+    "@eslint/eslintrc": "^3.3.0",
+    "@eslint/js": "^9.22.0",
+    "@evilmartians/lefthook": "^1.5.0",
+    "@expo/config-plugins": "^54.0.4",
+    "@react-native/eslint-config": "^0.78.0",
+    "@release-it/conventional-changelog": "^8.0.0",
+    "@types/jest": "^29.5.5",
+    "@types/react": "^19.0.0",
+    "commitlint": "^19.6.1",
+    "del-cli": "^5.1.0",
+    "eslint": "^9.22.0",
+    "eslint-config-prettier": "^10.1.1",
+    "eslint-plugin-prettier": "^5.2.3",
+    "jest": "^29.7.0",
+    "nitrogen": "^0.35.0",
+    "prettier": "^3.0.3",
+    "react": "19.0.0",
+    "react-native": "0.78.2",
+    "react-native-builder-bob": "^0.40.6",
+    "react-native-nitro-modules": "^0.35.0",
+    "release-it": "^17.10.0",
+    "turbo": "^1.10.7",
+    "typescript": "^5.2.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": ">=0.35.0"
+  },
+  "workspaces": [
+    "example"
+  ],
+  "packageManager": "yarn@3.6.1",
+  "jest": {
+    "preset": "react-native",
+    "modulePathIgnorePatterns": [
+      "<rootDir>/example/node_modules",
+      "<rootDir>/lib/"
+    ]
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release ${version}",
+      "tagName": "v${version}",
+      "requireCleanWorkingDir": false,
+      "push": true,
+      "pushArgs": [
+        "--force-with-lease"
+      ]
+    },
+    "npm": {
+      "publish": true,
+      "publishPath": "."
+    },
+    "github": {
+      "release": true,
+      "autoGenerate": true
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": {
+          "name": "angular"
+        },
+        "ignoreRecommendedBump": true
+      }
+    },
+    "hooks": {
+      "before:npm:publish": "yarn prepare-publish"
+    }
+  },
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
+  "create-react-native-library": {
+    "type": "legacy-view",
+    "languages": "kotlin-objc",
+    "version": "0.49.8"
+  },
+  "codegenConfig": {
+    "name": "RNCVideoViewSpec",
+    "type": "components",
+    "jsSrcsDir": "src/spec/fabric",
+    "android": {
+      "javaPackageName": "com.facebook.react.viewmanagers"
+    }
+  }
+}

package/react-native.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        packageImportPath: 'import com.unifiedplayer.react.VideoPackage;',
+        packageInstance: 'new VideoPackage()',
+      },
+    },
+  },
+};

package/src/core/VideoPlayer.ts

@@ -0,0 +1,357 @@
+import { Platform } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import { type VideoPlayer as VideoPlayerImpl } from '../spec/nitro/VideoPlayer.nitro';
+import type { VideoPlayerSource } from '../spec/nitro/VideoPlayerSource.nitro';
+import type { IgnoreSilentSwitchMode } from './types/IgnoreSilentSwitchMode';
+import type { MixAudioMode } from './types/MixAudioMode';
+import type { TextTrack } from './types/TextTrack';
+import type { NoAutocomplete } from './types/Utils';
+import type { VideoConfig, VideoSource } from './types/VideoConfig';
+import {
+  tryParseNativeVideoError,
+  VideoRuntimeError,
+} from './types/VideoError';
+import type { VideoPlayerBase } from './types/VideoPlayerBase';
+import type { VideoPlayerStatus } from './types/VideoPlayerStatus';
+import type { ListenerSubscription } from '../spec/nitro/VideoPlayerEventEmitter.nitro';
+import { createPlayer } from './utils/playerFactory';
+import { createSource } from './utils/sourceFactory';
+import { VideoPlayerEvents } from './VideoPlayerEvents';
+
+class VideoPlayer extends VideoPlayerEvents implements VideoPlayerBase {
+  private _player: VideoPlayerImpl | undefined;
+  private _releaseTimeout: ReturnType<typeof setTimeout> | undefined;
+  private _statusErrorSubscription: ListenerSubscription | undefined;
+  private _lastObservedStatus: VideoPlayerStatus | undefined;
+
+  protected get player(): VideoPlayerImpl {
+    if (this._player === undefined) {
+      throw new VideoRuntimeError(
+        'player/released',
+        "You can't access player after it's released"
+      );
+    }
+
+    return this._player;
+  }
+
+  constructor(source: VideoSource | VideoConfig | VideoPlayerSource) {
+    const hybridSource = createSource(source);
+    const player = createPlayer(hybridSource);
+
+    // Initialize events
+    super(player.eventEmitter);
+    this._player = player;
+    this._lastObservedStatus = player.status;
+    this._statusErrorSubscription =
+      player.eventEmitter.addOnStatusChangeListener((status) => {
+        if (status === 'error' && this._lastObservedStatus !== 'error') {
+          this.triggerJSEvent(
+            'onError',
+            new VideoRuntimeError(
+              'unknown/unknown',
+              'Playback failed (native player reported error status).'
+            )
+          );
+        }
+        this._lastObservedStatus = status;
+      });
+  }
+
+  /**
+   * Releases the player's native resources and releases native state.
+   * @internal
+   */
+  __destroy() {
+    if (this._player === undefined) return;
+
+    this._statusErrorSubscription?.remove();
+    this._statusErrorSubscription = undefined;
+    this._lastObservedStatus = undefined;
+
+    this.clearAllEvents();
+
+    try {
+      this.player.release();
+    } catch (error) {
+      // Best effort cleanup: teardown must never crash app unmount.
+      console.error('Failed to cleanup native player resources', error);
+    }
+
+    // We leave hybrid object to be cleaned up by garbage collector
+    // So we update memory size to ensure that memory is released
+    // when needed
+    this.updateMemorySize();
+
+    // We wait for 5s to let late events that were triggered before release to be processed
+    if (this._releaseTimeout !== undefined) {
+      clearTimeout(this._releaseTimeout);
+    }
+
+    this._releaseTimeout = setTimeout(() => {
+      this._player = undefined;
+      this._releaseTimeout = undefined;
+    }, 5000);
+  }
+
+  /**
+   * Returns the native (hybrid) player instance.
+   * Should not be used outside of the module.
+   * @internal
+   */
+  __getNativePlayer() {
+    return this.player;
+  }
+
+  /**
+   * Handles parsing native errors to VideoRuntimeError and calling onError if provided
+   * @internal
+   */
+  private throwError(error: unknown) {
+    const parsedError = tryParseNativeVideoError(error);
+
+    if (
+      parsedError instanceof VideoRuntimeError &&
+      this.triggerJSEvent('onError', parsedError as VideoRuntimeError)
+    ) {
+      // We don't throw errors if onError is provided
+      return;
+    }
+
+    throw parsedError;
+  }
+
+  /**
+   * Updates the memory size of the player and its source. Should be called after any operation that changes the memory size of the player or its source.
+   * @internal
+   */
+  private updateMemorySize() {
+    NitroModules.updateMemorySize(this.player);
+    NitroModules.updateMemorySize(this.player.source);
+  }
+
+  /**
+   * Wraps a promise to try parsing native errors to VideoRuntimeError
+   * @internal
+   */
+  private wrapPromise<T>(promise: Promise<T>) {
+    return new Promise<T>((resolve, reject) => {
+      promise.then(resolve).catch((error) => {
+        reject(this.throwError(error));
+      });
+    });
+  }
+
+  // Source
+  get source(): VideoPlayerSource {
+    return this.player.source;
+  }
+
+  // Status
+  get status(): VideoPlayerStatus {
+    return this.player.status;
+  }
+
+  // Duration
+  get duration(): number {
+    return this.player.duration;
+  }
+
+  // Volume
+  get volume(): number {
+    return this.player.volume;
+  }
+
+  set volume(value: number) {
+    this.player.volume = value;
+  }
+
+  // Current Time
+  get currentTime(): number {
+    return this.player.currentTime;
+  }
+
+  set currentTime(value: number) {
+    this.player.currentTime = value;
+  }
+
+  // Muted
+  get muted(): boolean {
+    return this.player.muted;
+  }
+
+  set muted(value: boolean) {
+    this.player.muted = value;
+  }
+
+  // Loop
+  get loop(): boolean {
+    return this.player.loop;
+  }
+
+  set loop(value: boolean) {
+    this.player.loop = value;
+  }
+
+  // Rate
+  get rate(): number {
+    return this.player.rate;
+  }
+
+  set rate(value: number) {
+    this.player.rate = value;
+  }
+
+  // Mix Audio Mode
+  get mixAudioMode(): MixAudioMode {
+    return this.player.mixAudioMode;
+  }
+
+  set mixAudioMode(value: MixAudioMode) {
+    this.player.mixAudioMode = value;
+  }
+
+  // Ignore Silent Switch Mode
+  get ignoreSilentSwitchMode(): IgnoreSilentSwitchMode {
+    return this.player.ignoreSilentSwitchMode;
+  }
+
+  set ignoreSilentSwitchMode(value: IgnoreSilentSwitchMode) {
+    if (__DEV__ && !['ios'].includes(Platform.OS)) {
+      console.warn(
+        'ignoreSilentSwitchMode is not supported on this platform, it wont have any effect'
+      );
+    }
+
+    this.player.ignoreSilentSwitchMode = value;
+  }
+
+  // Play In Background
+  get playInBackground(): boolean {
+    return this.player.playInBackground;
+  }
+
+  set playInBackground(value: boolean) {
+    this.player.playInBackground = value;
+  }
+
+  // Play When Inactive
+  get playWhenInactive(): boolean {
+    return this.player.playWhenInactive;
+  }
+
+  set playWhenInactive(value: boolean) {
+    this.player.playWhenInactive = value;
+  }
+
+  // Is Playing
+  get isPlaying(): boolean {
+    return this.player.isPlaying;
+  }
+
+  get showNotificationControls(): boolean {
+    return this.player.showNotificationControls;
+  }
+
+  set showNotificationControls(value: boolean) {
+    this.player.showNotificationControls = value;
+  }
+
+  async initialize(): Promise<void> {
+    await this.wrapPromise(this.player.initialize());
+
+    this.updateMemorySize();
+  }
+
+  async preload(): Promise<void> {
+    await this.wrapPromise(this.player.preload());
+
+    this.updateMemorySize();
+  }
+
+  /**
+   * Releases the player's native resources and releases native state.
+   * After calling this method, the player is no longer usable.
+   * Accessing any properties or methods of the player after calling this method will throw an error.
+   * If you want to clean player resource use `replaceSourceAsync` with `null` instead.
+   */
+  release(): void {
+    this.__destroy();
+  }
+
+  play(): void {
+    try {
+      this.player.play();
+    } catch (error) {
+      this.throwError(error);
+    }
+  }
+
+  pause(): void {
+    try {
+      this.player.pause();
+    } catch (error) {
+      this.throwError(error);
+    }
+  }
+
+  seekBy(time: number): void {
+    try {
+      this.player.seekBy(time);
+    } catch (error) {
+      this.throwError(error);
+    }
+  }
+
+  seekTo(time: number): void {
+    try {
+      this.player.seekTo(time);
+    } catch (error) {
+      this.throwError(error);
+    }
+  }
+
+  async replaceSourceAsync(
+    source: VideoSource | VideoConfig | NoAutocomplete<VideoPlayerSource> | null
+  ): Promise<void> {
+    this.updateMemorySize();
+
+    await this.wrapPromise(
+      this.player.replaceSourceAsync(
+        source === null ? null : createSource(source)
+      )
+    );
+
+    this.updateMemorySize();
+  }
+
+  // Text Track Management
+  getAvailableTextTracks(): TextTrack[] {
+    try {
+      return this.player.getAvailableTextTracks();
+    } catch (error) {
+      this.throwError(error);
+      return [];
+    }
+  }
+
+  selectTextTrack(textTrack: TextTrack | null): void {
+    try {
+      this.player.selectTextTrack(textTrack);
+    } catch (error) {
+      this.throwError(error);
+    }
+  }
+
+  // Selected Text Track
+  get selectedTrack(): TextTrack | undefined {
+    return this.player.selectedTrack;
+  }
+
+  // Frame Capture
+  async captureFrame(): Promise<string> {
+    return this.wrapPromise(this.player.captureFrame());
+  }
+}
+
+export { VideoPlayer };