car/test/CarAudioExtFocusTest.java

/*
 * Copyright (C) 2016 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.test;

import android.car.Car;
import android.car.media.CarAudioManager;
import android.car.test.VehicleHalEmulator.VehicleHalPropertyHandler;
import android.content.Context;
import android.media.AudioAttributes;
import android.media.AudioManager;
import android.os.SystemClock;
import android.test.suitebuilder.annotation.MediumTest;
import android.util.Log;

import com.android.car.vehiclenetwork.VehicleNetworkConsts;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehicleAudioContextFlag;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehicleAudioExtFocusFlag;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehicleAudioFocusIndex;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehicleAudioFocusRequest;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehicleAudioFocusState;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehicleAudioStream;
import com.android.car.vehiclenetwork.VehiclePropConfigUtil;
import com.android.car.vehiclenetwork.VehiclePropValueUtil;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehiclePermissionModel;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehiclePropAccess;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehiclePropChangeMode;
import com.android.car.vehiclenetwork.VehicleNetworkConsts.VehicleValueType;
import com.android.car.vehiclenetwork.VehicleNetworkProto.VehiclePropValue;

import java.util.Arrays;
import java.util.LinkedList;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

@MediumTest
public class CarAudioExtFocusTest extends MockedCarTestBase {
    private static final String TAG = CarAudioExtFocusTest.class.getSimpleName();

    private static final long TIMEOUT_MS = 3000;

    private final VehicleHalPropertyHandler mAudioRoutingPolicyPropertyHandler =
            new VehicleHalPropertyHandler() {
        @Override
        public void onPropertySet(VehiclePropValue value) {
            //TODO
        }

        @Override
        public VehiclePropValue onPropertyGet(VehiclePropValue value) {
            fail("cannot get");
            return null;
        }

        @Override
        public void onPropertySubscribe(int property, float sampleRate, int zones) {
            fail("cannot subscribe");
        }

        @Override
        public void onPropertyUnsubscribe(int property) {
            fail("cannot unsubscribe");
        }
    };

    private final FocusPropertyHandler mAudioFocusPropertyHandler =
            new FocusPropertyHandler(this);

    private final ExtRoutingHintPropertyHandler mExtRoutingHintPropertyHandler =
            new ExtRoutingHintPropertyHandler();

    private static final String EXT_ROUTING_CONFIG =
            "0:RADIO_AM_FM:0,1:RADIO_SATELLITE:0,33:CD_DVD:0," +
            "64:com.google.test.SOMETHING_SPECIAL," +
            "4:EXT_NAV_GUIDANCE:1," +
            "5:AUX_IN0:0";

    private final Semaphore mWaitSemaphore = new Semaphore(0);
    private final LinkedList<VehiclePropValue> mEvents = new LinkedList<VehiclePropValue>();
    private AudioManager mAudioManager;
    private CarAudioManager mCarAudioManager;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        // AudioManager should be created in main thread to get focus event. :(
        runOnMainSync(new Runnable() {
            @Override
            public void run() {
                mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
            }
        });

        getVehicleHalEmulator().addProperty(
                VehiclePropConfigUtil.getBuilder(
                        VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_ROUTING_POLICY,
                        VehiclePropAccess.VEHICLE_PROP_ACCESS_WRITE,
                        VehiclePropChangeMode.VEHICLE_PROP_CHANGE_MODE_ON_CHANGE,
                        VehicleValueType.VEHICLE_VALUE_TYPE_INT32_VEC2,
                        VehiclePermissionModel.VEHICLE_PERMISSION_SYSTEM_APP_ONLY,
                        0 /*configFlags*/, 0 /*sampleRateMax*/, 0 /*sampleRateMin*/).build(),
                        mAudioRoutingPolicyPropertyHandler);
        getVehicleHalEmulator().addProperty(
                VehiclePropConfigUtil.getBuilder(
                        VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_FOCUS,
                        VehiclePropAccess.VEHICLE_PROP_ACCESS_READ_WRITE,
                        VehiclePropChangeMode.VEHICLE_PROP_CHANGE_MODE_ON_CHANGE,
                        VehicleValueType.VEHICLE_VALUE_TYPE_INT32_VEC4,
                        VehiclePermissionModel.VEHICLE_PERMISSION_SYSTEM_APP_ONLY,
                        0 /*configFlags*/, 0 /*sampleRateMax*/, 0 /*sampleRateMin*/).build(),
                        mAudioFocusPropertyHandler);
        getVehicleHalEmulator().addStaticProperty(
                VehiclePropConfigUtil.createStaticStringProperty(
                        VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_HW_VARIANT),
                VehiclePropValueUtil.createIntValue(
                        VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_HW_VARIANT, 1, 0));
        getVehicleHalEmulator().addProperty(
                VehiclePropConfigUtil.getBuilder(
                        VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_EXT_ROUTING_HINT,
                        VehiclePropAccess.VEHICLE_PROP_ACCESS_WRITE,
                        VehiclePropChangeMode.VEHICLE_PROP_CHANGE_MODE_ON_CHANGE,
                        VehicleValueType.VEHICLE_VALUE_TYPE_INT32_VEC4,
                        VehiclePermissionModel.VEHICLE_PERMISSION_SYSTEM_APP_ONLY,
                        0 /*configFlags*/, 0 /*sampleRateMax*/, 0 /*sampleRateMin*/).
                        setConfigString(EXT_ROUTING_CONFIG).build(),
                        mExtRoutingHintPropertyHandler);
        getVehicleHalEmulator().start();
        mCarAudioManager = (CarAudioManager) getCar().getCarManager(Car.AUDIO_SERVICE);
        assertNotNull(mCarAudioManager);
    }

    public void testExtRoutings() throws Exception {
        String[] radioTypes = mCarAudioManager.getSupportedRadioTypes();
        assertNotNull(radioTypes);
        checkStringArrayContents(new String[] {"RADIO_AM_FM", "RADIO_SATELLITE"}, radioTypes);

        String[] nonRadioTypes = mCarAudioManager.getSupportedExternalSourceTypes();
        assertNotNull(nonRadioTypes);
        checkStringArrayContents(new String[] {"CD_DVD", "com.google.test.SOMETHING_SPECIAL",
                "EXT_NAV_GUIDANCE", "AUX_IN0"}, nonRadioTypes);
    }

    private void checkStringArrayContents(String[] expected, String[] actual) throws Exception {
        Arrays.sort(expected);
        Arrays.sort(actual);
        assertEquals(expected.length, actual.length);
        for (int i = 0; i < expected.length; i++) {
            assertEquals(expected[i], actual[i]);
        }
    }

    public void testRadioAttributeCreation() throws Exception {
        AudioAttributes attrb = mCarAudioManager.getAudioAttributesForRadio(
                CarAudioManager.CAR_RADIO_TYPE_AM_FM);
        assertNotNull(attrb);

        attrb = mCarAudioManager.getAudioAttributesForRadio(
                CarAudioManager.CAR_RADIO_TYPE_SATELLITE);
        assertNotNull(attrb);

        try {
            attrb = mCarAudioManager.getAudioAttributesForRadio(
                    CarAudioManager.CAR_RADIO_TYPE_AM_FM_HD);
            fail();
        } catch (IllegalArgumentException e) {
            // expected
        }
    }

    public void testExtSourceAttributeCreation() throws Exception {
        AudioAttributes attrb = mCarAudioManager.getAudioAttributesForExternalSource(
                CarAudioManager.CAR_EXTERNAL_SOURCE_TYPE_CD_DVD);
        assertNotNull(attrb);

        attrb = mCarAudioManager.getAudioAttributesForExternalSource(
                CarAudioManager.CAR_EXTERNAL_SOURCE_TYPE_EXT_NAV_GUIDANCE);
        assertNotNull(attrb);

        attrb = mCarAudioManager.getAudioAttributesForExternalSource(
                "com.google.test.SOMETHING_SPECIAL");
        assertNotNull(attrb);

        try {
            attrb = mCarAudioManager.getAudioAttributesForExternalSource(
                    CarAudioManager.CAR_RADIO_TYPE_AM_FM_HD);
            fail();
        } catch (IllegalArgumentException e) {
            // expected
        }
    }

    public void testRadioAmFmGainFocus() throws Exception {
        AudioAttributes attrb = mCarAudioManager.getAudioAttributesForRadio(
                CarAudioManager.CAR_RADIO_TYPE_AM_FM);
        assertNotNull(attrb);
        checkSingleRequestRelease(attrb, AudioManager.AUDIOFOCUS_GAIN, new int[] {1, 0, 0, 0},
                0, VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG);
    }

    public void testRadioSatelliteGainFocus() throws Exception {
        AudioAttributes attrb = mCarAudioManager.getAudioAttributesForRadio(
                CarAudioManager.CAR_RADIO_TYPE_SATELLITE);
        assertNotNull(attrb);
        checkSingleRequestRelease(attrb, AudioManager.AUDIOFOCUS_GAIN, new int[] {2, 0, 0, 0},
                0, VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG);
    }

    public void testCdGainFocus() throws Exception {
        AudioAttributes attrb = mCarAudioManager.getAudioAttributesForExternalSource(
                CarAudioManager.CAR_EXTERNAL_SOURCE_TYPE_CD_DVD);
        assertNotNull(attrb);
        checkSingleRequestRelease(attrb, AudioManager.AUDIOFOCUS_GAIN, new int[] {0, 2, 0, 0},
                0, VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_CD_ROM_FLAG);
    }

    public void testAuxInFocus() throws Exception {
        AudioAttributes attrb = mCarAudioManager.getAudioAttributesForExternalSource(
                CarAudioManager.CAR_EXTERNAL_SOURCE_TYPE_AUX_IN0);
        assertNotNull(attrb);
        checkSingleRequestRelease(attrb, AudioManager.AUDIOFOCUS_GAIN, new int[] {0x1<<5, 0, 0, 0},
                0, VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_AUX_AUDIO_FLAG);
    }

    public void testExtNavInFocus() throws Exception {
        AudioAttributes attrb = mCarAudioManager.getAudioAttributesForExternalSource(
                CarAudioManager.CAR_EXTERNAL_SOURCE_TYPE_EXT_NAV_GUIDANCE);
        assertNotNull(attrb);
        checkSingleRequestRelease(attrb, AudioManager.AUDIOFOCUS_GAIN, new int[] {0x1<<4, 0, 0, 0},
                0, VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_EXT_SOURCE_FLAG);
    }

    public void testCustomInFocus() throws Exception {
        AudioAttributes attrb = mCarAudioManager.getAudioAttributesForExternalSource(
                "com.google.test.SOMETHING_SPECIAL");
        assertNotNull(attrb);
        checkSingleRequestRelease(attrb, AudioManager.AUDIOFOCUS_GAIN, new int[] {0, 0, 1, 0},
                0, VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_EXT_SOURCE_FLAG);
    }

    public void testMediaNavFocus() throws Exception {
        //music start
        AudioFocusListener listenerMusic = new AudioFocusListener();
        int res = mAudioManager.requestAudioFocus(listenerMusic,
                AudioManager.STREAM_MUSIC,
                AudioManager.AUDIOFOCUS_GAIN);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        int[] request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        // nav guidance start
        AudioFocusListener listenerNav = new AudioFocusListener();
        AudioAttributes navAttrib = (new AudioAttributes.Builder()).
                setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION).
                setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE).
                build();
        res = mAudioManager.requestAudioFocus(listenerNav, navAttrib,
                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 0);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0x3, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG |
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_NAVIGATION_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN, request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        // nav guidance done
        mAudioManager.abandonAudioFocus(listenerNav);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN, request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        // music done
        mAudioManager.abandonAudioFocus(listenerMusic);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_RELEASE, request[0]);
        assertEquals(0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS, request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);
    }

    public void testMediaExternalMediaNavFocus() throws Exception {
        // android music
        AudioFocusListener listenerMusic = new AudioFocusListener();
        int res = mAudioManager.requestAudioFocus(listenerMusic,
                AudioManager.STREAM_MUSIC,
                AudioManager.AUDIOFOCUS_GAIN);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        int[] request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        // car plays external media (=outside Android)
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PERMANENT_FLAG);
        int focusChange = listenerMusic.waitAndGetFocusChange(TIMEOUT_MS);
        assertEquals(AudioManager.AUDIOFOCUS_LOSS, focusChange);

        // nav guidance start
        AudioFocusListener listenerNav = new AudioFocusListener();
        AudioAttributes navAttrib = (new AudioAttributes.Builder()).
                setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION).
                setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE).
                build();
        res = mAudioManager.requestAudioFocus(listenerNav, navAttrib,
                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 0);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN_TRANSIENT_MAY_DUCK,
                request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM1, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_NAVIGATION_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN_TRANSIENT,
                0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM1,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PERMANENT_FLAG);

        // nav guidance ends
        mAudioManager.abandonAudioFocus(listenerNav);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_RELEASE, request[0]);
        assertEquals(0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PERMANENT_FLAG);

        // now ends external play
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS,
                0,
                0);
        mAudioManager.abandonAudioFocus(listenerMusic);
        //TODO how to check this?
    }

    public void testExternalRadioExternalNav() throws Exception {
        // android radio
        AudioFocusListener listenerRadio = new AudioFocusListener();
        CarAudioManager carAudioManager = (CarAudioManager) getCar().getCarManager(
                Car.AUDIO_SERVICE);
        assertNotNull(carAudioManager);
        AudioAttributes radioAttributes = carAudioManager.getAudioAttributesForCarUsage(
                CarAudioManager.CAR_AUDIO_USAGE_RADIO);
        int res = mAudioManager.requestAudioFocus(listenerRadio,
                radioAttributes, AudioManager.AUDIOFOCUS_GAIN, 0);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        int[] request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG, request[3]);
        assertArrayEquals(new int[] {1, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG);

        //external nav
        AudioFocusListener listenerNav = new AudioFocusListener();
        AudioAttributes extNavAttributes = mCarAudioManager.getAudioAttributesForExternalSource(
                CarAudioManager.CAR_EXTERNAL_SOURCE_TYPE_EXT_NAV_GUIDANCE);
        res = mAudioManager.requestAudioFocus(listenerNav,
                extNavAttributes, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 0);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN,
                request[0]);
        assertEquals(0, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG |
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_EXT_SOURCE_FLAG, request[3]);
        assertArrayEquals(new int[] {1 | 1<<4, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG);

        mAudioManager.abandonAudioFocus(listenerNav);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG, request[3]);
        assertArrayEquals(new int[] {1, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG);

        mAudioManager.abandonAudioFocus(listenerRadio);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_RELEASE, request[0]);
        assertEquals(0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS,
                0,
                0);
    }

    public void testMediaExternalNav() throws Exception {
        // android music
        AudioFocusListener listenerMusic = new AudioFocusListener();
        int res = mAudioManager.requestAudioFocus(listenerMusic,
                AudioManager.STREAM_MUSIC,
                AudioManager.AUDIOFOCUS_GAIN);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        int[] request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        //external nav
        AudioFocusListener listenerNav = new AudioFocusListener();
        AudioAttributes extNavAttributes = mCarAudioManager.getAudioAttributesForExternalSource(
                CarAudioManager.CAR_EXTERNAL_SOURCE_TYPE_EXT_NAV_GUIDANCE);
        res = mAudioManager.requestAudioFocus(listenerNav,
                extNavAttributes, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 0);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN,
                request[0]);
        assertEquals(0x1, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG |
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_EXT_SOURCE_FLAG, request[3]);
        assertArrayEquals(new int[] {1<<4, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0x1,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG);

        mAudioManager.abandonAudioFocus(listenerNav);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        mAudioManager.abandonAudioFocus(listenerMusic);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_RELEASE, request[0]);
        assertEquals(0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS,
                0,
                0);
    }

    /**
     * Test internal nav - external nav case.
     * External nav takes the same physical stream as internal nav. So internal nav
     * will be lost while external nav is played. This should not happen in real case when
     * AppFocus is used, but this test is to make sure that audio focus works as expected.
     */
    public void testNavExternalNav() throws Exception {
        // android nav
        AudioFocusListener listenerIntNav = new AudioFocusListener();
        AudioAttributes intNavAttributes = mCarAudioManager.getAudioAttributesForCarUsage(
                CarAudioManager.CAR_AUDIO_USAGE_NAVIGATION_GUIDANCE);
        int res = mAudioManager.requestAudioFocus(listenerIntNav, intNavAttributes,
                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 0);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        int[] request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN_TRANSIENT_MAY_DUCK,
                request[0]);
        assertEquals(0x2, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_NAVIGATION_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        //external nav
        AudioFocusListener listenerExtNav = new AudioFocusListener();
        AudioAttributes extNavAttributes = mCarAudioManager.getAudioAttributesForExternalSource(
                CarAudioManager.CAR_EXTERNAL_SOURCE_TYPE_EXT_NAV_GUIDANCE);
        res = mAudioManager.requestAudioFocus(listenerExtNav,
                extNavAttributes, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 0);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN,
                request[0]);
        assertEquals(0, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_EXT_SOURCE_FLAG, request[3]);
        assertArrayEquals(new int[] {1<<4, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0x1,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG);

        mAudioManager.abandonAudioFocus(listenerExtNav);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN_TRANSIENT_MAY_DUCK,
                request[0]);
        assertEquals(0x2, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_NAVIGATION_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        mAudioManager.abandonAudioFocus(listenerIntNav);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_RELEASE, request[0]);
        assertEquals(0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS,
                0,
                0);
    }

    public void testMediaExternalRadioNavMediaFocus() throws Exception {
        // android music
        AudioFocusListener listenerMusic = new AudioFocusListener();
        int res = mAudioManager.requestAudioFocus(listenerMusic,
                AudioManager.STREAM_MUSIC,
                AudioManager.AUDIOFOCUS_GAIN);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        int[] request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);

        // android radio
        AudioFocusListener listenerRadio = new AudioFocusListener();
        CarAudioManager carAudioManager = (CarAudioManager) getCar().getCarManager(
                Car.AUDIO_SERVICE);
        assertNotNull(carAudioManager);
        AudioAttributes radioAttributes = carAudioManager.getAudioAttributesForCarUsage(
                CarAudioManager.CAR_AUDIO_USAGE_RADIO);
        res = mAudioManager.requestAudioFocus(listenerRadio,
                radioAttributes, AudioManager.AUDIOFOCUS_GAIN, 0);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG, request[3]);
        assertArrayEquals(new int[] {1, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG);

        // nav guidance start
        AudioFocusListener listenerNav = new AudioFocusListener();
        AudioAttributes navAttrib = (new AudioAttributes.Builder()).
                setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION).
                setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE).
                build();
        res = mAudioManager.requestAudioFocus(listenerNav, navAttrib,
                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 0);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN,
                request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM1, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_NAVIGATION_FLAG |
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG, request[3]);
        assertArrayEquals(new int[] {1, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM1,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG);

        // nav guidance ends
        mAudioManager.abandonAudioFocus(listenerNav);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN,
                request[0]);
        assertEquals(0, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG, request[3]);
        assertArrayEquals(new int[] {1, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG);

        // ends radio. music will get the focus GAIN.
        // Music app is supposed to stop and release focus when it has lost focus, but here just
        // check if focus is working.
        mAudioManager.abandonAudioFocus(listenerRadio);
        listenerMusic.waitForFocus(TIMEOUT_MS, AudioManager.AUDIOFOCUS_GAIN);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM0,
                0);

        // now music release focus.
        mAudioManager.abandonAudioFocus(listenerMusic);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_RELEASE, request[0]);
        assertEquals(0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);
    }

    private void checkSingleRequestRelease(AudioAttributes attrb, int androidFocusToRequest,
            int[] expectedExtRouting, int expectedStreams,
            int expectedExtState, int expectedContexts) throws Exception {
        AudioFocusListener lister = new AudioFocusListener();
        int res = mCarAudioManager.requestAudioFocus(lister, attrb, androidFocusToRequest, 0);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        int[] request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        int expectedFocusRequest = VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_RELEASE;
        int response = VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS;
        switch (androidFocusToRequest) {
            case AudioManager.AUDIOFOCUS_GAIN:
                expectedFocusRequest = VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN;
                response = VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN;
                break;
            case AudioManager.AUDIOFOCUS_GAIN_TRANSIENT:
                expectedFocusRequest =
                    VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN_TRANSIENT;
                response = VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN_TRANSIENT;
                break;
            case AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK:
                expectedFocusRequest =
                    VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN_TRANSIENT_MAY_DUCK;
                response = VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN_TRANSIENT;
                break;
        }
        assertEquals(expectedFocusRequest, request[0]);
        assertEquals(expectedStreams, request[1]);
        assertEquals(expectedExtState, request[2]);
        assertEquals(expectedContexts, request[3]);
        assertArrayEquals(expectedExtRouting, mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                response,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);
        mAudioManager.abandonAudioFocus(lister);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_RELEASE, request[0]);
        assertEquals(0, request[1]);
        assertEquals(0, request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS,
                request[1],
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_NONE_FLAG);
    }

    public void testRadioMute() throws Exception {
        testMediaMute(CarAudioManager.CAR_AUDIO_USAGE_RADIO,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_PLAY_ONLY_FLAG,
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_RADIO_FLAG);
    }

    public void testMusicMute() throws Exception {
        testMediaMute(CarAudioManager.CAR_AUDIO_USAGE_MUSIC,
                0x1,
                0,
                VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_MUSIC_FLAG);
    }

    private void testMediaMute(int mediaUsage, int primaryStream, int extFocusFlag,
            int mediaContext) throws Exception {
        // android radio
        AudioFocusListener listenerMedia = new AudioFocusListener();
        CarAudioManager carAudioManager = (CarAudioManager) getCar().getCarManager(
                Car.AUDIO_SERVICE);
        assertNotNull(carAudioManager);
        AudioAttributes radioAttributes = carAudioManager.getAudioAttributesForCarUsage(mediaUsage);
        Log.i(TAG, "request media Focus");
        int res = mAudioManager.requestAudioFocus(listenerMedia,
                radioAttributes, AudioManager.AUDIOFOCUS_GAIN, 0);
        assertEquals(AudioManager.AUDIOFOCUS_REQUEST_GRANTED, res);
        int[] request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(primaryStream, request[1]);
        assertEquals(extFocusFlag, request[2]);
        assertEquals(mediaContext, request[3]);
        if (mediaUsage == CarAudioManager.CAR_AUDIO_USAGE_RADIO) {
            assertArrayEquals(new int[] {1, 0, 0, 0},
                    mExtRoutingHintPropertyHandler.getLastHint());
        } else {
            assertArrayEquals(new int[] {0, 0, 0, 0},
                    mExtRoutingHintPropertyHandler.getLastHint());
        }
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                primaryStream,
                extFocusFlag);
        // now mute it.
        assertFalse(carAudioManager.isMediaMuted());
        Log.i(TAG, "mute media");
        assertTrue(carAudioManager.setMediaMute(true));
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN_TRANSIENT,
                request[0]);
        assertEquals(0, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_MUTE_MEDIA_FLAG,
                request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_MUTE_MEDIA_FLAG);
        assertTrue(carAudioManager.isMediaMuted());
        // nav guidance on top of it
        AudioFocusListener listenerNav = new AudioFocusListener();
        AudioAttributes navAttrib = (new AudioAttributes.Builder()).
                setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION).
                setUsage(AudioAttributes.USAGE_ASSISTANCE_NAVIGATION_GUIDANCE).
                build();
        Log.i(TAG, "request nav Focus");
        res = mAudioManager.requestAudioFocus(listenerNav, navAttrib,
                AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK, 0);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN_TRANSIENT_MAY_DUCK,
                request[0]);
        assertEquals(0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM1, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_MUTE_MEDIA_FLAG,
                request[2]);
        assertEquals(VehicleAudioContextFlag.VEHICLE_AUDIO_CONTEXT_NAVIGATION_FLAG, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        assertTrue(carAudioManager.isMediaMuted());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0x1 << VehicleAudioStream.VEHICLE_AUDIO_STREAM1,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_MUTE_MEDIA_FLAG);
        assertTrue(carAudioManager.isMediaMuted());
        // nav guidance ends
        mAudioManager.abandonAudioFocus(listenerNav);
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN_TRANSIENT,
                request[0]);
        assertEquals(0, request[1]);
        assertEquals(VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_MUTE_MEDIA_FLAG,
                request[2]);
        assertEquals(0, request[3]);
        assertArrayEquals(new int[] {0, 0, 0, 0},
                mExtRoutingHintPropertyHandler.getLastHint());
        assertTrue(carAudioManager.isMediaMuted());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                0,
                VehicleAudioExtFocusFlag.VEHICLE_AUDIO_EXT_FOCUS_CAR_MUTE_MEDIA_FLAG);
        // now unmute it. media should resume.
        assertTrue(carAudioManager.isMediaMuted());
        assertFalse(carAudioManager.setMediaMute(false));
        assertFalse(carAudioManager.isMediaMuted());
        request = mAudioFocusPropertyHandler.waitForAudioFocusRequest(TIMEOUT_MS);
        assertEquals(VehicleAudioFocusRequest.VEHICLE_AUDIO_FOCUS_REQUEST_GAIN, request[0]);
        assertEquals(primaryStream, request[1]);
        assertEquals(extFocusFlag,
                request[2]);
        assertEquals(mediaContext, request[3]);
        if (mediaUsage == CarAudioManager.CAR_AUDIO_USAGE_RADIO) {
            assertArrayEquals(new int[] {1, 0, 0, 0},
                    mExtRoutingHintPropertyHandler.getLastHint());
        } else {
            assertArrayEquals(new int[] {0, 0, 0, 0},
                    mExtRoutingHintPropertyHandler.getLastHint());
        }
        assertFalse(carAudioManager.isMediaMuted());
        mAudioFocusPropertyHandler.sendAudioFocusState(
                VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_GAIN,
                primaryStream,
                extFocusFlag);
        assertFalse(carAudioManager.isMediaMuted());
        // release focus
        mAudioManager.abandonAudioFocus(listenerMedia);
    }

    protected static class AudioFocusListener implements AudioManager.OnAudioFocusChangeListener {
        private final Semaphore mFocusChangeWait = new Semaphore(0);
        private int mLastFocusChange;

        public int waitAndGetFocusChange(long timeoutMs) throws Exception {
            if (!mFocusChangeWait.tryAcquire(timeoutMs, TimeUnit.MILLISECONDS)) {
                fail("timeout waiting for focus change");
            }
            return mLastFocusChange;
        }

        public void waitForFocus(long timeoutMs, int expectedFocus) throws Exception {
            while (mLastFocusChange != expectedFocus) {
                if (!mFocusChangeWait.tryAcquire(timeoutMs, TimeUnit.MILLISECONDS)) {
                    fail("timeout waiting for focus change");
                }
            }
        }

        @Override
        public void onAudioFocusChange(int focusChange) {
            mLastFocusChange = focusChange;
            mFocusChangeWait.release();
        }
    }

    protected static class FocusPropertyHandler implements VehicleHalPropertyHandler {

        private int mState = VehicleAudioFocusState.VEHICLE_AUDIO_FOCUS_STATE_LOSS;
        private int mStreams = 0;
        private int mExtFocus = 0;
        private int mRequest;
        private int mRequestedStreams;
        private int mRequestedExtFocus;
        private int mRequestedAudioContexts;
        private final MockedCarTestBase mCarTest;

        private final Semaphore mSetWaitSemaphore = new Semaphore(0);

        public FocusPropertyHandler(MockedCarTestBase carTest) {
            mCarTest = carTest;
        }

        public void sendAudioFocusState(int state, int streams, int extFocus) {
            synchronized (this) {
                mState = state;
                mStreams = streams;
                mExtFocus = extFocus;
            }
            int[] values = { state, streams, extFocus, 0 };
            mCarTest.getVehicleHalEmulator().injectEvent(VehiclePropValueUtil.createIntVectorValue(
                    VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_FOCUS, values,
                    SystemClock.elapsedRealtimeNanos()));
        }

        public int[] waitForAudioFocusRequest(long timeoutMs) throws Exception {
            if (!mSetWaitSemaphore.tryAcquire(timeoutMs, TimeUnit.MILLISECONDS)) {
                fail("timeout");
            }
            synchronized (this) {
                return new int[] { mRequest, mRequestedStreams, mRequestedExtFocus,
                        mRequestedAudioContexts };
            }
        }

        @Override
        public void onPropertySet(VehiclePropValue value) {
            assertEquals(VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_FOCUS, value.getProp());
            synchronized (this) {
                mRequest = value.getInt32Values(
                        VehicleAudioFocusIndex.VEHICLE_AUDIO_FOCUS_INDEX_FOCUS);
                mRequestedStreams = value.getInt32Values(
                        VehicleAudioFocusIndex.VEHICLE_AUDIO_FOCUS_INDEX_STREAMS);
                mRequestedExtFocus = value.getInt32Values(
                        VehicleAudioFocusIndex.VEHICLE_AUDIO_FOCUS_INDEX_EXTERNAL_FOCUS_STATE);
                mRequestedAudioContexts = value.getInt32Values(
                        VehicleAudioFocusIndex.VEHICLE_AUDIO_FOCUS_INDEX_AUDIO_CONTEXTS);
            }
            mSetWaitSemaphore.release();
        }

        @Override
        public VehiclePropValue onPropertyGet(VehiclePropValue value) {
            assertEquals(VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_FOCUS, value.getProp());
            int state, streams, extFocus;
            synchronized (this) {
                state = mState;
                streams = mStreams;
                extFocus = mExtFocus;
            }
            int[] values = { state, streams, extFocus, 0 };
            return VehiclePropValueUtil.createIntVectorValue(
                    VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_FOCUS, values,
                    SystemClock.elapsedRealtimeNanos());
        }

        @Override
        public void onPropertySubscribe(int property, float sampleRate, int zones) {
            assertEquals(VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_FOCUS, property);
        }

        @Override
        public void onPropertyUnsubscribe(int property) {
            assertEquals(VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_FOCUS, property);
        }
    }

    private static class ExtRoutingHintPropertyHandler implements VehicleHalPropertyHandler {
        private int[] mLastHint = {0, 0, 0, 0};

        public int[] getLastHint() {
            int[] lastHint = new int[mLastHint.length];
            synchronized (this) {
                System.arraycopy(mLastHint, 0, lastHint, 0, mLastHint.length);
            }
            return lastHint;
        }

        @Override
        public void onPropertySet(VehiclePropValue value) {
            assertEquals(VehicleNetworkConsts.VEHICLE_PROPERTY_AUDIO_EXT_ROUTING_HINT,
                    value.getProp());
            assertEquals(mLastHint.length, value.getInt32ValuesCount());
            synchronized (this) {
                for (int i = 0; i < mLastHint.length; i++) {
                    mLastHint[i] = value.getInt32Values(i);
                }
            }
        }

        @Override
        public VehiclePropValue onPropertyGet(VehiclePropValue value) {
            fail("write only");
            return null;
        }

        @Override
        public void onPropertySubscribe(int property, float sampleRate, int zones) {
            fail("cannot subsctibe");
        }

        @Override
        public void onPropertyUnsubscribe(int property) {
            fail("cannot subsctibe");
        }
    }
}