Merge "Unit test for ComputerControlSessionImpl" into main

/*

 * Copyright (C) 2025 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.companion.virtual.computercontrol;

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

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

import android.companion.virtual.ActivityPolicyExemption;

import android.companion.virtual.IVirtualDevice;

import android.companion.virtual.VirtualDeviceParams;

import android.companion.virtual.computercontrol.ComputerControlSessionParams;

import android.content.AttributionSource;

import android.content.pm.PackageManager;

import android.hardware.display.DisplayManager;

import android.hardware.display.VirtualDisplayConfig;

import android.hardware.input.VirtualDpadConfig;

import android.hardware.input.VirtualKeyboardConfig;

import android.hardware.input.VirtualTouchscreenConfig;

import android.os.Binder;

import android.os.IBinder;

import android.view.Surface;

import androidx.test.ext.junit.runners.AndroidJUnit4;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.Captor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

@RunWith(AndroidJUnit4.class)

public class ComputerControlSessionTest {

    private static final String PERMISSION_CONTROLLER_PACKAGE = "permission.controller.package";

    private static final int VIRTUAL_DISPLAY_ID = 42;

    @Mock

    private PackageManager mPackageManager;

    @Mock

    private ComputerControlSessionProcessor.VirtualDeviceFactory mVirtualDeviceFactory;

    @Mock

    private IVirtualDevice mVirtualDevice;

    @Captor

    private ArgumentCaptor<VirtualDeviceParams> mVirtualDeviceParamsArgumentCaptor;

    @Captor

    private ArgumentCaptor<ActivityPolicyExemption> mActivityPolicyExemptionArgumentCaptor;

    @Captor

    private ArgumentCaptor<VirtualDisplayConfig> mVirtualDisplayConfigArgumentCaptor;

    @Captor

    private ArgumentCaptor<VirtualTouchscreenConfig> mVirtualTouchscreenConfigArgumentCaptor;

    @Captor

    private ArgumentCaptor<VirtualDpadConfig> mVirtualDpadConfigArgumentCaptor;

    @Captor

    private ArgumentCaptor<VirtualKeyboardConfig> mVirtualKeyboardConfigArgumentCaptor;

    private AutoCloseable mMockitoSession;

    private final IBinder mAppToken = new Binder();

    private final ComputerControlSessionParams mParams = new ComputerControlSessionParams();

    private ComputerControlSessionImpl mSession;

    @Before

    public void setUp() throws Exception {

        mMockitoSession = MockitoAnnotations.openMocks(this);

        mParams.displayDpi = 100;

        mParams.displayHeightPx = 200;

        mParams.displayWidthPx = 300;

        mParams.displaySurface = new Surface();

        mParams.isDisplayAlwaysUnlocked = true;

        mParams.name = ComputerControlSessionTest.class.getSimpleName();

        when(mPackageManager.getPermissionControllerPackageName())

                .thenReturn(PERMISSION_CONTROLLER_PACKAGE);

        when(mVirtualDeviceFactory.createVirtualDevice(any(), any(), any(), any()))

                .thenReturn(mVirtualDevice);

        when(mVirtualDevice.createVirtualDisplay(any(), any())).thenReturn(VIRTUAL_DISPLAY_ID);

        mSession = new ComputerControlSessionImpl(mAppToken, mParams,

                AttributionSource.myAttributionSource(), mPackageManager, mVirtualDeviceFactory);

    }

    @After

    public void tearDown() throws Exception {

        mMockitoSession.close();

    }

    @Test

    public void createSession_appliesCorrectParams() throws Exception {

        verify(mVirtualDeviceFactory).createVirtualDevice(

                eq(mAppToken), any(), mVirtualDeviceParamsArgumentCaptor.capture(), any());

        assertThat(mVirtualDeviceParamsArgumentCaptor.getValue().getName()).isEqualTo(mParams.name);

        verify(mVirtualDevice).addActivityPolicyExemption(

                mActivityPolicyExemptionArgumentCaptor.capture());

        assertThat(mActivityPolicyExemptionArgumentCaptor.getValue().getPackageName())

                .isEqualTo(PERMISSION_CONTROLLER_PACKAGE);

        verify(mVirtualDevice).createVirtualDisplay(

                mVirtualDisplayConfigArgumentCaptor.capture(), any());

        VirtualDisplayConfig virtualDisplayConfig = mVirtualDisplayConfigArgumentCaptor.getValue();

        assertThat(virtualDisplayConfig.getDensityDpi()).isEqualTo(mParams.displayDpi);

        assertThat(virtualDisplayConfig.getHeight()).isEqualTo(mParams.displayHeightPx);

        assertThat(virtualDisplayConfig.getWidth()).isEqualTo(mParams.displayWidthPx);

        assertThat(virtualDisplayConfig.getSurface()).isEqualTo(mParams.displaySurface);

        assertThat(virtualDisplayConfig.getName()).contains(mParams.name);

        int expectedDisplayFlags = DisplayManager.VIRTUAL_DISPLAY_FLAG_TRUSTED

                | DisplayManager.VIRTUAL_DISPLAY_FLAG_STEAL_TOP_FOCUS_DISABLED

                | DisplayManager.VIRTUAL_DISPLAY_FLAG_ALWAYS_UNLOCKED;

        assertThat(virtualDisplayConfig.getFlags()).isEqualTo(expectedDisplayFlags);

        verify(mVirtualDevice).createVirtualDpad(

                mVirtualDpadConfigArgumentCaptor.capture(), any());

        VirtualDpadConfig virtualDpadConfig = mVirtualDpadConfigArgumentCaptor.getValue();

        assertThat(virtualDpadConfig.getAssociatedDisplayId()).isEqualTo(VIRTUAL_DISPLAY_ID);

        assertThat(virtualDpadConfig.getInputDeviceName()).contains(mParams.name);

        verify(mVirtualDevice).createVirtualKeyboard(

                mVirtualKeyboardConfigArgumentCaptor.capture(), any());

        VirtualKeyboardConfig virtualKeyboardConfig =

                mVirtualKeyboardConfigArgumentCaptor.getValue();

        assertThat(virtualKeyboardConfig.getAssociatedDisplayId()).isEqualTo(VIRTUAL_DISPLAY_ID);

        assertThat(virtualKeyboardConfig.getInputDeviceName()).contains(mParams.name);

        verify(mVirtualDevice).createVirtualTouchscreen(

                mVirtualTouchscreenConfigArgumentCaptor.capture(), any());

        VirtualTouchscreenConfig virtualTouchscreenConfig =

                mVirtualTouchscreenConfigArgumentCaptor.getValue();

        assertThat(virtualTouchscreenConfig.getAssociatedDisplayId()).isEqualTo(VIRTUAL_DISPLAY_ID);

        assertThat(virtualTouchscreenConfig.getWidth()).isEqualTo(mParams.displayWidthPx);

        assertThat(virtualTouchscreenConfig.getHeight()).isEqualTo(mParams.displayHeightPx);

        assertThat(virtualTouchscreenConfig.getInputDeviceName()).contains(mParams.name);

    }

    @Test

    public void closeSession_closesVirtualDevice() throws Exception {

        mSession.close();

        verify(mVirtualDevice).close();

    }

    @Test

    public void getVirtualDisplayId_returnsCreatedDisplay() {

        assertThat(mSession.getVirtualDisplayId()).isEqualTo(VIRTUAL_DISPLAY_ID);

    }

}