expo-video-metadata 0.1.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['universe/native', 'universe/web'],
+  ignorePatterns: ['build'],
+};

package/README.md

@@ -0,0 +1,41 @@
+# expo-video-metadata
+
+Provides a function that let you get some metadata from video files, like the duration, width, height, fps, codec, hasAudio, orientation, audioChannels, audioCodec, audioSampleRate etc. Check the exported types for more information. Web support is not available yet but it is planned.
+
+# Installation in bare React Native projects
+
+This package needs **Expo SDK 50** or **higher**, as it uses FileSystem APIs that were added in that version. This package adds native code to your project and does not work with Expo Go. Please use a custom dev client or build a standalone app.
+
+For bare React Native projects, you must ensure that you have [installed and configured the `expo` package](https://docs.expo.dev/bare/installing-expo-modules/) before continuing (SDK 50+). This just adds ~150KB to your final app size and is the easiest way to get started and it works with and without Expo projects.
+
+### Add the package to your npm dependencies
+
+```
+npx expo install expo-video-metadata
+```
+
+### Configure for iOS
+
+Run `npx pod-install` after installing the npm package.
+
+### Configure for Android
+
+No additional set up necessary.
+
+# API
+
+```ts
+import { getVideoInfoAsync } from 'expo-video-metadata';
+
+/**
+ * Gets metadata from a video file.
+ * @param sourceFilename An URI of the video, local or remote.
+ * @return Returns a promise that resolves to a `VideoInfoResult` object.
+ */
+const videoInfo = await getVideoInfoAsync(sourceFileName: string): Promise<VideoInfo>;
+
+```
+
+# Info
+
+I am planning to add more metadata to the result object. If you need something specific, please open an issue or a PR.

package/android/build.gradle

@@ -0,0 +1,89 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
+
+group = 'expo.modules.videometadata'
+version = '0.1.0'
+
+buildscript {
+  def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+  if (expoModulesCorePlugin.exists()) {
+    apply from: expoModulesCorePlugin
+    applyKotlinExpoModulesCorePlugin()
+  }
+
+  // Simple helper that allows the root project to override versions declared by this library.
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+
+  // Ensures backward compatibility
+  ext.getKotlinVersion = {
+    if (ext.has("kotlinVersion")) {
+      ext.kotlinVersion()
+    } else {
+      ext.safeExtGet("kotlinVersion", "1.8.10")
+    }
+  }
+
+  repositories {
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${getKotlinVersion()}")
+  }
+}
+
+afterEvaluate {
+  publishing {
+    publications {
+      release(MavenPublication) {
+        from components.release
+      }
+    }
+    repositories {
+      maven {
+        url = mavenLocal().url
+      }
+    }
+  }
+}
+
+android {
+  compileSdkVersion safeExtGet("compileSdkVersion", 33)
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_17.majorVersion
+  }
+
+  namespace "expo.modules.videometadata"
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 21)
+    targetSdkVersion safeExtGet("targetSdkVersion", 33)
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+  publishing {
+    singleVariant("release") {
+      withSourcesJar()
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  implementation project(':expo-modules-core')
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

package/android/src/main/java/expo/modules/videometadata/Exceptions.kt

@@ -0,0 +1,9 @@
+package expo.modules.videometadata
+
+import expo.modules.kotlin.exception.CodedException
+
+class VideoFileException :
+  CodedException("Can't read file")
+
+class FilePermissionsModuleNotFound :
+  CodedException("File permissions module not found")

package/android/src/main/java/expo/modules/videometadata/ExpoVideoMetadataModule.kt

@@ -0,0 +1,203 @@
+package expo.modules.videometadata
+
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.util.Log
+import android.webkit.URLUtil
+import expo.modules.core.errors.ModuleDestroyedException
+import expo.modules.interfaces.filesystem.Permission
+import expo.modules.kotlin.Promise
+import expo.modules.kotlin.exception.CodedException
+import expo.modules.kotlin.exception.Exceptions
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import java.io.File
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+class ExpoVideoMetadataModule : Module() {
+  private val context
+    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
+  private val moduleCoroutineScope = CoroutineScope(Dispatchers.IO)
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoVideoMetadata")
+
+    AsyncFunction("getVideoInfo") { sourceFilename: String, options: ExpoVideoMetadataOptions, promise: Promise ->
+      if (URLUtil.isFileUrl(sourceFilename) && !isAllowedToRead(Uri.decode(sourceFilename).replace("file://", ""))) {
+        throw VideoFileException()
+      }
+
+      withModuleScope(promise) {
+        try {
+          val retriever = MediaMetadataRetriever()
+          val extractor = MediaExtractor()
+
+          var fileSize: Long? = null
+
+          if (URLUtil.isFileUrl(sourceFilename)) {
+            retriever.setDataSource(Uri.decode(sourceFilename).replace("file://", ""))
+            extractor.setDataSource(Uri.decode(sourceFilename).replace("file://", ""))
+            fileSize = File(sourceFilename.replace("file://", "")).length()
+          } else if (URLUtil.isContentUrl(sourceFilename)) {
+            val fileUri = Uri.parse(sourceFilename)
+            fileSize = File(sourceFilename).length()
+            context.contentResolver.openFileDescriptor(fileUri, "r")?.use { parcelFileDescriptor ->
+              retriever.setDataSource(parcelFileDescriptor.fileDescriptor)
+              extractor.setDataSource(parcelFileDescriptor.fileDescriptor)
+            }
+          } else {
+            retriever.setDataSource(sourceFilename, options.headers)
+            extractor.setDataSource(sourceFilename, options.headers)
+          }
+
+          // extract metadata
+          val durationMs = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLongOrNull() ?: 0L
+          val duration = BigDecimal(durationMs)
+            .divide(BigDecimal(1000), 15, RoundingMode.HALF_UP)
+            .toDouble()
+
+          val width = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toIntOrNull()
+          val height = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toIntOrNull()
+          val bitrate = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)?.toIntOrNull()
+          val rotation = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)?.toIntOrNull()
+          val hasAudio = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_AUDIO) != null
+
+          // release
+          retriever.release()
+
+          // Additional metadata can be extracted here
+          var audioChannels: Int? = null
+          var audioSampleRate: Int? = null
+          var audioCodec: String? = null
+          var videoCodec: String? = null
+          var frameRate: Float? = null
+
+          val numTracks = extractor.trackCount
+          for (i in 0 until numTracks) {
+            val format = extractor.getTrackFormat(i)
+            val mimeType = format.getString(MediaFormat.KEY_MIME) ?: continue
+            if (mimeType.startsWith("audio/")) {
+              audioChannels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+              audioSampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+              audioCodec = mapMimeTypeToCodecName(mimeType)
+            } else if (mimeType.startsWith("video/")) {
+              videoCodec = mapMimeTypeToCodecName(mimeType)
+
+              // extract video frameRate
+              if (format.containsKey(MediaFormat.KEY_FRAME_RATE)) {
+                frameRate = try {
+                  // Try to get frame rate as Integer and convert to Float
+                  format.getInteger(MediaFormat.KEY_FRAME_RATE).toFloat()
+                } catch (e: Exception) {
+                  // If Integer retrieval fails, try as Float
+                  format.getFloat(MediaFormat.KEY_FRAME_RATE)
+                }
+              }
+            }
+          }
+
+          extractor.release()
+
+
+          promise.resolve(
+            mapOf(
+              "audioChannels" to audioChannels,
+              "duration" to duration,
+              "width" to width,
+              "height" to height,
+              "bitrate" to bitrate,
+              "fileSize" to fileSize,
+              "hasAudio" to hasAudio,
+              "audioCodec" to audioCodec,
+              "orientation" to getOrientation(rotation),
+              "audioSampleRate" to audioSampleRate,
+              "audioCodec" to audioCodec,
+              "codec" to videoCodec,
+              "fps" to frameRate
+            )
+          )
+        } catch (e: Exception) {
+          Log.e(TAG, "Error retrieving video metadata: ${e.message}", e)
+          promise.reject(ERROR_TAG, "Failed to retrieve video metadata", e)
+        }
+      }
+    }
+
+
+    OnDestroy {
+      try {
+        moduleCoroutineScope.cancel(ModuleDestroyedException())
+      } catch (e: IllegalStateException) {
+        Log.e(TAG, "The scope does not have a job in it")
+      }
+    }
+  }
+
+  private fun isAllowedToRead(url: String): Boolean {
+    val permissionModuleInterface = appContext.filePermission
+      ?: throw FilePermissionsModuleNotFound()
+    return permissionModuleInterface.getPathPermissions(context, url).contains(Permission.READ)
+  }
+
+  private fun getOrientation(rotation: Int?): String {
+    return when (rotation) {
+      0 -> "LandscapeRight"
+      90 -> "Portrait"
+      180 -> "LandscapeLeft"
+      270 -> "PortraitUpsideDown"
+      else -> "LandscapeRight" // Default or unknown rotation
+    }
+  }
+
+
+  private fun mapMimeTypeToCodecName(mimeType: String): String {
+    return when {
+      mimeType.startsWith("audio/") -> {
+        when {
+          mimeType.contains("mp4a-latm") -> "aac" // AAC Audio
+          mimeType.contains("ac3") -> "ac3" // AC3 Audio
+          mimeType.contains("opus") -> "opus" // Opus Audio
+          mimeType.contains("vorbis") -> "vorbis" // Vorbis Audio
+          mimeType.contains("flac") -> "flac" // FLAC Audio
+          // Add more audio mappings as needed
+          else -> mimeType.substringAfter("audio/")
+        }
+      }
+      mimeType.startsWith("video/") -> {
+        when {
+          mimeType.contains("avc") || mimeType.contains("h264") -> "avc1" // H.264/AVC Video
+          mimeType.contains("hev") || mimeType.contains("h265") -> "hev1" // H.265/HEVC Video
+          mimeType.contains("vp9") -> "vp9" // VP9 Video
+          mimeType.contains("vp8") -> "vp8" // VP8 Video
+          mimeType.contains("mp4v-es") -> "mp4v" // MPEG-4 Video
+          // Add more video mappings as needed
+          else -> mimeType.substringAfter("video/")
+        }
+      }
+      else -> mimeType
+    }
+  }
+
+
+  private inline fun withModuleScope(promise: Promise, crossinline block: () -> Unit) = moduleCoroutineScope.launch {
+    try {
+      block()
+    } catch (e: CodedException) {
+      promise.reject(e)
+    } catch (e: ModuleDestroyedException) {
+      promise.reject(TAG, "ExpoVideoMetadata module destroyed", e)
+    }
+  }
+
+  companion object {
+    private const val TAG = "ExpoVideoMetadata"
+    private const val ERROR_TAG = "E_VIDEO_METADATA"
+  }
+}

package/android/src/main/java/expo/modules/videometadata/VideoMetadataOptions.kt

@@ -0,0 +1,9 @@
+package expo.modules.videometadata
+
+import expo.modules.kotlin.records.Field
+import expo.modules.kotlin.records.Record
+
+data class ExpoVideoMetadataOptions(
+  @Field
+  val headers: Map<String, String> = emptyMap()
+) : Record

package/build/ExpoVideoMetadata.types.d.ts

@@ -0,0 +1,57 @@
+export type VideoInfoResult = {
+    /**
+     * Duration of the video in seconds (float).
+     */
+    duration: number;
+    /**
+     * Tells if the video has a audio track. If the video has no audio track, its considered a mute video.
+     */
+    hasAudio: boolean;
+    /**
+     * Width of the video in pixels.
+     */
+    width: number;
+    /**
+     * Height of the video in pixels.
+     */
+    height: number;
+    /**
+     * Frame rate of the video in frames per second.
+     */
+    fps: number;
+    /**
+     * Bit rate of the video in bits per second.
+     */
+    bitRate: number;
+    /**
+     * File size of the video in bytes. Works only for local files, returns 0 for remote files.
+     */
+    fileSize: number;
+    /**
+     * Video codec.
+     */
+    codec: string;
+    /**
+     * Video orientation.
+     */
+    orientation: "Portrait" | "PortraitUpsideDown" | "LandscapeRight" | "LandscapeLeft";
+    /**
+     * Audio sample rate of the video in samples per second.
+     */
+    audioSampleRate: number;
+    /**
+     * Audio channel count of the video.
+     */
+    audioChannels: number;
+    /**
+     * Audio codec of the video.
+     */
+    audioCodec: string;
+};
+export type VideoInfoOptions = {
+    /**
+     * In case `sourceFilename` is a remote URI, `headers` object is passed in a network request.
+     */
+    headers?: Record<string, string>;
+};
+//# sourceMappingURL=ExpoVideoMetadata.types.d.ts.map

package/build/ExpoVideoMetadata.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoMetadata.types.d.ts","sourceRoot":"","sources":["../src/ExpoVideoMetadata.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAClB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,WAAW,EACP,UAAU,GACV,oBAAoB,GACpB,gBAAgB,GAChB,eAAe,CAAC;IACpB;;OAEG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC"}

package/build/ExpoVideoMetadata.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ExpoVideoMetadata.types.js.map

package/build/ExpoVideoMetadata.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoMetadata.types.js","sourceRoot":"","sources":["../src/ExpoVideoMetadata.types.ts"],"names":[],"mappings":"","sourcesContent":["export type VideoInfoResult = {\n  /**\n   * Duration of the video in seconds (float).\n   */\n  duration: number;\n  /**\n   * Tells if the video has a audio track. If the video has no audio track, its considered a mute video.\n   */\n  hasAudio: boolean;\n  /**\n   * Width of the video in pixels.\n   */\n  width: number;\n  /**\n   * Height of the video in pixels.\n   */\n  height: number;\n  /**\n   * Frame rate of the video in frames per second.\n   */\n  fps: number;\n  /**\n   * Bit rate of the video in bits per second.\n   */\n  bitRate: number;\n  /**\n   * File size of the video in bytes. Works only for local files, returns 0 for remote files.\n   */\n  fileSize: number;\n  /**\n   * Video codec.\n   */\n  codec: string;\n  /**\n   * Video orientation.\n   */\n  orientation:\n    | \"Portrait\"\n    | \"PortraitUpsideDown\"\n    | \"LandscapeRight\"\n    | \"LandscapeLeft\";\n  /**\n   * Audio sample rate of the video in samples per second.\n   */\n  audioSampleRate: number;\n  /**\n   * Audio channel count of the video.\n   */\n  audioChannels: number;\n  /**\n   * Audio codec of the video.\n   */\n  audioCodec: string;\n};\n\nexport type VideoInfoOptions = {\n  /**\n   * In case `sourceFilename` is a remote URI, `headers` object is passed in a network request.\n   */\n  headers?: Record<string, string>;\n};\n"]}

package/build/ExpoVideoMetadataModule.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+export default _default;
+//# sourceMappingURL=ExpoVideoMetadataModule.d.ts.map

package/build/ExpoVideoMetadataModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoMetadataModule.d.ts","sourceRoot":"","sources":["../src/ExpoVideoMetadataModule.ts"],"names":[],"mappings":";AACA,wBAAwD"}

package/build/ExpoVideoMetadataModule.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from "expo-modules-core";
+export default requireNativeModule("ExpoVideoMetadata");
+//# sourceMappingURL=ExpoVideoMetadataModule.js.map

package/build/ExpoVideoMetadataModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoMetadataModule.js","sourceRoot":"","sources":["../src/ExpoVideoMetadataModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,eAAe,mBAAmB,CAAC,mBAAmB,CAAC,CAAC","sourcesContent":["import { requireNativeModule } from \"expo-modules-core\";\nexport default requireNativeModule(\"ExpoVideoMetadata\");\n"]}

package/build/ExpoVideoMetadataModule.web.d.ts

@@ -0,0 +1,7 @@
+import type { VideoInfoOptions, VideoInfoResult } from "./ExpoVideoMetadata.types";
+declare const _default: {
+    readonly name: string;
+    getVideoInfoAsync(sourceFilename: string, options?: VideoInfoOptions): Promise<VideoInfoResult>;
+};
+export default _default;
+//# sourceMappingURL=ExpoVideoMetadataModule.web.d.ts.map

package/build/ExpoVideoMetadataModule.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoMetadataModule.web.d.ts","sourceRoot":"","sources":["../src/ExpoVideoMetadataModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EAChB,MAAM,2BAA2B,CAAC;;;sCAOf,MAAM,YACb,gBAAgB,GACxB,QAAQ,eAAe,CAAC;;AAP7B,wBAUE"}

package/build/ExpoVideoMetadataModule.web.js

@@ -0,0 +1,9 @@
+export default {
+    get name() {
+        return "ExpoVideoMetadata";
+    },
+    async getVideoInfoAsync(sourceFilename, options = {}) {
+        throw new Error("ExpoVideoMetadata not supported on Expo Web yet");
+    },
+};
+//# sourceMappingURL=ExpoVideoMetadataModule.web.js.map

package/build/ExpoVideoMetadataModule.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoVideoMetadataModule.web.js","sourceRoot":"","sources":["../src/ExpoVideoMetadataModule.web.ts"],"names":[],"mappings":"AAKA,eAAe;IACb,IAAI,IAAI;QACN,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IACD,KAAK,CAAC,iBAAiB,CACrB,cAAsB,EACtB,UAA4B,EAAE;QAE9B,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;IACrE,CAAC;CACF,CAAC","sourcesContent":["import type {\n  VideoInfoOptions,\n  VideoInfoResult,\n} from \"./ExpoVideoMetadata.types\";\n\nexport default {\n  get name(): string {\n    return \"ExpoVideoMetadata\";\n  },\n  async getVideoInfoAsync(\n    sourceFilename: string,\n    options: VideoInfoOptions = {},\n  ): Promise<VideoInfoResult> {\n    throw new Error(\"ExpoVideoMetadata not supported on Expo Web yet\");\n  },\n};\n"]}

package/build/index.d.ts

@@ -0,0 +1,12 @@
+import { VideoInfoOptions, VideoInfoResult } from "./ExpoVideoMetadata.types";
+export { VideoInfoOptions, VideoInfoResult };
+/**
+ * Create an image thumbnail from video provided via `sourceFilename`.
+ *
+ * @param sourceFilename An URI of the video, local or remote.
+ * @param options Pass `headers` object in case `sourceFilename` is a remote URI, e.g { headers: "Authorization": "Bearer some-token" } etc.
+ *
+ * @return Returns a promise which fulfils with [`VideoInfoResult`](#Videoinforesult).
+ */
+export declare function getVideoInfoAsync(sourceFilename: string, options?: VideoInfoOptions): Promise<VideoInfoResult>;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAG9E,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,CAAC;AAK7C;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,cAAc,EAAE,MAAM,EACtB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,eAAe,CAAC,CAE1B"}

package/build/index.js

@@ -0,0 +1,15 @@
+import ExpoVideoMetadataModule from "./ExpoVideoMetadataModule";
+// Import the native module. On web, it will be resolved to ExpoVideoMetadata.web.ts
+// and on native platforms to ExpoVideoMetadata.ts
+/**
+ * Create an image thumbnail from video provided via `sourceFilename`.
+ *
+ * @param sourceFilename An URI of the video, local or remote.
+ * @param options Pass `headers` object in case `sourceFilename` is a remote URI, e.g { headers: "Authorization": "Bearer some-token" } etc.
+ *
+ * @return Returns a promise which fulfils with [`VideoInfoResult`](#Videoinforesult).
+ */
+export async function getVideoInfoAsync(sourceFilename, options = {}) {
+    return await ExpoVideoMetadataModule.getVideoInfo(sourceFilename, options);
+}
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,uBAAuB,MAAM,2BAA2B,CAAC;AAIhE,oFAAoF;AACpF,kDAAkD;AAElD;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,cAAsB,EACtB,UAA4B,EAAE;IAE9B,OAAO,MAAM,uBAAuB,CAAC,YAAY,CAAC,cAAc,EAAE,OAAO,CAAC,CAAC;AAC7E,CAAC","sourcesContent":["import { VideoInfoOptions, VideoInfoResult } from \"./ExpoVideoMetadata.types\";\nimport ExpoVideoMetadataModule from \"./ExpoVideoMetadataModule\";\n\nexport { VideoInfoOptions, VideoInfoResult };\n\n// Import the native module. On web, it will be resolved to ExpoVideoMetadata.web.ts\n// and on native platforms to ExpoVideoMetadata.ts\n\n/**\n * Create an image thumbnail from video provided via `sourceFilename`.\n *\n * @param sourceFilename An URI of the video, local or remote.\n * @param options Pass `headers` object in case `sourceFilename` is a remote URI, e.g { headers: \"Authorization\": \"Bearer some-token\" } etc.\n *\n * @return Returns a promise which fulfils with [`VideoInfoResult`](#Videoinforesult).\n */\nexport async function getVideoInfoAsync(\n  sourceFilename: string,\n  options: VideoInfoOptions = {},\n): Promise<VideoInfoResult> {\n  return await ExpoVideoMetadataModule.getVideoInfo(sourceFilename, options);\n}\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["ios", "android", "web"],
+  "ios": {
+    "modules": ["ExpoVideoMetadataModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.videometadata.ExpoVideoMetadataModule"]
+  }
+}

package/ios/ExpoVideoMetadata.podspec

@@ -0,0 +1,27 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoVideoMetadata'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platform       = :ios, '13.4'
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/hirbod/expo-video-metadata' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  s.source_files = "**/*.{h,m,swift}"
+end

package/ios/ExpoVideoMetadataExceptions.swift

@@ -0,0 +1,7 @@
+import ExpoModulesCore
+
+internal class FileSystemReadPermissionException: GenericException<String> {
+  override var reason: String {
+    "File '\(param)' is not readable"
+  }
+}

package/ios/ExpoVideoMetadataModule.swift

@@ -0,0 +1,110 @@
+import ExpoModulesCore
+import AVFoundation
+
+public class ExpoVideoMetadataModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoVideoMetadata")
+
+    AsyncFunction("getVideoInfo", getVideoInfo).runOnQueue(.main)
+  }
+
+  internal func getVideoInfo(sourceFilename: URL, options: ExpoVideoMetadataOptions) throws -> [String: Any] {
+    if sourceFilename.isFileURL {
+      guard FileSystemUtilities.permissions(appContext, for: sourceFilename).contains(.read) else {
+        throw FileSystemReadPermissionException(sourceFilename.absoluteString)
+      }
+    }
+
+    let asset = AVURLAsset.init(url: sourceFilename, options: ["AVURLAssetHTTPHeaderFieldsKey": options.headers])
+    let duration = CMTimeGetSeconds(asset.duration)
+    let hasAudio = asset.tracks(withMediaType: .audio).count > 0
+
+    var fileSize: Int64 = 0
+    if let fileAttributes = try? FileManager.default.attributesOfItem(atPath: sourceFilename.path),
+       let size = fileAttributes[.size] as? NSNumber {
+      fileSize = size.int64Value
+    }
+
+    // Initialize default values
+    var bitrate: Float = 0.0
+    var width: Int = 0
+    var height: Int = 0
+    var frameRate: Float = 0.0
+    var codec: String = ""
+    var orientation: String = ""
+    var audioSampleRate: Int = 0
+    var audioChannels: Int = 0
+    var audioCodec: String = ""
+
+    // If there are video tracks, extract more information
+    if let videoTrack = asset.tracks(withMediaType: .video).first {
+      // Bitrate
+      bitrate = videoTrack.estimatedDataRate
+
+      // Width and Height
+      let size = videoTrack.naturalSize
+      width = Int(size.width)
+      height = Int(size.height)
+
+      // Frame Rate
+      frameRate = videoTrack.nominalFrameRate
+
+      // Codec
+      if let firstFormatDescription = videoTrack.formatDescriptions.first {
+        let formatDescription = firstFormatDescription as! CMFormatDescription
+        let codecType = CMFormatDescriptionGetMediaSubType(formatDescription)
+        codec = fourCharCodeToString(fourCharCode: codecType)
+      }
+
+      // Orientation
+      let transform = videoTrack.preferredTransform
+      if transform.a == 0 && transform.d == 0 {
+        orientation = (transform.b == 1.0) ? "Portrait" : "PortraitUpsideDown"
+      } else {
+        orientation = (transform.a == 1.0) ? "LandscapeRight" : "LandscapeLeft"
+      }
+    }
+
+    // Audio track information
+    if let audioTrack = asset.tracks(withMediaType: .audio).first {
+      audioSampleRate = Int(audioTrack.naturalTimeScale)
+
+      // Extracting audio channels from the format descriptions
+      if let formatDescriptions = audioTrack.formatDescriptions as? [CMAudioFormatDescription],
+         let firstFormatDescription = formatDescriptions.first {
+        let audioStreamBasicDescription = CMAudioFormatDescriptionGetStreamBasicDescription(firstFormatDescription)?.pointee
+        audioChannels = Int(audioStreamBasicDescription?.mChannelsPerFrame ?? 0)
+
+        // Extract audio codec
+        let codecType = CMFormatDescriptionGetMediaSubType(firstFormatDescription)
+        audioCodec = fourCharCodeToString(fourCharCode: codecType)
+      }
+    }
+
+    return [
+      "duration": duration,
+      "hasAudio": hasAudio,
+      "fileSize": fileSize,
+      "bitrate": bitrate,
+      "fps": frameRate,
+      "width": width,
+      "height": height,
+      "codec": codec,
+      "orientation": orientation,
+      "audioSampleRate": audioSampleRate,
+      "audioChannels": audioChannels,
+      "audioCodec": audioCodec
+    ]
+  }
+
+  // Helper function to convert FourCC code to String
+  private func fourCharCodeToString(fourCharCode: FourCharCode) -> String {
+    let characters = [
+      Character(UnicodeScalar((fourCharCode >> 24) & 0xFF)!),
+      Character(UnicodeScalar((fourCharCode >> 16) & 0xFF)!),
+      Character(UnicodeScalar((fourCharCode >> 8) & 0xFF)!),
+      Character(UnicodeScalar(fourCharCode & 0xFF)!)
+    ]
+    return String(characters)
+  }
+}

package/ios/ExpoVideoMetadataOptions.swift

@@ -0,0 +1,5 @@
+import ExpoModulesCore
+
+internal struct ExpoVideoMetadataOptions: Record {
+  @Field var headers: [String: String] = [String: String]()
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "expo-video-metadata",
+  "version": "0.1.0",
+  "description": "Module to retrieve informations from a video",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "open -a \"Xcode\" example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-video-metadata",
+    "ExpoVideoMetadata"
+  ],
+  "repository": "https://github.com/hirbod/expo-video-metadata",
+  "bugs": {
+    "url": "https://github.com/hirbod/expo-video-metadata/issues"
+  },
+  "author": "Hirbod Mirjavadi <hm@nightstomp.com> (https://github.com/hirbod)",
+  "license": "MIT",
+  "homepage": "https://github.com/hirbod/expo-video-metadata#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "^18.0.25",
+    "expo-module-scripts": "^3.0.11",
+    "expo-modules-core": "^1.5.11"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/src/ExpoVideoMetadata.types.ts

@@ -0,0 +1,61 @@
+export type VideoInfoResult = {
+  /**
+   * Duration of the video in seconds (float).
+   */
+  duration: number;
+  /**
+   * Tells if the video has a audio track. If the video has no audio track, its considered a mute video.
+   */
+  hasAudio: boolean;
+  /**
+   * Width of the video in pixels.
+   */
+  width: number;
+  /**
+   * Height of the video in pixels.
+   */
+  height: number;
+  /**
+   * Frame rate of the video in frames per second.
+   */
+  fps: number;
+  /**
+   * Bit rate of the video in bits per second.
+   */
+  bitRate: number;
+  /**
+   * File size of the video in bytes. Works only for local files, returns 0 for remote files.
+   */
+  fileSize: number;
+  /**
+   * Video codec.
+   */
+  codec: string;
+  /**
+   * Video orientation.
+   */
+  orientation:
+    | "Portrait"
+    | "PortraitUpsideDown"
+    | "LandscapeRight"
+    | "LandscapeLeft";
+  /**
+   * Audio sample rate of the video in samples per second.
+   */
+  audioSampleRate: number;
+  /**
+   * Audio channel count of the video.
+   */
+  audioChannels: number;
+  /**
+   * Audio codec of the video.
+   */
+  audioCodec: string;
+};
+
+export type VideoInfoOptions = {
+  /**
+   * In case `sourceFilename` is a remote URI, `headers` object is passed in a network request.
+   */
+  headers?: Record<string, string>;
+};

package/src/ExpoVideoMetadataModule.ts

@@ -0,0 +1,2 @@
+import { requireNativeModule } from "expo-modules-core";
+export default requireNativeModule("ExpoVideoMetadata");

package/src/ExpoVideoMetadataModule.web.ts

@@ -0,0 +1,16 @@
+import type {
+  VideoInfoOptions,
+  VideoInfoResult,
+} from "./ExpoVideoMetadata.types";
+
+export default {
+  get name(): string {
+    return "ExpoVideoMetadata";
+  },
+  async getVideoInfoAsync(
+    sourceFilename: string,
+    options: VideoInfoOptions = {},
+  ): Promise<VideoInfoResult> {
+    throw new Error("ExpoVideoMetadata not supported on Expo Web yet");
+  },
+};

package/src/index.ts

@@ -0,0 +1,22 @@
+import { VideoInfoOptions, VideoInfoResult } from "./ExpoVideoMetadata.types";
+import ExpoVideoMetadataModule from "./ExpoVideoMetadataModule";
+
+export { VideoInfoOptions, VideoInfoResult };
+
+// Import the native module. On web, it will be resolved to ExpoVideoMetadata.web.ts
+// and on native platforms to ExpoVideoMetadata.ts
+
+/**
+ * Create an image thumbnail from video provided via `sourceFilename`.
+ *
+ * @param sourceFilename An URI of the video, local or remote.
+ * @param options Pass `headers` object in case `sourceFilename` is a remote URI, e.g { headers: "Authorization": "Bearer some-token" } etc.
+ *
+ * @return Returns a promise which fulfils with [`VideoInfoResult`](#Videoinforesult).
+ */
+export async function getVideoInfoAsync(
+  sourceFilename: string,
+  options: VideoInfoOptions = {},
+): Promise<VideoInfoResult> {
+  return await ExpoVideoMetadataModule.getVideoInfo(sourceFilename, options);
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*"]
+}