Fixed photos being rotated when uploaded (#88)

Co-authored-by: Thomas Ezan <[email protected]>
Co-authored-by: lethargicpanda <[email protected]>

Author: JolandaVerhoef

ai-catalog/gradle/libs.versions.toml

@@ -32,6 +32,7 @@ uiTooling = "1.8.3"
 firebaseAi = "16.2.0"
 lifecycleViewmodelAndroid = "2.8.7"
 material3 = "1.3.2"
+exifinterface = "1.4.1"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
@@ -78,6 +79,7 @@ ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling", version.ref =
 google-firebase-ai = { group = "com.google.firebase", name = "firebase-ai", version.ref = "firebaseAi" }
 androidx-lifecycle-viewmodel-android = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-android", version.ref = "lifecycleViewmodelAndroid" }
 material3 = { group = "androidx.compose.material3", name = "material3", version.ref = "material3" }
+androidx-exifinterface = { group = "androidx.exifinterface", name = "exifinterface", version.ref = "exifinterface" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }

ai-catalog/samples/gemini-image-chat/build.gradle.kts

@@ -67,6 +67,7 @@ dependencies {
     implementation(libs.androidx.lifecycle.runtime.compose)
     implementation(libs.androidx.material3.android)
     implementation(libs.coil.compose)
+    implementation(libs.androidx.exifinterface)
     ksp(libs.hilt.compiler)
 
     testImplementation(libs.junit)

ai-catalog/samples/gemini-image-chat/src/main/java/com/android/ai/samples/geminiimagechat/GeminiImageChatScreen.kt

@@ -18,7 +18,6 @@ package com.android.ai.samples.geminiimagechat
 import android.content.Intent
 import android.graphics.Bitmap
 import android.net.Uri
-import android.provider.MediaStore
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.PickVisualMediaRequest
 import androidx.activity.result.contract.ActivityResultContracts.PickVisualMedia
@@ -53,6 +52,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
@@ -67,6 +67,10 @@ import androidx.compose.ui.unit.sp
 import androidx.core.net.toUri
 import androidx.hilt.navigation.compose.hiltViewModel
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.android.ai.samples.util.loadBitmapWithCorrectOrientation
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 @OptIn(ExperimentalMaterial3Api::class)
 @Composable
@@ -84,6 +88,7 @@ fun GeminiImageChatScreen(viewModel: GeminiImageChatViewModel = hiltViewModel())
     }
 
     val context = LocalContext.current
+    val coroutineScope = rememberCoroutineScope()
 
     Scaffold(
         modifier = Modifier
@@ -146,12 +151,16 @@ fun GeminiImageChatScreen(viewModel: GeminiImageChatViewModel = hiltViewModel())
                     message = it
                 },
                 onSendClick = {
-                    val bitmap = imageUri?.let {
-                        MediaStore.Images.Media.getBitmap(context.contentResolver, imageUri)
+                    coroutineScope.launch {
+                        val bitmap = imageUri?.let {
+                            withContext(Dispatchers.IO) {
+                                loadBitmapWithCorrectOrientation(context, it)
+                            }
+                        }
+                        viewModel.sendMessage(message, bitmap)
+                        imageUri = null
+                        message = ""
                     }
-                    viewModel.sendMessage(message, bitmap)
-                    imageUri = null
-                    message = ""
                 },
                 sendEnabled = uiState.geminiMessageState !is GeminiMessageState.Generating,
                 addImage = {

ai-catalog/samples/gemini-image-chat/src/main/java/com/android/ai/samples/util/BitmapUtils.kt

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.ai.samples.util
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.ImageDecoder
+import android.graphics.Matrix
+import android.net.Uri
+import android.os.Build.VERSION
+import android.os.Build.VERSION_CODES
+import android.provider.MediaStore
+import androidx.exifinterface.media.ExifInterface
+import java.io.IOException
+
+internal fun loadBitmapWithCorrectOrientation(context: Context, uri: Uri): Bitmap? {
+    return try {
+        if (VERSION.SDK_INT >= VERSION_CODES.P) {
+            val source = ImageDecoder.createSource(context.contentResolver, uri)
+            ImageDecoder.decodeBitmap(source)
+        } else {
+            @Suppress("DEPRECATION")
+            val bitmap = MediaStore.Images.Media.getBitmap(context.contentResolver, uri)
+
+            context.contentResolver.openInputStream(uri)?.use { inputStream ->
+                val exifInterface = ExifInterface(inputStream)
+                val orientation = exifInterface.getAttributeInt(
+                    ExifInterface.TAG_ORIENTATION,
+                    ExifInterface.ORIENTATION_NORMAL,
+                )
+
+                if (orientation == ExifInterface.ORIENTATION_NORMAL) {
+                    return@use bitmap
+                }
+
+                val matrix = Matrix()
+                when (orientation) {
+                    ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+                    ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+                    ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+                    ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.preScale(-1.0f, 1.0f)
+                    ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.preScale(1.0f, -1.0f)
+                    ExifInterface.ORIENTATION_TRANSPOSE -> {
+                        matrix.postRotate(90f)
+                        matrix.preScale(-1.0f, 1.0f)
+                    }
+                    ExifInterface.ORIENTATION_TRANSVERSE -> {
+                        matrix.postRotate(-90f)
+                        matrix.preScale(-1.0f, 1.0f)
+                    }
+                }
+
+                bitmap?.let {
+                    Bitmap.createBitmap(
+                        it, 0, 0, it.width, it.height, matrix, true,
+                    )
+                }
+            } ?: bitmap
+        }
+    } catch (e: IOException) {
+        // In a real app, you should use a proper logging library.
+        e.printStackTrace()
+        null
+    }
+}