/*
 * 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 com.android.car.occupantconnection;

import static android.car.Car.CAR_INTENT_ACTION_RECEIVER_SERVICE;
import static android.car.CarOccupantZoneManager.OCCUPANT_TYPE_DRIVER;
import static android.car.CarOccupantZoneManager.OCCUPANT_TYPE_FRONT_PASSENGER;
import static android.car.VehicleAreaSeat.SEAT_ROW_1_LEFT;
import static android.car.VehicleAreaSeat.SEAT_ROW_1_RIGHT;
import static android.car.occupantconnection.CarOccupantConnectionManager.CONNECTION_ERROR_NOT_READY;
import static android.car.occupantconnection.CarOccupantConnectionManager.CONNECTION_ERROR_PEER_APP_NOT_INSTALLED;
import static android.car.occupantconnection.CarOccupantConnectionManager.CONNECTION_ERROR_UNKNOWN;

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

import static org.junit.Assert.assertThrows;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyString;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import android.car.Car;
import android.car.CarOccupantZoneManager.OccupantZoneInfo;
import android.car.occupantconnection.IBackendReceiver;
import android.car.occupantconnection.IConnectionRequestCallback;
import android.car.occupantconnection.IPayloadCallback;
import android.car.occupantconnection.Payload;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.UserHandle;
import android.util.ArrayMap;
import android.util.ArraySet;

import com.android.car.CarLocalServices;
import com.android.car.CarOccupantZoneService;
import com.android.car.internal.util.BinderKeyValueContainer;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public final class CarOccupantConnectionServiceTest {

    private static final String PACKAGE_NAME = "my_package_name";
    private static final String FAKE_PACKAGE_NAME = "fake_package_name";
    private static final String RECEIVER_ENDPOINT_ID = "test_receiver_endpoint";
    private static final int USER_ID = 123;
    private static final int RECEIVER_USER_ID = 456;

    @Mock
    private Context mContext;
    @Mock
    private CarOccupantZoneService mOccupantZoneService;
    @Mock
    private CarRemoteDeviceService mRemoteDeviceService;
    @Mock
    private IPayloadCallback mPayloadCallback;
    @Mock
    private IBinder mPayloadCallbackBinder;
    @Mock
    private IConnectionRequestCallback mConnectionRequestCallback;
    @Mock
    private IBinder mConnectionRequestCallbackBinder;

    // TODO(b/272196149): make zone IDs constant.
    private final OccupantZoneInfo mReceiverZone =
            new OccupantZoneInfo(/* zoneId= */ 0, OCCUPANT_TYPE_DRIVER, SEAT_ROW_1_LEFT);
    private final OccupantZoneInfo mSenderZone =
            new OccupantZoneInfo(/* zoneId= */ 1, OCCUPANT_TYPE_FRONT_PASSENGER, SEAT_ROW_1_RIGHT);

    private final ArraySet<ClientId> mConnectingReceiverServices = new ArraySet<>();
    private final BinderKeyValueContainer<ClientId, IBackendReceiver>
            mConnectedReceiverServiceMap = new BinderKeyValueContainer<>();
    private final ArrayMap<ClientId, ServiceConnection> mReceiverServiceConnectionMap =
            new ArrayMap<>();
    private final BinderKeyValueContainer<ReceiverEndpointId, IPayloadCallback>
            mPreregisteredReceiverEndpointMap = new BinderKeyValueContainer<>();
    private final BinderKeyValueContainer<ReceiverEndpointId, IPayloadCallback>
            mRegisteredReceiverEndpointMap = new BinderKeyValueContainer<>();
    private final BinderKeyValueContainer<ConnectionId, IConnectionRequestCallback>
            mPendingConnectionRequestMap = new BinderKeyValueContainer<>();
    private final BinderKeyValueContainer<ConnectionId, IConnectionRequestCallback>
            mAcceptedConnectionRequestMap = new BinderKeyValueContainer<>();
    private final ArraySet<ConnectionRecord> mEstablishedConnections = new ArraySet<>();

    private CarOccupantConnectionService mService;

    @Before
    public void setUp() throws PackageManager.NameNotFoundException {
        // Stored as static: Other tests can leave things behind and fail this test in add call.
        // So just remove as safety guard.
        CarLocalServices.removeServiceForTest(CarOccupantZoneService.class);
        CarLocalServices.addService(CarOccupantZoneService.class, mOccupantZoneService);
        CarLocalServices.removeServiceForTest(CarRemoteDeviceService.class);
        CarLocalServices.addService(CarRemoteDeviceService.class, mRemoteDeviceService);

        mService = new CarOccupantConnectionService(mContext,
                mOccupantZoneService,
                mRemoteDeviceService,
                mConnectingReceiverServices,
                mConnectedReceiverServiceMap,
                mReceiverServiceConnectionMap,
                mPreregisteredReceiverEndpointMap,
                mRegisteredReceiverEndpointMap,
                mPendingConnectionRequestMap,
                mAcceptedConnectionRequestMap,
                mEstablishedConnections);
        mService.init();
        when(mPayloadCallback.asBinder()).thenReturn(mPayloadCallbackBinder);
        when(mConnectionRequestCallback.asBinder()).thenReturn(mConnectionRequestCallbackBinder);
        mockPackageName();
    }

    @After
    public void tearDown() {
        CarLocalServices.removeServiceForTest(CarRemoteDeviceService.class);
        CarLocalServices.removeServiceForTest(CarOccupantZoneService.class);
    }

    @Test
    public void testRegisterReceiverWithoutPermission_throwsException() {
        when(mContext.checkCallingOrSelfPermission(eq(Car.PERMISSION_MANAGE_OCCUPANT_CONNECTION)))
                .thenReturn(PackageManager.PERMISSION_DENIED);

        assertThrows(SecurityException.class,
                () -> mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID,
                        mPayloadCallback));
    }

    @Test
    public void testRegisterReceiverWithFakePackageName_throwsException() {
        assertThrows(SecurityException.class,
                () -> mService.registerReceiver(FAKE_PACKAGE_NAME, RECEIVER_ENDPOINT_ID,
                        mPayloadCallback));
    }

    @Test
    public void testRegisterReceiverWithDuplicateId_throwsException() {
        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(receiverUserHandle))
                .thenReturn(mReceiverZone);
        mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID, mPayloadCallback);

        IPayloadCallback payloadCallback2 = mock(IPayloadCallback.class);
        IBinder payloadCallbackBinder2 = mock(IBinder.class);
        when(payloadCallback2.asBinder()).thenReturn(payloadCallbackBinder2);

        assertThrows(IllegalStateException.class,
                () -> mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID,
                        payloadCallback2));
    }

    @Test
    public void testRegisterTwoReceiversWithoutReceiverServiceConnected() {
        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(receiverUserHandle))
                .thenReturn(mReceiverZone);
        mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID, mPayloadCallback);

        // It should have a receiver service that is not connected yet, and a receiver endpoint
        // pending registration.
        assertThat(mConnectingReceiverServices.size()).isEqualTo(1);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(0);
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(1);
        assertThat(mRegisteredReceiverEndpointMap.size()).isEqualTo(0);

        ClientId clientId = mConnectingReceiverServices.valueAt(0);
        assertThat(clientId.packageName).isEqualTo(PACKAGE_NAME);

        ReceiverEndpointId receiverEndpointId =
                new ReceiverEndpointId(clientId, RECEIVER_ENDPOINT_ID);
        assertThat(mPreregisteredReceiverEndpointMap.get(receiverEndpointId))
                .isEqualTo(mPayloadCallback);

        // One more receiver endpoint pending registration.
        String endpointId2 = "ID2";
        IPayloadCallback payloadCallback2 = mock(IPayloadCallback.class);
        IBinder payloadCallbackBinder2 = mock(IBinder.class);
        when(payloadCallback2.asBinder()).thenReturn(payloadCallbackBinder2);
        mService.registerReceiver(PACKAGE_NAME, endpointId2, payloadCallback2);

        assertThat(mConnectingReceiverServices.size()).isEqualTo(1);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(0);
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(2);
        assertThat(mRegisteredReceiverEndpointMap.size()).isEqualTo(0);

        ReceiverEndpointId receiverEndpointId2 =
                new ReceiverEndpointId(clientId, endpointId2);
        assertThat(mPreregisteredReceiverEndpointMap.get(receiverEndpointId2))
                .isEqualTo(payloadCallback2);
    }

    @Test
    public void testRegisterReceiverThenConnectReceiverService() {
        ServiceConnection[] connection = new ServiceConnection[1];
        doAnswer((invocation) -> {
            Object[] args = invocation.getArguments();
            Intent intent = (Intent) args[0];

            assertThat(intent.getAction()).isEqualTo(CAR_INTENT_ACTION_RECEIVER_SERVICE);

            connection[0] = (ServiceConnection) args[1];
            return null;
        }).when(mContext).bindServiceAsUser(any(Intent.class), any(ServiceConnection.class),
                anyInt(), any(UserHandle.class));

        // Since the receiver service is not connected, the receiver endpoint is
        // pending registration.
        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(receiverUserHandle))
                .thenReturn(mReceiverZone);
        mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID, mPayloadCallback);

        // The receiver service is connected.
        ComponentName componentName = mock(ComponentName.class);
        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(binder.queryLocalInterface(anyString())).thenReturn(receiverService);
        when(receiverService.asBinder()).thenReturn(binder);
        connection[0].onServiceConnected(componentName, binder);

        // The receiver endpoint should be registered.
        assertThat(mConnectingReceiverServices.size()).isEqualTo(0);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(1);
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(0);
        assertThat(mRegisteredReceiverEndpointMap.size()).isEqualTo(1);

        ClientId clientId = mConnectedReceiverServiceMap.keyAt(0);
        assertThat(mConnectedReceiverServiceMap.get(clientId))
                .isEqualTo(receiverService);

        ReceiverEndpointId receiverEndpointId =
                new ReceiverEndpointId(clientId, RECEIVER_ENDPOINT_ID);
        assertThat(mRegisteredReceiverEndpointMap.get(receiverEndpointId))
                .isEqualTo(mPayloadCallback);
    }

    @Test
    public void testRegisterReceiverWithReceiverServiceConnected() {
        ServiceConnection[] connection = new ServiceConnection[1];
        doAnswer((invocation) -> {
            Object[] args = invocation.getArguments();
            Intent intent = (Intent) args[0];

            assertThat(intent.getAction()).isEqualTo(CAR_INTENT_ACTION_RECEIVER_SERVICE);

            connection[0] = (ServiceConnection) args[1];
            return null;
        }).when(mContext).bindServiceAsUser(any(Intent.class), any(ServiceConnection.class),
                anyInt(), any(UserHandle.class));

        // Register the first receiver endpoint.
        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(receiverUserHandle))
                .thenReturn(mReceiverZone);
        mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID, mPayloadCallback);

        // The receiver service is connected.
        ComponentName componentName = mock(ComponentName.class);
        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(binder.queryLocalInterface(anyString())).thenReturn(receiverService);
        when(receiverService.asBinder()).thenReturn(binder);
        connection[0].onServiceConnected(componentName, binder);

        // Register the second receiver endpoint.
        String endpointId2 = "ID2";
        IPayloadCallback payloadCallback2 = mock(IPayloadCallback.class);
        IBinder payloadCallbackBinder2 = mock(IBinder.class);
        when(payloadCallback2.asBinder()).thenReturn(payloadCallbackBinder2);
        mService.registerReceiver(PACKAGE_NAME, endpointId2, payloadCallback2);

        assertThat(mConnectingReceiverServices.size()).isEqualTo(0);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(1);
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(0);
        assertThat(mRegisteredReceiverEndpointMap.size()).isEqualTo(2);

        ClientId clientId = mConnectedReceiverServiceMap.keyAt(0);
        ReceiverEndpointId receiverEndpointId2 =
                new ReceiverEndpointId(clientId, endpointId2);
        assertThat(mRegisteredReceiverEndpointMap.get(receiverEndpointId2))
                .isEqualTo(payloadCallback2);

        // The receiver service is disconnected.
        connection[0].onServiceDisconnected(componentName);

        assertThat(mConnectingReceiverServices.size()).isEqualTo(0);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(0);
    }

    @Test
    public void testUnregisterReceiverWithoutPermission_throwsException() {
        when(mContext.checkCallingOrSelfPermission(eq(Car.PERMISSION_MANAGE_OCCUPANT_CONNECTION)))
                .thenReturn(PackageManager.PERMISSION_DENIED);

        assertThrows(SecurityException.class,
                () -> mService.unregisterReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID));
    }

    @Test
    public void testUnregisterReceiverWithFakePackageName_throwsException() {
        assertThrows(SecurityException.class,
                () -> mService.unregisterReceiver(FAKE_PACKAGE_NAME, RECEIVER_ENDPOINT_ID));
    }

    @Test
    public void testUnregisterNonexistentReceiver_throwsException() {
        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(receiverUserHandle))
                .thenReturn(mReceiverZone);

        assertThrows(IllegalStateException.class,
                () -> mService.unregisterReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID));
    }

    @Test
    public void testUnregisterReceiverWithReceiverServiceBound() throws RemoteException {
        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(receiverUserHandle))
                .thenReturn(mReceiverZone);
        ClientId receiverClient = mService.getCallingClientId(PACKAGE_NAME);
        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(receiverService.asBinder()).thenReturn(binder);
        // The receiver service is connected already.
        mConnectedReceiverServiceMap.put(receiverClient, receiverService);
        ServiceConnection serviceConnection = mock(ServiceConnection.class);
        mReceiverServiceConnectionMap.put(receiverClient, serviceConnection);

        mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID, mPayloadCallback);
        ReceiverEndpointId receiverEndpoint =
                new ReceiverEndpointId(receiverClient, RECEIVER_ENDPOINT_ID);

        assertThat(mRegisteredReceiverEndpointMap.get(receiverEndpoint))
                .isEqualTo(mPayloadCallback);
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(0);

        mService.unregisterReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID);

        // The receiver endpoint should be unregistered.
        assertThat(mRegisteredReceiverEndpointMap.size()).isEqualTo(0);
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(0);

        // The receiver service should be unbound since there is no receiver endpoint, no
        // established connection, and no pending connection request.
        // TODO(b/272196149): utilize assertWithMessage to incorporate the scenarios
        // described in the comments.
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(0);
        assertThat(mReceiverServiceConnectionMap.size()).isEqualTo(0);

        verify(receiverService).unregisterReceiver(eq(RECEIVER_ENDPOINT_ID));
        verify(mContext).unbindService(serviceConnection);
    }

    @Test
    public void testUnregisterReceiverWithoutReceiverServiceBound() {
        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(receiverUserHandle))
                .thenReturn(mReceiverZone);
        mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID, mPayloadCallback);

        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(1);
        assertThat(mConnectingReceiverServices.size()).isEqualTo(1);

        ClientId receiverClient = mService.getCallingClientId(PACKAGE_NAME);
        ServiceConnection serviceConnection = mReceiverServiceConnectionMap.get(receiverClient);
        assertThat(serviceConnection).isNotNull();

        mService.unregisterReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID);

        // The receiver endpoint should be unregistered.
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(0);

        // The receiver service should be unbound since there is no receiver endpoint, no
        // established connection, and no pending connection request.
        assertThat(mConnectingReceiverServices.size()).isEqualTo(0);
        assertThat(mReceiverServiceConnectionMap.size()).isEqualTo(0);
        verify(mContext).unbindService(serviceConnection);
    }

    @Test
    public void testUnregisterReceiverWithOtherReceiversLeft() {
        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(receiverUserHandle))
                .thenReturn(mReceiverZone);
        // Register the first receiver endpoint.
        mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID, mPayloadCallback);

        // Register the second receiver endpoint.
        String receiverEndpointId2 = "another_endpoint";
        IPayloadCallback payloadCallback2 = mock(IPayloadCallback.class);
        IBinder binder2 = mock(IBinder.class);
        when(payloadCallback2.asBinder()).thenReturn(binder2);
        mService.registerReceiver(PACKAGE_NAME, receiverEndpointId2, payloadCallback2);

        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(2);

        // Unregister the first receiver endpoint.
        mService.unregisterReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID);

        // The first receiver endpoint should be unregistered.
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(1);
        ClientId receiverClient = mService.getCallingClientId(PACKAGE_NAME);
        ReceiverEndpointId receiverEndpoint2 =
                new ReceiverEndpointId(receiverClient, receiverEndpointId2);
        assertThat(mPreregisteredReceiverEndpointMap.get(receiverEndpoint2))
                .isEqualTo(payloadCallback2);

        // The receiver service should not be unbound since there is another receiver endpoint
        // registered.
        assertThat(mConnectingReceiverServices.size()).isEqualTo(1);
        assertThat(mReceiverServiceConnectionMap.size()).isEqualTo(1);
        verify(mContext, never()).unbindService(any());
    }

    @Test
    public void testRequestConnectionWithoutPermission_throwsException() {
        when(mContext.checkCallingOrSelfPermission(eq(Car.PERMISSION_MANAGE_OCCUPANT_CONNECTION)))
                .thenReturn(PackageManager.PERMISSION_DENIED);

        assertThrows(SecurityException.class,
                () -> mService.requestConnection(PACKAGE_NAME, mReceiverZone,
                        mConnectionRequestCallback));
    }

    @Test
    public void testRequestConnectionWithFakePackageName_throwsException() {
        assertThrows(SecurityException.class,
                () -> mService.requestConnection(FAKE_PACKAGE_NAME, mReceiverZone,
                        mConnectionRequestCallback));
    }

    @Test
    public void testRequestConnectionWithoutReceiverServiceBoundBefore() throws RemoteException {
        // The receiver service is not bound yet before the sender requests a connection.
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        mockAppInstalled(mSenderZone, senderUserHandle);
        UserHandle receiverUserHandle = UserHandle.of(RECEIVER_USER_ID);
        mockAppInstalled(mReceiverZone, receiverUserHandle);

        mService.requestConnection(PACKAGE_NAME, mReceiverZone, mConnectionRequestCallback);

        // The sender endpoint should be saved in the cache.
        assertThat(mPendingConnectionRequestMap.size()).isEqualTo(1);
        ConnectionId connectionId = mPendingConnectionRequestMap.keyAt(0);
        assertThat(connectionId.senderClient.packageName).isEqualTo(PACKAGE_NAME);

        // It should start binding the receiver service automatically.
        assertThat(mReceiverServiceConnectionMap.size()).isEqualTo(1);
        assertThat(mConnectingReceiverServices.size()).isEqualTo(1);

        ClientId receiverClient = mReceiverServiceConnectionMap.keyAt(0);
        assertThat(receiverClient.packageName).isEqualTo(PACKAGE_NAME);
        assertThat(mConnectingReceiverServices.valueAt(0)).isEqualTo(receiverClient);

        // The receiver service is connected.
        ServiceConnection connection = mReceiverServiceConnectionMap.valueAt(0);
        ComponentName componentName = mock(ComponentName.class);
        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(binder.queryLocalInterface(anyString())).thenReturn(receiverService);
        when(receiverService.asBinder()).thenReturn(binder);
        connection.onServiceConnected(componentName, binder);

        assertThat(mConnectingReceiverServices.size()).isEqualTo(0);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(1);
        assertThat(mConnectedReceiverServiceMap.get(receiverClient)).isEqualTo(receiverService);

        assertThat(mPendingConnectionRequestMap.size()).isEqualTo(1);

        // The receiver service should be notified for the connection request.
        verify(receiverService).onConnectionInitiated(mSenderZone, /* senderVersion= */
                0, /* senderSigningInfo= */ null);
    }

    @Test
    public void testRequestConnectionWithReceiverServiceBoundAlready() throws RemoteException {
        // The receiver service is bound already before the sender requests a connection.
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        mockAppInstalled(mSenderZone, senderUserHandle);
        UserHandle receiverUserHandle = UserHandle.of(RECEIVER_USER_ID);
        mockAppInstalled(mReceiverZone, receiverUserHandle);
        ClientId receiverClient = new ClientId(mReceiverZone, RECEIVER_USER_ID, PACKAGE_NAME);
        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(receiverService.asBinder()).thenReturn(binder);

        // Pretend that the receiver service is bound already.
        mConnectedReceiverServiceMap.put(receiverClient, receiverService);
        ServiceConnection connection = mock(ServiceConnection.class);
        mReceiverServiceConnectionMap.put(receiverClient, connection);

        mService.requestConnection(PACKAGE_NAME, mReceiverZone, mConnectionRequestCallback);

        assertThat(mPendingConnectionRequestMap.size()).isEqualTo(1);
        ConnectionId connectionId = mPendingConnectionRequestMap.keyAt(0);
        assertThat(connectionId.senderClient.packageName).isEqualTo(PACKAGE_NAME);

        // The receiver service should be notified for the connection request.
        verify(receiverService).onConnectionInitiated(mSenderZone, /* senderVersion= */
                0, /* senderSigningInfo= */ null);
    }

    @Test
    public void testRequestConnectionAlreadyConnected() {
        // The sender client is already connected to the receiver client before requesting a
        // connection.
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        mockAppInstalled(mSenderZone, senderUserHandle);
        UserHandle receiverUserHandle = UserHandle.of(RECEIVER_USER_ID);
        mockAppInstalled(mReceiverZone, receiverUserHandle);
        ClientId senderClient =
                new ClientId(mSenderZone, senderUserHandle.getIdentifier(), PACKAGE_NAME);
        ClientId receiverClient = new ClientId(mReceiverZone, RECEIVER_USER_ID, PACKAGE_NAME);
        ConnectionId connectionId = new ConnectionId(senderClient, receiverClient);

        IConnectionRequestCallback callback = mock(IConnectionRequestCallback.class);
        IBinder callbackBinder = mock(IBinder.class);
        when(callback.asBinder()).thenReturn(callbackBinder);
        mAcceptedConnectionRequestMap.put(connectionId, callback);

        assertThrows(IllegalStateException.class,
                () -> mService.requestConnection(PACKAGE_NAME, mReceiverZone,
                        mConnectionRequestCallback));
    }

    @Test
    public void testRequestConnectionWithPendingConnection() {
        // The sender client is already connected to the receiver client before requesting a
        // connection.
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        mockAppInstalled(mSenderZone, senderUserHandle);
        UserHandle receiverUserHandle = UserHandle.of(RECEIVER_USER_ID);
        mockAppInstalled(mReceiverZone, receiverUserHandle);
        ClientId senderClient =
                new ClientId(mSenderZone, senderUserHandle.getIdentifier(), PACKAGE_NAME);
        ClientId receiverClient = new ClientId(mReceiverZone, RECEIVER_USER_ID, PACKAGE_NAME);
        ConnectionId connectionId = new ConnectionId(senderClient, receiverClient);

        IConnectionRequestCallback callback = mock(IConnectionRequestCallback.class);
        IBinder callbackBinder = mock(IBinder.class);
        when(callback.asBinder()).thenReturn(callbackBinder);
        mPendingConnectionRequestMap.put(connectionId, callback);

        assertThrows(IllegalStateException.class,
                () -> mService.requestConnection(PACKAGE_NAME, mReceiverZone,
                        mConnectionRequestCallback));
    }

    @Test
    public void testRequestConnectionReceiverZoneNotReady() throws RemoteException {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        mockAppInstalled(mSenderZone, senderUserHandle);
        when(mRemoteDeviceService.isConnectionReady(mReceiverZone)).thenReturn(false);

        mService.requestConnection(PACKAGE_NAME, mReceiverZone, mConnectionRequestCallback);

        verify(mConnectionRequestCallback).onFailed(mReceiverZone, CONNECTION_ERROR_NOT_READY);
    }

    @Test
    public void testRequestConnectionReceiverAppNotInstalled() throws RemoteException {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        mockAppInstalled(mSenderZone, senderUserHandle);
        when(mRemoteDeviceService.isConnectionReady(mReceiverZone)).thenReturn(true);

        mService.requestConnection(PACKAGE_NAME, mReceiverZone, mConnectionRequestCallback);

        verify(mConnectionRequestCallback)
                .onFailed(mReceiverZone, CONNECTION_ERROR_PEER_APP_NOT_INSTALLED);
    }

    @Test
    public void testCancelConnectionWithoutPermission_throwsException() {
        when(mContext.checkCallingOrSelfPermission(eq(Car.PERMISSION_MANAGE_OCCUPANT_CONNECTION)))
                .thenReturn(PackageManager.PERMISSION_DENIED);

        assertThrows(SecurityException.class,
                () -> mService.cancelConnection(PACKAGE_NAME, any(OccupantZoneInfo.class)));
    }

    @Test
    public void testCancelConnectionWithFakePackageName_throwsException() {
        assertThrows(SecurityException.class,
                () -> mService.cancelConnection(FAKE_PACKAGE_NAME, any(OccupantZoneInfo.class)));
    }

    @Test
    public void testCancelConnection() throws RemoteException {
        when(mOccupantZoneService.getUserForOccupant(mReceiverZone.zoneId))
                .thenReturn(RECEIVER_USER_ID);
        ClientId receiverClient = new ClientId(mReceiverZone, RECEIVER_USER_ID, PACKAGE_NAME);

        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle))
                .thenReturn(mSenderZone);
        ClientId senderClient = mService.getCallingClientId(PACKAGE_NAME);

        ConnectionId connectionId = new ConnectionId(senderClient, receiverClient);
        mPendingConnectionRequestMap.put(connectionId, mConnectionRequestCallback);

        IConnectionRequestCallback connectionRequestCallback2 =
                mock(IConnectionRequestCallback.class);
        IBinder connectionRequestCallbackBinder2 = mock(IBinder.class);
        when(connectionRequestCallback2.asBinder()).thenReturn(connectionRequestCallbackBinder2);
        mPendingConnectionRequestMap.put(connectionId, connectionRequestCallback2);

        ServiceConnection serviceConnection = mock(ServiceConnection.class);
        mReceiverServiceConnectionMap.put(receiverClient, serviceConnection);
        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(receiverService.asBinder()).thenReturn(binder);
        mConnectedReceiverServiceMap.put(receiverClient, receiverService);

        mService.cancelConnection(PACKAGE_NAME, mReceiverZone);

        // All pending connection requests should be canceled.
        assertThat(mPendingConnectionRequestMap.size()).isEqualTo(0);

        // The receiver service should be notified of the cancellation, and should be unbound.
        verify(receiverService).onConnectionCanceled(mSenderZone);
        verify(mContext).unbindService(serviceConnection);
    }

    @Test
    public void testCancelConnectionWithoutPendingConnectionRequest_throwsException() {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle))
                .thenReturn(mSenderZone);

        // There is no pending connection request to cancel, so it should throw an
        // IllegalStateException.
        assertThrows(IllegalStateException.class,
                () -> mService.cancelConnection(PACKAGE_NAME, mReceiverZone));
    }

    @Test
    public void testCancelConnectionWithEstablishedConnection_throwsException() {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle))
                .thenReturn(mSenderZone);
        ConnectionRecord connectionRecord =
                new ConnectionRecord(PACKAGE_NAME, mSenderZone.zoneId, mReceiverZone.zoneId);
        mEstablishedConnections.add(connectionRecord);

        // The connection is established already, so canceling it should throw an
        // IllegalStateException.
        assertThrows(IllegalStateException.class,
                () -> mService.cancelConnection(PACKAGE_NAME, mReceiverZone));
    }

    @Test
    public void testReceiverServiceDisconnected() throws RemoteException {
        ServiceConnection[] connection = new ServiceConnection[1];
        doAnswer((invocation) -> {
            Object[] args = invocation.getArguments();
            connection[0] = (ServiceConnection) args[1];
            return null;
        }).when(mContext).bindServiceAsUser(any(Intent.class), any(ServiceConnection.class),
                anyInt(), any(UserHandle.class));

        UserHandle receiverUserHandle = Binder.getCallingUserHandle();
        mockAppInstalled(mReceiverZone, receiverUserHandle);
        mService.registerReceiver(PACKAGE_NAME, RECEIVER_ENDPOINT_ID, mPayloadCallback);

        ClientId receiverClient = mService.getCallingClientId(PACKAGE_NAME);
        ReceiverEndpointId receiverEndpoint =
                new ReceiverEndpointId(receiverClient, RECEIVER_ENDPOINT_ID);
        ClientId senderClient = new ClientId(mSenderZone, USER_ID, PACKAGE_NAME);
        ConnectionId connectionId = new ConnectionId(senderClient, receiverClient);
        ConnectionRecord connectionRecord =
                new ConnectionRecord(PACKAGE_NAME, mSenderZone.zoneId, mReceiverZone.zoneId);

        mConnectingReceiverServices.add(receiverClient);

        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(receiverService.asBinder()).thenReturn(binder);
        mConnectedReceiverServiceMap.put(receiverClient, receiverService);

        mReceiverServiceConnectionMap.put(receiverClient, connection[0]);

        mPreregisteredReceiverEndpointMap.put(receiverEndpoint, mPayloadCallback);

        mRegisteredReceiverEndpointMap.put(receiverEndpoint, mPayloadCallback);
        mPendingConnectionRequestMap.put(connectionId, mConnectionRequestCallback);

        IConnectionRequestCallback callback2 = mock(IConnectionRequestCallback.class);
        Binder binder2 = mock(Binder.class);
        when(callback2.asBinder()).thenReturn(binder2);
        mAcceptedConnectionRequestMap.put(connectionId, callback2);

        mEstablishedConnections.add(connectionRecord);

        connection[0].onServiceDisconnected(mock(ComponentName.class));

        assertThat(mConnectingReceiverServices.isEmpty()).isTrue();
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(0);
        assertThat(mReceiverServiceConnectionMap.isEmpty()).isTrue();
        assertThat(mPreregisteredReceiverEndpointMap.size()).isEqualTo(0);
        assertThat(mRegisteredReceiverEndpointMap.size()).isEqualTo(0);
        assertThat(mPendingConnectionRequestMap.size()).isEqualTo(0);
        assertThat(mAcceptedConnectionRequestMap.size()).isEqualTo(0);
        assertThat(mEstablishedConnections.isEmpty()).isTrue();

        verify(mConnectionRequestCallback).onFailed(receiverClient.occupantZone,
                CONNECTION_ERROR_UNKNOWN);
        verify(callback2).onDisconnected(receiverClient.occupantZone);
    }

    @Test
    public void testSendPayloadWithoutPermission_throwsException() {
        when(mContext.checkCallingOrSelfPermission(eq(Car.PERMISSION_MANAGE_OCCUPANT_CONNECTION)))
                .thenReturn(PackageManager.PERMISSION_DENIED);

        assertThrows(SecurityException.class,
                () -> mService.sendPayload(PACKAGE_NAME, mReceiverZone, any(Payload.class)));
    }

    @Test
    public void testSendPayloadWithFakePackageName_throwsException() {
        assertThrows(SecurityException.class,
                () -> mService.sendPayload(FAKE_PACKAGE_NAME, mReceiverZone, any(Payload.class)));
    }

    @Test
    public void testSendPayloadWithoutConnection_throwsException() {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle)).thenReturn(mSenderZone);

        assertThrows(IllegalStateException.class,
                () -> mService.sendPayload(PACKAGE_NAME, mReceiverZone, any(Payload.class)));
    }

    @Test
    public void testSendPayloadSucceed() throws RemoteException {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle)).thenReturn(mSenderZone);
        ConnectionRecord connectionRecord =
                new ConnectionRecord(PACKAGE_NAME, mSenderZone.zoneId, mReceiverZone.zoneId);

        // It is connected.
        mEstablishedConnections.add(connectionRecord);

        when(mOccupantZoneService.getUserForOccupant(mReceiverZone.zoneId))
                .thenReturn(RECEIVER_USER_ID);
        ClientId receiverClient = new ClientId(mReceiverZone, RECEIVER_USER_ID, PACKAGE_NAME);
        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(receiverService.asBinder()).thenReturn(binder);

        // And the receiver service is bound already.
        mConnectedReceiverServiceMap.put(receiverClient, receiverService);

        Payload payload = mock(Payload.class);
        mService.sendPayload(PACKAGE_NAME, mReceiverZone, payload);

        // The receiver service should be notified for the payload.
        verify(receiverService).onPayloadReceived(mSenderZone, payload);
    }

    @Test
    public void testIsConnectedWithoutPermission_throwsException() {
        when(mContext.checkCallingOrSelfPermission(eq(Car.PERMISSION_MANAGE_OCCUPANT_CONNECTION)))
                .thenReturn(PackageManager.PERMISSION_DENIED);

        assertThrows(SecurityException.class,
                () -> mService.isConnected(PACKAGE_NAME, any(OccupantZoneInfo.class)));
    }

    @Test
    public void testIsConnectedWithFakePackageName_throwsException() {
        assertThrows(SecurityException.class,
                () -> mService.isConnected(FAKE_PACKAGE_NAME, any(OccupantZoneInfo.class)));
    }

    @Test
    public void testIsConnected() {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle)).thenReturn(mSenderZone);

        assertThat(mService.isConnected(PACKAGE_NAME, mReceiverZone)).isFalse();

        ConnectionRecord connectionRecord =
                new ConnectionRecord(PACKAGE_NAME, mSenderZone.zoneId, mReceiverZone.zoneId);
        mEstablishedConnections.add(connectionRecord);

        assertThat(mService.isConnected(PACKAGE_NAME, mReceiverZone)).isTrue();
    }

    @Test
    public void testDisconnectWithoutPermission_throwsException() {
        when(mContext.checkCallingOrSelfPermission(eq(Car.PERMISSION_MANAGE_OCCUPANT_CONNECTION)))
                .thenReturn(PackageManager.PERMISSION_DENIED);

        assertThrows(SecurityException.class,
                () -> mService.disconnect(PACKAGE_NAME, mReceiverZone));
    }

    @Test
    public void testDisconnectWithFakePackageName_throwsException() {
        assertThrows(SecurityException.class,
                () -> mService.disconnect(FAKE_PACKAGE_NAME, mReceiverZone));
    }

    @Test
    public void testDisconnect() throws RemoteException {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle)).thenReturn(mSenderZone);
        ConnectionRecord connectionRecord =
                new ConnectionRecord(PACKAGE_NAME, mSenderZone.zoneId, mReceiverZone.zoneId);
        mEstablishedConnections.add(connectionRecord);

        ClientId senderClient = mService.getCallingClientId(PACKAGE_NAME);
        when(mOccupantZoneService.getUserForOccupant(mReceiverZone.zoneId))
                .thenReturn(RECEIVER_USER_ID);
        ClientId receiverClient = new ClientId(mReceiverZone, RECEIVER_USER_ID, PACKAGE_NAME);
        ConnectionId connectionId = new ConnectionId(senderClient, receiverClient);
        mAcceptedConnectionRequestMap.put(connectionId, mConnectionRequestCallback);

        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(receiverService.asBinder()).thenReturn(binder);
        mConnectedReceiverServiceMap.put(receiverClient, receiverService);
        ServiceConnection serviceConnection = mock(ServiceConnection.class);
        mReceiverServiceConnectionMap.put(receiverClient, serviceConnection);

        mService.disconnect(PACKAGE_NAME, mReceiverZone);

        assertThat(mEstablishedConnections.size()).isEqualTo(0);
        assertThat(mAcceptedConnectionRequestMap.size()).isEqualTo(0);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(0);
        assertThat(mReceiverServiceConnectionMap.size()).isEqualTo(0);
        verify(receiverService).onDisconnected(mSenderZone);
        verify(mContext).unbindService(serviceConnection);
    }

    @Test
    public void testDisconnectWithoutEstablishedConnection_throwsException() {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle)).thenReturn(mSenderZone);

        // The connection is not established yet, so disconnecting should throw an
        // IllegalStateException.
        assertThrows(IllegalStateException.class,
                () -> mService.disconnect(PACKAGE_NAME, mReceiverZone));
    }

    @Test
    public void testConnectedSenderDied() throws RemoteException {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle)).thenReturn(mSenderZone);
        ConnectionRecord connectionRecord =
                new ConnectionRecord(PACKAGE_NAME, mSenderZone.zoneId, mReceiverZone.zoneId);
        mEstablishedConnections.add(connectionRecord);

        ClientId senderClient = mService.getCallingClientId(PACKAGE_NAME);
        int receiverUserId = 456;
        when(mOccupantZoneService.getUserForOccupant(mReceiverZone.zoneId))
                .thenReturn(receiverUserId);
        ClientId receiverClient = new ClientId(mReceiverZone, receiverUserId, PACKAGE_NAME);
        ConnectionId connectionId = new ConnectionId(senderClient, receiverClient);
        TestConnectionRequestCallback connectionRequestCallback =
                new TestConnectionRequestCallback();
        mAcceptedConnectionRequestMap.put(connectionId, connectionRequestCallback);

        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(receiverService.asBinder()).thenReturn(binder);
        mConnectedReceiverServiceMap.put(receiverClient, receiverService);
        ServiceConnection serviceConnection = mock(ServiceConnection.class);
        mReceiverServiceConnectionMap.put(receiverClient, serviceConnection);

        // The sender dies.
        connectionRequestCallback.die();

        assertThat(mEstablishedConnections.size()).isEqualTo(0);
        assertThat(mAcceptedConnectionRequestMap.size()).isEqualTo(0);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(0);
        assertThat(mReceiverServiceConnectionMap.size()).isEqualTo(0);
        verify(receiverService).onDisconnected(mSenderZone);
        verify(mContext).unbindService(serviceConnection);
    }

    @Test
    public void testConnectingSenderDiedWithoutReceiverServiceBound() throws RemoteException {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle)).thenReturn(mSenderZone);

        ClientId senderClient = mService.getCallingClientId(PACKAGE_NAME);
        int receiverUserId = 456;
        when(mOccupantZoneService.getUserForOccupant(mReceiverZone.zoneId))
                .thenReturn(receiverUserId);
        ClientId receiverClient = new ClientId(mReceiverZone, receiverUserId, PACKAGE_NAME);
        ConnectionId connectionId = new ConnectionId(senderClient, receiverClient);
        TestConnectionRequestCallback connectionRequestCallback =
                new TestConnectionRequestCallback();
        mPendingConnectionRequestMap.put(connectionId, connectionRequestCallback);

        mConnectingReceiverServices.add(receiverClient);
        ServiceConnection serviceConnection = mock(ServiceConnection.class);
        mReceiverServiceConnectionMap.put(receiverClient, serviceConnection);

        // The sender dies.
        connectionRequestCallback.die();

        assertThat(mPendingConnectionRequestMap.size()).isEqualTo(0);
        assertThat(mConnectingReceiverServices.size()).isEqualTo(0);
        assertThat(mReceiverServiceConnectionMap.size()).isEqualTo(0);
        verify(mContext).unbindService(serviceConnection);
    }

    @Test
    public void testConnectingSenderDiedWithReceiverServiceBound() throws RemoteException {
        UserHandle senderUserHandle = Binder.getCallingUserHandle();
        when(mOccupantZoneService.getOccupantZoneForUser(senderUserHandle)).thenReturn(mSenderZone);

        ClientId senderClient = mService.getCallingClientId(PACKAGE_NAME);
        int receiverUserId = 456;
        when(mOccupantZoneService.getUserForOccupant(mReceiverZone.zoneId))
                .thenReturn(receiverUserId);
        ClientId receiverClient = new ClientId(mReceiverZone, receiverUserId, PACKAGE_NAME);
        ConnectionId connectionId = new ConnectionId(senderClient, receiverClient);
        TestConnectionRequestCallback connectionRequestCallback =
                new TestConnectionRequestCallback();
        mPendingConnectionRequestMap.put(connectionId, connectionRequestCallback);

        IBinder binder = mock(IBinder.class);
        IBackendReceiver receiverService = mock(IBackendReceiver.class);
        when(receiverService.asBinder()).thenReturn(binder);
        mConnectedReceiverServiceMap.put(receiverClient, receiverService);
        ServiceConnection serviceConnection = mock(ServiceConnection.class);
        mReceiverServiceConnectionMap.put(receiverClient, serviceConnection);

        // The sender dies.
        connectionRequestCallback.die();

        assertThat(mPendingConnectionRequestMap.size()).isEqualTo(0);
        assertThat(mConnectedReceiverServiceMap.size()).isEqualTo(0);
        assertThat(mReceiverServiceConnectionMap.size()).isEqualTo(0);
        verify(receiverService).onConnectionCanceled(mSenderZone);
        verify(mContext).unbindService(serviceConnection);
    }

    private void mockPackageName() throws PackageManager.NameNotFoundException {
        PackageManager pm = mock(PackageManager.class);
        when(mContext.getPackageManager()).thenReturn(pm);
        when(pm.getPackageUidAsUser(eq(PACKAGE_NAME), anyInt())).thenReturn(Binder.getCallingUid());
    }

    private void mockAppInstalled(OccupantZoneInfo occupantZone, UserHandle userHandle) {
        when(mRemoteDeviceService.isConnectionReady(occupantZone)).thenReturn(true);
        PackageInfo packageInfo = mock(PackageInfo.class);
        when(mRemoteDeviceService.getEndpointPackageInfo(occupantZone.zoneId, PACKAGE_NAME))
                .thenReturn(packageInfo);
        when(mOccupantZoneService.getOccupantZoneForUser(userHandle))
                .thenReturn(occupantZone);
        when(mOccupantZoneService.getUserForOccupant(occupantZone.zoneId))
                .thenReturn(userHandle.getIdentifier());
        when(mRemoteDeviceService.getPackageInfoAsUser(PACKAGE_NAME, userHandle.getIdentifier()))
                .thenReturn(packageInfo);
    }

    private static final class TestConnectionRequestCallback extends android.os.Binder implements
            IConnectionRequestCallback {

        private DeathRecipient mRecipient;

        @Override
        public void linkToDeath(DeathRecipient recipient, int flags) {
            // In any situation, a single binder object should only have at most one death
            // recipient.
            assertThat(mRecipient).isNull();

            mRecipient = recipient;
        }

        @Override
        public boolean unlinkToDeath(DeathRecipient recipient, int flags) {
            assertThat(mRecipient).isSameInstanceAs(recipient);
            mRecipient = null;
            return true;
        }

        @Override
        public IBinder asBinder() {
            return this;
        }

        @Override
        public void onConnected(OccupantZoneInfo receiverZone) {
        }

        @Override
        public void onFailed(OccupantZoneInfo receiverZone, int connectionError) {
        }

        @Override
        public void onDisconnected(OccupantZoneInfo receiverZone) {
        }

        private void die() {
            if (mRecipient != null) {
                mRecipient.binderDied(this);
            }
            mRecipient = null;
        }
    }
}