react-native-libyuv-resizer 0.2.0

package/android/src/androidTest/java/com/libyuvresizer/LibyuvResizerModuleOutputPathTest.kt

@@ -0,0 +1,96 @@
+package com.libyuvresizer
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import com.facebook.react.bridge.ReadableMap
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+class LibyuvResizerModuleOutputPathTest {
+
+  private lateinit var module: LibyuvResizerModule
+  private lateinit var reactContext: FakeReactContext
+  private val createdFiles = mutableListOf<String>()
+  private lateinit var srcPath: String
+
+  @Before
+  fun setUp() {
+    val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    reactContext = FakeReactContext(ctx)
+    module = LibyuvResizerModule(reactContext)
+    srcPath = TestFixtures.createJpeg(reactContext, 120, 80, "output_path_src.jpg")
+    createdFiles += srcPath
+  }
+
+  @After
+  fun tearDown() {
+    createdFiles.forEach { TestFixtures.deleteIfExists(it) }
+    createdFiles.clear()
+  }
+
+  private fun resize(outputPath: String = "", quality: Double = 80.0, format: String = "jpeg"): FakePromise {
+    val promise = FakePromise()
+    module.resize(srcPath, 60.0, 60.0, quality, 0.0, "contain", outputPath, "box", false, format, promise)
+    return promise
+  }
+
+  @Test
+  fun resize_emptyOutputPath_writesToCacheDir() {
+    val promise = resize(outputPath = "")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue(
+      "output must be inside cacheDir",
+      outPath.startsWith(reactContext.cacheDir.absolutePath)
+    )
+    assertTrue(File(outPath).exists())
+  }
+
+  @Test
+  fun resize_customOutputPath_writesToProvidedDir() {
+    val destDir = reactContext.filesDir
+    val promise = resize(outputPath = destDir.absolutePath)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue(
+      "output must be inside filesDir",
+      outPath.startsWith(destDir.absolutePath)
+    )
+    assertTrue(File(outPath).exists())
+  }
+
+  @Test
+  fun resize_customOutputPath_keepsInputFilename() {
+    // resolveOutputFile uses File(inputFilePath).name → output filename = input filename.
+    // "output_path_src.jpg" is kept even when quality=100 (ext would be "png").
+    val destDir = reactContext.filesDir
+    val promise = resize(outputPath = destDir.absolutePath)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    val outputFilename = File(outPath).name
+    assertEquals("output_path_src.jpg", outputFilename)
+  }
+
+  @Test
+  fun resize_formatPng_emptyOutputPath_usesPngExtension() {
+    val promise = resize(outputPath = "", format = "png")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output must end with .png", outPath.endsWith(".png"))
+    assertTrue(File(outPath).exists())
+  }
+}

package/android/src/androidTest/java/com/libyuvresizer/LibyuvResizerModuleRotationTest.kt

@@ -0,0 +1,120 @@
+package com.libyuvresizer
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import com.facebook.react.bridge.ReadableMap
+import java.io.File
+
+@RunWith(AndroidJUnit4::class)
+class LibyuvResizerModuleRotationTest {
+
+  private lateinit var module: LibyuvResizerModule
+  private lateinit var reactContext: FakeReactContext
+  private val createdFiles = mutableListOf<String>()
+
+  // 200x100 landscape source used in all rotation tests (no inSampleSize reduction at small targets)
+  private lateinit var landscapeSrc: String
+
+  @Before
+  fun setUp() {
+    val ctx = InstrumentationRegistry.getInstrumentation().targetContext
+    reactContext = FakeReactContext(ctx)
+    module = LibyuvResizerModule(reactContext)
+    landscapeSrc = TestFixtures.createJpeg(reactContext, 200, 100, "rotation_src.jpg")
+    createdFiles += landscapeSrc
+  }
+
+  @After
+  fun tearDown() {
+    createdFiles.forEach { TestFixtures.deleteIfExists(it) }
+    createdFiles.clear()
+  }
+
+  private fun resize(
+    filePath: String,
+    targetW: Double,
+    targetH: Double,
+    rotation: Double,
+    mode: String = "contain"
+  ): FakePromise {
+    val promise = FakePromise()
+    module.resize(filePath, targetW, targetH, 80.0, rotation, mode, "", "box", false, "jpeg", promise)
+    return promise
+  }
+
+  @Test
+  fun resize_rotation0_usesNativeResizeBranch() {
+    // rot == 0 → nativeResize path. 200x100 → 300x300 contain → 300x150
+    val promise = resize(landscapeSrc, 300.0, 300.0, 0.0)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    assertTrue("output file must exist", File(outPath).exists())
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(300, w)
+    assertEquals(150, h)
+  }
+
+  @Test
+  fun resize_rotation90_swapsDimensions() {
+    // rot=90 → nativeResizeAndRotate path.
+    // srcBitmap 200x100, effectiveW=srcH=100, effectiveH=srcW=200.
+    // contain: scale=min(300/100, 300/200)=min(3.0,1.5)=1.5 → (floor(150), floor(300)) = 150x300
+    val promise = resize(landscapeSrc, 300.0, 300.0, 90.0)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(150, w)
+    assertEquals(300, h)
+  }
+
+  @Test
+  fun resize_rotation180_doesNotSwapDimensions() {
+    // rot=180 → effectiveW=srcW=200, effectiveH=srcH=100 (no swap).
+    // contain: scale=min(300/200, 300/100)=1.5 → (floor(300), floor(150)) = 300x150 (same as rot=0)
+    val promise = resize(landscapeSrc, 300.0, 300.0, 180.0)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(300, w)
+    assertEquals(150, h)
+  }
+
+  @Test
+  fun resize_rotation270_swapsDimensions() {
+    // rot=270 → same swap logic as 90 → 150x300
+    val promise = resize(landscapeSrc, 300.0, 300.0, 270.0)
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(150, w)
+    assertEquals(300, h)
+  }
+
+  @Test
+  fun resize_rotation90_stretch_targetDimsIgnoreRotation() {
+    // stretch with rotation: target dims are returned as-is (ignores rotation).
+    // 200x100 → target 120x80 stretch → output 120x80 regardless of rotation.
+    val promise = resize(landscapeSrc, 120.0, 80.0, 90.0, mode = "stretch")
+
+    assertTrue(promise.resolved)
+    val outPath = (promise.result as ReadableMap).getString("path")!!
+    createdFiles += outPath
+    val (w, h) = TestFixtures.decodeDimensions(outPath)
+    assertEquals(120, w)
+    assertEquals(80, h)
+  }
+}

package/android/src/androidTest/java/com/libyuvresizer/TestFixtures.kt

@@ -0,0 +1,48 @@
+package com.libyuvresizer
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Color
+import androidx.exifinterface.media.ExifInterface
+import java.io.File
+import java.io.FileOutputStream
+
+object TestFixtures {
+
+  fun createJpeg(context: Context, width: Int, height: Int, name: String): String {
+    val bmp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888).apply {
+      eraseColor(Color.BLUE)
+    }
+    val file = File(context.cacheDir, name)
+    FileOutputStream(file).use { bmp.compress(Bitmap.CompressFormat.JPEG, 80, it) }
+    bmp.recycle()
+    return file.absolutePath
+  }
+
+  fun createPng(context: Context, width: Int, height: Int, name: String): String {
+    val bmp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888).apply {
+      eraseColor(Color.GREEN)
+    }
+    val file = File(context.cacheDir, name)
+    FileOutputStream(file).use { bmp.compress(Bitmap.CompressFormat.PNG, 0, it) }
+    bmp.recycle()
+    return file.absolutePath
+  }
+
+  fun createCorruptFile(context: Context, name: String): String {
+    val file = File(context.cacheDir, name)
+    file.writeBytes(byteArrayOf(0xFF.toByte(), 0xD8.toByte(), 0x00, 0x01, 0x02))
+    return file.absolutePath
+  }
+
+  fun decodeDimensions(path: String): Pair<Int, Int> {
+    val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+    BitmapFactory.decodeFile(path, opts)
+    return Pair(opts.outWidth, opts.outHeight)
+  }
+
+  fun deleteIfExists(path: String?) {
+    path?.let { File(it).delete() }
+  }
+}

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/cpp/LibyuvResizerModule.cpp

@@ -0,0 +1,137 @@
+#include <jni.h>
+#include <android/bitmap.h>
+#include <cstdlib>
+#include "libyuv/scale_argb.h"
+#include "libyuv/rotate_argb.h"
+
+namespace {
+
+struct MallocGuard {
+    uint8_t* ptr;
+    explicit MallocGuard(size_t n) : ptr(static_cast<uint8_t*>(std::malloc(n))) {}
+    ~MallocGuard() { std::free(ptr); }
+    MallocGuard(const MallocGuard&) = delete;
+    MallocGuard& operator=(const MallocGuard&) = delete;
+};
+
+} // namespace
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_libyuvresizer_LibyuvResizerModule_nativeResize(
+    JNIEnv* env,
+    jobject /* thiz */,
+    jobject srcBitmap,
+    jobject dstBitmap,
+    jint filterMode
+) {
+    AndroidBitmapInfo srcInfo{}, dstInfo{};
+    AndroidBitmap_getInfo(env, srcBitmap, &srcInfo);
+    AndroidBitmap_getInfo(env, dstBitmap, &dstInfo);
+
+    void* srcPixels = nullptr;
+    void* dstPixels = nullptr;
+
+    if (AndroidBitmap_lockPixels(env, srcBitmap, &srcPixels) < 0) {
+        jclass ex = env->FindClass("java/lang/RuntimeException");
+        env->ThrowNew(ex, "AndroidBitmap_lockPixels failed (src)");
+        return;
+    }
+    if (AndroidBitmap_lockPixels(env, dstBitmap, &dstPixels) < 0) {
+        AndroidBitmap_unlockPixels(env, srcBitmap);
+        jclass ex = env->FindClass("java/lang/RuntimeException");
+        env->ThrowNew(ex, "AndroidBitmap_lockPixels failed (dst)");
+        return;
+    }
+
+    libyuv::ARGBScale(
+        static_cast<const uint8_t*>(srcPixels), static_cast<int>(srcInfo.stride),
+        static_cast<int>(srcInfo.width),  static_cast<int>(srcInfo.height),
+        static_cast<uint8_t*>(dstPixels), static_cast<int>(dstInfo.stride),
+        static_cast<int>(dstInfo.width),  static_cast<int>(dstInfo.height),
+        static_cast<libyuv::FilterModeEnum>(filterMode)
+    );
+
+    AndroidBitmap_unlockPixels(env, srcBitmap);
+    AndroidBitmap_unlockPixels(env, dstBitmap);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_libyuvresizer_LibyuvResizerModule_nativeResizeAndRotate(
+    JNIEnv* env,
+    jobject /* thiz */,
+    jobject srcBitmap,
+    jobject dstBitmap,
+    jint rotation,
+    jint filterMode
+) {
+    AndroidBitmapInfo srcInfo{}, dstInfo{};
+    AndroidBitmap_getInfo(env, srcBitmap, &srcInfo);
+    AndroidBitmap_getInfo(env, dstBitmap, &dstInfo);
+
+    // 90/270 rotations swap output dims — pre-rotation buffer has transposed size
+    const bool swap = (rotation == 90 || rotation == 270);
+    const uint32_t preW = swap ? dstInfo.height : dstInfo.width;
+    const uint32_t preH = swap ? dstInfo.width  : dstInfo.height;
+    // use size_t to avoid uint32_t overflow on large images
+    const size_t preStride  = static_cast<size_t>(preW) * 4;
+    const size_t allocSize  = preStride * static_cast<size_t>(preH);
+
+    MallocGuard preBuf(allocSize);
+    if (!preBuf.ptr) {
+        jclass ex = env->FindClass("java/lang/OutOfMemoryError");
+        env->ThrowNew(ex, "nativeResizeAndRotate: malloc failed");
+        return;
+    }
+
+    void* srcPixels = nullptr;
+    void* dstPixels = nullptr;
+
+    if (AndroidBitmap_lockPixels(env, srcBitmap, &srcPixels) < 0) {
+        jclass ex = env->FindClass("java/lang/RuntimeException");
+        env->ThrowNew(ex, "AndroidBitmap_lockPixels failed (src)");
+        return;  // preBuf freed by MallocGuard dtor
+    }
+    if (AndroidBitmap_lockPixels(env, dstBitmap, &dstPixels) < 0) {
+        AndroidBitmap_unlockPixels(env, srcBitmap);
+        jclass ex = env->FindClass("java/lang/RuntimeException");
+        env->ThrowNew(ex, "AndroidBitmap_lockPixels failed (dst)");
+        return;  // preBuf freed by MallocGuard dtor
+    }
+
+    const int scaleResult = libyuv::ARGBScale(
+        static_cast<const uint8_t*>(srcPixels), static_cast<int>(srcInfo.stride),
+        static_cast<int>(srcInfo.width), static_cast<int>(srcInfo.height),
+        preBuf.ptr, static_cast<int>(preStride),
+        static_cast<int>(preW), static_cast<int>(preH),
+        static_cast<libyuv::FilterModeEnum>(filterMode)
+    );
+
+    if (scaleResult != 0) {
+        AndroidBitmap_unlockPixels(env, srcBitmap);
+        AndroidBitmap_unlockPixels(env, dstBitmap);
+        jclass ex = env->FindClass("java/lang/RuntimeException");
+        env->ThrowNew(ex, "ARGBScale failed");
+        return;
+    }
+
+    libyuv::RotationMode mode = libyuv::kRotate0;
+    if (rotation == 90)  mode = libyuv::kRotate90;
+    if (rotation == 180) mode = libyuv::kRotate180;
+    if (rotation == 270) mode = libyuv::kRotate270;
+
+    const int rotateResult = libyuv::ARGBRotate(
+        preBuf.ptr, static_cast<int>(preStride),
+        static_cast<uint8_t*>(dstPixels), static_cast<int>(dstInfo.stride),
+        static_cast<int>(preW), static_cast<int>(preH),
+        mode
+    );
+
+    AndroidBitmap_unlockPixels(env, srcBitmap);
+    AndroidBitmap_unlockPixels(env, dstBitmap);
+
+    if (rotateResult != 0) {
+        jclass ex = env->FindClass("java/lang/RuntimeException");
+        env->ThrowNew(ex, "ARGBRotate failed");
+    }
+    // MallocGuard frees preBuf on scope exit
+}

package/android/src/main/java/com/libyuvresizer/DimensionCalculator.kt

@@ -0,0 +1,52 @@
+package com.libyuvresizer
+
+import kotlin.math.roundToInt
+
+object DimensionCalculator {
+  fun calculateInSampleSize(srcW: Int, srcH: Int, dstW: Int, dstH: Int): Int {
+    var sampleSize = 1
+    if (srcH > dstH || srcW > dstW) {
+      val halfH = srcH / 2
+      val halfW = srcW / 2
+      while (halfH / sampleSize >= dstH && halfW / sampleSize >= dstW) sampleSize *= 2
+    }
+    return sampleSize
+  }
+
+  // floor=true uses toInt() to ensure contain mode never exceeds target dimensions
+  fun scaleBy(scale: Double, w: Double, h: Double, floor: Boolean = false): Pair<Int, Int> {
+    val round: (Double) -> Int = if (floor) Double::toInt else Double::roundToInt
+    return Pair(maxOf(1, round(w * scale)), maxOf(1, round(h * scale)))
+  }
+
+  // For 90°/270°, srcW and srcH are the *raw bitmap* dims (before rotation).
+  // effectiveW/H are swapped to represent the post-rotation logical dims used for scale math.
+  fun computeDstDims(
+    srcW: Double,
+    srcH: Double,
+    targetW: Int,
+    targetH: Int,
+    rotation: Int,
+    mode: String
+  ): Pair<Int, Int> {
+    val (effectiveW, effectiveH) = if (rotation == 90 || rotation == 270)
+      Pair(srcH, srcW)
+    else
+      Pair(srcW, srcH)
+
+    return when (mode) {
+      "stretch" -> Pair(targetW, targetH)
+      "contain" -> scaleBy(
+        minOf(targetW / effectiveW, targetH / effectiveH),
+        effectiveW,
+        effectiveH,
+        floor = true
+      )
+      else -> scaleBy(
+        maxOf(targetW / effectiveW, targetH / effectiveH),
+        effectiveW,
+        effectiveH
+      )
+    }
+  }
+}

package/android/src/main/java/com/libyuvresizer/ExifCopier.kt

@@ -0,0 +1,133 @@
+package com.libyuvresizer
+
+import androidx.exifinterface.media.ExifInterface
+import java.io.IOException
+
+internal object ExifCopier {
+    fun copy(sourcePath: String, destPath: String) {
+        val src = try { ExifInterface(sourcePath) } catch (_: IOException) { return }
+        val dst = ExifInterface(destPath)
+        for (tag in TAGS) {
+            src.getAttribute(tag)?.let { dst.setAttribute(tag, it) }
+        }
+        dst.setAttribute(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL.toString())
+        dst.saveAttributes()
+    }
+
+    private val TAGS = listOf(
+        ExifInterface.TAG_APERTURE_VALUE,
+        ExifInterface.TAG_ARTIST,
+        ExifInterface.TAG_BITS_PER_SAMPLE,
+        ExifInterface.TAG_BRIGHTNESS_VALUE,
+        ExifInterface.TAG_CAMERA_OWNER_NAME,
+        ExifInterface.TAG_COLOR_SPACE,
+        ExifInterface.TAG_COMPONENTS_CONFIGURATION,
+        ExifInterface.TAG_COMPRESSED_BITS_PER_PIXEL,
+        ExifInterface.TAG_COMPRESSION,
+        ExifInterface.TAG_CONTRAST,
+        ExifInterface.TAG_COPYRIGHT,
+        ExifInterface.TAG_CUSTOM_RENDERED,
+        ExifInterface.TAG_DATETIME,
+        ExifInterface.TAG_DATETIME_DIGITIZED,
+        ExifInterface.TAG_DATETIME_ORIGINAL,
+        ExifInterface.TAG_DEVICE_SETTING_DESCRIPTION,
+        ExifInterface.TAG_DIGITAL_ZOOM_RATIO,
+        ExifInterface.TAG_DNG_VERSION,
+        ExifInterface.TAG_EXIF_VERSION,
+        ExifInterface.TAG_EXPOSURE_BIAS_VALUE,
+        ExifInterface.TAG_EXPOSURE_INDEX,
+        ExifInterface.TAG_EXPOSURE_MODE,
+        ExifInterface.TAG_EXPOSURE_PROGRAM,
+        ExifInterface.TAG_EXPOSURE_TIME,
+        ExifInterface.TAG_F_NUMBER,
+        ExifInterface.TAG_FILE_SOURCE,
+        ExifInterface.TAG_FLASH,
+        ExifInterface.TAG_FLASH_ENERGY,
+        ExifInterface.TAG_FLASHPIX_VERSION,
+        ExifInterface.TAG_FOCAL_LENGTH,
+        ExifInterface.TAG_FOCAL_LENGTH_IN_35MM_FILM,
+        ExifInterface.TAG_FOCAL_PLANE_RESOLUTION_UNIT,
+        ExifInterface.TAG_FOCAL_PLANE_X_RESOLUTION,
+        ExifInterface.TAG_FOCAL_PLANE_Y_RESOLUTION,
+        ExifInterface.TAG_GAIN_CONTROL,
+        ExifInterface.TAG_GPS_ALTITUDE,
+        ExifInterface.TAG_GPS_ALTITUDE_REF,
+        ExifInterface.TAG_GPS_AREA_INFORMATION,
+        ExifInterface.TAG_GPS_DATESTAMP,
+        ExifInterface.TAG_GPS_DEST_BEARING,
+        ExifInterface.TAG_GPS_DEST_BEARING_REF,
+        ExifInterface.TAG_GPS_DEST_DISTANCE,
+        ExifInterface.TAG_GPS_DEST_DISTANCE_REF,
+        ExifInterface.TAG_GPS_DEST_LATITUDE,
+        ExifInterface.TAG_GPS_DEST_LATITUDE_REF,
+        ExifInterface.TAG_GPS_DEST_LONGITUDE,
+        ExifInterface.TAG_GPS_DEST_LONGITUDE_REF,
+        ExifInterface.TAG_GPS_DIFFERENTIAL,
+        ExifInterface.TAG_GPS_DOP,
+        ExifInterface.TAG_GPS_H_POSITIONING_ERROR,
+        ExifInterface.TAG_GPS_IMG_DIRECTION,
+        ExifInterface.TAG_GPS_IMG_DIRECTION_REF,
+        ExifInterface.TAG_GPS_LATITUDE,
+        ExifInterface.TAG_GPS_LATITUDE_REF,
+        ExifInterface.TAG_GPS_LONGITUDE,
+        ExifInterface.TAG_GPS_LONGITUDE_REF,
+        ExifInterface.TAG_GPS_MAP_DATUM,
+        ExifInterface.TAG_GPS_MEASURE_MODE,
+        ExifInterface.TAG_GPS_PROCESSING_METHOD,
+        ExifInterface.TAG_GPS_SATELLITES,
+        ExifInterface.TAG_GPS_SPEED,
+        ExifInterface.TAG_GPS_SPEED_REF,
+        ExifInterface.TAG_GPS_STATUS,
+        ExifInterface.TAG_GPS_TIMESTAMP,
+        ExifInterface.TAG_GPS_TRACK,
+        ExifInterface.TAG_GPS_TRACK_REF,
+        ExifInterface.TAG_GPS_VERSION_ID,
+        ExifInterface.TAG_IMAGE_DESCRIPTION,
+        ExifInterface.TAG_IMAGE_UNIQUE_ID,
+        ExifInterface.TAG_INTEROPERABILITY_INDEX,
+        ExifInterface.TAG_ISO_SPEED,
+        ExifInterface.TAG_PHOTOGRAPHIC_SENSITIVITY,
+        ExifInterface.TAG_LENS_MAKE,
+        ExifInterface.TAG_LENS_MODEL,
+        ExifInterface.TAG_LENS_SERIAL_NUMBER,
+        ExifInterface.TAG_LENS_SPECIFICATION,
+        ExifInterface.TAG_LIGHT_SOURCE,
+        ExifInterface.TAG_MAKE,
+        ExifInterface.TAG_MAKER_NOTE,
+        ExifInterface.TAG_MAX_APERTURE_VALUE,
+        ExifInterface.TAG_METERING_MODE,
+        ExifInterface.TAG_MODEL,
+        ExifInterface.TAG_OECF,
+        ExifInterface.TAG_PHOTOMETRIC_INTERPRETATION,
+        ExifInterface.TAG_PIXEL_X_DIMENSION,
+        ExifInterface.TAG_PIXEL_Y_DIMENSION,
+        ExifInterface.TAG_RELATED_SOUND_FILE,
+        ExifInterface.TAG_RESOLUTION_UNIT,
+        ExifInterface.TAG_SATURATION,
+        ExifInterface.TAG_SCENE_CAPTURE_TYPE,
+        ExifInterface.TAG_SCENE_TYPE,
+        ExifInterface.TAG_SENSING_METHOD,
+        ExifInterface.TAG_SHARPNESS,
+        ExifInterface.TAG_SHUTTER_SPEED_VALUE,
+        ExifInterface.TAG_SOFTWARE,
+        ExifInterface.TAG_SPATIAL_FREQUENCY_RESPONSE,
+        ExifInterface.TAG_SPECTRAL_SENSITIVITY,
+        ExifInterface.TAG_SUBJECT_AREA,
+        ExifInterface.TAG_SUBJECT_DISTANCE,
+        ExifInterface.TAG_SUBJECT_DISTANCE_RANGE,
+        ExifInterface.TAG_SUBJECT_LOCATION,
+        ExifInterface.TAG_SUBSEC_TIME,
+        ExifInterface.TAG_SUBSEC_TIME_DIGITIZED,
+        ExifInterface.TAG_SUBSEC_TIME_ORIGINAL,
+        ExifInterface.TAG_TRANSFER_FUNCTION,
+        ExifInterface.TAG_USER_COMMENT,
+        ExifInterface.TAG_WHITE_BALANCE,
+        ExifInterface.TAG_WHITE_POINT,
+        ExifInterface.TAG_X_RESOLUTION,
+        ExifInterface.TAG_Y_CB_CR_COEFFICIENTS,
+        ExifInterface.TAG_Y_CB_CR_POSITIONING,
+        ExifInterface.TAG_Y_CB_CR_SUB_SAMPLING,
+        ExifInterface.TAG_Y_RESOLUTION,
+        // TAG_ORIENTATION excluded — reset to ORIENTATION_NORMAL after loop
+    )
+}