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

Commit b77a83bf authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Automerger Merge Worker
Browse files

Merge changes from topic "uwb_api_changes" into sc-dev am: 848cc69c 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/13606242

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: I8d5c944417d7cdd0658c7bff6ffe394325611a5f
parents 278c46e3 848cc69c

core/java/android/uwb/IUwbAdapter.aidl

+7 −6
Original line number Diff line number Diff line
@@ -62,9 +62,6 @@ interface IUwbAdapter { 
  /**

   * Request to open a new ranging session

   *

   * This function must return before calling any functions in

   * IUwbAdapterCallbacks.

   *

   * This function does not start the ranging session, but all necessary

   * components must be initialized and ready to start a new ranging

   * session prior to calling IUwbAdapterCallback#onRangingOpened.
@@ -77,11 +74,15 @@ interface IUwbAdapter { 
   * RANGING_SESSION_OPEN_THRESHOLD_MS milliseconds of #openRanging being called

   * if the ranging session fails to be opened.

   *

   * If the provided sessionHandle is already open for the calling client, then

   * #onRangingOpenFailed must be called and the new session must not be opened.

   *

   * @param sessionHandle the session handle to open ranging for

   * @param rangingCallbacks the callbacks used to deliver ranging information

   * @param parameters the configuration to use for ranging

   * @return a SessionHandle used to identify this ranging request

   */

  SessionHandle openRanging(in IUwbRangingCallbacks rangingCallbacks,

  void openRanging(in SessionHandle sessionHandle,

                   in IUwbRangingCallbacks rangingCallbacks,

                   in PersistableBundle parameters);



  /**

core/java/android/uwb/RangingManager.java

+8 −14
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ public class RangingManager extends android.uwb.IUwbRangingCallbacks.Stub { 


    private final IUwbAdapter mAdapter;

    private final Hashtable<SessionHandle, RangingSession> mRangingSessionTable = new Hashtable<>();

    private int mNextSessionId = 1;



    public RangingManager(IUwbAdapter adapter) {

        mAdapter = adapter;
@@ -51,24 +52,17 @@ public class RangingManager extends android.uwb.IUwbRangingCallbacks.Stub { 
    public CancellationSignal openSession(@NonNull PersistableBundle params,

            @NonNull Executor executor,

            @NonNull RangingSession.Callback callbacks) {

        SessionHandle sessionHandle;

        synchronized (this) {

            SessionHandle sessionHandle = new SessionHandle(mNextSessionId++);

            RangingSession session =

                    new RangingSession(executor, callbacks, mAdapter, sessionHandle);

            mRangingSessionTable.put(sessionHandle, session);

            try {

            sessionHandle = mAdapter.openRanging(this, params);

                mAdapter.openRanging(sessionHandle, this, params);

            } catch (RemoteException e) {

                throw e.rethrowFromSystemServer();

            }



        synchronized (this) {

            if (hasSession(sessionHandle)) {

                Log.w(TAG, "Newly created session unexpectedly reuses an active SessionHandle");

                executor.execute(() -> callbacks.onClosed(

                        RangingSession.Callback.REASON_GENERIC_ERROR,

                        new PersistableBundle()));

            }



            RangingSession session =

                    new RangingSession(executor, callbacks, mAdapter, sessionHandle);

            mRangingSessionTable.put(sessionHandle, session);

            CancellationSignal cancellationSignal = new CancellationSignal();

            cancellationSignal.setOnCancelListener(() -> session.close());

            return cancellationSignal;

core/tests/uwbtests/src/android/uwb/RangingManagerTest.java

+51 −59
Original line number Diff line number Diff line
@@ -22,7 +22,6 @@ import static org.mockito.ArgumentMatchers.eq; 
import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.os.PersistableBundle;

import android.os.RemoteException;
@@ -32,6 +31,7 @@ import androidx.test.filters.SmallTest; 


import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;



import java.util.concurrent.Executor;
@@ -42,51 +42,23 @@ import java.util.concurrent.Executor; 
@RunWith(AndroidJUnit4.class)

public class RangingManagerTest {



    private static final IUwbAdapter ADAPTER = mock(IUwbAdapter.class);

    private static final Executor EXECUTOR = UwbTestUtils.getExecutor();

    private static final PersistableBundle PARAMS = new PersistableBundle();

    private static final @RangingChangeReason int REASON = RangingChangeReason.UNKNOWN;



    @Test

    public void testOpenSession_OpenRangingInvoked() throws RemoteException {

        RangingManager rangingManager = new RangingManager(ADAPTER);

        IUwbAdapter adapter = mock(IUwbAdapter.class);

        RangingManager rangingManager = new RangingManager(adapter);

        RangingSession.Callback callback = mock(RangingSession.Callback.class);

        rangingManager.openSession(PARAMS, EXECUTOR, callback);

        verify(ADAPTER, times(1)).openRanging(eq(rangingManager), eq(PARAMS));

    }



    @Test

    public void testOpenSession_ErrorIfSameSessionHandleReturned() throws RemoteException {

        RangingManager rangingManager = new RangingManager(ADAPTER);

        RangingSession.Callback callback = mock(RangingSession.Callback.class);

        SessionHandle handle = new SessionHandle(1);

        when(ADAPTER.openRanging(any(), any())).thenReturn(handle);



        rangingManager.openSession(PARAMS, EXECUTOR, callback);



        // Calling openSession will cause the same session handle to be returned. The onClosed

        // callback should be invoked

        RangingSession.Callback callback2 = mock(RangingSession.Callback.class);

        rangingManager.openSession(PARAMS, EXECUTOR, callback2);

        verify(callback, times(0)).onClosed(anyInt(), any());

        verify(callback2, times(1)).onClosed(anyInt(), any());

    }



    @Test

    public void testOnRangingOpened_ValidSessionHandle() throws RemoteException {

        RangingManager rangingManager = new RangingManager(ADAPTER);

        RangingSession.Callback callback = mock(RangingSession.Callback.class);

        SessionHandle handle = new SessionHandle(1);

        when(ADAPTER.openRanging(any(), any())).thenReturn(handle);



        rangingManager.openSession(PARAMS, EXECUTOR, callback);

        rangingManager.onRangingOpened(handle);

        verify(callback, times(1)).onOpened(any());

        verify(adapter, times(1)).openRanging(any(), eq(rangingManager), eq(PARAMS));

    }



    @Test

    public void testOnRangingOpened_InvalidSessionHandle() throws RemoteException {

        RangingManager rangingManager = new RangingManager(ADAPTER);

        IUwbAdapter adapter = mock(IUwbAdapter.class);

        RangingManager rangingManager = new RangingManager(adapter);

        RangingSession.Callback callback = mock(RangingSession.Callback.class);



        rangingManager.onRangingOpened(new SessionHandle(2));
@@ -95,18 +67,20 @@ public class RangingManagerTest { 


    @Test

    public void testOnRangingOpened_MultipleSessionsRegistered() throws RemoteException {

        SessionHandle sessionHandle1 = new SessionHandle(1);

        SessionHandle sessionHandle2 = new SessionHandle(2);

        IUwbAdapter adapter = mock(IUwbAdapter.class);

        RangingSession.Callback callback1 = mock(RangingSession.Callback.class);

        RangingSession.Callback callback2 = mock(RangingSession.Callback.class);

        ArgumentCaptor<SessionHandle> sessionHandleCaptor =

                ArgumentCaptor.forClass(SessionHandle.class);



        when(ADAPTER.openRanging(any(), any()))

                .thenReturn(sessionHandle1)

                .thenReturn(sessionHandle2);



        RangingManager rangingManager = new RangingManager(ADAPTER);

        RangingManager rangingManager = new RangingManager(adapter);

        rangingManager.openSession(PARAMS, EXECUTOR, callback1);

        verify(adapter, times(1)).openRanging(sessionHandleCaptor.capture(), any(), any());

        SessionHandle sessionHandle1 = sessionHandleCaptor.getValue();



        rangingManager.openSession(PARAMS, EXECUTOR, callback2);

        verify(adapter, times(2)).openRanging(sessionHandleCaptor.capture(), any(), any());

        SessionHandle sessionHandle2 = sessionHandleCaptor.getValue();



        rangingManager.onRangingOpened(sessionHandle1);

        verify(callback1, times(1)).onOpened(any());
@@ -119,12 +93,17 @@ public class RangingManagerTest { 


    @Test

    public void testCorrectCallbackInvoked() throws RemoteException {

        RangingManager rangingManager = new RangingManager(ADAPTER);

        IUwbAdapter adapter = mock(IUwbAdapter.class);

        RangingManager rangingManager = new RangingManager(adapter);

        RangingSession.Callback callback = mock(RangingSession.Callback.class);

        SessionHandle handle = new SessionHandle(1);

        when(ADAPTER.openRanging(any(), any())).thenReturn(handle);



        ArgumentCaptor<SessionHandle> sessionHandleCaptor =

                ArgumentCaptor.forClass(SessionHandle.class);



        rangingManager.openSession(PARAMS, EXECUTOR, callback);

        verify(adapter, times(1)).openRanging(sessionHandleCaptor.capture(), any(), any());

        SessionHandle handle = sessionHandleCaptor.getValue();



        rangingManager.onRangingOpened(handle);

        verify(callback, times(1)).onOpened(any());
@@ -156,20 +135,23 @@ public class RangingManagerTest { 


    @Test

    public void testOnRangingClosed_MultipleSessionsRegistered() throws RemoteException {

        IUwbAdapter adapter = mock(IUwbAdapter.class);

        // Verify that if multiple sessions are registered, only the session that is

        // requested to close receives the associated callbacks

        SessionHandle sessionHandle1 = new SessionHandle(1);

        SessionHandle sessionHandle2 = new SessionHandle(2);

        RangingSession.Callback callback1 = mock(RangingSession.Callback.class);

        RangingSession.Callback callback2 = mock(RangingSession.Callback.class);



        when(ADAPTER.openRanging(any(), any()))

                .thenReturn(sessionHandle1)

                .thenReturn(sessionHandle2);

        RangingManager rangingManager = new RangingManager(adapter);

        ArgumentCaptor<SessionHandle> sessionHandleCaptor =

                ArgumentCaptor.forClass(SessionHandle.class);



        RangingManager rangingManager = new RangingManager(ADAPTER);

        rangingManager.openSession(PARAMS, EXECUTOR, callback1);

        verify(adapter, times(1)).openRanging(sessionHandleCaptor.capture(), any(), any());

        SessionHandle sessionHandle1 = sessionHandleCaptor.getValue();



        rangingManager.openSession(PARAMS, EXECUTOR, callback2);

        verify(adapter, times(2)).openRanging(sessionHandleCaptor.capture(), any(), any());

        SessionHandle sessionHandle2 = sessionHandleCaptor.getValue();



        rangingManager.onRangingClosed(sessionHandle1, REASON, PARAMS);

        verify(callback1, times(1)).onClosed(anyInt(), any());
@@ -182,19 +164,22 @@ public class RangingManagerTest { 


    @Test

    public void testOnRangingReport_MultipleSessionsRegistered() throws RemoteException {

        SessionHandle sessionHandle1 = new SessionHandle(1);

        SessionHandle sessionHandle2 = new SessionHandle(2);

        IUwbAdapter adapter = mock(IUwbAdapter.class);

        RangingSession.Callback callback1 = mock(RangingSession.Callback.class);

        RangingSession.Callback callback2 = mock(RangingSession.Callback.class);



        when(ADAPTER.openRanging(any(), any()))

                .thenReturn(sessionHandle1)

                .thenReturn(sessionHandle2);

        ArgumentCaptor<SessionHandle> sessionHandleCaptor =

                ArgumentCaptor.forClass(SessionHandle.class);



        RangingManager rangingManager = new RangingManager(ADAPTER);

        RangingManager rangingManager = new RangingManager(adapter);

        rangingManager.openSession(PARAMS, EXECUTOR, callback1);

        verify(adapter, times(1)).openRanging(sessionHandleCaptor.capture(), any(), any());

        SessionHandle sessionHandle1 = sessionHandleCaptor.getValue();



        rangingManager.onRangingStarted(sessionHandle1, PARAMS);

        rangingManager.openSession(PARAMS, EXECUTOR, callback2);

        verify(adapter, times(2)).openRanging(sessionHandleCaptor.capture(), any(), any());

        SessionHandle sessionHandle2 = sessionHandleCaptor.getValue();

        rangingManager.onRangingStarted(sessionHandle2, PARAMS);



        rangingManager.onRangingResult(sessionHandle1, UwbTestUtils.getRangingReports(1));
@@ -232,17 +217,24 @@ public class RangingManagerTest { 


    private void runReason(@RangingChangeReason int reasonIn,

            @RangingSession.Callback.Reason int reasonOut) throws RemoteException {

        RangingManager rangingManager = new RangingManager(ADAPTER);

        IUwbAdapter adapter = mock(IUwbAdapter.class);

        RangingManager rangingManager = new RangingManager(adapter);

        RangingSession.Callback callback = mock(RangingSession.Callback.class);

        SessionHandle handle = new SessionHandle(1);

        when(ADAPTER.openRanging(any(), any())).thenReturn(handle);



        ArgumentCaptor<SessionHandle> sessionHandleCaptor =

                ArgumentCaptor.forClass(SessionHandle.class);



        rangingManager.openSession(PARAMS, EXECUTOR, callback);

        verify(adapter, times(1)).openRanging(sessionHandleCaptor.capture(), any(), any());

        SessionHandle handle = sessionHandleCaptor.getValue();



        rangingManager.onRangingOpenFailed(handle, reasonIn, PARAMS);

        verify(callback, times(1)).onOpenFailed(eq(reasonOut), eq(PARAMS));



        // Open a new session

        rangingManager.openSession(PARAMS, EXECUTOR, callback);

        verify(adapter, times(2)).openRanging(sessionHandleCaptor.capture(), any(), any());

        handle = sessionHandleCaptor.getValue();

        rangingManager.onRangingOpened(handle);



        rangingManager.onRangingStartFailed(handle, reasonIn, PARAMS);