Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android; |
| 18 | |
| 19 | import static org.mockito.ArgumentMatchers.anyInt; |
Brad Ebinger | 6c53e7f | 2023-01-27 16:26:44 -0800 | [diff] [blame] | 20 | import static org.mockito.ArgumentMatchers.anyString; |
Brad Ebinger | 9c5578a | 2020-09-23 17:03:48 -0700 | [diff] [blame] | 21 | import static org.mockito.Mockito.doAnswer; |
Tomasz Wasilczyk | d78e870 | 2024-03-14 11:11:46 -0700 | [diff] [blame] | 22 | import static org.mockito.Mockito.when; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 23 | |
Rafael Higuera Silva | 0b1ccf6 | 2022-02-11 17:58:27 +0000 | [diff] [blame] | 24 | import android.content.AttributionSource; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 25 | import android.content.BroadcastReceiver; |
James.cf Lin | cdad386 | 2020-02-25 15:55:03 +0800 | [diff] [blame] | 26 | import android.content.ContentResolver; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 27 | import android.content.Context; |
| 28 | import android.content.Intent; |
| 29 | import android.content.IntentFilter; |
Tyler Gunn | b1ead4b | 2024-11-15 17:27:21 +0000 | [diff] [blame^] | 30 | import android.content.ServiceConnection; |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 31 | import android.content.pm.PackageManager; |
| 32 | import android.os.Binder; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 33 | import android.os.Handler; |
Hall Liu | 12feea2 | 2021-03-22 15:37:41 -0700 | [diff] [blame] | 34 | import android.os.Looper; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 35 | import android.os.PersistableBundle; |
Rafael Higuera Silva | 0b1ccf6 | 2022-02-11 17:58:27 +0000 | [diff] [blame] | 36 | import android.os.Process; |
Jack Yu | 58d04bd | 2024-09-10 17:32:39 -0700 | [diff] [blame] | 37 | import android.os.UserHandle; |
Gil Cukierman | 6dac5eb | 2022-09-19 16:09:04 +0000 | [diff] [blame] | 38 | import android.os.UserManager; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 39 | import android.telecom.TelecomManager; |
| 40 | import android.telephony.CarrierConfigManager; |
| 41 | import android.telephony.SubscriptionManager; |
| 42 | import android.telephony.TelephonyManager; |
James.cf Lin | cdad386 | 2020-02-25 15:55:03 +0800 | [diff] [blame] | 43 | import android.telephony.ims.ImsManager; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 44 | import android.test.mock.MockContext; |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 45 | import android.util.Log; |
Brad Ebinger | 9c5578a | 2020-09-23 17:03:48 -0700 | [diff] [blame] | 46 | import android.util.SparseArray; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 47 | |
| 48 | import org.mockito.Mock; |
| 49 | import org.mockito.MockitoAnnotations; |
Brad Ebinger | 9c5578a | 2020-09-23 17:03:48 -0700 | [diff] [blame] | 50 | import org.mockito.stubbing.Answer; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 51 | |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 52 | import java.util.HashSet; |
Brad Ebinger | a68a497 | 2020-01-30 17:31:23 -0800 | [diff] [blame] | 53 | import java.util.concurrent.Executor; |
| 54 | |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 55 | public class TestContext extends MockContext { |
| 56 | |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 57 | private static final String TAG = "TestContext"; |
| 58 | // Stub used to grant all permissions |
| 59 | public static final String STUB_PERMISSION_ENABLE_ALL = "stub_permission_enable_all"; |
| 60 | |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 61 | @Mock CarrierConfigManager mMockCarrierConfigManager; |
| 62 | @Mock TelecomManager mMockTelecomManager; |
| 63 | @Mock TelephonyManager mMockTelephonyManager; |
| 64 | @Mock SubscriptionManager mMockSubscriptionManager; |
James.cf Lin | cdad386 | 2020-02-25 15:55:03 +0800 | [diff] [blame] | 65 | @Mock ImsManager mMockImsManager; |
Gil Cukierman | 6dac5eb | 2022-09-19 16:09:04 +0000 | [diff] [blame] | 66 | @Mock UserManager mMockUserManager; |
Tomasz Wasilczyk | d78e870 | 2024-03-14 11:11:46 -0700 | [diff] [blame] | 67 | @Mock PackageManager mPackageManager; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 68 | |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 69 | private final SparseArray<PersistableBundle> mCarrierConfigs = new SparseArray<>(); |
| 70 | |
| 71 | private Intent mIntent; |
| 72 | |
| 73 | private BroadcastReceiver mReceiver; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 74 | |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 75 | private final HashSet<String> mPermissionTable = new HashSet<>(); |
| 76 | |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 77 | public TestContext() { |
| 78 | MockitoAnnotations.initMocks(this); |
Brad Ebinger | 9c5578a | 2020-09-23 17:03:48 -0700 | [diff] [blame] | 79 | doAnswer((Answer<PersistableBundle>) invocation -> { |
| 80 | int subId = (int) invocation.getArguments()[0]; |
Brad Ebinger | 6c53e7f | 2023-01-27 16:26:44 -0800 | [diff] [blame] | 81 | return getTestConfigs(subId); |
Brad Ebinger | 9c5578a | 2020-09-23 17:03:48 -0700 | [diff] [blame] | 82 | }).when(mMockCarrierConfigManager).getConfigForSubId(anyInt()); |
Brad Ebinger | 6c53e7f | 2023-01-27 16:26:44 -0800 | [diff] [blame] | 83 | doAnswer((Answer<PersistableBundle>) invocation -> { |
| 84 | int subId = (int) invocation.getArguments()[0]; |
| 85 | return getTestConfigs(subId); |
| 86 | }).when(mMockCarrierConfigManager).getConfigForSubId(anyInt(), anyString()); |
Tomasz Wasilczyk | d78e870 | 2024-03-14 11:11:46 -0700 | [diff] [blame] | 87 | when(mPackageManager.hasSystemFeature(anyString())).thenReturn(true); |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | @Override |
Brad Ebinger | a68a497 | 2020-01-30 17:31:23 -0800 | [diff] [blame] | 91 | public Executor getMainExecutor() { |
| 92 | // Just run on current thread |
| 93 | return Runnable::run; |
| 94 | } |
| 95 | |
| 96 | @Override |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 97 | public Context getApplicationContext() { |
| 98 | return this; |
| 99 | } |
| 100 | |
| 101 | @Override |
| 102 | public String getPackageName() { |
| 103 | return "com.android.phone.tests"; |
| 104 | } |
| 105 | |
| 106 | @Override |
Tomasz Wasilczyk | 33c4452 | 2024-11-07 21:18:16 -0800 | [diff] [blame] | 107 | public String getOpPackageName() { |
| 108 | return getPackageName(); |
| 109 | } |
| 110 | |
| 111 | @Override |
Philip P. Moltmann | 8d34f0c | 2020-03-05 16:24:02 -0800 | [diff] [blame] | 112 | public String getAttributionTag() { |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 113 | return ""; |
| 114 | } |
| 115 | |
| 116 | @Override |
Rafael Higuera Silva | 0b1ccf6 | 2022-02-11 17:58:27 +0000 | [diff] [blame] | 117 | public AttributionSource getAttributionSource() { |
| 118 | return new AttributionSource(Process.myUid(), getPackageName(), ""); |
| 119 | } |
| 120 | |
| 121 | @Override |
Jack Yu | 58d04bd | 2024-09-10 17:32:39 -0700 | [diff] [blame] | 122 | public void startActivityAsUser(Intent intent, UserHandle user) { |
| 123 | throw new UnsupportedOperationException(); |
| 124 | } |
| 125 | |
| 126 | @Override |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 127 | public void sendBroadcast(Intent intent) { |
| 128 | mIntent = intent; |
| 129 | } |
| 130 | |
| 131 | @Override |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 132 | public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter) { |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 133 | mReceiver = receiver; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 134 | return null; |
| 135 | } |
| 136 | |
| 137 | @Override |
| 138 | public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, int flags) { |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 139 | mReceiver = receiver; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 140 | return null; |
| 141 | } |
| 142 | |
| 143 | @Override |
| 144 | public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, |
| 145 | String broadcastPermission, Handler scheduler) { |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 146 | mReceiver = receiver; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 147 | return null; |
| 148 | } |
| 149 | |
| 150 | @Override |
| 151 | public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter, |
| 152 | String broadcastPermission, Handler scheduler, int flags) { |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 153 | mReceiver = receiver; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 154 | return null; |
| 155 | } |
| 156 | |
| 157 | @Override |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 158 | public void unregisterReceiver(BroadcastReceiver receiver) { |
| 159 | mReceiver = null; |
| 160 | } |
| 161 | |
| 162 | @Override |
Tomasz Wasilczyk | d78e870 | 2024-03-14 11:11:46 -0700 | [diff] [blame] | 163 | public PackageManager getPackageManager() { |
| 164 | return mPackageManager; |
| 165 | } |
| 166 | |
| 167 | @Override |
James.cf Lin | cdad386 | 2020-02-25 15:55:03 +0800 | [diff] [blame] | 168 | public ContentResolver getContentResolver() { |
| 169 | return null; |
| 170 | } |
| 171 | |
| 172 | @Override |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 173 | public Object getSystemService(String name) { |
| 174 | switch (name) { |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 175 | case Context.CARRIER_CONFIG_SERVICE: { |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 176 | return mMockCarrierConfigManager; |
| 177 | } |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 178 | case Context.TELECOM_SERVICE: { |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 179 | return mMockTelecomManager; |
| 180 | } |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 181 | case Context.TELEPHONY_SERVICE: { |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 182 | return mMockTelephonyManager; |
| 183 | } |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 184 | case Context.TELEPHONY_SUBSCRIPTION_SERVICE: { |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 185 | return mMockSubscriptionManager; |
| 186 | } |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 187 | case Context.TELEPHONY_IMS_SERVICE: { |
James.cf Lin | cdad386 | 2020-02-25 15:55:03 +0800 | [diff] [blame] | 188 | return mMockImsManager; |
| 189 | } |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 190 | case Context.USER_SERVICE: { |
Gil Cukierman | 6dac5eb | 2022-09-19 16:09:04 +0000 | [diff] [blame] | 191 | return mMockUserManager; |
| 192 | } |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 193 | } |
| 194 | return null; |
| 195 | } |
| 196 | |
| 197 | @Override |
| 198 | public String getSystemServiceName(Class<?> serviceClass) { |
| 199 | if (serviceClass == CarrierConfigManager.class) { |
| 200 | return Context.CARRIER_CONFIG_SERVICE; |
| 201 | } |
| 202 | if (serviceClass == TelecomManager.class) { |
| 203 | return Context.TELECOM_SERVICE; |
| 204 | } |
| 205 | if (serviceClass == TelephonyManager.class) { |
| 206 | return Context.TELEPHONY_SERVICE; |
| 207 | } |
| 208 | if (serviceClass == SubscriptionManager.class) { |
| 209 | return Context.TELEPHONY_SUBSCRIPTION_SERVICE; |
| 210 | } |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 211 | if (serviceClass == ImsManager.class) { |
| 212 | return Context.TELEPHONY_IMS_SERVICE; |
| 213 | } |
Gil Cukierman | 6dac5eb | 2022-09-19 16:09:04 +0000 | [diff] [blame] | 214 | if (serviceClass == UserManager.class) { |
| 215 | return Context.USER_SERVICE; |
| 216 | } |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 217 | return null; |
| 218 | } |
| 219 | |
Hall Liu | 12feea2 | 2021-03-22 15:37:41 -0700 | [diff] [blame] | 220 | @Override |
Tomasz Wasilczyk | 310544d | 2024-10-24 14:08:18 -0700 | [diff] [blame] | 221 | public Looper getMainLooper() { |
| 222 | return Looper.getMainLooper(); |
| 223 | } |
| 224 | |
| 225 | @Override |
Hall Liu | 12feea2 | 2021-03-22 15:37:41 -0700 | [diff] [blame] | 226 | public Handler getMainThreadHandler() { |
| 227 | return new Handler(Looper.getMainLooper()); |
| 228 | } |
| 229 | |
Brad Ebinger | 9c5578a | 2020-09-23 17:03:48 -0700 | [diff] [blame] | 230 | /** |
| 231 | * @return CarrierConfig PersistableBundle for the subscription specified. |
| 232 | */ |
| 233 | public PersistableBundle getCarrierConfig(int subId) { |
| 234 | PersistableBundle b = mCarrierConfigs.get(subId); |
| 235 | if (b == null) { |
| 236 | b = new PersistableBundle(); |
| 237 | mCarrierConfigs.put(subId, b); |
| 238 | } |
| 239 | return b; |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 240 | } |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 241 | |
| 242 | @Override |
| 243 | public void enforceCallingOrSelfPermission(String permission, String message) { |
| 244 | if (checkCallingOrSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) { |
| 245 | throw new SecurityException(permission + " denied: " + message); |
| 246 | } |
| 247 | } |
| 248 | |
| 249 | @Override |
| 250 | public void enforcePermission(String permission, int pid, int uid, String message) { |
| 251 | enforceCallingOrSelfPermission(permission, message); |
| 252 | } |
| 253 | |
| 254 | @Override |
| 255 | public void enforceCallingPermission(String permission, String message) { |
| 256 | enforceCallingOrSelfPermission(permission, message); |
| 257 | } |
| 258 | |
| 259 | @Override |
| 260 | public int checkCallingOrSelfPermission(String permission) { |
| 261 | return checkPermission(permission, Binder.getCallingPid(), Binder.getCallingUid()); |
| 262 | } |
| 263 | |
| 264 | @Override |
| 265 | public int checkPermission(String permission, int pid, int uid) { |
| 266 | synchronized (mPermissionTable) { |
| 267 | if (mPermissionTable.contains(permission) |
| 268 | || mPermissionTable.contains(STUB_PERMISSION_ENABLE_ALL)) { |
| 269 | logd("checkCallingOrSelfPermission: " + permission + " return GRANTED"); |
| 270 | return PackageManager.PERMISSION_GRANTED; |
| 271 | } else { |
| 272 | logd("checkCallingOrSelfPermission: " + permission + " return DENIED"); |
| 273 | return PackageManager.PERMISSION_DENIED; |
| 274 | } |
| 275 | } |
| 276 | } |
| 277 | |
Tyler Gunn | b1ead4b | 2024-11-15 17:27:21 +0000 | [diff] [blame^] | 278 | @Override |
| 279 | public void unbindService(ServiceConnection conn) { |
| 280 | // Override the base implementation to ensure we don't crash. |
| 281 | } |
| 282 | |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 283 | public void grantPermission(String permission) { |
| 284 | synchronized (mPermissionTable) { |
Brad Ebinger | 6c53e7f | 2023-01-27 16:26:44 -0800 | [diff] [blame] | 285 | if (permission == null) return; |
| 286 | mPermissionTable.remove(STUB_PERMISSION_ENABLE_ALL); |
| 287 | mPermissionTable.add(permission); |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 288 | } |
| 289 | } |
| 290 | |
| 291 | public void revokePermission(String permission) { |
| 292 | synchronized (mPermissionTable) { |
Brad Ebinger | 6c53e7f | 2023-01-27 16:26:44 -0800 | [diff] [blame] | 293 | if (permission == null) return; |
| 294 | mPermissionTable.remove(permission); |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 295 | } |
| 296 | } |
| 297 | |
| 298 | public void revokeAllPermissions() { |
| 299 | synchronized (mPermissionTable) { |
| 300 | mPermissionTable.clear(); |
| 301 | } |
| 302 | } |
| 303 | |
Sarah Chin | 7146248 | 2022-11-18 02:25:25 -0800 | [diff] [blame] | 304 | public Intent getBroadcast() { |
| 305 | return mIntent; |
| 306 | } |
| 307 | |
| 308 | public BroadcastReceiver getBroadcastReceiver() { |
| 309 | return mReceiver; |
| 310 | } |
| 311 | |
Brad Ebinger | 6c53e7f | 2023-01-27 16:26:44 -0800 | [diff] [blame] | 312 | private PersistableBundle getTestConfigs(int subId) { |
| 313 | if (subId < 0) { |
| 314 | return new PersistableBundle(); |
| 315 | } |
| 316 | PersistableBundle b = getCarrierConfig(subId); |
| 317 | return (b != null ? b : new PersistableBundle()); |
| 318 | } |
| 319 | |
Rambo Wang | 7e3bc12 | 2021-03-23 09:24:38 -0700 | [diff] [blame] | 320 | private static void logd(String s) { |
| 321 | Log.d(TAG, s); |
| 322 | } |
Brad Ebinger | dc555b4 | 2019-12-09 16:12:57 -0800 | [diff] [blame] | 323 | } |