xref: /frameworks/base/core/tests/coretests/src/android/widget/RemoteViewsAdapterTest.java

/*
 * Copyright (C) 2017 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 android.widget;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import android.app.IServiceConnection;
import android.appwidget.AppWidgetManager;
import android.content.Context;
import android.content.ContextWrapper;
import android.content.Intent;
import android.content.ServiceConnection;
import android.database.DataSetObserver;
import android.os.Handler;
import android.os.Looper;
import android.os.RemoteException;
import android.support.test.InstrumentationRegistry;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
import android.view.View;

import com.android.frameworks.coretests.R;
import com.android.internal.widget.IRemoteViewsFactory;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.ArrayList;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

/**
 * Tests for RemoteViewsAdapter.
 */
@RunWith(AndroidJUnit4.class)
@SmallTest
public class RemoteViewsAdapterTest {

    @Mock AppWidgetManager mAppWidgetManager;
    @Mock IServiceConnection mIServiceConnection;
    @Mock RemoteViewsAdapter.RemoteAdapterConnectionCallback mCallback;

    private Handler mMainHandler;
    private TestContext mContext;

    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);
        when(mAppWidgetManager
                .bindRemoteViewsService(any(), anyInt(), any(), any(), anyInt())).thenReturn(true);
        mContext = new TestContext();
        mMainHandler = new Handler(Looper.getMainLooper());
    }

    @Test
    public void onRemoteAdapterConnected_after_metadata_loaded() throws Throwable {
        RemoteViewsAdapter adapter = getOnUiThread(
                () -> new RemoteViewsAdapter(mContext, new DistinctIntent(), mCallback, false));
        assertFalse(adapter.isDataReady());

        assertNotNull(mContext.conn.get());

        ViewsFactory factory = new ViewsFactory(1);
        mContext.sendConnect(factory);

        waitOnHandler(mMainHandler);
        verify(mCallback, never()).onRemoteAdapterConnected();

        factory.loadingView.set(createViews("loading"));
        waitOnHandler(mContext.handler.get());
        waitOnHandler(mMainHandler);
        verify(mCallback, times(1)).onRemoteAdapterConnected();

        assertEquals((Integer) 1, getOnUiThread(adapter::getCount));

        // Service is unbound
        assertTrue(isUnboundOrScheduled());
    }

    @Test
    public void viewReplaced_after_mainView_loaded() throws Throwable {
        RemoteViewsAdapter adapter = getOnUiThread(
                () -> new RemoteViewsAdapter(mContext, new DistinctIntent(), mCallback, false));

        ViewsFactory factory = new ViewsFactory(1);
        factory.loadingView.set(createViews("loading"));
        mContext.sendConnect(factory);

        waitOnHandler(mContext.handler.get());
        waitOnHandler(mMainHandler);

        // Returned view contains the loading text
        View view = getOnUiThread(() -> adapter.getView(0, null, new FrameLayout(mContext)));
        ArrayList<View> search = new ArrayList<>();
        view.findViewsWithText(search, "loading", View.FIND_VIEWS_WITH_TEXT);
        assertEquals(1, search.size());

        // Send the final remoteViews
        factory.views[0].set(createViews("updated"));
        waitOnHandler(mContext.handler.get());
        waitOnHandler(mMainHandler);

        // Existing view got updated with new text
        search.clear();
        view.findViewsWithText(search, "loading", View.FIND_VIEWS_WITH_TEXT);
        assertTrue(search.isEmpty());
        view.findViewsWithText(search, "updated", View.FIND_VIEWS_WITH_TEXT);
        assertEquals(1, search.size());

        // Service is unbound
        assertTrue(isUnboundOrScheduled());
    }

    @Test
    public void notifyDataSetChanged_deferred() throws Throwable {
        RemoteViewsAdapter adapter = getOnUiThread(
                () -> new RemoteViewsAdapter(mContext, new DistinctIntent(), mCallback, false));

        ViewsFactory factory = new ViewsFactory(1);
        factory.loadingView.set(createViews("loading"));
        mContext.sendConnect(factory);

        waitOnHandler(mContext.handler.get());
        waitOnHandler(mMainHandler);
        assertEquals((Integer) 1, getOnUiThread(adapter::getCount));

        // Reset the loading view so that next refresh is blocked
        factory.loadingView = new LockedValue<>();
        factory.mCount = 3;
        DataSetObserver observer = mock(DataSetObserver.class);
        getOnUiThread(() -> {
            adapter.registerDataSetObserver(observer);
            adapter.notifyDataSetChanged();
            return null;
        });

        waitOnHandler(mMainHandler);
        // Still giving the old values
        verify(observer, never()).onChanged();
        assertEquals((Integer) 1, getOnUiThread(adapter::getCount));

        factory.loadingView.set(createViews("refreshed"));
        waitOnHandler(mContext.handler.get());
        waitOnHandler(mMainHandler);

        // When the service returns new data, UI is updated.
        verify(observer, times(1)).onChanged();
        assertEquals((Integer) 3, getOnUiThread(adapter::getCount));

        // Service is unbound
        assertTrue(isUnboundOrScheduled());
    }

    @Test
    public void serviceDisconnected_before_getView() throws Throwable {
        RemoteViewsAdapter adapter = getOnUiThread(
                () -> new RemoteViewsAdapter(mContext, new DistinctIntent(), mCallback, false));

        ViewsFactory factory = new ViewsFactory(1);
        factory.loadingView.set(createViews("loading"));
        mContext.sendConnect(factory);

        waitOnHandler(mContext.handler.get());
        waitOnHandler(mMainHandler);
        verify(mCallback, times(1)).onRemoteAdapterConnected();
        assertEquals((Integer) 1, getOnUiThread(adapter::getCount));

        // Unbind the service
        ServiceConnection conn = mContext.conn.get();
        getOnHandler(mContext.handler.get(), () -> {
            conn.onServiceDisconnected(null);
            return null;
        });

        // Returned view contains the loading text
        View view = getOnUiThread(() -> adapter.getView(0, null, new FrameLayout(mContext)));
        ArrayList<View> search = new ArrayList<>();
        view.findViewsWithText(search, "loading", View.FIND_VIEWS_WITH_TEXT);
        assertEquals(1, search.size());

        // Unbind is not scheduled
        assertFalse(isUnboundOrScheduled());

        mContext.sendConnect(factory);
        waitOnHandler(mContext.handler.get());
        waitOnHandler(mMainHandler);
        verify(mCallback, times(2)).onRemoteAdapterConnected();
    }

    private RemoteViews createViews(String text) {
        RemoteViews views = new RemoteViews(mContext.getPackageName(), R.layout.remote_views_text);
        views.setTextViewText(R.id.text, text);
        return views;
    }

    private <T> T getOnUiThread(Supplier<T> supplier) throws Throwable {
        return getOnHandler(mMainHandler, supplier);
    }

    private boolean isUnboundOrScheduled() throws Throwable {
        Handler handler = mContext.handler.get();
        return getOnHandler(handler, () -> mContext.boundCount == 0
                || handler.hasMessages(RemoteViewsAdapter.MSG_UNBIND_SERVICE));
    }

    private static <T> T getOnHandler(Handler handler, Supplier<T> supplier) throws Throwable {
        LockedValue<T> result = new LockedValue<>();
        handler.post(() -> result.set(supplier.get()));
        return result.get();
    }

    private class TestContext extends ContextWrapper {

        public final LockedValue<ServiceConnection> conn = new LockedValue<>();
        public final LockedValue<Handler> handler = new LockedValue<>();
        public int boundCount;

        TestContext() {
            super(InstrumentationRegistry.getContext());
        }

        @Override
        public void unbindService(ServiceConnection conn) {
            boundCount--;
        }

        @Override
        public Object getSystemService(String name) {
            if (Context.APPWIDGET_SERVICE.equals(name)) {
                return mAppWidgetManager;
            }
            return super.getSystemService(name);
        }

        @Override
        public IServiceConnection getServiceDispatcher(
                ServiceConnection conn, Handler handler, int flags) {
            this.conn.set(conn);
            this.handler.set(handler);
            boundCount++;
            return mIServiceConnection;
        }

        @Override
        public Context getApplicationContext() {
            return this;
        }

        public void sendConnect(ViewsFactory factory) throws Exception {
            ServiceConnection connection = conn.get();
            handler.get().post(() -> connection.onServiceConnected(null, factory.asBinder()));
        }
    }

    private static void waitOnHandler(Handler handler) throws Exception {
        CountDownLatch latch = new CountDownLatch(1);
        handler.post(() -> latch.countDown());
        latch.await(20, TimeUnit.SECONDS);
    }

    private static class ViewsFactory extends IRemoteViewsFactory.Stub {

        public LockedValue<RemoteViews> loadingView = new LockedValue<>();
        public LockedValue<RemoteViews>[] views;

        private int mCount;

        ViewsFactory(int count) {
            mCount = count;
            views = new LockedValue[count];
            for (int i = 0; i < count; i++) {
                views[i] = new LockedValue<>();
            }
        }

        @Override
        public void onDataSetChanged() {}

        @Override
        public void onDataSetChangedAsync() { }

        @Override
        public void onDestroy(Intent intent) { }

        @Override
        public int getCount() throws RemoteException {
            return mCount;
        }

        @Override
        public RemoteViews getViewAt(int position) throws RemoteException {
            try {
                return views[position].get();
            } catch (Exception e) {
                throw new RemoteException(e.getMessage());
            }
        }

        @Override
        public RemoteViews getLoadingView() throws RemoteException {
            try {
                return loadingView.get();
            } catch (Exception e) {
                throw new RemoteException(e.getMessage());
            }
        }

        @Override
        public int getViewTypeCount() {
            return 1;
        }

        @Override
        public long getItemId(int position) {
            return position;
        }

        @Override
        public boolean hasStableIds() {
            return false;
        }

        @Override
        public boolean isCreated() {
            return false;
        }
    }

    private static class DistinctIntent extends Intent {

        @Override
        public boolean filterEquals(Intent other) {
            return false;
        }
    }

    private static class LockedValue<T> {

        private final CountDownLatch mLatch = new CountDownLatch(1);
        private T mValue;

        public void set(T value) {
            mValue = value;
            mLatch.countDown();
        }

        public T get() throws Exception {
            mLatch.await(10, TimeUnit.SECONDS);
            return mValue;
        }
    }
}