Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dde33f95 authored by Sungsoo Lim's avatar Sungsoo Lim Committed by Gerrit Code Review
Browse files

Merge "Add HfpNativeInterfaceTest"

parents e7f83916 c59cb7b1

android/app/src/com/android/bluetooth/btservice/AdapterService.java

+7 −1
Original line number Diff line number Diff line
@@ -248,7 +248,13 @@ public class AdapterService extends Service { 
        return sAdapterService;

    }



    private static synchronized void setAdapterService(AdapterService instance) {

    /**

     * Sets AdapterService for testing.

     *

     * @hide

     */

    @VisibleForTesting

    public static synchronized void setAdapterService(AdapterService instance) {

        Log.d(TAG, "setAdapterService() - trying to set service to " + instance);

        if (instance == null) {

            return;

android/app/src/com/android/bluetooth/hfpclient/NativeInterface.java

+44 −22
Original line number Diff line number Diff line
@@ -330,7 +330,8 @@ public class NativeInterface { 


    // Callbacks from the native back into the java framework. All callbacks are routed via the

    // Service which will disambiguate which state machine the message should be routed through.

    private void onConnectionStateChanged(int state, int peerFeat, int chldFeat, byte[] address) {

    @VisibleForTesting

    void onConnectionStateChanged(int state, int peerFeat, int chldFeat, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED);

        event.valueInt = state;

        event.valueInt2 = peerFeat;
@@ -349,7 +350,8 @@ public class NativeInterface { 
        }

    }



    private void onAudioStateChanged(int state, byte[] address) {

    @VisibleForTesting

    void onAudioStateChanged(int state, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_AUDIO_STATE_CHANGED);

        event.valueInt = state;

        event.device = getDevice(address);
@@ -365,7 +367,8 @@ public class NativeInterface { 
        }

    }



    private void onVrStateChanged(int state, byte[] address) {

    @VisibleForTesting

    void onVrStateChanged(int state, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_VR_STATE_CHANGED);

        event.valueInt = state;

        event.device = getDevice(address);
@@ -382,7 +385,8 @@ public class NativeInterface { 
        }

    }



    private void onNetworkState(int state, byte[] address) {

    @VisibleForTesting

    void onNetworkState(int state, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_NETWORK_STATE);

        event.valueInt = state;

        event.device = getDevice(address);
@@ -400,7 +404,8 @@ public class NativeInterface { 
        }

    }



    private void onNetworkRoaming(int state, byte[] address) {

    @VisibleForTesting

    void onNetworkRoaming(int state, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_ROAMING_STATE);

        event.valueInt = state;

        event.device = getDevice(address);
@@ -416,7 +421,8 @@ public class NativeInterface { 
        }

    }



    private void onNetworkSignal(int signal, byte[] address) {

    @VisibleForTesting

    void onNetworkSignal(int signal, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_NETWORK_SIGNAL);

        event.valueInt = signal;

        event.device = getDevice(address);
@@ -431,7 +437,8 @@ public class NativeInterface { 
        }

    }



    private void onBatteryLevel(int level, byte[] address) {

    @VisibleForTesting

    void onBatteryLevel(int level, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_BATTERY_LEVEL);

        event.valueInt = level;

        event.device = getDevice(address);
@@ -446,7 +453,8 @@ public class NativeInterface { 
        }

    }



    private void onCurrentOperator(String name, byte[] address) {

    @VisibleForTesting

    void onCurrentOperator(String name, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_OPERATOR_NAME);

        event.valueString = name;

        event.device = getDevice(address);
@@ -462,7 +470,8 @@ public class NativeInterface { 
        }

    }



    private void onCall(int call, byte[] address) {

    @VisibleForTesting

    void onCall(int call, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALL);

        event.valueInt = call;

        event.device = getDevice(address);
@@ -486,7 +495,8 @@ public class NativeInterface { 
     * 2 - Outgoing call process ongoing

     * 3 - Remote party being alerted for outgoing call

     */

    private void onCallSetup(int callsetup, byte[] address) {

    @VisibleForTesting

    void onCallSetup(int callsetup, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALLSETUP);

        event.valueInt = callsetup;

        event.device = getDevice(address);
@@ -511,7 +521,8 @@ public class NativeInterface { 
     * call)

     * 2 - Call on hold, no active call

     */

    private void onCallHeld(int callheld, byte[] address) {

    @VisibleForTesting

    void onCallHeld(int callheld, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALLHELD);

        event.valueInt = callheld;

        event.device = getDevice(address);
@@ -526,7 +537,8 @@ public class NativeInterface { 
        }

    }



    private void onRespAndHold(int respAndHold, byte[] address) {

    @VisibleForTesting

    void onRespAndHold(int respAndHold, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_RESP_AND_HOLD);

        event.valueInt = respAndHold;

        event.device = getDevice(address);
@@ -541,7 +553,8 @@ public class NativeInterface { 
        }

    }



    private void onClip(String number, byte[] address) {

    @VisibleForTesting

    void onClip(String number, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CLIP);

        event.valueString = number;

        event.device = getDevice(address);
@@ -556,7 +569,8 @@ public class NativeInterface { 
        }

    }



    private void onCallWaiting(String number, byte[] address) {

    @VisibleForTesting

    void onCallWaiting(String number, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CALL_WAITING);

        event.valueString = number;

        event.device = getDevice(address);
@@ -571,7 +585,8 @@ public class NativeInterface { 
        }

    }



    private void onCurrentCalls(int index, int dir, int state, int mparty, String number,

    @VisibleForTesting

    void onCurrentCalls(int index, int dir, int state, int mparty, String number,

            byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CURRENT_CALLS);

        event.valueInt = index;
@@ -591,7 +606,8 @@ public class NativeInterface { 
        }

    }



    private void onVolumeChange(int type, int volume, byte[] address) {

    @VisibleForTesting

    void onVolumeChange(int type, int volume, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_VOLUME_CHANGED);

        event.valueInt = type;

        event.valueInt2 = volume;
@@ -607,7 +623,8 @@ public class NativeInterface { 
        }

    }



    private void onCmdResult(int type, int cme, byte[] address) {

    @VisibleForTesting

    void onCmdResult(int type, int cme, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_CMD_RESULT);

        event.valueInt = type;

        event.valueInt2 = cme;
@@ -623,7 +640,8 @@ public class NativeInterface { 
        }

    }



    private void onSubscriberInfo(String number, int type, byte[] address) {

    @VisibleForTesting

    void onSubscriberInfo(String number, int type, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_SUBSCRIBER_INFO);

        event.valueInt = type;

        event.valueString = number;
@@ -640,7 +658,8 @@ public class NativeInterface { 
        }

    }



    private void onInBandRing(int inBand, byte[] address) {

    @VisibleForTesting

    void onInBandRing(int inBand, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_IN_BAND_RINGTONE);

        event.valueInt = inBand;

        event.device = getDevice(address);
@@ -656,11 +675,13 @@ public class NativeInterface { 
        }

    }



    private void onLastVoiceTagNumber(String number, byte[] address) {

    @VisibleForTesting

    void onLastVoiceTagNumber(String number, byte[] address) {

        Log.w(TAG, "onLastVoiceTagNumber not supported");

    }



    private void onRingIndication(byte[] address) {

    @VisibleForTesting

    void onRingIndication(byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_RING_INDICATION);

        event.device = getDevice(address);

        if (DBG) {
@@ -675,7 +696,8 @@ public class NativeInterface { 
        }

    }



    private void onUnknownEvent(String eventString, byte[] address) {

    @VisibleForTesting

    void onUnknownEvent(String eventString, byte[] address) {

        StackEvent event = new StackEvent(StackEvent.EVENT_TYPE_UNKNOWN_EVENT);

        event.device = getDevice(address);

        event.valueString = eventString;

android/app/tests/unit/src/com/android/bluetooth/hfpclient/HfpNativeInterfaceTest.java

0 → 100644
+310 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2022 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.bluetooth.hfpclient;



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



import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import com.android.bluetooth.btservice.AdapterService;



import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import org.mockito.ArgumentCaptor;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



public class HfpNativeInterfaceTest {

    private static final byte[] TEST_DEVICE_ADDRESS =

            new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

    @Mock

    HeadsetClientService mService;

    @Mock

    AdapterService mAdapterService;



    private NativeInterface mNativeInterface;



    @Before

    public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

        when(mService.isAvailable()).thenReturn(true);

        HeadsetClientService.setHeadsetClientService(mService);

        AdapterService.setAdapterService(mAdapterService);

        mNativeInterface = NativeInterface.getInstance();

    }



    @After

    public void tearDown() {

        HeadsetClientService.setHeadsetClientService(null);

        AdapterService.setAdapterService(null);

    }



    @Test

    public void onConnectionStateChanged() {

        int state = HeadsetClientHalConstants.CONNECTION_STATE_CONNECTED;

        int peerFeat = HeadsetClientHalConstants.PEER_FEAT_HF_IND;

        int chldFeat = HeadsetClientHalConstants.PEER_FEAT_ECS;

        mNativeInterface.onConnectionStateChanged(state, peerFeat, chldFeat, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_CONNECTION_STATE_CHANGED);

        assertThat(event.getValue().valueInt).isEqualTo(state);

        assertThat(event.getValue().valueInt2).isEqualTo(peerFeat);

        assertThat(event.getValue().valueInt3).isEqualTo(chldFeat);

    }



    @Test

    public void onAudioStateChanged() {

        int state = HeadsetClientHalConstants.AUDIO_STATE_DISCONNECTED;

        mNativeInterface.onAudioStateChanged(state, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_AUDIO_STATE_CHANGED);

        assertThat(event.getValue().valueInt).isEqualTo(state);

    }



    @Test

    public void onVrStateChanged() {

        int state = 1;

        mNativeInterface.onVrStateChanged(state, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_VR_STATE_CHANGED);

        assertThat(event.getValue().valueInt).isEqualTo(state);

    }



    @Test

    public void onNetworkState() {

        int state = HeadsetClientHalConstants.NETWORK_STATE_NOT_AVAILABLE;

        mNativeInterface.onNetworkState(state, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_NETWORK_STATE);

        assertThat(event.getValue().valueInt).isEqualTo(state);

    }



    @Test

    public void onNetworkRoaming() {

        int state = HeadsetClientHalConstants.SERVICE_TYPE_ROAMING;

        mNativeInterface.onNetworkRoaming(state, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_ROAMING_STATE);

        assertThat(event.getValue().valueInt).isEqualTo(state);

    }



    @Test

    public void onNetworkSignal() {

        int signal = 3;

        mNativeInterface.onNetworkSignal(signal, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_NETWORK_SIGNAL);

        assertThat(event.getValue().valueInt).isEqualTo(signal);

    }



    @Test

    public void onBatteryLevel() {

        int level = 15;

        mNativeInterface.onBatteryLevel(level, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_BATTERY_LEVEL);

        assertThat(event.getValue().valueInt).isEqualTo(level);

    }



    @Test

    public void onCurrentOperator() {

        String name = "test";

        mNativeInterface.onCurrentOperator(name, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_OPERATOR_NAME);

        assertThat(event.getValue().valueString).isEqualTo(name);

    }



    @Test

    public void onCall() {

        int call = 1;

        mNativeInterface.onCall(call, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_CALL);

        assertThat(event.getValue().valueInt).isEqualTo(call);

    }



    @Test

    public void onCallSetup() {

        int callsetup = 1;

        mNativeInterface.onCallSetup(callsetup, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_CALLSETUP);

        assertThat(event.getValue().valueInt).isEqualTo(callsetup);

    }



    @Test

    public void onCallHeld() {

        int callheld = 1;

        mNativeInterface.onCallSetup(callheld, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_CALLSETUP);

        assertThat(event.getValue().valueInt).isEqualTo(callheld);

    }



    @Test

    public void onRespAndHold() {

        int respAndHold = 1;

        mNativeInterface.onRespAndHold(respAndHold, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_RESP_AND_HOLD);

        assertThat(event.getValue().valueInt).isEqualTo(respAndHold);

    }



    @Test

    public void onClip() {

        String number = "000-000-0000";

        mNativeInterface.onClip(number, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_CLIP);

        assertThat(event.getValue().valueString).isEqualTo(number);

    }



    @Test

    public void onCallWaiting() {

        String number = "000-000-0000";

        mNativeInterface.onCallWaiting(number, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_CALL_WAITING);

        assertThat(event.getValue().valueString).isEqualTo(number);

    }



    @Test

    public void onCurrentCalls() {

        int index = 2;

        int dir = HeadsetClientHalConstants.CALL_DIRECTION_OUTGOING;

        int state = HfpClientCall.CALL_STATE_WAITING;

        int mparty = HeadsetClientHalConstants.CALL_MPTY_TYPE_MULTI;

        String number = "000-000-0000";

        mNativeInterface.onCurrentCalls(index, dir, state, mparty, number, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_CURRENT_CALLS);

        assertThat(event.getValue().valueInt).isEqualTo(index);

        assertThat(event.getValue().valueInt2).isEqualTo(dir);

        assertThat(event.getValue().valueInt3).isEqualTo(state);

        assertThat(event.getValue().valueInt4).isEqualTo(mparty);

        assertThat(event.getValue().valueString).isEqualTo(number);

    }



    @Test

    public void onVolumeChange() {

        int type = HeadsetClientHalConstants.VOLUME_TYPE_SPK;

        int volume = 10;

        mNativeInterface.onVolumeChange(type, volume, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_VOLUME_CHANGED);

        assertThat(event.getValue().valueInt).isEqualTo(type);

        assertThat(event.getValue().valueInt2).isEqualTo(volume);

    }



    @Test

    public void onCmdResult() {

        int type = HeadsetClientStateMachine.AT_OK;

        int cme = 10;

        mNativeInterface.onCmdResult(type, cme, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_CMD_RESULT);

        assertThat(event.getValue().valueInt).isEqualTo(type);

        assertThat(event.getValue().valueInt2).isEqualTo(cme);

    }



    @Test

    public void onSubscriberInfo() {

        String number = "000-000-0000";

        int type = 5;

        mNativeInterface.onSubscriberInfo(number, type, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_SUBSCRIBER_INFO);

        assertThat(event.getValue().valueString).isEqualTo(number);

    }



    @Test

    public void onInBandRing() {

        int inBand = 1;

        mNativeInterface.onInBandRing(inBand, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_IN_BAND_RINGTONE);

        assertThat(event.getValue().valueInt).isEqualTo(inBand);

    }



    @Test

    // onLastVoiceTagNumber is not supported.

    public void onLastVoiceTagNumber_doesNotCrash() {

        String number = "000-000-0000";

        mNativeInterface.onLastVoiceTagNumber(number, TEST_DEVICE_ADDRESS);

    }



    @Test

    public void onRingIndication() {

        mNativeInterface.onRingIndication(TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_RING_INDICATION);

    }



    @Test

    public void onUnknownEvent() {

        String eventString = "unknown";

        mNativeInterface.onUnknownEvent(eventString, TEST_DEVICE_ADDRESS);



        ArgumentCaptor<StackEvent> event = ArgumentCaptor.forClass(StackEvent.class);

        verify(mService).messageFromNative(event.capture());

        assertThat(event.getValue().type).isEqualTo(StackEvent.EVENT_TYPE_UNKNOWN_EVENT);

        assertThat(event.getValue().valueString).isEqualTo(eventString);

    }

}