/* * Copyright (C) 2018 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 com.android.settings.sound; import static android.media.AudioManager.STREAM_DEVICES_CHANGED_ACTION; import static android.media.AudioManager.STREAM_MUSIC; import static android.media.AudioManager.STREAM_VOICE_CALL; import static android.media.AudioSystem.DEVICE_OUT_ALL_A2DP; import static android.media.AudioSystem.DEVICE_OUT_ALL_SCO; import static android.media.AudioSystem.DEVICE_OUT_HEARING_AID; import static android.media.MediaRouter.ROUTE_TYPE_REMOTE_DISPLAY; import android.bluetooth.BluetoothDevice; import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.content.pm.PackageManager; import android.media.AudioDeviceCallback; import android.media.AudioDeviceInfo; import android.media.AudioManager; import android.media.MediaRouter; import android.media.MediaRouter.Callback; import android.os.Handler; import android.os.Looper; import android.support.v7.preference.ListPreference; import android.support.v7.preference.Preference; import android.support.v7.preference.PreferenceScreen; import android.text.TextUtils; import android.util.FeatureFlagUtils; import android.util.Log; import com.android.settings.R; import com.android.settings.bluetooth.Utils; import com.android.settings.core.BasePreferenceController; import com.android.settings.core.FeatureFlags; import com.android.settingslib.bluetooth.A2dpProfile; import com.android.settingslib.bluetooth.BluetoothCallback; import com.android.settingslib.bluetooth.CachedBluetoothDevice; import com.android.settingslib.bluetooth.HeadsetProfile; import com.android.settingslib.bluetooth.HearingAidProfile; import com.android.settingslib.bluetooth.LocalBluetoothManager; import com.android.settingslib.bluetooth.LocalBluetoothProfileManager; import com.android.settingslib.core.lifecycle.LifecycleObserver; import com.android.settingslib.core.lifecycle.events.OnStart; import com.android.settingslib.core.lifecycle.events.OnStop; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * Abstract class for audio switcher controller to notify subclass * updating the current status of switcher entry. Subclasses must overwrite * {@link #setActiveBluetoothDevice(BluetoothDevice)} to set the * active device for corresponding profile. */ public abstract class AudioSwitchPreferenceController extends BasePreferenceController implements Preference.OnPreferenceChangeListener, BluetoothCallback, LifecycleObserver, OnStart, OnStop { private static final String TAG = "AudioSwitchPreferenceController"; private static final int INVALID_INDEX = -1; protected final List<BluetoothDevice> mConnectedDevices; protected final AudioManager mAudioManager; protected final MediaRouter mMediaRouter; protected int mSelectedIndex; protected Preference mPreference; protected LocalBluetoothProfileManager mProfileManager; protected AudioSwitchCallback mAudioSwitchPreferenceCallback; private final AudioManagerAudioDeviceCallback mAudioManagerAudioDeviceCallback; private final MediaRouterCallback mMediaRouterCallback; private final WiredHeadsetBroadcastReceiver mReceiver; private final Handler mHandler; private LocalBluetoothManager mLocalBluetoothManager; public interface AudioSwitchCallback { void onPreferenceDataChanged(ListPreference preference); } public AudioSwitchPreferenceController(Context context, String preferenceKey) { super(context, preferenceKey); mAudioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE); mMediaRouter = (MediaRouter) context.getSystemService(Context.MEDIA_ROUTER_SERVICE); mHandler = new Handler(Looper.getMainLooper()); mAudioManagerAudioDeviceCallback = new AudioManagerAudioDeviceCallback(); mReceiver = new WiredHeadsetBroadcastReceiver(); mMediaRouterCallback = new MediaRouterCallback(); mConnectedDevices = new ArrayList<>(); final FutureTask<LocalBluetoothManager> localBtManagerFutureTask = new FutureTask<>( // Avoid StrictMode ThreadPolicy violation () -> Utils.getLocalBtManager(mContext)); try { localBtManagerFutureTask.run(); mLocalBluetoothManager = localBtManagerFutureTask.get(); } catch (InterruptedException | ExecutionException e) { Log.w(TAG, "Error getting LocalBluetoothManager.", e); return; } if (mLocalBluetoothManager == null) { Log.e(TAG, "Bluetooth is not supported on this device"); return; } mProfileManager = mLocalBluetoothManager.getProfileManager(); } /** * Make this method as final, ensure that subclass will checking * the feature flag and they could mistakenly break it via overriding. */ @Override public final int getAvailabilityStatus() { return FeatureFlagUtils.isEnabled(mContext, FeatureFlags.AUDIO_SWITCHER_SETTINGS) && mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH) ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; } @Override public boolean onPreferenceChange(Preference preference, Object newValue) { final String address = (String) newValue; if (!(preference instanceof ListPreference)) { return false; } final ListPreference listPreference = (ListPreference) preference; if (TextUtils.equals(address, mContext.getText(R.string.media_output_default_summary))) { // Switch to default device which address is device name mSelectedIndex = getDefaultDeviceIndex(); setActiveBluetoothDevice(null); listPreference.setSummary(mContext.getText(R.string.media_output_default_summary)); } else { // Switch to BT device which address is hardware address final int connectedDeviceIndex = getConnectedDeviceIndex(address); if (connectedDeviceIndex == INVALID_INDEX) { return false; } final BluetoothDevice btDevice = mConnectedDevices.get(connectedDeviceIndex); mSelectedIndex = connectedDeviceIndex; setActiveBluetoothDevice(btDevice); listPreference.setSummary(btDevice.getAliasName()); } return true; } public abstract void setActiveBluetoothDevice(BluetoothDevice device); @Override public void displayPreference(PreferenceScreen screen) { super.displayPreference(screen); mPreference = screen.findPreference(mPreferenceKey); mPreference.setVisible(false); } @Override public void onStart() { if (mLocalBluetoothManager == null) { Log.e(TAG, "Bluetooth is not supported on this device"); return; } mLocalBluetoothManager.setForegroundActivity(mContext); register(); } @Override public void onStop() { if (mLocalBluetoothManager == null) { Log.e(TAG, "Bluetooth is not supported on this device"); return; } mLocalBluetoothManager.setForegroundActivity(null); unregister(); } /** * Only concerned about whether the local adapter is connected to any profile of any device and * are not really concerned about which profile. */ @Override public void onConnectionStateChanged(CachedBluetoothDevice cachedDevice, int state) { } @Override public void onActiveDeviceChanged(CachedBluetoothDevice activeDevice, int bluetoothProfile) { updateState(mPreference); } @Override public void onAudioModeChanged() { updateState(mPreference); } @Override public void onProfileConnectionStateChanged(CachedBluetoothDevice cachedDevice, int state, int bluetoothProfile) { updateState(mPreference); } @Override public void onBluetoothStateChanged(int bluetoothState) { } /** * The local Bluetooth adapter has started the remote device discovery process. */ @Override public void onScanningStateChanged(boolean started) { } /** * Indicates a change in the bond state of a remote * device. For example, if a device is bonded (paired). */ @Override public void onDeviceAdded(CachedBluetoothDevice cachedDevice) { updateState(mPreference); } @Override public void onDeviceDeleted(CachedBluetoothDevice cachedDevice) { } @Override public void onDeviceBondStateChanged(CachedBluetoothDevice cachedDevice, int bondState) { } public void setCallback(AudioSwitchCallback callback) { mAudioSwitchPreferenceCallback = callback; } protected boolean isStreamFromOutputDevice(int streamType, int device) { return (device & mAudioManager.getDevicesForStream(streamType)) != 0; } /** * get hands free profile(HFP) connected device */ protected List<BluetoothDevice> getConnectedHfpDevices() { final List<BluetoothDevice> connectedDevices = new ArrayList<>(); final HeadsetProfile hfpProfile = mProfileManager.getHeadsetProfile(); if (hfpProfile == null) { return connectedDevices; } final List<BluetoothDevice> devices = hfpProfile.getConnectedDevices(); for (BluetoothDevice device : devices) { if (device.isConnected()) { connectedDevices.add(device); } } return connectedDevices; } /** * get A2dp connected device */ protected List<BluetoothDevice> getConnectedA2dpDevices() { final List<BluetoothDevice> connectedDevices = new ArrayList<>(); final A2dpProfile a2dpProfile = mProfileManager.getA2dpProfile(); if (a2dpProfile == null) { return connectedDevices; } final List<BluetoothDevice> devices = a2dpProfile.getConnectedDevices(); for (BluetoothDevice device : devices) { if (device.isConnected()) { connectedDevices.add(device); } } return connectedDevices; } /** * get hearing aid profile connected device, exclude other devices with same hiSyncId. */ protected List<BluetoothDevice> getConnectedHearingAidDevices() { final List<BluetoothDevice> connectedDevices = new ArrayList<>(); final HearingAidProfile hapProfile = mProfileManager.getHearingAidProfile(); if (hapProfile == null) { return connectedDevices; } final List<Long> devicesHiSyncIds = new ArrayList<>(); final List<BluetoothDevice> devices = hapProfile.getConnectedDevices(); for (BluetoothDevice device : devices) { final long hiSyncId = hapProfile.getHiSyncId(device); // device with same hiSyncId should not be shown in the UI. // So do not add it into connectedDevices. if (!devicesHiSyncIds.contains(hiSyncId) && device.isConnected()) { devicesHiSyncIds.add(hiSyncId); connectedDevices.add(device); } } return connectedDevices; } /** * According to different stream and output device, find the active device from * the corresponding profile. Hearing aid device could stream both STREAM_MUSIC * and STREAM_VOICE_CALL. * * @param streamType the type of audio streams. * @return the active device. Return null if the active device is current device * or streamType is not STREAM_MUSIC or STREAM_VOICE_CALL. */ protected BluetoothDevice findActiveDevice(int streamType) { if (streamType != STREAM_MUSIC && streamType != STREAM_VOICE_CALL) { return null; } if (isStreamFromOutputDevice(STREAM_MUSIC, DEVICE_OUT_ALL_A2DP)) { return mProfileManager.getA2dpProfile().getActiveDevice(); } else if (isStreamFromOutputDevice(STREAM_VOICE_CALL, DEVICE_OUT_ALL_SCO)) { return mProfileManager.getHeadsetProfile().getActiveDevice(); } else if (isStreamFromOutputDevice(streamType, DEVICE_OUT_HEARING_AID)) { // The first element is the left active device; the second element is // the right active device. And they will have same hiSyncId. If either // or both side is not active, it will be null on that position. List<BluetoothDevice> activeDevices = mProfileManager.getHearingAidProfile().getActiveDevices(); for (BluetoothDevice btDevice : activeDevices) { if (btDevice != null && mConnectedDevices.contains(btDevice)) { // also need to check mConnectedDevices, because one of // the device(same hiSyncId) might not be shown in the UI. return btDevice; } } } return null; } int getDefaultDeviceIndex() { // Default device is after all connected devices. return mConnectedDevices.size(); } void setupPreferenceEntries(CharSequence[] mediaOutputs, CharSequence[] mediaValues, BluetoothDevice activeDevice) { // default to current device mSelectedIndex = getDefaultDeviceIndex(); // default device is after all connected devices. mediaOutputs[mSelectedIndex] = mContext.getText(R.string.media_output_default_summary); // use default device name as address mediaValues[mSelectedIndex] = mContext.getText(R.string.media_output_default_summary); for (int i = 0, size = mConnectedDevices.size(); i < size; i++) { final BluetoothDevice btDevice = mConnectedDevices.get(i); mediaOutputs[i] = btDevice.getAliasName(); mediaValues[i] = btDevice.getAddress(); if (btDevice.equals(activeDevice)) { // select the active connected device. mSelectedIndex = i; } } } void setPreference(CharSequence[] mediaOutputs, CharSequence[] mediaValues, Preference preference) { final ListPreference listPreference = (ListPreference) preference; listPreference.setEntries(mediaOutputs); listPreference.setEntryValues(mediaValues); listPreference.setValueIndex(mSelectedIndex); listPreference.setSummary(mediaOutputs[mSelectedIndex]); mAudioSwitchPreferenceCallback.onPreferenceDataChanged(listPreference); } private int getConnectedDeviceIndex(String hardwareAddress) { if (mConnectedDevices != null) { for (int i = 0, size = mConnectedDevices.size(); i < size; i++) { final BluetoothDevice btDevice = mConnectedDevices.get(i); if (TextUtils.equals(btDevice.getAddress(), hardwareAddress)) { return i; } } } return INVALID_INDEX; } private void register() { mLocalBluetoothManager.getEventManager().registerCallback(this); mAudioManager.registerAudioDeviceCallback(mAudioManagerAudioDeviceCallback, mHandler); mMediaRouter.addCallback(ROUTE_TYPE_REMOTE_DISPLAY, mMediaRouterCallback); // Register for misc other intent broadcasts. IntentFilter intentFilter = new IntentFilter(Intent.ACTION_HEADSET_PLUG); intentFilter.addAction(STREAM_DEVICES_CHANGED_ACTION); mContext.registerReceiver(mReceiver, intentFilter); } private void unregister() { mLocalBluetoothManager.getEventManager().unregisterCallback(this); mAudioManager.unregisterAudioDeviceCallback(mAudioManagerAudioDeviceCallback); mMediaRouter.removeCallback(mMediaRouterCallback); mContext.unregisterReceiver(mReceiver); } /** Notifications of audio device connection and disconnection events. */ private class AudioManagerAudioDeviceCallback extends AudioDeviceCallback { @Override public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) { updateState(mPreference); } @Override public void onAudioDevicesRemoved(AudioDeviceInfo[] devices) { updateState(mPreference); } } /** Receiver for wired headset plugged and unplugged events. */ private class WiredHeadsetBroadcastReceiver extends BroadcastReceiver { @Override public void onReceive(Context context, Intent intent) { final String action = intent.getAction(); if (AudioManager.ACTION_HEADSET_PLUG.equals(action) || AudioManager.STREAM_DEVICES_CHANGED_ACTION.equals(action)) { updateState(mPreference); } } } /** Callback for cast device events. */ private class MediaRouterCallback extends Callback { @Override public void onRouteSelected(MediaRouter router, int type, MediaRouter.RouteInfo info) { } @Override public void onRouteUnselected(MediaRouter router, int type, MediaRouter.RouteInfo info) { } @Override public void onRouteAdded(MediaRouter router, MediaRouter.RouteInfo info) { if (info != null && !info.isDefault()) { // cast mode updateState(mPreference); } } @Override public void onRouteRemoved(MediaRouter router, MediaRouter.RouteInfo info) { } @Override public void onRouteChanged(MediaRouter router, MediaRouter.RouteInfo info) { if (info != null && !info.isDefault()) { // cast mode updateState(mPreference); } } @Override public void onRouteGrouped(MediaRouter router, MediaRouter.RouteInfo info, MediaRouter.RouteGroup group, int index) { } @Override public void onRouteUngrouped(MediaRouter router, MediaRouter.RouteInfo info, MediaRouter.RouteGroup group) { } @Override public void onRouteVolumeChanged(MediaRouter router, MediaRouter.RouteInfo info) { } } }