feat: implement internal camera functionality with capture and preview use cases [#45]

Author: ing03201

data/build.gradle.kts

@@ -49,6 +49,8 @@ dependencies {
     implementation(libs.datastore.preferences.core)
     implementation(libs.protobuf.javalite)
 
+    // camerax
+    implementation(libs.camerax.core)
     // test
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)

data/src/main/java/com/foke/together/data/repository/AppPreferencesRepository.kt

@@ -1,5 +1,7 @@
 package com.foke.together.data.repository
 
+import androidx.annotation.IntRange
+import androidx.camera.core.CameraSelector
 import androidx.datastore.core.DataStore
 import com.foke.together.AppPreferences
 import com.foke.together.CameraSource
@@ -53,6 +55,64 @@ class AppPreferencesRepository @Inject constructor(
         }
     }
 
+    override fun getInternalCameraLensFacing(): Flow<Int> =
+        appPreferencesFlow.map{
+            it.internalCameraLensFacing
+        }
+
+    override suspend fun setInternalCameraLensFacing(lensFacing: Int) {
+        appPreferences.updateData {
+            it.toBuilder()
+                .setInternalCameraLensFacing(lensFacing)
+                .build()
+        }
+    }
+
+    override fun getInterenalCameraFlashMode(): Flow<Int> =
+        appPreferencesFlow.map{
+            it.internalCameraFlashMode
+        }
+
+    override suspend fun setInterenalCameraFlashMode(
+        @IntRange(from = 0, to = 3) flashMode: Int
+    ) {
+        appPreferences.updateData {
+            it.toBuilder()
+                .setInternalCameraFlashMode(flashMode)
+                .build()
+        }
+    }
+
+    override fun getInternalCameraCaptureMode(): Flow<Int> =
+        appPreferencesFlow.map {
+            it.internalCameraCaptureMode
+        }
+
+    override suspend fun setInterenalCameraCaptureMode(
+        @IntRange(from = 0, to = 2) captureMode: Int
+    ) {
+        appPreferences.updateData {
+            it.toBuilder()
+                .setInternalCameraCaptureMode(captureMode)
+                .build()
+        }
+    }
+
+    override fun getInternalCameraAspectRatio(): Flow<Int> =
+        appPreferencesFlow.map {
+            it.internalCameraAspectRatio
+        }
+
+    override suspend fun setInterenalCameraAspectRatio(
+        @IntRange(from = -1, to = 1) aspectRatio: Int
+    ) {
+        appPreferences.updateData {
+            it.toBuilder()
+                .setInternalCameraAspectRatio(aspectRatio)
+                .build()
+        }
+    }
+
     override suspend fun clearAll() {
         appPreferences.updateData {
             it.toBuilder().clear().build()

data/src/main/proto/app_preferences.proto

@@ -15,6 +15,11 @@ message AppPreferences {
     CameraSource camera_source = 10;
     string external_camera_ip = 11;
 
+    int32 internal_camera_lens_facing = 20;
+    int32 internal_camera_flash_mode = 21;
+    int32 internal_camera_capture_mode = 22;
+    int32 internal_camera_aspect_ratio = 23;
+
     // TODO: sample code. remove later.
     string sample_id = 999997;
     string sample_title = 999998;

domain/build.gradle.kts

@@ -11,6 +11,8 @@ dependencies {
     implementation(libs.androidx.core.ktx)
     implementation(libs.androidx.appcompat)
     implementation(libs.material)
+    implementation(libs.camerax.view)
+    implementation(libs.camerax.lifecycle)
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)
     androidTestImplementation(libs.androidx.espresso.core)

domain/src/main/java/com/foke/together/domain/interactor/CaptureWithInternalCameraUseCase.kt

@@ -0,0 +1,34 @@
+package com.foke.together.domain.interactor
+
+import android.content.Context
+import com.foke.together.domain.output.ImageRepositoryInterface
+import com.foke.together.domain.output.InternalCameraRepositoryInterface
+import com.foke.together.util.AppLog
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+
+class CaptureWithInternalCameraUseCase @Inject constructor(
+    private val internalCameraRepository: InternalCameraRepositoryInterface,
+    private val imageRepository: ImageRepositoryInterface
+) {
+    suspend operator fun invoke(
+        context: Context,
+        fileName: String
+    ): Result<Unit>{
+        internalCameraRepository.capture(context)
+            .onSuccess {
+                AppLog.i(TAG, "invoke", "success: $it")
+                imageRepository.cachingImage(it, fileName)
+                return Result.success(Unit)
+            }
+            .onFailure {
+                AppLog.e(TAG, "invoke", "failure: $it")
+                return Result.failure(it)
+            }
+        return Result.failure(Exception("Unknown error"))
+    }
+
+    companion object {
+        private val TAG = CaptureWithInternalCameraUseCase::class.java.simpleName
+    }
+}

domain/src/main/java/com/foke/together/domain/interactor/GetInternalCameraAspectRatioUseCase.kt

@@ -0,0 +1,11 @@
+package com.foke.together.domain.interactor
+
+import com.foke.together.domain.output.AppPreferenceInterface
+import kotlinx.coroutines.flow.Flow
+import javax.inject.Inject
+
+class GetInternalCameraAspectRatioUseCase @Inject constructor(
+    private val appPreferenceRepository: AppPreferenceInterface
+) {
+    operator fun invoke() : Flow<Int> = appPreferenceRepository.getInternalCameraAspectRatio()
+}

domain/src/main/java/com/foke/together/domain/interactor/GetInternalCameraCaptureModeUseCase.kt

@@ -0,0 +1,11 @@
+package com.foke.together.domain.interactor
+
+import com.foke.together.domain.output.AppPreferenceInterface
+import kotlinx.coroutines.flow.Flow
+import javax.inject.Inject
+
+class GetInternalCameraCaptureModeUseCase @Inject constructor(
+    private val appPreferenceRepository: AppPreferenceInterface
+) {
+    operator fun invoke() : Flow<Int> = appPreferenceRepository.getInternalCameraCaptureMode()
+}

domain/src/main/java/com/foke/together/domain/interactor/GetInternalCameraFlashModeUseCase.kt

@@ -0,0 +1,11 @@
+package com.foke.together.domain.interactor
+
+import com.foke.together.domain.output.AppPreferenceInterface
+import kotlinx.coroutines.flow.Flow
+import javax.inject.Inject
+
+class GetInternalCameraFlashModeUseCase @Inject constructor(
+    private val appPreferenceRepository: AppPreferenceInterface
+) {
+    operator fun invoke() : Flow<Int> = appPreferenceRepository.getInterenalCameraFlashMode()
+}

domain/src/main/java/com/foke/together/domain/interactor/GetInternalCameraLensFacingUseCase.kt

@@ -0,0 +1,17 @@
+package com.foke.together.domain.interactor
+
+import androidx.camera.core.CameraSelector
+import com.foke.together.domain.output.AppPreferenceInterface
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import javax.inject.Inject
+
+class GetInternalCameraLensFacingUseCase @Inject constructor(
+    private val appPreferenceRepository: AppPreferenceInterface
+) {
+    operator fun invoke() : Flow<CameraSelector> = appPreferenceRepository.getInternalCameraLensFacing().map { cameraSelectorIdx ->
+            CameraSelector.Builder()
+                .requireLensFacing(cameraSelectorIdx)
+                .build()
+        }
+}

domain/src/main/java/com/foke/together/domain/interactor/GetInternalCameraPreviewUseCase.kt

@@ -0,0 +1,34 @@
+package com.foke.together.domain.interactor
+
+import android.content.Context
+import androidx.annotation.IntRange
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.view.PreviewView
+import androidx.lifecycle.LifecycleOwner
+import com.foke.together.domain.output.InternalCameraRepositoryInterface
+import javax.inject.Inject
+
+class GetInternalCameraPreviewUseCase @Inject constructor(
+    private val internalCameraRepository: InternalCameraRepositoryInterface,
+) {
+    suspend operator fun invoke(
+        context: Context,
+        previewView: PreviewView,
+        lifecycleOwner: LifecycleOwner,
+        cameraSelector: CameraSelector,
+        imageAnalysis: ImageAnalysis?,
+        @IntRange(from = 0, to = 2) captureMode: Int,
+        @IntRange(from = 0, to = 3) flashMode: Int,
+        @IntRange(from = -1, to = 1) aspectRatio: Int
+    ) = internalCameraRepository.showCameraPreview(
+        context = context,
+        lifecycleOwner = lifecycleOwner,
+        previewView = previewView,
+        selector = cameraSelector,
+        imageAnalysis = imageAnalysis,
+        captureMode = captureMode,
+        flashMode = flashMode,
+        aspectRatio = aspectRatio
+    )
+}

domain/src/main/java/com/foke/together/domain/output/AppPreferenceInterface.kt

@@ -1,5 +1,7 @@
 package com.foke.together.domain.output
 
+import androidx.annotation.IntRange
+import androidx.camera.core.CameraSelector
 import com.foke.together.domain.interactor.entity.CameraSourceType
 import com.foke.together.domain.interactor.entity.ExternalCameraIP
 import kotlinx.coroutines.flow.Flow
@@ -11,5 +13,25 @@ interface AppPreferenceInterface {
     fun getExternalCameraIP(): Flow<ExternalCameraIP>
     suspend fun setExternalCameraIP(ip: ExternalCameraIP)
 
+    fun getInternalCameraLensFacing(): Flow<Int>
+    suspend fun setInternalCameraLensFacing(
+        @IntRange(from = 0, to = 1) lensFacing: Int
+    )
+
+    fun getInterenalCameraFlashMode(): Flow<Int>
+    suspend fun setInterenalCameraFlashMode(
+        @IntRange(from = 0, to = 3) flashMode: Int
+    )
+
+    fun getInternalCameraCaptureMode(): Flow<Int>
+    suspend fun setInterenalCameraCaptureMode(
+        @IntRange(from = 0, to = 2) captureMode: Int
+    )
+
+    fun getInternalCameraAspectRatio(): Flow<Int>
+    suspend fun setInterenalCameraAspectRatio(
+        @IntRange(from = -1, to = 1) aspectRatio: Int
+    )
+
     suspend fun clearAll()
 }

domain/src/main/java/com/foke/together/domain/output/InternalCameraRepositoryInterface.kt

@@ -0,0 +1,24 @@
+package com.foke.together.domain.output
+
+import android.content.Context
+import android.graphics.Bitmap
+import androidx.annotation.IntRange
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.ImageAnalysis
+import androidx.camera.core.ImageCapture
+import androidx.camera.view.PreviewView
+import androidx.lifecycle.LifecycleOwner
+
+interface InternalCameraRepositoryInterface {
+    suspend fun capture(context: Context): Result<Bitmap>
+    suspend fun showCameraPreview(
+        context: Context,
+        lifecycleOwner: LifecycleOwner,
+        previewView: PreviewView,
+        selector : CameraSelector,
+        imageAnalysis: ImageAnalysis?,
+        @IntRange(from = 0, to = 2) captureMode: Int,
+        @IntRange(from = 0, to = 3) flashMode: Int,
+        @IntRange(from = -1, to = 1) aspectRatio: Int
+    )
+}