/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.bluetooth.cts;

import static android.Manifest.permission.BLUETOOTH_CONNECT;
import static android.Manifest.permission.BLUETOOTH_PRIVILEGED;

import static org.junit.Assert.assertThrows;

import android.annotation.NonNull;
import android.app.UiAutomation;
import android.bluetooth.BluetoothActivityEnergyInfo;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothStatusCodes;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.test.AndroidTestCase;
import android.util.Log;

import androidx.test.InstrumentationRegistry;

import com.android.compatibility.common.util.ApiLevelUtil;

import java.io.IOException;
import java.time.Duration;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Very basic test, just of the static methods of {@link
 * BluetoothAdapter}.
 */
public class BluetoothAdapterTest extends AndroidTestCase {
    private static final String TAG = "BluetoothAdapterTest";
    private static final int SET_NAME_TIMEOUT = 5000; // ms timeout for setting adapter name

    private boolean mHasBluetooth;
    private ReentrantLock mAdapterNameChangedlock;
    private Condition mConditionAdapterNameChanged;
    private boolean mIsAdapterNameChanged;

    private BluetoothAdapter mAdapter;
    private UiAutomation mUiAutomation;

    @Override
    public void setUp() throws Exception {
        super.setUp();

        mHasBluetooth = getContext().getPackageManager().hasSystemFeature(
                PackageManager.FEATURE_BLUETOOTH);
        if (mHasBluetooth) {
            mAdapter = getContext().getSystemService(BluetoothManager.class).getAdapter();
            assertNotNull(mAdapter);
            mUiAutomation = InstrumentationRegistry.getInstrumentation().getUiAutomation();
            mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);
        }
        mAdapterNameChangedlock = new ReentrantLock();
        mConditionAdapterNameChanged = mAdapterNameChangedlock.newCondition();
        mIsAdapterNameChanged = false;
    }

    @Override
    public void tearDown() throws Exception {
        if (mHasBluetooth) {
            mUiAutomation.dropShellPermissionIdentity();
        }
    }

    public void test_getDefaultAdapter() {
        /*
         * Note: If the target doesn't support Bluetooth at all, then
         * this method should return null.
         */
        if (mHasBluetooth) {
            assertNotNull(BluetoothAdapter.getDefaultAdapter());
        } else {
            assertNull(BluetoothAdapter.getDefaultAdapter());
        }
    }

    public void test_checkBluetoothAddress() {
        // Can't be null.
        assertFalse(BluetoothAdapter.checkBluetoothAddress(null));

        // Must be 17 characters long.
        assertFalse(BluetoothAdapter.checkBluetoothAddress(""));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("0"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:0"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:0"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:0"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:00:"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:00:0"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:00:00:"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:00:00:0"));

        // Must have colons between octets.
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00x00:00:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00.00:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00-00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:00900:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:00:00:00?00"));

        // Hex letters must be uppercase.
        assertFalse(BluetoothAdapter.checkBluetoothAddress("a0:00:00:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("0b:00:00:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:c0:00:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:0d:00:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:e0:00:00:00"));
        assertFalse(BluetoothAdapter.checkBluetoothAddress("00:00:0f:00:00:00"));

        assertTrue(BluetoothAdapter.checkBluetoothAddress("00:00:00:00:00:00"));
        assertTrue(BluetoothAdapter.checkBluetoothAddress("12:34:56:78:9A:BC"));
        assertTrue(BluetoothAdapter.checkBluetoothAddress("DE:F0:FE:DC:B8:76"));
    }

    /** Checks enable(), disable(), getState(), isEnabled() */
    public void test_enableDisable() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }

        for (int i = 0; i < 5; i++) {
            assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
            assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        }
    }

    public void test_getAddress() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }
        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        assertTrue(BluetoothAdapter.checkBluetoothAddress(mAdapter.getAddress()));

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mAdapter.getAddress());

    }

    public void test_setName_getName() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }
        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));

        IntentFilter filter = new IntentFilter();
        filter.addAction(BluetoothAdapter.ACTION_LOCAL_NAME_CHANGED);
        filter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
        mContext.registerReceiver(mAdapterNameChangeReceiver, filter);

        String name = mAdapter.getName();
        assertNotNull(name);

        // Check renaming the adapter
        String genericName = "Generic Device 1";
        mIsAdapterNameChanged = false;
        assertTrue(mAdapter.setName(genericName));
        assertTrue(waitForAdapterNameChange());
        mIsAdapterNameChanged = false;
        assertEquals(genericName, mAdapter.getName());

        // Check setting adapter back to original name
        assertTrue(mAdapter.setName(name));
        assertTrue(waitForAdapterNameChange());
        mIsAdapterNameChanged = false;
        assertEquals(name, mAdapter.getName());

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mAdapter.setName("The name"));
        assertThrows(SecurityException.class, () -> mAdapter.getName());
    }

    public void test_getBondedDevices() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }
        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));

        // empty value is returned when Bluetooth is disabled
        Set<BluetoothDevice> devices = mAdapter.getBondedDevices();
        assertNotNull(devices);
        assertTrue(devices.isEmpty());

        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        devices = mAdapter.getBondedDevices();
        assertNotNull(devices);
        for (BluetoothDevice device : devices) {
            assertTrue(BluetoothAdapter.checkBluetoothAddress(device.getAddress()));
        }

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mAdapter.getBondedDevices());

    }

    public void test_getRemoteDevice() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }
        // getRemoteDevice() should work even with Bluetooth disabled
        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        mUiAutomation.dropShellPermissionIdentity();

        // test bad addresses
        assertThrows(IllegalArgumentException.class, () -> mAdapter.getRemoteDevice((String) null));
        assertThrows(IllegalArgumentException.class, () ->
                mAdapter.getRemoteDevice("00:00:00:00:00:00:00:00"));
        assertThrows(IllegalArgumentException.class, () -> mAdapter.getRemoteDevice((byte[]) null));
        assertThrows(IllegalArgumentException.class, () ->
                mAdapter.getRemoteDevice(new byte[] {0x00, 0x00, 0x00, 0x00, 0x00}));

        // test success
        BluetoothDevice device = mAdapter.getRemoteDevice("00:11:22:AA:BB:CC");
        assertNotNull(device);
        assertEquals("00:11:22:AA:BB:CC", device.getAddress());
        device = mAdapter.getRemoteDevice(
                new byte[] {0x01, 0x02, 0x03, 0x04, 0x05, 0x06});
        assertNotNull(device);
        assertEquals("01:02:03:04:05:06", device.getAddress());
    }

    public void test_getRemoteLeDevice() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }
        // getRemoteLeDevice() should work even with Bluetooth disabled
        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        mUiAutomation.dropShellPermissionIdentity();

        // test bad addresses
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.getRemoteLeDevice((String) null,
                                                 BluetoothDevice.ADDRESS_TYPE_PUBLIC));
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.getRemoteLeDevice("01:02:03:04:05:06:07:08",
                                                 BluetoothDevice.ADDRESS_TYPE_PUBLIC));
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.getRemoteLeDevice("01:02:03:04:05",
                                                 BluetoothDevice.ADDRESS_TYPE_PUBLIC));
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.getRemoteLeDevice("00:01:02:03:04:05",
                                                 BluetoothDevice.ADDRESS_TYPE_RANDOM + 1));
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.getRemoteLeDevice("00:01:02:03:04:05",
                                                 BluetoothDevice.ADDRESS_TYPE_PUBLIC - 1));

        // test success
        BluetoothDevice device = mAdapter.getRemoteLeDevice("00:11:22:AA:BB:CC",
                BluetoothDevice.ADDRESS_TYPE_PUBLIC);
        assertNotNull(device);
        assertEquals("00:11:22:AA:BB:CC", device.getAddress());
        device = mAdapter.getRemoteLeDevice("01:02:03:04:05:06",
                BluetoothDevice.ADDRESS_TYPE_RANDOM);
        assertNotNull(device);
        assertEquals("01:02:03:04:05:06", device.getAddress());
    }

    public void test_isLeAudioSupported() throws IOException {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }
        assertNotSame(BluetoothStatusCodes.ERROR_UNKNOWN, mAdapter.isLeAudioSupported());
    }

    public void test_isLeAudioBroadcastSourceSupported() throws IOException {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }
        assertNotSame(BluetoothStatusCodes.ERROR_UNKNOWN,
                mAdapter.isLeAudioBroadcastSourceSupported());
    }

    public void test_isLeAudioBroadcastAssistantSupported() throws IOException {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }
        assertNotSame(BluetoothStatusCodes.ERROR_UNKNOWN,
                mAdapter.isLeAudioBroadcastAssistantSupported());
    }

    public void test_getMaxConnectedAudioDevices() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }

        // Defined in com.android.bluetooth.btservice.AdapterProperties
        int maxConnectedAudioDevicesLowerBound = 1;
        // Defined in com.android.bluetooth.btservice.AdapterProperties
        int maxConnectedAudioDevicesUpperBound = 5;

        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        assertTrue(mAdapter.getMaxConnectedAudioDevices() >= maxConnectedAudioDevicesLowerBound);
        assertTrue(mAdapter.getMaxConnectedAudioDevices() <= maxConnectedAudioDevicesUpperBound);

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mAdapter.getMaxConnectedAudioDevices());
    }

    public void test_listenUsingRfcommWithServiceRecord() throws IOException {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }

        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        BluetoothServerSocket socket = mAdapter.listenUsingRfcommWithServiceRecord(
                "test", UUID.randomUUID());
        assertNotNull(socket);
        socket.close();

        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mAdapter.listenUsingRfcommWithServiceRecord(
                    "test", UUID.randomUUID()));
    }

    public void test_discoverableTimeout() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth is not present.
            return;
        }

        Duration minutes = Duration.ofMinutes(2);

        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertEquals(null, mAdapter.getDiscoverableTimeout());
        assertEquals(BluetoothStatusCodes.ERROR_BLUETOOTH_NOT_ENABLED,
                mAdapter.setDiscoverableTimeout(minutes));

        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        TestUtils.adoptPermissionAsShellUid(BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED);
        assertThrows(IllegalArgumentException.class, () -> mAdapter.setDiscoverableTimeout(
                Duration.ofDays(25000)));
        assertEquals(BluetoothStatusCodes.SUCCESS,
                mAdapter.setDiscoverableTimeout(minutes));
        assertEquals(minutes, mAdapter.getDiscoverableTimeout());
    }

    public void test_getConnectionState() {
        if (!mHasBluetooth) return;

        // Verify return value if Bluetooth is not enabled
        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        assertEquals(BluetoothProfile.STATE_DISCONNECTED, mAdapter.getConnectionState());
    }

    public void test_getMostRecentlyConnectedDevices() {
        if (!mHasBluetooth) return;

        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));

        // Verify throws SecurityException without permission.BLUETOOTH_PRIVILEGED
        assertThrows(SecurityException.class, () -> mAdapter.getMostRecentlyConnectedDevices());

        // Verify return value if Bluetooth is not enabled
        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        List<BluetoothDevice> devices = mAdapter.getMostRecentlyConnectedDevices();
        assertTrue(devices.isEmpty());
    }

    public void test_getUuids() {
        if (!mHasBluetooth) return;

        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));

        // Verify return value without permission.BLUETOOTH_CONNECT
        mUiAutomation.dropShellPermissionIdentity();
        assertThrows(SecurityException.class, () -> mAdapter.getUuidsList());
        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);

        assertNotNull(mAdapter.getUuidsList());
        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));

        // Verify return value if Bluetooth is not enabled
        assertEquals(0, mAdapter.getUuidsList().size());

    }

    public void test_nameForState() {
        assertEquals("ON", BluetoothAdapter.nameForState(BluetoothAdapter.STATE_ON));
        assertEquals("OFF", BluetoothAdapter.nameForState(BluetoothAdapter.STATE_OFF));
        assertEquals("TURNING_ON",
                BluetoothAdapter.nameForState(BluetoothAdapter.STATE_TURNING_ON));
        assertEquals("TURNING_OFF",
                BluetoothAdapter.nameForState(BluetoothAdapter.STATE_TURNING_OFF));

        assertEquals("BLE_ON", BluetoothAdapter.nameForState(BluetoothAdapter.STATE_BLE_ON));

        // Check value before state range
        for (int state = 0; state < BluetoothAdapter.STATE_OFF; state++) {
            assertEquals("?!?!? (" + state + ")", BluetoothAdapter.nameForState(state));
        }
        // Check value after state range (skip TURNING_OFF)
        for (int state = BluetoothAdapter.STATE_BLE_ON + 2; state < 100; state++) {
            assertEquals("?!?!? (" + state + ")", BluetoothAdapter.nameForState(state));
        }
    }

    public void test_BluetoothConnectionCallback_disconnectReasonText() {
        assertEquals("Reason unknown", BluetoothAdapter.BluetoothConnectionCallback
                .disconnectReasonToString(BluetoothStatusCodes.ERROR_UNKNOWN));
    }

    public void test_registerBluetoothConnectionCallback() {
        if (!mHasBluetooth) return;

        Executor executor = mContext.getMainExecutor();
        BluetoothAdapter.BluetoothConnectionCallback callback =
                new BluetoothAdapter.BluetoothConnectionCallback() {
                    @Override
                    public void onDeviceConnected(@NonNull BluetoothDevice device) {}
                    @Override
                    public void onDeviceDisconnected(BluetoothDevice device, int reason) {}

                };

        // placeholder call for coverage
        callback.onDeviceConnected(null);
        callback.onDeviceDisconnected(null, BluetoothStatusCodes.ERROR_UNKNOWN);

        // Verify parameter
        assertFalse(mAdapter.registerBluetoothConnectionCallback(null, callback));
        assertFalse(mAdapter.registerBluetoothConnectionCallback(executor, null));
        assertFalse(mAdapter.unregisterBluetoothConnectionCallback(null));

        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));

        // Verify throws SecurityException without permission.BLUETOOTH_PRIVILEGED
        assertThrows(SecurityException.class,
                () -> mAdapter.registerBluetoothConnectionCallback(executor, callback));

        mUiAutomation.dropShellPermissionIdentity();
        // Verify throws SecurityException without permission.BLUETOOTH_CONNECT
        assertThrows(SecurityException.class, () ->
                mAdapter.registerBluetoothConnectionCallback(executor, callback));
        assertThrows(SecurityException.class, () ->
                mAdapter.unregisterBluetoothConnectionCallback(callback));
    }

    public void test_requestControllerActivityEnergyInfo() {
        if (!mHasBluetooth) return;

        BluetoothAdapter.OnBluetoothActivityEnergyInfoCallback callback =
                new BluetoothAdapter.OnBluetoothActivityEnergyInfoCallback() {
                    @Override
                    public void onBluetoothActivityEnergyInfoAvailable(
                            BluetoothActivityEnergyInfo info) {
                        assertNotNull(info);
                    }

                    @Override
                    public void onBluetoothActivityEnergyInfoError(int errorCode) {}
                };

        // Verify parameter
        assertThrows(NullPointerException.class,
                () -> mAdapter.requestControllerActivityEnergyInfo(null, callback));
    }

    public void test_clearBluetooth() {
        if (!mHasBluetooth) return;

        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));

        // Verify throws SecurityException without permission.BLUETOOTH_PRIVILEGED
        assertThrows(SecurityException.class, () -> mAdapter.clearBluetooth());
        mUiAutomation.dropShellPermissionIdentity();
        // Verify throws SecurityException without permission.BLUETOOTH_CONNECT
        assertThrows(SecurityException.class, () -> mAdapter.clearBluetooth());

        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT);
        assertTrue(BTAdapterUtils.disableAdapter(mAdapter, mContext));
        // Verify throws RuntimeException when trying to save sysprop for later (permission denied)
        assertThrows(RuntimeException.class, () -> mAdapter.clearBluetooth());
    }

    public void test_BluetoothProfile_getConnectionStateName() {
        if (!mHasBluetooth) return;

        assertEquals("STATE_DISCONNECTED",
                BluetoothProfile.getConnectionStateName(BluetoothProfile.STATE_DISCONNECTED));
        assertEquals("STATE_CONNECTED",
                BluetoothProfile.getConnectionStateName(BluetoothProfile.STATE_CONNECTED));
        assertEquals("STATE_CONNECTING",
                BluetoothProfile.getConnectionStateName(BluetoothProfile.STATE_CONNECTING));
        assertEquals("STATE_CONNECTED",
                BluetoothProfile.getConnectionStateName(BluetoothProfile.STATE_CONNECTED));
        assertEquals("STATE_DISCONNECTING",
                BluetoothProfile.getConnectionStateName(BluetoothProfile.STATE_DISCONNECTING));
        assertEquals("STATE_UNKNOWN",
                BluetoothProfile.getConnectionStateName(BluetoothProfile.STATE_DISCONNECTING + 1));
    }

    public void test_BluetoothProfile_getProfileName() {
        if (!mHasBluetooth) return;
        assertEquals("HEADSET",
                BluetoothProfile.getProfileName(BluetoothProfile.HEADSET));
        assertEquals("A2DP",
                BluetoothProfile.getProfileName(BluetoothProfile.A2DP));
        assertEquals("HID_HOST",
                BluetoothProfile.getProfileName(BluetoothProfile.HID_HOST));
        assertEquals("PAN",
                BluetoothProfile.getProfileName(BluetoothProfile.PAN));
        assertEquals("PBAP",
                BluetoothProfile.getProfileName(BluetoothProfile.PBAP));
        assertEquals("GATT",
                BluetoothProfile.getProfileName(BluetoothProfile.GATT));
        assertEquals("GATT_SERVER",
                BluetoothProfile.getProfileName(BluetoothProfile.GATT_SERVER));
        assertEquals("MAP",
                BluetoothProfile.getProfileName(BluetoothProfile.MAP));
        assertEquals("SAP",
                BluetoothProfile.getProfileName(BluetoothProfile.SAP));
        assertEquals("A2DP_SINK",
                BluetoothProfile.getProfileName(BluetoothProfile.A2DP_SINK));
        assertEquals("AVRCP_CONTROLLER",
                BluetoothProfile.getProfileName(BluetoothProfile.AVRCP_CONTROLLER));
        // assertEquals("AVRCP",
        //         BluetoothProfile.getProfileName(BluetoothProfile.AVRCP));
        assertEquals("HEADSET_CLIENT",
                BluetoothProfile.getProfileName(BluetoothProfile.HEADSET_CLIENT));
        assertEquals("PBAP_CLIENT",
                BluetoothProfile.getProfileName(BluetoothProfile.PBAP_CLIENT));
        assertEquals("MAP_CLIENT",
                BluetoothProfile.getProfileName(BluetoothProfile.MAP_CLIENT));
        assertEquals("HID_DEVICE",
                BluetoothProfile.getProfileName(BluetoothProfile.HID_DEVICE));
        assertEquals("OPP",
                BluetoothProfile.getProfileName(BluetoothProfile.OPP));
        assertEquals("HEARING_AID",
                BluetoothProfile.getProfileName(BluetoothProfile.HEARING_AID));
        assertEquals("LE_AUDIO",
                BluetoothProfile.getProfileName(BluetoothProfile.LE_AUDIO));
        assertEquals("HAP_CLIENT",
                BluetoothProfile.getProfileName(BluetoothProfile.HAP_CLIENT));

        if (!ApiLevelUtil.isAtLeast(Build.VERSION_CODES.TIRAMISU)) {
            return;
        }

        assertEquals("VOLUME_CONTROL",
                BluetoothProfile.getProfileName(BluetoothProfile.VOLUME_CONTROL));
        assertEquals("CSIP_SET_COORDINATOR",
                BluetoothProfile.getProfileName(BluetoothProfile.CSIP_SET_COORDINATOR));
        assertEquals("LE_AUDIO_BROADCAST",
                BluetoothProfile.getProfileName(BluetoothProfile.LE_AUDIO_BROADCAST));
        assertEquals("LE_AUDIO_BROADCAST_ASSISTANT",
                BluetoothProfile.getProfileName(BluetoothProfile.LE_AUDIO_BROADCAST_ASSISTANT));
    }

    public void test_getSetBluetoothHciSnoopLoggingMode() {
        if (!mHasBluetooth) {
            return;
        }

        assertThrows(SecurityException.class, () -> mAdapter
                .setBluetoothHciSnoopLoggingMode(BluetoothAdapter.BT_SNOOP_LOG_MODE_FULL));
        assertThrows(SecurityException.class, () -> mAdapter
                .getBluetoothHciSnoopLoggingMode());

        TestUtils.adoptPermissionAsShellUid(BLUETOOTH_PRIVILEGED);

        assertThrows(IllegalArgumentException.class, () -> mAdapter
                .setBluetoothHciSnoopLoggingMode(-1));

        assertEquals(BluetoothStatusCodes.SUCCESS, mAdapter
                .setBluetoothHciSnoopLoggingMode(BluetoothAdapter.BT_SNOOP_LOG_MODE_FULL));
        assertEquals(mAdapter.getBluetoothHciSnoopLoggingMode(),
                BluetoothAdapter.BT_SNOOP_LOG_MODE_FULL);

        assertEquals(BluetoothStatusCodes.SUCCESS, mAdapter
                .setBluetoothHciSnoopLoggingMode(BluetoothAdapter.BT_SNOOP_LOG_MODE_FILTERED));
        assertEquals(mAdapter.getBluetoothHciSnoopLoggingMode(),
                BluetoothAdapter.BT_SNOOP_LOG_MODE_FILTERED);

        assertEquals(BluetoothStatusCodes.SUCCESS, mAdapter
                .setBluetoothHciSnoopLoggingMode(BluetoothAdapter.BT_SNOOP_LOG_MODE_DISABLED));
        assertEquals(mAdapter.getBluetoothHciSnoopLoggingMode(),
                BluetoothAdapter.BT_SNOOP_LOG_MODE_DISABLED);

    }

    public void test_setPreferredAudioProfiles_getPreferredAudioProfiles() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }
        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        String deviceAddress = "00:11:22:AA:BB:CC";
        BluetoothDevice device = mAdapter.getRemoteDevice(deviceAddress);

        Bundle preferences = new Bundle();
        preferences.putInt(BluetoothAdapter.AUDIO_MODE_OUTPUT_ONLY, BluetoothProfile.HEADSET);

        // Test invalid input
        assertThrows(NullPointerException.class, () ->
                mAdapter.setPreferredAudioProfiles(device, null));
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.setPreferredAudioProfiles(device, preferences));
        assertThrows(NullPointerException.class, () -> mAdapter.getPreferredAudioProfiles(null));

        preferences.putInt(BluetoothAdapter.AUDIO_MODE_OUTPUT_ONLY, BluetoothProfile.HID_HOST);
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.setPreferredAudioProfiles(device, preferences));

        preferences.putInt(BluetoothAdapter.AUDIO_MODE_OUTPUT_ONLY, BluetoothProfile.LE_AUDIO);
        preferences.putInt(BluetoothAdapter.AUDIO_MODE_DUPLEX, BluetoothProfile.A2DP);
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.setPreferredAudioProfiles(device, preferences));

        preferences.putInt(BluetoothAdapter.AUDIO_MODE_DUPLEX, BluetoothProfile.GATT);
        assertThrows(IllegalArgumentException.class,
                () -> mAdapter.setPreferredAudioProfiles(device, preferences));

        preferences.putInt(BluetoothAdapter.AUDIO_MODE_DUPLEX, BluetoothProfile.HEADSET);

        assertThrows(NullPointerException.class, () ->
                mAdapter.setPreferredAudioProfiles(null, preferences));

        // Check what happens when the device is not bonded
        assertTrue(mAdapter.getPreferredAudioProfiles(device).isEmpty());
        assertEquals(BluetoothStatusCodes.ERROR_DEVICE_NOT_BONDED,
                mAdapter.setPreferredAudioProfiles(device, preferences));
    }

    public void test_preferredAudioProfileCallbacks() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }
        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        String deviceAddress = "00:11:22:AA:BB:CC";
        BluetoothDevice device = mAdapter.getRemoteDevice(deviceAddress);

        Executor executor = mContext.getMainExecutor();
        BluetoothAdapter.PreferredAudioProfilesChangedCallback callback =
                new BluetoothAdapter.PreferredAudioProfilesChangedCallback() {
            @Override
            public void onPreferredAudioProfilesChanged(
                    @androidx.annotation.NonNull BluetoothDevice device,
                    @androidx.annotation.NonNull Bundle preferredAudioProfiles, int status) {}
        };

        callback.onPreferredAudioProfilesChanged(device, Bundle.EMPTY,
                BluetoothStatusCodes.SUCCESS);

        assertThrows(NullPointerException.class, () ->
                mAdapter.registerPreferredAudioProfilesChangedCallback(null, callback));
        assertThrows(NullPointerException.class, () ->
                mAdapter.registerPreferredAudioProfilesChangedCallback(executor, null));
        assertThrows(NullPointerException.class, () ->
                mAdapter.unregisterPreferredAudiProfilesChangedCallback(null));

        // This should throw a SecurityException because no BLUETOOTH_PRIVILEGED permission
        assertThrows(SecurityException.class, () ->
                mAdapter.registerPreferredAudioProfilesChangedCallback(executor, callback));
        assertThrows(IllegalArgumentException.class, () ->
                mAdapter.unregisterPreferredAudiProfilesChangedCallback(callback));

        mUiAutomation.adoptShellPermissionIdentity(BLUETOOTH_CONNECT, BLUETOOTH_PRIVILEGED);

        // Try the happy path
        assertEquals(BluetoothStatusCodes.SUCCESS,
                mAdapter.registerPreferredAudioProfilesChangedCallback(executor, callback));
        assertEquals(BluetoothStatusCodes.SUCCESS,
                mAdapter.unregisterPreferredAudiProfilesChangedCallback(callback));
    }

    public void test_notifyPreferredAudioProfileChangeApplied() {
        if (!mHasBluetooth) {
            // Skip the test if bluetooth or companion device are not present.
            return;
        }
        assertTrue(BTAdapterUtils.enableAdapter(mAdapter, mContext));
        String deviceAddress = "00:11:22:AA:BB:CC";
        BluetoothDevice device = mAdapter.getRemoteDevice(deviceAddress);

        assertThrows(NullPointerException.class, () ->
                mAdapter.notifyPreferredAudioProfileChangeApplied(null));


        assertEquals(BluetoothStatusCodes.ERROR_BLUETOOTH_NOT_ALLOWED,
                mAdapter.notifyPreferredAudioProfileChangeApplied(device));
    }

    private static void sleep(long t) {
        try {
            Thread.sleep(t);
        } catch (InterruptedException e) { }
    }

    private boolean waitForAdapterNameChange() {
        mAdapterNameChangedlock.lock();
        try {
            // Wait for the Adapter name to be changed
            while (!mIsAdapterNameChanged) {
                if (!mConditionAdapterNameChanged.await(
                        SET_NAME_TIMEOUT, TimeUnit.MILLISECONDS)) {
                    Log.e(TAG, "Timeout while waiting for adapter name change");
                    break;
                }
            }
        } catch (InterruptedException e) {
            Log.e(TAG, "waitForAdapterNameChange: interrrupted");
        } finally {
            mAdapterNameChangedlock.unlock();
        }
        return mIsAdapterNameChanged;
    }

    private final BroadcastReceiver mAdapterNameChangeReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(BluetoothAdapter.ACTION_LOCAL_NAME_CHANGED)) {
                mAdapterNameChangedlock.lock();
                mIsAdapterNameChanged = true;
                try {
                    mConditionAdapterNameChanged.signal();
                } catch (IllegalMonitorStateException ex) {
                } finally {
                    mAdapterNameChangedlock.unlock();
                }
            }
        }
    };
}