@cometchat/skills 4.1.0 → 4.2.0

package/skills/cometchat-android-v6-calls/references/in-call-chat.md

@@ -0,0 +1,136 @@
+# In-call chat on Android V6
+
+V5 has detailed in-call-chat reference; V6 adds Compose-specific UI patterns. The SDK API + group-as-session architecture is unchanged.
+
+**Canonical docs:** https://www.cometchat.com/docs/calls/android/in-call-chat
+**Read first:** `cometchat-android-v5-calls/references/in-call-chat.md` — full Kotlin Views + Java SDK patterns + group setup.
+
+---
+
+## Compose ModalBottomSheet for in-call chat
+
+```kotlin
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun InCallChatSheet(
+  sessionId: String,
+  viewModel: InCallChatViewModel = viewModel(),
+) {
+  val state by viewModel.state.collectAsStateWithLifecycle()
+  val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = false)
+
+  if (state.open && state.group != null) {
+    ModalBottomSheet(
+      onDismissRequest = { viewModel.close() },
+      sheetState = sheetState,
+      shape = RoundedCornerShape(topStart = 16.dp, topEnd = 16.dp),
+    ) {
+      Column(modifier = Modifier
+        .fillMaxWidth()
+        .heightIn(min = 400.dp)
+        .padding(16.dp)) {
+        Text("Chat", style = MaterialTheme.typography.titleMedium)
+        Spacer(modifier = Modifier.height(8.dp))
+        // Compose call's CometChatMessageList composable
+        CometChatMessageList(
+          group = state.group,
+          modifier = Modifier.weight(1f),
+        )
+        CometChatMessageComposer(group = state.group)
+      }
+    }
+  }
+}
+```
+
+`Modifier.weight(1f)` makes the message list expand; composer pinned at bottom. Same minHeight:0 idea but Compose-flavored.
+
+---
+
+## ViewModel
+
+```kotlin
+data class InCallChatState(
+  val open: Boolean = false,
+  val unread: Int = 0,
+  val group: Group? = null,
+)
+
+class InCallChatViewModel : ViewModel(), MessageListener {
+  private val _state = MutableStateFlow(InCallChatState())
+  val state: StateFlow<InCallChatState> = _state
+
+  fun init(sessionId: String) {
+    viewModelScope.launch {
+      val group = ensureGroup(sessionId)
+      _state.update { it.copy(group = group) }
+      CometChat.addMessageListener("in-call-chat-$sessionId", this@InCallChatViewModel)
+    }
+  }
+
+  override fun onTextMessageReceived(message: TextMessage) {
+    if (_state.value.open) return
+    if (message.receiverType != CometChatConstants.RECEIVER_TYPE_GROUP) return
+    if (message.receiverUid != _state.value.group?.guid) return
+    _state.update { it.copy(unread = it.unread + 1) }
+    CometChatCalls.setChatButtonUnreadCount(_state.value.unread)
+  }
+
+  fun open() {
+    _state.update { it.copy(open = true, unread = 0) }
+    CometChatCalls.setChatButtonUnreadCount(0)
+  }
+
+  fun close() {
+    _state.update { it.copy(open = false) }
+  }
+
+  override fun onCleared() {
+    CometChat.removeMessageListener("in-call-chat-${_state.value.group?.guid}")
+  }
+}
+```
+
+---
+
+## Triggering from SDK event
+
+In your `CometChatCallsEventsListener` impl:
+
+```kotlin
+override fun onChatButtonClicked() {
+  // Listener is on background thread — dispatch to UI
+  Handler(Looper.getMainLooper()).post {
+    inCallChatViewModel.open()
+  }
+}
+```
+
+---
+
+## Anti-patterns
+
+V5 sister rules apply, plus Compose-specific:
+
+1. **`collectAsState()` instead of `collectAsStateWithLifecycle()`.** State updates while paused.
+2. **No `Modifier.weight(1f)` on the message list.** Composer pushes off bottom (same flex-shrink trap).
+3. **`ModalBottomSheet` without `skipPartiallyExpanded = false`.** Defaults to half-screen only; user can't drag to full.
+
+---
+
+## Verification checklist
+
+- [ ] InCallChatViewModel uses StateFlow + collectAsStateWithLifecycle
+- [ ] Message list has `Modifier.weight(1f)`
+- [ ] ModalBottomSheet `skipPartiallyExpanded = false`
+- [ ] Listener cleanup in `onCleared`
+- [ ] Real-device smoke: 2 phones in call, message → badge → tap → see message
+
+---
+
+## Pointers
+
+- `cometchat-android-v5-calls/references/in-call-chat.md` — V5 sister (Kotlin Views patterns)
+- `cometchat-android-v6-calls` SKILL.md
+- `cometchat-android-v6-calls/references/raise-hand.md` — Compose pattern sibling
+- Canonical docs: https://www.cometchat.com/docs/calls/android/in-call-chat

package/skills/cometchat-android-v6-calls/references/raise-hand.md

@@ -0,0 +1,186 @@
+# Raise hand on Android V6 (Compose + Kotlin Views)
+
+V6 ships the same SDK API as V5 with two key delta: (1) Compose-first surface for new code, Kotlin Views still supported; (2) ViewModel + `collectAsStateWithLifecycle` is the canonical state-binding shape rather than manual `repeatOnLifecycle`.
+
+**Canonical docs:** https://www.cometchat.com/docs/calls/android/raise-hand
+**Read first:** `cometchat-android-v5-calls/references/raise-hand.md` — the SDK API + ViewModel pattern is shared; this reference covers V6's Compose layer.
+
+---
+
+## SDK API (same as V5)
+
+```kotlin
+import com.cometchat.calls.core.CometChatCalls
+import com.cometchat.calls.listeners.CometChatCallsEventsListener
+import com.cometchat.calls.model.Participant
+
+CometChatCalls.raiseHand()
+CometChatCalls.lowerHand()
+
+val settings = SessionSettingsBuilder(context, callContainer)
+  .setSessionType(SessionType.VIDEO)
+  .hideRaiseHandButton(true)
+  .build()
+```
+
+ViewModel + `StateFlow` pattern is identical to V5 (cf. sister reference). The Compose-specific delta is the UI layer.
+
+---
+
+## Compose toggle button
+
+```kotlin
+@Composable
+fun RaiseHandButton(viewModel: RaiseHandViewModel = viewModel()) {
+  val state by viewModel.state.collectAsStateWithLifecycle()
+  val context = LocalContext.current
+
+  // Announce a11y on state change
+  LaunchedEffect(state.localRaised) {
+    val accessibilityManager = context.getSystemService(Context.ACCESSIBILITY_SERVICE)
+      as AccessibilityManager
+    if (accessibilityManager.isEnabled) {
+      val announcement = if (state.localRaised) "Hand raised" else "Hand lowered"
+      val event = AccessibilityEvent.obtain(AccessibilityEvent.TYPE_ANNOUNCEMENT)
+      event.text.add(announcement)
+      accessibilityManager.sendAccessibilityEvent(event)
+    }
+  }
+
+  IconButton(
+    onClick = { viewModel.toggle() },
+    modifier = Modifier
+      .semantics {
+        role = Role.Button
+        selected = state.localRaised
+        contentDescription = if (state.localRaised) "Lower hand" else "Raise hand"
+      }
+      .background(
+        color = if (state.localRaised) Color(0xFFFFD60A) else Color.White.copy(alpha = 0.2f),
+        shape = CircleShape,
+      )
+      .padding(12.dp),
+  ) {
+    Icon(
+      imageVector = if (state.localRaised) Icons.Filled.PanTool else Icons.Outlined.PanTool,
+      contentDescription = null,
+      tint = if (state.localRaised) Color.Black else Color.White,
+    )
+  }
+}
+```
+
+`collectAsStateWithLifecycle()` (from `androidx.lifecycle.compose:lifecycle-viewmodel-compose`) is the replacement for V5's manual `repeatOnLifecycle` — it pauses collection automatically when the Composable's lifecycle drops below STARTED.
+
+`semantics { ... }` is Compose's accessibility primitive — `role`, `selected`, `contentDescription` map to Android's TalkBack model.
+
+---
+
+## Compose raised-hands sheet
+
+```kotlin
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun RaisedHandsSheet(viewModel: RaiseHandViewModel = viewModel()) {
+  val state by viewModel.state.collectAsStateWithLifecycle()
+  val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = false)
+
+  if (state.raised.isNotEmpty()) {
+    ModalBottomSheet(
+      onDismissRequest = { /* host control */ },
+      sheetState = sheetState,
+    ) {
+      Column(modifier = Modifier.padding(16.dp)) {
+        Text(
+          text = "Raised hands (${state.raised.size})",
+          style = MaterialTheme.typography.titleMedium,
+        )
+        Spacer(modifier = Modifier.height(8.dp))
+        LazyColumn {
+          items(state.raised, key = { it.uid }) { p ->
+            ListItem(
+              leadingContent = { Text("✋", fontSize = 20.sp) },
+              headlineContent = { Text(p.name) },
+              supportingContent = {
+                Text(
+                  "${(System.currentTimeMillis() - p.raisedAt) / 1000}s ago",
+                  style = MaterialTheme.typography.bodySmall,
+                  color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+              },
+            )
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+`ModalBottomSheet` is Material 3 — the V6 default. `key = { it.uid }` on `LazyColumn.items` is critical (same as `trackBy` on the web/Angular side) — without it, every state change re-renders every item from scratch.
+
+---
+
+## Wiring inside a CometChat call screen
+
+Whether the project uses Compose or Kotlin Views for the call surface affects where the button + sheet land. V6 supports both surfaces (cf. `cometchat-android-v6-calls` SKILL.md).
+
+**Compose surface:**
+
+```kotlin
+@Composable
+fun CallScreen() {
+  Box(modifier = Modifier.fillMaxSize()) {
+    // CometChat call surface (composable from chatuikit-compose-android)
+    CometChatOngoingCall(modifier = Modifier.fillMaxSize())
+
+    // Custom raise-hand overlay
+    Box(modifier = Modifier
+      .align(Alignment.BottomEnd)
+      .padding(20.dp)
+    ) {
+      RaiseHandButton()
+    }
+
+    RaisedHandsSheet()
+  }
+}
+```
+
+**Kotlin Views surface (XML layouts):** use the V5 `MaterialButton`-based pattern from the sister reference. The ViewModel + StateFlow plumbing is identical.
+
+---
+
+## Anti-patterns
+
+V5 sister reference rules apply, plus V6 Compose-specific:
+
+1. **Forgetting `key = { it.uid }` on `LazyColumn.items`.** Without it, scrolling becomes jittery as items re-mount.
+2. **Using `collectAsState()` instead of `collectAsStateWithLifecycle()`.** The former doesn't pause on lifecycle pause; burns CPU during background.
+3. **`LaunchedEffect(state.localRaised)` firing the announcement on initial composition.** First render counts as a state change; if you don't want an announcement on screen open, gate on `if (state.localRaised) ... else ...` semantics with prior tracking.
+4. **Mixing Compose state (`mutableStateOf`) with StateFlow.** Pick one source of truth — StateFlow with `collectAsStateWithLifecycle` is the V6 recommended path.
+5. **Custom raise-hand button without the `semantics { selected = ... }`.** TalkBack reads "button" but doesn't announce selection state.
+
+---
+
+## Verification checklist
+
+- [ ] `RaiseHandViewModel` uses `StateFlow` for state
+- [ ] Compose components use `collectAsStateWithLifecycle()` (not `collectAsState()`)
+- [ ] `LazyColumn.items` uses `key = { it.uid }`
+- [ ] Toggle has `semantics { role, selected, contentDescription }`
+- [ ] Accessibility announcement on state change via AccessibilityManager
+- [ ] `hideRaiseHandButton(true)` in SessionSettingsBuilder if custom UI
+- [ ] Compose surface: button mounted via `Box.align` overlay, doesn't shift CometChat call view
+- [ ] Real-device smoke: 3 Android phones, 2 raise → host's sheet shows both, sorted by time
+- [ ] TalkBack smoke: announces "Hand raised" / "Hand lowered" on toggle
+
+---
+
+## Pointers
+
+- `cometchat-android-v5-calls/references/raise-hand.md` — V5 sister reference (Kotlin Views + StateFlow)
+- `cometchat-android-v6-calls` SKILL.md — V6 hard rules + Compose vs Views split
+- `cometchat-android-v6-calls/references/group-calls.md` (when authored) — group call composition patterns
+- `cometchat-a11y` — Android Compose semantics + TalkBack
+- Canonical docs: https://www.cometchat.com/docs/calls/android/raise-hand

package/skills/cometchat-android-v6-calls/references/ringing-integration.md

@@ -0,0 +1,176 @@
+# Ringing — call signaling with custom UI (Android V6 / Compose)
+
+V5 has the canonical Android ringing reference. V6 keeps the same SDK API; only the UI layer changes (Compose vs XML Views).
+
+**Read first:**
+- `cometchat-android-v5-calls/references/ringing-integration.md` — canonical Android (full SDK flow)
+- `cometchat-react-calls/references/ringing-integration.md` — architecture + hard rules
+
+---
+
+## ViewModel
+
+```kotlin
+data class CallSignalingState(
+  val incoming: Call? = null,
+  val outgoing: Call? = null,
+  val activeSessionId: String? = null,
+)
+
+class CallSignalingViewModel : ViewModel(), CometChat.CallListener {
+  private val _state = MutableStateFlow(CallSignalingState())
+  val state: StateFlow<CallSignalingState> = _state
+
+  init {
+    CometChat.addCallListener("app", this)
+  }
+
+  override fun onIncomingCallReceived(call: Call) {
+    Handler(Looper.getMainLooper()).post {
+      _state.update { it.copy(incoming = call) }
+    }
+  }
+
+  override fun onOutgoingCallAccepted(call: Call) {
+    Handler(Looper.getMainLooper()).post {
+      _state.update { it.copy(outgoing = null, activeSessionId = call.sessionId) }
+    }
+  }
+
+  override fun onOutgoingCallRejected(call: Call) {
+    Handler(Looper.getMainLooper()).post {
+      _state.update { it.copy(outgoing = null) }
+    }
+  }
+
+  override fun onIncomingCallCancelled(call: Call) {
+    Handler(Looper.getMainLooper()).post {
+      _state.update { it.copy(incoming = null) }
+    }
+  }
+
+  override fun onCallEndedMessageReceived(call: Call) {
+    Handler(Looper.getMainLooper()).post {
+      _state.update { CallSignalingState() }
+    }
+  }
+
+  fun initiate(receiverUid: String, type: String) {
+    val call = Call(receiverUid, type, CometChatConstants.RECEIVER_TYPE_USER)
+    CometChat.initiateCall(call, object : CometChat.CallbackListener<Call>() {
+      override fun onSuccess(outgoing: Call) {
+        _state.update { it.copy(outgoing = outgoing) }
+      }
+      override fun onError(e: CometChatException) { Log.e("App", "Initiate failed", e) }
+    })
+  }
+
+  fun accept(call: Call) {
+    CometChat.acceptCall(call.sessionId, object : CometChat.CallbackListener<Call>() {
+      override fun onSuccess(accepted: Call) {
+        _state.update { it.copy(incoming = null, activeSessionId = accepted.sessionId) }
+      }
+      override fun onError(e: CometChatException) {}
+    })
+  }
+
+  fun reject(call: Call) {
+    CometChat.rejectCall(call.sessionId, CometChatConstants.CALL_STATUS_REJECTED, null)
+    _state.update { it.copy(incoming = null) }
+  }
+
+  override fun onCleared() {
+    CometChat.removeCallListener("app")
+  }
+}
+```
+
+---
+
+## Compose incoming-call overlay
+
+```kotlin
+@Composable
+fun CallSignalingOverlay(viewModel: CallSignalingViewModel = viewModel()) {
+  val state by viewModel.state.collectAsStateWithLifecycle()
+
+  state.incoming?.let { call ->
+    Dialog(onDismissRequest = { viewModel.reject(call) }) {
+      Surface(
+        modifier = Modifier.fillMaxSize(),
+        color = Color.Black.copy(alpha = 0.85f),
+      ) {
+        Column(
+          modifier = Modifier.fillMaxSize(),
+          horizontalAlignment = Alignment.CenterHorizontally,
+          verticalArrangement = Arrangement.Center,
+        ) {
+          AsyncImage(
+            model = call.callInitiator?.avatar,
+            contentDescription = null,
+            modifier = Modifier.size(120.dp).clip(CircleShape),
+          )
+          Spacer(Modifier.height(16.dp))
+          Text(
+            call.callInitiator?.name ?: "Unknown",
+            style = MaterialTheme.typography.titleLarge,
+            color = Color.White,
+          )
+          Text("Incoming ${call.type} call", color = Color.White.copy(alpha = 0.7f))
+          Spacer(Modifier.height(32.dp))
+          Row(horizontalArrangement = Arrangement.spacedBy(32.dp)) {
+            FloatingActionButton(
+              onClick = { viewModel.reject(call) },
+              containerColor = Color.Red,
+              modifier = Modifier.semantics { contentDescription = "Decline call" },
+            ) { Icon(Icons.Default.CallEnd, contentDescription = null, tint = Color.White) }
+            FloatingActionButton(
+              onClick = { viewModel.accept(call) },
+              containerColor = Color.Green,
+              modifier = Modifier.semantics { contentDescription = "Accept call" },
+            ) { Icon(Icons.Default.Call, contentDescription = null, tint = Color.White) }
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+Mount above your nav graph in `MainActivity.setContent` so it surfaces over any screen.
+
+---
+
+## Backgrounded ring — ConnectionService + FCM (mandatory)
+
+The Compose overlay only fires when the app is foreground. For backgrounded/killed-app ring delivery, FCM data-message → ConnectionService → OS-level UI. See `cometchat-android-v6-calls/references/server-fcm-voip.md`.
+
+---
+
+## Anti-patterns
+
+V5 sister rules apply, plus V6-specific:
+
+1. **`collectAsState()` instead of `collectAsStateWithLifecycle()`.** State updates while paused.
+2. **Listener registered in a Composable.** Disposes on recomposition; use a ViewModel or Application-scoped class.
+3. **Forgetting `Handler(Looper.getMainLooper()).post`.** SDK fires off main thread; StateFlow updates from background are fine but Compose recompositions need main.
+
+---
+
+## Verification checklist
+
+- [ ] ViewModel implements `CometChat.CallListener` and registers in init
+- [ ] `onCleared` calls `removeCallListener`
+- [ ] All state updates dispatched to main thread
+- [ ] `Dialog`-based overlay mounts above nav graph in MainActivity
+- [ ] FCM + ConnectionService handles backgrounded ring (V5 sister)
+- [ ] Real-device smoke: foreground + backgrounded + killed-app ring
+
+---
+
+## Pointers
+
+- `cometchat-android-v5-calls/references/ringing-integration.md` — canonical Android (V5 Views patterns)
+- `cometchat-android-v6-calls/SKILL.md` — V6 architecture
+- `cometchat-android-v6-calls/references/server-fcm-voip.md` — Compose IncomingCallActivity for backgrounded ring
+- Canonical docs: https://www.cometchat.com/docs/calls/android/ringing

package/skills/cometchat-android-v6-calls/references/server-fcm-voip.md

@@ -0,0 +1,127 @@
+# Server-side FCM HTTP v1 for Android V6 VoIP push
+
+V5 has the canonical server template; V6 adds Compose-specific receiver patterns. The FCM payload + HTTP v1 API are unchanged from V5.
+
+**Canonical docs:** https://firebase.google.com/docs/cloud-messaging/migrate-v1
+**Read first:** `cometchat-android-v5-calls/references/server-fcm-voip.md` — full Node + Python templates, hard rules, webhook shape.
+
+---
+
+## V6 receiver-side delta
+
+V5 patterns work on V6 (Compose calls bundle into chatuikit-{compose,kotlin}-android, but the FCM data-message reception is in a regular Service so Compose doesn't change anything there). One V6 nicety: surface the incoming-call UI through a Compose Activity that's launched in the foreground.
+
+```kotlin
+class VoipMessagingService : FirebaseMessagingService() {
+  override fun onMessageReceived(message: RemoteMessage) {
+    val data = message.data
+    if (data["type"] != "incoming_call") return
+
+    // V6: launch IncomingCallActivity (a Compose Activity) directly when the
+    // app is in the foreground; otherwise route through ConnectionService
+    // for the OS-level UI.
+    val isAppInForeground = ProcessLifecycleOwner.get().lifecycle.currentState
+      .isAtLeast(Lifecycle.State.STARTED)
+
+    if (isAppInForeground) {
+      val intent = Intent(this, IncomingCallActivity::class.java).apply {
+        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+        putExtra("sessionId", data["sessionId"])
+        putExtra("callerName", data["callerName"])
+        putExtra("callType", data["callType"])
+      }
+      startActivity(intent)
+    } else {
+      // V5 ConnectionService path — see V5 sister doc
+      val telecom = getSystemService(Context.TELECOM_SERVICE) as TelecomManager
+      // ... addNewIncomingCall flow
+    }
+  }
+}
+```
+
+---
+
+## Compose IncomingCallActivity (V6 specific)
+
+```kotlin
+class IncomingCallActivity : ComponentActivity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    // Allow showing over lock screen
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
+      setShowWhenLocked(true)
+      setTurnScreenOn(true)
+      val keyguard = getSystemService(KEYGUARD_SERVICE) as KeyguardManager
+      keyguard.requestDismissKeyguard(this, null)
+    } else {
+      window.addFlags(
+        WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
+        WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
+        WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
+      )
+    }
+
+    val sessionId = intent.getStringExtra("sessionId") ?: return finish()
+    val callerName = intent.getStringExtra("callerName") ?: ""
+    val callType = intent.getStringExtra("callType") ?: "audio"
+
+    setContent {
+      AppTheme {
+        IncomingCallScreen(
+          callerName = callerName,
+          callType = callType,
+          onAccept = {
+            // Hand off to the kit's call surface
+            val callIntent = Intent(this, ActiveCallActivity::class.java).apply {
+              putExtra("sessionId", sessionId)
+            }
+            startActivity(callIntent)
+            finish()
+          },
+          onReject = {
+            // Notify CometChat backend
+            CometChat.rejectCall(sessionId, ...)
+            finish()
+          },
+        )
+      }
+    }
+  }
+}
+```
+
+Key V6 deltas vs V5:
+- `setShowWhenLocked(true)` instead of `FLAG_SHOW_WHEN_LOCKED` (V5 uses the deprecated flag)
+- `setContent { ... }` for Compose UI vs XML layout
+- Compose Activity transitions are smoother — no XML inflation lag
+
+---
+
+## Anti-patterns
+
+V5 sister rules apply, plus V6-specific:
+
+1. **Calling `setContent` before `setShowWhenLocked`.** UI flashes briefly before the keyguard layer applies.
+2. **Forgetting `requestDismissKeyguard`.** Lock screen still shows behind your call UI.
+3. **Mixing `IncomingCallActivity` (foreground path) and `ConnectionService` (background path).** Pick the right one based on app state — V6 still benefits from V5's ConnectionService path for true background.
+
+---
+
+## Verification checklist
+
+- [ ] V5 server template (Node/Python) — see V5 sister
+- [ ] FCM data message lands at `VoipMessagingService.onMessageReceived` regardless of app state
+- [ ] Foreground: `IncomingCallActivity` launches with show-when-locked
+- [ ] Background/killed: ConnectionService path surfaces OS-level UI
+- [ ] Real-device smoke: 3 cohorts (foreground, backgrounded, killed) all ring
+
+---
+
+## Pointers
+
+- `cometchat-android-v5-calls/references/server-fcm-voip.md` — V5 sister (canonical server template)
+- `cometchat-android-v6-calls/SKILL.md` — V6 architecture
+- `cometchat-android-v6-calls/references/incoming-call-overlay.md` — Compose overlay patterns
+- FCM HTTP v1: https://firebase.google.com/docs/cloud-messaging/migrate-v1