Projects >> frameworks_base_disabled >>1046553d0ab3479dbe6fe43ea48b6ad540b6320d

Chunk
Conflicting content 
        mTestUtils.disable(adapter);
    }
<<<<<<< HEAD
=======

    public void testPair() {
        int iterations = BluetoothTestRunner.sPairIterations;
        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
        BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sPairAddress);
        mTestUtils.enable(adapter);

        for (int i = 0; i < iterations; i++) {
            mTestUtils.writeOutput("pair iteration " + (i + 1) + " of " + iterations);
            mTestUtils.pair(adapter, device, BluetoothTestRunner.sPairPasskey,
                    BluetoothTestRunner.sPairPin);
            mTestUtils.unpair(adapter, device);
        }
        mTestUtils.disable(adapter);
    }

    public void testConnectA2dp() {
        int iterations = BluetoothTestRunner.sConnectA2dpIterations;
        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
        BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sA2dpAddress);

        mTestUtils.enable(adapter);
        mTestUtils.pair(adapter, device, BluetoothTestRunner.sPairPasskey,
                BluetoothTestRunner.sPairPin);

        for (int i = 0; i < iterations; i++) {
            mTestUtils.writeOutput("connectA2dp iteration " + (i + 1) + " of " + iterations);
            mTestUtils.connectA2dp(adapter, device);
            mTestUtils.disconnectA2dp(adapter, device);
        }

        // TODO: Unpair from device if device can accept pairing after unpairing
        mTestUtils.disable(adapter);
    }

    public void testConnectHeadset() {
        int iterations = BluetoothTestRunner.sConnectHeadsetIterations;
        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
        BluetoothDevice device = adapter.getRemoteDevice(BluetoothTestRunner.sHeadsetAddress);

        mTestUtils.enable(adapter);
        mTestUtils.pair(adapter, device, BluetoothTestRunner.sPairPasskey,
                BluetoothTestRunner.sPairPin);

        for (int i = 0; i < iterations; i++) {
            mTestUtils.writeOutput("connectHeadset iteration " + (i + 1) + " of " + iterations);
            mTestUtils.connectHeadset(adapter, device);
            mTestUtils.disconnectHeadset(adapter, device);
        }

        // TODO: Unpair from device if device can accept pairing after unpairing
        mTestUtils.disable(adapter);
    }
>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949
}
Solution content 
        mTestUtils.disable(adapter);
    }
}
File
BluetoothStressTest.java
Developer's decision
Version 1
Kind of conflict
Method declaration
Chunk
Conflicting content 
    public static int sEnableIterations = 100;
    public static int sDiscoverableIterations = 1000;
    public static int sScanIterations = 1000;
<<<<<<< HEAD
=======
    public static int sPairIterations = 100;
    public static int sConnectHeadsetIterations = 100;
    public static int sConnectA2dpIterations = 100;

    public static String sPairAddress = "";
    public static String sHeadsetAddress = "";
    public static String sA2dpAddress = "";
>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949

    public static byte[] sPairPin = {'1', '2', '3', '4'};
    public static int sPairPasskey = 123456;
Solution content 
    public static int sEnableIterations = 100;
    public static int sDiscoverableIterations = 1000;
    public static int sScanIterations = 1000;

    @Override
    public TestSuite getAllTests() {
        TestSuite suite = new InstrumentationTestSuite(this);
        suite.addTestSuite(BluetoothStressTest.class);
        return suite;
    }

    @Override
    public ClassLoader getLoader() {
        return BluetoothTestRunner.class.getClassLoader();
    }

    @Override
    public void onCreate(Bundle arguments) {
        super.onCreate(arguments);

        String val = arguments.getString("enable_iterations");
        if (val != null) {
            try {
                sEnableIterations = Integer.parseInt(val);
            } catch (NumberFormatException e) {
                // Invalid argument, fall back to default value
            }
        }

        val = arguments.getString("discoverable_iterations");
        if (val != null) {
            try {
                sDiscoverableIterations = Integer.parseInt(val);
            } catch (NumberFormatException e) {
                // Invalid argument, fall back to default value
            }
        }

        val = arguments.getString("scan_iterations");
        if (val != null) {
            try {
                sScanIterations = Integer.parseInt(val);
            } catch (NumberFormatException e) {
                // Invalid argument, fall back to default value
            }
        }
    }
}
File
BluetoothTestRunner.java
Developer's decision
Manual
Kind of conflict
Attribute
Chunk
Conflicting content 
        }
                // Invalid argument, fall back to default value
            }
        }
<<<<<<< HEAD
=======

        val = arguments.getString("pair_iterations");
        if (val != null) {
            try {
                sPairIterations = Integer.parseInt(val);
            } catch (NumberFormatException e) {
                // Invalid argument, fall back to default value
            }
        }

        val = arguments.getString("connect_a2dp_iterations");
        if (val != null) {
            try {
                sConnectA2dpIterations = Integer.parseInt(val);
            } catch (NumberFormatException e) {
                // Invalid argument, fall back to default value
            }
        }

        val = arguments.getString("connect_headset_iterations");
        if (val != null) {
            try {
                sConnectHeadsetIterations = Integer.parseInt(val);
            } catch (NumberFormatException e) {
                // Invalid argument, fall back to default value
            }
        }

        val = arguments.getString("pair_address");
        if (val != null) {
            sPairAddress = val;

        val = arguments.getString("headset_address");
        if (val != null) {
            sHeadsetAddress = val;
        }

        val = arguments.getString("a2dp_address");
        if (val != null) {
            sA2dpAddress = val;
        }

        val = arguments.getString("pair_pin");
        if (val != null) {
            sPairPin = BluetoothDevice.convertPinToBytes(val);
        }

        val = arguments.getString("pair_passkey");
        if (val != null) {
            try {
                sPairPasskey = Integer.parseInt(val);
            } catch (NumberFormatException e) {
                // Invalid argument, fall back to default value
            }
        }
>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949
    }
}
Solution content 
                // Invalid argument, fall back to default value
            }
        }
    }
}
File
BluetoothTestRunner.java
Developer's decision
Version 1
Kind of conflict
If statement
Method invocation
Variable
Chunk
Conflicting content 
     */
    private static final int CANCEL_DISCOVERY_TIMEOUT = 5000;

<<<<<<< HEAD
    private static final int DISCOVERY_STARTED_FLAG = 1;
    private static final int DISCOVERY_FINISHED_FLAG = 1 << 1;
    private static final int SCAN_MODE_NONE_FLAG = 1 << 2;
    private static final int SCAN_MODE_CONNECTABLE_FLAG = 1 << 3;
    private static final int SCAN_MODE_CONNECTABLE_DISCOVERABLE_FLAG = 1 << 4;
    private static final int STATE_OFF_FLAG = 1 << 5;
    private static final int STATE_TURNING_ON_FLAG = 1 << 6;
    private static final int STATE_ON_FLAG = 1 << 7;
    private static final int STATE_TURNING_OFF_FLAG = 1 << 8;
=======
    /**
     * Timeout for {@link BluetoothDevice#createBond()} in ms.
     */
    private static final int PAIR_TIMEOUT = 20000;

    /**
     * Timeout for {@link BluetoothDevice#removeBond()} in ms.
     */
    private static final int UNPAIR_TIMEOUT = 20000;

    /**
     * Timeout for {@link BluetoothA2dp#connectSink(BluetoothDevice)} in ms.
     */
    private static final int CONNECT_A2DP_TIMEOUT = 20000;

    /**
     * Timeout for {@link BluetoothA2dp#disconnectSink(BluetoothDevice)} in ms.
     */
    private static final int DISCONNECT_A2DP_TIMEOUT = 20000;

    /**
     * Timeout for {@link BluetoothHeadset#connectHeadset(BluetoothDevice)} in ms.
     */
    private static final int CONNECT_HEADSET_TIMEOUT = 20000;

    /**
     * Timeout for {@link BluetoothHeadset#disconnectHeadset(BluetoothDevice)} in ms.
     */
    private static final int DISCONNECT_HEADSET_TIMEOUT = 20000;
>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949

    /**
     * Time between polls in ms.
Solution content 
     */
    private static final int CANCEL_DISCOVERY_TIMEOUT = 5000;

    private static final int DISCOVERY_STARTED_FLAG = 1;
    private static final int DISCOVERY_FINISHED_FLAG = 1 << 1;
    private static final int SCAN_MODE_NONE_FLAG = 1 << 2;
    private static final int SCAN_MODE_CONNECTABLE_FLAG = 1 << 3;
    private static final int SCAN_MODE_CONNECTABLE_DISCOVERABLE_FLAG = 1 << 4;
    private static final int STATE_OFF_FLAG = 1 << 5;
    private static final int STATE_TURNING_ON_FLAG = 1 << 6;
    private static final int STATE_ON_FLAG = 1 << 7;
    private static final int STATE_TURNING_OFF_FLAG = 1 << 8;

    /**
     * Time between polls in ms.
File
BluetoothTestUtils.java
Developer's decision
Version 1
Kind of conflict
Attribute
Comment
Chunk
Conflicting content 
        private static final int HEADSET_STATE_CONNECTED = 1 << 2;

        private int mFiredFlags = 0;
<<<<<<< HEAD
=======
        private int mA2dpFiredFlags = 0;
        private int mHeadsetFiredFlags = 0;
>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949

        @Override
        public void onReceive(Context context, Intent intent) {
Solution content 
        private int mFiredFlags = 0;

        @Override
        public void onReceive(Context context, Intent intent) {
File
BluetoothTestUtils.java
Developer's decision
Version 1
Kind of conflict
Attribute
Chunk
Conflicting content 
                            mFiredFlags |= STATE_TURNING_OFF_FLAG;
                            break;
                    }
<<<<<<< HEAD
=======
                } else if (BluetoothA2dp.ACTION_SINK_STATE_CHANGED.equals(intent.getAction())) {
                    mFiredFlags |= PROFILE_A2DP_FLAG;
                    int state = intent.getIntExtra(BluetoothA2dp.EXTRA_SINK_STATE, -1);
                    assertNotSame(state, -1);
                    switch (state) {
                        case BluetoothA2dp.STATE_DISCONNECTED:
                            mA2dpFiredFlags |= A2DP_STATE_DISCONNECTED;
                            break;
                        case BluetoothA2dp.STATE_CONNECTING:
                            mA2dpFiredFlags |= A2DP_STATE_CONNECTING;
                            break;
                        case BluetoothA2dp.STATE_CONNECTED:
                            mA2dpFiredFlags |= A2DP_STATE_CONNECTED;
                            break;
                        case BluetoothA2dp.STATE_DISCONNECTING:
                            mA2dpFiredFlags |= A2DP_STATE_DISCONNECTING;
                            break;
                        case BluetoothA2dp.STATE_PLAYING:
                            mA2dpFiredFlags |= A2DP_STATE_PLAYING;
                            break;
                    }
                } else if (BluetoothHeadset.ACTION_STATE_CHANGED.equals(intent.getAction())) {
                    mFiredFlags |= PROFILE_HEADSET_FLAG;
                    int state = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE,
                            BluetoothHeadset.STATE_ERROR);
                    assertNotSame(state, BluetoothHeadset.STATE_ERROR);
                    switch (state) {
                        case BluetoothHeadset.STATE_DISCONNECTED:
                            mHeadsetFiredFlags |= HEADSET_STATE_DISCONNECTED;
                            break;
                        case BluetoothHeadset.STATE_CONNECTING:
                            mHeadsetFiredFlags |= HEADSET_STATE_CONNECTING;
                            break;
                        case BluetoothHeadset.STATE_CONNECTED:
                            mHeadsetFiredFlags |= HEADSET_STATE_CONNECTED;
                            break;
                    }
>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949
                }
            }
        }
Solution content 
                            mFiredFlags |= STATE_TURNING_OFF_FLAG;
                            break;
                    }
                }
            }
        }
File
BluetoothTestUtils.java
Developer's decision
Version 1
Kind of conflict
Attribute
If statement
Method invocation
Switch statement
Variable
Chunk
Conflicting content 
            }
        }

<<<<<<< HEAD
        public void resetFiredFlags() {
            synchronized (this) {
                mFiredFlags = 0;
=======
        public int getA2dpFiredFlags() {
            synchronized (this) {
                return mA2dpFiredFlags;
            }
        }

        public int getHeadsetFiredFlags() {
            synchronized (this) {
                return mHeadsetFiredFlags;
            }
        }

        public void resetFiredFlags() {
            synchronized (this) {
                mFiredFlags = 0;
                mA2dpFiredFlags = 0;
                mHeadsetFiredFlags = 0;
>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949
            }
        }
    }
Solution content 
            }
        }

        public void resetFiredFlags() {
            synchronized (this) {
                mFiredFlags = 0;
            }
        }
    }
File
BluetoothTestUtils.java
Developer's decision
Version 1
Kind of conflict
Method declaration
Method signature
Synchronized statement
Chunk
Conflicting content 
            }
        }

<<<<<<< HEAD
        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
        filter.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
        filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
        mContext.registerReceiver(mReceiver, filter);
=======
        mA2dp = new BluetoothA2dp(mContext);
        mHeadset = new BluetoothHeadset(mContext, mHeadsetServiceListener);
        mBluetoothReceiver = getBluetoothReceiver(mContext);
        mReceivers.add(mBluetoothReceiver);
>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949
    }

    public void close() {
Solution content 
            }
        }

        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
        filter.addAction(BluetoothAdapter.ACTION_SCAN_MODE_CHANGED);
        filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
        mContext.registerReceiver(mReceiver, filter);
    }

    public void close() {
File
BluetoothTestUtils.java
Developer's decision
Version 1
Kind of conflict
Attribute
Method invocation
Variable
Chunk
Conflicting content 
    }

<<<<<<< HEAD
=======
    public void pair(BluetoothAdapter adapter, BluetoothDevice device, int passkey, byte[] pin) {
        int mask = PairReceiver.PAIR_FLAG;
        int pairMask = PairReceiver.PAIR_STATE_BONDING | PairReceiver.PAIR_STATE_BONDED;

        PairReceiver pairReceiver = getPairReceiver(mContext, device, passkey, pin);
        mReceivers.add(pairReceiver);

        if (!adapter.isEnabled()) {
            fail("pair() bluetooth not enabled");
        }

        int state = device.getBondState();
        switch (state) {
            case BluetoothDevice.BOND_BONDED:
                assertTrue(adapter.getBondedDevices().contains(device));
                return;
            case BluetoothDevice.BOND_BONDING:
                // Don't check for received intents since we might have missed them.
                mask = pairMask = 0;
                break;
            case BluetoothDevice.BOND_NONE:
                assertFalse(adapter.getBondedDevices().contains(device));
                assertTrue(device.createBond());
                break;
            default:
                fail("pair() invalide state: state=" + state);
        }

        long s = System.currentTimeMillis();
        while (System.currentTimeMillis() - s < PAIR_TIMEOUT) {
            state = device.getBondState();
            if (state == BluetoothDevice.BOND_BONDED) {
                assertTrue(adapter.getBondedDevices().contains(device));
                if ((pairReceiver.getFiredFlags() & mask) == mask
                        && (pairReceiver.getPairFiredFlags() & pairMask) == pairMask) {
                    writeOutput(String.format("pair() completed in %d ms: device=%s",
                            (System.currentTimeMillis() - s), device));
                    mReceivers.remove(pairReceiver);
                    mContext.unregisterReceiver(pairReceiver);
                    return;
                }
            }
            sleep(POLL_TIME);
        }

        int firedFlags = pairReceiver.getFiredFlags();
        int pairFiredFlags = pairReceiver.getPairFiredFlags();
        pairReceiver.resetFiredFlags();
        fail(String.format("pair() timeout: state=%d (expected %d), flags=0x%x (expected 0x%x), "
                + "pairFlags=0x%x (expected 0x%x)", state, BluetoothDevice.BOND_BONDED, firedFlags,
                mask, pairFiredFlags, pairMask));
    }

    public void unpair(BluetoothAdapter adapter, BluetoothDevice device) {
        int mask = PairReceiver.PAIR_FLAG;
        int pairMask = PairReceiver.PAIR_STATE_NONE;

        PairReceiver pairReceiver = getPairReceiver(mContext, device, 0, null);
        mReceivers.add(pairReceiver);

        if (!adapter.isEnabled()) {
            fail("unpair() bluetooth not enabled");
        }

        int state = device.getBondState();
        switch (state) {
            case BluetoothDevice.BOND_BONDED:
                assertTrue(adapter.getBondedDevices().contains(device));
                assertTrue(device.removeBond());
                break;
            case BluetoothDevice.BOND_BONDING:
                assertTrue(device.removeBond());
                break;
            case BluetoothDevice.BOND_NONE:
                assertFalse(adapter.getBondedDevices().contains(device));
                return;
            default:
                fail("unpair() invalid state: state=" + state);
        }

        assertTrue(device.removeBond());

        long s = System.currentTimeMillis();
        while (System.currentTimeMillis() - s < UNPAIR_TIMEOUT) {
            if (device.getBondState() == BluetoothDevice.BOND_NONE) {
                assertFalse(adapter.getBondedDevices().contains(device));
                if ((pairReceiver.getFiredFlags() & mask) == mask
                       && (pairReceiver.getPairFiredFlags() & pairMask) == pairMask) {
                    writeOutput(String.format("unpair() completed in %d ms: device=%s",
                            (System.currentTimeMillis() - s), device));
                    mReceivers.remove(pairReceiver);
                    mContext.unregisterReceiver(pairReceiver);
                    return;
                }
            }
        }

        int firedFlags = pairReceiver.getFiredFlags();
        int pairFiredFlags = pairReceiver.getPairFiredFlags();
        pairReceiver.resetFiredFlags();
        fail(String.format("unpair() timeout: state=%d (expected %d), flags=0x%x (expected 0x%x), "
                + "pairFlags=0x%x (expected 0x%x)", state, BluetoothDevice.BOND_BONDED, firedFlags,
                mask, pairFiredFlags, pairMask));
    }

    public void connectA2dp(BluetoothAdapter adapter, BluetoothDevice device) {
        int mask = BluetoothReceiver.PROFILE_A2DP_FLAG;
        int a2dpMask1 = (BluetoothReceiver.A2DP_STATE_CONNECTING
                | BluetoothReceiver.A2DP_STATE_CONNECTED | BluetoothReceiver.A2DP_STATE_PLAYING);
        int a2dpMask2 = a2dpMask1 ^ BluetoothReceiver.A2DP_STATE_CONNECTED;
        int a2dpMask3 = a2dpMask1 ^ BluetoothReceiver.A2DP_STATE_PLAYING;
        mBluetoothReceiver.resetFiredFlags();

        if (!adapter.isEnabled()) {
            fail("connectA2dp() bluetooth not enabled");
        }

        if (!adapter.getBondedDevices().contains(device)) {
            fail("connectA2dp() device not paired: device=" + device);
        }

        int state = mA2dp.getSinkState(device);
        switch (state) {
            case BluetoothA2dp.STATE_CONNECTED:
            case BluetoothA2dp.STATE_PLAYING:

                assertTrue(mA2dp.isSinkConnected(device));
                return;
            case BluetoothA2dp.STATE_DISCONNECTING:
            case BluetoothA2dp.STATE_DISCONNECTED:
                assertFalse(mA2dp.isSinkConnected(device));
                assertTrue(mA2dp.connectSink(device));
                break;
            case BluetoothA2dp.STATE_CONNECTING:
                assertFalse(mA2dp.isSinkConnected(device));
                // Don't check for received intents since we might have missed them.
                mask = a2dpMask1 = a2dpMask2 = a2dpMask3 = 0;
                break;
            default:
                fail("connectA2dp() invalid state: state=" + state);
        }

        long s = System.currentTimeMillis();
        while (System.currentTimeMillis() - s < CONNECT_A2DP_TIMEOUT) {
            state = mA2dp.getSinkState(device);
            if (state == BluetoothA2dp.STATE_CONNECTED || state == BluetoothA2dp.STATE_PLAYING) {
                assertTrue(mA2dp.isSinkConnected(device));
                // Check whether STATE_CONNECTING and (STATE_CONNECTED or STATE_PLAYING) intents
                // have fired if we are checking if intents should be fired.
                int firedFlags = mBluetoothReceiver.getFiredFlags();
                int a2dpFiredFlags = mBluetoothReceiver.getA2dpFiredFlags();
                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask
                        && ((a2dpFiredFlags & a2dpMask1) == a2dpMask1
                                || (a2dpFiredFlags & a2dpMask2) == a2dpMask2
                                || (a2dpFiredFlags & a2dpMask3) == a2dpMask3)) {
                    mBluetoothReceiver.resetFiredFlags();
                    writeOutput(String.format("connectA2dp() completed in %d ms: device=%s",
                            (System.currentTimeMillis() - s), device));
                    return;
                }
            }
            sleep(POLL_TIME);
        }

        int firedFlags = mBluetoothReceiver.getFiredFlags();
        int a2dpFiredFlags = mBluetoothReceiver.getA2dpFiredFlags();
        mBluetoothReceiver.resetFiredFlags();
        fail(String.format("connectA2dp() timeout: state=%d (expected %d or %d), "
                + "flags=0x%x (expected 0x%x), a2dpFlags=0x%x (expected 0x%x or 0x%x or 0x%x)",
                state, BluetoothHeadset.STATE_CONNECTED, BluetoothA2dp.STATE_PLAYING, firedFlags,
                mask, a2dpFiredFlags, a2dpMask1, a2dpMask2, a2dpMask3));
    }

    public void disconnectA2dp(BluetoothAdapter adapter, BluetoothDevice device) {
        int mask = BluetoothReceiver.PROFILE_A2DP_FLAG;
        int a2dpMask = (BluetoothReceiver.A2DP_STATE_DISCONNECTING
                | BluetoothReceiver.A2DP_STATE_DISCONNECTED);
        mBluetoothReceiver.resetFiredFlags();

        if (!adapter.isEnabled()) {
            fail("disconnectA2dp() bluetooth not enabled");
        }

        if (!adapter.getBondedDevices().contains(device)) {
            fail("disconnectA2dp() device not paired: device=" + device);
        }

        int state = mA2dp.getSinkState(device);
        switch (state) {
            case BluetoothA2dp.STATE_DISCONNECTED:
                assertFalse(mA2dp.isSinkConnected(device));
                return;
            case BluetoothA2dp.STATE_CONNECTED:
            case BluetoothA2dp.STATE_PLAYING:
                assertTrue(mA2dp.isSinkConnected(device));
                assertTrue(mA2dp.disconnectSink(device));
                break;
            case BluetoothA2dp.STATE_CONNECTING:
                assertFalse(mA2dp.isSinkConnected(device));
                assertTrue(mA2dp.disconnectSink(device));
                break;
            case BluetoothA2dp.STATE_DISCONNECTING:
                assertFalse(mA2dp.isSinkConnected(device));
                // Don't check for received intents since we might have missed them.
                mask = a2dpMask = 0;
                break;
            default:
                fail("disconnectA2dp() invalid state: state=" + state);
        }

        long s = System.currentTimeMillis();
        while (System.currentTimeMillis() - s < DISCONNECT_A2DP_TIMEOUT) {
            state = mA2dp.getSinkState(device);
            if (state == BluetoothA2dp.STATE_DISCONNECTED) {
                assertFalse(mA2dp.isSinkConnected(device));
                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask
                        && (mBluetoothReceiver.getA2dpFiredFlags() & a2dpMask) == a2dpMask) {
                    mBluetoothReceiver.resetFiredFlags();
                    writeOutput(String.format("disconnectA2dp() completed in %d ms: device=%s",
                            (System.currentTimeMillis() - s), device));
                    return;
                }
            }
            sleep(POLL_TIME);
        }

        int firedFlags = mBluetoothReceiver.getFiredFlags();
        int a2dpFiredFlags = mBluetoothReceiver.getA2dpFiredFlags();
        mBluetoothReceiver.resetFiredFlags();
        fail(String.format("disconnectA2dp() timeout: state=%d (expected %d), "
                + "flags=0x%x (expected 0x%x), a2dpFlags=0x%x (expected 0x%x)", state,
                BluetoothA2dp.STATE_DISCONNECTED, firedFlags, mask, a2dpFiredFlags, a2dpMask));
    }

    public void connectHeadset(BluetoothAdapter adapter, BluetoothDevice device) {
        int mask = BluetoothReceiver.PROFILE_HEADSET_FLAG;
        int headsetMask = (BluetoothReceiver.HEADSET_STATE_CONNECTING
                | BluetoothReceiver.HEADSET_STATE_CONNECTED);
        mBluetoothReceiver.resetFiredFlags();

        if (!adapter.isEnabled()) {
            fail("connectHeadset() bluetooth not enabled");
        }

        if (!adapter.getBondedDevices().contains(device)) {
            fail("connectHeadset() device not paired: device=" + device);
        }

        while (!mHeadsetServiceListener.isConnected()) {
            sleep(POLL_TIME);
        }

        int state = mHeadset.getState(device);
        switch (state) {
            case BluetoothHeadset.STATE_CONNECTED:
                assertTrue(mHeadset.isConnected(device));
                return;
            case BluetoothHeadset.STATE_DISCONNECTED:
                assertFalse(mHeadset.isConnected(device));
                mHeadset.connectHeadset(device);
                break;
            case BluetoothHeadset.STATE_CONNECTING:
                assertFalse(mHeadset.isConnected(device));
                // Don't check for received intents since we might have missed them.
                mask = headsetMask = 0;
                break;
            case BluetoothHeadset.STATE_ERROR:
                fail("connectHeadset() error state");
                break;
            default:
                fail("connectHeadset() invalid state: state=" + state);
        }

        long s = System.currentTimeMillis();
        while (System.currentTimeMillis() - s < CONNECT_HEADSET_TIMEOUT) {
            state = mHeadset.getState(device);
            if (state == BluetoothHeadset.STATE_CONNECTED) {
                assertTrue(mHeadset.isConnected(device));
                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask
                        && (mBluetoothReceiver.getHeadsetFiredFlags() & headsetMask) == headsetMask) {
                    mBluetoothReceiver.resetFiredFlags();
                    writeOutput(String.format("connectHeadset() completed in %d ms: device=%s",
                            (System.currentTimeMillis() - s), device));
                    return;
                }
            }
            sleep(POLL_TIME);
        }

        int firedFlags = mBluetoothReceiver.getFiredFlags();
        int headsetFiredFlags = mBluetoothReceiver.getHeadsetFiredFlags();
        mBluetoothReceiver.resetFiredFlags();
        fail(String.format("connectHeadset() timeout: state=%d (expected %d), "
                + "flags=0x%x (expected 0x%x), headsetFlags=0x%s (expected 0x%x)", state,
                BluetoothHeadset.STATE_CONNECTED, firedFlags, mask, headsetFiredFlags,
                headsetMask));
    }
    public void disconnectHeadset(BluetoothAdapter adapter, BluetoothDevice device) {
        int mask = BluetoothReceiver.PROFILE_HEADSET_FLAG;
        int headsetMask = BluetoothReceiver.HEADSET_STATE_DISCONNECTED;
        mBluetoothReceiver.resetFiredFlags();

        if (!adapter.isEnabled()) {
            fail("disconnectHeadset() bluetooth not enabled");
        }

        if (!adapter.getBondedDevices().contains(device)) {
            fail("disconnectHeadset() device not paired: device=" + device);
        }

        while (!mHeadsetServiceListener.isConnected()) {
            sleep(POLL_TIME);
        }

        int state = mHeadset.getState(device);
        switch (state) {
            case BluetoothHeadset.STATE_CONNECTED:
                mHeadset.disconnectHeadset(device);
                break;
            case BluetoothHeadset.STATE_CONNECTING:
                mHeadset.disconnectHeadset(device);
                break;
            case BluetoothHeadset.STATE_DISCONNECTED:
                return;
            case BluetoothHeadset.STATE_ERROR:
                fail("disconnectHeadset() error state");
                break;
            default:
                fail("disconnectHeadset() invalid state: state=" + state);
        }

        long s = System.currentTimeMillis();
        while (System.currentTimeMillis() - s < DISCONNECT_HEADSET_TIMEOUT) {
            state = mHeadset.getState(device);
            if (state == BluetoothHeadset.STATE_DISCONNECTED) {
                assertFalse(mHeadset.isConnected(device));
                if ((mBluetoothReceiver.getFiredFlags() & mask) == mask
                        && (mBluetoothReceiver.getHeadsetFiredFlags() & headsetMask) == headsetMask) {
                    mBluetoothReceiver.resetFiredFlags();
                    writeOutput(String.format("disconnectHeadset() completed in %d ms: device=%s",
                            (System.currentTimeMillis() - s), device));
                    return;
                }
            }
            sleep(POLL_TIME);
        }

        int firedFlags = mBluetoothReceiver.getFiredFlags();
        int headsetFiredFlags = mBluetoothReceiver.getHeadsetFiredFlags();
        mBluetoothReceiver.resetFiredFlags();
        fail(String.format("disconnectHeadset() timeout: state=%d (expected %d), "
                + "flags=0x%x (expected 0x%x), headsetFlags=0x%s (expected 0x%x)", state,
                BluetoothHeadset.STATE_DISCONNECTED, firedFlags, mask, headsetFiredFlags,
                headsetMask));
    }

>>>>>>> 86bf0c7b69856124feb41fb1a938dce1f6695949
    public void writeOutput(String s) {
        Log.i(mTag, s);
        if (mOutputWriter == null) {
Solution content 
    }

    public void writeOutput(String s) {
        Log.i(mTag, s);
        if (mOutputWriter == null) {
File
BluetoothTestUtils.java
Developer's decision
Version 1
Kind of conflict
Method declaration