Created pdf on android, rotates photo

[a-petrenko-muse]

Hello!
I use pictures from react camera or from library, and it works great on ios, but on android the received pdf rotates the photo by 90 degrees, checked with all paperSize. I use the latest version of the library and 0.74 rn without new architecture.
The screenshot below shows a photo from the camera, and above is the resulting pdf displayed via react native pdf

[benjamineruvieru]

Hi, I'll investigate the issue can you drop your code snippet to

[a-petrenko-muse]

Thanks for the quick reply. I looked at the source code on Android (PdfFromImageModuleImpl.kt).
I don’t know how correct this decision is, but the deepseek suggested it and it works.
Maybe this will help someone. Thanks.

`
package com.pdffromimage
import android.graphics.BitmapFactory
import android.graphics.pdf.PdfDocument
import android.graphics.pdf.PdfDocument.PageInfo
import com.facebook.react.bridge.Arguments
import com.facebook.react.bridge.Promise
import com.facebook.react.bridge.ReadableMap
import com.facebook.react.bridge.WritableMap
import java.io.File
import java.io.FileNotFoundException
import java.io.FileOutputStream
import java.io.IOException
import android.media.ExifInterface
import android.graphics.Matrix
import android.graphics.Bitmap

class PdfFromImageModuleImpl {
fun createPdf(
imageObject: ReadableMap,
documentFile: File,
promise: Promise? = null,
): WritableMap {
val resultMap: WritableMap = Arguments.createMap()

  try {
      val imagePaths = imageObject.getArray("imagePaths")
      val documentName = imageObject.getString("name") ?: "document"

      val document = PdfDocument()

      if (imagePaths != null) {
          for (i in 0 until imagePaths.size()) {
              val imagePath = imagePaths.getString(i)

              val options = BitmapFactory.Options().apply {
                  inJustDecodeBounds = true
              }
              BitmapFactory.decodeFile(imagePath, options)

              val exif = ExifInterface(imagePath)
              val orientation = exif.getAttributeInt(
                  ExifInterface.TAG_ORIENTATION,
                  ExifInterface.ORIENTATION_NORMAL
              )

              val swapDimensions = orientation == ExifInterface.ORIENTATION_ROTATE_90 ||
                                  orientation == ExifInterface.ORIENTATION_ROTATE_270

              val originalWidth = options.outWidth
              val originalHeight = options.outHeight

              val (pageWidth, pageHeight) = if (imageObject.hasKey("paperSize")) {
                  val paperSizeMap = imageObject.getMap("paperSize")
                  var width = paperSizeMap?.getDouble("width")?.toInt() ?: originalWidth
                  var height = paperSizeMap?.getDouble("height")?.toInt() ?: originalHeight

                  if (swapDimensions) {
                      val temp = width
                      width = height
                      height = temp
                  }
                  Pair(width, height)
              } else {
                  if (swapDimensions) {
                      Pair(originalHeight, originalWidth)
                  } else {
                      Pair(originalWidth, originalHeight)
                  }
              }

              val bitmap = BitmapFactory.decodeFile(imagePath)?.let { bitmap ->
                  when (orientation) {
                      ExifInterface.ORIENTATION_ROTATE_90 -> rotateBitmap(bitmap, 90f)
                      ExifInterface.ORIENTATION_ROTATE_180 -> rotateBitmap(bitmap, 180f)
                      ExifInterface.ORIENTATION_ROTATE_270 -> rotateBitmap(bitmap, 270f)
                      else -> bitmap
                  }
              }

              if (bitmap != null) {
                  val pageInfo = PageInfo.Builder(pageWidth, pageHeight, i + 1).create()
                  val page = document.startPage(pageInfo)
                  val canvas = page.canvas

                  val widthRatio = pageWidth.toFloat() / bitmap.width
                  val heightRatio = pageHeight.toFloat() / bitmap.height
                  val scale = minOf(widthRatio, heightRatio)

                  val scaledWidth = bitmap.width * scale
                  val scaledHeight = bitmap.height * scale
                  val xOffset = (pageWidth - scaledWidth) / 2
                  val yOffset = (pageHeight - scaledHeight) / 2

                  canvas.save()
                  canvas.translate(xOffset, yOffset)
                  canvas.scale(scale, scale)
                  canvas.drawBitmap(bitmap, 0f, 0f, null)
                  canvas.restore()

                  document.finishPage(page)
                  bitmap.recycle()
              }
          }
      }

      document.writeTo(FileOutputStream(documentFile))
      document.close()

      resultMap.putString("filePath", documentFile.path)
      promise?.resolve(resultMap)
  } catch (e: Exception) {
      promise?.reject("PDF_CREATION_ERROR", e)
  }

  return resultMap

}

companion object {
const val NAME = "PdfFromImage"
}

private fun rotateBitmap(source: Bitmap, angle: Float): Bitmap {
val matrix = Matrix()
matrix.postRotate(angle)
return Bitmap.createBitmap(
source, 0, 0, source.width, source.height, matrix, true
)
}
}
`