/*
 * 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 android.media;

import static android.media.audiopolicy.Flags.FLAG_ENABLE_FADE_MANAGER_CONFIGURATION;

import android.annotation.DurationMillisLong;
import android.annotation.FlaggedApi;
import android.annotation.IntDef;
import android.annotation.IntRange;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.ArrayMap;
import android.util.IntArray;
import android.util.SparseArray;

import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.util.Preconditions;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

/**
 * Class to encapsulate fade configurations.
 *
 * <p>Configurations are provided through:
 * <ul>
 *     <li>Fadeable list: a positive list of fadeable type - usage</li>
 *     <li>Unfadeable lists: negative list of unfadeable types - content type, uid, audio attributes
 *     </li>
 *     <li>Volume shaper configs: fade in and fade out configs per usage or audio attributes
 *     </li>
 * </ul>
 *
 * <p>Fade manager configuration can be created in one of the following ways:
 * <ul>
 *     <li>Disabled fades:
 *     <pre class="prettyprint">
 *         new FadeManagerConfiguration.Builder()
 *               .setFadeState(FADE_STATE_DISABLED).build()
 *               </pre>
 *     Can be used to disable fading</li>
 *     <li>Default configurations including default fade duration:
 *     <pre class="prettyprint">
 *         new FadeManagerConfiguration.Builder()
 *                .setFadeState(FADE_STATE_ENABLED_DEFAULT).build()
 *                </pre>
 *     Can be used to enable default fading configurations</li>
 *     <li>Default configurations with custom fade duration:
 *     <pre class="prettyprint">
 *         new FadeManagerConfiguration.Builder(fade out duration, fade in duration)
 *            .setFadeState(FADE_STATE_ENABLED_DEFAULT).build()
 *            </pre>
 *     Can be used to enable default fadeability lists with configurable fade in and out duration
 *     </li>
 *     <li>Custom configurations and fade volume shapers:
 *     <pre class="prettyprint">
 *         new FadeManagerConfiguration.Builder(fade out duration, fade in duration)
 *                .setFadeState(FADE_STATE_ENABLED_DEFAULT)
 *                .setFadeableUsages(list of usages)
 *                .setUnfadeableContentTypes(list of content types)
 *                .setUnfadeableUids(list of uids)
 *                .setUnfadeableAudioAttributes(list of audio attributes)
 *                .setFadeOutVolumeShaperConfigForAudioAttributes(attributes, volume shaper config)
 *                .setFadeInDurationForUsaeg(usage, duration)
 *                ....
 *                .build() </pre>
 *      Achieves full customization of fadeability lists and configurations</li>
 *      <li>Also provides a copy constructor from another instance of fade manager configuration
 *      <pre class="prettyprint">
 *          new FadeManagerConfiguration.Builder(fadeManagerConfiguration)
 *                 .addFadeableUsage(new usage)
 *                 ....
 *                 .build()</pre>
 *      Helps with recreating a new instance from another to simply change/add on top of the
 *      existing ones</li>
 * </ul>
 * @hide
 */
@SystemApi
@FlaggedApi(FLAG_ENABLE_FADE_MANAGER_CONFIGURATION)
public final class FadeManagerConfiguration implements Parcelable {

    public static final String TAG = "FadeManagerConfiguration";

    /**
     * Defines the disabled fade state. No player will be faded in this state.
     */
    public static final int FADE_STATE_DISABLED = 0;

    /**
     * Defines the enabled fade state with default configurations
     */
    public static final int FADE_STATE_ENABLED_DEFAULT = 1;

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(flag = false, prefix = "FADE_STATE", value = {
            FADE_STATE_DISABLED,
            FADE_STATE_ENABLED_DEFAULT,
    })
    public @interface FadeStateEnum {}

    /**
     * Defines ID to be used in volume shaper for fading
     */
    public static final int VOLUME_SHAPER_SYSTEM_FADE_ID = 2;

    /**
     * Used to reset duration or return duration when not set
     *
     * @see Builder#setFadeOutDurationForUsage(int, long)
     * @see Builder#setFadeInDurationForUsage(int, long)
     * @see Builder#setFadeOutDurationForAudioAttributes(AudioAttributes, long)
     * @see Builder#setFadeInDurationForAudioAttributes(AudioAttributes, long)
     * @see #getFadeOutDurationForUsage(int)
     * @see #getFadeInDurationForUsage(int)
     * @see #getFadeOutDurationForAudioAttributes(AudioAttributes)
     * @see #getFadeInDurationForAudioAttributes(AudioAttributes)
     */
    public static final @DurationMillisLong long DURATION_NOT_SET = 0;

    /** Defines the default fade out duration */
    private static final @DurationMillisLong long DEFAULT_FADE_OUT_DURATION_MS = 2_000;

    /** Defines the default fade in duration */
    private static final @DurationMillisLong long DEFAULT_FADE_IN_DURATION_MS = 1_000;

    /** Map of Usage to Fade volume shaper configs wrapper */
    private final SparseArray<FadeVolumeShaperConfigsWrapper> mUsageToFadeWrapperMap;
    /** Map of AudioAttributes to Fade volume shaper configs wrapper */
    private final ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper> mAttrToFadeWrapperMap;
    /** list of fadeable usages */
    private final @NonNull IntArray mFadeableUsages;
    /** list of unfadeable content types */
    private final @NonNull IntArray mUnfadeableContentTypes;
    /** list of unfadeable player types */
    private final @NonNull IntArray mUnfadeablePlayerTypes;
    /** list of unfadeable uid(s) */
    private final @NonNull IntArray mUnfadeableUids;
    /** list of unfadeable AudioAttributes */
    private final @NonNull List<AudioAttributes> mUnfadeableAudioAttributes;
    /** fade state */
    private final @FadeStateEnum int mFadeState;
    /** fade out duration from builder - used for creating default fade out volume shaper */
    private final @DurationMillisLong long mFadeOutDurationMillis;
    /** fade in duration from builder - used for creating default fade in volume shaper */
    private final @DurationMillisLong long mFadeInDurationMillis;
    /** delay after which the offending players are faded back in */
    private final @DurationMillisLong long mFadeInDelayForOffendersMillis;

    private FadeManagerConfiguration(int fadeState, @DurationMillisLong long fadeOutDurationMillis,
            @DurationMillisLong long fadeInDurationMillis,
            @DurationMillisLong long offendersFadeInDelayMillis,
            @NonNull SparseArray<FadeVolumeShaperConfigsWrapper> usageToFadeWrapperMap,
            @NonNull ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper> attrToFadeWrapperMap,
            @NonNull IntArray fadeableUsages, @NonNull IntArray unfadeableContentTypes,
            @NonNull IntArray unfadeablePlayerTypes, @NonNull IntArray unfadeableUids,
            @NonNull List<AudioAttributes> unfadeableAudioAttributes) {
        mFadeState = fadeState;
        mFadeOutDurationMillis = fadeOutDurationMillis;
        mFadeInDurationMillis = fadeInDurationMillis;
        mFadeInDelayForOffendersMillis = offendersFadeInDelayMillis;
        mUsageToFadeWrapperMap = Objects.requireNonNull(usageToFadeWrapperMap,
                "Usage to fade wrapper map cannot be null");
        mAttrToFadeWrapperMap = Objects.requireNonNull(attrToFadeWrapperMap,
                "Attribute to fade wrapper map cannot be null");
        mFadeableUsages = Objects.requireNonNull(fadeableUsages,
                "List of fadeable usages cannot be null");
        mUnfadeableContentTypes = Objects.requireNonNull(unfadeableContentTypes,
                "List of unfadeable content types cannot be null");
        mUnfadeablePlayerTypes = Objects.requireNonNull(unfadeablePlayerTypes,
                "List of unfadeable player types cannot be null");
        mUnfadeableUids = Objects.requireNonNull(unfadeableUids,
                "List of unfadeable uids cannot be null");
        mUnfadeableAudioAttributes = Objects.requireNonNull(unfadeableAudioAttributes,
                "List of unfadeable audio attributes cannot be null");
    }

    /**
     * Get the fade state
     */
    @FadeStateEnum
    public int getFadeState() {
        return mFadeState;
    }

    /**
     * Get the list of usages that can be faded
     *
     * @return list of {@link android.media.AudioAttributes usages} that shall be faded
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @NonNull
    public List<Integer> getFadeableUsages() {
        ensureFadingIsEnabled();
        return convertIntArrayToIntegerList(mFadeableUsages);
    }

    /**
     * Get the list of {@link android.media.AudioPlaybackConfiguration player types} that can be
     * faded
     *
     * @return list of {@link android.media.AudioPlaybackConfiguration player types}
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @NonNull
    public List<Integer> getUnfadeablePlayerTypes() {
        ensureFadingIsEnabled();
        return convertIntArrayToIntegerList(mUnfadeablePlayerTypes);
    }

    /**
     * Get the list of {@link android.media.AudioAttributes content types} that can be faded
     *
     * @return list of {@link android.media.AudioAttributes content types}
     * @throws IllegalStateExceptionif if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @NonNull
    public List<Integer> getUnfadeableContentTypes() {
        ensureFadingIsEnabled();
        return convertIntArrayToIntegerList(mUnfadeableContentTypes);
    }

    /**
     * Get the list of uids that cannot be faded
     *
     * @return list of uids that shall not be faded
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @NonNull
    public List<Integer> getUnfadeableUids() {
        ensureFadingIsEnabled();
        return convertIntArrayToIntegerList(mUnfadeableUids);
    }

    /**
     * Get the list of {@link android.media.AudioAttributes} that cannot be faded
     *
     * @return list of {@link android.media.AudioAttributes} that shall not be faded
     * @throws IllegalStateException if fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @NonNull
    public List<AudioAttributes> getUnfadeableAudioAttributes() {
        ensureFadingIsEnabled();
        return mUnfadeableAudioAttributes;
    }

    /**
     * Get the duration used to fade out players with {@link android.media.AudioAttributes usage}
     *
     * @param usage the {@link android.media.AudioAttributes usage}
     * @return duration in milliseconds if set for the usage or {@link #DURATION_NOT_SET} otherwise
     * @throws IllegalArgumentException if the usage is invalid
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @IntRange(from = 0) @DurationMillisLong
    public long getFadeOutDurationForUsage(@AudioAttributes.AttributeUsage int usage) {
        ensureFadingIsEnabled();
        validateUsage(usage);
        return getDurationForVolumeShaperConfig(getVolumeShaperConfigFromWrapper(
                mUsageToFadeWrapperMap.get(usage), /* isFadeIn= */ false));
    }

    /**
     * Get the duration used to fade in players with {@link android.media.AudioAttributes usage}
     *
     * @param usage the {@link android.media.AudioAttributes usage}
     * @return duration in milliseconds if set for the usage or {@link #DURATION_NOT_SET} otherwise
     * @throws IllegalArgumentException if the usage is invalid
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @IntRange(from = 0) @DurationMillisLong
    public long getFadeInDurationForUsage(@AudioAttributes.AttributeUsage int usage) {
        ensureFadingIsEnabled();
        validateUsage(usage);
        return getDurationForVolumeShaperConfig(getVolumeShaperConfigFromWrapper(
                mUsageToFadeWrapperMap.get(usage), /* isFadeIn= */ true));
    }

    /**
     * Get the {@link android.media.VolumeShaper.Configuration} used to fade out players with
     * {@link android.media.AudioAttributes usage}
     *
     * @param usage the {@link android.media.AudioAttributes usage}
     * @return {@link android.media.VolumeShaper.Configuration} if set for the usage or
     *     {@code null} otherwise
     * @throws IllegalArgumentException if the usage is invalid
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @Nullable
    public VolumeShaper.Configuration getFadeOutVolumeShaperConfigForUsage(
            @AudioAttributes.AttributeUsage int usage) {
        ensureFadingIsEnabled();
        validateUsage(usage);
        return getVolumeShaperConfigFromWrapper(mUsageToFadeWrapperMap.get(usage),
                /* isFadeIn= */ false);
    }

    /**
     * Get the {@link android.media.VolumeShaper.Configuration} used to fade in players with
     * {@link android.media.AudioAttributes usage}
     *
     * @param usage the {@link android.media.AudioAttributes usage}
     * @return {@link android.media.VolumeShaper.Configuration} if set for the usage or
     *     {@code null} otherwise
     * @throws IllegalArgumentException if the usage is invalid
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @Nullable
    public VolumeShaper.Configuration getFadeInVolumeShaperConfigForUsage(
            @AudioAttributes.AttributeUsage int usage) {
        ensureFadingIsEnabled();
        validateUsage(usage);
        return getVolumeShaperConfigFromWrapper(mUsageToFadeWrapperMap.get(usage),
                /* isFadeIn= */ true);
    }

    /**
     * Get the duration used to fade out players with {@link android.media.AudioAttributes}
     *
     * @param audioAttributes {@link android.media.AudioAttributes}
     * @return duration in milliseconds if set for the audio attributes or
     *     {@link #DURATION_NOT_SET} otherwise
     * @throws NullPointerException if the audio attributes is {@code null}
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @IntRange(from = 0) @DurationMillisLong
    public long getFadeOutDurationForAudioAttributes(@NonNull AudioAttributes audioAttributes) {
        ensureFadingIsEnabled();
        return getDurationForVolumeShaperConfig(getVolumeShaperConfigFromWrapper(
                mAttrToFadeWrapperMap.get(audioAttributes), /* isFadeIn= */ false));
    }

    /**
     * Get the duration used to fade-in players with {@link android.media.AudioAttributes}
     *
     * @param audioAttributes {@link android.media.AudioAttributes}
     * @return duration in milliseconds if set for the audio attributes or
     *     {@link #DURATION_NOT_SET} otherwise
     * @throws NullPointerException if the audio attributes is {@code null}
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @IntRange(from = 0) @DurationMillisLong
    public long getFadeInDurationForAudioAttributes(@NonNull AudioAttributes audioAttributes) {
        ensureFadingIsEnabled();
        return getDurationForVolumeShaperConfig(getVolumeShaperConfigFromWrapper(
                mAttrToFadeWrapperMap.get(audioAttributes), /* isFadeIn= */ true));
    }

    /**
     * Get the {@link android.media.VolumeShaper.Configuration} used to fade out players with
     * {@link android.media.AudioAttributes}
     *
     * @param audioAttributes {@link android.media.AudioAttributes}
     * @return {@link android.media.VolumeShaper.Configuration} if set for the audio attribute or
     *     {@code null} otherwise
     * @throws NullPointerException if the audio attributes is {@code null}
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @Nullable
    public VolumeShaper.Configuration getFadeOutVolumeShaperConfigForAudioAttributes(
            @NonNull AudioAttributes audioAttributes) {
        Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null");
        ensureFadingIsEnabled();
        return getVolumeShaperConfigFromWrapper(mAttrToFadeWrapperMap.get(audioAttributes),
                /* isFadeIn= */ false);
    }

    /**
     * Get the {@link android.media.VolumeShaper.Configuration} used to fade out players with
     * {@link android.media.AudioAttributes}
     *
     * @param audioAttributes {@link android.media.AudioAttributes}
     * @return {@link android.media.VolumeShaper.Configuration} used for fading in if set for the
     *     audio attribute or {@code null} otherwise
     * @throws NullPointerException if the audio attributes is {@code null}
     * @throws IllegalStateException if the fade state is set to {@link #FADE_STATE_DISABLED}
     */
    @Nullable
    public VolumeShaper.Configuration getFadeInVolumeShaperConfigForAudioAttributes(
            @NonNull AudioAttributes audioAttributes) {
        Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null");
        ensureFadingIsEnabled();
        return getVolumeShaperConfigFromWrapper(mAttrToFadeWrapperMap.get(audioAttributes),
                /* isFadeIn= */ true);
    }

    /**
     * Get the list of {@link android.media.AudioAttributes} for whome the volume shaper
     * configurations are defined
     *
     * @return list of {@link android.media.AudioAttributes} with valid volume shaper configs or
     *     empty list if none set.
     */
    @NonNull
    public List<AudioAttributes> getAudioAttributesWithVolumeShaperConfigs() {
        return getAudioAttributesInternal();
    }

    /**
     * Get the delay after which the offending players are faded back in
     *
     * Players are categorized as offending if they do not honor audio focus state changes. For
     * example - when an app loses audio focus, it is expected that the app stops any active
     * player in favor of the app(s) that gained audio focus. However, if the app do not stop the
     * audio playback, such players are termed as offenders.
     *
     * @return delay in milliseconds
     */
    @IntRange(from = 0) @DurationMillisLong
    public long getFadeInDelayForOffenders() {
        return mFadeInDelayForOffendersMillis;
    }

    /**
     * Query if fade is enabled
     *
     * @return {@code true} if fading is enabled, {@code false} otherwise
     */
    public boolean isFadeEnabled() {
        return mFadeState != FADE_STATE_DISABLED;
    }

    /**
     * Query if the usage is fadeable
     *
     * @param usage the {@link android.media.AudioAttributes usage}
     * @return {@code true} if usage is fadeable, {@code false}  when the fade state is set to
     *     {@link #FADE_STATE_DISABLED} or if the usage is not fadeable.
     */
    public boolean isUsageFadeable(@AudioAttributes.AttributeUsage int usage) {
        if (!isFadeEnabled()) {
            return false;
        }
        return mFadeableUsages.contains(usage);
    }

    /**
     * Query if the content type is unfadeable
     *
     * @param contentType the {@link android.media.AudioAttributes content type}
     * @return {@code true} if content type is unfadeable or if fade state is set to
     *     {@link #FADE_STATE_DISABLED}, {@code false} otherwise
     */
    public boolean isContentTypeUnfadeable(@AudioAttributes.AttributeContentType int contentType) {
        if (!isFadeEnabled()) {
            return true;
        }
        return mUnfadeableContentTypes.contains(contentType);
    }

    /**
     * Query if the player type is unfadeable
     *
     * @param playerType the {@link android.media.AudioPlaybackConfiguration player type}
     * @return {@code true} if player type is unfadeable or if fade state is set to
     *     {@link #FADE_STATE_DISABLED}, {@code false} otherwise
     */
    public boolean isPlayerTypeUnfadeable(@AudioPlaybackConfiguration.PlayerType int playerType) {
        if (!isFadeEnabled()) {
            return true;
        }
        return mUnfadeablePlayerTypes.contains(playerType);
    }

    /**
     * Query if the audio attributes is unfadeable
     *
     * @param audioAttributes the {@link android.media.AudioAttributes}
     * @return {@code true} if audio attributes is unfadeable or if fade state is set to
     *     {@link #FADE_STATE_DISABLED}, {@code false} otherwise
     * @throws NullPointerException if the audio attributes is {@code null}
     */
    public boolean isAudioAttributesUnfadeable(@NonNull AudioAttributes audioAttributes) {
        Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null");
        if (!isFadeEnabled()) {
            return true;
        }
        return mUnfadeableAudioAttributes.contains(audioAttributes);
    }

    /**
     * Query if the uid is unfadeable
     *
     * @param uid the uid of application
     * @return {@code true} if uid is unfadeable or if fade state is set to
     *     {@link #FADE_STATE_DISABLED}, {@code false} otherwise
     */
    public boolean isUidUnfadeable(int uid) {
        if (!isFadeEnabled()) {
            return true;
        }
        return mUnfadeableUids.contains(uid);
    }

    /**
     * Returns the default fade out duration (in milliseconds)
     */
    public static @IntRange(from = 1) @DurationMillisLong long getDefaultFadeOutDurationMillis() {
        return DEFAULT_FADE_OUT_DURATION_MS;
    }

    /**
     * Returns the default fade in duration (in milliseconds)
     */
    public static @IntRange(from = 1) @DurationMillisLong long getDefaultFadeInDurationMillis() {
        return DEFAULT_FADE_IN_DURATION_MS;
    }

    @Override
    public String toString() {
        return "FadeManagerConfiguration { fade state = " + fadeStateToString(mFadeState)
                + ", fade out duration = " + mFadeOutDurationMillis
                + ", fade in duration = " + mFadeInDurationMillis
                + ", offenders fade in delay = " + mFadeInDelayForOffendersMillis
                + ", fade volume shapers for audio attributes = " + mAttrToFadeWrapperMap
                + ", fadeable usages = " + mFadeableUsages.toString()
                + ", unfadeable content types = " + mUnfadeableContentTypes.toString()
                + ", unfadeable player types = " + mUnfadeablePlayerTypes.toString()
                + ", unfadeable uids = " + mUnfadeableUids.toString()
                + ", unfadeable audio attributes = " + mUnfadeableAudioAttributes + "}";
    }

    /**
     * Convert fade state into a human-readable string
     *
     * @param fadeState one of {@link #FADE_STATE_DISABLED} or {@link #FADE_STATE_ENABLED_DEFAULT}
     * @return human-readable string
     * @hide
     */
    @NonNull
    public static String fadeStateToString(@FadeStateEnum int fadeState) {
        switch (fadeState) {
            case FADE_STATE_DISABLED:
                return "FADE_STATE_DISABLED";
            case FADE_STATE_ENABLED_DEFAULT:
                return "FADE_STATE_ENABLED_DEFAULT";
            default:
                return "unknown fade state: " + fadeState;
        }
    }

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

        if (!(o instanceof FadeManagerConfiguration)) {
            return false;
        }

        FadeManagerConfiguration rhs = (FadeManagerConfiguration) o;

        return mUsageToFadeWrapperMap.contentEquals(rhs.mUsageToFadeWrapperMap)
                && mAttrToFadeWrapperMap.equals(rhs.mAttrToFadeWrapperMap)
                && Arrays.equals(mFadeableUsages.toArray(), rhs.mFadeableUsages.toArray())
                && Arrays.equals(mUnfadeableContentTypes.toArray(),
                rhs.mUnfadeableContentTypes.toArray())
                && Arrays.equals(mUnfadeablePlayerTypes.toArray(),
                rhs.mUnfadeablePlayerTypes.toArray())
                && Arrays.equals(mUnfadeableUids.toArray(), rhs.mUnfadeableUids.toArray())
                && mUnfadeableAudioAttributes.equals(rhs.mUnfadeableAudioAttributes)
                && mFadeState == rhs.mFadeState
                && mFadeOutDurationMillis == rhs.mFadeOutDurationMillis
                && mFadeInDurationMillis == rhs.mFadeInDurationMillis
                && mFadeInDelayForOffendersMillis == rhs.mFadeInDelayForOffendersMillis;
    }

    @Override
    public int hashCode() {
        return Objects.hash(mUsageToFadeWrapperMap, mAttrToFadeWrapperMap, mFadeableUsages,
                mUnfadeableContentTypes, mUnfadeablePlayerTypes, mUnfadeableAudioAttributes,
                mUnfadeableUids, mFadeState, mFadeOutDurationMillis, mFadeInDurationMillis,
                mFadeInDelayForOffendersMillis);
    }

    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        dest.writeInt(mFadeState);
        dest.writeLong(mFadeOutDurationMillis);
        dest.writeLong(mFadeInDurationMillis);
        dest.writeLong(mFadeInDelayForOffendersMillis);
        dest.writeTypedSparseArray(mUsageToFadeWrapperMap, flags);
        dest.writeMap(mAttrToFadeWrapperMap);
        dest.writeIntArray(mFadeableUsages.toArray());
        dest.writeIntArray(mUnfadeableContentTypes.toArray());
        dest.writeIntArray(mUnfadeablePlayerTypes.toArray());
        dest.writeIntArray(mUnfadeableUids.toArray());
        dest.writeTypedList(mUnfadeableAudioAttributes, flags);
    }

    /**
     * Creates fade manage configuration from parcel
     *
     * @hide
     */
    @VisibleForTesting()
    FadeManagerConfiguration(Parcel in) {
        int fadeState = in.readInt();
        long fadeOutDurationMillis = in.readLong();
        long fadeInDurationMillis = in.readLong();
        long fadeInDelayForOffenders = in.readLong();
        SparseArray<FadeVolumeShaperConfigsWrapper> usageToWrapperMap =
                in.createTypedSparseArray(FadeVolumeShaperConfigsWrapper.CREATOR);
        ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper> attrToFadeWrapperMap =
                new ArrayMap<>();
        in.readMap(attrToFadeWrapperMap, getClass().getClassLoader(), AudioAttributes.class,
                FadeVolumeShaperConfigsWrapper.class);
        int[] fadeableUsages = in.createIntArray();
        int[] unfadeableContentTypes = in.createIntArray();
        int[] unfadeablePlayerTypes = in.createIntArray();
        int[] unfadeableUids = in.createIntArray();
        List<AudioAttributes> unfadeableAudioAttributes = new ArrayList<>();
        in.readTypedList(unfadeableAudioAttributes, AudioAttributes.CREATOR);

        this.mFadeState = fadeState;
        this.mFadeOutDurationMillis = fadeOutDurationMillis;
        this.mFadeInDurationMillis = fadeInDurationMillis;
        this.mFadeInDelayForOffendersMillis = fadeInDelayForOffenders;
        this.mUsageToFadeWrapperMap = usageToWrapperMap;
        this.mAttrToFadeWrapperMap = attrToFadeWrapperMap;
        this.mFadeableUsages = IntArray.wrap(fadeableUsages);
        this.mUnfadeableContentTypes = IntArray.wrap(unfadeableContentTypes);
        this.mUnfadeablePlayerTypes = IntArray.wrap(unfadeablePlayerTypes);
        this.mUnfadeableUids = IntArray.wrap(unfadeableUids);
        this.mUnfadeableAudioAttributes = unfadeableAudioAttributes;
    }

    @NonNull
    public static final Creator<FadeManagerConfiguration> CREATOR = new Creator<>() {
        @Override
        @NonNull
        public FadeManagerConfiguration createFromParcel(@NonNull Parcel in) {
            return new FadeManagerConfiguration(in);
        }

        @Override
        @NonNull
        public FadeManagerConfiguration[] newArray(int size) {
            return new FadeManagerConfiguration[size];
        }
    };

    private long getDurationForVolumeShaperConfig(VolumeShaper.Configuration config) {
        return config != null ? config.getDuration() : DURATION_NOT_SET;
    }

    private VolumeShaper.Configuration getVolumeShaperConfigFromWrapper(
            FadeVolumeShaperConfigsWrapper wrapper, boolean isFadeIn) {
        // if no volume shaper config is available, return null
        if (wrapper == null) {
            return null;
        }
        if (isFadeIn) {
            return wrapper.getFadeInVolShaperConfig();
        }
        return wrapper.getFadeOutVolShaperConfig();
    }

    private List<AudioAttributes> getAudioAttributesInternal() {
        List<AudioAttributes> attrs = new ArrayList<>(mAttrToFadeWrapperMap.size());
        for (int index = 0; index < mAttrToFadeWrapperMap.size(); index++) {
            attrs.add(mAttrToFadeWrapperMap.keyAt(index));
        }
        return attrs;
    }

    private static boolean isUsageValid(int usage) {
        return AudioAttributes.isSdkUsage(usage) || AudioAttributes.isSystemUsage(usage)
                || AudioAttributes.isHiddenUsage(usage);
    }

    private void ensureFadingIsEnabled() {
        if (!isFadeEnabled()) {
            throw new IllegalStateException("Method call not allowed when fade is disabled");
        }
    }

    private static void validateUsage(int usage) {
        Preconditions.checkArgument(isUsageValid(usage), "Invalid usage: %s", usage);
    }

    private static IntArray convertIntegerListToIntArray(List<Integer> integerList) {
        if (integerList == null) {
            return new IntArray();
        }

        IntArray intArray = new IntArray(integerList.size());
        for (int index = 0; index < integerList.size(); index++) {
            intArray.add(integerList.get(index));
        }
        return intArray;
    }

    private static List<Integer> convertIntArrayToIntegerList(IntArray intArray) {
        if (intArray == null) {
            return new ArrayList<>();
        }

        ArrayList<Integer> integerArrayList = new ArrayList<>(intArray.size());
        for (int index = 0; index < intArray.size(); index++) {
            integerArrayList.add(intArray.get(index));
        }
        return integerArrayList;
    }

    /**
     * Builder class for {@link FadeManagerConfiguration} objects.
     *
     * <p><b>Notes:</b>
     * <ul>
     *     <li>When fade state is set to {@link #FADE_STATE_ENABLED_DEFAULT}, the builder expects at
     *     least one valid usage to be set/added. Failure to do so will result in an exception
     *     during {@link #build()}</li>
     *     <li>Every usage added to the fadeable list should have corresponding volume shaper
     *     configs defined. This can be achieved by setting either the duration or volume shaper
     *     config through {@link #setFadeOutDurationForUsage(int, long)} or
     *     {@link #setFadeOutVolumeShaperConfigForUsage(int, VolumeShaper.Configuration)}</li>
     *     <li> It is recommended to set volume shaper configurations individually for fade out and
     *     fade in</li>
     *     <li>For any incomplete volume shaper configurations, a volume shaper configuration will
     *     be created using either the default fade durations or the ones provided as part of the
     *     {@link #Builder(long, long)}</li>
     *     <li>Additional volume shaper configs can also configured for a given usage
     *     with additional attributes like content-type in order to achieve finer fade controls.
     *     See:
     *     {@link #setFadeOutVolumeShaperConfigForAudioAttributes(AudioAttributes,
     *     VolumeShaper.Configuration)} and
     *     {@link #setFadeInVolumeShaperConfigForAudioAttributes(AudioAttributes,
     *     VolumeShaper.Configuration)} </li>
     *     </ul>
     *
     */
    @SuppressWarnings("WeakerAccess")
    public static final class Builder {
        private static final int INVALID_INDEX = -1;
        private static final long IS_BUILDER_USED_FIELD_SET = 1 << 0;
        private static final long IS_FADEABLE_USAGES_FIELD_SET = 1 << 1;
        private static final long IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET = 1 << 2;

        /**
         * delay after which a faded out player will be faded back in. This will be heard by the
         * user only in the case of unmuting players that didn't respect audio focus and didn't
         * stop/pause when their app lost focus.
         * This is the amount of time between the app being notified of the focus loss
         * (when its muted by the fade out), and the time fade in (to unmute) starts
         */
        private static final long DEFAULT_DELAY_FADE_IN_OFFENDERS_MS = 2_000;


        private static final IntArray DEFAULT_UNFADEABLE_PLAYER_TYPES = IntArray.wrap(new int[]{
                AudioPlaybackConfiguration.PLAYER_TYPE_AAUDIO,
                AudioPlaybackConfiguration.PLAYER_TYPE_JAM_SOUNDPOOL
        });

        private static final IntArray DEFAULT_UNFADEABLE_CONTENT_TYPES = IntArray.wrap(new int[]{
                AudioAttributes.CONTENT_TYPE_SPEECH
        });

        private static final IntArray DEFAULT_FADEABLE_USAGES = IntArray.wrap(new int[]{
                AudioAttributes.USAGE_GAME,
                AudioAttributes.USAGE_MEDIA
        });

        private int mFadeState = FADE_STATE_ENABLED_DEFAULT;
        private @DurationMillisLong long mFadeInDelayForOffendersMillis =
                DEFAULT_DELAY_FADE_IN_OFFENDERS_MS;
        private @DurationMillisLong long mFadeOutDurationMillis;
        private @DurationMillisLong long mFadeInDurationMillis;
        private long mBuilderFieldsSet;
        private SparseArray<FadeVolumeShaperConfigsWrapper> mUsageToFadeWrapperMap =
                new SparseArray<>();
        private ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper> mAttrToFadeWrapperMap =
                new ArrayMap<>();
        private IntArray mFadeableUsages = new IntArray();
        private IntArray mUnfadeableContentTypes = new IntArray();
        // Player types are not yet configurable
        private IntArray mUnfadeablePlayerTypes = DEFAULT_UNFADEABLE_PLAYER_TYPES;
        private IntArray mUnfadeableUids = new IntArray();
        private List<AudioAttributes> mUnfadeableAudioAttributes = new ArrayList<>();

        /**
         * Constructs a new Builder with {@link #DEFAULT_FADE_OUT_DURATION_MS} and
         * {@link #DEFAULT_FADE_IN_DURATION_MS} durations.
         */
        public Builder() {
            mFadeOutDurationMillis = DEFAULT_FADE_OUT_DURATION_MS;
            mFadeInDurationMillis = DEFAULT_FADE_IN_DURATION_MS;
        }

        /**
         * Constructs a new Builder with the provided fade out and fade in durations
         *
         * @param fadeOutDurationMillis duration in milliseconds used for fading out
         * @param fadeInDurationMills duration in milliseconds used for fading in
         */
        public Builder(@IntRange(from = 1) @DurationMillisLong long fadeOutDurationMillis,
                @IntRange(from = 1) @DurationMillisLong long fadeInDurationMills) {
            mFadeOutDurationMillis = fadeOutDurationMillis;
            mFadeInDurationMillis = fadeInDurationMills;
        }

        /**
         * Constructs a new Builder from the given {@link FadeManagerConfiguration}
         *
         * @param fmc the {@link FadeManagerConfiguration} object whose data will be reused in the
         *            new builder
         */
        public Builder(@NonNull FadeManagerConfiguration fmc) {
            mFadeState = fmc.mFadeState;
            copyUsageToFadeWrapperMapInternal(fmc.mUsageToFadeWrapperMap);
            mAttrToFadeWrapperMap = new ArrayMap<AudioAttributes, FadeVolumeShaperConfigsWrapper>(
                    fmc.mAttrToFadeWrapperMap);
            mFadeableUsages = fmc.mFadeableUsages.clone();
            setFlag(IS_FADEABLE_USAGES_FIELD_SET);
            mUnfadeableContentTypes = fmc.mUnfadeableContentTypes.clone();
            setFlag(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET);
            mUnfadeablePlayerTypes = fmc.mUnfadeablePlayerTypes.clone();
            mUnfadeableUids = fmc.mUnfadeableUids.clone();
            mUnfadeableAudioAttributes = new ArrayList<>(fmc.mUnfadeableAudioAttributes);
            mFadeOutDurationMillis = fmc.mFadeOutDurationMillis;
            mFadeInDurationMillis = fmc.mFadeInDurationMillis;
        }

        /**
         * Set the overall fade state
         *
         * @param state one of the {@link #FADE_STATE_DISABLED} or
         *     {@link #FADE_STATE_ENABLED_DEFAULT} states
         * @return the same Builder instance
         * @throws IllegalArgumentException if the fade state is invalid
         * @see #getFadeState()
         */
        @NonNull
        public Builder setFadeState(@FadeStateEnum int state) {
            validateFadeState(state);
            mFadeState = state;
            return this;
        }

        /**
         * Set the {@link android.media.VolumeShaper.Configuration} used to fade out players with
         * {@link android.media.AudioAttributes usage}
         * <p>
         * This method accepts {@code null} for volume shaper config to clear a previously set
         * configuration (example, if set through
         * {@link #Builder(android.media.FadeManagerConfiguration)})
         *
         * @param usage the {@link android.media.AudioAttributes usage} of target player
         * @param fadeOutVShaperConfig the {@link android.media.VolumeShaper.Configuration} used
         *     to fade out players with usage
         * @return the same Builder instance
         * @throws IllegalArgumentException if the usage is invalid
         * @see #getFadeOutVolumeShaperConfigForUsage(int)
         */
        @NonNull
        public Builder setFadeOutVolumeShaperConfigForUsage(
                @AudioAttributes.AttributeUsage int usage,
                @Nullable VolumeShaper.Configuration fadeOutVShaperConfig) {
            validateUsage(usage);
            getFadeVolShaperConfigWrapperForUsage(usage)
                    .setFadeOutVolShaperConfig(fadeOutVShaperConfig);
            cleanupInactiveWrapperEntries(usage);
            return this;
        }

        /**
         * Set the {@link android.media.VolumeShaper.Configuration} used to fade in players with
         * {@link android.media.AudioAttributes usage}
         * <p>
         * This method accepts {@code null} for volume shaper config to clear a previously set
         * configuration (example, if set through
         * {@link #Builder(android.media.FadeManagerConfiguration)})
         *
         * @param usage the {@link android.media.AudioAttributes usage}
         * @param fadeInVShaperConfig the {@link android.media.VolumeShaper.Configuration} used
         *     to fade in players with usage
         * @return the same Builder instance
         * @throws IllegalArgumentException if the usage is invalid
         * @see #getFadeInVolumeShaperConfigForUsage(int)
         */
        @NonNull
        public Builder setFadeInVolumeShaperConfigForUsage(
                @AudioAttributes.AttributeUsage int usage,
                @Nullable VolumeShaper.Configuration fadeInVShaperConfig) {
            validateUsage(usage);
            getFadeVolShaperConfigWrapperForUsage(usage)
                    .setFadeInVolShaperConfig(fadeInVShaperConfig);
            cleanupInactiveWrapperEntries(usage);
            return this;
        }

        /**
         * Set the duration used for fading out players with
         * {@link android.media.AudioAttributes usage}
         * <p>
         * A Volume shaper configuration is generated with the provided duration and default
         * volume curve definitions. This config is then used to fade out players with given usage.
         * <p>
         * In order to clear previously set duration (example, if set through
         * {@link #Builder(android.media.FadeManagerConfiguration)}), this method accepts
         * {@link #DURATION_NOT_SET} and sets the corresponding fade out volume shaper config to
         * {@code null}
         *
         * @param usage the {@link android.media.AudioAttributes usage} of target player
         * @param fadeOutDurationMillis positive duration in milliseconds or
         *     {@link #DURATION_NOT_SET}
         * @return the same Builder instance
         * @throws IllegalArgumentException if the fade out duration is non-positive with the
         *     exception of {@link #DURATION_NOT_SET}
         * @see #setFadeOutVolumeShaperConfigForUsage(int, VolumeShaper.Configuration)
         * @see #getFadeOutDurationForUsage(int)
         */
        @NonNull
        public Builder setFadeOutDurationForUsage(@AudioAttributes.AttributeUsage int usage,
                @IntRange(from = 0) @DurationMillisLong long fadeOutDurationMillis) {
            validateUsage(usage);
            VolumeShaper.Configuration fadeOutVShaperConfig =
                    createVolShaperConfigForDuration(fadeOutDurationMillis, /* isFadeIn= */ false);
            setFadeOutVolumeShaperConfigForUsage(usage, fadeOutVShaperConfig);
            return this;
        }

        /**
         * Set the duration used for fading in players with
         * {@link android.media.AudioAttributes usage}
         * <p>
         * A Volume shaper configuration is generated with the provided duration and default
         * volume curve definitions. This config is then used to fade in players with given usage.
         * <p>
         * <b>Note: </b>In order to clear previously set duration (example, if set through
         * {@link #Builder(android.media.FadeManagerConfiguration)}), this method accepts
         * {@link #DURATION_NOT_SET} and sets the corresponding fade in volume shaper config to
         * {@code null}
         *
         * @param usage the {@link android.media.AudioAttributes usage} of target player
         * @param fadeInDurationMillis positive duration in milliseconds or
         *     {@link #DURATION_NOT_SET}
         * @return the same Builder instance
         * @throws IllegalArgumentException if the fade in duration is non-positive with the
         *     exception of {@link #DURATION_NOT_SET}
         * @see #setFadeInVolumeShaperConfigForUsage(int, VolumeShaper.Configuration)
         * @see #getFadeInDurationForUsage(int)
         */
        @NonNull
        public Builder setFadeInDurationForUsage(@AudioAttributes.AttributeUsage int usage,
                @IntRange(from = 0) @DurationMillisLong long fadeInDurationMillis) {
            validateUsage(usage);
            VolumeShaper.Configuration fadeInVShaperConfig =
                    createVolShaperConfigForDuration(fadeInDurationMillis, /* isFadeIn= */ true);
            setFadeInVolumeShaperConfigForUsage(usage, fadeInVShaperConfig);
            return this;
        }

        /**
         * Set the {@link android.media.VolumeShaper.Configuration} used to fade out players with
         * {@link android.media.AudioAttributes}
         * <p>
         * This method accepts {@code null} for volume shaper config to clear a previously set
         * configuration (example, set through
         * {@link #Builder(android.media.FadeManagerConfiguration)})
         *
         * @param audioAttributes the {@link android.media.AudioAttributes}
         * @param fadeOutVShaperConfig the {@link android.media.VolumeShaper.Configuration} used to
         *     fade out players with audio attribute
         * @return the same Builder instance
         * @see #getFadeOutVolumeShaperConfigForAudioAttributes(AudioAttributes)
         */
        @NonNull
        public Builder setFadeOutVolumeShaperConfigForAudioAttributes(
                @NonNull AudioAttributes audioAttributes,
                @Nullable VolumeShaper.Configuration fadeOutVShaperConfig) {
            Objects.requireNonNull(audioAttributes, "Audio attribute cannot be null");
            getFadeVolShaperConfigWrapperForAttr(audioAttributes)
                    .setFadeOutVolShaperConfig(fadeOutVShaperConfig);
            cleanupInactiveWrapperEntries(audioAttributes);
            return this;
        }

        /**
         * Set the {@link android.media.VolumeShaper.Configuration} used to fade in players with
         * {@link android.media.AudioAttributes}
         *
         * <p>This method accepts {@code null} for volume shaper config to clear a previously set
         * configuration (example, set through
         * {@link #Builder(android.media.FadeManagerConfiguration)})
         *
         * @param audioAttributes the {@link android.media.AudioAttributes}
         * @param fadeInVShaperConfig the {@link android.media.VolumeShaper.Configuration} used to
         *     fade in players with audio attribute
         * @return the same Builder instance
         * @throws NullPointerException if the audio attributes is {@code null}
         * @see #getFadeInVolumeShaperConfigForAudioAttributes(AudioAttributes)
         */
        @NonNull
        public Builder setFadeInVolumeShaperConfigForAudioAttributes(
                @NonNull AudioAttributes audioAttributes,
                @Nullable VolumeShaper.Configuration fadeInVShaperConfig) {
            Objects.requireNonNull(audioAttributes, "Audio attribute cannot be null");
            getFadeVolShaperConfigWrapperForAttr(audioAttributes)
                    .setFadeInVolShaperConfig(fadeInVShaperConfig);
            cleanupInactiveWrapperEntries(audioAttributes);
            return this;
        }

        /**
         * Set the duration used for fading out players of type
         * {@link android.media.AudioAttributes}.
         * <p>
         * A Volume shaper configuration is generated with the provided duration and default
         * volume curve definitions. This config is then used to fade out players with given usage.
         * <p>
         * <b>Note: </b>In order to clear previously set duration (example, if set through
         * {@link #Builder(android.media.FadeManagerConfiguration)}), this method accepts
         * {@link #DURATION_NOT_SET} and sets the corresponding fade out volume shaper config to
         * {@code null}
         *
         * @param audioAttributes the {@link android.media.AudioAttributes} for which the fade out
         *     duration will be set/updated/reset
         * @param fadeOutDurationMillis positive duration in milliseconds or
         *     {@link #DURATION_NOT_SET}
         * @return the same Builder instance
         * @throws IllegalArgumentException if the fade out duration is non-positive with the
         *     exception of {@link #DURATION_NOT_SET}
         * @see #getFadeOutDurationForAudioAttributes(AudioAttributes)
         * @see #setFadeOutVolumeShaperConfigForAudioAttributes(AudioAttributes,
         * VolumeShaper.Configuration)
         */
        @NonNull
        public Builder setFadeOutDurationForAudioAttributes(
                @NonNull AudioAttributes audioAttributes,
                @IntRange(from = 0) @DurationMillisLong long fadeOutDurationMillis) {
            Objects.requireNonNull(audioAttributes, "Audio attribute cannot be null");
            VolumeShaper.Configuration fadeOutVShaperConfig =
                    createVolShaperConfigForDuration(fadeOutDurationMillis, /* isFadeIn= */ false);
            setFadeOutVolumeShaperConfigForAudioAttributes(audioAttributes, fadeOutVShaperConfig);
            return this;
        }

        /**
         * Set the duration used for fading in players of type {@link android.media.AudioAttributes}
         * <p>
         * A Volume shaper configuration is generated with the provided duration and default
         * volume curve definitions. This config is then used to fade in players with given usage.
         * <p>
         * <b>Note: </b>In order to clear previously set duration (example, if set through
         * {@link #Builder(android.media.FadeManagerConfiguration)}), this method accepts
         * {@link #DURATION_NOT_SET} and sets the corresponding fade in volume shaper config to
         * {@code null}
         *
         * @param audioAttributes the {@link android.media.AudioAttributes} for which the fade in
         *     duration will be set/updated/reset
         * @param fadeInDurationMillis positive duration in milliseconds or
         *     {@link #DURATION_NOT_SET}
         * @return the same Builder instance
         * @throws IllegalArgumentException if the fade in duration is non-positive with the
         *     exception of {@link #DURATION_NOT_SET}
         * @see #getFadeInDurationForAudioAttributes(AudioAttributes)
         * @see #setFadeInVolumeShaperConfigForAudioAttributes(AudioAttributes,
         * VolumeShaper.Configuration)
         */
        @NonNull
        public Builder setFadeInDurationForAudioAttributes(@NonNull AudioAttributes audioAttributes,
                @IntRange(from = 0) @DurationMillisLong long fadeInDurationMillis) {
            Objects.requireNonNull(audioAttributes, "Audio attribute cannot be null");
            VolumeShaper.Configuration fadeInVShaperConfig =
                    createVolShaperConfigForDuration(fadeInDurationMillis, /* isFadeIn= */ true);
            setFadeInVolumeShaperConfigForAudioAttributes(audioAttributes, fadeInVShaperConfig);
            return this;
        }

        /**
         * Set the list of {@link android.media.AudioAttributes usage} that can be faded
         *
         * <p>This is a positive list. Players with matching usage will be considered for fading.
         * Usages that are not part of this list will not be faded
         *
         * <p><b>Warning:</b> When fade state is set to enabled, the builder expects at least one
         * usage to be set/added. Failure to do so will result in an exception during
         * {@link #build()}
         *
         * @param usages List of the {@link android.media.AudioAttributes usages}
         * @return the same Builder instance
         * @throws IllegalArgumentException if the usages are invalid
         * @see #getFadeableUsages()
         */
        @NonNull
        public Builder setFadeableUsages(@NonNull List<Integer> usages) {
            Objects.requireNonNull(usages, "List of usages cannot be null");
            validateUsages(usages);
            setFlag(IS_FADEABLE_USAGES_FIELD_SET);
            mFadeableUsages.clear();
            mFadeableUsages.addAll(convertIntegerListToIntArray(usages));
            return this;
        }

        /**
         * Add the {@link android.media.AudioAttributes usage} to the fadeable list
         *
         * @param usage the {@link android.media.AudioAttributes usage}
         * @return the same Builder instance
         * @throws IllegalArgumentException if the usage is invalid
         * @see #getFadeableUsages()
         * @see #setFadeableUsages(List)
         */
        @NonNull
        public Builder addFadeableUsage(@AudioAttributes.AttributeUsage int usage) {
            validateUsage(usage);
            setFlag(IS_FADEABLE_USAGES_FIELD_SET);
            if (!mFadeableUsages.contains(usage)) {
                mFadeableUsages.add(usage);
            }
            return this;
        }

        /**
         * Clears the fadeable {@link android.media.AudioAttributes usage} list
         *
         * <p>This can be used to reset the list when using a copy constructor
         *
         * @return the same Builder instance
         * @see #getFadeableUsages()
         * @see #setFadeableUsages(List)
         */
        @NonNull
        public Builder clearFadeableUsages() {
            setFlag(IS_FADEABLE_USAGES_FIELD_SET);
            mFadeableUsages.clear();
            return this;
        }

        /**
         * Set the list of {@link android.media.AudioAttributes content type} that can not be faded
         *
         * <p>This is a negative list. Players with matching content type of this list will not be
         * faded. Content types that are not part of this list will be considered for fading.
         *
         * <p>Passing an empty list as input clears the existing list. This can be used to
         * reset the list when using a copy constructor
         *
         * @param contentTypes list of {@link android.media.AudioAttributes content types}
         * @return the same Builder instance
         * @throws IllegalArgumentException if the content types are invalid
         * @see #getUnfadeableContentTypes()
         */
        @NonNull
        public Builder setUnfadeableContentTypes(@NonNull List<Integer> contentTypes) {
            Objects.requireNonNull(contentTypes, "List of content types cannot be null");
            validateContentTypes(contentTypes);
            setFlag(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET);
            mUnfadeableContentTypes.clear();
            mUnfadeableContentTypes.addAll(convertIntegerListToIntArray(contentTypes));
            return this;
        }

        /**
         * Add the {@link android.media.AudioAttributes content type} to unfadeable list
         *
         * @param contentType the {@link android.media.AudioAttributes content type}
         * @return the same Builder instance
         * @throws IllegalArgumentException if the content type is invalid
         * @see #setUnfadeableContentTypes(List)
         * @see #getUnfadeableContentTypes()
         */
        @NonNull
        public Builder addUnfadeableContentType(
                @AudioAttributes.AttributeContentType int contentType) {
            validateContentType(contentType);
            setFlag(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET);
            if (!mUnfadeableContentTypes.contains(contentType)) {
                mUnfadeableContentTypes.add(contentType);
            }
            return this;
        }

        /**
         * Clears the unfadeable {@link android.media.AudioAttributes content type} list
         *
         * <p>This can be used to reset the list when using a copy constructor
         *
         * @return the same Builder instance
         * @see #setUnfadeableContentTypes(List)
         * @see #getUnfadeableContentTypes()
         */
        @NonNull
        public Builder clearUnfadeableContentTypes() {
            setFlag(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET);
            mUnfadeableContentTypes.clear();
            return this;
        }

        /**
         * Set the uids that cannot be faded
         *
         * <p>This is a negative list. Players with matching uid of this list will not be faded.
         * Uids that are not part of this list shall be considered for fading.
         *
         * @param uids list of uids
         * @return the same Builder instance
         * @see #getUnfadeableUids()
         */
        @NonNull
        public Builder setUnfadeableUids(@NonNull List<Integer> uids) {
            Objects.requireNonNull(uids, "List of uids cannot be null");
            mUnfadeableUids.clear();
            mUnfadeableUids.addAll(convertIntegerListToIntArray(uids));
            return this;
        }

        /**
         * Add uid to unfadeable list
         *
         * @param uid client uid
         * @return the same Builder instance
         * @see #setUnfadeableUids(List)
         * @see #getUnfadeableUids()
         */
        @NonNull
        public Builder addUnfadeableUid(int uid) {
            if (!mUnfadeableUids.contains(uid)) {
                mUnfadeableUids.add(uid);
            }
            return this;
        }

        /**
         * Clears the unfadeable uid list
         *
         * <p>This can be used to reset the list when using a copy constructor.
         *
         * @return the same Builder instance
         * @see #setUnfadeableUids(List)
         * @see #getUnfadeableUids()
         */
        @NonNull
        public Builder clearUnfadeableUids() {
            mUnfadeableUids.clear();
            return this;
        }

        /**
         * Set the list of {@link android.media.AudioAttributes} that can not be faded
         *
         * <p>This is a negative list. Players with matching audio attributes of this list will not
         * be faded. Audio attributes that are not part of this list shall be considered for fading.
         *
         * <p><b>Note:</b> Be cautious when adding generic audio attributes into this list as it can
         * negatively impact fadeability decision (if such an audio attribute and corresponding
         * usage fall into opposing lists).
         * For example:
         * <pre class=prettyprint>
         *    AudioAttributes.Builder().setUsage(AudioAttributes.USAGE_MEDIA).build() </pre>
         * is a generic audio attribute for {@link android.media.AudioAttributes.USAGE_MEDIA}.
         * It is an undefined behavior to have an {@link android.media.AudioAttributes usage} in the
         * fadeable usage list and the corresponding generic {@link android.media.AudioAttributes}
         * in the unfadeable list. Such cases will result in an exception during {@link #build()}.
         *
         * @param attrs list of {@link android.media.AudioAttributes}
         * @return the same Builder instance
         * @see #getUnfadeableAudioAttributes()
         */
        @NonNull
        public Builder setUnfadeableAudioAttributes(@NonNull List<AudioAttributes> attrs) {
            Objects.requireNonNull(attrs, "List of audio attributes cannot be null");
            mUnfadeableAudioAttributes.clear();
            mUnfadeableAudioAttributes.addAll(attrs);
            return this;
        }

        /**
         * Add the {@link android.media.AudioAttributes} to the unfadeable list
         *
         * @param audioAttributes the {@link android.media.AudioAttributes}
         * @return the same Builder instance
         * @see #setUnfadeableAudioAttributes(List)
         * @see #getUnfadeableAudioAttributes()
         */
        @NonNull
        public Builder addUnfadeableAudioAttributes(@NonNull AudioAttributes audioAttributes) {
            Objects.requireNonNull(audioAttributes, "Audio attributes cannot be null");
            if (!mUnfadeableAudioAttributes.contains(audioAttributes)) {
                mUnfadeableAudioAttributes.add(audioAttributes);
            }
            return this;
        }

        /**
         * Clears the unfadeable {@link android.media.AudioAttributes} list.
         *
         * <p>This can be used to reset the list when using a copy constructor.
         *
         * @return the same Builder instance
         * @see #getUnfadeableAudioAttributes()
         */
        @NonNull
        public Builder clearUnfadeableAudioAttributes() {
            mUnfadeableAudioAttributes.clear();
            return this;
        }

        /**
         * Set the delay after which the offending faded out player will be faded in.
         *
         * <p>This is the amount of time between the app being notified of the focus loss (when its
         * muted by the fade out), and the time fade in (to unmute) starts
         *
         * @param delayMillis delay in milliseconds
         * @return the same Builder instance
         * @throws IllegalArgumentException if the delay is negative
         * @see #getFadeInDelayForOffenders()
         */
        @NonNull
        public Builder setFadeInDelayForOffenders(
                @IntRange(from = 0) @DurationMillisLong long delayMillis) {
            Preconditions.checkArgument(delayMillis >= 0, "Delay cannot be negative");
            mFadeInDelayForOffendersMillis = delayMillis;
            return this;
        }

        /**
         * Builds the {@link FadeManagerConfiguration} with all of the fade configurations that
         * have been set.
         *
         * @return a new {@link FadeManagerConfiguration} object
         */
        @NonNull
        public FadeManagerConfiguration build() {
            if (!checkNotSet(IS_BUILDER_USED_FIELD_SET)) {
                throw new IllegalStateException(
                        "This Builder should not be reused. Use a new Builder instance instead");
            }

            setFlag(IS_BUILDER_USED_FIELD_SET);

            if (checkNotSet(IS_FADEABLE_USAGES_FIELD_SET)) {
                mFadeableUsages = DEFAULT_FADEABLE_USAGES;
                setVolShaperConfigsForUsages(mFadeableUsages);
            }

            if (checkNotSet(IS_UNFADEABLE_CONTENT_TYPE_FIELD_SET)) {
                mUnfadeableContentTypes = DEFAULT_UNFADEABLE_CONTENT_TYPES;
            }

            validateFadeConfigurations();

            return new FadeManagerConfiguration(mFadeState, mFadeOutDurationMillis,
                    mFadeInDurationMillis, mFadeInDelayForOffendersMillis, mUsageToFadeWrapperMap,
                    mAttrToFadeWrapperMap, mFadeableUsages, mUnfadeableContentTypes,
                    mUnfadeablePlayerTypes, mUnfadeableUids, mUnfadeableAudioAttributes);
        }

        private void setFlag(long flag) {
            mBuilderFieldsSet |= flag;
        }

        private boolean checkNotSet(long flag) {
            return (mBuilderFieldsSet & flag) == 0;
        }

        private FadeVolumeShaperConfigsWrapper getFadeVolShaperConfigWrapperForUsage(int usage) {
            if (!mUsageToFadeWrapperMap.contains(usage)) {
                mUsageToFadeWrapperMap.put(usage, new FadeVolumeShaperConfigsWrapper());
            }
            return mUsageToFadeWrapperMap.get(usage);
        }

        private FadeVolumeShaperConfigsWrapper getFadeVolShaperConfigWrapperForAttr(
                AudioAttributes attr) {
            // if no entry, create a new one for setting/clearing
            if (!mAttrToFadeWrapperMap.containsKey(attr)) {
                mAttrToFadeWrapperMap.put(attr, new FadeVolumeShaperConfigsWrapper());
            }
            return mAttrToFadeWrapperMap.get(attr);
        }

        private VolumeShaper.Configuration createVolShaperConfigForDuration(long duration,
                boolean isFadeIn) {
            // used to reset the volume shaper config setting
            if (duration == DURATION_NOT_SET) {
                return null;
            }

            VolumeShaper.Configuration.Builder builder = new VolumeShaper.Configuration.Builder()
                    .setId(VOLUME_SHAPER_SYSTEM_FADE_ID)
                    .setOptionFlags(VolumeShaper.Configuration.OPTION_FLAG_CLOCK_TIME)
                    .setDuration(duration);

            if (isFadeIn) {
                builder.setCurve(/* times= */ new float[]{0.f, 0.50f, 1.0f},
                        /* volumes= */ new float[]{0.f, 0.30f, 1.0f});
            } else {
                builder.setCurve(/* times= */ new float[]{0.f, 0.25f, 1.0f},
                        /* volumes= */ new float[]{1.f, 0.65f, 0.0f});
            }

            return builder.build();
        }

        private void cleanupInactiveWrapperEntries(int usage) {
            FadeVolumeShaperConfigsWrapper fmcw = mUsageToFadeWrapperMap.get(usage);
            // cleanup map entry if FadeVolumeShaperConfigWrapper is inactive
            if (fmcw != null && fmcw.isInactive()) {
                mUsageToFadeWrapperMap.remove(usage);
            }
        }

        private void cleanupInactiveWrapperEntries(AudioAttributes attr) {
            FadeVolumeShaperConfigsWrapper fmcw = mAttrToFadeWrapperMap.get(attr);
            // cleanup map entry if FadeVolumeShaperConfigWrapper is inactive
            if (fmcw != null && fmcw.isInactive()) {
                mAttrToFadeWrapperMap.remove(attr);
            }
        }

        private void setVolShaperConfigsForUsages(IntArray usages) {
            // set default volume shaper configs for fadeable usages
            for (int index = 0; index < usages.size(); index++) {
                setMissingVolShaperConfigsForWrapper(
                        getFadeVolShaperConfigWrapperForUsage(usages.get(index)));
            }
        }

        private void setMissingVolShaperConfigsForWrapper(FadeVolumeShaperConfigsWrapper wrapper) {
            if (!wrapper.isFadeOutConfigActive()) {
                wrapper.setFadeOutVolShaperConfig(createVolShaperConfigForDuration(
                        mFadeOutDurationMillis, /* isFadeIn= */ false));
            }
            if (!wrapper.isFadeInConfigActive()) {
                wrapper.setFadeInVolShaperConfig(createVolShaperConfigForDuration(
                        mFadeInDurationMillis, /* isFadeIn= */ true));
            }
        }

        private  void copyUsageToFadeWrapperMapInternal(
                SparseArray<FadeVolumeShaperConfigsWrapper> usageToFadeWrapperMap) {
            for (int index = 0; index < usageToFadeWrapperMap.size(); index++) {
                mUsageToFadeWrapperMap.put(usageToFadeWrapperMap.keyAt(index),
                        new FadeVolumeShaperConfigsWrapper(usageToFadeWrapperMap.valueAt(index)));
            }
        }

        private void validateFadeState(int state) {
            switch(state) {
                case FADE_STATE_DISABLED:
                case FADE_STATE_ENABLED_DEFAULT:
                    break;
                default:
                    throw new IllegalArgumentException("Unknown fade state: " + state);
            }
        }

        private void validateUsages(List<Integer> usages) {
            for (int index = 0; index < usages.size(); index++) {
                validateUsage(usages.get(index));
            }
        }

        private void validateContentTypes(List<Integer> contentTypes) {
            for (int index = 0; index < contentTypes.size(); index++) {
                validateContentType(contentTypes.get(index));
            }
        }

        private void validateContentType(int contentType) {
            Preconditions.checkArgument(AudioAttributes.isSdkContentType(contentType),
                    "Invalid content type: ", contentType);
        }

        private void validateFadeConfigurations() {
            validateFadeableUsages();
            validateFadeVolumeShaperConfigsWrappers();
            validateUnfadeableAudioAttributes();
        }

        /** Ensure fadeable usage list meets config requirements */
        private void validateFadeableUsages() {
            // ensure at least one fadeable usage
            Preconditions.checkArgumentPositive(mFadeableUsages.size(),
                    "Fadeable usage list cannot be empty when state set to enabled");
            // ensure all fadeable usages have volume shaper configs - both fade in and out
            for (int index = 0; index < mFadeableUsages.size(); index++) {
                setMissingVolShaperConfigsForWrapper(
                        getFadeVolShaperConfigWrapperForUsage(mFadeableUsages.get(index)));
            }
        }

        /** Ensure Fade volume shaper config wrappers meet requirements */
        private void validateFadeVolumeShaperConfigsWrappers() {
            // ensure both fade in & out volume shaper configs are defined for all wrappers
            // for usages -
            for (int index = 0; index < mUsageToFadeWrapperMap.size(); index++) {
                setMissingVolShaperConfigsForWrapper(
                        getFadeVolShaperConfigWrapperForUsage(mUsageToFadeWrapperMap.keyAt(index)));
            }

            // for additional audio attributes -
            for (int index = 0; index < mAttrToFadeWrapperMap.size(); index++) {
                setMissingVolShaperConfigsForWrapper(
                        getFadeVolShaperConfigWrapperForAttr(mAttrToFadeWrapperMap.keyAt(index)));
            }
        }

        /** Ensure Unfadeable attributes meet configuration requirements */
        private void validateUnfadeableAudioAttributes() {
            // ensure no generic AudioAttributes in unfadeable list with matching usage in fadeable
            // list. failure results in an undefined behavior as the audio attributes
            // shall be both fadeable (because of the usage) and unfadeable at the same time.
            for (int index = 0; index < mUnfadeableAudioAttributes.size(); index++) {
                AudioAttributes targetAttr = mUnfadeableAudioAttributes.get(index);
                int usage = targetAttr.getSystemUsage();
                boolean isFadeableUsage = mFadeableUsages.contains(usage);
                // cannot have a generic audio attribute that also is a fadeable usage
                Preconditions.checkArgument(
                        !isFadeableUsage || (isFadeableUsage && !isGeneric(targetAttr)),
                        "Unfadeable audio attributes cannot be generic of the fadeable usage");
            }
        }

        private static boolean isGeneric(AudioAttributes attr) {
            return (attr.getContentType() == AudioAttributes.CONTENT_TYPE_UNKNOWN
                    && attr.getFlags() == 0x0
                    && attr.getBundle() == null
                    && attr.getTags().isEmpty());
        }
    }

    private static final class FadeVolumeShaperConfigsWrapper implements Parcelable {
        // null volume shaper config refers to either init state or if its cleared/reset
        private @Nullable VolumeShaper.Configuration mFadeOutVolShaperConfig;
        private @Nullable VolumeShaper.Configuration mFadeInVolShaperConfig;

        FadeVolumeShaperConfigsWrapper() {}

        FadeVolumeShaperConfigsWrapper(@NonNull FadeVolumeShaperConfigsWrapper wrapper) {
            Objects.requireNonNull(wrapper, "Fade volume shaper configs wrapper cannot be null");
            this.mFadeOutVolShaperConfig = wrapper.mFadeOutVolShaperConfig;
            this.mFadeInVolShaperConfig = wrapper.mFadeInVolShaperConfig;
        }

        public void setFadeOutVolShaperConfig(@Nullable VolumeShaper.Configuration fadeOutConfig) {
            mFadeOutVolShaperConfig = fadeOutConfig;
        }

        public void setFadeInVolShaperConfig(@Nullable VolumeShaper.Configuration fadeInConfig) {
            mFadeInVolShaperConfig = fadeInConfig;
        }

        /**
         * Query fade out volume shaper config
         *
         * @return configured fade out volume shaper config or {@code null} when initialized/reset
         */
        @Nullable
        public VolumeShaper.Configuration getFadeOutVolShaperConfig() {
            return mFadeOutVolShaperConfig;
        }

        /**
         * Query fade in volume shaper config
         *
         * @return configured fade in volume shaper config or {@code null} when initialized/reset
         */
        @Nullable
        public VolumeShaper.Configuration getFadeInVolShaperConfig() {
            return mFadeInVolShaperConfig;
        }

        /**
         * Wrapper is inactive if both fade out and in configs are cleared.
         *
         * @return {@code true} if configs are cleared. {@code false} if either of the configs is
         * set
         */
        public boolean isInactive() {
            return !isFadeOutConfigActive() && !isFadeInConfigActive();
        }

        boolean isFadeOutConfigActive() {
            return mFadeOutVolShaperConfig != null;
        }

        boolean isFadeInConfigActive() {
            return mFadeInVolShaperConfig != null;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }

            if (!(o instanceof FadeVolumeShaperConfigsWrapper)) {
                return false;
            }

            FadeVolumeShaperConfigsWrapper rhs = (FadeVolumeShaperConfigsWrapper) o;

            if (mFadeInVolShaperConfig == null && rhs.mFadeInVolShaperConfig == null
                    && mFadeOutVolShaperConfig == null && rhs.mFadeOutVolShaperConfig == null) {
                return true;
            }

            boolean isEqual;
            if (mFadeOutVolShaperConfig != null) {
                isEqual = mFadeOutVolShaperConfig.equals(rhs.mFadeOutVolShaperConfig);
            } else if (rhs.mFadeOutVolShaperConfig != null) {
                return false;
            } else {
                isEqual = true;
            }

            if (mFadeInVolShaperConfig != null) {
                isEqual = isEqual && mFadeInVolShaperConfig.equals(rhs.mFadeInVolShaperConfig);
            } else if (rhs.mFadeInVolShaperConfig != null) {
                return false;
            }

            return isEqual;
        }

        @Override
        public int hashCode() {
            return Objects.hash(mFadeOutVolShaperConfig, mFadeInVolShaperConfig);
        }

        @Override
        public int describeContents() {
            return 0;
        }

        @Override
        public void writeToParcel(@NonNull Parcel dest, int flags) {
            mFadeOutVolShaperConfig.writeToParcel(dest, flags);
            mFadeInVolShaperConfig.writeToParcel(dest, flags);
        }

        /**
         * Creates fade volume shaper config wrapper from parcel
         *
         * @hide
         */
        @VisibleForTesting()
        FadeVolumeShaperConfigsWrapper(Parcel in) {
            mFadeOutVolShaperConfig = VolumeShaper.Configuration.CREATOR.createFromParcel(in);
            mFadeInVolShaperConfig = VolumeShaper.Configuration.CREATOR.createFromParcel(in);
        }

        @NonNull
        public static final Creator<FadeVolumeShaperConfigsWrapper> CREATOR = new Creator<>() {
            @Override
            @NonNull
            public FadeVolumeShaperConfigsWrapper createFromParcel(@NonNull Parcel in) {
                return new FadeVolumeShaperConfigsWrapper(in);
            }

            @Override
            @NonNull
            public FadeVolumeShaperConfigsWrapper[] newArray(int size) {
                return new FadeVolumeShaperConfigsWrapper[size];
            }
        };
    }
}