Java 类android.bluetooth.BluetoothHeadset 实例源码

private void optional() {
        HeadsetPlugManager.getInstance().registerHeadsetPlugListener(this);
        mHeadsetListener = new HeadsetBroadcastReceiver();
        registerReceiver(mHeadsetListener, new IntentFilter(Intent.ACTION_HEADSET_PLUG));
        mBluetoothHeadsetBroadcastListener = new BluetoothHeadsetBroadcastReceiver();
        mBtAdapter = BluetoothAdapter.getDefaultAdapter();
        if (mBtAdapter != null && BluetoothProfile.STATE_CONNECTED == mBtAdapter.getProfileConnectionState(BluetoothProfile.HEADSET)) {
            // on some devices, BT is not supported
            boolean bt = mBtAdapter.getProfileProxy(getBaseContext(), mBluetoothHeadsetListener, BluetoothProfile.HEADSET);
            int connection = mBtAdapter.getProfileConnectionState(BluetoothProfile.HEADSET);
        }
        IntentFilter i = new IntentFilter(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
        i.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
        i.addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
        registerReceiver(mBluetoothHeadsetBroadcastListener, i);
//避免对window添加ui修改参数
//        getWindow().addFlags(WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN);
//        getWindow().addFlags(WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS);

        setVolumeControlStream(AudioManager.STREAM_VOICE_CALL);
    }

public void initBluetooth() {
    if (!ensureInit()) {
        Log.w("[Bluetooth] Manager tried to init bluetooth but LinphoneService not ready yet...");
        return;
    }

    IntentFilter filter = new IntentFilter();
    filter.addCategory(BluetoothHeadset.VENDOR_SPECIFIC_HEADSET_EVENT_COMPANY_ID_CATEGORY + "." + BluetoothAssignedNumbers.PLANTRONICS);
    filter.addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
    filter.addAction(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED);
    filter.addAction(BluetoothHeadset.ACTION_VENDOR_SPECIFIC_HEADSET_EVENT);
    mContext.registerReceiver(this,  filter);
    Log.d("[Bluetooth] Receiver started");

    startBluetooth();
}

public boolean isBluetoothHeadsetAvailable() {
    ensureInit();
    if (mBluetoothAdapter != null && mBluetoothAdapter.isEnabled() && mAudioManager != null && mAudioManager.isBluetoothScoAvailableOffCall()) {
        boolean isHeadsetConnected = false;
        if (mBluetoothHeadset != null) {
            List<BluetoothDevice> devices = mBluetoothHeadset.getConnectedDevices();
            mBluetoothDevice = null;
            for (final BluetoothDevice dev : devices) {    
                if (mBluetoothHeadset.getConnectionState(dev) == BluetoothHeadset.STATE_CONNECTED) {
                    mBluetoothDevice = dev;
                    isHeadsetConnected = true;
                    break;
                }
            }
            Log.d(isHeadsetConnected ? "[Bluetooth] Headset found, bluetooth audio route available" : "[Bluetooth] No headset found, bluetooth audio route unavailable");
        }
        return isHeadsetConnected;
    }

    return false;
}

public BluetoothStateManager(@NonNull Context context, @Nullable BluetoothStateListener listener) {
    this.context                     = context.getApplicationContext();
    this.bluetoothAdapter            = BluetoothAdapter.getDefaultAdapter();
    this.bluetoothScoReceiver        = new BluetoothScoReceiver();
    this.bluetoothConnectionReceiver = new BluetoothConnectionReceiver();
    this.listener                    = listener;

    requestHeadsetProxyProfile();

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
        context.registerReceiver(bluetoothConnectionReceiver, new IntentFilter(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED));
    }

    Intent sticky = context.registerReceiver(bluetoothScoReceiver, new IntentFilter(AudioManager.ACTION_SCO_AUDIO_STATE_CHANGED));

    if (sticky != null) {
        bluetoothScoReceiver.onReceive(context, sticky);
    }

    handleBluetoothStateChange();
}

public BluetoothStateManager(@NonNull Context context, @Nullable BluetoothStateListener listener) {
  this.context                     = context.getApplicationContext();
  this.bluetoothAdapter            = BluetoothAdapter.getDefaultAdapter();
  this.bluetoothScoReceiver        = new BluetoothScoReceiver();
  this.bluetoothConnectionReceiver = new BluetoothConnectionReceiver();
  this.listener                    = listener;

  if (this.bluetoothAdapter == null)
    return;

  requestHeadsetProxyProfile();

  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
    context.registerReceiver(bluetoothConnectionReceiver, new IntentFilter(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED));
  }

  Intent sticky = context.registerReceiver(bluetoothScoReceiver, new IntentFilter(getScoChangeIntent()));

  if (sticky != null) {
    bluetoothScoReceiver.onReceive(context, sticky);
  }

  handleBluetoothStateChange();
}

public void onServiceConnected(int profile, BluetoothProfile proxy) {
    if (profile == BluetoothProfile.HEADSET) {
        mBluetoothHeadset = (BluetoothHeadset) proxy;
        List<BluetoothDevice> pairedDevices = mBluetoothHeadset.getConnectedDevices();
        // If there are paired devices
        if (pairedDevices.size() > 0) {
            startSCO();
            for (BluetoothDevice device : pairedDevices) {
                Log.e(TAG, "BT Device :"+device.getName()+ " , BD_ADDR:" + device.getAddress());       //Print out Headset name      
            }
        } else {
            Toast.makeText(mContext, "Could not find a connected Headset, please connect a headset", Toast.LENGTH_LONG).show();
            return;
        }
    }
}

@Override
public void onReceive(Context context, Intent intent) {
    if (ACTION_HEADSET_PLUG.equals(intent.getAction())) {
        isHeadsetPlugged = intent.getIntExtra("state", 0) == 1;
        if (isHeadsetPlugged && proximityWakelock != null && proximityWakelock.isHeld()) {
            proximityWakelock.release();
        }
        isProximityNear = false;
        updateOutputGainControlState();
    } else if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
        updateNetworkType();
    } else if(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED.equals(intent.getAction())){
        //FileLog.e("bt headset state = "+intent.getIntExtra(BluetoothProfile.EXTRA_STATE, 0));
        updateBluetoothHeadsetState(intent.getIntExtra(BluetoothProfile.EXTRA_STATE, 0)==BluetoothProfile.STATE_CONNECTED);
    }else if(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED.equals(intent.getAction())){
        for (StateListener l : stateListeners)
            l.onAudioSettingsChanged();
    }else if(TelephonyManager.ACTION_PHONE_STATE_CHANGED.equals(intent.getAction())){
        String state=intent.getStringExtra(TelephonyManager.EXTRA_STATE);
        if(TelephonyManager.EXTRA_STATE_OFFHOOK.equals(state)){
            hangUp();
        }
    }
}

private void startBluetooth() {
    if (isBluetoothConnected) {
        Log.e("[Bluetooth] Already started, skipping...");
        return;
    }

    mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

    if (mBluetoothAdapter != null && mBluetoothAdapter.isEnabled()) {
        if (mProfileListener != null) {
            Log.w("[Bluetooth] Headset profile was already opened, let's close it");
            mBluetoothAdapter.closeProfileProxy(BluetoothProfile.HEADSET, mBluetoothHeadset);
        }

        mProfileListener = new BluetoothProfile.ServiceListener() {
            public void onServiceConnected(int profile, BluetoothProfile proxy) {
                if (profile == BluetoothProfile.HEADSET) {
                    Log.d("[Bluetooth] Headset connected");
                    mBluetoothHeadset = (BluetoothHeadset) proxy;
                    isBluetoothConnected = true;
                }
            }
            public void onServiceDisconnected(int profile) {
                if (profile == BluetoothProfile.HEADSET) {
                    mBluetoothHeadset = null;
                    isBluetoothConnected = false;
                    Log.d("[Bluetooth] Headset disconnected");
                    LinphoneManager.getInstance().routeAudioToReceiver();
                }
            }
        };
        boolean success = mBluetoothAdapter.getProfileProxy(mContext, mProfileListener, BluetoothProfile.HEADSET);
        if (!success) {
            Log.e("[Bluetooth] getProfileProxy failed !");
        }
    } else {
        Log.w("[Bluetooth] Interface disabled on device");
    }
}

@Override
public void onServiceConnected(int profile, BluetoothProfile proxy) {
    Log.e("blueHeadsetListener", "onServiceConnected:" + profile);
    if (profile == BluetoothProfile.A2DP) {
        voiceMediator.setBluetoothA2dp((BluetoothA2dp) proxy);
    } else if (profile == BluetoothProfile.HEADSET) {
        voiceMediator.setBluetoothHeadset((BluetoothHeadset) proxy);
    }
}

@Override
public void startBluetoothSco() {
    if (isBlueToothHeadSet()) {
        BluetoothHeadset headset = getBluetoothHeadset();
        if (headset == null || headset.getConnectedDevices().isEmpty() || headset.isAudioConnected(headset.getConnectedDevices().get(0)))
            return;
        Log.e(TAG, "startBluetoothSco:device size=" + headset.getConnectedDevices().size());
        headset.startVoiceRecognition(headset.getConnectedDevices().get(0));
    }
}

@Override
// Called to notify the client when the proxy object has been connected to the service.
// Once we have the profile proxy object, we can use it to monitor the state of the
// connection and perform other operations that are relevant to the headset profile.
public void onServiceConnected(int profile, BluetoothProfile proxy) {
    if (profile != BluetoothProfile.HEADSET || bluetoothState == State.UNINITIALIZED) {
        return;
    }
    Log.d(TAG, "BluetoothServiceListener.onServiceConnected: BT state=" + bluetoothState);
    // Android only supports one connected Bluetooth Headset at a time.
    bluetoothHeadset = (BluetoothHeadset) proxy;
    updateAudioDeviceState();
    Log.d(TAG, "onServiceConnected done: BT state=" + bluetoothState);
}

@Override
public void onReceive(Context context, Intent intent) {

    BluetoothDevice mConnectedHeadset = null;

    String action = intent.getAction();
    int state = BluetoothHeadset.STATE_DISCONNECTED;
    int previousState = intent.getIntExtra(BluetoothHeadset.EXTRA_PREVIOUS_STATE, BluetoothHeadset.STATE_DISCONNECTED);
    if (BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
        state = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_DISCONNECTED);
        if (state == BluetoothHeadset.STATE_CONNECTED) {
            mConnectedHeadset = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
            log.debug("AudioManager ACTION_CONNECTION_STATE_CHANGED " + mConnectedHeadset + " " + state);
            HeadsetPlugManager.getInstance().notifyHeadsetPlugged(true, HeadsetPlugManager.BLUETOOTH, mConnectedHeadset);
        } else if (state == BluetoothHeadset.STATE_DISCONNECTED) {
            mConnectedHeadset = null;
            log.debug("AudioManager ACTION_CONNECTION_STATE_CHANGED " + " " + state);
            HeadsetPlugManager.getInstance().notifyHeadsetPlugged(false, HeadsetPlugManager.BLUETOOTH);
        }
    } else if (BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED.equals(action)) {
        state = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_AUDIO_DISCONNECTED);
        log.debug("AudioManager ACTION_AUDIO_STATE_CHANGED " + " " + state);
        if (state == BluetoothHeadset.STATE_AUDIO_CONNECTED) {
            // bluetooth audio connected. you send audio stream to headset now!!!
        } else if (state == BluetoothHeadset.STATE_AUDIO_DISCONNECTED) {
        }
    } else if (AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED.equals(action)) {
        state = intent.getIntExtra(AudioManager.EXTRA_SCO_AUDIO_STATE, AudioManager.SCO_AUDIO_STATE_DISCONNECTED);
        log.debug("AudioManager ACTION_SCO_AUDIO_STATE_UPDATED " + " " + state);
    }
}

@Override
// Called to notify the client when the proxy object has been connected to the service.
// Once we have the profile proxy object, we can use it to monitor the state of the
// connection and perform other operations that are relevant to the headset profile.
public void onServiceConnected(int profile, BluetoothProfile proxy) {
  if (profile != BluetoothProfile.HEADSET || bluetoothState == State.UNINITIALIZED) {
    return;
  }
  Log.d(TAG, "BluetoothServiceListener.onServiceConnected: BT state=" + bluetoothState);
  // Android only supports one connected Bluetooth Headset at a time.
  bluetoothHeadset = (BluetoothHeadset) proxy;
  updateAudioDeviceState();
  Log.d(TAG, "onServiceConnected done: BT state=" + bluetoothState);
}

@Override
// Called to notify the client when the proxy object has been connected to the service.
// Once we have the profile proxy object, we can use it to monitor the state of the
// connection and perform other operations that are relevant to the headset profile.
public void onServiceConnected(int profile, BluetoothProfile proxy) {
    if (profile != BluetoothProfile.HEADSET || bluetoothState == State.UNINITIALIZED) {
        return;
    }
    Log.d(TAG, "BluetoothServiceListener.onServiceConnected: BT state=" + bluetoothState);
    // Android only supports one connected Bluetooth Headset at a time.
    bluetoothHeadset = (BluetoothHeadset) proxy;
    updateAudioDeviceState();
    Log.d(TAG, "onServiceConnected done: BT state=" + bluetoothState);
}

@Override
// Called to notify the client when the proxy object has been connected to the service.
// Once we have the profile proxy object, we can use it to monitor the state of the
// connection and perform other operations that are relevant to the headset profile.
public void onServiceConnected(int profile, BluetoothProfile proxy) {
  if (profile != BluetoothProfile.HEADSET || bluetoothState == State.UNINITIALIZED) {
    return;
  }
  Log.d(TAG, "BluetoothServiceListener.onServiceConnected: BT state=" + bluetoothState);
  // Android only supports one connected Bluetooth Headset at a time.
  bluetoothHeadset = (BluetoothHeadset) proxy;
  updateAudioDeviceState();
  Log.d(TAG, "onServiceConnected done: BT state=" + bluetoothState);
}

@Override
public void onReceive(Context context, Intent intent)
{
    int state = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_DISCONNECTED);

    SharedPreferences.Editor editor = PreferenceManager.getDefaultSharedPreferences(context).edit();
    editor.putBoolean(SETTING_HEADSET_CONNECTED, state == BluetoothHeadset.STATE_CONNECTED);
    editor.apply();
}

public void onReceive(Context context, Intent intent) {
    Log.d(TAG, "BT state changed");
    String action = intent.getAction();
    if (BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED.equals(action)) {
        int status = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, 0);
        if (status == 2) {
            Log.d(TAG, "BT device found");
            // Discovery has found a device. Get the BluetoothDevice
            // object and its info from the Intent.
            if (btChangesListener != null) {
                btChangesListener.onBluetoothStateChanged(status);
            }
        }
    }
}

private void registerBtReceiver() {
    if (!scoReceiverRegistered) {
        context.registerReceiver(
                btStatusReceiver,
                new IntentFilter(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)
        );
        scoReceiverRegistered = true;
    }
}

private void disableBluetoothEvents() {
    if (null != bluetoothProfile && bluetoothAdapter != null) {
        bluetoothAdapter.closeProfileProxy(BluetoothProfile.HEADSET, bluetoothProfile);
    }
    unregisterBtReceiver();
    /* force a shutdown of bluetooth: when a call comes in, the handler is not invoked by system */
    Intent intent = new Intent(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
    intent.putExtra(BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_DISCONNECTED);
    btStatusReceiver.onReceive(context, intent);
}

public void setBluetoothHeadset(BluetoothHeadset bluetoothHeadset) {
    this.bluetoothHeadset = bluetoothHeadset;
}

@Override
public BluetoothHeadset getBluetoothHeadset() {
    return bluetoothHeadset;
}

/**
 * Activates components required to detect Bluetooth devices and to enable
 * BT SCO (audio is routed via BT SCO) for the headset profile. The end
 * state will be HEADSET_UNAVAILABLE but a state machine has started which
 * will start a state change sequence where the final outcome depends on
 * if/when the BT headset is enabled.
 * Example of state change sequence when start() is called while BT device
 * is connected and enabled:
 * UNINITIALIZED --> HEADSET_UNAVAILABLE --> HEADSET_AVAILABLE -->
 * SCO_CONNECTING --> SCO_CONNECTED <==> audio is now routed via BT SCO.
 * Note that the AppRTCAudioManager is also involved in driving this state
 * change.
 */
public void start() {
    ThreadUtils.checkIsOnMainThread();
    Log.d(TAG, "start");
    if (!hasPermission(apprtcContext, android.Manifest.permission.BLUETOOTH)) {
        Log.w(TAG, "Process (pid=" + Process.myPid() + ") lacks BLUETOOTH permission");
        return;
    }
    if (bluetoothState != State.UNINITIALIZED) {
        Log.w(TAG, "Invalid BT state");
        return;
    }
    bluetoothHeadset = null;
    bluetoothDevice = null;
    scoConnectionAttempts = 0;
    // Get a handle to the default local Bluetooth adapter.
    bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    if (bluetoothAdapter == null) {
        Log.w(TAG, "Device does not support Bluetooth");
        return;
    }
    // Ensure that the device supports use of BT SCO audio for off call use cases.
    if (!audioManager.isBluetoothScoAvailableOffCall()) {
        Log.e(TAG, "Bluetooth SCO audio is not available off call");
        return;
    }
    logBluetoothAdapterInfo(bluetoothAdapter);
    // Establish a connection to the HEADSET profile (includes both Bluetooth Headset and
    // Hands-Free) proxy object and install a listener.
    if (!getBluetoothProfileProxy(
            apprtcContext, bluetoothServiceListener, BluetoothProfile.HEADSET)) {
        Log.e(TAG, "BluetoothAdapter.getProfileProxy(HEADSET) failed");
        return;
    }
    // Register receivers for BluetoothHeadset change notifications.
    IntentFilter bluetoothHeadsetFilter = new IntentFilter();
    // Register receiver for change in connection state of the Headset profile.
    bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
    // Register receiver for change in audio connection state of the Headset profile.
    bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
    registerReceiver(bluetoothHeadsetReceiver, bluetoothHeadsetFilter);
    Log.d(TAG, "HEADSET profile state: "
               + stateToString(bluetoothAdapter.getProfileConnectionState(BluetoothProfile.HEADSET)));
    Log.d(TAG, "Bluetooth proxy for headset profile has started");
    bluetoothState = State.HEADSET_UNAVAILABLE;
    Log.d(TAG, "start done: BT state=" + bluetoothState);
}

/**
 * Activates components required to detect Bluetooth devices and to enable
 * BT SCO (audio is routed via BT SCO) for the headset profile. The end
 * state will be HEADSET_UNAVAILABLE but a state machine has started which
 * will start a state change sequence where the final outcome depends on
 * if/when the BT headset is enabled.
 * Example of state change sequence when start() is called while BT device
 * is connected and enabled:
 *   UNINITIALIZED --> HEADSET_UNAVAILABLE --> HEADSET_AVAILABLE -->
 *   SCO_CONNECTING --> SCO_CONNECTED <==> audio is now routed via BT SCO.
 * Note that the AppRTCAudioManager is also involved in driving this state
 * change.
 */
public void start() {
  ThreadUtils.checkIsOnMainThread();
  Log.d(TAG, "start");
  if (!hasPermission(apprtcContext, android.Manifest.permission.BLUETOOTH)) {
    Log.w(TAG, "Process (pid=" + Process.myPid() + ") lacks BLUETOOTH permission");
    return;
  }
  if (bluetoothState != State.UNINITIALIZED) {
    Log.w(TAG, "Invalid BT state");
    return;
  }
  bluetoothHeadset = null;
  bluetoothDevice = null;
  scoConnectionAttempts = 0;
  // Get a handle to the default local Bluetooth adapter.
  bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  if (bluetoothAdapter == null) {
    Log.w(TAG, "Device does not support Bluetooth");
    return;
  }
  // Ensure that the device supports use of BT SCO audio for off call use cases.
  if (!audioManager.isBluetoothScoAvailableOffCall()) {
    Log.e(TAG, "Bluetooth SCO audio is not available off call");
    return;
  }
  logBluetoothAdapterInfo(bluetoothAdapter);
  // Establish a connection to the HEADSET profile (includes both Bluetooth Headset and
  // Hands-Free) proxy object and install a listener.
  if (!getBluetoothProfileProxy(
          apprtcContext, bluetoothServiceListener, BluetoothProfile.HEADSET)) {
    Log.e(TAG, "BluetoothAdapter.getProfileProxy(HEADSET) failed");
    return;
  }
  // Register receivers for BluetoothHeadset change notifications.
  IntentFilter bluetoothHeadsetFilter = new IntentFilter();
  // Register receiver for change in connection state of the Headset profile.
  bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
  // Register receiver for change in audio connection state of the Headset profile.
  bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
  registerReceiver(bluetoothHeadsetReceiver, bluetoothHeadsetFilter);
  Log.d(TAG, "HEADSET profile state: "
          + stateToString(bluetoothAdapter.getProfileConnectionState(BluetoothProfile.HEADSET)));
  Log.d(TAG, "Bluetooth proxy for headset profile has started");
  bluetoothState = State.HEADSET_UNAVAILABLE;
  Log.d(TAG, "start done: BT state=" + bluetoothState);
}

/**
 * Activates components required to detect Bluetooth devices and to enable
 * BT SCO (audio is routed via BT SCO) for the headset profile. The end
 * state will be HEADSET_UNAVAILABLE but a state machine has started which
 * will start a state change sequence where the final outcome depends on
 * if/when the BT headset is enabled.
 * Example of state change sequence when start() is called while BT device
 * is connected and enabled:
 * UNINITIALIZED --> HEADSET_UNAVAILABLE --> HEADSET_AVAILABLE -->
 * SCO_CONNECTING --> SCO_CONNECTED <==> audio is now routed via BT SCO.
 * Note that the AppRTCAudioManager is also involved in driving this state
 * change.
 */
public void start() {
    ThreadUtils.checkIsOnMainThread();
    Log.d(TAG, "start");
    if (!hasPermission(apprtcContext, android.Manifest.permission.BLUETOOTH)) {
        Log.w(TAG, "Process (pid=" + Process.myPid() + ") lacks BLUETOOTH permission");
        return;
    }
    if (bluetoothState != State.UNINITIALIZED) {
        Log.w(TAG, "Invalid BT state");
        return;
    }
    bluetoothHeadset = null;
    bluetoothDevice = null;
    scoConnectionAttempts = 0;
    // Get a handle to the default local Bluetooth adapter.
    bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
    if (bluetoothAdapter == null) {
        Log.w(TAG, "Device does not support Bluetooth");
        return;
    }
    // Ensure that the device supports use of BT SCO audio for off call use cases.
    if (!audioManager.isBluetoothScoAvailableOffCall()) {
        Log.e(TAG, "Bluetooth SCO audio is not available off call");
        return;
    }
    logBluetoothAdapterInfo(bluetoothAdapter);
    // Establish a connection to the HEADSET profile (includes both Bluetooth Headset and
    // Hands-Free) proxy object and install a listener.
    if (!getBluetoothProfileProxy(
            apprtcContext, bluetoothServiceListener, BluetoothProfile.HEADSET)) {
        Log.e(TAG, "BluetoothAdapter.getProfileProxy(HEADSET) failed");
        return;
    }
    // Register receivers for BluetoothHeadset change notifications.
    IntentFilter bluetoothHeadsetFilter = new IntentFilter();
    // Register receiver for change in connection state of the Headset profile.
    bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
    // Register receiver for change in audio connection state of the Headset profile.
    bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
    registerReceiver(bluetoothHeadsetReceiver, bluetoothHeadsetFilter);
    Log.d(TAG, "HEADSET profile state: "
            + stateToString(bluetoothAdapter.getProfileConnectionState(BluetoothProfile.HEADSET)));
    Log.d(TAG, "Bluetooth proxy for headset profile has started");
    bluetoothState = State.HEADSET_UNAVAILABLE;
    Log.d(TAG, "start done: BT state=" + bluetoothState);
}

@Before
public void setUp() {
    ShadowLog.stream = System.out;
    context = ShadowApplication.getInstance().getApplicationContext();
    mockedAppRtcAudioManager = mock(AppRTCAudioManager.class);
    mockedAudioManager = mock(AudioManager.class);
    mockedBluetoothHeadset = mock(BluetoothHeadset.class);
    mockedBluetoothDevice = mock(BluetoothDevice.class);
    mockedBluetoothDeviceList = new LinkedList<BluetoothDevice>();

    // Simulate that bluetooth SCO audio is available by default.
    when(mockedAudioManager.isBluetoothScoAvailableOffCall()).thenReturn(true);

    // Create the test object and override protected methods for this test.
    bluetoothManager = new AppRTCBluetoothManager(context, mockedAppRtcAudioManager) {
        @Override
        protected AudioManager getAudioManager(Context context) {
            Log.d(TAG, "getAudioManager");
            return mockedAudioManager;
        }

        @Override
        protected void registerReceiver(BroadcastReceiver receiver, IntentFilter filter) {
            Log.d(TAG, "registerReceiver");
            if (filter.hasAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)
                    && filter.hasAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED)) {
                // Gives access to the real broadcast receiver so the test can use it.
                bluetoothHeadsetStateReceiver = receiver;
            }
        }

        @Override
        protected void unregisterReceiver(BroadcastReceiver receiver) {
            Log.d(TAG, "unregisterReceiver");
            if (receiver == bluetoothHeadsetStateReceiver) {
                bluetoothHeadsetStateReceiver = null;
            }
        }

        @Override
        protected boolean getBluetoothProfileProxy(
                Context context, BluetoothProfile.ServiceListener listener, int profile) {
            Log.d(TAG, "getBluetoothProfileProxy");
            if (profile == BluetoothProfile.HEADSET) {
                // Allows the test to access the real Bluetooth service listener object.
                bluetoothServiceListener = listener;
            }
            return true;
        }

        @Override
        protected boolean hasPermission(Context context, String permission) {
            Log.d(TAG, "hasPermission(" + permission + ")");
            // Ensure that the client asks for Bluetooth permission.
            return (permission == android.Manifest.permission.BLUETOOTH);
        }

        @Override
        protected void logBluetoothAdapterInfo(BluetoothAdapter localAdapter) {
            // Do nothing in tests. No need to mock BluetoothAdapter.
        }
    };
}

private void simulateBluetoothHeadsetConnected() {
    Intent intent = new Intent();
    intent.setAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
    intent.putExtra(BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_CONNECTED);
    bluetoothHeadsetStateReceiver.onReceive(context, intent);
}

private void simulateBluetoothScoConnectionConnected() {
    Intent intent = new Intent();
    intent.setAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
    intent.putExtra(BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_AUDIO_CONNECTED);
    bluetoothHeadsetStateReceiver.onReceive(context, intent);
}

private void simulateBluetoothScoConnectionDisconnected() {
    Intent intent = new Intent();
    intent.setAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
    intent.putExtra(BluetoothHeadset.EXTRA_STATE, BluetoothHeadset.STATE_AUDIO_DISCONNECTED);
    bluetoothHeadsetStateReceiver.onReceive(context, intent);
}

/**
 * Activates components required to detect Bluetooth devices and to enable
 * BT SCO (audio is routed via BT SCO) for the headset profile. The end
 * state will be HEADSET_UNAVAILABLE but a state machine has started which
 * will start a state change sequence where the final outcome depends on
 * if/when the BT headset is enabled.
 * Example of state change sequence when start() is called while BT device
 * is connected and enabled:
 *   UNINITIALIZED --> HEADSET_UNAVAILABLE --> HEADSET_AVAILABLE -->
 *   SCO_CONNECTING --> SCO_CONNECTED <==> audio is now routed via BT SCO.
 * Note that the AppRTCAudioManager is also involved in driving this state
 * change.
 */
public void start() {
  Log.d(TAG, "start");
  if (!hasPermission(apprtcContext, android.Manifest.permission.BLUETOOTH)) {
    Log.w(TAG, "Process (pid=" + Process.myPid() + ") lacks BLUETOOTH permission");
    return;
  }
  if (bluetoothState != State.UNINITIALIZED) {
    Log.w(TAG, "Invalid BT state");
    return;
  }
  bluetoothHeadset = null;
  bluetoothDevice = null;
  scoConnectionAttempts = 0;
  // Get a handle to the default local Bluetooth adapter.
  bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
  if (bluetoothAdapter == null) {
    Log.w(TAG, "Device does not support Bluetooth");
    return;
  }
  // Ensure that the device supports use of BT SCO audio for off call use cases.
  if (!audioManager.isBluetoothScoAvailableOffCall()) {
    Log.e(TAG, "Bluetooth SCO audio is not available off call");
    return;
  }
  logBluetoothAdapterInfo(bluetoothAdapter);
  // Establish a connection to the HEADSET profile (includes both Bluetooth Headset and
  // Hands-Free) proxy object and install a listener.
  if (!getBluetoothProfileProxy(
          apprtcContext, bluetoothServiceListener, BluetoothProfile.HEADSET)) {
    Log.e(TAG, "BluetoothAdapter.getProfileProxy(HEADSET) failed");
    return;
  }
  // Register receivers for BluetoothHeadset change notifications.
  IntentFilter bluetoothHeadsetFilter = new IntentFilter();
  // Register receiver for change in connection state of the Headset profile.
  bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
  // Register receiver for change in audio connection state of the Headset profile.
  bluetoothHeadsetFilter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED);
  registerReceiver(bluetoothHeadsetReceiver, bluetoothHeadsetFilter);
  Log.d(TAG, "HEADSET profile state: "
          + stateToString(bluetoothAdapter.getProfileConnectionState(BluetoothProfile.HEADSET)));
  Log.d(TAG, "Bluetooth proxy for headset profile has started");
  bluetoothState = State.HEADSET_UNAVAILABLE;
  Log.d(TAG, "start done: BT state=" + bluetoothState);
}

public void registerBtConnection() {
    Log.d(TAG, "Register BT connection");
    mContext.registerReceiver(mBtReceiver, new IntentFilter(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED));
}

@Override
public void onCreate() {
    super.onCreate();
    FileLog.d("=============== VoIPService STARTING ===============");
    AudioManager am = (AudioManager) getSystemService(AUDIO_SERVICE);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1 && am.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER)!=null) {
        int outFramesPerBuffer = Integer.parseInt(am.getProperty(AudioManager.PROPERTY_OUTPUT_FRAMES_PER_BUFFER));
        VoIPController.setNativeBufferSize(outFramesPerBuffer);
    } else {
        VoIPController.setNativeBufferSize(AudioTrack.getMinBufferSize(48000, AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_16BIT) / 2);
    }
    updateServerConfig();
    try {
        controller = createController();
        controller.setConnectionStateListener(this);

        cpuWakelock = ((PowerManager) getSystemService(POWER_SERVICE)).newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "telegram-voip");
        cpuWakelock.acquire();

        btAdapter=am.isBluetoothScoAvailableOffCall() ? BluetoothAdapter.getDefaultAdapter() : null;

        IntentFilter filter = new IntentFilter();
        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        filter.addAction(ACTION_HEADSET_PLUG);
        if(btAdapter!=null){
            filter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
            filter.addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
        }
        filter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED);
        registerReceiver(receiver, filter);

        ConnectionsManager.getInstance().setAppPaused(false, false);

        soundPool = new SoundPool(1, AudioManager.STREAM_VOICE_CALL, 0);
        spConnectingId = soundPool.load(this, R.raw.voip_connecting, 1);
        spRingbackID = soundPool.load(this, R.raw.voip_ringback, 1);
        spFailedID = soundPool.load(this, R.raw.voip_failed, 1);
        spEndId = soundPool.load(this, R.raw.voip_end, 1);
        spBusyId = soundPool.load(this, R.raw.voip_busy, 1);

        am.registerMediaButtonEventReceiver(new ComponentName(this, VoIPMediaButtonReceiver.class));

        if(btAdapter!=null && btAdapter.isEnabled()){
            int headsetState=btAdapter.getProfileConnectionState(BluetoothProfile.HEADSET);
            updateBluetoothHeadsetState(headsetState==BluetoothProfile.STATE_CONNECTED);
            if(headsetState==BluetoothProfile.STATE_CONNECTED)
                am.setBluetoothScoOn(true);
            for (StateListener l : stateListeners)
                l.onAudioSettingsChanged();
        }

        NotificationCenter.getInstance().addObserver(this, NotificationCenter.appDidLogout);
    } catch (Exception x) {
        FileLog.e("error initializing voip controller", x);
        callFailed();
    }
}

/**
 * 获取蓝牙耳机对象
 **/
BluetoothHeadset getBluetoothHeadset();