Android Selfie App LP review

pareenaverma · pareenaverma · commit 57808b142967 · 2024-12-23T20:29:26.000Z
diff --git a/content/learning-paths/smartphones-and-mobile/build-android-selfie-app-using-mediapipe-multimodality/6-flow-data-to-view-1.md b/content/learning-paths/smartphones-and-mobile/build-android-selfie-app-using-mediapipe-multimodality/6-flow-data-to-view-1.md
@@ -8,7 +8,7 @@ layout: learningpathall
 
 [SharedFlow](https://developer.android.com/kotlin/flow/stateflow-and-sharedflow#sharedflow) and [StateFlow](https://developer.android.com/kotlin/flow/stateflow-and-sharedflow#stateflow) are [Kotlin Flow](https://developer.android.com/kotlin/flow) APIs that enable Flows to optimally emit state updates and emit values to multiple consumers.
 
-In this learning path, you will have the opportunity to experiment with both `SharedFlow` and `StateFlow`. This chapter will focus on SharedFlow while the next chapter will focus on StateFlow.
+In this learning path, you will experiment with both `SharedFlow` and `StateFlow`. This section will focus on SharedFlow while the next chapter will focus on StateFlow.
 
 `SharedFlow` is a general-purpose, hot flow that can emit values to multiple subscribers. It is highly configurable, allowing you to set the replay cache size, buffer capacity, etc.
 
@@ -54,9 +54,9 @@ This `SharedFlow` is initialized with a replay size of `1`. This retains the mos
 
 ## Visualize face and gesture results
 
-To visualize the results of Face Landmark Detection and Gesture Recognition tasks, we have prepared the following code for you based on [MediaPipe's samples](https://github.com/google-ai-edge/mediapipe-samples/tree/main/examples).
+To visualize the results of Face Landmark Detection and Gesture Recognition tasks, based on [MediaPipe's samples](https://github.com/google-ai-edge/mediapipe-samples/tree/main/examples) follow the intructions in this section.
 
-1. Create a new file named `FaceLandmarkerOverlayView.kt` and fill in the content below:
+1. Create a new file named `FaceLandmarkerOverlayView.kt` and copy the content below:
 
 ```kotlin
 /*
@@ -180,7 +180,7 @@ class FaceLandmarkerOverlayView(context: Context?, attrs: AttributeSet?) :
 ```
 
 
-2. Create a new file named `GestureOverlayView.kt` and fill in the content below:
+2. Create a new file named `GestureOverlayView.kt` and copy the content below:
 
 ```kotlin
 /*
@@ -302,7 +302,7 @@ class GestureOverlayView(context: Context?, attrs: AttributeSet?) :
 
 ## Update UI in the view controller
 
-1. Add the above two overlay views to `activity_main.xml` layout file:
+1. Add the two overlay views to `activity_main.xml` layout file:
 
 ```xml
     <com.example.holisticselfiedemo.FaceLandmarkerOverlayView
@@ -316,7 +316,7 @@ class GestureOverlayView(context: Context?, attrs: AttributeSet?) :
         android:layout_height="match_parent" />
 ```
 
-2. Collect the new SharedFlow `uiEvents` in `MainActivity` by appending the code below to the end of `onCreate` method, **below** `setupCamera()` method call.
+2. Collect the new SharedFlow `uiEvents` in `MainActivity` by appending the code below to the end of `onCreate` method, below `setupCamera()` method call.
 
 ```kotlin
         lifecycleScope.launch {
@@ -363,7 +363,7 @@ class GestureOverlayView(context: Context?, attrs: AttributeSet?) :
     }
 ```
 
-4. Build and run the app again. Now you should be seeing face and gesture overlays on top of the camera preview as shown below. Good job!
+4. Build and run the app again. Now you should see face and gesture overlays on top of the camera preview as shown below. Good job!
 
 ![overlay views](images/6/overlay%20views.png)
 
diff --git a/content/learning-paths/smartphones-and-mobile/build-android-selfie-app-using-mediapipe-multimodality/7-flow-data-to-view-2.md b/content/learning-paths/smartphones-and-mobile/build-android-selfie-app-using-mediapipe-multimodality/7-flow-data-to-view-2.md
@@ -25,7 +25,7 @@ Therefore, `StateFlow` is a specialized type of `SharedFlow` that represents a s
     val gestureOk: StateFlow<Boolean> = _gestureOk
 ```
 
-2. Append the following constant values to `MainViewModel`'s companion object. In this demo app, we are only focusing on smiling faces and thumb-up gestures.
+2. Append the following constant values to `MainViewModel`'s companion object. In this demo app, you will focus on smiling faces and thumb-up gestures.
 
 ```kotlin
         private const val FACE_CATEGORY_MOUTH_SMILE = "mouthSmile"
@@ -75,7 +75,7 @@ Therefore, `StateFlow` is a specialized type of `SharedFlow` that represents a s
     <string name="condition_indicator_text_gesture">Gesture</string>
 ```
 
-2. In the same directory, create a new resource file named `dimens.xml` if not exist, which is used to define layout related dimension values:
+2. In the same directory, create a new resource file named `dimens.xml` if it does not exist. This file is used to define layout related dimension values:
 
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
@@ -85,7 +85,7 @@ Therefore, `StateFlow` is a specialized type of `SharedFlow` that represents a s
 </resources>
 ```
 
-3. Navigate to `activity_main.xml` layout file and add the following code to the root `ConstraintLayout`, **below** the two overlay views which you just added in the previous chapter.
+3. Navigate to `activity_main.xml` layout file and add the following code to the root `ConstraintLayout`. Add this code after the two overlay views which you just added in the previous section.
 
 ```xml
     <androidx.appcompat.widget.SwitchCompat
@@ -111,7 +111,7 @@ Therefore, `StateFlow` is a specialized type of `SharedFlow` that represents a s
         app:layout_constraintBottom_toBottomOf="parent" />
 ```
 
-4. Finally, navigate to `MainActivity.kt` and append the following code inside `repeatOnLifecycle(Lifecycle.State.RESUMED)` block, **below** the `launch` block you just added in the previous chapter. This makes sure each of the **three** parallel `launch` runs in its own Coroutine concurrently without blocking each other.
+4. Finally, navigate to `MainActivity.kt` and append the following code inside `repeatOnLifecycle(Lifecycle.State.RESUMED)` block, after the `launch` block you just added in the previous section. This makes sure each of the three parallel `launch` run in its own co-routine concurrently without blocking each other.
 
 ```kotlin
                 launch {
@@ -127,15 +127,15 @@ Therefore, `StateFlow` is a specialized type of `SharedFlow` that represents a s
                 }
 ```
 
-5. Build and run the app again. Now you should be seeing two switches on the bottom of the screen as shown below, which turns on and off while you smile and show thumb-up gestures. Good job!
+5. Build and run the app again. Now you should see two switches on the bottom of the screen as shown below, which turn on and off while you smile and show thumb-up gestures. Good job!
 
 ![indicator UI](images/7/indicator%20ui.png)
 
 ## Recap on SharedFlow vs StateFlow
 
 This app uses `SharedFlow` for dispatching overlay views' UI events without mandating a specific stateful model, which avoids redundant computation. Meanwhile, it uses `StateFlow` for dispatching condition switches' UI states, which prevents duplicated emission and consequent UI updates.
 
-Here's a breakdown of the differences between `SharedFlow` and `StateFlow`:
+Here's a overview of the differences between `SharedFlow` and `StateFlow`:
 
 |  | SharedFlow | StateFlow |
 | --- | --- | --- |
diff --git a/content/learning-paths/smartphones-and-mobile/build-android-selfie-app-using-mediapipe-multimodality/8-mediate-flows.md b/content/learning-paths/smartphones-and-mobile/build-android-selfie-app-using-mediapipe-multimodality/8-mediate-flows.md
@@ -6,7 +6,7 @@ weight: 8
 layout: learningpathall
 ---
 
-Now you have two independent Flows indicating the conditions of face landmark detection and gesture recognition. The simplest multimodality strategy is to combine multiple source Flows into a single output Flow, which emits consolidated values as the [single source of truth](https://en.wikipedia.org/wiki/Single_source_of_truth) for its observers (collectors) to carry out corresponding actions.
+Now you have two independent Flows indicating the conditions of face landmark detection and gesture recognition. The simplest multimodality strategy is to combine multiple source Flows into a single output Flow, which emits consolidated values as the single source of truth for its observers (collectors) to carry out corresponding actions.
 
 ## Combine two Flows into a single Flow
 
@@ -33,9 +33,9 @@ Now you have two independent Flows indicating the conditions of face landmark de
 ```
 
 {{% notice Note %}}
-Kotlin Flow's [`combine`](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/combine.html) transformation is equivalent to ReactiveX's [`combineLatest`](https://reactivex.io/documentation/operators/combinelatest.html). It combines emissions from multiple observables, so that each time **any** observable emits, the combinator function is called with the latest values from all sources.
+Kotlin Flow's [`combine`](https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/combine.html) transformation is equivalent to ReactiveX's [`combineLatest`](https://reactivex.io/documentation/operators/combinelatest.html). It combines emissions from multiple observables, so that each time any observable emits, the combinator function is called with the latest values from all sources.
 
-You might need to add `@OptIn(FlowPreview::class)` annotation since `sample` is still in preview. For more information on similar transformations, please refer to [this blog](https://kt.academy/article/cc-flow-combine).
+You might need to add `@OptIn(FlowPreview::class)` annotation since `sample` is still in preview.
 
 {{% /notice %}}
 
@@ -49,30 +49,7 @@ You might need to add `@OptIn(FlowPreview::class)` annotation since `sample` is
         .shareIn(viewModelScope, SharingStarted.WhileSubscribed())
 ```
 
-If this code looks confusing to you, please see the explanations below for Kotlin beginners.
-
-{{% notice Info %}}
-
-###### Keyword "it"
-
-The operation `filter { it }` is simplified from `filter { bothOk -> bothOk == true }`. 
-
-Since Kotlin allows for implictly calling the single parameter in a lambda `it`, `{ bothOk -> bothOk == true }` is equivalent to `{ it == true }`, and again  `{ it }`. 
-
-See [this doc](https://kotlinlang.org/docs/lambdas.html#it-implicit-name-of-a-single-parameter) for more details.
-
-{{% /notice %}}
-
-{{% notice Info %}}
-
-###### "Unit" type
-This `SharedFlow` has a generic type `Unit`, which doesn't contain any value. You may think of it as a "pulse" signal.
-
-The operation `map { }` simply maps the upstream `Boolean` value emitted from `_bothOk` to `Unit` regardless their values are true or false. It's simplified from `map { bothOk -> Unit }`, which becomes `map { Unit } ` where the keyword `it` is not used at all. Since an empty block already returns `Unit` implicitly, we don't need to explicitly return it.
-
-{{% /notice %}}
-
-If this still looks confusing, you may also opt to use `SharedFlow<Boolean>` and remove the `map { }` operation. Just note that when you collect this Flow, it doesn't matter whether the emitted `Boolean` values are true or false. In fact, they are always `true` due to the `filter` operation.
+You may also opt to use `SharedFlow<Boolean>` and remove the `map { }` operation. Just note that when you collect this Flow, it doesn't matter whether the emitted `Boolean` values are true or false. In fact, they are always `true` due to the `filter` operation.
 
 ## Configure ImageCapture use case
 
@@ -92,7 +69,7 @@ If this still looks confusing, you may also opt to use `SharedFlow<Boolean>` and
             .build()
 ```
 
-3. Again, don't forget to append this use case to `bindToLifecycle`.
+3. Append this use case to `bindToLifecycle`.
 
 ```kotlin
             camera = cameraProvider.bindToLifecycle(
@@ -102,7 +79,7 @@ If this still looks confusing, you may also opt to use `SharedFlow<Boolean>` and
 
 ## Execute photo capture with ImageCapture
 
-1. Append the following constant values to `MainActivity`'s companion object. They define the file name format and the [MIME type](https://en.wikipedia.org/wiki/Media_type).
+1. Append the following constant values to `MainActivity`'s companion object. They define the file name format and the media type:
 
 ```kotlin
         // Image capture
@@ -165,7 +142,7 @@ If this still looks confusing, you may also opt to use `SharedFlow<Boolean>` and
 
 ## Add a flash effect upon capturing photo
 
-1. Navigate to `activity_main.xml` layout file and insert the following `View` element **between** the two overlay views and two `SwitchCompat` views. This is essentially just a white blank view covering the whole surface.
+1. Navigate to `activity_main.xml` layout file and insert the following `View` element between the two overlay views and two `SwitchCompat` views. This is essentially just a white blank view covering the whole surface.
 
 ```
     <View
@@ -204,6 +181,6 @@ If this still looks confusing, you may also opt to use `SharedFlow<Boolean>` and
     }
 ``` 
 
-3. Invoke `showFlashEffect()` method in `executeCapturePhoto()` method, **before** invoking `imageCapture.takePicture()`
+3. Invoke `showFlashEffect()` method in `executeCapturePhoto()` method, before invoking `imageCapture.takePicture()`
 
 4. Build and run the app. Try keeping up a smiling face while presenting thumb-up gestures. When you see both switches turn on and stay stable for approximately half a second, the screen should flash white and then a photo should be captured and shows up in your album, which may take a few seconds depending on your Android device's hardware. Good job!
diff --git a/content/learning-paths/smartphones-and-mobile/build-android-selfie-app-using-mediapipe-multimodality/9-avoid-redundant-requests.md b/content/learning-paths/smartphones-and-mobile/build-android-selfie-app-using-mediapipe-multimodality/9-avoid-redundant-requests.md
@@ -1,16 +1,16 @@
 ---
-title: Avoid duplicated photo capture requests
+title: Avoid duplicate photo capture requests
 weight: 9
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-So far, we have implemented the core logic for mediating MediaPipe's face and gesture task results and executing photo captures. However, the view controller does not communicate its execution results back to the view model. This introduces risks such as photo capture failures, frequent or duplicate requests, and other potential issues.
+So far, you have implemented the core logic for MediaPipe's face and gesture task results and executing photo captures. However, the view controller does not communicate its execution results back to the view model. This introduces risks such as photo capture failures, frequent or duplicate requests, and other potential issues.
 
 ## Introduce camera readiness state
 
-It is a best practice to complete the data flow cycle by providing callbacks for the view controller's states. This ensures that the view model does not emit values in undesired states, such as when the camera is busy or unavailable.
+It is best practice to complete the data flow cycle by providing callbacks for the view controller's states. This ensures that the view model does not emit values in undesired states, such as when the camera is busy or unavailable.
 
 1. Navigate to `MainViewModel` and add a `MutableStateFlow` named `_isCameraReady` as a  private member variable. This keeps track of whether the camera is busy or unavailable.
 
@@ -58,7 +58,7 @@ The duration of image capture can vary across Android devices due to hardware di
 
 To address this, implementing a simple cooldown mechanism after each photo capture can enhance the user experience while conserving computing resources.
 
-1. Add the following constant value to `MainViewModel`'s companion object. This defines a `3` sec cooldown before marking the camera available again.
+1. Add the following constant value to `MainViewModel`'s companion object. This defines a 3 seconds cooldown before making the camera available again.
 
 ```kotlin
     private const val IMAGE_CAPTURE_DEFAULT_COUNTDOWN = 3000L
@@ -91,6 +91,6 @@ However, silently failing without notifying the user is not a good practice for
 
 ## Completed sample code on GitHub
 
-If you run into any difficulties completing this learning path, feel free to check out the [completed sample code](https://github.com/hanyin-arm/sample-android-selfie-app-using-mediapipe-multimodality) and import it into Android Studio.
+If you run into any difficulties completing this learning path, you can check out the [complete sample code](https://github.com/hanyin-arm/sample-android-selfie-app-using-mediapipe-multimodality) and import it into Android Studio.
 
-If you discover a bug, encounter an issue, or have suggestions for improvement, we’d love to hear from you! Please feel free to [open an issue](https://github.com/hanyin-arm/sample-android-selfie-app-using-mediapipe-multimodality/issues/new) with detailed information.
+If you discover a bug, encounter an issue, or have suggestions for improvement, please feel free to [open an issue](https://github.com/hanyin-arm/sample-android-selfie-app-using-mediapipe-multimodality/issues/new) with detailed information.
