public void init() {
    Log.d(TAG, "init");
    if (initialized) {
      return;
    }

    // Store current audio state so we can restore it when close() is called.
    savedAudioMode = audioManager.getMode();
    savedIsSpeakerPhoneOn = audioManager.isSpeakerphoneOn();
    savedIsMicrophoneMute = audioManager.isMicrophoneMute();

    // Request audio focus before making any device switch.
    audioManager.requestAudioFocus(
        null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);

    // Start by setting MODE_IN_COMMUNICATION as default audio mode. It is
    // required to be in this mode when playout and/or recording starts for
    // best possible VoIP performance.
    // TODO(henrika): we migh want to start with RINGTONE mode here instead.
    audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);

    // Always disable microphone mute during a WebRTC call.
    setMicrophoneMute(false);

    // Do initial selection of audio device. This setting can later be changed
    // either by adding/removing a wired headset or by covering/uncovering the
    // proximity sensor.
    updateAudioDeviceState(hasWiredHeadset());

    // Register receiver for broadcast intents related to adding/removing a
    // wired headset (Intent.ACTION_HEADSET_PLUG).
    registerForWiredHeadsetIntentBroadcast();

    initialized = true;
  }
Example #2
0
  public void init() {
    Log.d(TAG, "init");
    if (initialized) {
      return;
    }

    // Store current audio state so we can restore it when close() is called.
    savedAudioMode = audioManager.getMode();
    savedIsSpeakerPhoneOn = audioManager.isSpeakerphoneOn();
    savedIsMicrophoneMute = audioManager.isMicrophoneMute();

    // Request audio focus before making any device switch.
    audioManager.requestAudioFocus(
        null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);

    // Start by setting RINGTONE as default audio mode. The native WebRTC
    // audio layer will switch to COMMUNICATION mode when the first streaming
    // session starts and return to RINGTONE mode when all streaming stops.
    audioManager.setMode(AudioManager.MODE_RINGTONE);

    // Always disable microphone mute during a WebRTC call.
    setMicrophoneMute(false);

    // Do initial selection of audio device. This setting can later be changed
    // either by adding/removing a wired headset or by covering/uncovering the
    // proximity sensor.
    updateAudioDeviceState(hasWiredHeadset());

    // Register receiver for broadcast intents related to adding/removing a
    // wired headset (Intent.ACTION_HEADSET_PLUG).
    registerForWiredHeadsetIntentBroadcast();

    initialized = true;
  }
Example #3
0
  /** Save current audio mode in order to be able to restore it once done */
  @SuppressWarnings("deprecation")
  private synchronized void saveAudioState() {
    if (prefs.getBoolean("isSavedAudioState", false)) {
      // If we have already set, do not set it again !!!
      return;
    }
    ContentResolver ctntResolver = service.getContentResolver();

    Editor ed = prefs.edit();
    // ed.putInt("savedVibrateRing",
    // audioManager.getVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER));
    // ed.putInt("savedVibradeNotif",
    // audioManager.getVibrateSetting(AudioManager.VIBRATE_TYPE_NOTIFICATION));
    // ed.putInt("savedRingerMode", audioManager.getRingerMode());
    ed.putInt(
        "savedWifiPolicy",
        android.provider.Settings.System.getInt(
            ctntResolver,
            android.provider.Settings.System.WIFI_SLEEP_POLICY,
            Settings.System.WIFI_SLEEP_POLICY_DEFAULT));

    int inCallStream = Compatibility.getInCallStream(userWantBluetooth);
    ed.putInt("savedVolume", audioManager.getStreamVolume(inCallStream));

    int targetMode = getAudioTargetMode();
    if (service.getPrefs().useRoutingApi()) {
      ed.putInt("savedRoute", audioManager.getRouting(targetMode));
    } else {
      ed.putBoolean("savedSpeakerPhone", audioManager.isSpeakerphoneOn());
    }
    ed.putInt("savedMode", audioManager.getMode());

    ed.putBoolean("isSavedAudioState", true);
    ed.commit();
  }
 public ec(Context context) {
   boolean z = true;
   AudioManager audioManager = (AudioManager) context.getSystemService("audio");
   ConnectivityManager connectivityManager =
       (ConnectivityManager) context.getSystemService("connectivity");
   DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics();
   Locale locale = Locale.getDefault();
   PackageManager packageManager = context.getPackageManager();
   TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService("phone");
   Intent registerReceiver =
       context.registerReceiver(null, new IntentFilter("android.intent.action.BATTERY_CHANGED"));
   this.rb = audioManager.getMode();
   this.rc = m947a(packageManager, "geo:0,0?q=donuts") != null;
   this.rd = m947a(packageManager, "http://www.google.com") != null;
   this.re = telephonyManager.getNetworkOperator();
   this.rf = locale.getCountry();
   this.rg = et.bV();
   this.rh = audioManager.isMusicActive();
   this.ri = audioManager.isSpeakerphoneOn();
   this.rj = locale.getLanguage();
   this.rk = m948a(packageManager);
   this.rl = audioManager.getStreamVolume(3);
   this.rm = m946a(context, connectivityManager, packageManager);
   this.rn = telephonyManager.getNetworkType();
   this.ro = telephonyManager.getPhoneType();
   this.rp = audioManager.getRingerMode();
   this.rq = audioManager.getStreamVolume(2);
   this.rr = displayMetrics.density;
   this.rs = displayMetrics.widthPixels;
   this.rt = displayMetrics.heightPixels;
   if (registerReceiver != null) {
     int intExtra = registerReceiver.getIntExtra(NotificationCompatApi21.CATEGORY_STATUS, -1);
     this.ru =
         (double)
             (((float) registerReceiver.getIntExtra("level", -1))
                 / ((float) registerReceiver.getIntExtra("scale", -1)));
     if (!(intExtra == 2 || intExtra == 5)) {
       z = false;
     }
     this.rv = z;
   } else {
     this.ru = -1.0d;
     this.rv = false;
   }
   if (VERSION.SDK_INT >= 16) {
     this.rw = connectivityManager.isActiveNetworkMetered();
     if (connectivityManager.getActiveNetworkInfo() != null) {
       this.rx = connectivityManager.getActiveNetworkInfo().getDetailedState().ordinal();
       return;
     } else {
       this.rx = -1;
       return;
     }
   }
   this.rw = false;
   this.rx = -1;
 }
 @TestTargets({
   @TestTargetNew(
       level = TestLevel.COMPLETE,
       method = "setMode",
       args = {int.class}),
   @TestTargetNew(
       level = TestLevel.COMPLETE,
       method = "getMode",
       args = {})
 })
 public void testAccessMode() throws Exception {
   mAudioManager.setMode(MODE_RINGTONE);
   assertEquals(MODE_RINGTONE, mAudioManager.getMode());
   mAudioManager.setMode(MODE_IN_CALL);
   assertEquals(MODE_IN_CALL, mAudioManager.getMode());
   mAudioManager.setMode(MODE_NORMAL);
   assertEquals(MODE_NORMAL, mAudioManager.getMode());
 }
 public static a g(Context context) {
   if (f == null) {
     f = (AudioManager) context.getSystemService("audio");
   }
   a aVar = a.f;
   int mode = f.getMode();
   if (c()) {
     return a.e;
   }
   if (f.isMusicActive() || f.isSpeakerphoneOn() || mode == 2 || mode == 1) {
     return a.d;
   }
   mode = f.getRingerMode();
   return (mode == 0 || mode == 1) ? a.d : a.b;
 }
 private void setAudioFocus(boolean focus) {
   if (focus) {
     previousAudioMode = audioManager.getMode();
     // Request audio focus before making any device switch.
     audioManager.requestAudioFocus(
         null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
     /*
      * Use MODE_IN_COMMUNICATION as the default audio mode. It is required
      * to be in this mode when playout and/or recording starts for the best
      * possible VoIP performance. Some devices have difficulties with
      * speaker mode if this is not set.
      */
     audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
   } else {
     audioManager.setMode(previousAudioMode);
     audioManager.abandonAudioFocus(null);
   }
 }
  private void toggleAudioMute() {
    if (mAudioManager == null) {
      mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
    }
    // We only act in normal mode (rings, calls, ... are handled by aosp)
    if (mAudioManager.getMode() == AudioManager.MODE_NORMAL) {
      // TODO: If an alarm is sound then don't toggle the volume mute. In this case,
      // is better to ignore the key event and let the alarm app to handle it.

      // Just toggle between normal and silent (by now we are not going to handle
      // vibration here)
      int newValue =
          mAudioManager.getRingerMode() != AudioManager.RINGER_MODE_NORMAL
              ? AudioManager.RINGER_MODE_NORMAL
              : AudioManager.RINGER_MODE_SILENT;
      mAudioManager.setRingerMode(newValue);

      int status =
          newValue == AudioManager.RINGER_MODE_NORMAL ? ASUSDEC_STATUS_OFF : ASUSDEC_STATUS_ON;
      notifyKey(ASUSDEC_VOLUME_MUTE, status);
    }
  }
 public static int getMode() {
   AudioManager am = (AudioManager) Receiver.mContext.getSystemService(Context.AUDIO_SERVICE);
   if (Integer.parseInt(Build.VERSION.SDK) >= 5)
     return am.isSpeakerphoneOn() ? AudioManager.MODE_NORMAL : AudioManager.MODE_IN_CALL;
   else return am.getMode();
 }
Example #10
0
 public ec(Context context)
 {
     boolean flag1 = true;
     super();
     AudioManager audiomanager = (AudioManager)context.getSystemService("audio");
     ConnectivityManager connectivitymanager = (ConnectivityManager)context.getSystemService("connectivity");
     DisplayMetrics displaymetrics = context.getResources().getDisplayMetrics();
     Locale locale = Locale.getDefault();
     PackageManager packagemanager = context.getPackageManager();
     TelephonyManager telephonymanager = (TelephonyManager)context.getSystemService("phone");
     Intent intent = context.registerReceiver(null, new IntentFilter("android.intent.action.BATTERY_CHANGED"));
     rb = audiomanager.getMode();
     boolean flag;
     if (a(packagemanager, "geo:0,0?q=donuts") != null)
     {
         flag = true;
     } else
     {
         flag = false;
     }
     rc = flag;
     if (a(packagemanager, "http://www.google.com") != null)
     {
         flag = true;
     } else
     {
         flag = false;
     }
     rd = flag;
     re = telephonymanager.getNetworkOperator();
     rf = locale.getCountry();
     rh = audiomanager.isMusicActive();
     ri = audiomanager.isSpeakerphoneOn();
     rj = locale.getLanguage();
     rk = a(packagemanager);
     rl = audiomanager.getStreamVolume(3);
     rm = a(context, connectivitymanager, packagemanager);
     rn = telephonymanager.getNetworkType();
     ro = telephonymanager.getPhoneType();
     rp = audiomanager.getRingerMode();
     rq = audiomanager.getStreamVolume(2);
     rr = displaymetrics.density;
     rs = displaymetrics.widthPixels;
     rt = displaymetrics.heightPixels;
     if (intent != null)
     {
         int i = intent.getIntExtra("status", -1);
         int j = intent.getIntExtra("level", -1);
         int k = intent.getIntExtra("scale", -1);
         ru = (float)j / (float)k;
         flag = flag1;
         if (i != 2)
         {
             if (i == 5)
             {
                 flag = flag1;
             } else
             {
                 flag = false;
             }
         }
         rv = flag;
     } else
     {
         ru = -1D;
         rv = false;
     }
     if (android.os.Build.VERSION.SDK_INT >= 16)
     {
         rw = connectivitymanager.isActiveNetworkMetered();
         if (connectivitymanager.getActiveNetworkInfo() != null)
         {
             rx = connectivitymanager.getActiveNetworkInfo().getDetailedState().ordinal();
             return;
         } else
         {
             rx = -1;
             return;
         }
     } else
     {
         rw = false;
         rx = -1;
         return;
     }
 }
Example #11
0
  /** Set the audio mode as in call */
  @SuppressWarnings("deprecation")
  private synchronized void actualSetAudioInCall() {
    // Ensure not already set
    if (isSetAudioMode) {
      return;
    }
    stopRing();
    saveAudioState();

    // Set the rest of the phone in a better state to not interferate with
    // current call
    // Do that only if we were not already in silent mode
    /*
     * Not needed anymore with on flight gsm call capture
     * if(audioManager.getRingerMode() != AudioManager.RINGER_MODE_SILENT) {
     * audioManager.setVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER,
     * AudioManager.VIBRATE_SETTING_ON);
     * audioManager.setVibrateSetting(AudioManager
     * .VIBRATE_TYPE_NOTIFICATION, AudioManager.VIBRATE_SETTING_OFF);
     * audioManager.setRingerMode(AudioManager.RINGER_MODE_VIBRATE); }
     */

    // LOCKS

    // Wifi management if necessary
    ContentResolver ctntResolver = service.getContentResolver();
    Settings.System.putInt(
        ctntResolver, Settings.System.WIFI_SLEEP_POLICY, Settings.System.WIFI_SLEEP_POLICY_NEVER);

    // Acquire wifi lock
    WifiManager wman = (WifiManager) service.getSystemService(Context.WIFI_SERVICE);
    if (wifiLock == null) {
      wifiLock =
          wman.createWifiLock(
              (Compatibility.isCompatible(9))
                  ? WifiManager.WIFI_MODE_FULL_HIGH_PERF
                  : WifiManager.WIFI_MODE_FULL,
              "com.csipsimple.InCallLock");
      wifiLock.setReferenceCounted(false);
    }
    WifiInfo winfo = wman.getConnectionInfo();
    if (winfo != null) {
      DetailedState dstate = WifiInfo.getDetailedStateOf(winfo.getSupplicantState());
      // We assume that if obtaining ip addr, we are almost connected so
      // can keep wifi lock
      if (dstate == DetailedState.OBTAINING_IPADDR || dstate == DetailedState.CONNECTED) {
        if (!wifiLock.isHeld()) {
          wifiLock.acquire();
        }
      }

      // This wake lock purpose is to prevent PSP wifi mode
      if (service.getPrefs().getPreferenceBooleanValue(SipConfigManager.KEEP_AWAKE_IN_CALL)) {
        if (screenLock == null) {
          PowerManager pm = (PowerManager) service.getSystemService(Context.POWER_SERVICE);
          screenLock =
              pm.newWakeLock(
                  PowerManager.SCREEN_DIM_WAKE_LOCK | PowerManager.ON_AFTER_RELEASE,
                  "com.csipsimple.onIncomingCall.SCREEN");
          screenLock.setReferenceCounted(false);
        }
        // Ensure single lock
        if (!screenLock.isHeld()) {
          screenLock.acquire();
        }
      }
    }

    if (!useWebRTCImpl) {
      // Audio routing
      int targetMode = getAudioTargetMode();
      Log.d(THIS_FILE, "Set mode audio in call to " + targetMode);

      if (service.getPrefs().generateForSetCall()) {
        boolean needOutOfSilent = (audioManager.getRingerMode() == AudioManager.RINGER_MODE_SILENT);
        if (needOutOfSilent) {
          audioManager.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
        }
        ToneGenerator toneGenerator = new ToneGenerator(AudioManager.STREAM_VOICE_CALL, 1);
        toneGenerator.startTone(41 /* ToneGenerator.TONE_CDMA_CONFIRM */);
        toneGenerator.stopTone();
        toneGenerator.release();
        // Restore silent mode
        if (needOutOfSilent) {
          audioManager.setRingerMode(AudioManager.RINGER_MODE_SILENT);
        }
      }

      // Set mode
      if (targetMode != AudioManager.MODE_IN_CALL && useSgsWrkAround) {
        // For galaxy S we need to set in call mode before to reset
        // stack
        audioManager.setMode(AudioManager.MODE_IN_CALL);
      }

      audioManager.setMode(targetMode);

      // Routing
      if (service.getPrefs().useRoutingApi()) {
        audioManager.setRouting(
            targetMode,
            userWantSpeaker ? AudioManager.ROUTE_SPEAKER : AudioManager.ROUTE_EARPIECE,
            AudioManager.ROUTE_ALL);
      } else {
        audioManager.setSpeakerphoneOn(userWantSpeaker ? true : false);
      }

      audioManager.setMicrophoneMute(false);
      if (bluetoothWrapper != null && userWantBluetooth && bluetoothWrapper.canBluetooth()) {
        Log.d(THIS_FILE, "Try to enable bluetooth");
        bluetoothWrapper.setBluetoothOn(true);
      }

    } else {
      // WebRTC implementation for routing
      int apiLevel = Compatibility.getApiLevel();

      // SetAudioMode
      // ***IMPORTANT*** When the API level for honeycomb (H) has been
      // decided,
      // the condition should be changed to include API level 8 to H-1.
      if (android.os.Build.BRAND.equalsIgnoreCase("Samsung") && (8 == apiLevel)) {
        // Set Samsung specific VoIP mode for 2.2 devices
        int mode = 4;
        audioManager.setMode(mode);
        if (audioManager.getMode() != mode) {
          Log.e(THIS_FILE, "Could not set audio mode for Samsung device");
        }
      }

      // SetPlayoutSpeaker
      if ((3 == apiLevel) || (4 == apiLevel)) {
        // 1.5 and 1.6 devices
        if (userWantSpeaker) {
          // route audio to back speaker
          audioManager.setMode(AudioManager.MODE_NORMAL);
        } else {
          // route audio to earpiece
          audioManager.setMode(AudioManager.MODE_IN_CALL);
        }
      } else {
        // 2.x devices
        if ((android.os.Build.BRAND.equalsIgnoreCase("samsung"))
            && ((5 == apiLevel) || (6 == apiLevel) || (7 == apiLevel))) {
          // Samsung 2.0, 2.0.1 and 2.1 devices
          if (userWantSpeaker) {
            // route audio to back speaker
            audioManager.setMode(AudioManager.MODE_IN_CALL);
            audioManager.setSpeakerphoneOn(userWantSpeaker);
          } else {
            // route audio to earpiece
            audioManager.setSpeakerphoneOn(userWantSpeaker);
            audioManager.setMode(AudioManager.MODE_NORMAL);
          }
        } else {
          // Non-Samsung and Samsung 2.2 and up devices
          audioManager.setSpeakerphoneOn(userWantSpeaker);
        }
      }
    }

    // Set stream solo/volume/focus

    int inCallStream = Compatibility.getInCallStream(userWantBluetooth);
    if (doFocusAudio) {
      if (!accessibilityManager.isEnabled()) {
        audioManager.setStreamSolo(inCallStream, true);
      }
      audioFocusWrapper.focus(userWantBluetooth);
    }
    Log.d(THIS_FILE, "Initial volume level : " + service.getPrefs().getInitialVolumeLevel());
    setStreamVolume(
        inCallStream,
        (int)
            (audioManager.getStreamMaxVolume(inCallStream)
                * service.getPrefs().getInitialVolumeLevel()),
        0);

    isSetAudioMode = true;
    // System.gc();
  }
Example #12
0
  /**
   * Shows an Astrid notification. Pulls in ring tone and quiet hour settings from preferences. You
   * can make it say anything you like.
   *
   * @param ringTimes number of times to ring (-1 = nonstop)
   */
  public static void showNotification(
      int notificationId, Intent intent, int type, String title, String text, int ringTimes) {
    Context context = ContextManager.getContext();
    if (notificationManager == null) notificationManager = new AndroidNotificationManager(context);

    // quiet hours? unless alarm clock
    boolean quietHours = false;
    int quietHoursStart = Preferences.getIntegerFromString(R.string.p_rmd_quietStart, -1);
    int quietHoursEnd = Preferences.getIntegerFromString(R.string.p_rmd_quietEnd, -1);
    if (quietHoursStart != -1 && quietHoursEnd != -1 && ringTimes >= 0) {
      int hour = new Date().getHours();
      if (quietHoursStart <= quietHoursEnd) {
        if (hour >= quietHoursStart && hour < quietHoursEnd) quietHours = true;
      } else { // wrap across 24/hour boundary
        if (hour >= quietHoursStart || hour < quietHoursEnd) quietHours = true;
      }
    }

    PendingIntent pendingIntent =
        PendingIntent.getActivity(
            context, notificationId, intent, PendingIntent.FLAG_UPDATE_CURRENT);

    // set up properties (name and icon) for the notification
    int icon;
    switch (Preferences.getIntegerFromString(R.string.p_rmd_icon, ICON_SET_ASTRID)) {
      case ICON_SET_PINK:
        icon = R.drawable.notif_pink_alarm;
        break;
      case ICON_SET_BORING:
        icon = R.drawable.notif_boring_alarm;
        break;
      default:
        icon = R.drawable.notif_astrid;
    }

    // create notification object
    Notification notification = new Notification(icon, text, System.currentTimeMillis());
    notification.setLatestEventInfo(context, title, text, pendingIntent);
    notification.flags |= Notification.FLAG_AUTO_CANCEL;
    if (Preferences.getBoolean(R.string.p_rmd_persistent, true)) {
      notification.flags |= Notification.FLAG_NO_CLEAR | Notification.FLAG_SHOW_LIGHTS;
      notification.ledOffMS = 5000;
      notification.ledOnMS = 700;
      notification.ledARGB = Color.YELLOW;
    } else notification.defaults = Notification.DEFAULT_LIGHTS;

    AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);

    // detect call state
    TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
    int callState = tm.getCallState();

    boolean voiceReminder = Preferences.getBoolean(R.string.p_voiceRemindersEnabled, false);

    // if multi-ring is activated, set up the flags for insistent
    // notification, and increase the volume to full volume, so the user
    // will actually pay attention to the alarm
    if (ringTimes != 1 && (type != ReminderService.TYPE_RANDOM)) {
      notification.audioStreamType = AudioManager.STREAM_ALARM;
      audioManager.setStreamVolume(
          AudioManager.STREAM_ALARM, audioManager.getStreamMaxVolume(AudioManager.STREAM_ALARM), 0);

      // insistent rings until notification is disabled
      if (ringTimes < 0) {
        notification.flags |= Notification.FLAG_INSISTENT;
        voiceReminder = false;
      }

    } else {
      notification.audioStreamType = AudioManager.STREAM_NOTIFICATION;
    }

    // quiet hours = no sound
    if (quietHours || callState != TelephonyManager.CALL_STATE_IDLE) {
      notification.sound = null;
      voiceReminder = false;
    } else {
      String notificationPreference = Preferences.getStringValue(R.string.p_rmd_ringtone);
      if (audioManager.getStreamVolume(AudioManager.STREAM_RING) == 0) {
        notification.sound = null;
        voiceReminder = false;
      } else if (notificationPreference != null) {
        if (notificationPreference.length() > 0) {
          Uri notificationSound = Uri.parse(notificationPreference);
          notification.sound = notificationSound;
        } else {
          notification.sound = null;
        }
      } else {
        notification.defaults |= Notification.DEFAULT_SOUND;
      }
    }

    // quiet hours && ! due date or snooze = no vibrate
    if (quietHours && !(type == ReminderService.TYPE_DUE || type == ReminderService.TYPE_SNOOZE)) {
      notification.vibrate = null;
    } else if (callState != TelephonyManager.CALL_STATE_IDLE) {
      notification.vibrate = null;
    } else {
      if (Preferences.getBoolean(R.string.p_rmd_vibrate, true)
          && audioManager.shouldVibrate(AudioManager.VIBRATE_TYPE_NOTIFICATION)) {
        notification.vibrate = new long[] {0, 1000, 500, 1000, 500, 1000};
      } else {
        notification.vibrate = null;
      }
    }

    if (Constants.DEBUG)
      Log.w("Astrid", "Logging notification: " + text); // $NON-NLS-1$ //$NON-NLS-2$

    for (int i = 0; i < Math.max(ringTimes, 1); i++) {
      notificationManager.notify(notificationId, notification);
      AndroidUtilities.sleepDeep(500);
    }

    if (voiceReminder) {
      AndroidUtilities.sleepDeep(2000);
      for (int i = 0; i < 50; i++) {
        AndroidUtilities.sleepDeep(500);
        if (audioManager.getMode() != AudioManager.MODE_RINGTONE) break;
      }
      try {
        VoiceOutputService.getVoiceOutputInstance().queueSpeak(text);
      } catch (VerifyError e) {
        // unavailable
      }
    }
  }