fix: verify window is hidden before call

Author: edospadoni

src/main/classes/controllers/PhoneIslandController.ts

@@ -30,9 +30,13 @@ export class PhoneIslandController {
         //make sure the size is equal to [0,0] when you want to close the phone island, otherwise the size will not close and will generate slowness problems.
         if (h === 0 && w === 0) {
           window.hide()
+        } else if (this.isWarmingUp) {
+          // During warm-up: force hide even if size changes
+          Log.info(`[RESIZE] FORCING HIDE during warm-up (size: ${w}x${h}, visible: ${window.isVisible()})`)
+          window.hide()
         } else {
-          // Don't show window during warm-up
-          if (!window.isVisible() && !this.isWarmingUp) {
+          // Normal flow: show if not visible (no logging)
+          if (!window.isVisible()) {
             window.show()
             window.setAlwaysOnTop(true)
           }
@@ -49,6 +53,12 @@ export class PhoneIslandController {
       const window = this.window.getWindow()
       if (window) {
 
+        // Block showPhoneIsland during warm-up
+        if (this.isWarmingUp) {
+          Log.info(`[SHOW_PHONE_ISLAND] BLOCKED during warm-up (size: ${size.w}x${size.h})`)
+          return
+        }
+
         this.resize(size)
         if (process.platform !== 'linux') {
           const phoneIslandPosition = AccountController.instance.getAccountPhoneIslandPosition()
@@ -178,9 +188,10 @@ export class PhoneIslandController {
     try {
       const window = this.window.getWindow()
       if (window) {
+        const wasVisible = window.isVisible()
         this.isWarmingUp = true
         window.hide()
-        Log.info('PhoneIsland window hidden')
+        Log.info(`[FORCE_HIDE] PhoneIsland window hidden (was visible: ${wasVisible}, isWarmingUp now: ${this.isWarmingUp})`)
       }
     } catch (e) {
       Log.warning('error during force hiding PhoneIsland:', e)
@@ -194,10 +205,13 @@ export class PhoneIslandController {
         this.isWarmingUp = false
         // Only show if there's actually content (size > 0)
         const bounds = window.getBounds()
+        Log.info(`[FORCE_SHOW] Attempting to show (isWarmingUp now: ${this.isWarmingUp}, bounds: ${bounds.width}x${bounds.height})`)
         if (bounds.width > 0 && bounds.height > 0) {
           window.show()
           window.setAlwaysOnTop(true)
-          Log.info('PhoneIsland window shown')
+          Log.info('[FORCE_SHOW] PhoneIsland window shown')
+        } else {
+          Log.info('[FORCE_SHOW] Not showing - no content (size is 0)')
         }
       }
     } catch (e) {

src/main/lib/ipcEvents.ts

@@ -280,40 +280,79 @@ export function registerIpcEvents() {
 
   // Handler for warm-up audio devices request from renderer
   ipcMain.on(IPC_EVENTS.WARMUP_AUDIO_DEVICES, async () => {
-    // Check if warm-up has already been executed
-    if (hasRunAudioWarmup) {
-      Log.info('[WARMUP] Audio warm-up already executed, skipping...')
-      return
-    }
+    try {
+      Log.info('[WARMUP] Warm-up request received (hasRunAudioWarmup:', hasRunAudioWarmup, ')')
+
+      // Check if warm-up has already been executed
+      if (hasRunAudioWarmup) {
+        Log.info('[WARMUP] Audio warm-up already executed, skipping...')
+        return
+      }
 
-    // Mark as executed
-    hasRunAudioWarmup = true
+      // Mark as executed
+      hasRunAudioWarmup = true
 
-    try {
       Log.info('[WARMUP] Starting silent echo test to warm up audio devices...')
 
+      if (!PhoneIslandController.instance) {
+        Log.error('[WARMUP] PhoneIslandController.instance not found, aborting warm-up')
+        return
+      }
+
+      const window = PhoneIslandController.instance.window.getWindow()
+      if (!window) {
+        Log.error('[WARMUP] Window not found, aborting warm-up')
+        return
+      }
+
+      Log.info('[WARMUP] Window state BEFORE hide:', {
+        exists: !!window,
+        isVisible: window.isVisible(),
+        isMuted: window.webContents?.audioMuted
+      })
+
       // Hide the PhoneIsland window to prevent it from showing during warm-up
       PhoneIslandController.instance.forceHide()
 
       // Mute the PhoneIsland window audio
       PhoneIslandController.instance.muteAudio()
 
-      // Wait a bit to ensure mute and hide are applied
-      await new Promise(resolve => setTimeout(resolve, 550))
+      // Wait and verify that hide and mute are actually applied
+      // Use polling to ensure they're effective even on slow/loaded systems
+      let attempts = 0
+      const maxAttempts = 20 // Max 2 seconds (20 * 100ms)
+
+      while (attempts < maxAttempts) {
+        await new Promise(resolve => setTimeout(resolve, 100))
+
+        const isHidden = !window.isVisible()
+        const isMuted = window.webContents?.audioMuted
+
+        if (isHidden && isMuted) {
+          Log.info(`[WARMUP] Window hidden and audio muted verified after ${attempts * 100}ms`)
+          break
+        }
+
+        if (attempts === maxAttempts - 1) {
+          Log.warning(`[WARMUP] Could not verify hide/mute after ${maxAttempts * 100}ms (hidden: ${isHidden}, muted: ${isMuted})`)
+        }
+
+        attempts++
+      }
 
       // Start echo test call to *43
       Log.info('[WARMUP] Starting call to *43')
       PhoneIslandController.instance.call('*43')
 
-      // Keep the call active for 5 seconds to warm up devices
+      // Keep the call active for 1.5 seconds to warm up devices
       await new Promise(resolve => setTimeout(resolve, 1500))
 
       // End the call
       Log.info('[WARMUP] Ending echo test call')
       PhoneIslandController.instance.window.emit(IPC_EVENTS.END_CALL)
 
       // Wait a bit before unmuting and showing
-      await new Promise(resolve => setTimeout(resolve, 550))
+      await new Promise(resolve => setTimeout(resolve, 500))
 
       // Unmute the PhoneIsland window audio
       PhoneIslandController.instance.unmuteAudio()
@@ -325,8 +364,12 @@ export function registerIpcEvents() {
     } catch (error) {
       Log.error('[WARMUP] Error during audio warm-up:', error)
       // Make sure to unmute and show even if there's an error
-      PhoneIslandController.instance.unmuteAudio()
-      PhoneIslandController.instance.forceShow()
+      try {
+        PhoneIslandController.instance?.unmuteAudio()
+        PhoneIslandController.instance?.forceShow()
+      } catch (cleanupError) {
+        Log.error('[WARMUP] Error during cleanup:', cleanupError)
+      }
     }
   })
 

src/renderer/src/pages/PhoneIslandPage.tsx

@@ -78,6 +78,13 @@ export function PhoneIslandPage() {
     window.electron.receive(IPC_EVENTS.CHANGE_PREFERRED_DEVICES, (devices: PreferredDevices) => {
       Log.info('Received CHANGE_PREFERRED_DEVICES in PhoneIslandPage:', devices)
 
+      // Debug: log the check conditions
+      Log.info('Warm-up check:', {
+        hasRunWarmup: hasRunWarmup.current,
+        platform: window.api?.platform,
+        shouldRun: !hasRunWarmup.current && (window.api?.platform === 'win32' || window.api?.platform === 'darwin')
+      })
+
       // Run audio warm-up first, only once after PhoneIsland is fully initialized
       // Only on Windows/macOS where the issue occurs
       if (!hasRunWarmup.current && (window.api?.platform === 'win32' || window.api?.platform === 'darwin')) {