demo-app/src/main/kotlin/io/getstream/video/android/ui/menu/base/DynamicMenu.kt (1)

174-182: findSubMenuItem relies on unique titles across the entire menu tree.

If two SubMenuItems at different nesting levels share the same title, this depth-first search returns the first match, which may not be the intended submenu. This is fine for the current demo app menu structure, but worth noting as a fragility if menus grow or titles are localized identically.

demo-app/src/main/kotlin/io/getstream/video/android/ui/menu/MenuDefinitions.kt (1)

283-332: Use listOf instead of arrayListOf — the returned list doesn't need to be mutable.

arrayListOf allocates a mutable ArrayList that is never mutated. The return type is List<MenuItem>, so listOf is more idiomatic and communicates immutability.

Also, the repeated selectedRecordingTypes.contains(…) calls per item can be simplified with local booleans.

♻️ Suggested simplification

 fun recordingTypeMenu(onSelectRecording: (RecordingType) -> Unit, selectedRecordingTypes: Set<RecordingType>): List<MenuItem> {
-    return arrayListOf(
-        ActionMenuItem(
-            title = if (selectedRecordingTypes.contains(
-                    RecordingType.Raw,
-                )
-            ) {
-                "Stop raw recording"
-            } else {
-                "Start raw recording"
-            },
-            icon = if (selectedRecordingTypes.contains(
-                    RecordingType.Raw,
-                )
-            ) {
-                Icons.Default.RawOn
-            } else {
-                Icons.Default.RawOff
-            },
-            highlight = selectedRecordingTypes.contains(RecordingType.Raw),
-            action = { onSelectRecording(RecordingType.Raw) },
-        ),
-        ActionMenuItem(
-            title = if (selectedRecordingTypes.contains(
-                    RecordingType.Individual,
-                )
-            ) {
-                "Stop individual recording"
-            } else {
-                "Start individual recording"
-            },
-            icon = Icons.Default.Person,
-            highlight = selectedRecordingTypes.contains(RecordingType.Individual),
-            action = { onSelectRecording(RecordingType.Individual) },
-        ),
-        ActionMenuItem(
-            title = if (selectedRecordingTypes.contains(
-                    RecordingType.Composite,
-                )
-            ) {
-                "Stop composite recording"
-            } else {
-                "Start composite recording"
-            },
-            icon = Icons.Default.CropFree,
-            highlight = selectedRecordingTypes.contains(RecordingType.Composite),
-            action = { onSelectRecording(RecordingType.Composite) },
-        ),
-    )
+    val isRaw = RecordingType.Raw in selectedRecordingTypes
+    val isIndividual = RecordingType.Individual in selectedRecordingTypes
+    val isComposite = RecordingType.Composite in selectedRecordingTypes
+
+    return listOf(
+        ActionMenuItem(
+            title = if (isRaw) "Stop raw recording" else "Start raw recording",
+            icon = if (isRaw) Icons.Default.RawOn else Icons.Default.RawOff,
+            highlight = isRaw,
+            action = { onSelectRecording(RecordingType.Raw) },
+        ),
+        ActionMenuItem(
+            title = if (isIndividual) "Stop individual recording" else "Start individual recording",
+            icon = Icons.Default.Person,
+            highlight = isIndividual,
+            action = { onSelectRecording(RecordingType.Individual) },
+        ),
+        ActionMenuItem(
+            title = if (isComposite) "Stop composite recording" else "Start composite recording",
+            icon = Icons.Default.CropFree,
+            highlight = isComposite,
+            action = { onSelectRecording(RecordingType.Composite) },
+        ),
+    )
 }

demo-app/src/main/kotlin/io/getstream/video/android/ui/menu/SettingsMenu.kt (1)

265-277: The when is redundant — all branches perform the same action.

Every sealed subclass of RecordingType is collapsed into a single branch, so the when adds no value. A simple if/else on the set membership is sufficient. If the intent is to get a compile error on future RecordingType additions, the when should be exhaustive (e.g., drop the combined branch and handle each case separately) — but since they all do the same thing, that won't help either.

Also, consider surfacing the Result from startRecording/stopRecording to show a toast on failure, consistent with how other debug actions in this file show Toast messages.

♻️ Simplified handler

     val onSelectRecordingType = { recordingType: RecordingType ->
         scope.launch {
-            when (recordingType) {
-                RecordingType.Raw, RecordingType.Individual, RecordingType.Composite ->
-                    if (enabledRecordingTypes.contains(recordingType)) {
-                        call.stopRecording(recordingType)
-                    } else {
-                        call.startRecording(recordingType)
-                    }
+            if (recordingType in enabledRecordingTypes) {
+                call.stopRecording(recordingType)
+            } else {
+                call.startRecording(recordingType)
             }
         }
         Unit
     }

demo-app/src/main/kotlin/io/getstream/video/android/ui/call/CallScreen.kt (1)

796-804: Simplify isRecording — building a Set just to check emptiness is unnecessary overhead.

Since you only need a boolean, a simple disjunction avoids the Set allocation on every derivation pass.

♻️ Simplified derivation

         val isRecording by remember {
             derivedStateOf {
-                buildSet {
-                    if (compositeRecording) add(RecordingType.Composite)
-                    if (individualRecording) add(RecordingType.Individual)
-                    if (rawRecording) add(RecordingType.Raw)
-                }.isNotEmpty()
+                compositeRecording || individualRecording || rawRecording
             }
         }

Note: this buildSet pattern is also duplicated in SettingsMenu.kt (lines 256-264). Consider extracting a shared helper if both need the same Set<RecordingType> representation, or simplify both to plain boolean logic where only a boolean is needed.