expo-image-to-video 0.1.2 → 0.1.3

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'expo.modules.imagetovideo'
-version = '0.1.2'
+version = '0.1.3'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 apply from: expoModulesCorePlugin
@@ -35,9 +35,27 @@ android {
   namespace "expo.modules.imagetovideo"
   defaultConfig {
     versionCode 1
-    versionName "0.1.2"
+    versionName "0.1.3"
   }
   lintOptions {
     abortOnError false
   }
 }
+
+dependencies {
+    // 2. Kotlin Standard Library (SDK 54 uses Kotlin 1.9+)
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+
+    // 3. Android KTX for cleaner Kotlin code
+    implementation "androidx.core:core-ktx:1.12.0"
+
+    // 4. Coroutines for background processing (Critical for VideoEncoder)
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+
+    // 5. EXIF support for image rotation handling
+    implementation "androidx.exifinterface:exifinterface:1.3.6"
+    
+    // 6. Lifecycle KTX (Useful if you want to scope encoding to the app lifecycle)
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.7.0"
+}

package/android/src/main/java/expo/modules/imagetovideo/ImageUtils.kt

@@ -0,0 +1,80 @@
+package expo.modules.imagetovideo
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import android.net.Uri
+import androidx.exifinterface.media.ExifInterface
+import java.io.InputStream
+
+object ImageUtils {
+    /**
+     * Loads a bitmap from a URI, scales it to fit the target dimensions,
+     * and corrects the orientation based on EXIF data.
+     */
+    fun loadBitmap(context: Context, uriString: String, targetWidth: Int, targetHeight: Int): Bitmap? {
+        val uri = Uri.parse(uriString)
+        var inputStream: InputStream? = null
+        
+        try {
+            // 1. Get dimensions without loading into memory
+            val options = BitmapFactory.Options().apply {
+                inJustDecodeBounds = true
+            }
+            context.contentResolver.openInputStream(uri).use { 
+                BitmapFactory.decodeStream(it, null, options) 
+            }
+
+            // 2. Calculate scaling to save memory (OOM Prevention)
+            options.inSampleSize = calculateInSampleSize(options, targetWidth, targetHeight)
+            options.inJustDecodeBounds = false
+
+            // 3. Decode the actual bitmap
+            val decodedBitmap = context.contentResolver.openInputStream(uri).use {
+                BitmapFactory.decodeStream(it, null, options)
+            } ?: return null
+
+            // 4. Correct rotation if needed (common with phone photos)
+            return rotateImageIfRequired(context, decodedBitmap, uri)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return null
+        }
+    }
+
+    private fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
+        val (height: Int, width: Int) = options.outHeight to options.outWidth
+        var inSampleSize = 1
+
+        if (height > reqHeight || width > reqWidth) {
+            val halfHeight: Int = height / 2
+            val halfWidth: Int = width / 2
+            while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) {
+                inSampleSize *= 2
+            }
+        }
+        return inSampleSize
+    }
+
+    private fun rotateImageIfRequired(context: Context, img: Bitmap, selectedImage: Uri): Bitmap {
+        val input = context.contentResolver.openInputStream(selectedImage) ?: return img
+        val ei = ExifInterface(input)
+        val orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)
+
+        return when (orientation) {
+            ExifInterface.ORIENTATION_ROTATE_90 -> rotateImage(img, 90f)
+            ExifInterface.ORIENTATION_ROTATE_180 -> rotateImage(img, 180f)
+            ExifInterface.ORIENTATION_ROTATE_270 -> rotateImage(img, 270f)
+            else -> img
+        }
+    }
+
+    private fun rotateImage(img: Bitmap, degree: Float): Bitmap {
+        val matrix = Matrix()
+        matrix.postRotate(degree)
+        val rotatedImg = Bitmap.createBitmap(img, 0, 0, img.width, img.height, matrix, true)
+        img.recycle()
+        return rotatedImg
+    }
+}

package/ios/ExpoImageToVideo.podspec

@@ -20,7 +20,8 @@ Pod::Spec.new do |s|
 
   s.dependency 'ExpoModulesCore'
 
-  s.frameworks = 'AVFoundation', 'CoreMedia', 'CoreVideo', 'UIKit'
+  #s.frameworks = 'AVFoundation', 'CoreMedia', 'CoreVideo', 'UIKit'
+  s.frameworks = 'AVFoundation', 'CoreMedia', 'CoreVideo', 'UIKit', 'CoreGraphics'
 
   # Swift/Objective-C compatibility
   s.pod_target_xcconfig = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-image-to-video",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "High-performance native image-to-video conversion for Expo",
   "main": "build/index.js",
   "types": "build/index.d.ts",