Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7d46e82b authored by Jean-Michel Trivi's avatar Jean-Michel Trivi
Browse files

AudioService: new interface for absolute volume control 

New class VolumeInfo to communicate any type of
  volume information, such as volume type (stream
  type vs volume group), index and associated
  range.
New manager class AudioDeviceVolumeManager to
  serve as the client-side code for setting
  absolute volume for a given device, and
  registering the corresponding volume change
  listener. This is not done through AudioManager
  so as to not keep on piling functionality
  into it that increases its memory footprint.

Bug: 201781907
Test: upcoming after hook up in AudioService

Change-Id: I97fd1827f27f55a90d92c538c142a4d9aae966b3
parent d9b337e9

media/java/android/media/AudioDeviceVolumeManager.java

0 → 100644
+192 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 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.media;



import android.annotation.CallbackExecutor;

import android.annotation.NonNull;

import android.annotation.Nullable;

import android.annotation.RequiresPermission;

import android.content.Context;

import android.os.IBinder;

import android.os.RemoteException;

import android.os.ServiceManager;



import com.android.internal.annotations.GuardedBy;



import java.util.ArrayList;

import java.util.List;

import java.util.Objects;

import java.util.concurrent.Executor;



/**

 * @hide

 * AudioDeviceVolumeManager provides access to audio device volume control.

 */

public class AudioDeviceVolumeManager {



    // define when using Log.*

    //private static final String TAG = "AudioDeviceVolumeManager";

    private static IAudioService sService;



    private final String mPackageName;



    public AudioDeviceVolumeManager(Context context) {

        mPackageName = context.getApplicationContext().getOpPackageName();

    }



    /**

     * @hide

     * Interface to receive volume changes on a device that behaves in absolute volume mode.

     * @see #setDeviceAbsoluteMultiVolumeBehavior(AudioDeviceAttributes, List, Executor,

     *         OnAudioDeviceVolumeChangeListener)

     * @see #setDeviceAbsoluteVolumeBehavior(AudioDeviceAttributes, VolumeInfo, Executor,

     *         OnAudioDeviceVolumeChangeListener)

     */

    public interface OnAudioDeviceVolumeChangedListener {

        /**

         * Called the device for the given audio device has changed.

         * @param device the audio device whose volume has changed

         * @param vol the new volume for the device

         */

        void onAudioDeviceVolumeChanged(

                @NonNull AudioDeviceAttributes device,

                @NonNull VolumeInfo vol);

    }



    static class ListenerInfo {

        final @NonNull OnAudioDeviceVolumeChangedListener mListener;

        final @NonNull Executor mExecutor;

        final @NonNull AudioDeviceAttributes mDevice;



        ListenerInfo(@NonNull OnAudioDeviceVolumeChangedListener listener, @NonNull Executor exe,

                @NonNull AudioDeviceAttributes device) {

            mListener = listener;

            mExecutor = exe;

            mDevice = device;

        }

    }



    private final Object mDeviceVolumeListenerLock = new Object();

    /**

     * List of listeners for volume changes, the associated device, and their associated Executor.

     * List is lazy-initialized on first registration

     */

    @GuardedBy("mDeviceVolumeListenerLock")

    private @Nullable ArrayList<ListenerInfo> mDeviceVolumeListeners;



    @GuardedBy("mDeviceVolumeListenerLock")

    private DeviceVolumeDispatcherStub mDeviceVolumeDispatcherStub;



    final class DeviceVolumeDispatcherStub extends IAudioDeviceVolumeDispatcher.Stub {

        /**

         * Register / unregister the stub

         * @param register true for registering, false for unregistering

         * @param device device for which volume is monitored

         */

        public void register(boolean register, @NonNull AudioDeviceAttributes device,

                @NonNull List<VolumeInfo> volumes) {

            try {

                getService().registerDeviceVolumeDispatcherForAbsoluteVolume(register,

                        this, mPackageName,

                        Objects.requireNonNull(device), Objects.requireNonNull(volumes));

            } catch (RemoteException e) {

                e.rethrowFromSystemServer();

            }

        }



        @Override

        public void dispatchDeviceVolumeChanged(

                @NonNull AudioDeviceAttributes device, @NonNull VolumeInfo vol) {

            final ArrayList<ListenerInfo> volumeListeners;

            synchronized (mDeviceVolumeListenerLock) {

                volumeListeners = (ArrayList<ListenerInfo>) mDeviceVolumeListeners.clone();

            }

            for (ListenerInfo listenerInfo : volumeListeners) {

                if (listenerInfo.mDevice.equals(device)) {

                    listenerInfo.mExecutor.execute(

                            () -> listenerInfo.mListener.onAudioDeviceVolumeChanged(device, vol));

                }

            }

        }

    }



    /**

     * @hide

     * Configures a device to use absolute volume model, and registers a listener for receiving

     * volume updates to apply on that device

     * @param device the audio device set to absolute volume mode

     * @param volume the type of volume this device responds to

     * @param executor the Executor used for receiving volume updates through the listener

     * @param vclistener the callback for volume updates

     */

    @RequiresPermission(anyOf = { android.Manifest.permission.MODIFY_AUDIO_ROUTING,

            android.Manifest.permission.BLUETOOTH_PRIVILEGED })

    public void setDeviceAbsoluteVolumeBehavior(

            @NonNull AudioDeviceAttributes device,

            @NonNull VolumeInfo volume,

            @NonNull @CallbackExecutor Executor executor,

            @NonNull OnAudioDeviceVolumeChangedListener vclistener) {

        final ArrayList<VolumeInfo> volumes = new ArrayList<>(1);

        volumes.add(volume);

        setDeviceAbsoluteMultiVolumeBehavior(device, volumes, executor, vclistener);

    }



    /**

     * @hide

     * Configures a device to use absolute volume model applied to different volume types, and

     * registers a listener for receiving volume updates to apply on that device

     * @param device the audio device set to absolute multi-volume mode

     * @param volumes the list of volumes the given device responds to

     * @param executor the Executor used for receiving volume updates through the listener

     * @param vclistener the callback for volume updates

     */

    @RequiresPermission(anyOf = { android.Manifest.permission.MODIFY_AUDIO_ROUTING,

            android.Manifest.permission.BLUETOOTH_PRIVILEGED })

    public void setDeviceAbsoluteMultiVolumeBehavior(

            @NonNull AudioDeviceAttributes device,

            @NonNull List<VolumeInfo> volumes,

            @NonNull @CallbackExecutor Executor executor,

            @NonNull OnAudioDeviceVolumeChangedListener vclistener) {

        Objects.requireNonNull(device);

        Objects.requireNonNull(volumes);

        Objects.requireNonNull(executor);

        Objects.requireNonNull(vclistener);



        // TODO verify not already registered

        //final ListenerInfo listenerInfo = new ListenerInfo(vclistener, executor, device);

        synchronized (mDeviceVolumeListenerLock) {

            if (mDeviceVolumeListeners == null) {

                mDeviceVolumeListeners = new ArrayList<>();

            }

            if (mDeviceVolumeListeners.size() == 0) {

                if (mDeviceVolumeDispatcherStub == null) {

                    mDeviceVolumeDispatcherStub = new DeviceVolumeDispatcherStub();

                }

            }

            mDeviceVolumeDispatcherStub.register(true, device, volumes);

        }

    }



    private static IAudioService getService() {

        if (sService != null) {

            return sService;

        }

        IBinder b = ServiceManager.getService(Context.AUDIO_SERVICE);

        sService = IAudioService.Stub.asInterface(b);

        return sService;

    }

}

media/java/android/media/IAudioDeviceVolumeDispatcher.aidl

0 → 100644
+31 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 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.media;



import android.media.AudioDeviceAttributes;

import android.media.VolumeInfo;



/**

 * AIDL for the AudioService to signal audio device volume changes.

 *

 * {@hide}

 */

oneway interface IAudioDeviceVolumeDispatcher {



    void dispatchDeviceVolumeChanged(in AudioDeviceAttributes device, in VolumeInfo vol);



}

media/java/android/media/IAudioService.aidl

+11 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ import android.media.AudioPlaybackConfiguration; 
import android.media.AudioRecordingConfiguration;

import android.media.AudioRoutesInfo;

import android.media.BluetoothProfileConnectionInfo;

import android.media.IAudioDeviceVolumeDispatcher;

import android.media.IAudioFocusDispatcher;

import android.media.IAudioModeDispatcher;

import android.media.IAudioRoutesObserver;
@@ -44,6 +45,7 @@ import android.media.ISpatializerOutputCallback; 
import android.media.IVolumeController;

import android.media.IVolumeController;

import android.media.PlayerBase;

import android.media.VolumeInfo;

import android.media.VolumePolicy;

import android.media.audiopolicy.AudioPolicyConfig;

import android.media.audiopolicy.AudioProductStrategy;
@@ -456,6 +458,8 @@ interface IAudioService { 


    boolean isVolumeFixed();



    VolumeInfo getDefaultVolumeInfo();



    boolean isPstnCallAudioInterceptable();



    oneway void muteAwaitConnection(in int[] usagesToMute, in AudioDeviceAttributes dev,
@@ -474,6 +478,7 @@ interface IAudioService { 


    boolean sendFocusLoss(in AudioFocusInfo focusLoser, in IAudioPolicyCallback apcb);





    @JavaPassthrough(annotation="@android.annotation.RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)")

    void addAssistantServicesUids(in int[] assistantUID);
@@ -488,4 +493,10 @@ interface IAudioService { 


    @JavaPassthrough(annotation="@android.annotation.RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)")

    int[] getActiveAssistantServiceUids();



    @JavaPassthrough(annotation="@android.annotation.RequiresPermission(android.Manifest.permission.MODIFY_AUDIO_ROUTING)")

    void registerDeviceVolumeDispatcherForAbsoluteVolume(boolean register,

            in IAudioDeviceVolumeDispatcher cb,

            in String packageName,

            in AudioDeviceAttributes device, in List<VolumeInfo> volumes);

}

media/java/android/media/VolumeInfo.aidl

0 → 100644
+18 −0
Original line number Diff line number Diff line 
/* Copyright 2022, 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.media;



parcelable VolumeInfo;

media/java/android/media/VolumeInfo.java

0 → 100644
+380 −0

File added.

Preview size limit exceeded, changes collapsed.