refactor: clean up push notifications code and fix redundant checks

Author: Linhead

public/firebase/firebase-messaging-sw.js

@@ -4,6 +4,12 @@ importScripts('https://www.gstatic.com/firebasejs/9.22.1/firebase-messaging-comp
 importScripts('https://cdnjs.cloudflare.com/ajax/libs/tweetnacl/1.0.3/nacl.min.js')
 importScripts('/js/ed2curve.min.js')
 
+const NOTIFICATION_TYPES = {
+  NO_NOTIFICATIONS: 0,
+  BACKGROUND_FETCH: 1,
+  PUSH: 2
+}
+
 // Checking double notifications
 const processedEvents = new Set()
 setInterval(() => processedEvents.clear(), 2 * 60 * 1000) // 2 minutes
@@ -107,31 +113,58 @@ channel.onmessage = (event) => {
   }
 }
 
-// Handling background messages
-messaging.onBackgroundMessage(async (payload) => {
-  if (!payload.data?.txn) return
+function parseTransactionPayload(payload) {
+  if (!payload.data?.txn) {
+    return null
+  }
 
-  let transaction, eventId
   try {
-    transaction = JSON.parse(payload.data.txn)
-    eventId = transaction.id
+    const transaction = JSON.parse(payload.data.txn)
+    return {
+      transaction,
+      eventId: transaction.id
+    }
   } catch (error) {
     console.warn('Invalid transaction JSON:', error)
-    return
+    return null
   }
+}
 
-  if (!eventId || processedEvents.has(eventId)) return
+function isEventProcessed(eventId) {
+  if (!eventId || processedEvents.has(eventId)) {
+    return true
+  }
   processedEvents.add(eventId)
+  return false
+}
+
+async function ensureSettingsInitialized() {
+  if (notificationSettings.initialized) {
+    return
+  }
+
+  await new Promise((resolve) => setTimeout(resolve, 2000))
 
-  // Wait for settings if needed
   if (!notificationSettings.initialized) {
-    await new Promise((resolve) => setTimeout(resolve, 2000))
-    if (!notificationSettings.initialized) {
-      notificationSettings.initialized = true
-    }
+    notificationSettings.initialized = true
   }
+}
+
+function isPushEnabled() {
+  return notificationSettings.type === NOTIFICATION_TYPES.PUSH
+}
+
+messaging.onBackgroundMessage(async (payload) => {
+  const parsed = parseTransactionPayload(payload)
+  if (!parsed) return
+
+  const { transaction, eventId } = parsed
+
+  if (isEventProcessed(eventId)) return
+
+  await ensureSettingsInitialized()
 
-  if (notificationSettings.type !== 2 || (await isAppVisible())) {
+  if (!isPushEnabled() || (await isAppVisible())) {
     return
   }
 

src/hooks/pushNotifications/useAndroidPushNotifications.ts

@@ -1,113 +1,45 @@
-import { ref, computed } from 'vue'
+import { computed } from 'vue'
 import { Capacitor } from '@capacitor/core'
 
-export interface AndroidNotificationSettings {
-  type: number
-  privateKey?: string
-}
-
-/**
- * Android-specific composable for managing push notifications
- * Handles only data passing to AndroidPushService
- */
 export function useAndroidPushNotifications() {
-  const privateKey = ref<string | null>(null)
-  const isSupported = Capacitor.getPlatform() === 'android'
-
-  const isActive = computed(() => privateKey.value !== null)
+  const isSupported = computed(() => Capacitor.getPlatform() === 'android')
 
   /**
-   * Gets reference to pushService
+   * Gets reference to pushService (always AndroidPushService on Android)
    */
   const getPushService = async () => {
-    try {
-      const { pushService } = await import('@/lib/notifications/pushServiceFactory')
-      return pushService
-    } catch (error) {
-      console.error('[Android Push] Failed to import pushService:', error)
-      return null
-    }
-  }
-
-  /**
-   * Stores private key and passes it to AndroidPushService
-   */
-  const sendPrivateKey = async (key: string): Promise<boolean> => {
-    if (!isSupported || !key) {
-      return false
-    }
+    if (!isSupported.value) return null
 
-    try {
-      // Store locally
-      privateKey.value = key
-
-      // Pass to push service
-      const pushService = await getPushService()
-      if (pushService) {
-        pushService.setPrivateKey(key)
-        return true
-      }
-
-      return false
-    } catch (error) {
-      console.error('[Android Push] Failed to send private key:', error)
-      return false
-    }
+    const { pushService } = await import('@/lib/notifications/pushServiceFactory')
+    return pushService
   }
 
   /**
-   * Clears private key
+   * Sets private key - proxy to pushService.setPrivateKey()
    */
-  const clearPrivateKey = async (): Promise<boolean> => {
-    if (!isSupported) {
-      return false
-    }
-
-    try {
-      // Clear locally
-      privateKey.value = null
+  const setPrivateKey = async (key: string): Promise<boolean> => {
+    if (!isSupported.value) return false
 
-      // Clear in push service
-      const pushService = await getPushService()
-      if (pushService) {
-        pushService.setPrivateKey('')
-        return true
-      }
-
-      return false
-    } catch (error) {
-      console.error('[Android Push] Failed to clear private key:', error)
-      return false
+    const service = await getPushService()
+    if (service) {
+      service.setPrivateKey(key)
+      return true
     }
+
+    return false
   }
 
   /**
-   * Syncs notification settings (mainly stores private key if provided)
+   * Clears private key - proxy to pushService.setPrivateKey('')
    */
-  const syncNotificationSettings = async (
-    settings: AndroidNotificationSettings
-  ): Promise<boolean> => {
-    if (!isSupported) {
-      return false
-    }
-
-    try {
-      // If private key provided - store it
-      if (settings.privateKey) {
-        await sendPrivateKey(settings.privateKey)
-      }
-
-      return true
-    } catch (error) {
-      console.error('[Android Push] Failed to sync settings:', error)
-      return false
-    }
+  const clearPrivateKey = async (): Promise<boolean> => {
+    return setPrivateKey('')
   }
 
   return {
-    isActive,
-    sendPrivateKey,
+    isSupported,
+    setPrivateKey,
     clearPrivateKey,
-    syncNotificationSettings
+    getPushService
   }
 }

src/hooks/pushNotifications/usePrivateKeyManager.ts

@@ -0,0 +1,77 @@
+import { useStore } from 'vuex'
+import { Capacitor } from '@capacitor/core'
+import { useWebPushNotifications } from './useWebPushNotifications'
+import { useAndroidPushNotifications } from './useAndroidPushNotifications'
+
+/**
+ * Composable for managing private key across platforms
+ * Handles sending/clearing private keys to both Service Worker and Push Services
+ */
+export function usePrivateKeyManager() {
+  const store = useStore()
+  const platform = Capacitor.getPlatform()
+
+  // Platform-specific composables
+  const webPush = platform === 'web' ? useWebPushNotifications() : null
+  const androidPush = platform === 'android' ? useAndroidPushNotifications() : null
+
+  /**
+   * Gets private key from store
+   */
+  const getPrivateKey = async (): Promise<string | null> => {
+    try {
+      return await store.dispatch('getPrivateKeyForPush')
+    } catch (error) {
+      console.error('Error getting private key:', error)
+      return null
+    }
+  }
+
+  /**
+   * Sends private key to appropriate platform handlers
+   */
+  const sendPrivateKey = async (): Promise<boolean> => {
+    const privateKey = await getPrivateKey()
+    if (!privateKey) return false
+
+    if (webPush) {
+      return webPush.setPrivateKey(privateKey)
+    }
+    if (androidPush) {
+      return await androidPush.setPrivateKey(privateKey)
+    }
+
+    return false
+  }
+
+  /**
+   * Clears private key from appropriate platform handlers
+   */
+  const clearPrivateKey = async (): Promise<boolean> => {
+    if (webPush) {
+      return webPush.clearPrivateKey()
+    }
+    if (androidPush) {
+      return await androidPush.clearPrivateKey()
+    }
+
+    return false
+  }
+
+  /**
+   * Syncs notification settings (web only)
+   */
+  const syncNotificationSettings = (type: number) => {
+    if (webPush) {
+      webPush.syncNotificationSettings({ type })
+    }
+    // Android settings are managed through pushService directly
+  }
+
+  return {
+    getPrivateKey,
+    sendPrivateKey,
+    clearPrivateKey,
+    syncNotificationSettings
+  }
+}

src/hooks/pushNotifications/usePushEventHandlers.ts

@@ -0,0 +1,70 @@
+import { onMounted, onBeforeUnmount } from 'vue'
+import { useRouter } from 'vue-router'
+
+/**
+ * Composable for handling push notification events and navigation
+ */
+export function usePushEventHandlers() {
+  const router = useRouter()
+
+  /**
+   * Handles opening chat from notification click
+   */
+  const handleOpenChat = (event: Event) => {
+    const detail = (event as CustomEvent).detail
+    if (detail?.partnerId) {
+      router.push({
+        name: 'Chat',
+        params: { partnerId: detail.partnerId }
+      })
+    }
+  }
+
+  /**
+   * Handles messages from Service Worker
+   */
+  const handleServiceWorkerMessage = (event: MessageEvent) => {
+    if (!event.data) return
+
+    const { action, partnerId } = event.data
+
+    if (action === 'OPEN_CHAT' && partnerId) {
+      const currentRoute = router.currentRoute.value
+
+      if (currentRoute.name !== 'Chat' || currentRoute.params.partnerId !== partnerId) {
+        router.push({
+          name: 'Chat',
+          params: { partnerId }
+        })
+      }
+
+      window.focus()
+    }
+  }
+
+  /**
+   * Sets up event listeners
+   */
+  const setupEventListeners = () => {
+    window.addEventListener('openChat', handleOpenChat)
+    navigator.serviceWorker?.addEventListener('message', handleServiceWorkerMessage)
+  }
+
+  /**
+   * Removes event listeners
+   */
+  const removeEventListeners = () => {
+    window.removeEventListener('openChat', handleOpenChat)
+    navigator.serviceWorker?.removeEventListener('message', handleServiceWorkerMessage)
+  }
+
+  onMounted(setupEventListeners)
+  onBeforeUnmount(removeEventListeners)
+
+  return {
+    handleOpenChat,
+    handleServiceWorkerMessage,
+    setupEventListeners,
+    removeEventListeners
+  }
+}