@granite-js/video 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @granite-js/video
+
+## 1.0.0
+
+### Major Changes
+
+- 260daab: feat: introduce support react native 0.84

package/GraniteVideo.podspec

@@ -0,0 +1,72 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+# ============================================================
+# GraniteVideo Default Provider Configuration
+# ============================================================
+# Priority: GRANITE_VIDEO_DEFAULT_PROVIDER > GRANITE_DEFAULT_PROVIDER_ALL > true (default)
+#
+# Examples:
+#   Include default provider (default):
+#     pod install
+#
+#   Exclude default provider for video only:
+#     GRANITE_VIDEO_DEFAULT_PROVIDER=false pod install
+#
+#   Exclude default providers for all Granite packages:
+#     GRANITE_DEFAULT_PROVIDER_ALL=false pod install
+#
+#   Exclude all but override video to include:
+#     GRANITE_DEFAULT_PROVIDER_ALL=false GRANITE_VIDEO_DEFAULT_PROVIDER=true pod install
+# ============================================================
+resolve_default_provider = lambda do |specific_key, fallback_key, default_value|
+  if ENV.key?(specific_key)
+    ENV[specific_key] == 'true'
+  elsif ENV.key?(fallback_key)
+    ENV[fallback_key] == 'true'
+  else
+    default_value
+  end
+end
+
+use_default_provider = resolve_default_provider.call(
+  'GRANITE_VIDEO_DEFAULT_PROVIDER',
+  'GRANITE_DEFAULT_PROVIDER_ALL',
+  true
+)
+
+# Exclude AVPlayerProvider when not using default provider
+exclude_patterns = []
+exclude_patterns << "ios/Providers/AVPlayerProvider.swift" unless use_default_provider
+
+Pod::Spec.new do |s|
+  s.name         = "GraniteVideo"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/toss/granite.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.exclude_files = exclude_patterns if exclude_patterns.any?
+
+  # Preprocessor definitions for conditional compilation
+  preprocessor_defs = ['$(inherited)']
+  preprocessor_defs << 'GRANITE_VIDEO_DEFAULT_PROVIDER=1' if use_default_provider
+
+  s.pod_target_xcconfig = {
+    'CLANG_ENABLE_MODULES' => 'YES',
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_OBJC_INTERFACE_HEADER_NAME' => 'GraniteVideo-Swift.h',
+    'GCC_PREPROCESSOR_DEFINITIONS' => preprocessor_defs.join(' ')
+  }
+
+  s.frameworks = ["AVFoundation", "AVKit", "CoreMedia"]
+
+  # React Native modules dependencies (Fabric/TurboModule)
+  install_modules_dependencies(s)
+end

package/android/README.md

@@ -0,0 +1,232 @@
+# GraniteVideo Android
+
+Android native module for React Native video player library.
+
+## Module Structure
+
+```
+packages/video/
+├── android/           → granite-video (Core)
+└── android-media3/    → granite-video-media3 (Media3 ExoPlayer implementation)
+```
+
+- **granite-video**: Video player interface, registry, React Native view
+- **granite-video-media3**: Default implementation based on Media3 ExoPlayer
+
+---
+
+## Basic Usage
+
+### 1. Add Dependencies
+
+```gradle
+// app/build.gradle
+dependencies {
+    implementation project(':granite-video')
+    implementation project(':granite-video-media3')  // Media3 ExoPlayer
+}
+```
+
+### 2. Register React Native Packages
+
+```kotlin
+// MainApplication.kt
+import run.granite.video.GraniteVideoPackage
+import run.granite.video.media3.GraniteVideoMedia3Package
+
+override fun getPackages(): List<ReactPackage> {
+    val packages = PackageList(this).packages.toMutableList()
+    packages.add(GraniteVideoPackage())
+    packages.add(GraniteVideoMedia3Package())  // Auto-registers Media3 provider
+    return packages
+}
+```
+
+---
+
+## Media3 Provider (Default)
+
+Media3 ExoPlayer is the default video provider and is enabled by default.
+
+### Disabling Media3
+
+To disable Media3 and use a custom provider, you can use either:
+
+**Option 1: gradle.properties**
+
+```properties
+graniteVideo.useMedia3=false
+```
+
+**Option 2: Environment variable** (takes priority)
+
+```bash
+export GRANITE_VIDEO_USE_MEDIA3=false
+```
+
+Priority: Environment variable > gradle.properties > default (true)
+
+### Custom Provider Registration
+
+When Media3 is disabled, register your custom provider in your Application class:
+
+```kotlin
+class MyApplication : Application() {
+    override fun onCreate() {
+        super.onCreate()
+
+        GraniteVideoRegistry.registerFactory("custom") { MyCustomProvider() }
+        GraniteVideoRegistry.setDefaultProvider("custom")
+    }
+}
+```
+
+---
+
+## Custom Provider Implementation
+
+To use a different player (VLC, ijkplayer, etc.) instead of Media3, implement a custom provider.
+
+### 1. Implement GraniteVideoProvider Interface
+
+```kotlin
+package com.example.video
+
+import android.content.Context
+import android.view.View
+import run.granite.video.provider.*
+
+class MyCustomProvider : GraniteVideoProvider {
+
+    // Required: Provider identification
+    override val providerId: String = "custom"
+    override val providerName: String = "My Custom Player"
+
+    // Required: Delegate (event callbacks)
+    override var delegate: GraniteVideoDelegate? = null
+
+    // Required: State properties
+    override val currentTime: Double get() = /* current playback position */
+    override val duration: Double get() = /* total duration */
+    override val isPlaying: Boolean get() = /* is playing */
+
+    // Required: Create player view
+    override fun createPlayerView(context: Context): View {
+        // Return player view (e.g., SurfaceView, TextureView)
+        return MyPlayerView(context)
+    }
+
+    // Required: Load source
+    override fun loadSource(source: GraniteVideoSource) {
+        val uri = source.uri ?: return
+        // Load media from URI
+        // Handle source.headers, source.drm, etc.
+
+        // Fire load start event
+        delegate?.onLoadStart(
+            isNetwork = uri.startsWith("http"),
+            type = source.type ?: "unknown",
+            uri = uri
+        )
+    }
+
+    override fun unload() {
+        // Release resources
+    }
+
+    // Required: Playback control
+    override fun play() {
+        // Start playback
+        delegate?.onPlaybackStateChanged(isPlaying = true, isSeeking = false, isLooping = false)
+    }
+
+    override fun pause() {
+        // Pause playback
+        delegate?.onPlaybackStateChanged(isPlaying = false, isSeeking = false, isLooping = false)
+    }
+
+    override fun seek(time: Double, tolerance: Double) {
+        val previousTime = currentTime
+        // Seek to position
+        delegate?.onSeek(currentTime = previousTime, seekTime = time)
+    }
+
+    // Optional: Volume, rate, repeat, etc.
+    override fun setVolume(volume: Float) { /* ... */ }
+    override fun setRate(rate: Float) { /* ... */ }
+    override fun setRepeat(shouldRepeat: Boolean) { /* ... */ }
+
+    // Optional: Release resources
+    fun release() {
+        unload()
+        delegate = null
+    }
+}
+```
+
+### 2. Create Provider Initialization Package
+
+```kotlin
+package com.example.video
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import run.granite.video.provider.GraniteVideoRegistry
+
+class MyCustomVideoPackage : ReactPackage {
+
+    init {
+        // Register provider when package is instantiated
+        GraniteVideoRegistry.registerFactory("custom") { MyCustomProvider() }
+        GraniteVideoRegistry.setDefaultProvider("custom")
+    }
+
+    override fun createNativeModules(ctx: ReactApplicationContext): List<NativeModule> = emptyList()
+    override fun createViewManagers(ctx: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}
+```
+
+### 3. Register Package in MainApplication
+
+```kotlin
+// MainApplication.kt
+import run.granite.video.GraniteVideoPackage
+import com.example.video.MyCustomVideoPackage
+
+override fun getPackages(): List<ReactPackage> {
+    val packages = PackageList(this).packages.toMutableList()
+
+    // Core Package (required)
+    packages.add(GraniteVideoPackage())
+
+    // Custom Provider Package (instead of Media3Package)
+    packages.add(MyCustomVideoPackage())
+
+    return packages
+}
+```
+
+---
+
+## Provider Event Callbacks
+
+Providers communicate events via `delegate`:
+
+| Method                                                    | Description                                |
+| --------------------------------------------------------- | ------------------------------------------ |
+| `onLoadStart(isNetwork, type, uri)`                       | Source load started                        |
+| `onLoad(data)`                                            | Load complete (duration, dimensions, etc.) |
+| `onProgress(data)`                                        | Playback progress                          |
+| `onError(error)`                                          | Error occurred                             |
+| `onEnd()`                                                 | Playback ended                             |
+| `onBuffer(isBuffering)`                                   | Buffering state changed                    |
+| `onPlaybackStateChanged(isPlaying, isSeeking, isLooping)` | Playback state changed                     |
+| `onSeek(currentTime, seekTime)`                           | Seek completed                             |
+
+---
+
+## License
+
+Apache License 2.0

package/android/build.gradle

@@ -0,0 +1,117 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['GraniteVideo_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["GraniteVideo_" + name]).toInteger()
+}
+
+// Check useMedia3 flag from environment variable or gradle.properties (default: true)
+// Priority: Environment variable > root gradle.properties > module gradle.properties > default (true)
+def useMedia3Flag = System.getenv('GRANITE_VIDEO_USE_MEDIA3') ?: rootProject.findProperty('graniteVideo.useMedia3')?.toString() ?: project.findProperty('graniteVideo.useMedia3')?.toString()
+def useMedia3 = useMedia3Flag != 'false'
+
+android {
+  namespace "run.granite.video"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    // Pass flag to BuildConfig for conditional registration
+    buildConfigField "boolean", "USE_MEDIA3", useMedia3.toString()
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java {
+        srcDirs += ["generated/java", "generated/jni"]
+        // Conditionally include Media3 sources
+        if (useMedia3) {
+          srcDirs += ["src/media3/java"]
+        }
+      }
+      // Use different manifest based on Media3 flag
+      // - media3 manifest includes ContentProvider for auto-initialization
+      // - main manifest is empty (for custom provider use case)
+      if (useMedia3) {
+        manifest.srcFile "src/media3/AndroidManifest.xml"
+      }
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  // Media3 ExoPlayer dependencies (conditional)
+  if (useMedia3) {
+    implementation "androidx.media3:media3-exoplayer:1.2.1"
+    implementation "androidx.media3:media3-exoplayer-dash:1.2.1"
+    implementation "androidx.media3:media3-exoplayer-hls:1.2.1"
+    implementation "androidx.media3:media3-exoplayer-smoothstreaming:1.2.1"
+    implementation "androidx.media3:media3-datasource:1.2.1"
+    implementation "androidx.media3:media3-ui:1.2.1"
+  }
+
+  // Test dependencies
+  testImplementation "io.kotest:kotest-runner-junit5:5.9.1"
+  testImplementation "io.kotest:kotest-assertions-core:5.9.1"
+  testImplementation "io.kotest:kotest-property:5.9.1"
+  testImplementation "io.mockk:mockk:1.13.9"
+  testImplementation "org.robolectric:robolectric:4.11.1"
+  testImplementation "junit:junit:4.13.2"
+}
+
+tasks.withType(Test).configureEach {
+  useJUnitPlatform()
+}
+

package/android/gradle.properties

@@ -0,0 +1,8 @@
+GraniteVideo_kotlinVersion=2.1.20
+GraniteVideo_minSdkVersion=24
+GraniteVideo_targetSdkVersion=35
+GraniteVideo_compileSdkVersion=35
+GraniteVideo_ndkVersion=27.1.12297006
+
+# Media3 provider enabled by default
+graniteVideo.useMedia3=true

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/run/granite/video/GraniteVideoModule.kt

@@ -0,0 +1,70 @@
+package run.granite.video
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import run.granite.video.provider.GraniteVideoRegistry
+
+class GraniteVideoModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = NAME
+
+    @ReactMethod
+    fun clearCache(promise: Promise) {
+        try {
+            GraniteVideoRegistry.createProvider()?.clearCache()
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("CLEAR_CACHE_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getWidevineLevel(promise: Promise) {
+        try {
+            val level = GraniteVideoRegistry.createProvider()?.getWidevineLevel() ?: 0
+            promise.resolve(level)
+        } catch (e: Exception) {
+            promise.reject("WIDEVINE_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun isCodecSupported(mimeType: String, width: Int, height: Int, promise: Promise) {
+        try {
+            val supported = GraniteVideoRegistry.createProvider()?.isCodecSupported(mimeType, width, height) ?: false
+            promise.resolve(supported)
+        } catch (e: Exception) {
+            promise.reject("CODEC_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun isHEVCSupported(promise: Promise) {
+        try {
+            val supported = GraniteVideoRegistry.createProvider()?.isHEVCSupported() ?: false
+            promise.resolve(supported)
+        } catch (e: Exception) {
+            promise.reject("HEVC_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getCurrentPosition(viewTag: Int, promise: Promise) {
+        // This would need to find the view by tag and get the current position
+        // For now, return 0
+        promise.resolve(0.0)
+    }
+
+    @ReactMethod
+    fun save(viewTag: Int, options: ReadableMap?, promise: Promise) {
+        // Save functionality - would need implementation
+        promise.reject("NOT_IMPLEMENTED", "Save is not implemented on Android")
+    }
+
+    companion object {
+        const val NAME = "GraniteVideoModule"
+    }
+}

package/android/src/main/java/run/granite/video/GraniteVideoPackage.kt

@@ -0,0 +1,43 @@
+package run.granite.video
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package for GraniteVideo core functionality.
+ *
+ * This package provides the video view and module.
+ * Video provider registration is handled automatically via ContentProvider
+ * when USE_MEDIA3 is enabled (default).
+ *
+ * ## Basic Usage
+ * ```kotlin
+ * // Default configuration (uses Media3)
+ * packages.add(GraniteVideoPackage())
+ * ```
+ *
+ * ## Custom Provider Configuration
+ * To disable Media3 and use a custom provider:
+ * ```
+ * // In gradle.properties
+ * graniteVideo.useMedia3=false
+ * ```
+ *
+ * Then register your custom provider:
+ * ```kotlin
+ * GraniteVideoRegistry.registerFactory("custom") { MyCustomProvider() }
+ * GraniteVideoRegistry.setDefaultProvider("custom")
+ * ```
+ */
+class GraniteVideoPackage : ReactPackage {
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return listOf(GraniteVideoViewManager())
+    }
+
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(GraniteVideoModule(reactContext))
+    }
+}