react-native-image-compression-kit 0.1.0

package/android/src/main/java/com/imagecompressionkit/ImageCompressionKitPackage.kt

@@ -0,0 +1,33 @@
+package com.imagecompressionkit
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ImageCompressionKitPackage : BaseReactPackage() {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext
+  ): NativeModule? =
+    if (name == ImageCompressionKitModule.NAME) {
+      ImageCompressionKitModule(reactContext)
+    } else {
+      null
+    }
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider {
+      mapOf(
+        ImageCompressionKitModule.NAME to ReactModuleInfo(
+          ImageCompressionKitModule.NAME,
+          ImageCompressionKitModule.NAME,
+          false,
+          false,
+          false,
+          true
+        )
+      )
+    }
+}

package/android/src/main/java/com/imagecompressionkit/ImageCompressionOutput.kt

@@ -0,0 +1,396 @@
+package com.imagecompressionkit
+
+import android.graphics.Bitmap
+import android.net.Uri
+import android.os.Build
+import java.io.File
+import java.io.FileOutputStream
+import java.util.UUID
+
+internal data class CompressionOutputDimensions(
+  val width: Int,
+  val height: Int
+)
+
+internal data class CompressionOutputResultMetadata(
+  val uri: String,
+  val format: String,
+  val width: Int,
+  val height: Int,
+  val byteSize: Long,
+  val originalByteSize: Long,
+  val compressionRatio: Double
+)
+
+internal data class CompressionFormatCapability(
+  val format: String,
+  val input: Boolean,
+  val output: Boolean,
+  val supportsAlpha: Boolean,
+  val supportsAnimation: Boolean,
+  val notes: List<String>
+)
+
+internal enum class OutputFormat(
+  val value: String,
+  val fileExtension: String,
+  val supportsTargetSizeCompression: Boolean,
+  val supportsJpegExifMetadata: Boolean
+) {
+  JPEG(
+    value = "jpeg",
+    fileExtension = "jpg",
+    supportsTargetSizeCompression = true,
+    supportsJpegExifMetadata = true
+  ),
+  PNG(
+    value = "png",
+    fileExtension = "png",
+    supportsTargetSizeCompression = false,
+    supportsJpegExifMetadata = false
+  ),
+  WEBP(
+    value = "webp",
+    fileExtension = "webp",
+    supportsTargetSizeCompression = true,
+    supportsJpegExifMetadata = false
+  );
+
+  val compressFormat: Bitmap.CompressFormat
+    get() = when (this) {
+      JPEG -> Bitmap.CompressFormat.JPEG
+      PNG -> Bitmap.CompressFormat.PNG
+      WEBP -> webpCompressFormat()
+    }
+
+  fun compressionQuality(quality: Int): Int =
+    if (this == PNG) {
+      100
+    } else {
+      quality
+    }
+
+  @Suppress("DEPRECATION")
+  private fun webpCompressFormat(): Bitmap.CompressFormat =
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+      Bitmap.CompressFormat.WEBP_LOSSY
+    } else {
+      Bitmap.CompressFormat.WEBP
+    }
+
+  companion object {
+    fun fromValue(value: String?): OutputFormat? =
+      values().firstOrNull { it.value == value }
+  }
+}
+
+internal object ImageCompressionOutput {
+  const val MAX_BYTES_UNSUPPORTED_MESSAGE =
+    "Android MVP supports output.maxBytes for JPEG and WebP output only."
+
+  val FORMAT_VALUES = arrayOf(
+    JPEG_FORMAT,
+    PNG_FORMAT,
+    WEBP_FORMAT,
+    HEIC_FORMAT,
+    HEIF_FORMAT,
+    "avif",
+    GIF_FORMAT
+  )
+
+  fun fromValue(value: String?): OutputFormat? =
+    OutputFormat.fromValue(value)
+
+  fun maxBytesValidationError(
+    outputFormat: OutputFormat,
+    maxBytes: Long?
+  ): String? =
+    if (maxBytes != null && !outputFormat.supportsTargetSizeCompression) {
+      MAX_BYTES_UNSUPPORTED_MESSAGE
+    } else {
+      null
+    }
+
+  fun createOutputFile(cacheDir: File, outputFormat: OutputFormat): File {
+    val outputDir = File(cacheDir, OUTPUT_DIRECTORY_NAME)
+    if (!outputDir.exists()) {
+      outputDir.mkdirs()
+    }
+
+    return File(
+      outputDir,
+      "compressed-${System.currentTimeMillis()}-${UUID.randomUUID()}.${outputFormat.fileExtension}"
+    )
+  }
+
+  fun encodeBitmap(
+    bitmap: Bitmap,
+    outputFile: File,
+    outputFormat: OutputFormat,
+    quality: Int,
+    maxBytes: Long?,
+    copiedExifMetadata: CopiedExifMetadata? = null
+  ): Boolean =
+    if (maxBytes == null) {
+      encodeBitmapAtQuality(
+        bitmap,
+        outputFile,
+        outputFormat,
+        quality,
+        copiedExifMetadata
+      )
+    } else {
+      encodeBitmapToTargetSize(
+        bitmap,
+        outputFile,
+        outputFormat,
+        quality,
+        maxBytes,
+        copiedExifMetadata
+      )
+    }
+
+  fun createResultMetadata(
+    originalByteSize: Long,
+    outputFile: File,
+    dimensions: CompressionOutputDimensions,
+    outputFormat: OutputFormat
+  ): CompressionOutputResultMetadata {
+    val byteSize = outputFile.length()
+
+    return CompressionOutputResultMetadata(
+      uri = Uri.fromFile(outputFile).toString(),
+      format = outputFormat.value,
+      width = dimensions.width,
+      height = dimensions.height,
+      byteSize = byteSize,
+      originalByteSize = originalByteSize,
+      compressionRatio = if (originalByteSize > 0L) {
+        byteSize.toDouble() / originalByteSize.toDouble()
+      } else {
+        1.0
+      }
+    )
+  }
+
+  fun createFormatCapability(format: String): CompressionFormatCapability {
+    val outputFormat = OutputFormat.fromValue(format)
+    val isSupportedInput = format in SUPPORTED_INPUT_FORMATS
+
+    return CompressionFormatCapability(
+      format = format,
+      input = isSupportedInput,
+      output = outputFormat != null,
+      supportsAlpha = false,
+      supportsAnimation = false,
+      notes = when (outputFormat) {
+        OutputFormat.JPEG -> jpegFormatNotes()
+        OutputFormat.PNG -> pngFormatNotes()
+        OutputFormat.WEBP -> webpFormatNotes()
+        null -> when (format) {
+          HEIC_FORMAT -> heicHeifFormatNotes("HEIC")
+          HEIF_FORMAT -> heicHeifFormatNotes("HEIF")
+          AVIF_FORMAT -> avifFormatNotes()
+          GIF_FORMAT -> gifFormatNotes()
+          else -> notImplementedNotes()
+        }
+      }
+    )
+  }
+
+  private fun notImplementedNotes(): List<String> =
+    listOf("Native codec support has not been implemented yet.")
+
+  private fun heicHeifFormatNotes(formatLabel: String): List<String> =
+    listOf(
+      "$formatLabel input is supported on Android 8.0+ when device HEIF decode codecs are present.",
+      "Android API 28+ uses ImageDecoder for $formatLabel input.",
+      "Android API 26-27 attempts a guarded BitmapFactory HEIF decode fallback.",
+      "$formatLabel inputs are decoded without copying EXIF metadata.",
+      "$formatLabel output is not implemented."
+    )
+
+  private fun avifFormatNotes(): List<String> =
+    listOf(
+      "AVIF input is supported on Android 14+ for baseline still images.",
+      "Android API 34+ uses ImageDecoder for AVIF input.",
+      "AVIF inputs are decoded without copying EXIF metadata.",
+      "Animated AVIF preservation is not implemented.",
+      "AVIF output is not implemented."
+    )
+
+  private fun encodeBitmapToTargetSize(
+    bitmap: Bitmap,
+    outputFile: File,
+    outputFormat: OutputFormat,
+    qualityCap: Int,
+    maxBytes: Long,
+    copiedExifMetadata: CopiedExifMetadata?
+  ): Boolean {
+    var currentQuality = qualityCap
+
+    if (
+      !encodeBitmapAtQuality(
+        bitmap,
+        outputFile,
+        outputFormat,
+        currentQuality,
+        copiedExifMetadata
+      )
+    ) {
+      return false
+    }
+
+    if (outputFile.length() <= maxBytes) {
+      return true
+    }
+
+    var lowestAboveTargetQuality = currentQuality
+    var lowestAboveTargetSize = outputFile.length()
+    var bestWithinTargetQuality: Int? = null
+    var low = MIN_QUALITY
+    var high = qualityCap - 1
+
+    while (low <= high) {
+      currentQuality = (low + high) / 2
+
+      if (
+        !encodeBitmapAtQuality(
+          bitmap,
+          outputFile,
+          outputFormat,
+          currentQuality,
+          copiedExifMetadata
+        )
+      ) {
+        return false
+      }
+
+      val byteSize = outputFile.length()
+
+      if (byteSize <= maxBytes) {
+        bestWithinTargetQuality = currentQuality
+        low = currentQuality + 1
+      } else {
+        if (byteSize < lowestAboveTargetSize) {
+          lowestAboveTargetQuality = currentQuality
+          lowestAboveTargetSize = byteSize
+        }
+        high = currentQuality - 1
+      }
+    }
+
+    val finalQuality = bestWithinTargetQuality ?: lowestAboveTargetQuality
+
+    return if (currentQuality == finalQuality) {
+      true
+    } else {
+      encodeBitmapAtQuality(
+        bitmap,
+        outputFile,
+        outputFormat,
+        finalQuality,
+        copiedExifMetadata
+      )
+    }
+  }
+
+  private fun encodeBitmapAtQuality(
+    bitmap: Bitmap,
+    outputFile: File,
+    outputFormat: OutputFormat,
+    quality: Int,
+    copiedExifMetadata: CopiedExifMetadata?
+  ): Boolean {
+    val encoded = FileOutputStream(outputFile).use { outputStream ->
+      bitmap.compress(
+        outputFormat.compressFormat,
+        outputFormat.compressionQuality(quality),
+        outputStream
+      )
+    }
+
+    if (!encoded) {
+      return false
+    }
+
+    if (outputFormat.supportsJpegExifMetadata) {
+      writeCopiedExifMetadata(copiedExifMetadata, outputFile)
+    }
+
+    return true
+  }
+
+  private fun writeCopiedExifMetadata(
+    copiedExifMetadata: CopiedExifMetadata?,
+    outputFile: File
+  ) {
+    try {
+      JpegExifMetadata.write(copiedExifMetadata, outputFile)
+    } catch (error: Exception) {
+      throw IllegalStateException(
+        "Android MVP could not write preserved EXIF metadata.",
+        error
+      )
+    }
+  }
+
+  private fun jpegFormatNotes(): List<String> =
+    listOf(
+      "Android MVP supports JPEG file:// and content:// sources.",
+      "EXIF orientation is applied before resize and selected output encoding.",
+      "Resize supports contain, cover, and stretch modes with maxWidth and maxHeight.",
+      "Target-size compression supports maxBytes by adjusting JPEG quality.",
+      "Metadata preserve copies supported JPEG source EXIF attributes into JPEG output.",
+      "Metadata safe copies privacy-filtered JPEG source EXIF attributes.",
+      "Metadata safe excludes GPS/location, owner/serial, maker note, user comment, and XMP.",
+      "Metadata preserve normalizes output EXIF orientation after pixels are transformed.",
+      "Metadata strip re-encodes JPEG output without preserving source metadata.",
+      "PNG, WebP, GIF, HEIC, HEIF, and AVIF sources are decoded without copying EXIF metadata."
+    )
+
+  private fun pngFormatNotes(): List<String> =
+    listOf(
+      "Android MVP supports PNG file:// and content:// sources.",
+      "Android can encode decoded JPEG, PNG, WebP, or GIF input to PNG output.",
+      "PNG output ignores quality and does not support target-size maxBytes.",
+      "Non-JPEG output does not preserve source EXIF metadata."
+    )
+
+  private fun webpFormatNotes(): List<String> =
+    listOf(
+      "Android MVP supports WebP file:// and content:// sources.",
+      "Android can encode decoded JPEG, PNG, WebP, or GIF input to WebP output.",
+      "WebP target-size compression supports maxBytes by adjusting WebP quality.",
+      "Non-JPEG output does not preserve source EXIF metadata.",
+      "Animated WebP input or output is not implemented."
+    )
+
+  private fun gifFormatNotes(): List<String> =
+    listOf(
+      "Android MVP decodes GIF file:// and content:// sources as a static first frame.",
+      "Animated GIF preservation is not implemented.",
+      "GIF output is not implemented.",
+      "GIF sources are decoded without copying EXIF metadata."
+    )
+
+  private val SUPPORTED_INPUT_FORMATS = setOf(
+    JPEG_FORMAT,
+    PNG_FORMAT,
+    WEBP_FORMAT,
+    HEIC_FORMAT,
+    HEIF_FORMAT,
+    AVIF_FORMAT,
+    GIF_FORMAT
+  )
+
+  private const val JPEG_FORMAT = "jpeg"
+  private const val PNG_FORMAT = "png"
+  private const val WEBP_FORMAT = "webp"
+  private const val HEIC_FORMAT = "heic"
+  private const val HEIF_FORMAT = "heif"
+  private const val AVIF_FORMAT = "avif"
+  private const val GIF_FORMAT = "gif"
+  private const val OUTPUT_DIRECTORY_NAME = "image-compression-kit"
+  private const val MIN_QUALITY = 0
+}

package/android/src/main/java/com/imagecompressionkit/JpegExifMetadata.kt

@@ -0,0 +1,233 @@
+package com.imagecompressionkit
+
+import androidx.exifinterface.media.ExifInterface
+import java.io.File
+import java.io.InputStream
+
+internal data class CopiedExifMetadata(
+  val attributes: Map<String, String>,
+  val width: Int,
+  val height: Int
+)
+
+internal object JpegExifMetadata {
+  val SAFE_EXIF_TAGS = arrayOf(
+    ExifInterface.TAG_APERTURE_VALUE,
+    ExifInterface.TAG_BRIGHTNESS_VALUE,
+    ExifInterface.TAG_CFA_PATTERN,
+    ExifInterface.TAG_COLOR_SPACE,
+    ExifInterface.TAG_COMPONENTS_CONFIGURATION,
+    ExifInterface.TAG_COMPRESSED_BITS_PER_PIXEL,
+    ExifInterface.TAG_CONTRAST,
+    ExifInterface.TAG_CUSTOM_RENDERED,
+    ExifInterface.TAG_DATETIME,
+    ExifInterface.TAG_DATETIME_DIGITIZED,
+    ExifInterface.TAG_DATETIME_ORIGINAL,
+    ExifInterface.TAG_DIGITAL_ZOOM_RATIO,
+    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_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_GAMMA,
+    ExifInterface.TAG_ISO_SPEED,
+    ExifInterface.TAG_ISO_SPEED_LATITUDE_YYY,
+    ExifInterface.TAG_ISO_SPEED_LATITUDE_ZZZ,
+    ExifInterface.TAG_LENS_MAKE,
+    ExifInterface.TAG_LENS_MODEL,
+    ExifInterface.TAG_LENS_SPECIFICATION,
+    ExifInterface.TAG_LIGHT_SOURCE,
+    ExifInterface.TAG_MAKE,
+    ExifInterface.TAG_MAX_APERTURE_VALUE,
+    ExifInterface.TAG_METERING_MODE,
+    ExifInterface.TAG_MODEL,
+    ExifInterface.TAG_OFFSET_TIME,
+    ExifInterface.TAG_OFFSET_TIME_DIGITIZED,
+    ExifInterface.TAG_OFFSET_TIME_ORIGINAL,
+    ExifInterface.TAG_PHOTOGRAPHIC_SENSITIVITY,
+    ExifInterface.TAG_RECOMMENDED_EXPOSURE_INDEX,
+    ExifInterface.TAG_SATURATION,
+    ExifInterface.TAG_SCENE_CAPTURE_TYPE,
+    ExifInterface.TAG_SCENE_TYPE,
+    ExifInterface.TAG_SENSING_METHOD,
+    ExifInterface.TAG_SENSITIVITY_TYPE,
+    ExifInterface.TAG_SHARPNESS,
+    ExifInterface.TAG_SHUTTER_SPEED_VALUE,
+    ExifInterface.TAG_SOFTWARE,
+    ExifInterface.TAG_STANDARD_OUTPUT_SENSITIVITY,
+    ExifInterface.TAG_SUBSEC_TIME,
+    ExifInterface.TAG_SUBSEC_TIME_DIGITIZED,
+    ExifInterface.TAG_SUBSEC_TIME_ORIGINAL,
+    ExifInterface.TAG_WHITE_BALANCE
+  )
+
+  val PRESERVED_EXIF_TAGS = arrayOf(
+    ExifInterface.TAG_ARTIST,
+    ExifInterface.TAG_BODY_SERIAL_NUMBER,
+    ExifInterface.TAG_BRIGHTNESS_VALUE,
+    ExifInterface.TAG_CAMERA_OWNER_NAME,
+    ExifInterface.TAG_CFA_PATTERN,
+    ExifInterface.TAG_COLOR_SPACE,
+    ExifInterface.TAG_COMPONENTS_CONFIGURATION,
+    ExifInterface.TAG_COMPRESSED_BITS_PER_PIXEL,
+    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_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_GAMMA,
+    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_ISO_SPEED_LATITUDE_YYY,
+    ExifInterface.TAG_ISO_SPEED_LATITUDE_ZZZ,
+    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_OFFSET_TIME,
+    ExifInterface.TAG_OFFSET_TIME_DIGITIZED,
+    ExifInterface.TAG_OFFSET_TIME_ORIGINAL,
+    ExifInterface.TAG_PHOTOGRAPHIC_SENSITIVITY,
+    ExifInterface.TAG_RECOMMENDED_EXPOSURE_INDEX,
+    ExifInterface.TAG_RELATED_SOUND_FILE,
+    ExifInterface.TAG_SATURATION,
+    ExifInterface.TAG_SCENE_CAPTURE_TYPE,
+    ExifInterface.TAG_SCENE_TYPE,
+    ExifInterface.TAG_SENSING_METHOD,
+    ExifInterface.TAG_SENSITIVITY_TYPE,
+    ExifInterface.TAG_SHARPNESS,
+    ExifInterface.TAG_SHUTTER_SPEED_VALUE,
+    ExifInterface.TAG_SOFTWARE,
+    ExifInterface.TAG_SPATIAL_FREQUENCY_RESPONSE,
+    ExifInterface.TAG_SPECTRAL_SENSITIVITY,
+    ExifInterface.TAG_STANDARD_OUTPUT_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_USER_COMMENT,
+    ExifInterface.TAG_WHITE_BALANCE,
+    ExifInterface.TAG_XMP
+  )
+
+  fun read(
+    inputStream: InputStream,
+    exifTags: Array<String>,
+    width: Int,
+    height: Int
+  ): CopiedExifMetadata {
+    val sourceExif = ExifInterface(inputStream)
+    val attributes = linkedMapOf<String, String>()
+
+    exifTags.forEach { tag ->
+      val value = sourceExif.getAttribute(tag)
+
+      if (value != null) {
+        attributes[tag] = value
+      }
+    }
+
+    return CopiedExifMetadata(
+      attributes = attributes,
+      width = width,
+      height = height
+    )
+  }
+
+  fun write(metadata: CopiedExifMetadata?, outputFile: File) {
+    if (metadata == null) {
+      return
+    }
+
+    val outputExif = ExifInterface(outputFile.absolutePath)
+
+    metadata.attributes.forEach { (tag, value) ->
+      outputExif.setAttribute(tag, value)
+    }
+
+    outputExif.setAttribute(
+      ExifInterface.TAG_ORIENTATION,
+      ExifInterface.ORIENTATION_NORMAL.toString()
+    )
+    outputExif.setAttribute(ExifInterface.TAG_IMAGE_WIDTH, metadata.width.toString())
+    outputExif.setAttribute(ExifInterface.TAG_IMAGE_LENGTH, metadata.height.toString())
+    outputExif.setAttribute(ExifInterface.TAG_PIXEL_X_DIMENSION, metadata.width.toString())
+    outputExif.setAttribute(ExifInterface.TAG_PIXEL_Y_DIMENSION, metadata.height.toString())
+    outputExif.saveAttributes()
+  }
+}

package/ios/RCTImageCompressionKit.h

@@ -0,0 +1,10 @@
+#import <Foundation/Foundation.h>
+#import <RNImageCompressionKitSpec/RNImageCompressionKitSpec.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTImageCompressionKit : NSObject <NativeImageCompressionKitSpec>
+
+@end
+
+NS_ASSUME_NONNULL_END