@lodev09/react-native-exify 0.2.7 → 1.0.1

package/Exify.podspec

@@ -1,7 +1,6 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-folly_compiler_flags = '-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1 -Wno-comma -Wno-shorten-64-to-32'
 
 Pod::Spec.new do |s|
   s.name         = "Exify"
@@ -14,27 +13,8 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported }
   s.source       = { :git => "https://github.com/lodev09/react-native-exify.git", :tag => "#{s.version}" }
 
-  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
 
-  # Use install_modules_dependencies helper to install the dependencies if React Native version >=0.71.0.
-  # See https://github.com/facebook/react-native/blob/febf6b7f33fdb4904669f99d795eba4c0f95d7bf/scripts/cocoapods/new_architecture.rb#L79.
-  if respond_to?(:install_modules_dependencies, true)
-    install_modules_dependencies(s)
-  else
-  s.dependency "React-Core"
-
-  # Don't install the dependencies when we run `pod install` in the old architecture.
-  if ENV['RCT_NEW_ARCH_ENABLED'] == '1' then
-    s.compiler_flags = folly_compiler_flags + " -DRCT_NEW_ARCH_ENABLED=1"
-    s.pod_target_xcconfig    = {
-        "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\"",
-        "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
-        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
-    }
-    s.dependency "React-Codegen"
-    s.dependency "RCT-Folly"
-    s.dependency "RCTRequired"
-    s.dependency "RCTTypeSafety"
-   end
-  end    
+  install_modules_dependencies(s)
 end

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 lodev09
+Copyright (c) 2026 lodev09
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights

package/README.md

@@ -1,16 +1,20 @@
 # React Native Exify
 
 [![CI](https://github.com/lodev09/react-native-exify/actions/workflows/ci.yml/badge.svg)](https://github.com/lodev09/react-native-exify/actions/workflows/ci.yml)
-![GitHub Release](https://img.shields.io/github/v/release/lodev09/react-native-exify)
 ![NPM Downloads](https://img.shields.io/npm/dw/%40lodev09%2Freact-native-exify)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/lodev09/react-native-exify)
 
-A simple library to read and write image Exif metadata in React Native. Inspired from [this thread](https://github.com/mrousavy/react-native-vision-camera/issues/780).
+A simple library to read and write image Exif metadata for your React Native Apps. 🏷️
+
+<img alt="@lodev09/react-native-exify" src="preview.gif" width="400" />
 
 ## Features
-* ✅ Read Exif data from an image
-* ✅ Write Exif data into an image
-* ✅ Tags are typed and standardized
-* ✅ Works with Expo and bare React Native projects
+
+* Read Exif data from an image
+* Write Exif data into an image
+* Tags are typed and standardized
+* Works with Expo and bare React Native projects
+* Supports New Architecture (Turbo Module)
 
 ## Installation
 
@@ -20,21 +24,31 @@ yarn add @lodev09/react-native-exify
 
 ## Usage
 
-```ts
-import { writeAsync, readAsync, ExifTags } from '@lodev09/react-native-exify';
+```tsx
+import * as Exify from '@lodev09/react-native-exify';
 ```
 
-### 🧐 Reading Exif
-```ts
-// ...
+### Reading Exif 🔍
+
+```tsx
 const uri = 'file://path/to/image.jpg'
 
-const tags = await readAsync(uri)
+const tags = await Exify.read(uri)
 console.log(tags)
 ```
 
-### ✍️ Writing Exif
-```ts
+> [!IMPORTANT]
+> The `uri` must include a scheme (e.g. `file://`, `ph://`, `content://`). Bare file paths like `/var/mobile/.../image.jpg` are not supported and will throw an error.
+
+> [!NOTE]
+> On Android 10+, GPS data is redacted from `content://` URIs by default. The library automatically requests `ACCESS_MEDIA_LOCATION` at runtime to access unredacted location data. Your app must have media read access (`READ_MEDIA_IMAGES` or `READ_EXTERNAL_STORAGE`) granted first.
+> If you're already using a library like [`expo-media-library`](https://docs.expo.dev/versions/latest/sdk/media-library/) that grants `ACCESS_MEDIA_LOCATION`, exify will use the existing grant.
+
+### Writing Exif ✍️
+
+```tsx
+import type { ExifTags } from '@lodev09/react-native-exify';
+
 const uri = 'file://path/to/image.jpg'
 const newTags: ExifTags = {
   GPSLatitude: 69.69,
@@ -42,17 +56,30 @@ const newTags: ExifTags = {
   UserComment: 'Someone wrote GPS here!',
 }
 
-const result = await writeAsync(uri, newTags)
+const result = await Exify.write(uri, newTags)
 console.log(result.tags)
 ```
 
 > [!NOTE]
-> On IOS, writing exif into an Asset file will duplicate the image. IOS does not allow writing exif into an Asset file directly.
-> If you're getting the photo from a [camera](https://github.com/mrousavy/react-native-vision-camera/), write it into the output file first before saving to the Asset library!
+> On iOS, writing exif into an Asset file will duplicate the image. iOS does not allow writing exif into an Asset file directly.
+> If you're getting the photo from a [camera](https://docs.expo.dev/versions/latest/sdk/camera/), write it into the output file first before saving to the Asset library!
+
+## Example
 
 See [example](example) for more detailed usage.
 
+### Built with True Sheet
+
+The example app uses [@lodev09/react-native-true-sheet](https://github.com/lodev09/react-native-true-sheet) for the image picker UI. Check it out!
+
 ## Contributing
-Contributions are welcome!
 
 See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.
+
+## License
+
+[MIT](LICENSE)
+
+---
+
+Made with ❤️ by [@lodev09](http://linkedin.com/in/lodev09/)

package/android/build.gradle

@@ -1,6 +1,18 @@
 buildscript {
-  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
-  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["Exify_kotlinVersion"]
+  ext.Exify = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return Exify[prop]
+  }
 
   repositories {
     google()
@@ -8,57 +20,30 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:7.2.1"
+    classpath "com.android.tools.build:gradle:8.7.2"
     // noinspection DifferentKotlinGradleVersion
-    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
   }
 }
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
-}
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
-
-def getExtOrDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["Exify_" + name]
-}
-
-def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["Exify_" + name]).toInteger()
-}
-
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
-}
+apply plugin: "com.facebook.react"
 
 android {
-  if (supportsNamespace()) {
-    namespace "com.lodev09.exify"
-
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
+  namespace "com.lodev09.exify"
 
-  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
 
   defaultConfig {
-    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
-    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+  }
 
+  buildFeatures {
+    buildConfig true
   }
 
   buildTypes {
@@ -67,7 +52,7 @@ android {
     }
   }
 
-  lintOptions {
+  lint {
     disable "GradleCompatible"
   }
 
@@ -77,19 +62,7 @@ android {
   }
 }
 
-repositories {
-  mavenCentral()
-  google()
-}
-
-def kotlin_version = getExtOrDefault("kotlinVersion")
-
 dependencies {
-  // For < 0.71, this will be from the local maven repo
-  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
-  // noinspection GradleDynamicVersion
-  implementation "com.facebook.react:react-native:+"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation "com.facebook.react:react-android"
   implementation "androidx.exifinterface:exifinterface:1.3.7"
 }
-

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,3 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.lodev09.exify">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.ACCESS_MEDIA_LOCATION" />
 </manifest>

package/android/src/main/java/com/lodev09/exify/ExifyModule.kt

@@ -1,50 +1,120 @@
 package com.lodev09.exify
 
-import android.content.Context
+import android.Manifest
+import android.content.pm.PackageManager
 import android.net.Uri
+import android.os.Build
+import android.provider.MediaStore
+import androidx.core.content.ContextCompat
 import androidx.exifinterface.media.ExifInterface
-import com.lodev09.exify.ExifyUtils.formatTags
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.ReadableType
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import com.facebook.react.util.RNLog
+import com.lodev09.exify.ExifyUtils.formatTags
 import java.io.IOException
 
 private const val ERROR_TAG = "E_EXIFY_ERROR"
+private const val MEDIA_LOCATION_REQUEST_CODE = 4209
 
-class ExifyModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
+class ExifyModule(
+  reactContext: ReactApplicationContext,
+) : NativeExifyModuleSpec(reactContext) {
+  private val context = reactContext
 
-  private val context: Context = reactContext
+  override fun read(
+    uri: String,
+    promise: Promise,
+  ) {
+    val photoUri = Uri.parse(uri)
+    val scheme = photoUri.scheme
 
-  override fun getName(): String {
-    return NAME
-  }
+    if (scheme == null) {
+      RNLog.w(context, "Exify: URI must include a scheme (e.g. file://): $uri")
+      promise.reject(ERROR_TAG, "URI must include a scheme (e.g. file://): $uri")
+      return
+    }
 
-  @ReactMethod
-  fun readAsync(uri: String, promise: Promise) {
-    val photoUri = Uri.parse(uri)
+    // On Android Q+, request ACCESS_MEDIA_LOCATION for unredacted GPS data
+    if (scheme == "content" && Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q &&
+      ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_MEDIA_LOCATION) !=
+      PackageManager.PERMISSION_GRANTED
+    ) {
+      val activity = context.currentActivity as? PermissionAwareActivity
+      if (activity != null) {
+        activity.requestPermissions(
+          arrayOf(Manifest.permission.ACCESS_MEDIA_LOCATION),
+          MEDIA_LOCATION_REQUEST_CODE,
+          PermissionListener { requestCode, _, _ ->
+            if (requestCode == MEDIA_LOCATION_REQUEST_CODE) {
+              readExif(uri, photoUri, scheme, promise)
+              true
+            } else {
+              false
+            }
+          },
+        )
+        return
+      }
+    }
 
+    readExif(uri, photoUri, scheme, promise)
+  }
+
+  private fun readExif(
+    uri: String,
+    photoUri: Uri,
+    scheme: String,
+    promise: Promise,
+  ) {
     try {
-      context.contentResolver.openInputStream(photoUri)?.use {
-        val tags = formatTags(ExifInterface(it))
-        it.close()
+      val inputStream =
+        if (scheme == "http" || scheme == "https") {
+          java.net.URL(uri).openStream()
+        } else if (scheme == "content" && Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+          try {
+            context.contentResolver.openInputStream(MediaStore.setRequireOriginal(photoUri))
+          } catch (e: SecurityException) {
+            context.contentResolver.openInputStream(photoUri)
+          }
+        } else {
+          context.contentResolver.openInputStream(photoUri)
+        }
+
+      if (inputStream == null) {
+        RNLog.w(context, "Exify: Could not open URI: $uri")
+        promise.reject(ERROR_TAG, "Could not open URI: $uri")
+        return
+      }
 
+      inputStream.use {
+        val tags = formatTags(ExifInterface(it))
         promise.resolve(tags)
       }
     } catch (e: Exception) {
-      promise.resolve(null)
-      e.printStackTrace()
+      RNLog.w(context, "Exify: ${e.message}")
+      promise.reject(ERROR_TAG, e.message, e)
     }
   }
 
-  @ReactMethod
   @Throws(IOException::class)
-  fun writeAsync(uri: String, tags: ReadableMap, promise: Promise) {
+  override fun write(
+    uri: String,
+    tags: ReadableMap,
+    promise: Promise,
+  ) {
     val photoUri = Uri.parse(uri)
+
+    if (photoUri.scheme == null) {
+      RNLog.w(context, "Exify: URI must include a scheme (e.g. file://): $uri")
+      promise.reject(ERROR_TAG, "URI must include a scheme (e.g. file://): $uri")
+      return
+    }
+
     val params = Arguments.createMap()
 
     try {
@@ -57,15 +127,35 @@ class ExifyModule(reactContext: ReactApplicationContext) :
           val type = tags.getType(tag)
 
           when (type) {
-            ReadableType.Boolean -> exif.setAttribute(tag, tags.getBoolean(tag).toString())
-            ReadableType.Number ->
+            ReadableType.Boolean -> {
+              exif.setAttribute(tag, tags.getBoolean(tag).toString())
+            }
+
+            ReadableType.Number -> {
               when (valType) {
-                "double" -> exif.setAttribute(tag, tags.getDouble(tag).toBigDecimal().toPlainString())
+                "double" -> {
+                  val value = tags.getDouble(tag)
+                  if (tag.startsWith("GPS")) {
+                    exif.setAttribute(tag, ExifyUtils.decimalToRational(value))
+                  } else {
+                    exif.setAttribute(tag, value.toBigDecimal().toPlainString())
+                  }
+                }
                 else -> exif.setAttribute(tag, tags.getDouble(tag).toInt().toString())
               }
-            ReadableType.String -> exif.setAttribute(tag, tags.getString(tag))
-            ReadableType.Array -> exif.setAttribute(tag, tags.getArray(tag).toString())
-            else -> exif.setAttribute(tag, tags.getString(tag))
+            }
+
+            ReadableType.String -> {
+              exif.setAttribute(tag, tags.getString(tag))
+            }
+
+            ReadableType.Array -> {
+              exif.setAttribute(tag, tags.getArray(tag).toString())
+            }
+
+            else -> {
+              exif.setAttribute(tag, tags.getString(tag))
+            }
           }
         }
 
@@ -73,14 +163,46 @@ class ExifyModule(reactContext: ReactApplicationContext) :
           tags.hasKey(ExifInterface.TAG_GPS_LATITUDE) &&
           tags.hasKey(ExifInterface.TAG_GPS_LONGITUDE)
         ) {
-          exif.setLatLong(
-            tags.getDouble(ExifInterface.TAG_GPS_LATITUDE),
-            tags.getDouble(ExifInterface.TAG_GPS_LONGITUDE)
-          )
+          val hasExplicitRef =
+            tags.hasKey(ExifInterface.TAG_GPS_LATITUDE_REF) ||
+              tags.hasKey(ExifInterface.TAG_GPS_LONGITUDE_REF)
+
+          if (hasExplicitRef) {
+            val lat = tags.getDouble(ExifInterface.TAG_GPS_LATITUDE)
+            val lng = tags.getDouble(ExifInterface.TAG_GPS_LONGITUDE)
+            val latRef =
+              if (tags.hasKey(ExifInterface.TAG_GPS_LATITUDE_REF)) {
+                tags.getString(ExifInterface.TAG_GPS_LATITUDE_REF)
+              } else {
+                if (lat >= 0) "N" else "S"
+              }
+            val lngRef =
+              if (tags.hasKey(ExifInterface.TAG_GPS_LONGITUDE_REF)) {
+                tags.getString(ExifInterface.TAG_GPS_LONGITUDE_REF)
+              } else {
+                if (lng >= 0) "E" else "W"
+              }
+
+            exif.setAttribute(ExifInterface.TAG_GPS_LATITUDE, ExifyUtils.decimalToDms(Math.abs(lat)))
+            exif.setAttribute(ExifInterface.TAG_GPS_LATITUDE_REF, latRef)
+            exif.setAttribute(ExifInterface.TAG_GPS_LONGITUDE, ExifyUtils.decimalToDms(Math.abs(lng)))
+            exif.setAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF, lngRef)
+          } else {
+            exif.setLatLong(
+              tags.getDouble(ExifInterface.TAG_GPS_LATITUDE),
+              tags.getDouble(ExifInterface.TAG_GPS_LONGITUDE),
+            )
+          }
         }
 
         if (tags.hasKey(ExifInterface.TAG_GPS_ALTITUDE)) {
-          exif.setAltitude(tags.getDouble(ExifInterface.TAG_GPS_ALTITUDE))
+          val alt = tags.getDouble(ExifInterface.TAG_GPS_ALTITUDE)
+          if (tags.hasKey(ExifInterface.TAG_GPS_ALTITUDE_REF)) {
+            exif.setAttribute(ExifInterface.TAG_GPS_ALTITUDE, ExifyUtils.decimalToRational(Math.abs(alt)))
+            exif.setAttribute(ExifInterface.TAG_GPS_ALTITUDE_REF, tags.getInt(ExifInterface.TAG_GPS_ALTITUDE_REF).toString())
+          } else {
+            exif.setAltitude(alt)
+          }
         }
 
         params.putString("uri", uri)
@@ -89,7 +211,6 @@ class ExifyModule(reactContext: ReactApplicationContext) :
         exif.saveAttributes()
         promise.resolve(params)
       }
-
     } catch (e: Exception) {
       promise.reject(ERROR_TAG, e.message, e)
       e.printStackTrace()
@@ -97,6 +218,6 @@ class ExifyModule(reactContext: ReactApplicationContext) :
   }
 
   companion object {
-    const val NAME = "Exify"
+    const val NAME = NativeExifyModuleSpec.NAME
   }
 }

package/android/src/main/java/com/lodev09/exify/ExifyPackage.kt

@@ -1,17 +1,35 @@
 package com.lodev09.exify
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
 
+class ExifyPackage : BaseReactPackage() {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? =
+    if (name == ExifyModule.NAME) {
+      ExifyModule(reactContext)
+    } else {
+      null
+    }
 
-class ExifyPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(ExifyModule(reactContext))
-  }
-
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
-  }
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider {
+      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
+      moduleInfos[ExifyModule.NAME] =
+        ReactModuleInfo(
+          ExifyModule.NAME,
+          ExifyModule.NAME,
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          false, // isCxxModule
+          true, // isTurboModule
+        )
+      moduleInfos
+    }
 }