Merge "Move 'Audio Output' to Accessibility hearing device page" into udc-dev

src/com/android/settings/accessibility/AccessibilityAudioRoutingFragment.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2023 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.accessibility;
+
+import static android.os.UserManager.DISALLOW_CONFIG_BLUETOOTH;
+
+import android.app.settings.SettingsEnums;
+
+import com.android.settings.R;
+import com.android.settings.dashboard.RestrictedDashboardFragment;
+import com.android.settings.search.BaseSearchIndexProvider;
+
+/** Settings fragment containing bluetooth audio routing. */
+public class AccessibilityAudioRoutingFragment extends RestrictedDashboardFragment {
+    private static final String TAG = "AccessibilityAudioRoutingFragment";
+
+    public AccessibilityAudioRoutingFragment() {
+        super(DISALLOW_CONFIG_BLUETOOTH);
+    }
+
+    @Override
+    public int getMetricsCategory() {
+        return SettingsEnums.HEARING_AID_AUDIO_ROUTING;
+    }
+
+    @Override
+    protected int getPreferenceScreenResId() {
+        return R.xml.accessibility_audio_routing_fragment;
+    }
+
+    @Override
+    protected String getLogTag() {
+        return TAG;
+    }
+
+    public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
+            new BaseSearchIndexProvider(R.xml.accessibility_audio_routing_fragment);
+}

src/com/android/settings/accessibility/AccessibilityHearingAidPreferenceController.java

@@ -17,7 +17,6 @@
 package com.android.settings.accessibility;
 
 import android.bluetooth.BluetoothAdapter;
-import android.bluetooth.BluetoothDevice;
 import android.bluetooth.BluetoothHapClient;
 import android.bluetooth.BluetoothHearingAid;
 import android.bluetooth.BluetoothLeAudio;
@@ -41,20 +40,14 @@ import com.android.settings.core.BasePreferenceController;
 import com.android.settings.core.SubSettingLauncher;
 import com.android.settingslib.bluetooth.BluetoothCallback;
 import com.android.settingslib.bluetooth.CachedBluetoothDevice;
-import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager;
-import com.android.settingslib.bluetooth.HapClientProfile;
 import com.android.settingslib.bluetooth.HearingAidInfo;
-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.Set;
-import java.util.stream.Collectors;
 
 /**
  * Controller that shows and updates the bluetooth device name
@@ -73,10 +66,8 @@ public class AccessibilityHearingAidPreferenceController extends BasePreferenceC
     };
 
     private final LocalBluetoothManager mLocalBluetoothManager;
-    private final BluetoothAdapter mBluetoothAdapter;
     private final LocalBluetoothProfileManager mProfileManager;
-    private final CachedBluetoothDeviceManager mCachedDeviceManager;
-
+    private final HearingAidHelper mHelper;
     private FragmentManager mFragmentManager;
 
     public AccessibilityHearingAidPreferenceController(Context context, String preferenceKey) {
@@ -84,8 +75,7 @@ public class AccessibilityHearingAidPreferenceController extends BasePreferenceC
         mLocalBluetoothManager = com.android.settings.bluetooth.Utils.getLocalBluetoothManager(
                 context);
         mProfileManager = mLocalBluetoothManager.getProfileManager();
-        mCachedDeviceManager = mLocalBluetoothManager.getCachedDeviceManager();
-        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+        mHelper = new HearingAidHelper(context);
     }
 
     @Override
@@ -96,7 +86,7 @@ public class AccessibilityHearingAidPreferenceController extends BasePreferenceC
 
     @Override
     public int getAvailabilityStatus() {
-        return isHearingAidSupported() ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
+        return mHelper.isHearingAidSupported() ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
     }
 
     @Override
@@ -111,7 +101,7 @@ public class AccessibilityHearingAidPreferenceController extends BasePreferenceC
         // Can't get connected hearing aids when hearing aids related profiles are not ready. The
         // profiles will be ready after the services are connected. Needs to add listener and
         // updates the information when all hearing aids related services are connected.
-        if (isAnyHearingAidRelatedProfilesNotReady()) {
+        if (!mHelper.isAllHearingAidRelatedProfilesReady()) {
             mProfileManager.addServiceListener(this);
         }
     }
@@ -126,7 +116,7 @@ public class AccessibilityHearingAidPreferenceController extends BasePreferenceC
     @Override
     public boolean handlePreferenceTreeClick(Preference preference) {
         if (TextUtils.equals(preference.getKey(), getPreferenceKey())) {
-            final CachedBluetoothDevice device = getConnectedHearingAidDevice();
+            final CachedBluetoothDevice device = mHelper.getConnectedHearingAidDevice();
             if (FeatureFlagUtils.isEnabled(mContext,
                     FeatureFlagUtils.SETTINGS_ACCESSIBILITY_HEARING_AID_PAGE)) {
                 launchHearingAidPage();
@@ -144,10 +134,7 @@ public class AccessibilityHearingAidPreferenceController extends BasePreferenceC
 
     @Override
     public CharSequence getSummary() {
-        if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
-            return mContext.getText(R.string.accessibility_hearingaid_not_connected_summary);
-        }
-        final CachedBluetoothDevice device = getConnectedHearingAidDevice();
+        final CachedBluetoothDevice device = mHelper.getConnectedHearingAidDevice();
         if (device == null) {
             return mContext.getText(R.string.accessibility_hearingaid_not_connected_summary);
         }
@@ -203,7 +190,7 @@ public class AccessibilityHearingAidPreferenceController extends BasePreferenceC
 
     @Override
     public void onServiceConnected() {
-        if (!isAnyHearingAidRelatedProfilesNotReady()) {
+        if (mHelper.isAllHearingAidRelatedProfilesReady()) {
             updateState(mHearingAidPreference);
             mProfileManager.removeServiceListener(this);
         }
@@ -218,53 +205,8 @@ public class AccessibilityHearingAidPreferenceController extends BasePreferenceC
         mFragmentManager = fragmentManager;
     }
 
-    @VisibleForTesting
-    CachedBluetoothDevice getConnectedHearingAidDevice() {
-        final List<BluetoothDevice> deviceList = getConnectedHearingAidDeviceList();
-        return deviceList.isEmpty() ? null : mCachedDeviceManager.findDevice(deviceList.get(0));
-    }
-
     private int getConnectedHearingAidDeviceNum() {
-        return getConnectedHearingAidDeviceList().size();
-    }
-
-    private List<BluetoothDevice> getConnectedHearingAidDeviceList() {
-        if (!isHearingAidSupported()) {
-            return new ArrayList<>();
-        }
-        final List<BluetoothDevice> deviceList = new ArrayList<>();
-        final HapClientProfile hapClientProfile = mProfileManager.getHapClientProfile();
-        if (hapClientProfile != null) {
-            deviceList.addAll(hapClientProfile.getConnectedDevices());
-        }
-        final HearingAidProfile hearingAidProfile = mProfileManager.getHearingAidProfile();
-        if (hearingAidProfile != null) {
-            deviceList.addAll(hearingAidProfile.getConnectedDevices());
-        }
-        return deviceList.stream()
-                .distinct()
-                .filter(d -> !mCachedDeviceManager.isSubDevice(d)).collect(Collectors.toList());
-    }
-
-    private boolean isHearingAidSupported() {
-        if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
-            return false;
-        }
-        final List<Integer> supportedList = mBluetoothAdapter.getSupportedProfiles();
-        return supportedList.contains(BluetoothProfile.HEARING_AID)
-                || supportedList.contains(BluetoothProfile.HAP_CLIENT);
-    }
-
-    private boolean isAnyHearingAidRelatedProfilesNotReady() {
-        HearingAidProfile hearingAidProfile = mProfileManager.getHearingAidProfile();
-        if (hearingAidProfile != null && !hearingAidProfile.isProfileReady()) {
-            return true;
-        }
-        HapClientProfile hapClientProfile = mProfileManager.getHapClientProfile();
-        if (hapClientProfile != null && !hapClientProfile.isProfileReady()) {
-            return true;
-        }
-        return false;
+        return mHelper.getConnectedHearingAidDeviceList().size();
     }
 
     @VisibleForTesting(otherwise = VisibleForTesting.NONE)

src/com/android/settings/accessibility/AccessibilityHearingAidsFragment.java

@@ -39,7 +39,7 @@ public class AccessibilityHearingAidsFragment extends AccessibilityShortcutPrefe
 
     private static final String TAG = "AccessibilityHearingAidsFragment";
     private static final String KEY_HEARING_OPTIONS_CATEGORY = "hearing_options_category";
-    private static final int FIRST_PREFERENCE_IN_CATEGORY_INDEX = -1;
+    private static final int SHORTCUT_PREFERENCE_IN_CATEGORY_INDEX = 20;
     private String mFeatureName;
 
     public AccessibilityHearingAidsFragment() {
@@ -65,7 +65,7 @@ public class AccessibilityHearingAidsFragment extends AccessibilityShortcutPrefe
         final View view = super.onCreateView(inflater, container, savedInstanceState);
         final PreferenceCategory controlCategory = findPreference(KEY_HEARING_OPTIONS_CATEGORY);
         // To move the shortcut preference under controlCategory need to remove the original added.
-        mShortcutPreference.setOrder(FIRST_PREFERENCE_IN_CATEGORY_INDEX);
+        mShortcutPreference.setOrder(SHORTCUT_PREFERENCE_IN_CATEGORY_INDEX);
         getPreferenceScreen().removePreference(mShortcutPreference);
         controlCategory.addPreference(mShortcutPreference);
         return view;

src/com/android/settings/accessibility/HearingAidAudioRoutingPreferenceController.java

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023 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.accessibility;
+
+import android.content.Context;
+import android.util.FeatureFlagUtils;
+
+import com.android.settings.core.BasePreferenceController;
+
+/**
+ * The controller of the audio routing.
+ */
+public class HearingAidAudioRoutingPreferenceController extends BasePreferenceController {
+    public HearingAidAudioRoutingPreferenceController(Context context,
+            String preferenceKey) {
+        super(context, preferenceKey);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return FeatureFlagUtils.isEnabled(mContext, FeatureFlagUtils.SETTINGS_AUDIO_ROUTING)
+                ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
+    }
+}

src/com/android/settings/accessibility/HearingAidHelper.java

@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2023 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.accessibility;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothProfile;
+import android.content.Context;
+
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.CachedBluetoothDeviceManager;
+import com.android.settingslib.bluetooth.HapClientProfile;
+import com.android.settingslib.bluetooth.HearingAidProfile;
+import com.android.settingslib.bluetooth.LocalBluetoothManager;
+import com.android.settingslib.bluetooth.LocalBluetoothProfileManager;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * A helper class to get and check hearing aids and its status.
+ */
+public class HearingAidHelper {
+
+    private final BluetoothAdapter mBluetoothAdapter;
+    private final LocalBluetoothProfileManager mProfileManager;
+    private final CachedBluetoothDeviceManager mCachedDeviceManager;
+
+    public HearingAidHelper(Context context) {
+        final LocalBluetoothManager localBluetoothManager =
+                com.android.settings.bluetooth.Utils.getLocalBluetoothManager(context);
+        mProfileManager = localBluetoothManager.getProfileManager();
+        mCachedDeviceManager = localBluetoothManager.getCachedDeviceManager();
+        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+    }
+
+    /**
+     * Gets the connected hearing aids device whose profiles are
+     * {@link BluetoothProfile#HEARING_AID} or {@link BluetoothProfile#HAP_CLIENT}.
+     *
+     * @return a list of hearing aids {@link BluetoothDevice} objects
+     */
+    public List<BluetoothDevice> getConnectedHearingAidDeviceList() {
+        if (!isHearingAidSupported()) {
+            return new ArrayList<>();
+        }
+        final List<BluetoothDevice> deviceList = new ArrayList<>();
+        final HapClientProfile hapClientProfile = mProfileManager.getHapClientProfile();
+        if (hapClientProfile != null) {
+            deviceList.addAll(hapClientProfile.getConnectedDevices());
+        }
+        final HearingAidProfile hearingAidProfile = mProfileManager.getHearingAidProfile();
+        if (hearingAidProfile != null) {
+            deviceList.addAll(hearingAidProfile.getConnectedDevices());
+        }
+        return deviceList.stream()
+                .distinct()
+                .filter(d -> !mCachedDeviceManager.isSubDevice(d)).collect(Collectors.toList());
+    }
+
+    /**
+     * Gets the first connected hearing aids device.
+     *
+     * @return a {@link CachedBluetoothDevice} that is hearing aids device
+     */
+    public CachedBluetoothDevice getConnectedHearingAidDevice() {
+        final List<BluetoothDevice> deviceList = getConnectedHearingAidDeviceList();
+        return deviceList.isEmpty() ? null : mCachedDeviceManager.findDevice(deviceList.get(0));
+    }
+
+    /**
+     * Checks if {@link BluetoothProfile#HEARING_AID} or {@link BluetoothProfile#HAP_CLIENT}
+     * supported.
+     */
+    public boolean isHearingAidSupported() {
+        if (mBluetoothAdapter == null || !mBluetoothAdapter.isEnabled()) {
+            return false;
+        }
+        final List<Integer> supportedList = mBluetoothAdapter.getSupportedProfiles();
+        return supportedList.contains(BluetoothProfile.HEARING_AID)
+                || supportedList.contains(BluetoothProfile.HAP_CLIENT);
+    }
+
+    /**
+     * Checks if {@link BluetoothProfile#HEARING_AID} or {@link BluetoothProfile#HAP_CLIENT}
+     * profiles all ready.
+     */
+    public boolean isAllHearingAidRelatedProfilesReady() {
+        HearingAidProfile hearingAidProfile = mProfileManager.getHearingAidProfile();
+        if (hearingAidProfile != null && !hearingAidProfile.isProfileReady()) {
+            return false;
+        }
+        HapClientProfile hapClientProfile = mProfileManager.getHapClientProfile();
+        if (hapClientProfile != null && !hapClientProfile.isProfileReady()) {
+            return false;
+        }
+        return true;
+    }
+}

src/com/android/settings/accessibility/HearingDeviceAudioRoutingBasePreferenceController.java

@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2023 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.accessibility;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.media.AudioAttributes;
+import android.media.AudioDeviceAttributes;
+import android.media.audiopolicy.AudioProductStrategy;
+import android.util.Log;
+
+import androidx.preference.ListPreference;
+import androidx.preference.Preference;
+
+import com.android.settings.core.BasePreferenceController;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HearingAidAudioRoutingConstants;
+import com.android.settingslib.bluetooth.HearingAidAudioRoutingHelper;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.primitives.Ints;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Abstract class for providing audio routing {@link ListPreference} common control for hearing
+ * device specifically.
+ */
+public abstract class HearingDeviceAudioRoutingBasePreferenceController extends
+        BasePreferenceController implements Preference.OnPreferenceChangeListener {
+
+    private static final String TAG = "HARoutingBasePreferenceController";
+    private static final boolean DEBUG = false;
+
+    private final HearingAidAudioRoutingHelper mAudioRoutingHelper;
+    private final HearingAidHelper mHearingAidHelper;
+
+    public HearingDeviceAudioRoutingBasePreferenceController(Context context,
+            String preferenceKey) {
+        this(context, preferenceKey,
+                new HearingAidAudioRoutingHelper(context),
+                new HearingAidHelper(context));
+    }
+
+    @VisibleForTesting
+    public HearingDeviceAudioRoutingBasePreferenceController(Context context,
+            String preferenceKey, HearingAidAudioRoutingHelper audioRoutingHelper,
+            HearingAidHelper hearingAidHelper) {
+        super(context, preferenceKey);
+
+        mAudioRoutingHelper = audioRoutingHelper;
+        mHearingAidHelper = hearingAidHelper;
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return AVAILABLE;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        super.updateState(preference);
+
+        final ListPreference listPreference = (ListPreference) preference;
+        final int routingValue = restoreRoutingValue(mContext);
+        listPreference.setValue(String.valueOf(routingValue));
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        final Integer routingValue = Ints.tryParse((String) newValue);
+
+        saveRoutingValue(mContext, routingValue);
+        final CachedBluetoothDevice device = mHearingAidHelper.getConnectedHearingAidDevice();
+        if (device != null) {
+            trySetAudioRoutingConfig(getSupportedAttributeList(),
+                    mHearingAidHelper.getConnectedHearingAidDevice(), routingValue);
+        }
+
+        return true;
+    }
+
+    private void trySetAudioRoutingConfig(int[] audioAttributes,
+            CachedBluetoothDevice hearingDevice,
+            @HearingAidAudioRoutingConstants.RoutingValue int routingValue) {
+        final List<AudioProductStrategy> supportedStrategies =
+                mAudioRoutingHelper.getSupportedStrategies(audioAttributes);
+        final AudioDeviceAttributes hearingDeviceAttributes =
+                mAudioRoutingHelper.getMatchedHearingDeviceAttributes(hearingDevice);
+        if (hearingDeviceAttributes == null) {
+            if (DEBUG) {
+                Log.d(TAG,
+                        "Can not find expected AudioDeviceAttributes to config audio routing "
+                                + "maybe device is offline: "
+                                + hearingDevice.getDevice().getAnonymizedAddress());
+            }
+            return;
+        }
+
+        final boolean status = mAudioRoutingHelper.setPreferredDeviceRoutingStrategies(
+                supportedStrategies, hearingDeviceAttributes, routingValue);
+
+        if (!status) {
+            final List<String> strategiesName = supportedStrategies.stream()
+                    .map(AudioProductStrategy::getName)
+                    .collect(Collectors.toList());
+            Log.w(TAG, "routingMode: " + strategiesName + " routingValue: " + routingValue
+                    + " fail to configure AudioProductStrategy");
+        }
+    }
+
+    /**
+     * Gets a list of usage values defined in {@link AudioAttributes} that are used to identify
+     * {@link AudioProductStrategy} to configure audio routing.
+     */
+    protected abstract int[] getSupportedAttributeList();
+
+    /**
+     * Saves the routing value.
+     *
+     * @param context the valid context used to get the {@link ContentResolver}
+     * @param routingValue one of the value defined in
+     *                     {@link HearingAidAudioRoutingConstants.RoutingValue}
+     */
+    protected abstract void saveRoutingValue(Context context, int routingValue);
+
+    /**
+     * Restores the routing value and used to reflect status on ListPreference.
+     *
+     * @param context the valid context used to get the {@link ContentResolver}
+     * @return one of the value defined in {@link HearingAidAudioRoutingConstants.RoutingValue}
+     */
+    protected abstract int restoreRoutingValue(Context context);
+}

src/com/android/settings/accessibility/HearingDeviceCallRoutingPreferenceController.java

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2023 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.accessibility;
+
+import android.content.Context;
+import android.provider.Settings;
+
+import com.android.settings.Utils;
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HearingAidAudioRoutingConstants;
+
+/**
+ * The controller of the hearing device call routing list preference.
+ */
+public class HearingDeviceCallRoutingPreferenceController extends
+        HearingDeviceAudioRoutingBasePreferenceController {
+
+    private CachedBluetoothDevice mHearingDevice;
+
+    public HearingDeviceCallRoutingPreferenceController(Context context, String preferenceKey) {
+        super(context, preferenceKey);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        return Utils.isVoiceCapable(mContext) ? AVAILABLE : UNSUPPORTED_ON_DEVICE;
+    }
+
+    @Override
+    protected int[] getSupportedAttributeList() {
+        return HearingAidAudioRoutingConstants.CALL_ROUTING_ATTRIBUTES;
+    }
+
+    @Override
+    protected void saveRoutingValue(Context context, int routingValue) {
+        Settings.Secure.putInt(context.getContentResolver(),
+                Settings.Secure.HEARING_AID_CALL_ROUTING, routingValue);
+    }
+
+    @Override
+    protected int restoreRoutingValue(Context context) {
+        return Settings.Secure.getInt(context.getContentResolver(),
+                Settings.Secure.HEARING_AID_CALL_ROUTING,
+                HearingAidAudioRoutingConstants.RoutingValue.AUTO);
+    }
+}

src/com/android/settings/accessibility/HearingDeviceMediaRoutingPreferenceController.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2023 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.accessibility;
+
+import android.content.Context;
+import android.provider.Settings;
+
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HearingAidAudioRoutingConstants;
+
+/**
+ * The controller of the hearing device media routing list preference.
+ */
+public class HearingDeviceMediaRoutingPreferenceController extends
+        HearingDeviceAudioRoutingBasePreferenceController {
+
+    private CachedBluetoothDevice mHearingDevice;
+
+    public HearingDeviceMediaRoutingPreferenceController(Context context, String preferenceKey) {
+        super(context, preferenceKey);
+    }
+
+    @Override
+    protected int[] getSupportedAttributeList() {
+        return HearingAidAudioRoutingConstants.MEDIA_ROUTING_ATTRIBUTES;
+
+    }
+
+    @Override
+    protected void saveRoutingValue(Context context, int routingValue) {
+        Settings.Secure.putInt(context.getContentResolver(),
+                Settings.Secure.HEARING_AID_MEDIA_ROUTING, routingValue);
+    }
+
+    @Override
+    protected int restoreRoutingValue(Context context) {
+        return Settings.Secure.getInt(context.getContentResolver(),
+                Settings.Secure.HEARING_AID_MEDIA_ROUTING,
+                HearingAidAudioRoutingConstants.RoutingValue.AUTO);
+    }
+}

src/com/android/settings/accessibility/HearingDeviceRingtoneRoutingPreferenceController.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2023 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.accessibility;
+
+import android.content.Context;
+import android.provider.Settings;
+
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HearingAidAudioRoutingConstants;
+
+/**
+ * The controller of the hearing device ringtone routing list preference.
+ */
+public class HearingDeviceRingtoneRoutingPreferenceController extends
+        HearingDeviceAudioRoutingBasePreferenceController {
+
+    private CachedBluetoothDevice mHearingDevice;
+
+    public HearingDeviceRingtoneRoutingPreferenceController(Context context, String preferenceKey) {
+        super(context, preferenceKey);
+    }
+
+    @Override
+    protected int[] getSupportedAttributeList() {
+        return HearingAidAudioRoutingConstants.RINGTONE_ROUTING_ATTRIBUTE;
+
+    }
+
+    @Override
+    protected void saveRoutingValue(Context context, int routingValue) {
+        Settings.Secure.putInt(context.getContentResolver(),
+                Settings.Secure.HEARING_AID_RINGTONE_ROUTING, routingValue);
+    }
+
+    @Override
+    protected int restoreRoutingValue(Context context) {
+        return Settings.Secure.getInt(context.getContentResolver(),
+                Settings.Secure.HEARING_AID_RINGTONE_ROUTING,
+                HearingAidAudioRoutingConstants.RoutingValue.AUTO);
+    }
+}

src/com/android/settings/accessibility/HearingDeviceSystemSoundsRoutingPreferenceController.java

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 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.accessibility;
+
+import android.content.Context;
+import android.provider.Settings;
+
+import com.android.settingslib.bluetooth.CachedBluetoothDevice;
+import com.android.settingslib.bluetooth.HearingAidAudioRoutingConstants;
+
+/**
+ * The controller of the hearing device system sounds routing list preference.
+ */
+public class HearingDeviceSystemSoundsRoutingPreferenceController extends
+        HearingDeviceAudioRoutingBasePreferenceController {
+
+    private CachedBluetoothDevice mHearingDevice;
+
+    public HearingDeviceSystemSoundsRoutingPreferenceController(Context context,
+            String preferenceKey) {
+        super(context, preferenceKey);
+    }
+
+    @Override
+    protected int[] getSupportedAttributeList() {
+        return HearingAidAudioRoutingConstants.SYSTEM_SOUNDS_ROUTING_ATTRIBUTES;
+
+    }
+
+    @Override
+    protected void saveRoutingValue(Context context, int routingValue) {
+        Settings.Secure.putInt(context.getContentResolver(),
+                Settings.Secure.HEARING_AID_SYSTEM_SOUNDS_ROUTING, routingValue);
+
+    }
+
+    @Override
+    protected int restoreRoutingValue(Context context) {
+        return Settings.Secure.getInt(context.getContentResolver(),
+                Settings.Secure.HEARING_AID_SYSTEM_SOUNDS_ROUTING,
+                HearingAidAudioRoutingConstants.RoutingValue.AUTO);
+    }
+}