Create Micro Image widget - 1/3

app/AndroidManifest.xml

@@ -139,6 +139,10 @@
             android:name="com.google.firebase.messaging.default_notification_channel_id"
             android:value="@string/fcm_default_notification_channel" />
 
+        <meta-data
+            android:name="com.google.mlkit.vision.DEPENDENCIES"
+            android:value="face" />
+
         <activity
             android:label="@string/application_name"
             android:exported="true"
@@ -317,6 +321,10 @@
             android:name="org.commcare.activities.FormRecordListActivity"
             android:windowSoftInputMode="adjustResize">
         </activity>
+        <activity
+            android:name="org.commcare.fragments.MicroImageActivity"
+            android:windowSoftInputMode="adjustResize">
+        </activity>
         <service
             android:enabled="true"
             android:foregroundServiceType="specialUse"

app/assets/locales/android_translatable_strings.txt

@@ -992,3 +992,9 @@ background.sync.fail=Background sync failed. Please try to trigger a normal Sync
 android.package.name.org.commcare.dalvik.reminders=CommCare Reminders
 android.package.name.callout.commcare.org.sendussd=Commcare USSD
 android.package.name.org.commcare.dalvik.abha=CommCare ABHA
+
+microimage.camera.start.failed=Camera failed to start
+microimage.face.detection.mode.failed=Face detection mode failed
+microimage.cropping.failed=Image cropping failed, make sure the target is inside the capture area
+microimage.decoding.no.image=Image processing failed. Please try again
+microimage.scalingdown.compression.error=Image compression failed. Please try again

app/build.gradle

@@ -66,6 +66,11 @@ dependencies {
 
     // this syntax doesn't work for compiling .aar files, so those have to be loaded manually
     implementation fileTree(include: '*.jar', exclude: 'regexp-me.jar', dir: 'libs')
+    implementation "androidx.camera:camera-view:$cameraX_version"
+    implementation "androidx.camera:camera-core:$cameraX_version"
+    implementation "androidx.camera:camera-camera2:$cameraX_version"
+    implementation "androidx.camera:camera-lifecycle:$cameraX_version"
+    implementation 'com.google.android.gms:play-services-mlkit-face-detection:17.1.0'
     implementation(name: 'htmlspanner-custom', ext: 'aar')
     implementation 'com.github.dimagi:zebra-print-android:v1.3'
     implementation (name: 'LibSimprints-1.0.12', ext: 'aar')

app/res/layout/micro_image_widget.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:viewBindingIgnore="true">
+
+    <androidx.camera.view.PreviewView
+        android:id="@+id/view_finder"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical"
+        android:layout_gravity="center">
+
+        <org.commcare.views.FaceCaptureView
+            android:id="@+id/face_overlay"
+            android:layout_width="match_parent"
+            android:layout_height="0dp"
+            app:background_color="@color/cc_neutral_bg_tr"
+            app:face_capture_area_delimiter_color="@color/white"
+            app:face_marker_color="@color/cc_attention_positive_color"
+            app:countdown_text_size="@dimen/font_size_large"
+            android:layout_weight="1"/>
+    </LinearLayout>
+</FrameLayout>

app/res/values/attrs.xml

@@ -53,5 +53,10 @@
     <declare-styleable name="FilePreference">
         <attr name="file_type" format="string"/>
     </declare-styleable>
-
+    <declare-styleable name="FaceCaptureView">
+        <attr name="background_color" format="color" />
+        <attr name="face_capture_area_delimiter_color" format="color" />
+        <attr name="face_marker_color" format="color" />
+        <attr name="countdown_text_size" format="dimension" />
+    </declare-styleable>
 </resources>

app/res/values/colors.xml

@@ -86,6 +86,7 @@
     <!-- Neutral -->
     <color name="cc_neutral_color">#685C53</color>
     <color name="cc_neutral_bg">#D6D6D4</color>
+    <color name="cc_neutral_bg_tr">#80D6D6D4</color>
     <color name="cc_neutral_text">#373534</color>
 
     <!-- Attention Positive -->

app/res/values/strings.xml

@@ -461,4 +461,5 @@
     <string name="fcm_default_notification_channel">notification-channel-push-notifications</string>
     <string name="app_with_id_not_found">Required CommCare App is not installed on device</string>
     <string name="audio_recording_notification">Audio Recording Notification</string>
+    <string name="micro_image_activity_title" cc:translatable="true">Capture Face Picture</string>
 </resources>

app/src/org/commcare/activities/FormEntryActivity.java

@@ -358,9 +358,8 @@ public void onActivityResultSessionSafe(int requestCode, int resultCode, Intent
                                 Localization.get("intent.callout.unable.to.process"), Toast.LENGTH_SHORT).show();
                     }
                     break;
-                case FormEntryConstants.IMAGE_CAPTURE:
-                    ImageCaptureProcessing.processCaptureResponse(this,
-                            FormEntryInstanceState.getInstanceFolder(), true);
+                case FormEntryConstants.IMAGE_CAPTURE, FormEntryConstants.MICRO_IMAGE_CAPTURE:
+                    ImageCaptureProcessing.processCaptureResponse(this, FormEntryInstanceState.getInstanceFolder(), true);
                     break;
                 case FormEntryConstants.SIGNATURE_CAPTURE:
                     Logger.log(LogTypes.SOFT_ASSERT, "Signature captured successfully");

app/src/org/commcare/activities/components/FormEntryConstants.java

@@ -21,7 +21,7 @@ public class FormEntryConstants {
     public static final int INTENT_LOCATION_PERMISSION = 14;
     public static final int INTENT_LOCATION_EXCEPTION = 15;
     public static final int VIEW_VIDEO_FULLSCREEN = 16;
-
+    public static final int MICRO_IMAGE_CAPTURE = 17;
     public static final String NAV_STATE_NEXT = "next";
     public static final String NAV_STATE_DONE = "done";
     public static final String NAV_STATE_QUIT = "quit";

app/src/org/commcare/fragments/MicroImageActivity.java

@@ -0,0 +1,190 @@
+package org.commcare.fragments;
+
+import android.annotation.SuppressLint;
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.media.Image;
+import android.os.Bundle;
+import android.util.Size;
+import android.widget.Toast;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.mlkit.common.MlKitException;
+import com.google.mlkit.vision.common.InputImage;
+import com.google.mlkit.vision.common.internal.ImageConvertUtils;
+import com.google.mlkit.vision.face.Face;
+import com.google.mlkit.vision.face.FaceDetection;
+import com.google.mlkit.vision.face.FaceDetector;
+import com.google.mlkit.vision.face.FaceDetectorOptions;
+
+import org.commcare.dalvik.R;
+import org.commcare.util.LogTypes;
+import org.commcare.utils.MediaUtil;
+import org.commcare.views.FaceCaptureView;
+import org.commcare.views.widgets.ImageWidget;
+import org.javarosa.core.services.Logger;
+import org.javarosa.core.services.locale.Localization;
+
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.ActionBar;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.camera.core.CameraSelector;
+import androidx.camera.core.ImageAnalysis;
+import androidx.camera.core.ImageProxy;
+import androidx.camera.core.Preview;
+import androidx.camera.core.UseCase;
+import androidx.camera.lifecycle.ProcessCameraProvider;
+import androidx.camera.view.PreviewView;
+import androidx.core.content.ContextCompat;
+
+public class MicroImageActivity extends AppCompatActivity implements ImageAnalysis.Analyzer, FaceCaptureView.ImageStabilizedListener {
+    private static final String TAG = MicroImageActivity.class.toString();
+    private PreviewView cameraView;
+    private FaceCaptureView faceCaptureView;
+    private Bitmap inputImage;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.micro_image_widget);
+
+        faceCaptureView = findViewById(R.id.face_overlay);
+        cameraView = findViewById(R.id.view_finder);
+
+        ActionBar actionBar = getSupportActionBar();
+        if (actionBar != null) {
+            actionBar.setTitle(R.string.micro_image_activity_title);
+        }
+
+        faceCaptureView.setImageStabilizedListener(this);
+
+        try {
+           startCamera();
+        } catch (ExecutionException | InterruptedException e) {
+            logErrorAndExit("Error starting camera", "microimage.camera.start.failed", e);
+        }
+    }
+
+    private void startCamera() throws ExecutionException, InterruptedException {
+        ListenableFuture<ProcessCameraProvider> cameraProviderFuture = ProcessCameraProvider.getInstance(this);
+
+        cameraProviderFuture.addListener(() -> {
+            ProcessCameraProvider cameraProvider;
+            try {
+                cameraProvider = cameraProviderFuture.get();
+            } catch (ExecutionException | InterruptedException e) {
+                logErrorAndExit("Error acquiring camera provider", "microimage.camera.start.failed", e);
+                return;
+            }
+            bindUseCases(cameraProvider);
+        }, ContextCompat.getMainExecutor(this));
+    }
+
+    private void bindUseCases(ProcessCameraProvider cameraProvider) {
+        int targetRotation = getWindowManager().getDefaultDisplay().getRotation();
+        Size targetResolution = new Size(faceCaptureView.getImageWidth(), faceCaptureView.getImageHeight());
+
+        // Preview use case
+        Preview preview = new Preview.Builder()
+                .setTargetResolution(targetResolution)
+                .setTargetRotation(targetRotation)
+                .build();
+        preview.setSurfaceProvider(cameraView.getSurfaceProvider());
+
+        UseCase imageAnalyzer = buildImageAnalysisUseCase(targetResolution, targetRotation);
+
+        CameraSelector cameraSelector = CameraSelector.DEFAULT_BACK_CAMERA;
+
+        // Unbind any previous use cases before binding new ones
+        cameraProvider.unbindAll();
+
+        // Bind the use cases to the camera
+        cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageAnalyzer);
+    }
+
+    private UseCase buildImageAnalysisUseCase(Size targetResolution, int targetRotation) {
+        ImageAnalysis imageAnalyzer = new ImageAnalysis.Builder()
+                .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
+                .setTargetResolution(targetResolution)
+                .setTargetRotation(targetRotation)
+                .build();
+
+        imageAnalyzer.setAnalyzer(ContextCompat.getMainExecutor(getApplicationContext()), this);
+        return imageAnalyzer;
+    }
+
+    private void logErrorAndExit(String logMessage, String userMessageKey, Throwable e) {
+        if (e == null) {
+            Logger.log(LogTypes.TYPE_EXCEPTION, logMessage);
+        } else {
+            Logger.exception(logMessage, e);
+        }
+        Toast.makeText(this, Localization.get(userMessageKey), Toast.LENGTH_LONG).show();
+        setResult(AppCompatActivity.RESULT_CANCELED);
+        finish();
+    }
+
+    @Override
+    public void analyze(@NonNull ImageProxy imageProxy) {
+        @SuppressLint("UnsafeOptInUsageError") Image mediaImage = imageProxy.getImage();
+        if (mediaImage != null) {
+            InputImage image = InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
+
+            FaceDetectorOptions realTimeOpts = new FaceDetectorOptions.Builder()
+                    .setContourMode(FaceDetectorOptions.CONTOUR_MODE_NONE)
+                    .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE)
+                    .build();
+            FaceDetector faceDetector = FaceDetection.getClient(realTimeOpts);
+            // process image with the face detector
+            faceDetector.process(image)
+                    .addOnSuccessListener(faces -> processFaceDetectionResult(faces, image))
+                    .addOnFailureListener(e -> handleErrorDuringDetection(e))
+                    .addOnCompleteListener(task -> {
+                        imageProxy.close();
+                    });
+        } else {
+            imageProxy.close();
+        }
+    }
+
+    private void handleErrorDuringDetection(Exception e) {
+        Logger.exception("Error during face detection ", e);
+        Toast.makeText(this, "microimage.face.detection.mode.failed", Toast.LENGTH_LONG).show();
+        // TODO: decide whether to switch to manual mode or close activity
+    }
+
+    private void processFaceDetectionResult(List<Face> faces, InputImage image) {
+        if (faces.size() > 0) {
+            // Only one face is processed, this can be increased if needed
+            Face newFace = faces.get(0);
+
+            // this will draw a bounding circle around the first detected face
+            faceCaptureView.updateFace(newFace);
+            try {
+                inputImage = ImageConvertUtils.getInstance().convertToUpRightBitmap(image);
+            } catch (MlKitException e) {
+                Logger.exception("Error during face detection ", e);
+                Toast.makeText(this, "microimage.face.detection.mode.failed", Toast.LENGTH_LONG).show();
+                // TODO: decide whether to switch to manual mode or close activity?
+            }
+        } else {
+            faceCaptureView.updateFace(null);
+        }
+    }
+
+    @Override
+    public void onImageStabilizedListener(Rect faceArea) {
+        try {
+            MediaUtil.cropAndSaveImage(inputImage, faceArea, ImageWidget.getTempFileForImageCapture());
+            setResult(AppCompatActivity.RESULT_OK);
+            finish();
+        } catch (Exception e) {
+            logErrorAndExit(e.getMessage(), "microimage.cropping.failed", e.getCause());
+        }
+
+    }
+}