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

Commit ef115acc authored by Joe Antonetti's avatar Joe Antonetti
Browse files

Allow Listeners to subscribe to RemoteTaskStore 

Add APIs on RemoteTaskStore enabling listeners to directly subscribe
to change events, and updated underlying classes (like RemoteDeviceTaskList) to support this. Updated API stubs in TaskContinuityManagerService to pass listeners to RemoteTaskStore

Test: Added unit tests
Bug: 400970610
Flag: android.companion.enable_task_continuity
Change-Id: I5ffd0a0819b412590bfa337fc689dfa413a0bf71
parent de007d17

services/companion/java/com/android/server/companion/datatransfer/continuity/TaskContinuityManagerService.java

+2 −0
Original line number Diff line number Diff line
@@ -81,10 +81,12 @@ public final class TaskContinuityManagerService extends SystemService { 


        @Override

        public void registerRemoteTaskListener(@NonNull IRemoteTaskListener listener) {

            mRemoteTaskStore.addListener(listener);

        }



        @Override

        public void unregisterRemoteTaskListener(@NonNull IRemoteTaskListener listener) {

            mRemoteTaskStore.removeListener(listener);

        }



        @Override

services/companion/java/com/android/server/companion/datatransfer/continuity/tasks/RemoteDeviceTaskList.java

+65 −19
Original line number Diff line number Diff line
@@ -17,26 +17,52 @@ 
package com.android.server.companion.datatransfer.continuity.tasks;



import android.companion.datatransfer.continuity.RemoteTask;

import android.util.Slog;



import com.android.server.companion.datatransfer.continuity.messages.RemoteTaskInfo;



import java.util.function.Consumer;

import java.util.ArrayList;

import java.util.List;

import java.util.Comparator;

import java.util.HashSet;

import java.util.PriorityQueue;

import java.util.Set;



/**

 * Tracks remote tasks currently available on a specific remote device.

 */

class RemoteDeviceTaskList {



    private static final String TAG = "RemoteDeviceTaskList";



    private final int mAssociationId;

    private final String mDeviceName;

    private final List<RemoteTaskInfo> mTasks = new ArrayList<>();

    private final Consumer<RemoteTask> mOnMostRecentTaskChangedListener;

    private PriorityQueue<RemoteTaskInfo> mTasks;



    RemoteDeviceTaskList(

        int associationId,

        String deviceName) {

        String deviceName,

        Consumer<RemoteTask> onMostRecentTaskChangedListener) {



        mAssociationId = associationId;

        mDeviceName = deviceName;

        mOnMostRecentTaskChangedListener = onMostRecentTaskChangedListener;

        mTasks = new PriorityQueue<>(new Comparator<RemoteTaskInfo>() {

            @Override

            public int compare(RemoteTaskInfo task1, RemoteTaskInfo task2) {

                long lastUsedTime1 = task1.getLastUsedTimeMillis();

                long lastUsedTime2 = task2.getLastUsedTimeMillis();

                if (lastUsedTime1 < lastUsedTime2) {

                    return 1;

                } else if (lastUsedTime1 > lastUsedTime2) {

                    return -1;

                } else {

                    return 0;

                }

            }

        });

    }



    /**
@@ -58,22 +84,49 @@ class RemoteDeviceTaskList { 
     * device.

     */

    void addTask(RemoteTaskInfo taskInfo) {

        synchronized (mTasks) {

            Slog.v(TAG, "Adding task: " + taskInfo.getId() + " to association: " + mAssociationId);

            int previousTopTaskId

                = mTasks.peek() == null ? -1 : mTasks.peek().getId();



            mTasks.add(taskInfo);

            if (taskInfo.getId() != previousTopTaskId) {

                Slog.v(

                    TAG,

                    "Notifying most recent task changed for association: " + mAssociationId);

                mOnMostRecentTaskChangedListener.accept(getMostRecentTask());

            }

        }

    }



    /**

     * Sets the list of tasks currently available on the remote device.

     */

    void setTasks(List<RemoteTaskInfo> tasks) {

        synchronized (mTasks) {

            Slog.v(TAG, "Setting remote tasks for association: " + mAssociationId);

            mTasks.clear();

            mTasks.addAll(tasks);

            mOnMostRecentTaskChangedListener.accept(getMostRecentTask());

        }

    }



    /**

     * Removes a task from the list of tasks currently available on the remote device.

     */

    void removeTask(int taskId) {

        synchronized (mTasks) {

            Slog.v(TAG, "Removing task: " + taskId + " for association: " + mAssociationId);

            boolean shouldNotifyListeners

                = (mTasks.peek() != null && mTasks.peek().getId() == taskId);

            mTasks.removeIf(task -> task.getId() == taskId);

            if (shouldNotifyListeners) {

                Slog.v(

                    TAG,

                    "Notifying most recent task changed for association: " + mAssociationId);

                mOnMostRecentTaskChangedListener.accept(getMostRecentTask());

            }

        }

    }



    /**
@@ -81,20 +134,13 @@ class RemoteDeviceTaskList { 
     * tasks.

     */

    RemoteTask getMostRecentTask() {

        synchronized (mTasks) {

            Slog.v(TAG, "Getting most recent task for association: " + mAssociationId);

            if (mTasks.isEmpty()) {

                return null;

            }



        RemoteTaskInfo mostRecentTask = mTasks.get(0);

        for (RemoteTaskInfo task : mTasks) {

            if (

                task.getLastUsedTimeMillis()

                    > mostRecentTask.getLastUsedTimeMillis()) {



                mostRecentTask = task;

            }

            return mTasks.peek().toRemoteTask(mAssociationId, mDeviceName);

        }



        return mostRecentTask.toRemoteTask(mAssociationId, mDeviceName);

    }

}
 
 No newline at end of file

services/companion/java/com/android/server/companion/datatransfer/continuity/tasks/RemoteTaskStore.java

+46 −3
Original line number Diff line number Diff line
@@ -16,6 +16,9 @@ 
package com.android.server.companion.datatransfer.continuity.tasks;



import android.companion.AssociationInfo;

import android.companion.datatransfer.continuity.IRemoteTaskListener;

import android.os.RemoteCallbackList;

import android.os.RemoteException;

import android.util.Slog;



import com.android.server.companion.datatransfer.continuity.connectivity.ConnectedAssociationStore;
@@ -35,6 +38,8 @@ public class RemoteTaskStore implements ConnectedAssociationStore.Observer { 
    private final ConnectedAssociationStore mConnectedAssociationStore;

    private final Map<Integer, RemoteDeviceTaskList> mRemoteDeviceTaskLists

        = new HashMap<>();

    private final RemoteCallbackList<IRemoteTaskListener>

        mRemoteTaskListeners = new RemoteCallbackList<>();



    public RemoteTaskStore(

        ConnectedAssociationStore connectedAssociationStore) {
@@ -57,7 +62,8 @@ public class RemoteTaskStore implements ConnectedAssociationStore.Observer { 
            if (!mRemoteDeviceTaskLists.containsKey(associationId)) {

                Slog.e(

                    TAG,

                    "Attempted to set tasks for association: " + associationId + " which is not connected.");

                    "Attempted to set tasks for association: " + associationId

                        + " which is not connected.");



                return;

            }
@@ -110,18 +116,32 @@ public class RemoteTaskStore implements ConnectedAssociationStore.Observer { 
        }

    }



    public void addListener(IRemoteTaskListener listener) {

        synchronized (mRemoteTaskListeners) {

            mRemoteTaskListeners.register(listener);

        }

    }



    public void removeListener(IRemoteTaskListener listener) {

        synchronized (mRemoteTaskListeners) {

            mRemoteTaskListeners.unregister(listener);

        }

    }



    @Override

    public void onTransportConnected(AssociationInfo associationInfo) {

        synchronized (mRemoteDeviceTaskLists) {

            if (!mRemoteDeviceTaskLists.containsKey(associationInfo.getId())) {

                Slog.v(

                    TAG,

                    "Creating new RemoteDeviceTaskList for association: " + associationInfo.getId());

                    "Creating new RemoteDeviceTaskList for association: "

                        + associationInfo.getId());



                RemoteDeviceTaskList taskList

                    = new RemoteDeviceTaskList(

                        associationInfo.getId(),

                        associationInfo.getDisplayName().toString());

                        associationInfo.getDisplayName().toString(),

                        this::onMostRecentTaskChanged);



                mRemoteDeviceTaskLists.put(associationInfo.getId(), taskList);

            } else {
@@ -140,6 +160,29 @@ public class RemoteTaskStore implements ConnectedAssociationStore.Observer { 
                "Deleting RemoteDeviceTaskList for association: " + associationId);



            mRemoteDeviceTaskLists.remove(associationId);

            notifyListeners();

        }

    }



    private void onMostRecentTaskChanged(RemoteTask task) {

        notifyListeners();

    }



    private void notifyListeners() {

       synchronized (mRemoteTaskListeners) {

            List<RemoteTask> remoteTasks = getMostRecentTasks();

            int i = mRemoteTaskListeners.beginBroadcast();

            while (i > 0) {

                i--;

                try {

                    mRemoteTaskListeners

                        .getBroadcastItem(i)

                        .onRemoteTasksChanged(remoteTasks);

                } catch (RemoteException e) {

                    Slog.e(TAG, "Failed to notify listener: " + e.getMessage());

                }

            }

            mRemoteTaskListeners.finishBroadcast();

        }

    }

}
 
 No newline at end of file

services/tests/servicestests/src/com/android/server/companion/datatransfer/continuity/tasks/RemoteDeviceTaskListTest.java

+81 −39
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ import android.testing.AndroidTestingRunner; 


import com.android.server.companion.datatransfer.continuity.messages.RemoteTaskInfo;



import org.junit.Before;

import org.junit.Test;

import org.junit.Before;

import org.junit.runner.RunWith;
@@ -38,6 +39,9 @@ import java.util.List; 
@RunWith(AndroidTestingRunner.class)

public class RemoteDeviceTaskListTest {



    private RemoteTask mMostRecentTask;

    private int mObserverCallCount;



    private static final int ASSOCIATION_ID = 123;

    private static final String DEVICE_NAME = "device1";
@@ -45,7 +49,13 @@ public class RemoteDeviceTaskListTest { 


    @Before

    public void setUp() {

        taskList = new RemoteDeviceTaskList(ASSOCIATION_ID, DEVICE_NAME);

        mMostRecentTask = null;

        mObserverCallCount = 0;



        taskList = new RemoteDeviceTaskList(

            ASSOCIATION_ID,

            DEVICE_NAME,

            this::onMostRecentTaskChanged);

    }



    @Test
@@ -56,27 +66,37 @@ public class RemoteDeviceTaskListTest { 
    }



    @Test

    public void testAddTask_updatesMostRecentTask() {

        RemoteTaskInfo firstAddedTask = createNewRemoteTaskInfo(2, "task2", 200);



        taskList.addTask(firstAddedTask);

    public void testAddTask_updatesMostRecentTaskAndNotifiesListeners() {

        // Before adding any tasks, the most recent task should be null.

        assertThat(taskList.getMostRecentTask()).isNull();



        assertThat(taskList.getMostRecentTask())

            .isEqualTo(firstAddedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME));

        // Add a task, verify it automatically becomes the most recent task.

        RemoteTaskInfo firstAddedTaskInfo

            = createNewRemoteTaskInfo(2, "task2", 200);

        RemoteTask firstAddedTask

            = firstAddedTaskInfo.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME);

        taskList.addTask(firstAddedTaskInfo);

        assertThat(mObserverCallCount).isEqualTo(1);

        assertThat(mMostRecentTask).isEqualTo(firstAddedTask);

        assertThat(taskList.getMostRecentTask()).isEqualTo(firstAddedTask);



        // Add another task with an older timestamp, verify it doesn't update

        // the most recent task.

        RemoteTaskInfo secondAddedTask = createNewRemoteTaskInfo(1, "task1", 100);

        taskList.addTask(secondAddedTask);

        assertThat(taskList.getMostRecentTask())

            .isEqualTo(firstAddedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME));

        RemoteTaskInfo secondAddedTaskInfo = createNewRemoteTaskInfo(1, "task1", 100);

        taskList.addTask(secondAddedTaskInfo);

        assertThat(taskList.getMostRecentTask()).isEqualTo(firstAddedTask);

        assertThat(mObserverCallCount).isEqualTo(2);

        assertThat(mMostRecentTask).isEqualTo(firstAddedTask);



        // Add another task with a newer timestamp, verifying it changes the

        // most recently used task.

        RemoteTaskInfo thirdAddedTask = createNewRemoteTaskInfo(3, "task3", 300);

        taskList.addTask(thirdAddedTask);

        assertThat(taskList.getMostRecentTask())

            .isEqualTo(thirdAddedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME));

        RemoteTaskInfo thirdAddedTaskInfo = createNewRemoteTaskInfo(3, "task3", 300);

        RemoteTask thirdAddedTask = thirdAddedTaskInfo.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME);

        taskList.addTask(thirdAddedTaskInfo);



        assertThat(taskList.getMostRecentTask()).isEqualTo(thirdAddedTask);

        assertThat(mObserverCallCount).isEqualTo(3);

        assertThat(mMostRecentTask).isEqualTo(thirdAddedTask);

    }



    @Test
@@ -94,12 +114,11 @@ public class RemoteDeviceTaskListTest { 


        taskList.setTasks(initialTasks);



        assertThat(taskList.getMostRecentTask())

            .isEqualTo(expectedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME));

        assertThat(taskList.getMostRecentTask().getId()).isEqualTo(expectedTask.getId());

    }



    @Test

    public void testRemoveTask_removesTask() {

    public void testRemoveTask_removesTaskAndNotifiesListeners() {

        RemoteTaskInfo mostRecentTaskInfo = createNewRemoteTaskInfo(1, "task2", 200);

        RemoteTask mostRecentTask = mostRecentTaskInfo.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME);

        RemoteTaskInfo secondMostRecentTaskInfo = createNewRemoteTaskInfo(2, "task1", 100);
@@ -107,57 +126,75 @@ public class RemoteDeviceTaskListTest { 
            = secondMostRecentTaskInfo.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME);



        taskList.setTasks(Arrays.asList(mostRecentTaskInfo, secondMostRecentTaskInfo));

        assertThat(taskList.getMostRecentTask())

            .isEqualTo(mostRecentTask);

        assertThat(taskList.getMostRecentTask()).isEqualTo(mostRecentTask);

        assertThat(mObserverCallCount).isEqualTo(1);

        assertThat(mMostRecentTask).isEqualTo(mostRecentTask);



        taskList.removeTask(mostRecentTask.getId());

        assertThat(taskList.getMostRecentTask())

            .isEqualTo(secondMostRecentTask);

        assertThat(taskList.getMostRecentTask()).isEqualTo(secondMostRecentTask);

        assertThat(mObserverCallCount).isEqualTo(2);

        assertThat(mMostRecentTask).isEqualTo(secondMostRecentTask);

    }



    @Test

    public void testSetTasks_updatesMostRecentTask() {

    public void testSetTasks_updatesMostRecentTaskAndNotifiesListeners() {



        // Set tasks initially, verify the most recent task is the first one.

        RemoteTaskInfo firstExpectedTask

            = createNewRemoteTaskInfo(1, "task2", 200);

        RemoteTaskInfo firstExpectedTaskInfo = createNewRemoteTaskInfo(1, "task2", 200);

        RemoteTask firstExpectedTask

            = firstExpectedTaskInfo.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME);



        List<RemoteTaskInfo> initialTasks = Arrays.asList(

                createNewRemoteTaskInfo(2, "task1", 100),

                firstExpectedTask,

                firstExpectedTaskInfo,

                createNewRemoteTaskInfo(3, "task3", 150));



        taskList.setTasks(initialTasks);

        assertThat(taskList.getMostRecentTask())

            .isEqualTo(firstExpectedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME));



        assertThat(taskList.getMostRecentTask().getId()).isEqualTo(firstExpectedTask.getId());

        assertThat(mObserverCallCount).isEqualTo(1);

        assertThat(mMostRecentTask.getId()).isEqualTo(firstExpectedTask.getId());



        // Set the tasks to a different list, verify the most recent task is the

        // first one.

        RemoteTaskInfo secondExpectedTask

            = createNewRemoteTaskInfo(4, "task4", 300);

        RemoteTaskInfo secondExpectedTaskInfo = createNewRemoteTaskInfo(4, "task4", 300);

        List<RemoteTaskInfo> secondExpectedTasks = Arrays.asList(

                secondExpectedTask,

                secondExpectedTaskInfo,

                createNewRemoteTaskInfo(7, "task7", 200),

                createNewRemoteTaskInfo(5, "task5", 200),

                createNewRemoteTaskInfo(6, "task6", 100));

        RemoteTask secondExpectedTask =

            secondExpectedTaskInfo.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME);



        taskList.setTasks(secondExpectedTasks);

        assertThat(taskList.getMostRecentTask())

            .isEqualTo(secondExpectedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME));



        assertThat(mObserverCallCount).isEqualTo(2);

        assertThat(mMostRecentTask).isEqualTo(secondExpectedTask);

        assertThat(taskList.getMostRecentTask()).isEqualTo(secondExpectedTask);

    }



    @Test

    public void testSetTasks_overwritesExistingTasks() {

    public void testSetTasks_overwritesExistingTasksAndNotifiesListeners() {

        // Set the initial state of the list.

        RemoteTaskInfo firstExpectedTask = createNewRemoteTaskInfo(1, "task1", 100);

        RemoteTask firstExpectedRemoteTask =

            firstExpectedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME);

        taskList.setTasks(Arrays.asList(firstExpectedTask));

        assertThat(taskList.getMostRecentTask())

            .isEqualTo(firstExpectedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME));

        assertThat(taskList.getMostRecentTask()).isEqualTo(firstExpectedRemoteTask);

        assertThat(mObserverCallCount).isEqualTo(1);

        assertThat(mMostRecentTask).isEqualTo(firstExpectedRemoteTask);



        // Replace the tasks with a different list. The only task in this was used before the

        // previous task.

        RemoteTaskInfo secondExpectedTask = createNewRemoteTaskInfo(2, "task2", 10);

        RemoteTaskInfo secondExpectedTask = createNewRemoteTaskInfo(2, "task2", 200);

        RemoteTask secondExpectedRemoteTask

            = secondExpectedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME);

        taskList.setTasks(Arrays.asList(secondExpectedTask));



        // Because the task list is overwritten, the most recent task should be the second task.

        assertThat(taskList.getMostRecentTask())

            .isEqualTo(secondExpectedTask.toRemoteTask(ASSOCIATION_ID, DEVICE_NAME));

        assertThat(taskList.getMostRecentTask()).isEqualTo(secondExpectedRemoteTask);

        assertThat(mObserverCallCount).isEqualTo(2);

        assertThat(mMostRecentTask).isEqualTo(secondExpectedRemoteTask);

    }



    private RemoteTaskInfo createNewRemoteTaskInfo(
@@ -172,4 +209,9 @@ public class RemoteDeviceTaskListTest { 


        return new RemoteTaskInfo(runningTaskInfo);

    }



    public void onMostRecentTaskChanged(RemoteTask task) {

        mMostRecentTask = task;

        mObserverCallCount++;

    }

}
 
 No newline at end of file

services/tests/servicestests/src/com/android/server/companion/datatransfer/continuity/tasks/RemoteTaskStoreTest.java

+40 −7
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ import static com.android.server.companion.datatransfer.continuity.TaskContinuit 
import android.app.ActivityManager;

import android.companion.AssociationInfo;

import android.companion.datatransfer.continuity.RemoteTask;

import android.companion.datatransfer.continuity.IRemoteTaskListener;

import android.platform.test.annotations.Presubmit;

import android.testing.AndroidTestingRunner;
@@ -42,6 +43,7 @@ import org.mockito.Mock; 
import org.mockito.MockitoAnnotations;



import java.util.Arrays;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;
@@ -52,13 +54,23 @@ public class RemoteTaskStoreTest { 
    @Mock

    private ConnectedAssociationStore mMockConnectedAssociationStore;



    private final IRemoteTaskListener mRemoteTaskListener = new IRemoteTaskListener.Stub() {

        @Override

        public void onRemoteTasksChanged(List<RemoteTask> remoteTasks) {

            remoteTasksReportedToListener.add(remoteTasks);

        }

    };



    private final List<List<RemoteTask>> remoteTasksReportedToListener = new ArrayList<>();

    private RemoteTaskStore taskStore;



    @Before

    public void setUp() {

        MockitoAnnotations.initMocks(this);



        remoteTasksReportedToListener.clear();

        taskStore = new RemoteTaskStore(mMockConnectedAssociationStore);

        taskStore.addListener(mRemoteTaskListener);

    }



    @Test
@@ -68,20 +80,25 @@ public class RemoteTaskStoreTest { 
    }



    @Test

    public void onTransportConnected_addsNewAssociation() {

    public void onTransportConnected_addsNewAssociationAndNotifiesListeners() {

        // Simulate a new association being connected.

        AssociationInfo associationInfo = createAssociationInfo(1, "name");

        taskStore.onTransportConnected(associationInfo);

        assertThat(remoteTasksReportedToListener).hasSize(0);



        // Add tasks to the new association.

        RemoteTaskInfo remoteTaskInfo = createNewRemoteTaskInfo(1, "task1", 100L);

        RemoteTask remoteTask

            = remoteTaskInfo.toRemoteTask(associationInfo.getId(), "name");



        taskStore.setTasks(

            associationInfo.getId(),

            Collections.singletonList(remoteTaskInfo));

        assertThat(remoteTasksReportedToListener).hasSize(1);

        assertThat(remoteTasksReportedToListener.get(0)).containsExactly(remoteTask);



        // Verify the most recent task is added to the task store.

        assertThat(taskStore.getMostRecentTasks())

            .containsExactly(remoteTaskInfo.toRemoteTask(associationInfo.getId(), "name"));

        assertThat(taskStore.getMostRecentTasks()).containsExactly(remoteTask);

    }



    @Test
@@ -96,6 +113,7 @@ public class RemoteTaskStoreTest { 
        taskStore.setTasks(0, Collections.singletonList(remoteTaskInfo));



        assertThat(taskStore.getMostRecentTasks()).isEmpty();

        assertThat(remoteTasksReportedToListener).isEmpty();

    }



    @Test
@@ -117,32 +135,43 @@ public class RemoteTaskStoreTest { 


        assertThat(taskStore.getMostRecentTasks())

            .containsExactly(mostRecentTask);

        assertThat(remoteTasksReportedToListener).hasSize(1);

        assertThat(remoteTasksReportedToListener.get(0)).containsExactly(mostRecentTask);



        taskStore.removeTask(associationInfo.getId(), mostRecentTaskInfo.getId());

        assertThat(taskStore.getMostRecentTasks()).containsExactly(secondMostRecentTask);

        assertThat(remoteTasksReportedToListener).hasSize(2);

        assertThat(remoteTasksReportedToListener.get(1))

            .containsExactly(secondMostRecentTask);

    }



    @Test

    public void onTransportDisconnected_removesAssociation() {

    public void onTransportDisconnected_removesAssociationAndNotifiesListeners() {

        // Create a fake association info, and have connected association store

        // return it.

        AssociationInfo associationInfo = createAssociationInfo(1, "name");

        when(mMockConnectedAssociationStore.getConnectedAssociationById(1))

                .thenReturn(associationInfo);

        taskStore.onTransportConnected(associationInfo);



        // Set tasks for the association.

        RemoteTaskInfo remoteTaskInfo = createNewRemoteTaskInfo(1, "task1", 100L);

        taskStore.setTasks(0, Collections.singletonList(remoteTaskInfo));

        taskStore.setTasks(associationInfo.getId(), Collections.singletonList(remoteTaskInfo));

        assertThat(remoteTasksReportedToListener).hasSize(1);

        assertThat(remoteTasksReportedToListener.get(0))

            .containsExactly(remoteTaskInfo.toRemoteTask(1, "name"));



        // Simulate the association being disconnected.

        taskStore.onTransportDisconnected(0);

        taskStore.onTransportDisconnected(associationInfo.getId());



        // Verify the most recent task is added to the task store.

        assertThat(taskStore.getMostRecentTasks()).isEmpty();

        assertThat(remoteTasksReportedToListener).hasSize(2);

        assertThat(remoteTasksReportedToListener.get(1)).isEmpty();

    }



    @Test

    public void addTask_addsTaskToAssociation() {

    public void addTask_addsTaskToAssociationAndNotifiesListeners() {

        // Create a fake association info, and have connected association store return it.

        AssociationInfo associationInfo = createAssociationInfo(1, "name");

        when(mMockConnectedAssociationStore.getConnectedAssociationById(1))
@@ -153,6 +182,8 @@ public class RemoteTaskStoreTest { 
        RemoteTask remoteTask = remoteTaskInfo.toRemoteTask(associationInfo.getId(), "name");

        taskStore.setTasks(1, Collections.singletonList(remoteTaskInfo));

        assertThat(taskStore.getMostRecentTasks()).containsExactly(remoteTask);

        assertThat(remoteTasksReportedToListener).hasSize(1);

        assertThat(remoteTasksReportedToListener.get(0)).containsExactly(remoteTask);



        // Add a new task to the association.

        RemoteTaskInfo newRemoteTaskInfo = createNewRemoteTaskInfo(2, "task2", 200L);
@@ -161,6 +192,8 @@ public class RemoteTaskStoreTest { 


        // Verify the most recent tasks are added to the task store.

        assertThat(taskStore.getMostRecentTasks()).containsExactly(newRemoteTask);

        assertThat(remoteTasksReportedToListener).hasSize(2);

        assertThat(remoteTasksReportedToListener.get(1)).containsExactly(newRemoteTask);

    }



    @Test