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

Commit 23876b63 authored by Treehugger Robot's avatar Treehugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topic "registered_services_cache_ injection" into main 

* changes:
  Add unit tests for RegisteredServicesCache.
  According to the user Id to cache the ServiceInfo.
parents e0768748 eb553bfd

core/java/android/content/pm/RegisteredServicesCache.java

+21 −15
Original line number Diff line number Diff line
@@ -31,13 +31,13 @@ import android.os.Environment; 
import android.os.Handler;

import android.os.UserHandle;

import android.os.UserManager;

import android.util.ArrayMap;

import android.util.AtomicFile;

import android.util.AttributeSet;

import android.util.IntArray;

import android.util.Log;

import android.util.Slog;

import android.util.SparseArray;

import android.util.SparseArrayMap;

import android.util.Xml;



import com.android.internal.annotations.GuardedBy;
@@ -98,15 +98,16 @@ public abstract class RegisteredServicesCache<V> { 
    @GuardedBy("mServicesLock")

    private final SparseArray<UserServices<V>> mUserServices = new SparseArray<UserServices<V>>(2);



    @GuardedBy("mServiceInfoCaches")

    private final ArrayMap<ComponentName, ServiceInfo<V>> mServiceInfoCaches = new ArrayMap<>();

    @GuardedBy("mUserIdToServiceInfoCaches")

    private final SparseArrayMap<ComponentName, ServiceInfo<V>> mUserIdToServiceInfoCaches =

            new SparseArrayMap<>();



    private final Handler mBackgroundHandler;



    private final Runnable mClearServiceInfoCachesRunnable = new Runnable() {

        public void run() {

            synchronized (mServiceInfoCaches) {

                mServiceInfoCaches.clear();

            synchronized (mUserIdToServiceInfoCaches) {

                mUserIdToServiceInfoCaches.clear();

            }

        }

    };
@@ -537,8 +538,8 @@ public abstract class RegisteredServicesCache<V> { 
                    Slog.d(TAG, "Fail to get the PackageInfo in generateServicesMap: " + e);

                }

                if (lastUpdateTime >= 0) {

                    ServiceInfo<V> serviceInfo = getServiceInfoFromServiceCache(componentName,

                            lastUpdateTime);

                    ServiceInfo<V> serviceInfo = getServiceInfoFromServiceCache(userId,

                            componentName, lastUpdateTime);

                    if (serviceInfo != null) {

                        serviceInfos.add(serviceInfo);

                        continue;
@@ -553,8 +554,8 @@ public abstract class RegisteredServicesCache<V> { 
                }

                serviceInfos.add(info);

                if (Flags.optimizeParsingInRegisteredServicesCache()) {

                    synchronized (mServiceInfoCaches) {

                        mServiceInfoCaches.put(componentName, info);

                    synchronized (mUserIdToServiceInfoCaches) {

                        mUserIdToServiceInfoCaches.add(userId, componentName, info);

                    }

                }

            } catch (XmlPullParserException | IOException e) {
@@ -563,8 +564,8 @@ public abstract class RegisteredServicesCache<V> { 
        }



        if (Flags.optimizeParsingInRegisteredServicesCache()) {

            synchronized (mServiceInfoCaches) {

                if (!mServiceInfoCaches.isEmpty()) {

            synchronized (mUserIdToServiceInfoCaches) {

                if (mUserIdToServiceInfoCaches.numMaps() > 0) {

                    mBackgroundHandler.removeCallbacks(mClearServiceInfoCachesRunnable);

                    mBackgroundHandler.postDelayed(mClearServiceInfoCachesRunnable,

                            SERVICE_INFO_CACHES_TIMEOUT_MILLIS);
@@ -873,6 +874,11 @@ public abstract class RegisteredServicesCache<V> { 
        synchronized (mServicesLock) {

            mUserServices.remove(userId);

        }

        if (Flags.optimizeParsingInRegisteredServicesCache()) {

            synchronized (mUserIdToServiceInfoCaches) {

                mUserIdToServiceInfoCaches.delete(userId);

            }

        }

    }



    @VisibleForTesting
@@ -916,10 +922,10 @@ public abstract class RegisteredServicesCache<V> { 
        mContext.unregisterReceiver(mUserRemovedReceiver);

    }



    private ServiceInfo<V> getServiceInfoFromServiceCache(@NonNull ComponentName componentName,

            long lastUpdateTime) {

        synchronized (mServiceInfoCaches) {

            ServiceInfo<V> serviceCache = mServiceInfoCaches.get(componentName);

    private ServiceInfo<V> getServiceInfoFromServiceCache(int userId,

            @NonNull ComponentName componentName, long lastUpdateTime) {

        synchronized (mUserIdToServiceInfoCaches) {

            ServiceInfo<V> serviceCache = mUserIdToServiceInfoCaches.get(userId, componentName);

            if (serviceCache != null && serviceCache.lastUpdateTime == lastUpdateTime) {

                return serviceCache;

            }

core/tests/coretests/src/android/content/pm/RegisteredServicesCacheTest.java

+3 −9
Original line number Diff line number Diff line
@@ -233,7 +233,7 @@ public class RegisteredServicesCacheTest extends AndroidTestCase { 
    /**

     * Mock implementation of {@link android.content.pm.RegisteredServicesCache} for testing

     */

    private class TestServicesCache extends RegisteredServicesCache<TestServiceType> {

    public class TestServicesCache extends RegisteredServicesCache<TestServiceType> {

        static final String SERVICE_INTERFACE = "RegisteredServicesCacheTest";

        static final String SERVICE_META_DATA = "RegisteredServicesCacheTest";

        static final String ATTRIBUTES_NAME = "test";
@@ -245,12 +245,6 @@ public class RegisteredServicesCacheTest extends AndroidTestCase { 
                    SERVICE_INTERFACE, SERVICE_META_DATA, ATTRIBUTES_NAME, new TestSerializer());

        }



        TestServicesCache(Injector<TestServiceType> injector,

                XmlSerializerAndParser<TestServiceType> serializerAndParser) {

            super(injector, SERVICE_INTERFACE, SERVICE_META_DATA, ATTRIBUTES_NAME,

                    serializerAndParser);

        }



        @Override

        public TestServiceType parseServiceAttributes(Resources res, String packageName,

                AttributeSet attrs) {
@@ -338,7 +332,7 @@ public class RegisteredServicesCacheTest extends AndroidTestCase { 
        }

    }



    static class TestSerializer implements XmlSerializerAndParser<TestServiceType> {

    public static class TestSerializer implements XmlSerializerAndParser<TestServiceType> {



        public void writeAsXml(TestServiceType item, TypedXmlSerializer out) throws IOException {

            out.attribute(null, "type", item.type);
@@ -353,7 +347,7 @@ public class RegisteredServicesCacheTest extends AndroidTestCase { 
        }

    }



    static class TestServiceType implements Parcelable {

    public static class TestServiceType implements Parcelable {

        final String type;

        final String value;

core/tests/coretests/src/android/content/pm/RegisteredServicesCacheUnitTest.java

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

 * Copyright (C) 2025 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.content.pm;



import static android.content.pm.Flags.FLAG_OPTIMIZE_PARSING_IN_REGISTERED_SERVICES_CACHE;



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



import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyLong;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.doThrow;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.reset;

import static org.mockito.Mockito.spy;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.content.ComponentName;

import android.content.Context;

import android.content.Intent;

import android.content.pm.RegisteredServicesCacheTest.TestServiceType;

import android.content.res.Resources;

import android.os.Handler;

import android.os.Message;

import android.os.UserHandle;

import android.platform.test.annotations.Presubmit;

import android.platform.test.annotations.RequiresFlagsEnabled;

import android.platform.test.flag.junit.CheckFlagsRule;

import android.platform.test.flag.junit.DeviceFlagsValueProvider;

import android.util.AttributeSet;

import android.util.SparseArray;



import androidx.test.ext.junit.runners.AndroidJUnit4;



import com.android.internal.os.BackgroundThread;



import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.xmlpull.v1.XmlPullParserException;



import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;



/**

 * Unit tests for {@link android.content.pm.RegisteredServicesCache}

 */

@Presubmit

@RunWith(AndroidJUnit4.class)

@RequiresFlagsEnabled(FLAG_OPTIMIZE_PARSING_IN_REGISTERED_SERVICES_CACHE)

public class RegisteredServicesCacheUnitTest {

    private static final String TAG = "RegisteredServicesCacheUnitTest";

    private static final int U0 = 0;

    private static final int U1 = 1;

    private static final int UID1 = 1;



    @Rule

    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();



    private final ResolveInfo mResolveInfo1 = new ResolveInfo();

    private final ResolveInfo mResolveInfo2 = new ResolveInfo();

    private final TestServiceType mTestServiceType1 = new TestServiceType("t1", "value1");

    private final TestServiceType mTestServiceType2 = new TestServiceType("t2", "value2");

    @Mock

    RegisteredServicesCache.Injector<TestServiceType> mMockInjector;

    @Mock

    Context mMockContext;

    Handler mMockBackgroundHandler;

    @Mock

    PackageManager mMockPackageManager;



    @Before

    public void setup() throws Exception {

        MockitoAnnotations.initMocks(this);



        when(mMockInjector.getContext()).thenReturn(mMockContext);

        mMockBackgroundHandler = spy(BackgroundThread.getHandler());

        when(mMockInjector.getBackgroundHandler()).thenReturn(mMockBackgroundHandler);

        doReturn(mock(Intent.class)).when(mMockContext).registerReceiverAsUser(any(), any(), any(),

                any(), any());

        doReturn(mock(Intent.class)).when(mMockContext).registerReceiver(any(), any(), any(),

                any());

        when(mMockContext.getPackageManager()).thenReturn(mMockPackageManager);



        addServiceInfoIntoResolveInfo(mResolveInfo1, "r1.package.name" /* packageName */,

                "r1.service.name" /* serviceName */);

        addServiceInfoIntoResolveInfo(mResolveInfo2, "r2.package.name" /* packageName */,

                "r2.service.name" /* serviceName */);

    }



    @Test

    public void testSaveServiceInfoIntoCaches() throws Exception {

        PackageInfo packageInfo1 = createPackageInfo(1000L /* lastUpdateTime */);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo1.serviceInfo.packageName),

                anyInt(), eq(U0))).thenReturn(packageInfo1);

        PackageInfo packageInfo2 = createPackageInfo(2000L /* lastUpdateTime */);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo2.serviceInfo.packageName),

                anyInt(), eq(U1))).thenReturn(packageInfo2);



        TestRegisteredServicesCache testServicesCache = spy(

                new TestRegisteredServicesCache(mMockInjector, null /* serializerAndParser */));

        final RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo1 = newServiceInfo(

                mTestServiceType1, UID1, mResolveInfo1.serviceInfo.getComponentName(),

                1000L /* lastUpdateTime */);

        testServicesCache.addServiceForQuerying(U0, mResolveInfo1, serviceInfo1);



        int u1uid = UserHandle.getUid(U1, UID1);

        final RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo2 = newServiceInfo(

                mTestServiceType2, u1uid, mResolveInfo2.serviceInfo.getComponentName(),

                2000L /* lastUpdateTime */);

        testServicesCache.addServiceForQuerying(U1, mResolveInfo2, serviceInfo2);



        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));

        testServicesCache.getAllServices(U1);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo2), eq(2000L));



        reset(testServicesCache);



        testServicesCache.invalidateCache(U0);

        testServicesCache.invalidateCache(U1);

        testServicesCache.getAllServices(U0);

        verify(testServicesCache, never()).parseServiceInfo(eq(mResolveInfo1), eq(1000L));

        testServicesCache.getAllServices(U1);

        verify(testServicesCache, never()).parseServiceInfo(eq(mResolveInfo2), eq(2000L));

    }



    @Test

    public void testClearServiceInfoCachesAfterRemoveUserId() throws Exception {

        PackageInfo packageInfo1 = createPackageInfo(1000L /* lastUpdateTime */);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo1.serviceInfo.packageName),

                anyInt(), eq(U0))).thenReturn(packageInfo1);



        TestRegisteredServicesCache testServicesCache = spy(

                new TestRegisteredServicesCache(mMockInjector, null /* serializerAndParser */));

        final RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo1 = newServiceInfo(

                mTestServiceType1, UID1, mResolveInfo1.serviceInfo.getComponentName(),

                1000L /* lastUpdateTime */);

        testServicesCache.addServiceForQuerying(U0, mResolveInfo1, serviceInfo1);



        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));



        reset(testServicesCache);



        testServicesCache.onUserRemoved(U0);

        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));

    }



    @Test

    public void testGetServiceInfoCachesForMultiUser() throws Exception {

        PackageInfo packageInfo1 = createPackageInfo(1000L /* lastUpdateTime */);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo1.serviceInfo.packageName),

                anyInt(), eq(U0))).thenReturn(packageInfo1);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo1.serviceInfo.packageName),

                anyInt(), eq(U1))).thenReturn(packageInfo1);



        TestRegisteredServicesCache testServicesCache = spy(

                new TestRegisteredServicesCache(mMockInjector, null /* serializerAndParser */));

        final RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo1 = newServiceInfo(

                mTestServiceType1, UID1, mResolveInfo1.serviceInfo.getComponentName(),

                1000L /* lastUpdateTime */);

        testServicesCache.addServiceForQuerying(U0, mResolveInfo1, serviceInfo1);



        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));



        reset(testServicesCache);



        testServicesCache.clearServicesForQuerying();

        int u1uid = UserHandle.getUid(U1, UID1);

        assertThat(u1uid).isNotEqualTo(UID1);



        final RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo2 = newServiceInfo(

                mTestServiceType1, u1uid, mResolveInfo1.serviceInfo.getComponentName(),

                1000L /* lastUpdateTime */);

        testServicesCache.addServiceForQuerying(U1, mResolveInfo1, serviceInfo2);



        testServicesCache.getAllServices(U1);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));



        reset(testServicesCache);



        testServicesCache.invalidateCache(U0);

        testServicesCache.invalidateCache(U1);



        // There is a bug to return the same info from the cache for different users. Make sure it

        // will return the different info from the cache for different users.

        Collection<RegisteredServicesCache.ServiceInfo<TestServiceType>> serviceInfos;

        serviceInfos = testServicesCache.getAllServices(U0);

        // Make sure the service info is retrieved from the cache for U0.

        verify(testServicesCache, never()).parseServiceInfo(eq(mResolveInfo1), eq(1000L));

        for (RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo : serviceInfos) {

            assertThat(serviceInfo.componentInfo.applicationInfo.uid).isEqualTo(UID1);

        }



        serviceInfos = testServicesCache.getAllServices(U1);

        // Make sure the service info is retrieved from the cache for U1.

        verify(testServicesCache, never()).parseServiceInfo(eq(mResolveInfo2), eq(2000L));

        for (RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo : serviceInfos) {

            assertThat(serviceInfo.componentInfo.applicationInfo.uid).isEqualTo(u1uid);

        }

    }



    @Test

    public void testUpdateServiceInfoIntoCachesWhenPackageInfoNotFound() throws Exception {

        PackageInfo packageInfo1 = createPackageInfo(1000L /* lastUpdateTime */);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo1.serviceInfo.packageName),

                anyInt(), eq(U0))).thenReturn(packageInfo1);



        TestRegisteredServicesCache testServicesCache = spy(

                new TestRegisteredServicesCache(mMockInjector, null /* serializerAndParser */));

        final RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo1 = newServiceInfo(

                mTestServiceType1, UID1, mResolveInfo1.serviceInfo.getComponentName(),

                1000L /* lastUpdateTime */);

        testServicesCache.addServiceForQuerying(U0, mResolveInfo1, serviceInfo1);



        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));



        reset(testServicesCache);

        reset(mMockPackageManager);



        doThrow(new SecurityException("")).when(mMockPackageManager).getPackageInfoAsUser(

                eq(mResolveInfo1.serviceInfo.packageName), anyInt(), eq(U0));



        testServicesCache.invalidateCache(U0);

        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), anyLong());

    }



    @Test

    public void testUpdateServiceInfoIntoCachesWhenTheApplicationHasBeenUpdated() throws Exception {

        PackageInfo packageInfo1 = createPackageInfo(1000L /* lastUpdateTime */);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo1.serviceInfo.packageName),

                anyInt(), eq(U0))).thenReturn(packageInfo1);



        TestRegisteredServicesCache testServicesCache = spy(

                new TestRegisteredServicesCache(mMockInjector, null /* serializerAndParser */));

        final RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo1 = newServiceInfo(

                mTestServiceType1, UID1, mResolveInfo1.serviceInfo.getComponentName(),

                1000L /* lastUpdateTime */);

        testServicesCache.addServiceForQuerying(U0, mResolveInfo1, serviceInfo1);



        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));



        reset(testServicesCache);

        reset(mMockPackageManager);



        PackageInfo packageInfo2 = createPackageInfo(2000L /* lastUpdateTime */);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo1.serviceInfo.packageName),

                anyInt(), eq(U0))).thenReturn(packageInfo2);



        testServicesCache.invalidateCache(U0);

        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(2000L));

    }



    @Test

    public void testClearServiceInfoCachesAfterTimeout() throws Exception {

        PackageInfo packageInfo1 = createPackageInfo(1000L /* lastUpdateTime */);

        when(mMockPackageManager.getPackageInfoAsUser(eq(mResolveInfo1.serviceInfo.packageName),

                anyInt(), eq(U0))).thenReturn(packageInfo1);



        TestRegisteredServicesCache testServicesCache = spy(

                new TestRegisteredServicesCache(mMockInjector, null /* serializerAndParser */));

        final RegisteredServicesCache.ServiceInfo<TestServiceType> serviceInfo1 = newServiceInfo(

                mTestServiceType1, UID1, mResolveInfo1.serviceInfo.getComponentName(),

                1000L /* lastUpdateTime */);

        testServicesCache.addServiceForQuerying(U0, mResolveInfo1, serviceInfo1);



        // Immediately invoke run on the Runnable posted to the handler

        doAnswer(invocation -> {

            Message message = invocation.getArgument(0);

            message.getCallback().run();

            return true;

        }).when(mMockBackgroundHandler).sendMessageAtTime(any(Message.class), anyLong());



        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));

        verify(mMockBackgroundHandler, times(1)).sendMessageAtTime(any(Message.class), anyLong());



        reset(testServicesCache);



        testServicesCache.invalidateCache(U0);

        testServicesCache.getAllServices(U0);

        verify(testServicesCache, times(1)).parseServiceInfo(eq(mResolveInfo1), eq(1000L));

    }



    private static RegisteredServicesCache.ServiceInfo<TestServiceType> newServiceInfo(

            TestServiceType type, int uid, ComponentName componentName, long lastUpdateTime) {

        final ComponentInfo info = new ComponentInfo();

        info.applicationInfo = new ApplicationInfo();

        info.applicationInfo.uid = uid;

        return new RegisteredServicesCache.ServiceInfo<>(type, info, componentName, lastUpdateTime);

    }



    private void addServiceInfoIntoResolveInfo(ResolveInfo resolveInfo, String packageName,

            String serviceName) {

        final ServiceInfo serviceInfo = new ServiceInfo();

        serviceInfo.packageName = packageName;

        serviceInfo.name = serviceName;

        resolveInfo.serviceInfo = serviceInfo;

    }



    private PackageInfo createPackageInfo(long lastUpdateTime) {

        PackageInfo packageInfo = new PackageInfo();

        packageInfo.lastUpdateTime = lastUpdateTime;

        return packageInfo;

    }



    /**

     * Mock implementation of {@link android.content.pm.RegisteredServicesCache} for testing

     */

    public class TestRegisteredServicesCache extends RegisteredServicesCache<TestServiceType> {

        static final String SERVICE_INTERFACE = "RegisteredServicesCacheUnitTest";

        static final String SERVICE_META_DATA = "RegisteredServicesCacheUnitTest";

        static final String ATTRIBUTES_NAME = "test";

        private SparseArray<Map<ResolveInfo, ServiceInfo<TestServiceType>>> mServices =

                new SparseArray<>();



        public TestRegisteredServicesCache(Injector<TestServiceType> injector,

                XmlSerializerAndParser<TestServiceType> serializerAndParser) {

            super(injector, SERVICE_INTERFACE, SERVICE_META_DATA, ATTRIBUTES_NAME,

                    serializerAndParser);

        }



        @Override

        public TestServiceType parseServiceAttributes(Resources res, String packageName,

                AttributeSet attrs) {

            return null;

        }



        @Override

        protected List<ResolveInfo> queryIntentServices(int userId) {

            Map<ResolveInfo, ServiceInfo<TestServiceType>> map = mServices.get(userId,

                    new HashMap<ResolveInfo, ServiceInfo<TestServiceType>>());

            return new ArrayList<>(map.keySet());

        }



        void addServiceForQuerying(int userId, ResolveInfo resolveInfo,

                ServiceInfo<TestServiceType> serviceInfo) {

            Map<ResolveInfo, ServiceInfo<TestServiceType>> map = mServices.get(userId);

            if (map == null) {

                map = new HashMap<>();

                mServices.put(userId, map);

            }

            map.put(resolveInfo, serviceInfo);

        }



        void clearServicesForQuerying() {

            mServices.clear();

        }



        @Override

        protected ServiceInfo<TestServiceType> parseServiceInfo(ResolveInfo resolveInfo,

                long lastUpdateTime) throws XmlPullParserException, IOException {

            int size = mServices.size();

            for (int i = 0; i < size; i++) {

                Map<ResolveInfo, ServiceInfo<TestServiceType>> map = mServices.valueAt(i);

                ServiceInfo<TestServiceType> serviceInfo = map.get(resolveInfo);

                if (serviceInfo != null) {

                    return serviceInfo;

                }

            }

            throw new IllegalArgumentException("Unexpected service " + resolveInfo);

        }



        @Override

        public void onUserRemoved(int userId) {

            super.onUserRemoved(userId);

        }

    }

}