Merge "CEC: Run all actions after TV allocates address"

        mLocalDeviceAddresses = initLocalDeviceAddresses();

        resetSelectRequestBuffer();

        launchDeviceDiscovery();

        startQueuedActions();

        if (!mDelayedMessageBuffer.isBuffered(Constants.MESSAGE_ACTIVE_SOURCE)) {

            mService.sendCecCommand(HdmiCecMessageBuilder.buildRequestActiveSource(mAddress));

        }

/*

 * Copyright (C) 2020 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.server.hdmi;

import static com.android.server.hdmi.Constants.ADDR_PLAYBACK_1;

import static com.android.server.hdmi.Constants.ADDR_TV;

import static com.android.server.hdmi.HdmiControlService.INITIATED_BY_ENABLE_CEC;

import static com.google.common.truth.Truth.assertThat;

import android.content.Context;

import android.hardware.hdmi.HdmiControlManager;

import android.hardware.tv.cec.V1_0.SendMessageResult;

import android.os.Handler;

import android.os.IPowerManager;

import android.os.IThermalService;

import android.os.Looper;

import android.os.PowerManager;

import android.os.test.TestLooper;

import androidx.test.InstrumentationRegistry;

import androidx.test.filters.SmallTest;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.junit.runners.JUnit4;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import java.util.ArrayList;

@SmallTest

@RunWith(JUnit4.class)

/** Tests for {@link HdmiCecLocalDeviceTv} class. */

public class HdmiCecLocalDeviceTvTest {

    private HdmiControlService mHdmiControlService;

    private HdmiCecController mHdmiCecController;

    private HdmiCecLocalDeviceTv mHdmiCecLocalDeviceTv;

    private FakeNativeWrapper mNativeWrapper;

    private Looper mMyLooper;

    private TestLooper mTestLooper = new TestLooper();

    private ArrayList<HdmiCecLocalDevice> mLocalDevices = new ArrayList<>();

    private int mTvPhysicalAddress;

    @Mock

    private IPowerManager mIPowerManagerMock;

    @Mock

    private IThermalService mIThermalServiceMock;

    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);

        Context context = InstrumentationRegistry.getTargetContext();

        mMyLooper = mTestLooper.getLooper();

        PowerManager powerManager = new PowerManager(context, mIPowerManagerMock,

                mIThermalServiceMock, new Handler(mMyLooper));

        mHdmiControlService =

                new HdmiControlService(InstrumentationRegistry.getTargetContext()) {

                    @Override

                    boolean isControlEnabled() {

                        return true;

                    }

                    @Override

                    boolean isTvDevice() {

                        return true;

                    }

                    @Override

                    void writeStringSystemProperty(String key, String value) {

                        // do nothing

                    }

                    @Override

                    PowerManager getPowerManager() {

                        return powerManager;

                    }

                };

        mHdmiCecLocalDeviceTv = new HdmiCecLocalDeviceTv(mHdmiControlService);

        mHdmiCecLocalDeviceTv.init();

        mHdmiControlService.setIoLooper(mMyLooper);

        mNativeWrapper = new FakeNativeWrapper();

        mHdmiCecController =

                HdmiCecController.createWithNativeWrapper(mHdmiControlService, mNativeWrapper);

        mHdmiControlService.setCecController(mHdmiCecController);

        mHdmiControlService.setHdmiMhlController(HdmiMhlControllerStub.create(mHdmiControlService));

        mHdmiControlService.setMessageValidator(new HdmiCecMessageValidator(mHdmiControlService));

        mLocalDevices.add(mHdmiCecLocalDeviceTv);

        mHdmiControlService.initPortInfo();

        mHdmiControlService.allocateLogicalAddress(mLocalDevices, INITIATED_BY_ENABLE_CEC);

        mTvPhysicalAddress = 0x0000;

        mNativeWrapper.setPhysicalAddress(mTvPhysicalAddress);

        mTestLooper.dispatchAll();

        mNativeWrapper.clearResultMessages();

    }

    @Test

    public void initialPowerStateIsStandby() {

        assertThat(mHdmiCecLocalDeviceTv.getPowerStatus()).isEqualTo(

                HdmiControlManager.POWER_STATUS_STANDBY);

    }

    @Test

    public void onAddressAllocated_invokesDeviceDiscovery() {

        mNativeWrapper.setPollAddressResponse(ADDR_PLAYBACK_1, SendMessageResult.SUCCESS);

        mHdmiCecLocalDeviceTv.onAddressAllocated(0, HdmiControlService.INITIATED_BY_BOOT_UP);

        mTestLooper.dispatchAll();

        // Check for for <Give Physical Address> being sent to available device (ADDR_PLAYBACK_1).

        // This message is sent as part of the DeviceDiscoveryAction to available devices.

        HdmiCecMessage givePhysicalAddress = HdmiCecMessageBuilder.buildGivePhysicalAddress(ADDR_TV,

                ADDR_PLAYBACK_1);

        assertThat(mNativeWrapper.getResultMessages()).contains(givePhysicalAddress);

    }

}