コード例 #1
0
ファイル: DelonKun.java プロジェクト: reikoyam01/Delonkun
  public void pushTone(int i, int mode, boolean disp) {
    int t = 150;
    final TextView txtStatus = (TextView) findViewById(R.id.txtStatus);

    t += mode * 150;
    if (i == ToneGenerator.TONE_DTMF_3) t += 500;

    // Toast.makeText(this, String.valueOf(i), Toast.LENGTH_LONG).show();
    if (disp) {
      txtStatus.setText(String.format("mode %d dir %d time %d", mode, i, t));
    }
    /* 動作コマンド鳴動~停止 */
    toneGenerator.startTone(i);
    try {
      Thread.sleep(150);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    toneGenerator.stopTone();
    /* 待つ */
    try {
      Thread.sleep(t);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    /* 停止コマンド鳴動~停止 */
    toneGenerator.startTone(ToneGenerator.TONE_DTMF_4);
    try {
      Thread.sleep(150);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    toneGenerator.stopTone();
  }
コード例 #2
0
 private void playAudioFeedback_apk1(int at_mode) {
   int i = 0;
   if (at_mode == 1) {
     at_mode = 0;
     while (at_mode < 4) {
       i = 0;
       while (i < 2) {
         musePlayTone(null, at_mode);
         i += 1;
       }
       at_mode += 1;
     }
   }
   Log.i("Muse Headband kt:", "Starting ToneGenerator");
   ToneGenerator localToneGenerator = new ToneGenerator(4, 100);
   at_mode = i;
   for (; ; ) {
     if (this.stopSounds != 0) {
       localToneGenerator.stopTone();
       localToneGenerator = null;
       Log.i("Muse Headband kt:", "Stopping ToneGenerator");
       try {
         Thread.sleep(1000L);
       } catch (Exception localException1) {
       }
     } else {
       if (this.horseshoeElemeTone != 4) {
         at_mode = this.horseshoeElemeTone;
       }
       do {
         i = at_mode;
         if (this.horseshoeElem[at_mode] >= 3) {
           break;
         }
         i = at_mode + 1;
         at_mode = i;
       } while (i != 4);
       if (i != 4) {
         musePlayTone(localToneGenerator, i);
       }
       try {
         Thread.sleep(1000L);
         at_mode = i;
       } catch (Exception localException2) {
         at_mode = i;
       }
     }
   }
 }
コード例 #3
0
 @Override
 public void onDestroy() {
   Log.w(TAG, "Destroyed Location update Service");
   toneGenerator.release();
   unregisterActionReceiver();
   cleanUp();
   stopForeground(true);
   super.onDestroy();
 }
コード例 #4
0
  // kt:
  private void f_not_used(ToneGenerator toneGen, int toneIdx) {
    if (validSensor[toneIdx] == false) {
      return;
    }

    ToneGenerator toneG = null;
    if (toneGen == null) toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 100);
    else toneG = toneGen;

    toneG.startTone(HorseshoeTones[toneIdx]);
    try {
      Thread.sleep(tone_on_duration / 8);
    } catch (Exception e) {
    }
    toneG.stopTone();
    try {
      Thread.sleep(tone_off_duration / 2);
    } catch (Exception e) {
    }
  }
 public static synchronized void ringback(boolean ringback) {
   if (ringback && ringbackPlayer == null) {
     AudioManager am = (AudioManager) Receiver.mContext.getSystemService(Context.AUDIO_SERVICE);
     oldvol = am.getStreamVolume(AudioManager.STREAM_MUSIC);
     setMode(speakermode);
     enableBluetooth(
         PreferenceManager.getDefaultSharedPreferences(Receiver.mContext)
             .getBoolean(
                 org.sipdroid.sipua.ui.Settings.PREF_BLUETOOTH,
                 org.sipdroid.sipua.ui.Settings.DEFAULT_BLUETOOTH));
     am.setStreamVolume(
         stream(),
         PreferenceManager.getDefaultSharedPreferences(Receiver.mContext)
             .getInt(
                 "volume" + speakermode,
                 am.getStreamMaxVolume(stream())
                     * (speakermode == AudioManager.MODE_NORMAL ? 4 : 3)
                     / 4),
         0);
     ringbackPlayer =
         new ToneGenerator(
             stream(),
             (int) (ToneGenerator.MAX_VOLUME * 2 * org.sipdroid.sipua.ui.Settings.getEarGain()));
     ringbackPlayer.startTone(ToneGenerator.TONE_SUP_RINGTONE);
   } else if (!ringback && ringbackPlayer != null) {
     ringbackPlayer.stopTone();
     ringbackPlayer.release();
     ringbackPlayer = null;
     if (Receiver.call_state == UserAgent.UA_STATE_IDLE) {
       AudioManager am = (AudioManager) Receiver.mContext.getSystemService(Context.AUDIO_SERVICE);
       restoreMode();
       enableBluetooth(false);
       am.setStreamVolume(AudioManager.STREAM_MUSIC, oldvol, 0);
       oldvol = -1;
     }
   }
 }
コード例 #6
0
  private void musePlayTone(ToneGenerator paramToneGenerator, int toneIdx) {
    if (validSensor[toneIdx] == false) {
      return;
    }

    if (paramToneGenerator == null) {
      paramToneGenerator = new ToneGenerator(4, 100);
    }
    for (; ; ) {
      paramToneGenerator.startTone(HorseshoeTones[toneIdx]);
      try {
        Thread.sleep(this.tone_on_duration / 8);
        paramToneGenerator.stopTone();
        try {
          Thread.sleep(this.tone_off_duration / 2);
          return;
        } catch (Exception e) {
          Log.e("Muse Headband exception", e.toString());
        }
      } catch (Exception e) {
        Log.e("Muse Headband exception", e.toString());
      }
    }
  }
  /**
   * Plays debug sound
   *
   * @param name
   */
  protected void startTone(String name) {
    int tone = 0;
    int duration = 1000;

    if (name.equals("beep")) {
      tone = ToneGenerator.TONE_PROP_BEEP;
    } else if (name.equals("beep_beep_beep")) {
      tone = ToneGenerator.TONE_CDMA_CONFIRM;
    } else if (name.equals("long_beep")) {
      tone = ToneGenerator.TONE_CDMA_ABBR_ALERT;
    } else if (name.equals("doodly_doo")) {
      tone = ToneGenerator.TONE_CDMA_ALERT_NETWORK_LITE;
    } else if (name.equals("chirp_chirp_chirp")) {
      tone = ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD;
    } else if (name.equals("dialtone")) {
      tone = ToneGenerator.TONE_SUP_RINGTONE;
    }
    toneGenerator.startTone(tone, duration);
  }
コード例 #8
0
 @Override
 public void onListItemClick(ListView l, View v, int position, long id) {
   super.onListItemClick(l, v, position, id);
   mToneGenerator.startTone(position);
   Log.d("SystemSoundDemo", "Start tone. toneType=" + position);
 }
コード例 #9
0
 @Override
 public synchronized void onPause() {
   super.onPause();
   mToneGenerator.release();
 }
コード例 #10
0
    @Override
    public void run() {
      Log.d(THIS_FILE, "InCallTonePlayer.run(toneId = " + mToneId + ")...");

      int toneType; // passed to ToneGenerator.startTone()
      int toneVolume; // passed to the ToneGenerator constructor
      int toneLengthMillis;
      switch (mToneId) {
        case TONE_CALL_WAITING:
          toneType = ToneGenerator.TONE_SUP_CALL_WAITING;
          toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
          toneLengthMillis = 5000;
          break;
        case TONE_BUSY:
          toneType = ToneGenerator.TONE_SUP_BUSY;
          toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
          toneLengthMillis = 4000;
          break;
        case TONE_CONGESTION:
          toneType = ToneGenerator.TONE_SUP_CONGESTION;
          toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
          toneLengthMillis = 4000;
          break;
        case TONE_BATTERY_LOW:
          // For now, use ToneGenerator.TONE_PROP_ACK (two quick
          // beeps). TODO: is there some other ToneGenerator
          // tone that would be more appropriate here? Or
          // should we consider adding a new custom tone?
          toneType = ToneGenerator.TONE_PROP_ACK;
          toneVolume = TONE_RELATIVE_VOLUME_HIPRI;
          toneLengthMillis = 1000;
          break;
        case TONE_CALL_ENDED:
          toneType = ToneGenerator.TONE_PROP_PROMPT;
          toneVolume = TONE_RELATIVE_VOLUME_LOPRI;
          toneLengthMillis = 2000;
          break;
        default:
          throw new IllegalArgumentException("Bad toneId: " + mToneId);
      }

      // If the mToneGenerator creation fails, just continue without it.
      // It is
      // a local audio signal, and is not as important.
      ToneGenerator toneGenerator;
      try {
        toneGenerator = new ToneGenerator(AudioManager.STREAM_VOICE_CALL, toneVolume);
        // if (DBG) log("- created toneGenerator: " + toneGenerator);
      } catch (RuntimeException e) {
        Log.w(THIS_FILE, "InCallTonePlayer: Exception caught while creating ToneGenerator: " + e);
        toneGenerator = null;
      }

      // Using the ToneGenerator (with the CALL_WAITING / BUSY /
      // CONGESTION tones at least), the ToneGenerator itself knows
      // the right pattern of tones to play; we do NOT need to
      // manually start/stop each individual tone, or manually
      // insert the correct delay between tones. (We just start it
      // and let it run for however long we want the tone pattern to
      // continue.)
      //
      // TODO: When we stop the ToneGenerator in the middle of a
      // "tone pattern", it sounds bad if we cut if off while the
      // tone is actually playing. Consider adding API to the
      // ToneGenerator to say "stop at the next silent part of the
      // pattern", or simply "play the pattern N times and then
      // stop."

      if (toneGenerator != null) {
        toneGenerator.startTone(toneType);
        SystemClock.sleep(toneLengthMillis);
        toneGenerator.stopTone();

        Log.v(THIS_FILE, "- InCallTonePlayer: done playing.");
        toneGenerator.release();
      }
    }
コード例 #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();
  }
コード例 #12
0
 public void stopTone() {
   tg.stopTone();
 }
コード例 #13
0
  private void playAudioFeedback(int at_mode) {
    int tone;
    int play_tone = 0;
    int i = 0;
    int k;
    // create generator once
    // ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 100);

    // tone test
    int j;
    if (at_mode == 1) {
      for (j = 0; j < HorseshoeElemeToneMax; j++) {
        for (k = 0; k < 2; k++) // play twice
        {
          musePlayTone(null, j);
        }
      } // horseshoe for loop
      return; // test done
    }
    // end test

    // normal operation
    Log.i("Muse Headband kt:", "Starting ToneGenerator");
    ToneGenerator toneG = new ToneGenerator(AudioManager.STREAM_ALARM, 100);

    // infinite - user can connect/disconnect multiple times without exiting the app
    while (true) {
      if (stopSounds != 0) {
        toneG.stopTone();
        toneG = null;
        Log.i("Muse Headband kt:", "Stopping ToneGenerator");
        // stopSounds = 0;
        // put thread to sleep
        try {
          Thread.sleep(1000); // let CPU rest
        } catch (Exception e) {
        }
        continue;
      }

      if (horseshoeElemeTone != HorseshoeElemeToneMax) {
        i = horseshoeElemeTone;
      }
      // do not play sounds if horseshoe is less than 3
      // look for horseshoe less than 3
      while (horseshoeElem[i] < 3) {
        i++;
        if (i == HorseshoeElemeToneMax) break;
      }
      // we are here either becasue we scanned to the end of the array
      // or we found a bad sensor
      if (i != HorseshoeElemeToneMax) // if none bad, no sound
      {
        // we had bad sensor, play its sound
        musePlayTone(toneG, i);
      } else {
        horseshoeElemeTone = 0; // restart scanning from the start of array
      }
      // put thread to sleep
      try {
        Thread.sleep(1000); // let CPU rest
      } catch (Exception e) {
      }
    } // infinite lop
  }
 public void onDestroy() {
   toneGenerator.release();
 }
コード例 #15
0
  private boolean launchTarget(int target) {
    String targetKey;

    int targetListOffset;
    if (screenLayout() == Configuration.SCREENLAYOUT_SIZE_LARGE
        || screenLayout() == Configuration.SCREENLAYOUT_SIZE_XLARGE) {
      targetListOffset = 0;
    } else {
      if (isScreenPortrait() == true) {
        targetListOffset = 0;
      } else {
        targetListOffset = -2;
      }
    }

    if (target <= targetList.size()) {
      targetKey =
          Settings.System.getString(
              mContext.getContentResolver(), targetList.get(target + targetListOffset));
    } else {
      return false;
    }

    if (targetKey == null || targetKey.equals("")) {
      return false;
    }

    if (targetKey.startsWith("app:")) {
      String activity = targetKey.substring(4);
      ComponentName component = ComponentName.unflattenFromString(activity);

      /* Try to launch the activity from history, if available.*/
      ActivityManager activityManager =
          (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
      for (ActivityManager.RecentTaskInfo task :
          activityManager.getRecentTasks(20, ActivityManager.RECENT_IGNORE_UNAVAILABLE)) {
        if (task != null && task.origActivity != null && task.origActivity.equals(component)) {
          activityManager.moveTaskToFront(task.id, ActivityManager.MOVE_TASK_WITH_HOME);
          return true;
        }
      }

      vibrate();
      Intent intent = new Intent();
      intent.addCategory(Intent.CATEGORY_LAUNCHER);
      intent.setComponent(component);
      intent.addFlags(
          Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY
              | Intent.FLAG_ACTIVITY_TASK_ON_HOME
              | Intent.FLAG_ACTIVITY_NEW_TASK);
      mContext.startActivity(intent);
      return true;
    } else if (targetKey.equals("screenoff")) {
      vibrate();
      screenOff();
      return true;
    } else if (targetKey.equals("ime_switcher")) {
      vibrate();
      getContext().sendBroadcast(new Intent("android.settings.SHOW_INPUT_METHOD_PICKER"));
      return true;
    } else if (targetKey.equals("ring_vib")) {
      AudioManager am = (AudioManager) getContext().getSystemService(Context.AUDIO_SERVICE);
      if (am != null) {
        if (am.getRingerMode() != AudioManager.RINGER_MODE_VIBRATE) {
          am.setRingerMode(AudioManager.RINGER_MODE_VIBRATE);
          Vibrator vib = (Vibrator) getContext().getSystemService(Context.VIBRATOR_SERVICE);
          if (vib != null) {
            vib.vibrate(30);
          }
        } else {
          am.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
          ToneGenerator tg =
              new ToneGenerator(
                  AudioManager.STREAM_NOTIFICATION, (int) (ToneGenerator.MAX_VOLUME * 0.85));
          if (tg != null) {
            tg.startTone(ToneGenerator.TONE_PROP_BEEP);
          }
        }
      }
      return true;
    } else if (targetKey.equals("ring_silent")) {
      AudioManager am = (AudioManager) getContext().getSystemService(Context.AUDIO_SERVICE);
      if (am != null) {
        if (am.getRingerMode() != AudioManager.RINGER_MODE_SILENT) {
          am.setRingerMode(AudioManager.RINGER_MODE_SILENT);
        } else {
          am.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
          ToneGenerator tg =
              new ToneGenerator(
                  AudioManager.STREAM_NOTIFICATION, (int) (ToneGenerator.MAX_VOLUME * 0.85));
          if (tg != null) {
            tg.startTone(ToneGenerator.TONE_PROP_BEEP);
          }
        }
      }
      return true;
    } else if (targetKey.equals("ring_vib_silent")) {
      AudioManager am = (AudioManager) getContext().getSystemService(Context.AUDIO_SERVICE);
      if (am != null) {
        if (am.getRingerMode() == AudioManager.RINGER_MODE_NORMAL) {
          am.setRingerMode(AudioManager.RINGER_MODE_VIBRATE);
          Vibrator vib = (Vibrator) getContext().getSystemService(Context.VIBRATOR_SERVICE);
          if (vib != null) {
            vib.vibrate(30);
          }
        } else if (am.getRingerMode() == AudioManager.RINGER_MODE_VIBRATE) {
          am.setRingerMode(AudioManager.RINGER_MODE_SILENT);
        } else {
          am.setRingerMode(AudioManager.RINGER_MODE_NORMAL);
          ToneGenerator tg =
              new ToneGenerator(
                  AudioManager.STREAM_NOTIFICATION, (int) (ToneGenerator.MAX_VOLUME * 0.85));
          if (tg != null) {
            tg.startTone(ToneGenerator.TONE_PROP_BEEP);
          }
        }
      }
      return true;
    } else if (targetKey.equals("killcurrent")) {
      vibrate();
      killProcess();
      return true;
    } else if (targetKey.equals("screenshot")) {
      vibrate();
      takeScreenshot();
      return true;
    } else if (targetKey.equals("power")) {
      vibrate();
      powerMenu();
      return true;
    }
    return false;
  }
  /** Runs it in a new Thread. */
  public void run() {
    boolean nodata =
        PreferenceManager.getDefaultSharedPreferences(Receiver.mContext)
            .getBoolean(
                org.sipdroid.sipua.ui.Settings.PREF_NODATA,
                org.sipdroid.sipua.ui.Settings.DEFAULT_NODATA);
    keepon =
        PreferenceManager.getDefaultSharedPreferences(Receiver.mContext)
            .getBoolean(
                org.sipdroid.sipua.ui.Settings.PREF_KEEPON,
                org.sipdroid.sipua.ui.Settings.DEFAULT_KEEPON);

    if (rtp_socket == null) {
      if (DEBUG) println("ERROR: RTP socket is null");
      return;
    }

    byte[] buffer = new byte[BUFFER_SIZE + 12];
    rtp_packet = new RtpPacket(buffer, 0);

    if (DEBUG) println("Reading blocks of max " + buffer.length + " bytes");

    running = true;
    enableBluetooth(
        PreferenceManager.getDefaultSharedPreferences(Receiver.mContext)
            .getBoolean(
                org.sipdroid.sipua.ui.Settings.PREF_BLUETOOTH,
                org.sipdroid.sipua.ui.Settings.DEFAULT_BLUETOOTH));
    restored = false;

    android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_AUDIO);
    am = (AudioManager) Receiver.mContext.getSystemService(Context.AUDIO_SERVICE);
    cr = Receiver.mContext.getContentResolver();
    saveSettings();
    Settings.System.putInt(
        cr, Settings.System.WIFI_SLEEP_POLICY, Settings.System.WIFI_SLEEP_POLICY_NEVER);
    am.setVibrateSetting(AudioManager.VIBRATE_TYPE_RINGER, AudioManager.VIBRATE_SETTING_OFF);
    am.setVibrateSetting(AudioManager.VIBRATE_TYPE_NOTIFICATION, AudioManager.VIBRATE_SETTING_OFF);
    if (oldvol == -1) oldvol = am.getStreamVolume(AudioManager.STREAM_MUSIC);
    initMode();
    setCodec();
    short lin[] = new short[BUFFER_SIZE];
    short lin2[] = new short[BUFFER_SIZE];
    int server, headroom, todo, len = 0, m = 1, expseq, getseq, vm = 1, gap, gseq;
    ToneGenerator tg =
        new ToneGenerator(
            AudioManager.STREAM_VOICE_CALL,
            (int) (ToneGenerator.MAX_VOLUME * 2 * org.sipdroid.sipua.ui.Settings.getEarGain()));
    track.play();
    System.gc();
    empty();
    lockFirst = true;
    while (running) {
      lock(true);
      if (Receiver.call_state == UserAgent.UA_STATE_HOLD) {
        lock(false);
        tg.stopTone();
        track.pause();
        while (running && Receiver.call_state == UserAgent.UA_STATE_HOLD) {
          try {
            sleep(1000);
          } catch (InterruptedException e1) {
          }
        }
        track.play();
        System.gc();
        timeout = 1;
        luser = luser2 = -8000 * mu;
      }
      try {
        rtp_socket.receive(rtp_packet);
        if (timeout != 0) {
          tg.stopTone();
          track.pause();
          for (int i = maxjitter * 2; i > 0; i -= BUFFER_SIZE)
            write(lin2, 0, i > BUFFER_SIZE ? BUFFER_SIZE : i);
          cnt += maxjitter * 2;
          track.play();
          empty();
        }
        timeout = 0;
      } catch (IOException e) {
        if (timeout == 0 && nodata) {
          tg.startTone(ToneGenerator.TONE_SUP_RINGTONE);
        }
        rtp_socket.getDatagramSocket().disconnect();
        if (++timeout > 60) {
          Receiver.engine(Receiver.mContext).rejectcall();
          break;
        }
      }
      if (running && timeout == 0) {
        gseq = rtp_packet.getSequenceNumber();
        if (seq == gseq) {
          m++;
          continue;
        }
        gap = (gseq - seq) & 0xff;
        if (gap > 240) continue;
        server = track.getPlaybackHeadPosition();
        headroom = user - server;

        if (headroom > 2 * jitter) cnt += len;
        else cnt = 0;

        if (lserver == server) cnt2++;
        else cnt2 = 0;

        if (cnt <= 500 * mu
            || cnt2 >= 2
            || headroom - jitter < len
            || p_type.codec.number() != 8
            || p_type.codec.number() != 0) {
          if (rtp_packet.getPayloadType() != p_type.number
              && p_type.change(rtp_packet.getPayloadType())) {
            saveVolume();
            setCodec();
            restoreVolume();
            codec = p_type.codec.getTitle();
          }
          len = p_type.codec.decode(buffer, lin, rtp_packet.getPayloadLength());

          // Call recording: Save incoming.
          // Data is in buffer lin, from 0 to len.
          if (call_recorder != null) call_recorder.writeIncoming(lin, 0, len);

          if (speakermode == AudioManager.MODE_NORMAL) calc(lin, 0, len);
          else if (gain > 1) calc2(lin, 0, len);
        }

        avgheadroom = avgheadroom * 0.99 + (double) headroom * 0.01;
        if (avgcnt++ > 300)
          devheadroom = devheadroom * 0.999 + Math.pow(Math.abs(headroom - avgheadroom), 2) * 0.001;
        if (headroom < 250 * mu) {
          late++;
          newjitter(true);
          System.out.println("RTP:underflow " + (int) Math.sqrt(devheadroom));
          todo = jitter - headroom;
          write(lin2, 0, todo > BUFFER_SIZE ? BUFFER_SIZE : todo);
        }

        if (cnt > 500 * mu && cnt2 < 2) {
          todo = headroom - jitter;
          if (todo < len) write(lin, todo, len - todo);
        } else write(lin, 0, len);

        if (seq != 0) {
          getseq = gseq & 0xff;
          expseq = ++seq & 0xff;
          if (m == RtpStreamSender.m) vm = m;
          gap = (getseq - expseq) & 0xff;
          if (gap > 0) {
            System.out.println("RTP:lost");
            if (gap > 100) gap = 1;
            loss += gap;
            lost += gap;
            good += gap - 1;
            loss2++;
          } else {
            if (m < vm) {
              loss++;
              loss2++;
            }
          }
          good++;
          if (good > 110) {
            good *= 0.99;
            lost *= 0.99;
            loss *= 0.99;
            loss2 *= 0.99;
            late *= 0.99;
          }
        }
        m = 1;
        seq = gseq;

        if (user >= luser + 8000 * mu
            && (Receiver.call_state == UserAgent.UA_STATE_INCALL
                || Receiver.call_state == UserAgent.UA_STATE_OUTGOING_CALL)) {
          if (luser == -8000 * mu || getMode() != speakermode) {
            saveVolume();
            setMode(speakermode);
            restoreVolume();
          }
          luser = user;
          if (user >= luser2 + 160000 * mu) newjitter(false);
        }
        lserver = server;
      }
    }
    lock(false);
    track.stop();
    track.release();
    tg.stopTone();
    tg.release();
    saveVolume();
    am.setStreamVolume(AudioManager.STREAM_MUSIC, oldvol, 0);
    restoreSettings();
    enableBluetooth(false);
    am.setStreamVolume(AudioManager.STREAM_MUSIC, oldvol, 0);
    oldvol = -1;
    p_type.codec.close();
    rtp_socket.close();
    rtp_socket = null;
    codec = "";

    // Call recording: stop incoming receive.
    if (call_recorder != null) {
      call_recorder.stopIncoming();
      call_recorder = null;
    }

    if (DEBUG) println("rtp receiver terminated");

    cleanupBluetooth();
  }
コード例 #17
0
  public void playDTMFTONE(int tone_number) {
    switch (tone_number) {
      case (0):
        tg.startTone(ToneGenerator.TONE_DTMF_0);
        break;
      case (1):
        tg.startTone(ToneGenerator.TONE_DTMF_1);
        break;
      case (2):
        tg.startTone(ToneGenerator.TONE_DTMF_2);
        break;
      case (3):
        tg.startTone(ToneGenerator.TONE_DTMF_3);
        break;
      case (4):
        tg.startTone(ToneGenerator.TONE_DTMF_4);
        break;
      case (5):
        tg.startTone(ToneGenerator.TONE_DTMF_5);
        break;
      case (6):
        tg.startTone(ToneGenerator.TONE_DTMF_6);
        break;
      case (7):
        tg.startTone(ToneGenerator.TONE_DTMF_7);
        break;
      case (8):
        tg.startTone(ToneGenerator.TONE_DTMF_8);
        break;
      case (9):
        tg.startTone(ToneGenerator.TONE_DTMF_9);
        break;

      case (10):
        tg.startTone(ToneGenerator.TONE_DTMF_S);
        break;
      case (11):
        tg.startTone(ToneGenerator.TONE_DTMF_P);
        break;
      case (12):
        tg.startTone(ToneGenerator.TONE_DTMF_A);
        break;
      case (13):
        tg.startTone(ToneGenerator.TONE_DTMF_B);
        break;
      case (14):
        tg.startTone(ToneGenerator.TONE_DTMF_C);
        break;
      case (15):
        tg.startTone(ToneGenerator.TONE_DTMF_D);
        break;
      default:
        break;
    }
  }