@developer_tribe/react-native-comnyx 0.13.13 → 0.15.0

package/android/src/main/java/com/comnyx/ComnyxMediaPickerModule.kt

@@ -0,0 +1,347 @@
+package com.comnyx
+
+import android.app.Activity
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.net.Uri
+import android.provider.OpenableColumns
+import android.webkit.MimeTypeMap
+import com.facebook.react.bridge.*
+import java.io.File
+import java.io.FileOutputStream
+import java.io.InputStream
+import android.media.MediaMetadataRetriever
+
+class ComnyxMediaPickerModule(reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext), ActivityEventListener {
+
+  companion object {
+    const val NAME = "ComnyxMediaPicker"
+    private const val REQUEST_MEDIA = 2003
+    private const val REQUEST_IMAGE = 2004
+    private const val REQUEST_VIDEO = 2005
+    private const val COMPRESS_THRESHOLD = 500 * 1024 // 500KB
+    private const val COMPRESS_QUALITY = 80
+  }
+
+  private var promise: Promise? = null
+
+  private fun rejectPendingPromise() {
+    promise?.reject("CANCELLED", "A new picker request was made before the previous one completed")
+    promise = null
+  }
+
+  init {
+    reactContext.addActivityEventListener(this)
+  }
+
+  override fun getName(): String = NAME
+
+
+
+  // MARK: - Pick Media (both images and videos)
+
+  @ReactMethod
+  fun pickMedia(promise: Promise) {
+    rejectPendingPromise()
+    this.promise = promise
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      promise.reject("NO_ACTIVITY", "Activity is not available")
+      return
+    }
+    val intent = Intent(Intent.ACTION_GET_CONTENT).apply {
+      type = "*/*"
+      putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("image/*", "video/*"))
+      putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+      addCategory(Intent.CATEGORY_OPENABLE)
+    }
+    activity.startActivityForResult(intent, REQUEST_MEDIA)
+  }
+
+  // MARK: - Pick Image Only
+
+  @ReactMethod
+  fun pickImage(promise: Promise) {
+    rejectPendingPromise()
+    this.promise = promise
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      promise.reject("NO_ACTIVITY", "Activity is not available")
+      return
+    }
+    val intent = Intent(Intent.ACTION_GET_CONTENT).apply {
+      type = "image/*"
+      putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+      addCategory(Intent.CATEGORY_OPENABLE)
+    }
+    activity.startActivityForResult(intent, REQUEST_IMAGE)
+  }
+
+  // MARK: - Pick Video Only
+
+  @ReactMethod
+  fun pickVideo(promise: Promise) {
+    rejectPendingPromise()
+    this.promise = promise
+    val activity = reactApplicationContext.currentActivity
+    if (activity == null) {
+      promise.reject("NO_ACTIVITY", "Activity is not available")
+      return
+    }
+    val intent = Intent(Intent.ACTION_GET_CONTENT).apply {
+      type = "video/*"
+      putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
+      addCategory(Intent.CATEGORY_OPENABLE)
+    }
+    activity.startActivityForResult(intent, REQUEST_VIDEO)
+  }
+
+  // MARK: - Generate Thumbnail from Video URL
+
+  @ReactMethod
+  fun generateThumbnail(videoUrl: String, promise: Promise) {
+    android.util.Log.d("ComnyxMedia", "generateThumbnail called with: $videoUrl")
+    Thread {
+      try {
+        val retriever = MediaMetadataRetriever()
+        if (videoUrl.startsWith("http://") || videoUrl.startsWith("https://")) {
+          android.util.Log.d("ComnyxMedia", "Setting remote data source")
+          retriever.setDataSource(videoUrl, HashMap<String, String>())
+        } else {
+          android.util.Log.d("ComnyxMedia", "Setting local data source")
+          retriever.setDataSource(reactApplicationContext, Uri.parse(videoUrl))
+        }
+        val bitmap = retriever.getFrameAtTime(0, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
+        retriever.release()
+
+        if (bitmap != null) {
+          android.util.Log.d("ComnyxMedia", "Thumbnail bitmap generated: ${bitmap.width}x${bitmap.height}")
+          val thumbFile = File(reactApplicationContext.cacheDir, "thumb_${System.currentTimeMillis()}.jpg")
+          FileOutputStream(thumbFile).use { fos ->
+            bitmap.compress(Bitmap.CompressFormat.JPEG, 80, fos)
+          }
+          bitmap.recycle()
+          promise.resolve("file://" + thumbFile.absolutePath)
+        } else {
+          android.util.Log.d("ComnyxMedia", "Thumbnail bitmap is null")
+          promise.resolve(null)
+        }
+      } catch (e: Exception) {
+        android.util.Log.e("ComnyxMedia", "generateThumbnail error: ${e.message}", e)
+        promise.resolve(null)
+      }
+    }.start()
+  }
+
+  // MARK: - Open Video
+
+  @ReactMethod
+  fun openVideo(uri: String, promise: Promise) {
+    try {
+      val activity = reactApplicationContext.currentActivity
+      if (activity == null) {
+        promise.reject("NO_ACTIVITY", "Activity is not available")
+        return
+      }
+
+      if (uri.startsWith("http://") || uri.startsWith("https://")) {
+        // Remote URL — use system player for faster streaming
+        val intent = Intent(Intent.ACTION_VIEW).apply {
+          setDataAndType(Uri.parse(uri), "video/*")
+          addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+        activity.startActivity(intent)
+        promise.resolve(null)
+      } else {
+        // Local file — use custom VideoPlayerActivity
+        val intent = Intent(activity, VideoPlayerActivity::class.java).apply {
+          putExtra("video_uri", uri)
+        }
+        activity.startActivity(intent)
+        promise.resolve(null)
+      }
+    } catch (e: Exception) {
+      promise.reject("OPEN_ERROR", e.message, e)
+    }
+  }
+
+  // MARK: - Activity Result
+
+  override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+    if (requestCode != REQUEST_MEDIA && requestCode != REQUEST_IMAGE && requestCode != REQUEST_VIDEO) return
+
+    if (resultCode != Activity.RESULT_OK || data == null) {
+      promise?.resolve(null)
+      promise = null
+      return
+    }
+
+    // Collect all selected URIs
+    val uris = mutableListOf<Uri>()
+    val clipData = data.clipData
+    if (clipData != null) {
+      for (i in 0 until clipData.itemCount) {
+        uris.add(clipData.getItemAt(i).uri)
+      }
+    } else if (data.data != null) {
+      uris.add(data.data!!)
+    }
+
+    if (uris.isEmpty()) {
+      promise?.resolve(null)
+      promise = null
+      return
+    }
+
+    // Capture and clear promise to prevent double-resolve races
+    val currentPromise = promise
+    promise = null
+
+    // Move all heavy I/O to a background thread to prevent ANR
+    Thread {
+      try {
+        val context = reactApplicationContext
+        val contentResolver = context.contentResolver
+        val resultsArray = Arguments.createArray()
+
+        for (uri in uris) {
+          val mimeTypeStr = contentResolver.getType(uri) ?: ""
+          val isImage = mimeTypeStr.startsWith("image")
+          val mimeType = contentResolver.getType(uri) ?: if (isImage) "image/jpeg" else "video/mp4"
+
+          // Get file name
+          var fileName = "file_${System.currentTimeMillis()}"
+          val cursor = contentResolver.query(uri, null, null, null, null)
+          cursor?.use {
+            if (it.moveToFirst()) {
+              val nameIndex = it.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+              if (nameIndex >= 0) {
+                fileName = it.getString(nameIndex) ?: fileName
+              }
+            }
+          }
+
+          // Copy to temp file
+          val tempFile = File(context.cacheDir, "${System.currentTimeMillis()}_$fileName")
+          contentResolver.openInputStream(uri)?.use { inputStream ->
+            FileOutputStream(tempFile).use { outputStream ->
+              inputStream.copyTo(outputStream)
+            }
+          }
+
+          var finalFile = tempFile
+          var finalMimeType = mimeType
+          var finalFileSize = tempFile.length()
+
+          // Compress image if >500KB
+          if (isImage && finalFileSize > COMPRESS_THRESHOLD) {
+            val compressed = compressImage(tempFile)
+            if (compressed != null) {
+              tempFile.delete()
+              finalFile = compressed
+              finalMimeType = "image/jpeg"
+              finalFileSize = compressed.length()
+            }
+          }
+
+          val result = Arguments.createMap().apply {
+            putString("uri", Uri.fromFile(finalFile).toString())
+            putString("type", if (isImage) "image" else "video")
+            putString("fileName", finalFile.name)
+            putDouble("fileSize", finalFileSize.toDouble())
+            putString("mimeType", finalMimeType)
+            if (!isImage) {
+              val thumbnailUri = generateVideoThumbnail(finalFile)
+              if (thumbnailUri != null) {
+                putString("thumbnailUri", thumbnailUri)
+              }
+            }
+          }
+          resultsArray.pushMap(result)
+        }
+
+        currentPromise?.resolve(resultsArray)
+      } catch (e: Exception) {
+        currentPromise?.reject("PICK_ERROR", e.message, e)
+      }
+    }.start()
+  }
+
+  override fun onNewIntent(intent: Intent) {
+    // Not needed
+  }
+
+  // MARK: - Image Compression
+
+  private fun compressImage(file: File): File? {
+    return try {
+      val bitmap = BitmapFactory.decodeFile(file.absolutePath) ?: return null
+      val compressedFile = File(reactApplicationContext.cacheDir, "compressed_${System.currentTimeMillis()}.jpg")
+      FileOutputStream(compressedFile).use { outputStream ->
+        bitmap.compress(Bitmap.CompressFormat.JPEG, COMPRESS_QUALITY, outputStream)
+      }
+      bitmap.recycle()
+      compressedFile
+    } catch (e: Exception) {
+      null
+    }
+  }
+
+  private fun generateVideoThumbnail(videoFile: File): String? {
+    return try {
+      val retriever = MediaMetadataRetriever()
+      retriever.setDataSource(videoFile.absolutePath)
+      val bitmap = retriever.getFrameAtTime(0, MediaMetadataRetriever.OPTION_CLOSEST_SYNC)
+      retriever.release()
+      if (bitmap != null) {
+        val thumbFile = File(reactApplicationContext.cacheDir, "thumb_${System.currentTimeMillis()}.jpg")
+        FileOutputStream(thumbFile).use { outputStream ->
+          bitmap.compress(Bitmap.CompressFormat.JPEG, 70, outputStream)
+        }
+        bitmap.recycle()
+        Uri.fromFile(thumbFile).toString()
+      } else null
+    } catch (e: Exception) {
+      null
+    }
+  }
+
+  @ReactMethod
+  fun deleteTempFile(uri: String, promise: Promise) {
+    Thread {
+      try {
+        val path = uri.removePrefix("file://")
+        val file = File(path)
+        if (file.exists()) {
+          file.delete()
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.resolve(null)
+      }
+    }.start()
+  }
+
+  @ReactMethod
+  fun cleanupTempFiles(promise: Promise) {
+    Thread {
+      try {
+        val cacheDir = reactApplicationContext.cacheDir
+        val files = cacheDir.listFiles() ?: emptyArray()
+        for (file in files) {
+          val name = file.name.lowercase()
+          if (name.startsWith("thumb_") || name.startsWith("compressed_") ||
+            (name.contains("_") && (name.endsWith(".jpg") || name.endsWith(".jpeg") ||
+              name.endsWith(".png") || name.endsWith(".mp4") || name.endsWith(".mov")))) {
+            file.delete()
+          }
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.resolve(null)
+      }
+    }.start()
+  }
+}

package/android/src/main/java/com/comnyx/ComnyxPackage.kt

@@ -7,7 +7,7 @@ import com.facebook.react.uimanager.ViewManager
 
 class ComnyxPackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(ComnyxModule(reactContext))
+        return listOf(ComnyxModule(reactContext), ComnyxMediaPickerModule(reactContext))
     }
 
     override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {

package/android/src/main/java/com/comnyx/VideoPlayerActivity.kt

@@ -0,0 +1,91 @@
+package com.comnyx
+
+import android.net.Uri
+import android.os.Bundle
+import android.view.Gravity
+import android.view.Window
+import android.view.WindowManager
+import android.widget.FrameLayout
+import android.widget.ImageButton
+import android.widget.ProgressBar
+import android.widget.VideoView
+import android.app.Activity as AndroidActivity
+import android.widget.MediaController
+
+class VideoPlayerActivity : AndroidActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // Full screen
+        requestWindowFeature(Window.FEATURE_NO_TITLE)
+        window.setFlags(
+            WindowManager.LayoutParams.FLAG_FULLSCREEN,
+            WindowManager.LayoutParams.FLAG_FULLSCREEN
+        )
+
+        val container = FrameLayout(this)
+        container.setBackgroundColor(android.graphics.Color.BLACK)
+
+        val videoView = VideoView(this)
+        val videoParams = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            Gravity.CENTER
+        )
+        container.addView(videoView, videoParams)
+
+        // Loading spinner
+        val progressBar = ProgressBar(this)
+        val progressParams = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.WRAP_CONTENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT,
+            Gravity.CENTER
+        )
+        container.addView(progressBar, progressParams)
+
+        // Close button (X) top-right
+        val closeButton = ImageButton(this)
+        closeButton.setBackgroundColor(android.graphics.Color.TRANSPARENT)
+        closeButton.setImageResource(android.R.drawable.ic_menu_close_clear_cancel)
+        closeButton.setColorFilter(android.graphics.Color.WHITE)
+        closeButton.setPadding(24, 24, 24, 24)
+        val closeParams = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.WRAP_CONTENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT,
+            Gravity.TOP or Gravity.END
+        )
+        closeParams.topMargin = 60
+        closeParams.rightMargin = 24
+        container.addView(closeButton, closeParams)
+
+        closeButton.setOnClickListener {
+            finish()
+        }
+
+        setContentView(container)
+
+        val videoUri = intent.getStringExtra("video_uri") ?: run {
+            finish()
+            return
+        }
+
+        // MediaController for play/pause/seek controls
+        val mediaController = MediaController(this)
+        mediaController.setAnchorView(videoView)
+        videoView.setMediaController(mediaController)
+
+        videoView.setVideoURI(Uri.parse(videoUri))
+        videoView.setOnPreparedListener { mp ->
+            progressBar.visibility = android.view.View.GONE
+            mp.isLooping = false
+            videoView.start()
+        }
+        videoView.setOnCompletionListener {
+            finish()
+        }
+        videoView.setOnErrorListener { _, _, _ ->
+            finish()
+            true
+        }
+    }
+}

package/ios/ComnyxMediaPicker.m

@@ -0,0 +1,29 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(ComnyxMediaPicker, NSObject)
+
+RCT_EXTERN_METHOD(pickMedia:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(pickImage:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(pickVideo:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(generateThumbnail:(NSString *)videoUrl
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(openVideo:(NSString *)uri
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(deleteTempFile:(NSString *)uri
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(cleanupTempFiles:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+@end