1 /* 2 * Copyright (C) 2014 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.server; 18 19 import android.Manifest.permission; 20 import android.annotation.Nullable; 21 import android.content.BroadcastReceiver; 22 import android.content.ComponentName; 23 import android.content.ContentResolver; 24 import android.content.Context; 25 import android.content.Intent; 26 import android.content.IntentFilter; 27 import android.content.ServiceConnection; 28 import android.content.pm.PackageManager; 29 import android.content.pm.PackageManagerInternal; 30 import android.database.ContentObserver; 31 import android.location.LocationManager; 32 import android.net.INetworkRecommendationProvider; 33 import android.net.INetworkScoreCache; 34 import android.net.INetworkScoreService; 35 import android.net.NetworkKey; 36 import android.net.NetworkScoreManager; 37 import android.net.NetworkScorerAppData; 38 import android.net.ScoredNetwork; 39 import android.net.Uri; 40 import android.net.wifi.ScanResult; 41 import android.net.wifi.WifiInfo; 42 import android.net.wifi.WifiManager; 43 import android.net.wifi.WifiScanner; 44 import android.os.Binder; 45 import android.os.Build; 46 import android.os.Handler; 47 import android.os.IBinder; 48 import android.os.Looper; 49 import android.os.Message; 50 import android.os.RemoteCallbackList; 51 import android.os.RemoteException; 52 import android.os.UserHandle; 53 import android.provider.Settings.Global; 54 import android.text.TextUtils; 55 import android.util.ArrayMap; 56 import android.util.ArraySet; 57 import android.util.IntArray; 58 import android.util.Log; 59 60 import com.android.internal.annotations.GuardedBy; 61 import com.android.internal.annotations.VisibleForTesting; 62 import com.android.internal.content.PackageMonitor; 63 import com.android.internal.os.TransferPipe; 64 import com.android.internal.telephony.SmsApplication; 65 import com.android.internal.util.DumpUtils; 66 67 import java.io.FileDescriptor; 68 import java.io.IOException; 69 import java.io.PrintWriter; 70 import java.util.ArrayList; 71 import java.util.Collection; 72 import java.util.Collections; 73 import java.util.List; 74 import java.util.Map; 75 import java.util.Set; 76 import java.util.function.BiConsumer; 77 import java.util.function.Function; 78 import java.util.function.Supplier; 79 import java.util.function.UnaryOperator; 80 81 /** 82 * Backing service for {@link android.net.NetworkScoreManager}. 83 * @hide 84 */ 85 public class NetworkScoreService extends INetworkScoreService.Stub { 86 private static final String TAG = "NetworkScoreService"; 87 private static final boolean DBG = Build.IS_DEBUGGABLE && Log.isLoggable(TAG, Log.DEBUG); 88 private static final boolean VERBOSE = Build.IS_DEBUGGABLE && Log.isLoggable(TAG, Log.VERBOSE); 89 90 private final Context mContext; 91 private final NetworkScorerAppManager mNetworkScorerAppManager; 92 @GuardedBy("mScoreCaches") 93 private final Map<Integer, RemoteCallbackList<INetworkScoreCache>> mScoreCaches; 94 /** Lock used to update mPackageMonitor when scorer package changes occur. */ 95 private final Object mPackageMonitorLock = new Object(); 96 private final Object mServiceConnectionLock = new Object(); 97 private final Handler mHandler; 98 private final DispatchingContentObserver mRecommendationSettingsObserver; 99 private final ContentObserver mUseOpenWifiPackageObserver; 100 private final Function<NetworkScorerAppData, ScoringServiceConnection> mServiceConnProducer; 101 102 @GuardedBy("mPackageMonitorLock") 103 private NetworkScorerPackageMonitor mPackageMonitor; 104 @GuardedBy("mServiceConnectionLock") 105 private ScoringServiceConnection mServiceConnection; 106 107 private BroadcastReceiver mUserIntentReceiver = new BroadcastReceiver() { 108 @Override 109 public void onReceive(Context context, Intent intent) { 110 final String action = intent.getAction(); 111 final int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL); 112 if (DBG) Log.d(TAG, "Received " + action + " for userId " + userId); 113 if (userId == UserHandle.USER_NULL) return; 114 115 if (Intent.ACTION_USER_UNLOCKED.equals(action)) { 116 onUserUnlocked(userId); 117 } 118 } 119 }; 120 121 private BroadcastReceiver mLocationModeReceiver = new BroadcastReceiver() { 122 @Override 123 public void onReceive(Context context, Intent intent) { 124 final String action = intent.getAction(); 125 if (LocationManager.MODE_CHANGED_ACTION.equals(action)) { 126 refreshBinding(); 127 } 128 } 129 }; 130 131 public static final class Lifecycle extends SystemService { 132 private final NetworkScoreService mService; 133 134 public Lifecycle(Context context) { 135 super(context); 136 mService = new NetworkScoreService(context); 137 } 138 139 @Override 140 public void onStart() { 141 Log.i(TAG, "Registering " + Context.NETWORK_SCORE_SERVICE); 142 publishBinderService(Context.NETWORK_SCORE_SERVICE, mService); 143 } 144 145 @Override 146 public void onBootPhase(int phase) { 147 if (phase == PHASE_SYSTEM_SERVICES_READY) { 148 mService.systemReady(); 149 } else if (phase == PHASE_BOOT_COMPLETED) { 150 mService.systemRunning(); 151 } 152 } 153 } 154 155 /** 156 * Clears scores when the active scorer package is no longer valid and 157 * manages the service connection. 158 */ 159 private class NetworkScorerPackageMonitor extends PackageMonitor { 160 final String mPackageToWatch; 161 162 private NetworkScorerPackageMonitor(String packageToWatch) { 163 mPackageToWatch = packageToWatch; 164 } 165 166 @Override 167 public void onPackageAdded(String packageName, int uid) { 168 evaluateBinding(packageName, true /* forceUnbind */); 169 } 170 171 @Override 172 public void onPackageRemoved(String packageName, int uid) { 173 evaluateBinding(packageName, true /* forceUnbind */); 174 } 175 176 @Override 177 public void onPackageModified(String packageName) { 178 evaluateBinding(packageName, false /* forceUnbind */); 179 } 180 181 @Override 182 public boolean onHandleForceStop(Intent intent, String[] packages, int uid, boolean doit) { 183 if (doit) { // "doit" means the force stop happened instead of just being queried for. 184 for (String packageName : packages) { 185 evaluateBinding(packageName, true /* forceUnbind */); 186 } 187 } 188 return super.onHandleForceStop(intent, packages, uid, doit); 189 } 190 191 @Override 192 public void onPackageUpdateFinished(String packageName, int uid) { 193 evaluateBinding(packageName, true /* forceUnbind */); 194 } 195 196 private void evaluateBinding(String changedPackageName, boolean forceUnbind) { 197 if (!mPackageToWatch.equals(changedPackageName)) { 198 // Early exit when we don't care about the package that has changed. 199 return; 200 } 201 202 if (DBG) { 203 Log.d(TAG, "Evaluating binding for: " + changedPackageName 204 + ", forceUnbind=" + forceUnbind); 205 } 206 207 final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer(); 208 if (activeScorer == null) { 209 // Package change has invalidated a scorer, this will also unbind any service 210 // connection. 211 if (DBG) Log.d(TAG, "No active scorers available."); 212 refreshBinding(); 213 } else { // The scoring service changed in some way. 214 if (forceUnbind) { 215 unbindFromScoringServiceIfNeeded(); 216 } 217 if (DBG) { 218 Log.d(TAG, "Binding to " + activeScorer.getRecommendationServiceComponent() 219 + " if needed."); 220 } 221 bindToScoringServiceIfNeeded(activeScorer); 222 } 223 } 224 } 225 226 /** 227 * Dispatches observed content changes to a handler for further processing. 228 */ 229 @VisibleForTesting 230 public static class DispatchingContentObserver extends ContentObserver { 231 final private Map<Uri, Integer> mUriEventMap; 232 final private Context mContext; 233 final private Handler mHandler; 234 235 public DispatchingContentObserver(Context context, Handler handler) { 236 super(handler); 237 mContext = context; 238 mHandler = handler; 239 mUriEventMap = new ArrayMap<>(); 240 } 241 242 void observe(Uri uri, int what) { 243 mUriEventMap.put(uri, what); 244 final ContentResolver resolver = mContext.getContentResolver(); 245 resolver.registerContentObserver(uri, false /*notifyForDescendants*/, this); 246 } 247 248 @Override 249 public void onChange(boolean selfChange) { 250 onChange(selfChange, null); 251 } 252 253 @Override 254 public void onChange(boolean selfChange, Uri uri) { 255 if (DBG) Log.d(TAG, String.format("onChange(%s, %s)", selfChange, uri)); 256 final Integer what = mUriEventMap.get(uri); 257 if (what != null) { 258 mHandler.obtainMessage(what).sendToTarget(); 259 } else { 260 Log.w(TAG, "No matching event to send for URI = " + uri); 261 } 262 } 263 } 264 265 public NetworkScoreService(Context context) { 266 this(context, new NetworkScorerAppManager(context), 267 ScoringServiceConnection::new, Looper.myLooper()); 268 } 269 270 @VisibleForTesting 271 NetworkScoreService(Context context, NetworkScorerAppManager networkScoreAppManager, 272 Function<NetworkScorerAppData, ScoringServiceConnection> serviceConnProducer, 273 Looper looper) { 274 mContext = context; 275 mNetworkScorerAppManager = networkScoreAppManager; 276 mScoreCaches = new ArrayMap<>(); 277 IntentFilter filter = new IntentFilter(Intent.ACTION_USER_UNLOCKED); 278 // TODO: Need to update when we support per-user scorers. http://b/23422763 279 mContext.registerReceiverAsUser( 280 mUserIntentReceiver, UserHandle.SYSTEM, filter, null /* broadcastPermission*/, 281 null /* scheduler */); 282 mHandler = new ServiceHandler(looper); 283 IntentFilter locationModeFilter = new IntentFilter(LocationManager.MODE_CHANGED_ACTION); 284 mContext.registerReceiverAsUser( 285 mLocationModeReceiver, UserHandle.SYSTEM, locationModeFilter, 286 null /* broadcastPermission*/, mHandler); 287 mRecommendationSettingsObserver = new DispatchingContentObserver(context, mHandler); 288 mServiceConnProducer = serviceConnProducer; 289 mUseOpenWifiPackageObserver = new ContentObserver(mHandler) { 290 @Override 291 public void onChange(boolean selfChange, Uri uri, int userId) { 292 Uri useOpenWifiPkgUri = Global.getUriFor(Global.USE_OPEN_WIFI_PACKAGE); 293 if (useOpenWifiPkgUri.equals(uri)) { 294 String useOpenWifiPackage = Global.getString(mContext.getContentResolver(), 295 Global.USE_OPEN_WIFI_PACKAGE); 296 if (!TextUtils.isEmpty(useOpenWifiPackage)) { 297 LocalServices.getService(PackageManagerInternal.class) 298 .grantDefaultPermissionsToDefaultUseOpenWifiApp(useOpenWifiPackage, 299 userId); 300 } 301 } 302 } 303 }; 304 mContext.getContentResolver().registerContentObserver( 305 Global.getUriFor(Global.USE_OPEN_WIFI_PACKAGE), 306 false /*notifyForDescendants*/, 307 mUseOpenWifiPackageObserver); 308 // Set a callback for the package manager to query the use open wifi app. 309 LocalServices.getService(PackageManagerInternal.class).setUseOpenWifiAppPackagesProvider( 310 new PackageManagerInternal.PackagesProvider() { 311 @Override 312 public String[] getPackages(int userId) { 313 String useOpenWifiPackage = Global.getString(mContext.getContentResolver(), 314 Global.USE_OPEN_WIFI_PACKAGE); 315 if (!TextUtils.isEmpty(useOpenWifiPackage)) { 316 return new String[]{useOpenWifiPackage}; 317 } 318 return null; 319 } 320 }); 321 } 322 323 /** Called when the system is ready to run third-party code but before it actually does so. */ 324 void systemReady() { 325 if (DBG) Log.d(TAG, "systemReady"); 326 registerRecommendationSettingsObserver(); 327 } 328 329 /** Called when the system is ready for us to start third-party code. */ 330 void systemRunning() { 331 if (DBG) Log.d(TAG, "systemRunning"); 332 } 333 334 @VisibleForTesting 335 void onUserUnlocked(int userId) { 336 if (DBG) Log.d(TAG, "onUserUnlocked(" + userId + ")"); 337 refreshBinding(); 338 } 339 340 private void refreshBinding() { 341 if (DBG) Log.d(TAG, "refreshBinding()"); 342 // Make sure the scorer is up-to-date 343 mNetworkScorerAppManager.updateState(); 344 mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded(); 345 registerPackageMonitorIfNeeded(); 346 bindToScoringServiceIfNeeded(); 347 } 348 349 private void registerRecommendationSettingsObserver() { 350 final Uri packageNameUri = Global.getUriFor(Global.NETWORK_RECOMMENDATIONS_PACKAGE); 351 mRecommendationSettingsObserver.observe(packageNameUri, 352 ServiceHandler.MSG_RECOMMENDATIONS_PACKAGE_CHANGED); 353 354 final Uri settingUri = Global.getUriFor(Global.NETWORK_RECOMMENDATIONS_ENABLED); 355 mRecommendationSettingsObserver.observe(settingUri, 356 ServiceHandler.MSG_RECOMMENDATION_ENABLED_SETTING_CHANGED); 357 } 358 359 /** 360 * Ensures the package manager is registered to monitor the current active scorer. 361 * If a discrepancy is found any previous monitor will be cleaned up 362 * and a new monitor will be created. 363 * 364 * This method is idempotent. 365 */ 366 private void registerPackageMonitorIfNeeded() { 367 if (DBG) Log.d(TAG, "registerPackageMonitorIfNeeded()"); 368 final NetworkScorerAppData appData = mNetworkScorerAppManager.getActiveScorer(); 369 synchronized (mPackageMonitorLock) { 370 // Unregister the current monitor if needed. 371 if (mPackageMonitor != null && (appData == null 372 || !appData.getRecommendationServicePackageName().equals( 373 mPackageMonitor.mPackageToWatch))) { 374 if (DBG) { 375 Log.d(TAG, "Unregistering package monitor for " 376 + mPackageMonitor.mPackageToWatch); 377 } 378 mPackageMonitor.unregister(); 379 mPackageMonitor = null; 380 } 381 382 // Create and register the monitor if a scorer is active. 383 if (appData != null && mPackageMonitor == null) { 384 mPackageMonitor = new NetworkScorerPackageMonitor( 385 appData.getRecommendationServicePackageName()); 386 // TODO: Need to update when we support per-user scorers. http://b/23422763 387 mPackageMonitor.register(mContext, null /* thread */, UserHandle.SYSTEM, 388 false /* externalStorage */); 389 if (DBG) { 390 Log.d(TAG, "Registered package monitor for " 391 + mPackageMonitor.mPackageToWatch); 392 } 393 } 394 } 395 } 396 397 private void bindToScoringServiceIfNeeded() { 398 if (DBG) Log.d(TAG, "bindToScoringServiceIfNeeded"); 399 NetworkScorerAppData scorerData = mNetworkScorerAppManager.getActiveScorer(); 400 bindToScoringServiceIfNeeded(scorerData); 401 } 402 403 /** 404 * Ensures the service connection is bound to the current active scorer. 405 * If a discrepancy is found any previous connection will be cleaned up 406 * and a new connection will be created. 407 * 408 * This method is idempotent. 409 */ 410 private void bindToScoringServiceIfNeeded(NetworkScorerAppData appData) { 411 if (DBG) Log.d(TAG, "bindToScoringServiceIfNeeded(" + appData + ")"); 412 if (appData != null) { 413 synchronized (mServiceConnectionLock) { 414 // If we're connected to a different component then drop it. 415 if (mServiceConnection != null 416 && !mServiceConnection.getAppData().equals(appData)) { 417 unbindFromScoringServiceIfNeeded(); 418 } 419 420 // If we're not connected at all then create a new connection. 421 if (mServiceConnection == null) { 422 mServiceConnection = mServiceConnProducer.apply(appData); 423 } 424 425 // Make sure the connection is connected (idempotent) 426 mServiceConnection.bind(mContext); 427 } 428 } else { // otherwise make sure it isn't bound. 429 unbindFromScoringServiceIfNeeded(); 430 } 431 } 432 433 private void unbindFromScoringServiceIfNeeded() { 434 if (DBG) Log.d(TAG, "unbindFromScoringServiceIfNeeded"); 435 synchronized (mServiceConnectionLock) { 436 if (mServiceConnection != null) { 437 mServiceConnection.unbind(mContext); 438 if (DBG) Log.d(TAG, "Disconnected from: " 439 + mServiceConnection.getAppData().getRecommendationServiceComponent()); 440 } 441 mServiceConnection = null; 442 } 443 clearInternal(); 444 } 445 446 @Override 447 public boolean updateScores(ScoredNetwork[] networks) { 448 if (!isCallerActiveScorer(getCallingUid())) { 449 throw new SecurityException("Caller with UID " + getCallingUid() + 450 " is not the active scorer."); 451 } 452 453 final long token = Binder.clearCallingIdentity(); 454 try { 455 // Separate networks by type. 456 Map<Integer, List<ScoredNetwork>> networksByType = new ArrayMap<>(); 457 for (ScoredNetwork network : networks) { 458 List<ScoredNetwork> networkList = networksByType.get(network.networkKey.type); 459 if (networkList == null) { 460 networkList = new ArrayList<>(); 461 networksByType.put(network.networkKey.type, networkList); 462 } 463 networkList.add(network); 464 } 465 466 // Pass the scores of each type down to the appropriate network scorer. 467 for (final Map.Entry<Integer, List<ScoredNetwork>> entry : networksByType.entrySet()) { 468 final RemoteCallbackList<INetworkScoreCache> callbackList; 469 final boolean isEmpty; 470 synchronized (mScoreCaches) { 471 callbackList = mScoreCaches.get(entry.getKey()); 472 isEmpty = callbackList == null 473 || callbackList.getRegisteredCallbackCount() == 0; 474 } 475 476 if (isEmpty) { 477 if (Log.isLoggable(TAG, Log.VERBOSE)) { 478 Log.v(TAG, "No scorer registered for type " + entry.getKey() 479 + ", discarding"); 480 } 481 continue; 482 } 483 484 final BiConsumer<INetworkScoreCache, Object> consumer = 485 FilteringCacheUpdatingConsumer.create(mContext, entry.getValue(), 486 entry.getKey()); 487 sendCacheUpdateCallback(consumer, Collections.singleton(callbackList)); 488 } 489 490 return true; 491 } finally { 492 Binder.restoreCallingIdentity(token); 493 } 494 } 495 496 /** 497 * A {@link BiConsumer} implementation that filters the given {@link ScoredNetwork} 498 * list (if needed) before invoking {@link INetworkScoreCache#updateScores(List)} on the 499 * accepted {@link INetworkScoreCache} implementation. 500 */ 501 @VisibleForTesting 502 static class FilteringCacheUpdatingConsumer 503 implements BiConsumer<INetworkScoreCache, Object> { 504 private final Context mContext; 505 private final List<ScoredNetwork> mScoredNetworkList; 506 private final int mNetworkType; 507 // TODO: 1/23/17 - Consider a Map if we implement more filters. 508 // These are created on-demand to defer the construction cost until 509 // an instance is actually needed. 510 private UnaryOperator<List<ScoredNetwork>> mCurrentNetworkFilter; 511 private UnaryOperator<List<ScoredNetwork>> mScanResultsFilter; 512 513 static FilteringCacheUpdatingConsumer create(Context context, 514 List<ScoredNetwork> scoredNetworkList, int networkType) { 515 return new FilteringCacheUpdatingConsumer(context, scoredNetworkList, networkType, 516 null, null); 517 } 518 519 @VisibleForTesting 520 FilteringCacheUpdatingConsumer(Context context, 521 List<ScoredNetwork> scoredNetworkList, int networkType, 522 UnaryOperator<List<ScoredNetwork>> currentNetworkFilter, 523 UnaryOperator<List<ScoredNetwork>> scanResultsFilter) { 524 mContext = context; 525 mScoredNetworkList = scoredNetworkList; 526 mNetworkType = networkType; 527 mCurrentNetworkFilter = currentNetworkFilter; 528 mScanResultsFilter = scanResultsFilter; 529 } 530 531 @Override 532 public void accept(INetworkScoreCache networkScoreCache, Object cookie) { 533 int filterType = NetworkScoreManager.CACHE_FILTER_NONE; 534 if (cookie instanceof Integer) { 535 filterType = (Integer) cookie; 536 } 537 538 try { 539 final List<ScoredNetwork> filteredNetworkList = 540 filterScores(mScoredNetworkList, filterType); 541 if (!filteredNetworkList.isEmpty()) { 542 networkScoreCache.updateScores(filteredNetworkList); 543 } 544 } catch (RemoteException e) { 545 if (VERBOSE) { 546 Log.v(TAG, "Unable to update scores of type " + mNetworkType, e); 547 } 548 } 549 } 550 551 /** 552 * Applies the appropriate filter and returns the filtered results. 553 */ 554 private List<ScoredNetwork> filterScores(List<ScoredNetwork> scoredNetworkList, 555 int filterType) { 556 switch (filterType) { 557 case NetworkScoreManager.CACHE_FILTER_NONE: 558 return scoredNetworkList; 559 560 case NetworkScoreManager.CACHE_FILTER_CURRENT_NETWORK: 561 if (mCurrentNetworkFilter == null) { 562 mCurrentNetworkFilter = 563 new CurrentNetworkScoreCacheFilter(new WifiInfoSupplier(mContext)); 564 } 565 return mCurrentNetworkFilter.apply(scoredNetworkList); 566 567 case NetworkScoreManager.CACHE_FILTER_SCAN_RESULTS: 568 if (mScanResultsFilter == null) { 569 mScanResultsFilter = new ScanResultsScoreCacheFilter( 570 new ScanResultsSupplier(mContext)); 571 } 572 return mScanResultsFilter.apply(scoredNetworkList); 573 574 default: 575 Log.w(TAG, "Unknown filter type: " + filterType); 576 return scoredNetworkList; 577 } 578 } 579 } 580 581 /** 582 * Helper class that improves the testability of the cache filter Functions. 583 */ 584 private static class WifiInfoSupplier implements Supplier<WifiInfo> { 585 private final Context mContext; 586 587 WifiInfoSupplier(Context context) { 588 mContext = context; 589 } 590 591 @Override 592 public WifiInfo get() { 593 WifiManager wifiManager = mContext.getSystemService(WifiManager.class); 594 if (wifiManager != null) { 595 return wifiManager.getConnectionInfo(); 596 } 597 Log.w(TAG, "WifiManager is null, failed to return the WifiInfo."); 598 return null; 599 } 600 } 601 602 /** 603 * Helper class that improves the testability of the cache filter Functions. 604 */ 605 private static class ScanResultsSupplier implements Supplier<List<ScanResult>> { 606 private final Context mContext; 607 608 ScanResultsSupplier(Context context) { 609 mContext = context; 610 } 611 612 @Override 613 public List<ScanResult> get() { 614 WifiScanner wifiScanner = mContext.getSystemService(WifiScanner.class); 615 if (wifiScanner != null) { 616 return wifiScanner.getSingleScanResults(); 617 } 618 Log.w(TAG, "WifiScanner is null, failed to return scan results."); 619 return Collections.emptyList(); 620 } 621 } 622 623 /** 624 * Filters the given set of {@link ScoredNetwork}s and returns a new List containing only the 625 * {@link ScoredNetwork} associated with the current network. If no network is connected the 626 * returned list will be empty. 627 * <p> 628 * Note: this filter performs some internal caching for consistency and performance. The 629 * current network is determined at construction time and never changed. Also, the 630 * last filtered list is saved so if the same input is provided multiple times in a row 631 * the computation is only done once. 632 */ 633 @VisibleForTesting 634 static class CurrentNetworkScoreCacheFilter implements UnaryOperator<List<ScoredNetwork>> { 635 private final NetworkKey mCurrentNetwork; 636 637 CurrentNetworkScoreCacheFilter(Supplier<WifiInfo> wifiInfoSupplier) { 638 mCurrentNetwork = NetworkKey.createFromWifiInfo(wifiInfoSupplier.get()); 639 } 640 641 @Override 642 public List<ScoredNetwork> apply(List<ScoredNetwork> scoredNetworks) { 643 if (mCurrentNetwork == null || scoredNetworks.isEmpty()) { 644 return Collections.emptyList(); 645 } 646 647 for (int i = 0; i < scoredNetworks.size(); i++) { 648 final ScoredNetwork scoredNetwork = scoredNetworks.get(i); 649 if (scoredNetwork.networkKey.equals(mCurrentNetwork)) { 650 return Collections.singletonList(scoredNetwork); 651 } 652 } 653 654 return Collections.emptyList(); 655 } 656 } 657 658 /** 659 * Filters the given set of {@link ScoredNetwork}s and returns a new List containing only the 660 * {@link ScoredNetwork} associated with the current set of {@link ScanResult}s. 661 * If there are no {@link ScanResult}s the returned list will be empty. 662 * <p> 663 * Note: this filter performs some internal caching for consistency and performance. The 664 * current set of ScanResults is determined at construction time and never changed. 665 * Also, the last filtered list is saved so if the same input is provided multiple 666 * times in a row the computation is only done once. 667 */ 668 @VisibleForTesting 669 static class ScanResultsScoreCacheFilter implements UnaryOperator<List<ScoredNetwork>> { 670 private final Set<NetworkKey> mScanResultKeys; 671 672 ScanResultsScoreCacheFilter(Supplier<List<ScanResult>> resultsSupplier) { 673 List<ScanResult> scanResults = resultsSupplier.get(); 674 final int size = scanResults.size(); 675 mScanResultKeys = new ArraySet<>(size); 676 for (int i = 0; i < size; i++) { 677 ScanResult scanResult = scanResults.get(i); 678 NetworkKey key = NetworkKey.createFromScanResult(scanResult); 679 if (key != null) { 680 mScanResultKeys.add(key); 681 } 682 } 683 } 684 685 @Override 686 public List<ScoredNetwork> apply(List<ScoredNetwork> scoredNetworks) { 687 if (mScanResultKeys.isEmpty() || scoredNetworks.isEmpty()) { 688 return Collections.emptyList(); 689 } 690 691 List<ScoredNetwork> filteredScores = new ArrayList<>(); 692 for (int i = 0; i < scoredNetworks.size(); i++) { 693 final ScoredNetwork scoredNetwork = scoredNetworks.get(i); 694 if (mScanResultKeys.contains(scoredNetwork.networkKey)) { 695 filteredScores.add(scoredNetwork); 696 } 697 } 698 699 return filteredScores; 700 } 701 } 702 703 @Override 704 public boolean clearScores() { 705 // Only the active scorer or the system should be allowed to flush all scores. 706 enforceSystemOrIsActiveScorer(getCallingUid()); 707 final long token = Binder.clearCallingIdentity(); 708 try { 709 clearInternal(); 710 return true; 711 } finally { 712 Binder.restoreCallingIdentity(token); 713 } 714 } 715 716 @Override 717 public boolean setActiveScorer(String packageName) { 718 enforceSystemOrHasScoreNetworks(); 719 return mNetworkScorerAppManager.setActiveScorer(packageName); 720 } 721 722 /** 723 * Determine whether the application with the given UID is the enabled scorer. 724 * 725 * @param callingUid the UID to check 726 * @return true if the provided UID is the active scorer, false otherwise. 727 */ 728 @Override 729 public boolean isCallerActiveScorer(int callingUid) { 730 synchronized (mServiceConnectionLock) { 731 return mServiceConnection != null 732 && mServiceConnection.getAppData().packageUid == callingUid; 733 } 734 } 735 736 private void enforceSystemOnly() throws SecurityException { 737 // REQUEST_NETWORK_SCORES is a signature only permission. 738 mContext.enforceCallingOrSelfPermission(permission.REQUEST_NETWORK_SCORES, 739 "Caller must be granted REQUEST_NETWORK_SCORES."); 740 } 741 742 private void enforceSystemOrHasScoreNetworks() throws SecurityException { 743 if (mContext.checkCallingOrSelfPermission(permission.REQUEST_NETWORK_SCORES) 744 != PackageManager.PERMISSION_GRANTED 745 && mContext.checkCallingOrSelfPermission(permission.SCORE_NETWORKS) 746 != PackageManager.PERMISSION_GRANTED) { 747 throw new SecurityException( 748 "Caller is neither the system process or a network scorer."); 749 } 750 } 751 752 private void enforceSystemOrIsActiveScorer(int callingUid) throws SecurityException { 753 if (mContext.checkCallingOrSelfPermission(permission.REQUEST_NETWORK_SCORES) 754 != PackageManager.PERMISSION_GRANTED 755 && !isCallerActiveScorer(callingUid)) { 756 throw new SecurityException( 757 "Caller is neither the system process or the active network scorer."); 758 } 759 } 760 761 /** 762 * Obtain the package name of the current active network scorer. 763 * 764 * @return the full package name of the current active scorer, or null if there is no active 765 * scorer. 766 */ 767 @Override 768 public String getActiveScorerPackage() { 769 enforceSystemOrHasScoreNetworks(); 770 synchronized (mServiceConnectionLock) { 771 if (mServiceConnection != null) { 772 return mServiceConnection.getPackageName(); 773 } 774 } 775 return null; 776 } 777 778 /** 779 * Returns metadata about the active scorer or <code>null</code> if there is no active scorer. 780 */ 781 @Override 782 public NetworkScorerAppData getActiveScorer() { 783 // Only the system can access this data. 784 enforceSystemOnly(); 785 synchronized (mServiceConnectionLock) { 786 if (mServiceConnection != null) { 787 return mServiceConnection.getAppData(); 788 } 789 } 790 791 return null; 792 } 793 794 /** 795 * Returns the list of available scorer apps. The list will be empty if there are 796 * no valid scorers. 797 */ 798 @Override 799 public List<NetworkScorerAppData> getAllValidScorers() { 800 // Only the system can access this data. 801 enforceSystemOnly(); 802 return mNetworkScorerAppManager.getAllValidScorers(); 803 } 804 805 @Override 806 public void disableScoring() { 807 // Only the active scorer or the system should be allowed to disable scoring. 808 enforceSystemOrIsActiveScorer(getCallingUid()); 809 // no-op for now but we could write to the setting if needed. 810 } 811 812 /** Clear scores. Callers are responsible for checking permissions as appropriate. */ 813 private void clearInternal() { 814 sendCacheUpdateCallback(new BiConsumer<INetworkScoreCache, Object>() { 815 @Override 816 public void accept(INetworkScoreCache networkScoreCache, Object cookie) { 817 try { 818 networkScoreCache.clearScores(); 819 } catch (RemoteException e) { 820 if (Log.isLoggable(TAG, Log.VERBOSE)) { 821 Log.v(TAG, "Unable to clear scores", e); 822 } 823 } 824 } 825 }, getScoreCacheLists()); 826 } 827 828 @Override 829 public void registerNetworkScoreCache(int networkType, 830 INetworkScoreCache scoreCache, 831 int filterType) { 832 enforceSystemOnly(); 833 final long token = Binder.clearCallingIdentity(); 834 try { 835 synchronized (mScoreCaches) { 836 RemoteCallbackList<INetworkScoreCache> callbackList = mScoreCaches.get(networkType); 837 if (callbackList == null) { 838 callbackList = new RemoteCallbackList<>(); 839 mScoreCaches.put(networkType, callbackList); 840 } 841 if (!callbackList.register(scoreCache, filterType)) { 842 if (callbackList.getRegisteredCallbackCount() == 0) { 843 mScoreCaches.remove(networkType); 844 } 845 if (Log.isLoggable(TAG, Log.VERBOSE)) { 846 Log.v(TAG, "Unable to register NetworkScoreCache for type " + networkType); 847 } 848 } 849 } 850 } finally { 851 Binder.restoreCallingIdentity(token); 852 } 853 } 854 855 @Override 856 public void unregisterNetworkScoreCache(int networkType, INetworkScoreCache scoreCache) { 857 enforceSystemOnly(); 858 final long token = Binder.clearCallingIdentity(); 859 try { 860 synchronized (mScoreCaches) { 861 RemoteCallbackList<INetworkScoreCache> callbackList = mScoreCaches.get(networkType); 862 if (callbackList == null || !callbackList.unregister(scoreCache)) { 863 if (Log.isLoggable(TAG, Log.VERBOSE)) { 864 Log.v(TAG, "Unable to unregister NetworkScoreCache for type " 865 + networkType); 866 } 867 } else if (callbackList.getRegisteredCallbackCount() == 0) { 868 mScoreCaches.remove(networkType); 869 } 870 } 871 } finally { 872 Binder.restoreCallingIdentity(token); 873 } 874 } 875 876 @Override 877 public boolean requestScores(NetworkKey[] networks) { 878 enforceSystemOnly(); 879 final long token = Binder.clearCallingIdentity(); 880 try { 881 final INetworkRecommendationProvider provider = getRecommendationProvider(); 882 if (provider != null) { 883 try { 884 provider.requestScores(networks); 885 // TODO: 12/15/16 - Consider pushing null scores into the cache to 886 // prevent repeated requests for the same scores. 887 return true; 888 } catch (RemoteException e) { 889 Log.w(TAG, "Failed to request scores.", e); 890 // TODO: 12/15/16 - Keep track of failures. 891 } 892 } 893 return false; 894 } finally { 895 Binder.restoreCallingIdentity(token); 896 } 897 } 898 899 @Override 900 protected void dump(final FileDescriptor fd, final PrintWriter writer, final String[] args) { 901 if (!DumpUtils.checkDumpPermission(mContext, TAG, writer)) return; 902 final long token = Binder.clearCallingIdentity(); 903 try { 904 NetworkScorerAppData currentScorer = mNetworkScorerAppManager.getActiveScorer(); 905 if (currentScorer == null) { 906 writer.println("Scoring is disabled."); 907 return; 908 } 909 writer.println("Current scorer: " + currentScorer); 910 911 sendCacheUpdateCallback(new BiConsumer<INetworkScoreCache, Object>() { 912 @Override 913 public void accept(INetworkScoreCache networkScoreCache, Object cookie) { 914 try { 915 TransferPipe.dumpAsync(networkScoreCache.asBinder(), fd, args); 916 } catch (IOException | RemoteException e) { 917 writer.println("Failed to dump score cache: " + e); 918 } 919 } 920 }, getScoreCacheLists()); 921 922 synchronized (mServiceConnectionLock) { 923 if (mServiceConnection != null) { 924 mServiceConnection.dump(fd, writer, args); 925 } else { 926 writer.println("ScoringServiceConnection: null"); 927 } 928 } 929 writer.flush(); 930 } finally { 931 Binder.restoreCallingIdentity(token); 932 } 933 } 934 935 /** 936 * Returns a {@link Collection} of all {@link RemoteCallbackList}s that are currently active. 937 * 938 * <p>May be used to perform an action on all score caches without potentially strange behavior 939 * if a new scorer is registered during that action's execution. 940 */ 941 private Collection<RemoteCallbackList<INetworkScoreCache>> getScoreCacheLists() { 942 synchronized (mScoreCaches) { 943 return new ArrayList<>(mScoreCaches.values()); 944 } 945 } 946 947 private void sendCacheUpdateCallback(BiConsumer<INetworkScoreCache, Object> consumer, 948 Collection<RemoteCallbackList<INetworkScoreCache>> remoteCallbackLists) { 949 for (RemoteCallbackList<INetworkScoreCache> callbackList : remoteCallbackLists) { 950 synchronized (callbackList) { // Ensure only one active broadcast per RemoteCallbackList 951 final int count = callbackList.beginBroadcast(); 952 try { 953 for (int i = 0; i < count; i++) { 954 consumer.accept(callbackList.getBroadcastItem(i), 955 callbackList.getBroadcastCookie(i)); 956 } 957 } finally { 958 callbackList.finishBroadcast(); 959 } 960 } 961 } 962 } 963 964 @Nullable 965 private INetworkRecommendationProvider getRecommendationProvider() { 966 synchronized (mServiceConnectionLock) { 967 if (mServiceConnection != null) { 968 return mServiceConnection.getRecommendationProvider(); 969 } 970 } 971 return null; 972 } 973 974 // The class and methods need to be public for Mockito to work. 975 @VisibleForTesting 976 public static class ScoringServiceConnection implements ServiceConnection { 977 private final NetworkScorerAppData mAppData; 978 private volatile boolean mBound = false; 979 private volatile boolean mConnected = false; 980 private volatile INetworkRecommendationProvider mRecommendationProvider; 981 982 ScoringServiceConnection(NetworkScorerAppData appData) { 983 mAppData = appData; 984 } 985 986 @VisibleForTesting 987 public void bind(Context context) { 988 if (!mBound) { 989 Intent service = new Intent(NetworkScoreManager.ACTION_RECOMMEND_NETWORKS); 990 service.setComponent(mAppData.getRecommendationServiceComponent()); 991 mBound = context.bindServiceAsUser(service, this, 992 Context.BIND_AUTO_CREATE | Context.BIND_FOREGROUND_SERVICE, 993 UserHandle.SYSTEM); 994 if (!mBound) { 995 Log.w(TAG, "Bind call failed for " + service); 996 context.unbindService(this); 997 } else { 998 if (DBG) Log.d(TAG, "ScoringServiceConnection bound."); 999 } 1000 } 1001 } 1002 1003 @VisibleForTesting 1004 public void unbind(Context context) { 1005 try { 1006 if (mBound) { 1007 mBound = false; 1008 context.unbindService(this); 1009 if (DBG) Log.d(TAG, "ScoringServiceConnection unbound."); 1010 } 1011 } catch (RuntimeException e) { 1012 Log.e(TAG, "Unbind failed.", e); 1013 } 1014 1015 mConnected = false; 1016 mRecommendationProvider = null; 1017 } 1018 1019 @VisibleForTesting 1020 public NetworkScorerAppData getAppData() { 1021 return mAppData; 1022 } 1023 1024 @VisibleForTesting 1025 public INetworkRecommendationProvider getRecommendationProvider() { 1026 return mRecommendationProvider; 1027 } 1028 1029 @VisibleForTesting 1030 public String getPackageName() { 1031 return mAppData.getRecommendationServiceComponent().getPackageName(); 1032 } 1033 1034 @VisibleForTesting 1035 public boolean isAlive() { 1036 return mBound && mConnected; 1037 } 1038 1039 @Override 1040 public void onServiceConnected(ComponentName name, IBinder service) { 1041 if (DBG) Log.d(TAG, "ScoringServiceConnection: " + name.flattenToString()); 1042 mConnected = true; 1043 mRecommendationProvider = INetworkRecommendationProvider.Stub.asInterface(service); 1044 } 1045 1046 @Override 1047 public void onServiceDisconnected(ComponentName name) { 1048 if (DBG) { 1049 Log.d(TAG, "ScoringServiceConnection, disconnected: " + name.flattenToString()); 1050 } 1051 mConnected = false; 1052 mRecommendationProvider = null; 1053 } 1054 1055 public void dump(FileDescriptor fd, PrintWriter writer, String[] args) { 1056 writer.println("ScoringServiceConnection: " 1057 + mAppData.getRecommendationServiceComponent() 1058 + ", bound: " + mBound 1059 + ", connected: " + mConnected); 1060 } 1061 } 1062 1063 @VisibleForTesting 1064 public final class ServiceHandler extends Handler { 1065 public static final int MSG_RECOMMENDATIONS_PACKAGE_CHANGED = 1; 1066 public static final int MSG_RECOMMENDATION_ENABLED_SETTING_CHANGED = 2; 1067 1068 public ServiceHandler(Looper looper) { 1069 super(looper); 1070 } 1071 1072 @Override 1073 public void handleMessage(Message msg) { 1074 final int what = msg.what; 1075 switch (what) { 1076 case MSG_RECOMMENDATIONS_PACKAGE_CHANGED: 1077 case MSG_RECOMMENDATION_ENABLED_SETTING_CHANGED: 1078 refreshBinding(); 1079 break; 1080 1081 default: 1082 Log.w(TAG,"Unknown message: " + what); 1083 } 1084 } 1085 } 1086 } 1087
