| Chunk |
|---|
| Conflicting content |
|---|
} else {
if (mHeadsetService.getPriority(mDevice) ==
BluetoothHeadset.PRIORITY_AUTO_CONNECT &&
<<<<<<< HEAD
mHeadsetService.getDevicesMatchingConnectionStates(
new int[] {BluetoothProfile.STATE_CONNECTED,
BluetoothProfile.STATE_CONNECTING,
BluetoothProfile.STATE_DISCONNECTING}).size() == 0) {
mHeadsetService.connect(mDevice);
=======
!mHeadsetService.isConnected(mDevice)) {
Log.i(TAG, "Headset:Auto Connect Profiles");
mHeadsetService.connectHeadset(mDevice);
>>>>>>> 70a68f9544426fa47ba7284d80a95807e820e17a
}
if (mA2dpService != null &&
mA2dpService.getPriority(mDevice) == |
| Solution content |
|---|
} else {
if (mHeadsetService.getPriority(mDevice) ==
BluetoothHeadset.PRIORITY_AUTO_CONNECT &&
mHeadsetService.getDevicesMatchingConnectionStates(
new int[] {BluetoothProfile.STATE_CONNECTED,
BluetoothProfile.STATE_CONNECTING,
BluetoothProfile.STATE_DISCONNECTING}).size() == 0) {
mHeadsetService.connect(mDevice);
}
if (mA2dpService != null &&
mA2dpService.getPriority(mDevice) == |
| File |
|---|
| BluetoothDeviceProfileState.java |
| Developer's decision |
|---|
| Version 1 |
| Kind of conflict |
|---|
| Method invocation |
| Chunk |
|---|
| Conflicting content |
|---|
if (mA2dpService != null &&
mA2dpService.getPriority(mDevice) ==
BluetoothA2dp.PRIORITY_AUTO_CONNECT &&
<<<<<<< HEAD
mA2dpService.getDevicesMatchingConnectionStates(
new int[] {BluetoothA2dp.STATE_CONNECTED,
BluetoothProfile.STATE_CONNECTING,
BluetoothProfile.STATE_DISCONNECTING}).size() == 0) {
mA2dpService.connect(mDevice);
}
if (mService.getInputDevicePriority(mDevice) ==
BluetoothInputDevice.PRIORITY_AUTO_CONNECT) {
mService.connectInputDevice(mDevice);
=======
mA2dpService.getConnectedSinks().length == 0) {
Log.i(TAG, "A2dp:Auto Connect Profiles");
mA2dpService.connectSink(mDevice);
>>>>>>> 70a68f9544426fa47ba7284d80a95807e820e17a
}
}
break; |
| Solution content |
|---|
break;
}
if (mA2dpService != null &&
mA2dpService.getPriority(mDevice) ==
BluetoothA2dp.PRIORITY_AUTO_CONNECT &&
mA2dpService.getDevicesMatchingConnectionStates(
new int[] {BluetoothA2dp.STATE_CONNECTED,
BluetoothProfile.STATE_CONNECTING,
BluetoothProfile.STATE_DISCONNECTING}).size() == 0) {
mA2dpService.connect(mDevice);
}
if (mService.getInputDevicePriority(mDevice) ==
BluetoothInputDevice.PRIORITY_AUTO_CONNECT) {
mService.connectInputDevice(mDevice);
}
}
break;
case TRANSITION_TO_STABLE:
// ignore.
break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
}
private class OutgoingHandsfree extends HierarchicalState {
private boolean mStatus = false;
private int mCommand;
@Override
protected void enter() {
Log.i(TAG, "Entering OutgoingHandsfree state with: " + getCurrentMessage().what);
mCommand = getCurrentMessage().what;
if (mCommand != CONNECT_HFP_OUTGOING &&
mCommand != DISCONNECT_HFP_OUTGOING) {
Log.e(TAG, "Error: OutgoingHandsfree state with command:" + mCommand);
}
mStatus = processCommand(mCommand);
if (!mStatus) {
sendMessage(TRANSITION_TO_STABLE);
mService.sendProfileStateMessage(BluetoothProfileState.HFP,
BluetoothProfileState.TRANSITION_TO_STABLE);
}
}
@Override
protected boolean processMessage(Message message) {
log("OutgoingHandsfree State -> Processing Message: " + message.what);
Message deferMsg = new Message();
int command = message.what;
switch(command) {
case CONNECT_HFP_OUTGOING:
if (command != mCommand) {
// Disconnect followed by a connect - defer
deferMessage(message);
}
break;
case CONNECT_HFP_INCOMING:
if (mCommand == CONNECT_HFP_OUTGOING) {
// Cancel outgoing connect, accept incoming
cancelCommand(CONNECT_HFP_OUTGOING);
transitionTo(mIncomingHandsfree);
} else {
// We have done the disconnect but we are not
// sure which state we are in at this point.
deferMessage(message);
}
break;
case CONNECT_A2DP_INCOMING:
// accept incoming A2DP, retry HFP_OUTGOING
transitionTo(mIncomingA2dp);
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break;
case CONNECT_A2DP_OUTGOING:
deferMessage(message);
break;
case DISCONNECT_HFP_OUTGOING:
if (mCommand == CONNECT_HFP_OUTGOING) {
// Cancel outgoing connect
cancelCommand(CONNECT_HFP_OUTGOING);
processCommand(DISCONNECT_HFP_OUTGOING);
}
// else ignore
break;
case DISCONNECT_HFP_INCOMING:
// When this happens the socket would be closed and the headset
// state moved to DISCONNECTED, cancel the outgoing thread.
// if it still is in CONNECTING state
cancelCommand(CONNECT_HFP_OUTGOING);
break;
case DISCONNECT_A2DP_OUTGOING:
deferMessage(message);
break;
case DISCONNECT_A2DP_INCOMING:
// Bluez will handle the disconnect. If because of this the outgoing
// handsfree connection has failed, then retry.
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break;
case CONNECT_HID_OUTGOING:
case DISCONNECT_HID_OUTGOING:
deferMessage(message);
break;
case CONNECT_HID_INCOMING:
transitionTo(mIncomingHid);
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break;
case DISCONNECT_HID_INCOMING:
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break; // ignore
case DISCONNECT_PBAP_OUTGOING:
case UNPAIR:
case AUTO_CONNECT_PROFILES:
deferMessage(message);
break;
case TRANSITION_TO_STABLE:
transitionTo(mBondedDevice);
break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
}
private class IncomingHandsfree extends HierarchicalState {
private boolean mStatus = false;
private int mCommand;
@Override
protected void enter() {
Log.i(TAG, "Entering IncomingHandsfree state with: " + getCurrentMessage().what);
mCommand = getCurrentMessage().what;
if (mCommand != CONNECT_HFP_INCOMING &&
mCommand != DISCONNECT_HFP_INCOMING) {
}
Log.e(TAG, "Error: IncomingHandsfree state with command:" + mCommand);
}
mStatus = processCommand(mCommand);
if (!mStatus) {
sendMessage(TRANSITION_TO_STABLE);
mService.sendProfileStateMessage(BluetoothProfileState.HFP,
BluetoothProfileState.TRANSITION_TO_STABLE);
}
}
@Override
protected boolean processMessage(Message message) {
log("IncomingHandsfree State -> Processing Message: " + message.what);
switch(message.what) {
case CONNECT_HFP_OUTGOING:
deferMessage(message);
break;
case CONNECT_HFP_INCOMING:
// Ignore
Log.e(TAG, "Error: Incoming connection with a pending incoming connection");
break;
case CONNECT_A2DP_INCOMING:
// Serialize the commands.
deferMessage(message);
break;
case CONNECT_A2DP_OUTGOING:
deferMessage(message);
case DISCONNECT_HFP_OUTGOING:
// We don't know at what state we are in the incoming HFP connection state.
// We can be changing from DISCONNECTED to CONNECTING, or
// from CONNECTING to CONNECTED, so serializing this command is
// the safest option.
deferMessage(message);
break;
case DISCONNECT_HFP_INCOMING:
// Nothing to do here, we will already be DISCONNECTED
// by this point.
break;
case DISCONNECT_A2DP_OUTGOING:
deferMessage(message);
break;
case DISCONNECT_A2DP_INCOMING:
// Bluez handles incoming A2DP disconnect.
// If this causes incoming HFP to fail, it is more of a headset problem
// since both connections are incoming ones.
break;
case CONNECT_HID_OUTGOING:
case DISCONNECT_HID_OUTGOING:
deferMessage(message);
break;
case CONNECT_HID_INCOMING:
case DISCONNECT_HID_INCOMING:
break; // ignore
case DISCONNECT_PBAP_OUTGOING:
case UNPAIR:
case AUTO_CONNECT_PROFILES:
deferMessage(message);
break;
case TRANSITION_TO_STABLE:
transitionTo(mBondedDevice);
break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
}
private class OutgoingA2dp extends HierarchicalState {
private boolean mStatus = false;
private int mCommand;
@Override
protected void enter() {
Log.i(TAG, "Entering OutgoingA2dp state with: " + getCurrentMessage().what);
mCommand = getCurrentMessage().what;
if (mCommand != CONNECT_A2DP_OUTGOING &&
mCommand != DISCONNECT_A2DP_OUTGOING) {
Log.e(TAG, "Error: OutgoingA2DP state with command:" + mCommand);
}
mStatus = processCommand(mCommand);
if (!mStatus) {
sendMessage(TRANSITION_TO_STABLE);
mService.sendProfileStateMessage(BluetoothProfileState.A2DP,
BluetoothProfileState.TRANSITION_TO_STABLE);
}
}
@Override
protected boolean processMessage(Message message) {
log("OutgoingA2dp State->Processing Message: " + message.what);
Message deferMsg = new Message();
switch(message.what) {
case CONNECT_HFP_OUTGOING:
processCommand(CONNECT_HFP_OUTGOING);
// Don't cancel A2DP outgoing as there is no guarantee it
// will get canceled.
// It might already be connected but we might not have got the
// A2DP_SINK_STATE_CHANGE. Hence, no point disconnecting here.
// The worst case, the connection will fail, retry.
// The same applies to Disconnecting an A2DP connection.
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break;
case CONNECT_HFP_INCOMING:
processCommand(CONNECT_HFP_INCOMING);
// Don't cancel A2DP outgoing as there is no guarantee
// it will get canceled.
// The worst case, the connection will fail, retry.
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break;
case CONNECT_A2DP_INCOMING:
// Bluez will take care of conflicts between incoming and outgoing
// connections.
transitionTo(mIncomingA2dp);
break;
case CONNECT_A2DP_OUTGOING:
// Ignore
break;
case DISCONNECT_HFP_OUTGOING:
deferMessage(message);
break;
case DISCONNECT_HFP_INCOMING:
// At this point, we are already disconnected
// with HFP. Sometimes A2DP connection can
// fail due to the disconnection of HFP. So add a retry
// for the A2DP.
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break;
case DISCONNECT_A2DP_OUTGOING:
deferMessage(message);
break;
case DISCONNECT_A2DP_INCOMING:
// Ignore, will be handled by Bluez
break;
case CONNECT_HID_OUTGOING:
case DISCONNECT_HID_OUTGOING:
deferMessage(message);
break;
case CONNECT_HID_INCOMING:
transitionTo(mIncomingHid);
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break;
case DISCONNECT_HID_INCOMING:
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break; // ignore
case DISCONNECT_PBAP_OUTGOING:
case UNPAIR:
case AUTO_CONNECT_PROFILES:
deferMessage(message);
break;
case TRANSITION_TO_STABLE:
transitionTo(mBondedDevice);
break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
}
private class IncomingA2dp extends HierarchicalState {
private boolean mStatus = false;
break;
private int mCommand;
@Override
protected void enter() {
Log.i(TAG, "Entering IncomingA2dp state with: " + getCurrentMessage().what);
mCommand = getCurrentMessage().what;
if (mCommand != CONNECT_A2DP_INCOMING &&
mCommand != DISCONNECT_A2DP_INCOMING) {
Log.e(TAG, "Error: IncomingA2DP state with command:" + mCommand);
}
mStatus = processCommand(mCommand);
if (!mStatus) {
sendMessage(TRANSITION_TO_STABLE);
mService.sendProfileStateMessage(BluetoothProfileState.A2DP,
BluetoothProfileState.TRANSITION_TO_STABLE);
}
}
@Override
protected boolean processMessage(Message message) {
log("IncomingA2dp State->Processing Message: " + message.what);
Message deferMsg = new Message();
switch(message.what) {
case CONNECT_HFP_OUTGOING:
deferMessage(message);
break;
case CONNECT_HFP_INCOMING:
// Shouldn't happen, but serialize the commands.
deferMessage(message);
break;
case CONNECT_A2DP_INCOMING:
// ignore
break;
case CONNECT_A2DP_OUTGOING:
// Defer message and retry
deferMessage(message);
break;
case DISCONNECT_HFP_OUTGOING:
deferMessage(message);
break;
case DISCONNECT_HFP_INCOMING:
// Shouldn't happen but if does, we can handle it.
// Depends if the headset can handle it.
// Incoming A2DP will be handled by Bluez, Disconnect HFP
// the socket would have already been closed.
// ignore
break;
case DISCONNECT_A2DP_OUTGOING:
deferMessage(message);
break;
case DISCONNECT_A2DP_INCOMING:
// Ignore, will be handled by Bluez
break;
case CONNECT_HID_OUTGOING:
case DISCONNECT_HID_OUTGOING:
deferMessage(message);
break;
case CONNECT_HID_INCOMING:
case DISCONNECT_HID_INCOMING:
break; // ignore
case DISCONNECT_PBAP_OUTGOING:
case UNPAIR:
case AUTO_CONNECT_PROFILES:
deferMessage(message);
break;
case TRANSITION_TO_STABLE:
transitionTo(mBondedDevice);
break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
}
private class OutgoingHid extends HierarchicalState {
private boolean mStatus = false;
private int mCommand;
@Override
protected void enter() {
log("Entering OutgoingHid state with: " + getCurrentMessage().what);
mCommand = getCurrentMessage().what;
if (mCommand != CONNECT_HID_OUTGOING &&
mCommand != DISCONNECT_HID_OUTGOING) {
Log.e(TAG, "Error: OutgoingHid state with command:" + mCommand);
}
mStatus = processCommand(mCommand);
if (!mStatus) sendMessage(TRANSITION_TO_STABLE);
}
@Override
protected boolean processMessage(Message message) {
log("OutgoingHid State->Processing Message: " + message.what);
Message deferMsg = new Message();
switch(message.what) {
// defer all outgoing messages
case CONNECT_HFP_OUTGOING:
case CONNECT_A2DP_OUTGOING:
case CONNECT_HID_OUTGOING:
case DISCONNECT_HFP_OUTGOING:
case DISCONNECT_A2DP_OUTGOING:
case DISCONNECT_HID_OUTGOING:
deferMessage(message);
break;
case CONNECT_HFP_INCOMING:
transitionTo(mIncomingHandsfree);
case CONNECT_A2DP_INCOMING:
transitionTo(mIncomingA2dp);
// Don't cancel HID outgoing as there is no guarantee it
// will get canceled.
// It might already be connected but we might not have got the
// INPUT_DEVICE_STATE_CHANGE. Hence, no point disconnecting here.
// The worst case, the connection will fail, retry.
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
break;
case CONNECT_HID_INCOMING:
// Bluez will take care of the conflicts
transitionTo(mIncomingHid);
break;
case DISCONNECT_HFP_INCOMING:
case DISCONNECT_A2DP_INCOMING:
// At this point, we are already disconnected
// with HFP. Sometimes HID connection can
// fail due to the disconnection of HFP. So add a retry
// for the HID.
if (mStatus) {
deferMsg.what = mCommand;
deferMessage(deferMsg);
}
break;
case DISCONNECT_HID_INCOMING:
// Ignore, will be handled by Bluez
break;
case DISCONNECT_PBAP_OUTGOING:
case UNPAIR:
case AUTO_CONNECT_PROFILES:
deferMessage(message);
break;
case TRANSITION_TO_STABLE:
transitionTo(mBondedDevice);
break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
}
private class IncomingHid extends HierarchicalState {
private boolean mStatus = false;
private int mCommand;
@Override
protected void enter() {
log("Entering IncomingHid state with: " + getCurrentMessage().what);
mCommand = getCurrentMessage().what;
if (mCommand != CONNECT_HID_INCOMING &&
mCommand != DISCONNECT_HID_INCOMING) {
Log.e(TAG, "Error: IncomingHid state with command:" + mCommand);
}
mStatus = processCommand(mCommand);
if (!mStatus) sendMessage(TRANSITION_TO_STABLE);
}
@Override
protected boolean processMessage(Message message) {
log("IncomingHid State->Processing Message: " + message.what);
Message deferMsg = new Message();
switch(message.what) {
case CONNECT_HFP_OUTGOING:
case CONNECT_HFP_INCOMING:
case DISCONNECT_HFP_OUTGOING:
case CONNECT_A2DP_INCOMING:
case CONNECT_A2DP_OUTGOING:
case DISCONNECT_A2DP_OUTGOING:
case CONNECT_HID_OUTGOING:
case CONNECT_HID_INCOMING:
case DISCONNECT_HID_OUTGOING:
deferMessage(message);
break;
case DISCONNECT_HFP_INCOMING:
// Shouldn't happen but if does, we can handle it.
// Depends if the headset can handle it.
// Incoming HID will be handled by Bluez, Disconnect HFP
// the socket would have already been closed.
// ignore
break;
case DISCONNECT_HID_INCOMING:
case DISCONNECT_A2DP_INCOMING:
// Ignore, will be handled by Bluez
break;
case DISCONNECT_PBAP_OUTGOING:
case UNPAIR:
case AUTO_CONNECT_PROFILES:
deferMessage(message);
break;
case TRANSITION_TO_STABLE:
transitionTo(mBondedDevice);
break;
default:
return NOT_HANDLED;
}
return HANDLED;
}
}
synchronized void cancelCommand(int command) {
if (command == CONNECT_HFP_OUTGOING ) {
// Cancel the outgoing thread.
if (mHeadsetService != null) {
mHeadsetService.cancelConnectThread();
}
// HeadsetService is down. Phone process most likely crashed.
// The thread would have got killed.
}
}
synchronized void deferProfileServiceMessage(int command) {
Message msg = new Message();
msg.what = command;
deferMessage(msg);
}
synchronized boolean processCommand(int command) {
Log.i(TAG, "Processing command:" + command);
switch(command) {
case CONNECT_HFP_OUTGOING:
if (mHeadsetService == null) {
deferProfileServiceMessage(command);
} else {
return mHeadsetService.connectHeadsetInternal(mDevice);
}
break;
case CONNECT_HFP_INCOMING:
if (mHeadsetService == null) {
deferProfileServiceMessage(command);
} else if (mHeadsetState == BluetoothHeadset.STATE_CONNECTING) {
return mHeadsetService.acceptIncomingConnect(mDevice);
} else if (mHeadsetState == BluetoothHeadset.STATE_DISCONNECTED) {
return mHeadsetService.createIncomingConnect(mDevice);
}
break;
case CONNECT_A2DP_OUTGOING:
if (mA2dpService != null) {
return mA2dpService.connectSinkInternal(mDevice);
}
break;
case CONNECT_A2DP_INCOMING:
// ignore, Bluez takes care
return true;
case CONNECT_HID_OUTGOING:
return mService.connectInputDeviceInternal(mDevice);
case CONNECT_HID_INCOMING:
return true;
case DISCONNECT_HFP_OUTGOING:
if (mHeadsetService == null) {
deferProfileServiceMessage(command);
} else {
// Disconnect PBAP
// TODO(): Add PBAP to the state machine.
Message m = new Message();
m.what = DISCONNECT_PBAP_OUTGOING;
deferMessage(m);
if (mHeadsetService.getPriority(mDevice) ==
BluetoothHeadset.PRIORITY_AUTO_CONNECT) {
mHeadsetService.setPriority(mDevice, BluetoothHeadset.PRIORITY_ON);
}
return mHeadsetService.disconnectHeadsetInternal(mDevice);
case DISCONNECT_HFP_INCOMING:
// ignore
return true;
case DISCONNECT_A2DP_INCOMING:
// ignore
return true;
case DISCONNECT_A2DP_OUTGOING:
if (mA2dpService != null) {
if (mA2dpService.getPriority(mDevice) ==
BluetoothA2dp.PRIORITY_AUTO_CONNECT) {
mA2dpService.setPriority(mDevice, BluetoothHeadset.PRIORITY_ON);
}
return mA2dpService.disconnectSinkInternal(mDevice);
}
break;
case DISCONNECT_HID_INCOMING:
// ignore
return true;
case DISCONNECT_HID_OUTGOING:
if (mService.getInputDevicePriority(mDevice) ==
BluetoothInputDevice.PRIORITY_AUTO_CONNECT) {
mService.setInputDevicePriority(mDevice, BluetoothInputDevice.PRIORITY_ON);
}
return mService.disconnectInputDeviceInternal(mDevice);
case DISCONNECT_PBAP_OUTGOING:
if (!mPbapServiceConnected) {
deferProfileServiceMessage(command);
} else {
return mPbapService.disconnect();
}
break;
case UNPAIR:
return mService.removeBondInternal(mDevice.getAddress());
default:
Log.e(TAG, "Error: Unknown Command");
}
return false;
}
/*package*/ BluetoothDevice getDevice() {
return mDevice;
}
private void log(String message) {
if (DBG) {
Log.i(TAG, "Device:" + mDevice + " Message:" + message);
}
}
} |
| File |
|---|
| BluetoothDeviceProfileState.java |
| Developer's decision |
|---|
| Manual |
| Kind of conflict |
|---|
| If statement |
| Method invocation |
| Chunk |
|---|
| Conflicting content |
|---|
return false;
}
<<<<<<< HEAD
=======
private void handleConnectionOfOtherProfiles(int command) {
// The white paper recommendations mentions that when there is a
// link loss, it is the responsibility of the remote device to connect.
// Many connect only 1 profile - and they connect the second profile on
// some user action (like play being pressed) and so we need this code.
// Auto Connect code only connects to the last connected device - which
// is useful in cases like when the phone reboots. But consider the
// following case:
// User is connected to the car's phone and A2DP profile.
// User comes to the desk and places the phone in the dock
// (or any speaker or music system or even another headset) and thus
// gets connected to the A2DP profile. User goes back to the car.
// Ideally the car's system is supposed to send incoming connections
// from both Handsfree and A2DP profile. But they don't. The Auto
// connect code, will not work here because we only auto connect to the
// last connected device for that profile which in this case is the dock.
// Now suppose a user is using 2 headsets simultaneously, one for the
// phone profile one for the A2DP profile. If this is the use case, we
// expect the user to use the preference to turn off the A2DP profile in
// the Settings screen for the first headset. Else, after link loss,
// there can be an incoming connection from the first headset which
// might result in the connection of the A2DP profile (if the second
// headset is slower) and thus the A2DP profile on the second headset
// will never get connected.
//
// TODO(): Handle other profiles here.
switch (command) {
case CONNECT_HFP_INCOMING:
// Connect A2DP if there is no incoming connection
// If the priority is OFF - don't auto connect.
// If the priority is AUTO_CONNECT, auto connect code takes care.
if (mA2dpService.getSinkPriority(mDevice) == BluetoothA2dp.PRIORITY_ON) {
Message msg = new Message();
msg.what = CONNECT_OTHER_PROFILES;
msg.arg1 = CONNECT_A2DP_OUTGOING;
sendMessageDelayed(msg, AUTO_CONNECT_DELAY);
}
break;
case CONNECT_A2DP_INCOMING:
// This is again against spec. HFP incoming connections should be made
// before A2DP, so we should not hit this case. But many devices
// don't follow this.
if (mHeadsetService.getPriority(mDevice) == BluetoothHeadset.PRIORITY_ON) {
Message msg = new Message();
msg.what = CONNECT_OTHER_PROFILES;
msg.arg1 = CONNECT_HFP_OUTGOING;
sendMessageDelayed(msg, AUTO_CONNECT_DELAY);
}
break;
default:
break;
}
}
>>>>>>> 70a68f9544426fa47ba7284d80a95807e820e17a
/*package*/ BluetoothDevice getDevice() {
return mDevice; |
| Solution content |
|---|
return false;
}
/*package*/ BluetoothDevice getDevice() {
return mDevice; |
| File |
|---|
| BluetoothDeviceProfileState.java |
| Developer's decision |
|---|
| Version 1 |
| Kind of conflict |
|---|
| Method declaration |