service/src/com/android/car/audio/CarZonesAudioFocus.java - platform/packages/services/Car - Gitiles

 /*
  * 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.car.audio;

 import static com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport.DUMP_INFO;

 import android.annotation.NonNull;
 import android.annotation.UserIdInt;
 import android.car.media.CarAudioManager;
 import android.content.pm.PackageManager;
 import android.media.AudioAttributes;
 import android.media.AudioFocusInfo;
 import android.media.AudioManager;
 import android.media.audiopolicy.AudioPolicy;
 import android.os.Bundle;
 import android.util.IndentingPrintWriter;
 import android.util.SparseArray;

 import com.android.car.CarLog;
 import com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport;
 import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.util.Preconditions;
 import com.android.server.utils.Slogf;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;

 /**
  * Implements {@link AudioPolicy.AudioPolicyFocusListener}
  *
  * <p><b>Note:</b> Manages audio focus on a per zone basis.
  */
 final class CarZonesAudioFocus extends AudioPolicy.AudioPolicyFocusListener {
     private static final String TAG = CarLog.tagFor(CarZonesAudioFocus.class);

     private final CarFocusCallback mCarFocusCallback;
     private final boolean mDelayedFocusEnabled;
     private CarAudioService mCarAudioService; // Dynamically assigned just after construction
     private AudioPolicy mAudioPolicy; // Dynamically assigned just after construction

     private final SparseArray<CarAudioFocus> mFocusZones;

     public static CarZonesAudioFocus createCarZonesAudioFocus(@NonNull AudioManager audioManager,
             @NonNull PackageManager packageManager,
             @NonNull SparseArray<CarAudioZone> carAudioZones,
             @NonNull CarAudioSettings carAudioSettings,
             boolean enableDelayedAudioFocus,
             CarFocusCallback carFocusCallback) {
         Objects.requireNonNull(audioManager, "AudioManager cannot be null");
         Objects.requireNonNull(packageManager, "PackageManager cannot be null");
         Objects.requireNonNull(carAudioZones, "CarAudioZones cannot be null");
         Preconditions.checkArgument(carAudioZones.size() != 0,
                 "There must be a minimum of one audio zone");
         Objects.requireNonNull(carAudioSettings, "CarAudioSettings cannot be null");

         SparseArray<CarAudioFocus> audioFocusPerZone = new SparseArray<>();

         //Create focus for all the zones
         for (int i = 0; i < carAudioZones.size(); i++) {
             CarAudioZone audioZone = carAudioZones.valueAt(i);
             int audioZoneId = audioZone.getId();
             Slogf.d(TAG, "Adding new zone %d", audioZoneId);
             CarAudioFocus zoneFocusListener =
                     new CarAudioFocus(audioManager, packageManager,
                             new FocusInteraction(carAudioSettings), enableDelayedAudioFocus);
             audioFocusPerZone.put(audioZoneId, zoneFocusListener);
         }
         return new CarZonesAudioFocus(audioFocusPerZone, enableDelayedAudioFocus, carFocusCallback);
     }

     @VisibleForTesting
     CarZonesAudioFocus(SparseArray<CarAudioFocus> focusZones,
             boolean enableDelayedAudioFocus,
             CarFocusCallback carFocusCallback) {
         mFocusZones = focusZones;
         mDelayedFocusEnabled = enableDelayedAudioFocus;
         mCarFocusCallback = carFocusCallback;
     }

     /**
      * Query the current list of focus loser in zoneId for uid
      * @param uid uid to query for current focus losers
      * @param zoneId zone id to query for info
      * @return list of current focus losers for uid
      */
     ArrayList<AudioFocusInfo> getAudioFocusLosersForUid(int uid, int zoneId) {
         CarAudioFocus focus = mFocusZones.get(zoneId);
         return focus.getAudioFocusLosersForUid(uid);
     }

     /**
      * Query the current list of focus holders in zoneId for uid
      * @param uid uid to query for current focus holders
      * @param zoneId zone id to query
      * @return list of current focus holders that for uid
      */
     ArrayList<AudioFocusInfo> getAudioFocusHoldersForUid(int uid, int zoneId) {
         CarAudioFocus focus = mFocusZones.get(zoneId);
         return focus.getAudioFocusHoldersForUid(uid);
     }

     /**
      * For each entry in list, transiently lose focus
      * @param afiList list of audio focus entries
      * @param zoneId zone id where focus should should be lost
      */
     void transientlyLoseInFocusInZone(@NonNull ArrayList<AudioFocusInfo> afiList, int zoneId) {
         CarAudioFocus focus = mFocusZones.get(zoneId);

         for (AudioFocusInfo info : afiList) {
             focus.removeAudioFocusInfoAndTransientlyLoseFocus(info);
         }
     }

     int reevaluateAndRegainAudioFocus(AudioFocusInfo afi) {
         int zoneId = getAudioZoneIdForAudioFocusInfo(afi);
         return getCarAudioFocusForZoneId(zoneId).reevaluateAndRegainAudioFocus(afi);
     }

     /**
      * Sets the owning policy of the audio focus
      *
      * <p><b>Note:</b> This has to happen after the construction to avoid a chicken and egg
      * problem when setting up the AudioPolicy which must depend on this object.

      * @param carAudioService owning car audio service
      * @param parentPolicy owning parent car audio policy
      */
     void setOwningPolicy(CarAudioService carAudioService, AudioPolicy parentPolicy) {
         mAudioPolicy = parentPolicy;
         mCarAudioService = carAudioService;

         for (int i = 0; i < mFocusZones.size(); i++) {
             mFocusZones.valueAt(i).setOwningPolicy(mAudioPolicy);
         }
     }

     void setRestrictFocus(boolean isFocusRestricted) {
         int[] zoneIds = new int[mFocusZones.size()];
         for (int i = 0; i < mFocusZones.size(); i++) {
             zoneIds[i] = mFocusZones.keyAt(i);
             mFocusZones.valueAt(i).setRestrictFocus(isFocusRestricted);
         }
         notifyFocusCallback(zoneIds);
     }

     @Override
     public void onAudioFocusRequest(AudioFocusInfo afi, int requestResult) {
         int zoneId = getAudioZoneIdForAudioFocusInfo(afi);
         getCarAudioFocusForZoneId(zoneId).onAudioFocusRequest(afi, requestResult);
         notifyFocusCallback(new int[]{zoneId});
     }

     /**
      * @see AudioManager#abandonAudioFocus(AudioManager.OnAudioFocusChangeListener, AudioAttributes)
      * Note that we'll get this call for a focus holder that dies while in the focus stack, so
      * we don't need to watch for death notifications directly.
      */
     @Override
     public void onAudioFocusAbandon(AudioFocusInfo afi) {
         int zoneId = getAudioZoneIdForAudioFocusInfo(afi);
         getCarAudioFocusForZoneId(zoneId).onAudioFocusAbandon(afi);
         notifyFocusCallback(new int[]{zoneId});
     }

     @NonNull
     private CarAudioFocus getCarAudioFocusForZoneId(int zoneId) {
         return mFocusZones.get(zoneId);
     }

     private int getAudioZoneIdForAudioFocusInfo(AudioFocusInfo afi) {
         int zoneId = mCarAudioService.getZoneIdForUid(afi.getClientUid());

         // If the bundle attribute for AUDIOFOCUS_EXTRA_REQUEST_ZONE_ID has been assigned
         // Use zone id from that instead.
         Bundle bundle = afi.getAttributes().getBundle();

         if (bundle != null) {
             int bundleZoneId =
                     bundle.getInt(CarAudioManager.AUDIOFOCUS_EXTRA_REQUEST_ZONE_ID,
                             -1);
             // check if the zone id is within current zones bounds
             if (mCarAudioService.isAudioZoneIdValid(bundleZoneId)) {
                 Slogf.d(TAG, "getFocusForAudioFocusInfo valid zoneId %d with bundle request for"
                         + " client %s", bundleZoneId, afi.getClientId());
                 zoneId = bundleZoneId;
             } else {
                 Slogf.w(TAG, "getFocusForAudioFocusInfo invalid zoneId %d with bundle request for "
                                 + "client %s, dispatching focus request to zoneId %d", bundleZoneId,
                         afi.getClientId(), zoneId);
             }
         }

         return zoneId;
     }

     private void notifyFocusCallback(int[] zoneIds) {
         if (mCarFocusCallback == null) {
             return;
         }
         SparseArray<List<AudioFocusInfo>> focusHoldersByZoneId = new SparseArray<>();
         for (int i = 0; i < zoneIds.length; i++) {
             int zoneId = zoneIds[i];
             List<AudioFocusInfo> focusHolders = mFocusZones.get(zoneId).getAudioFocusHolders();
             focusHoldersByZoneId.put(zoneId, focusHolders);
         }

         mCarFocusCallback.onFocusChange(zoneIds, focusHoldersByZoneId);
     }

     @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
     void dump(IndentingPrintWriter writer) {
         writer.println("*CarZonesAudioFocus*");
         writer.increaseIndent();
         writer.printf("Delayed Focus Enabled: %b\n", mDelayedFocusEnabled);
         writer.printf("Has Focus Callback: %b\n", mCarFocusCallback != null);
         writer.println("Car Zones Audio Focus Listeners:");
         writer.increaseIndent();
         for (int i = 0; i < mFocusZones.size(); i++) {
             writer.printf("Zone Id: %d\n", mFocusZones.keyAt(i));
             writer.increaseIndent();
             mFocusZones.valueAt(i).dump(writer);
             writer.decreaseIndent();
         }
         writer.decreaseIndent();
         writer.decreaseIndent();
     }

     public void updateUserForZoneId(int audioZoneId, @UserIdInt int userId) {
         Preconditions.checkArgument(mCarAudioService.isAudioZoneIdValid(audioZoneId),
                 "Invalid zoneId %d", audioZoneId);
         mFocusZones.get(audioZoneId).getFocusInteraction().setUserIdForSettings(userId);
     }

     /**
      * Callback to get notified of the active focus holders after any focus request or abandon  call
      */
     public interface CarFocusCallback {
         /**
          * Called after a focus request or abandon call is handled.
          *
          * @param audioZoneIds IDs of the zones where the changes took place
          * @param focusHoldersByZoneId sparse array by zone ID, where each value is a list of
          * {@link AudioFocusInfo}s holding focus in specified audio zone
          */
         void onFocusChange(int[] audioZoneIds,
                 @NonNull SparseArray<List<AudioFocusInfo>> focusHoldersByZoneId);
     }
 }
	/*
	* 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.car.audio;

	import static com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport.DUMP_INFO;

	import android.annotation.NonNull;
	import android.annotation.UserIdInt;
	import android.car.media.CarAudioManager;
	import android.content.pm.PackageManager;
	import android.media.AudioAttributes;
	import android.media.AudioFocusInfo;
	import android.media.AudioManager;
	import android.media.audiopolicy.AudioPolicy;
	import android.os.Bundle;
	import android.util.IndentingPrintWriter;
	import android.util.SparseArray;

	import com.android.car.CarLog;
	import com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport;
	import com.android.internal.annotations.VisibleForTesting;
	import com.android.internal.util.Preconditions;
	import com.android.server.utils.Slogf;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.Objects;

	/**
	* Implements {@link AudioPolicy.AudioPolicyFocusListener}
	*
	* <p><b>Note:</b> Manages audio focus on a per zone basis.
	*/
	final class CarZonesAudioFocus extends AudioPolicy.AudioPolicyFocusListener {
	private static final String TAG = CarLog.tagFor(CarZonesAudioFocus.class);

	private final CarFocusCallback mCarFocusCallback;
	private final boolean mDelayedFocusEnabled;
	private CarAudioService mCarAudioService; // Dynamically assigned just after construction
	private AudioPolicy mAudioPolicy; // Dynamically assigned just after construction

	private final SparseArray<CarAudioFocus> mFocusZones;

	public static CarZonesAudioFocus createCarZonesAudioFocus(@NonNull AudioManager audioManager,
	@NonNull PackageManager packageManager,
	@NonNull SparseArray<CarAudioZone> carAudioZones,
	@NonNull CarAudioSettings carAudioSettings,
	boolean enableDelayedAudioFocus,
	CarFocusCallback carFocusCallback) {
	Objects.requireNonNull(audioManager, "AudioManager cannot be null");
	Objects.requireNonNull(packageManager, "PackageManager cannot be null");
	Objects.requireNonNull(carAudioZones, "CarAudioZones cannot be null");
	Preconditions.checkArgument(carAudioZones.size() != 0,
	"There must be a minimum of one audio zone");
	Objects.requireNonNull(carAudioSettings, "CarAudioSettings cannot be null");

	SparseArray<CarAudioFocus> audioFocusPerZone = new SparseArray<>();

	//Create focus for all the zones
	for (int i = 0; i < carAudioZones.size(); i++) {
	CarAudioZone audioZone = carAudioZones.valueAt(i);
	int audioZoneId = audioZone.getId();
	Slogf.d(TAG, "Adding new zone %d", audioZoneId);
	CarAudioFocus zoneFocusListener =
	new CarAudioFocus(audioManager, packageManager,
	new FocusInteraction(carAudioSettings), enableDelayedAudioFocus);
	audioFocusPerZone.put(audioZoneId, zoneFocusListener);
	}
	return new CarZonesAudioFocus(audioFocusPerZone, enableDelayedAudioFocus, carFocusCallback);
	}

	@VisibleForTesting
	CarZonesAudioFocus(SparseArray<CarAudioFocus> focusZones,
	boolean enableDelayedAudioFocus,
	CarFocusCallback carFocusCallback) {
	mFocusZones = focusZones;
	mDelayedFocusEnabled = enableDelayedAudioFocus;
	mCarFocusCallback = carFocusCallback;
	}

	/**
	* Query the current list of focus loser in zoneId for uid
	* @param uid uid to query for current focus losers
	* @param zoneId zone id to query for info
	* @return list of current focus losers for uid
	*/
	ArrayList<AudioFocusInfo> getAudioFocusLosersForUid(int uid, int zoneId) {
	CarAudioFocus focus = mFocusZones.get(zoneId);
	return focus.getAudioFocusLosersForUid(uid);
	}

	/**
	* Query the current list of focus holders in zoneId for uid
	* @param uid uid to query for current focus holders
	* @param zoneId zone id to query
	* @return list of current focus holders that for uid
	*/
	ArrayList<AudioFocusInfo> getAudioFocusHoldersForUid(int uid, int zoneId) {
	CarAudioFocus focus = mFocusZones.get(zoneId);
	return focus.getAudioFocusHoldersForUid(uid);
	}

	/**
	* For each entry in list, transiently lose focus
	* @param afiList list of audio focus entries
	* @param zoneId zone id where focus should should be lost
	*/
	void transientlyLoseInFocusInZone(@NonNull ArrayList<AudioFocusInfo> afiList, int zoneId) {
	CarAudioFocus focus = mFocusZones.get(zoneId);

	for (AudioFocusInfo info : afiList) {
	focus.removeAudioFocusInfoAndTransientlyLoseFocus(info);
	}
	}

	int reevaluateAndRegainAudioFocus(AudioFocusInfo afi) {
	int zoneId = getAudioZoneIdForAudioFocusInfo(afi);
	return getCarAudioFocusForZoneId(zoneId).reevaluateAndRegainAudioFocus(afi);
	}

	/**
	* Sets the owning policy of the audio focus
	*
	* <p><b>Note:</b> This has to happen after the construction to avoid a chicken and egg
	* problem when setting up the AudioPolicy which must depend on this object.

	* @param carAudioService owning car audio service
	* @param parentPolicy owning parent car audio policy
	*/
	void setOwningPolicy(CarAudioService carAudioService, AudioPolicy parentPolicy) {
	mAudioPolicy = parentPolicy;
	mCarAudioService = carAudioService;

	for (int i = 0; i < mFocusZones.size(); i++) {
	mFocusZones.valueAt(i).setOwningPolicy(mAudioPolicy);
	}
	}

	void setRestrictFocus(boolean isFocusRestricted) {
	int[] zoneIds = new int[mFocusZones.size()];
	for (int i = 0; i < mFocusZones.size(); i++) {
	zoneIds[i] = mFocusZones.keyAt(i);
	mFocusZones.valueAt(i).setRestrictFocus(isFocusRestricted);
	}
	notifyFocusCallback(zoneIds);
	}

	@Override
	public void onAudioFocusRequest(AudioFocusInfo afi, int requestResult) {
	int zoneId = getAudioZoneIdForAudioFocusInfo(afi);
	getCarAudioFocusForZoneId(zoneId).onAudioFocusRequest(afi, requestResult);
	notifyFocusCallback(new int[]{zoneId});
	}

	/**
	* @see AudioManager#abandonAudioFocus(AudioManager.OnAudioFocusChangeListener, AudioAttributes)
	* Note that we'll get this call for a focus holder that dies while in the focus stack, so
	* we don't need to watch for death notifications directly.
	*/
	@Override
	public void onAudioFocusAbandon(AudioFocusInfo afi) {
	int zoneId = getAudioZoneIdForAudioFocusInfo(afi);
	getCarAudioFocusForZoneId(zoneId).onAudioFocusAbandon(afi);
	notifyFocusCallback(new int[]{zoneId});
	}

	@NonNull
	private CarAudioFocus getCarAudioFocusForZoneId(int zoneId) {
	return mFocusZones.get(zoneId);
	}

	private int getAudioZoneIdForAudioFocusInfo(AudioFocusInfo afi) {
	int zoneId = mCarAudioService.getZoneIdForUid(afi.getClientUid());

	// If the bundle attribute for AUDIOFOCUS_EXTRA_REQUEST_ZONE_ID has been assigned
	// Use zone id from that instead.
	Bundle bundle = afi.getAttributes().getBundle();

	if (bundle != null) {
	int bundleZoneId =
	bundle.getInt(CarAudioManager.AUDIOFOCUS_EXTRA_REQUEST_ZONE_ID,
	-1);
	// check if the zone id is within current zones bounds
	if (mCarAudioService.isAudioZoneIdValid(bundleZoneId)) {
	Slogf.d(TAG, "getFocusForAudioFocusInfo valid zoneId %d with bundle request for"
	+ " client %s", bundleZoneId, afi.getClientId());
	zoneId = bundleZoneId;
	} else {
	Slogf.w(TAG, "getFocusForAudioFocusInfo invalid zoneId %d with bundle request for "
	+ "client %s, dispatching focus request to zoneId %d", bundleZoneId,
	afi.getClientId(), zoneId);
	}
	}

	return zoneId;
	}

	private void notifyFocusCallback(int[] zoneIds) {
	if (mCarFocusCallback == null) {
	return;
	}
	SparseArray<List<AudioFocusInfo>> focusHoldersByZoneId = new SparseArray<>();
	for (int i = 0; i < zoneIds.length; i++) {
	int zoneId = zoneIds[i];
	List<AudioFocusInfo> focusHolders = mFocusZones.get(zoneId).getAudioFocusHolders();
	focusHoldersByZoneId.put(zoneId, focusHolders);
	}

	mCarFocusCallback.onFocusChange(zoneIds, focusHoldersByZoneId);
	}

	@ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
	void dump(IndentingPrintWriter writer) {
	writer.println("CarZonesAudioFocus");
	writer.increaseIndent();
	writer.printf("Delayed Focus Enabled: %b\n", mDelayedFocusEnabled);
	writer.printf("Has Focus Callback: %b\n", mCarFocusCallback != null);
	writer.println("Car Zones Audio Focus Listeners:");
	writer.increaseIndent();
	for (int i = 0; i < mFocusZones.size(); i++) {
	writer.printf("Zone Id: %d\n", mFocusZones.keyAt(i));
	writer.increaseIndent();
	mFocusZones.valueAt(i).dump(writer);
	writer.decreaseIndent();
	}
	writer.decreaseIndent();
	writer.decreaseIndent();
	}

	public void updateUserForZoneId(int audioZoneId, @UserIdInt int userId) {
	Preconditions.checkArgument(mCarAudioService.isAudioZoneIdValid(audioZoneId),
	"Invalid zoneId %d", audioZoneId);
	mFocusZones.get(audioZoneId).getFocusInteraction().setUserIdForSettings(userId);
	}

	/**
	* Callback to get notified of the active focus holders after any focus request or abandon call
	*/
	public interface CarFocusCallback {
	/**
	* Called after a focus request or abandon call is handled.
	*
	* @param audioZoneIds IDs of the zones where the changes took place
	* @param focusHoldersByZoneId sparse array by zone ID, where each value is a list of
	* {@link AudioFocusInfo}s holding focus in specified audio zone
	*/
	void onFocusChange(int[] audioZoneIds,
	@NonNull SparseArray<List<AudioFocusInfo>> focusHoldersByZoneId);
	}
	}