| /* |
| * Copyright (C) 2015 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.messaging; |
| |
| import android.content.ContentProvider; |
| import android.content.Context; |
| import android.net.Uri; |
| import android.provider.Settings; |
| import android.telephony.SubscriptionInfo; |
| import android.telephony.SubscriptionManager; |
| |
| import com.android.messaging.datamodel.DataModel; |
| import com.android.messaging.datamodel.MemoryCacheManager; |
| import com.android.messaging.datamodel.ParticipantRefresh.ContactContentObserver; |
| import com.android.messaging.datamodel.media.MediaCacheManager; |
| import com.android.messaging.datamodel.media.MediaResourceManager; |
| import com.android.messaging.sms.ApnDatabase; |
| import com.android.messaging.sms.BugleCarrierConfigValuesLoader; |
| import com.android.messaging.ui.UIIntents; |
| import com.android.messaging.util.Assert; |
| import com.android.messaging.util.BugleGservices; |
| import com.android.messaging.util.BuglePrefs; |
| import com.android.messaging.util.FakeBugleGservices; |
| import com.android.messaging.util.FakeBuglePrefs; |
| import com.android.messaging.util.MediaUtil; |
| import com.android.messaging.util.OsUtil; |
| import com.android.messaging.util.PhoneUtils; |
| |
| import org.mockito.Matchers; |
| import org.mockito.Mock; |
| import org.mockito.Mockito; |
| import org.mockito.invocation.InvocationOnMock; |
| import org.mockito.stubbing.Answer; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| public class FakeFactory extends Factory { |
| private Context mContext; |
| private FakeContext mFakeContext; |
| private BugleGservices mBugleGservices; |
| private BuglePrefs mBuglePrefs; |
| private DataModel mDataModel; |
| private UIIntents mUIIntents; |
| private MemoryCacheManager mMemoryCacheManager; |
| private MediaResourceManager mMediaResourceManager; |
| private MediaCacheManager mMediaCacheManager; |
| @Mock protected PhoneUtils mPhoneUtils; |
| private MediaUtil mMediaUtil; |
| private BugleCarrierConfigValuesLoader mCarrierConfigValuesLoader; |
| |
| private FakeFactory() { |
| } |
| |
| public static FakeFactory registerWithFakeContext(final Context context, |
| final FakeContext fake) { |
| // In tests we currently NEVER run the application/factory initialization |
| Assert.isTrue(!sRegistered); |
| Assert.isTrue(!sInitialized); |
| |
| final FakeFactory factory = new FakeFactory(); |
| Factory.setInstance(factory); |
| |
| // At this point Factory is published. Services can now get initialized and depend on |
| // Factory.get(). |
| factory.mContext = context; |
| factory.mFakeContext = fake; |
| factory.mMediaResourceManager = Mockito.mock(MediaResourceManager.class); |
| factory.mBugleGservices = new FakeBugleGservices(); |
| factory.mBuglePrefs = new FakeBuglePrefs(); |
| factory.mPhoneUtils = Mockito.mock(PhoneUtils.class); |
| |
| ApnDatabase.initializeAppContext(context); |
| |
| Mockito.when(factory.mPhoneUtils.getCanonicalBySystemLocale(Matchers.anyString())) |
| .thenAnswer(new Answer<String>() { |
| @Override |
| public String answer(final InvocationOnMock invocation) throws Throwable { |
| final Object[] args = invocation.getArguments(); |
| return (String) args[0]; |
| } |
| } |
| ); |
| Mockito.when(factory.mPhoneUtils.getCanonicalBySimLocale(Matchers.anyString())).thenAnswer( |
| new Answer<String>() { |
| @Override |
| public String answer(final InvocationOnMock invocation) throws Throwable { |
| final Object[] args = invocation.getArguments(); |
| return (String) args[0]; |
| } |
| } |
| ); |
| Mockito.when(factory.mPhoneUtils.formatForDisplay(Matchers.anyString())).thenAnswer( |
| new Answer<String>() { |
| @Override |
| public String answer(final InvocationOnMock invocation) throws Throwable { |
| return (String) invocation.getArguments()[0]; |
| } |
| } |
| ); |
| if (OsUtil.isAtLeastL_MR1()) { |
| Mockito.when(factory.mPhoneUtils.toLMr1()).thenReturn( |
| new PhoneUtils.LMr1() { |
| @Override |
| public SubscriptionInfo getActiveSubscriptionInfo() { |
| return null; |
| } |
| |
| @Override |
| public List<SubscriptionInfo> getActiveSubscriptionInfoList() { |
| // Return empty list |
| return new ArrayList<>(); |
| } |
| |
| @Override |
| public void registerOnSubscriptionsChangedListener( |
| final SubscriptionManager.OnSubscriptionsChangedListener listener) { |
| } |
| } |
| ); |
| } |
| // By default only allow reading of system settings (that we provide) - can delegate |
| // to real provider if required. |
| final FakeContentProvider settings = new FakeContentProvider(context, |
| Settings.System.CONTENT_URI, false); |
| settings.addOverrideData(Settings.System.CONTENT_URI, "name=?", "time_12_24", |
| new String[] { "value" }, new Object[][] { { "12" } }); |
| settings.addOverrideData(Settings.System.CONTENT_URI, "name=?", "sound_effects_enabled", |
| new String[] { "value" }, new Object[][] { { 1 } }); |
| |
| factory.withProvider(Settings.System.CONTENT_URI, settings); |
| |
| return factory; |
| } |
| |
| public static FakeFactory register(final Context applicationContext) { |
| final FakeContext context = new FakeContext(applicationContext); |
| return registerWithFakeContext(applicationContext, context); |
| } |
| |
| public static FakeFactory registerWithoutFakeContext(final Context applicationContext) { |
| return registerWithFakeContext(applicationContext, null); |
| } |
| |
| @Override |
| public void onRequiredPermissionsAcquired() { |
| } |
| |
| @Override |
| public Context getApplicationContext() { |
| return ((mFakeContext != null) ? mFakeContext : mContext ); |
| } |
| |
| @Override |
| public DataModel getDataModel() { |
| return mDataModel; |
| } |
| |
| @Override |
| public BugleGservices getBugleGservices() { |
| return mBugleGservices; |
| } |
| |
| @Override |
| public BuglePrefs getApplicationPrefs() { |
| return mBuglePrefs; |
| } |
| |
| @Override |
| public BuglePrefs getWidgetPrefs() { |
| return mBuglePrefs; |
| } |
| |
| @Override |
| public BuglePrefs getSubscriptionPrefs(final int subId) { |
| return mBuglePrefs; |
| } |
| |
| @Override |
| public UIIntents getUIIntents() { |
| return mUIIntents; |
| } |
| |
| @Override |
| public MemoryCacheManager getMemoryCacheManager() { |
| return mMemoryCacheManager; |
| } |
| |
| @Override |
| public MediaResourceManager getMediaResourceManager() { |
| return mMediaResourceManager; |
| } |
| |
| @Override |
| public MediaCacheManager getMediaCacheManager() { |
| return mMediaCacheManager; |
| } |
| |
| @Override |
| public PhoneUtils getPhoneUtils(final int subId) { |
| return mPhoneUtils; |
| } |
| |
| @Override |
| public MediaUtil getMediaUtil() { |
| return mMediaUtil; |
| } |
| |
| @Override |
| public BugleCarrierConfigValuesLoader getCarrierConfigValuesLoader() { |
| return mCarrierConfigValuesLoader; |
| } |
| |
| @Override |
| public ContactContentObserver getContactContentObserver() { |
| return null; |
| } |
| |
| @Override |
| public void reclaimMemory() { |
| } |
| |
| @Override |
| public void onActivityResume() { |
| } |
| |
| public FakeFactory withDataModel(final DataModel dataModel) { |
| this.mDataModel = dataModel; |
| return this; |
| } |
| |
| public FakeFactory withUIIntents(final UIIntents uiIntents) { |
| this.mUIIntents = uiIntents; |
| return this; |
| } |
| |
| public FakeFactory withMemoryCacheManager(final MemoryCacheManager memoryCacheManager) { |
| this.mMemoryCacheManager = memoryCacheManager; |
| return this; |
| } |
| |
| public FakeFactory withBugleGservices(final BugleGservices bugleGservices) { |
| this.mBugleGservices = bugleGservices; |
| return this; |
| } |
| |
| public FakeFactory withMediaCacheManager(final MediaCacheManager mediaCacheManager) { |
| this.mMediaCacheManager = mediaCacheManager; |
| return this; |
| } |
| |
| public FakeFactory withProvider(final Uri uri, final ContentProvider provider) { |
| if (mFakeContext != null) { |
| mFakeContext.addContentProvider(uri.getAuthority(), provider); |
| } |
| return this; |
| } |
| |
| public FakeFactory withDefaultProvider(final Uri uri) { |
| if (mFakeContext != null) { |
| mFakeContext.addDefaultProvider(this.mContext, uri); |
| } |
| return this; |
| } |
| |
| public FakeFactory withMediaUtil(final MediaUtil mediaUtil) { |
| this.mMediaUtil = mediaUtil; |
| return this; |
| } |
| |
| public FakeFactory withCarrierConfigValuesLoader( |
| final BugleCarrierConfigValuesLoader carrierConfigValuesLoader) { |
| this.mCarrierConfigValuesLoader = carrierConfigValuesLoader; |
| return this; |
| } |
| } |