1 /* 2 * Copyright (C) 2006 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.content; 18 19 import android.Manifest; 20 import android.accounts.Account; 21 import android.app.ActivityManager; 22 import android.content.ContentResolver; 23 import android.content.Context; 24 import android.content.IContentService; 25 import android.content.ISyncStatusObserver; 26 import android.content.PeriodicSync; 27 import android.content.SyncAdapterType; 28 import android.content.SyncInfo; 29 import android.content.SyncRequest; 30 import android.content.SyncStatusInfo; 31 import android.database.IContentObserver; 32 import android.database.sqlite.SQLiteException; 33 import android.net.Uri; 34 import android.os.Binder; 35 import android.os.Bundle; 36 import android.os.IBinder; 37 import android.os.Parcel; 38 import android.os.RemoteException; 39 import android.os.ServiceManager; 40 import android.os.SystemProperties; 41 import android.os.UserHandle; 42 import android.text.TextUtils; 43 import android.util.Log; 44 import android.util.Pair; 45 import android.util.Slog; 46 import android.util.SparseIntArray; 47 48 import java.io.FileDescriptor; 49 import java.io.PrintWriter; 50 import java.security.InvalidParameterException; 51 import java.util.ArrayList; 52 import java.util.Collections; 53 import java.util.Comparator; 54 import java.util.List; 55 56 /** 57 * {@hide} 58 */ 59 public final class ContentService extends IContentService.Stub { 60 private static final String TAG = "ContentService"; 61 private Context mContext; 62 private boolean mFactoryTest; 63 private final ObserverNode mRootNode = new ObserverNode(""); 64 private SyncManager mSyncManager = null; 65 private final Object mSyncManagerLock = new Object(); 66 67 private SyncManager getSyncManager() { 68 if (SystemProperties.getBoolean("config.disable_network", false)) { 69 return null; 70 } 71 72 synchronized(mSyncManagerLock) { 73 try { 74 // Try to create the SyncManager, return null if it fails (e.g. the disk is full). 75 if (mSyncManager == null) mSyncManager = new SyncManager(mContext, mFactoryTest); 76 } catch (SQLiteException e) { 77 Log.e(TAG, "Can't create SyncManager", e); 78 } 79 return mSyncManager; 80 } 81 } 82 83 @Override 84 protected synchronized void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 85 mContext.enforceCallingOrSelfPermission(Manifest.permission.DUMP, 86 "caller doesn't have the DUMP permission"); 87 88 // This makes it so that future permission checks will be in the context of this 89 // process rather than the caller's process. We will restore this before returning. 90 long identityToken = clearCallingIdentity(); 91 try { 92 if (mSyncManager == null) { 93 pw.println("No SyncManager created! (Disk full?)"); 94 } else { 95 mSyncManager.dump(fd, pw); 96 } 97 pw.println(); 98 pw.println("Observer tree:"); 99 synchronized (mRootNode) { 100 int[] counts = new int[2]; 101 final SparseIntArray pidCounts = new SparseIntArray(); 102 mRootNode.dumpLocked(fd, pw, args, "", " ", counts, pidCounts); 103 pw.println(); 104 ArrayList<Integer> sorted = new ArrayList<Integer>(); 105 for (int i=0; i<pidCounts.size(); i++) { 106 sorted.add(pidCounts.keyAt(i)); 107 } 108 Collections.sort(sorted, new Comparator<Integer>() { 109 @Override 110 public int compare(Integer lhs, Integer rhs) { 111 int lc = pidCounts.get(lhs); 112 int rc = pidCounts.get(rhs); 113 if (lc < rc) { 114 return 1; 115 } else if (lc > rc) { 116 return -1; 117 } 118 return 0; 119 } 120 121 }); 122 for (int i=0; i<sorted.size(); i++) { 123 int pid = sorted.get(i); 124 pw.print(" pid "); pw.print(pid); pw.print(": "); 125 pw.print(pidCounts.get(pid)); pw.println(" observers"); 126 } 127 pw.println(); 128 pw.print(" Total number of nodes: "); pw.println(counts[0]); 129 pw.print(" Total number of observers: "); pw.println(counts[1]); 130 } 131 } finally { 132 restoreCallingIdentity(identityToken); 133 } 134 } 135 136 @Override 137 public boolean onTransact(int code, Parcel data, Parcel reply, int flags) 138 throws RemoteException { 139 try { 140 return super.onTransact(code, data, reply, flags); 141 } catch (RuntimeException e) { 142 // The content service only throws security exceptions, so let's 143 // log all others. 144 if (!(e instanceof SecurityException)) { 145 Slog.wtf(TAG, "Content Service Crash", e); 146 } 147 throw e; 148 } 149 } 150 151 /*package*/ ContentService(Context context, boolean factoryTest) { 152 mContext = context; 153 mFactoryTest = factoryTest; 154 } 155 156 public void systemReady() { 157 getSyncManager(); 158 } 159 160 /** 161 * Register a content observer tied to a specific user's view of the provider. 162 * @param userHandle the user whose view of the provider is to be observed. May be 163 * the calling user without requiring any permission, otherwise the caller needs to 164 * hold the INTERACT_ACROSS_USERS_FULL permission. Pseudousers USER_ALL and 165 * USER_CURRENT are properly handled; all other pseudousers are forbidden. 166 */ 167 @Override 168 public void registerContentObserver(Uri uri, boolean notifyForDescendants, 169 IContentObserver observer, int userHandle) { 170 if (observer == null || uri == null) { 171 throw new IllegalArgumentException("You must pass a valid uri and observer"); 172 } 173 174 final int callingUser = UserHandle.getCallingUserId(); 175 if (callingUser != userHandle) { 176 mContext.enforceCallingOrSelfPermission(Manifest.permission.INTERACT_ACROSS_USERS_FULL, 177 "no permission to observe other users' provider view"); 178 } 179 180 if (userHandle < 0) { 181 if (userHandle == UserHandle.USER_CURRENT) { 182 userHandle = ActivityManager.getCurrentUser(); 183 } else if (userHandle != UserHandle.USER_ALL) { 184 throw new InvalidParameterException("Bad user handle for registerContentObserver: " 185 + userHandle); 186 } 187 } 188 189 synchronized (mRootNode) { 190 mRootNode.addObserverLocked(uri, observer, notifyForDescendants, mRootNode, 191 Binder.getCallingUid(), Binder.getCallingPid(), userHandle); 192 if (false) Log.v(TAG, "Registered observer " + observer + " at " + uri + 193 " with notifyForDescendants " + notifyForDescendants); 194 } 195 } 196 197 public void registerContentObserver(Uri uri, boolean notifyForDescendants, 198 IContentObserver observer) { 199 registerContentObserver(uri, notifyForDescendants, observer, 200 UserHandle.getCallingUserId()); 201 } 202 203 public void unregisterContentObserver(IContentObserver observer) { 204 if (observer == null) { 205 throw new IllegalArgumentException("You must pass a valid observer"); 206 } 207 synchronized (mRootNode) { 208 mRootNode.removeObserverLocked(observer); 209 if (false) Log.v(TAG, "Unregistered observer " + observer); 210 } 211 } 212 213 /** 214 * Notify observers of a particular user's view of the provider. 215 * @param userHandle the user whose view of the provider is to be notified. May be 216 * the calling user without requiring any permission, otherwise the caller needs to 217 * hold the INTERACT_ACROSS_USERS_FULL permission. Pseudousers USER_ALL and 218 * USER_CURRENT are properly interpreted; no other pseudousers are allowed. 219 */ 220 @Override 221 public void notifyChange(Uri uri, IContentObserver observer, 222 boolean observerWantsSelfNotifications, boolean syncToNetwork, 223 int userHandle) { 224 if (Log.isLoggable(TAG, Log.VERBOSE)) { 225 Log.v(TAG, "Notifying update of " + uri + " for user " + userHandle 226 + " from observer " + observer + ", syncToNetwork " + syncToNetwork); 227 } 228 229 // Notify for any user other than the caller's own requires permission. 230 final int callingUserHandle = UserHandle.getCallingUserId(); 231 if (userHandle != callingUserHandle) { 232 mContext.enforceCallingOrSelfPermission(Manifest.permission.INTERACT_ACROSS_USERS_FULL, 233 "no permission to notify other users"); 234 } 235 236 // We passed the permission check; resolve pseudouser targets as appropriate 237 if (userHandle < 0) { 238 if (userHandle == UserHandle.USER_CURRENT) { 239 userHandle = ActivityManager.getCurrentUser(); 240 } else if (userHandle != UserHandle.USER_ALL) { 241 throw new InvalidParameterException("Bad user handle for notifyChange: " 242 + userHandle); 243 } 244 } 245 246 final int uid = Binder.getCallingUid(); 247 // This makes it so that future permission checks will be in the context of this 248 // process rather than the caller's process. We will restore this before returning. 249 long identityToken = clearCallingIdentity(); 250 try { 251 ArrayList<ObserverCall> calls = new ArrayList<ObserverCall>(); 252 synchronized (mRootNode) { 253 mRootNode.collectObserversLocked(uri, 0, observer, observerWantsSelfNotifications, 254 userHandle, calls); 255 } 256 final int numCalls = calls.size(); 257 for (int i=0; i<numCalls; i++) { 258 ObserverCall oc = calls.get(i); 259 try { 260 oc.mObserver.onChange(oc.mSelfChange, uri); 261 if (Log.isLoggable(TAG, Log.VERBOSE)) { 262 Log.v(TAG, "Notified " + oc.mObserver + " of " + "update at " + uri); 263 } 264 } catch (RemoteException ex) { 265 synchronized (mRootNode) { 266 Log.w(TAG, "Found dead observer, removing"); 267 IBinder binder = oc.mObserver.asBinder(); 268 final ArrayList<ObserverNode.ObserverEntry> list 269 = oc.mNode.mObservers; 270 int numList = list.size(); 271 for (int j=0; j<numList; j++) { 272 ObserverNode.ObserverEntry oe = list.get(j); 273 if (oe.observer.asBinder() == binder) { 274 list.remove(j); 275 j--; 276 numList--; 277 } 278 } 279 } 280 } 281 } 282 if (syncToNetwork) { 283 SyncManager syncManager = getSyncManager(); 284 if (syncManager != null) { 285 syncManager.scheduleLocalSync(null /* all accounts */, callingUserHandle, uid, 286 uri.getAuthority()); 287 } 288 } 289 } finally { 290 restoreCallingIdentity(identityToken); 291 } 292 } 293 294 public void notifyChange(Uri uri, IContentObserver observer, 295 boolean observerWantsSelfNotifications, boolean syncToNetwork) { 296 notifyChange(uri, observer, observerWantsSelfNotifications, syncToNetwork, 297 UserHandle.getCallingUserId()); 298 } 299 300 /** 301 * Hide this class since it is not part of api, 302 * but current unittest framework requires it to be public 303 * @hide 304 * 305 */ 306 public static final class ObserverCall { 307 final ObserverNode mNode; 308 final IContentObserver mObserver; 309 final boolean mSelfChange; 310 311 ObserverCall(ObserverNode node, IContentObserver observer, boolean selfChange) { 312 mNode = node; 313 mObserver = observer; 314 mSelfChange = selfChange; 315 } 316 } 317 318 @Override 319 public void requestSync(Account account, String authority, Bundle extras) { 320 ContentResolver.validateSyncExtrasBundle(extras); 321 int userId = UserHandle.getCallingUserId(); 322 int uId = Binder.getCallingUid(); 323 324 // This makes it so that future permission checks will be in the context of this 325 // process rather than the caller's process. We will restore this before returning. 326 long identityToken = clearCallingIdentity(); 327 try { 328 SyncManager syncManager = getSyncManager(); 329 if (syncManager != null) { 330 syncManager.scheduleSync(account, userId, uId, authority, extras, 331 0 /* no delay */, 0 /* no delay */, 332 false /* onlyThoseWithUnkownSyncableState */); 333 } 334 } finally { 335 restoreCallingIdentity(identityToken); 336 } 337 } 338 339 /** 340 * Request a sync with a generic {@link android.content.SyncRequest} object. This will be 341 * either: 342 * periodic OR one-off sync. 343 * and 344 * anonymous OR provider sync. 345 * Depending on the request, we enqueue to suit in the SyncManager. 346 * @param request The request object. Validation of this object is done by its builder. 347 */ 348 @Override 349 public void sync(SyncRequest request) { 350 Bundle extras = request.getBundle(); 351 long flextime = request.getSyncFlexTime(); 352 long runAtTime = request.getSyncRunTime(); 353 int userId = UserHandle.getCallingUserId(); 354 int uId = Binder.getCallingUid(); 355 356 // This makes it so that future permission checks will be in the context of this 357 // process rather than the caller's process. We will restore this before returning. 358 long identityToken = clearCallingIdentity(); 359 try { 360 SyncManager syncManager = getSyncManager(); 361 if (syncManager != null) { 362 if (request.hasAuthority()) { 363 // Sync Adapter registered with the system - old API. 364 final Account account = request.getAccount(); 365 final String provider = request.getProvider(); 366 if (request.isPeriodic()) { 367 mContext.enforceCallingOrSelfPermission( 368 Manifest.permission.WRITE_SYNC_SETTINGS, 369 "no permission to write the sync settings"); 370 if (runAtTime < 60) { 371 Slog.w(TAG, "Requested poll frequency of " + runAtTime 372 + " seconds being rounded up to 60 seconds."); 373 runAtTime = 60; 374 } 375 PeriodicSync syncToAdd = 376 new PeriodicSync(account, provider, extras, runAtTime, flextime); 377 getSyncManager().getSyncStorageEngine().addPeriodicSync(syncToAdd, userId); 378 } else { 379 long beforeRuntimeMillis = (flextime) * 1000; 380 long runtimeMillis = runAtTime * 1000; 381 syncManager.scheduleSync( 382 account, userId, uId, provider, extras, 383 beforeRuntimeMillis, runtimeMillis, 384 false /* onlyThoseWithUnknownSyncableState */); 385 } 386 } else { 387 Log.w(TAG, "Unrecognised sync parameters, doing nothing."); 388 } 389 } 390 } finally { 391 restoreCallingIdentity(identityToken); 392 } 393 } 394 395 /** 396 * Clear all scheduled sync operations that match the uri and cancel the active sync 397 * if they match the authority and account, if they are present. 398 * @param account filter the pending and active syncs to cancel using this account 399 * @param authority filter the pending and active syncs to cancel using this authority 400 */ 401 @Override 402 public void cancelSync(Account account, String authority) { 403 if (authority != null && authority.length() == 0) { 404 throw new IllegalArgumentException("Authority must be non-empty"); 405 } 406 407 int userId = UserHandle.getCallingUserId(); 408 // This makes it so that future permission checks will be in the context of this 409 // process rather than the caller's process. We will restore this before returning. 410 long identityToken = clearCallingIdentity(); 411 try { 412 SyncManager syncManager = getSyncManager(); 413 if (syncManager != null) { 414 syncManager.clearScheduledSyncOperations(account, userId, authority); 415 syncManager.cancelActiveSync(account, userId, authority); 416 } 417 } finally { 418 restoreCallingIdentity(identityToken); 419 } 420 } 421 422 /** 423 * Get information about the SyncAdapters that are known to the system. 424 * @return an array of SyncAdapters that have registered with the system 425 */ 426 @Override 427 public SyncAdapterType[] getSyncAdapterTypes() { 428 // This makes it so that future permission checks will be in the context of this 429 // process rather than the caller's process. We will restore this before returning. 430 final int userId = UserHandle.getCallingUserId(); 431 final long identityToken = clearCallingIdentity(); 432 try { 433 SyncManager syncManager = getSyncManager(); 434 return syncManager.getSyncAdapterTypes(userId); 435 } finally { 436 restoreCallingIdentity(identityToken); 437 } 438 } 439 440 @Override 441 public boolean getSyncAutomatically(Account account, String providerName) { 442 mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS, 443 "no permission to read the sync settings"); 444 445 int userId = UserHandle.getCallingUserId(); 446 long identityToken = clearCallingIdentity(); 447 try { 448 SyncManager syncManager = getSyncManager(); 449 if (syncManager != null) { 450 return syncManager.getSyncStorageEngine().getSyncAutomatically( 451 account, userId, providerName); 452 } 453 } finally { 454 restoreCallingIdentity(identityToken); 455 } 456 return false; 457 } 458 459 @Override 460 public void setSyncAutomatically(Account account, String providerName, boolean sync) { 461 if (TextUtils.isEmpty(providerName)) { 462 throw new IllegalArgumentException("Authority must be non-empty"); 463 } 464 mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, 465 "no permission to write the sync settings"); 466 467 int userId = UserHandle.getCallingUserId(); 468 long identityToken = clearCallingIdentity(); 469 try { 470 SyncManager syncManager = getSyncManager(); 471 if (syncManager != null) { 472 syncManager.getSyncStorageEngine().setSyncAutomatically( 473 account, userId, providerName, sync); 474 } 475 } finally { 476 restoreCallingIdentity(identityToken); 477 } 478 } 479 480 /** Old API. Schedule periodic sync with default flex time. */ 481 @Override 482 public void addPeriodicSync(Account account, String authority, Bundle extras, 483 long pollFrequency) { 484 if (account == null) { 485 throw new IllegalArgumentException("Account must not be null"); 486 } 487 if (TextUtils.isEmpty(authority)) { 488 throw new IllegalArgumentException("Authority must not be empty."); 489 } 490 mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, 491 "no permission to write the sync settings"); 492 493 int userId = UserHandle.getCallingUserId(); 494 if (pollFrequency < 60) { 495 Slog.w(TAG, "Requested poll frequency of " + pollFrequency 496 + " seconds being rounded up to 60 seconds."); 497 pollFrequency = 60; 498 } 499 500 long identityToken = clearCallingIdentity(); 501 try { 502 // Add default flex time to this sync. 503 PeriodicSync syncToAdd = 504 new PeriodicSync(account, authority, extras, 505 pollFrequency, 506 SyncStorageEngine.calculateDefaultFlexTime(pollFrequency)); 507 getSyncManager().getSyncStorageEngine().addPeriodicSync(syncToAdd, userId); 508 } finally { 509 restoreCallingIdentity(identityToken); 510 } 511 } 512 513 @Override 514 public void removePeriodicSync(Account account, String authority, Bundle extras) { 515 if (account == null) { 516 throw new IllegalArgumentException("Account must not be null"); 517 } 518 if (TextUtils.isEmpty(authority)) { 519 throw new IllegalArgumentException("Authority must not be empty"); 520 } 521 mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, 522 "no permission to write the sync settings"); 523 524 int userId = UserHandle.getCallingUserId(); 525 long identityToken = clearCallingIdentity(); 526 try { 527 PeriodicSync syncToRemove = new PeriodicSync(account, authority, extras, 528 0 /* Not read for removal */, 0 /* Not read for removal */); 529 getSyncManager().getSyncStorageEngine().removePeriodicSync(syncToRemove, userId); 530 } finally { 531 restoreCallingIdentity(identityToken); 532 } 533 } 534 535 /** 536 * TODO: Implement. 537 * @param request Sync to remove. 538 */ 539 public void removeSync(SyncRequest request) { 540 541 } 542 543 @Override 544 public List<PeriodicSync> getPeriodicSyncs(Account account, String providerName) { 545 if (account == null) { 546 throw new IllegalArgumentException("Account must not be null"); 547 } 548 if (TextUtils.isEmpty(providerName)) { 549 throw new IllegalArgumentException("Authority must not be empty"); 550 } 551 mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS, 552 "no permission to read the sync settings"); 553 554 int userId = UserHandle.getCallingUserId(); 555 long identityToken = clearCallingIdentity(); 556 try { 557 return getSyncManager().getSyncStorageEngine().getPeriodicSyncs( 558 account, userId, providerName); 559 } finally { 560 restoreCallingIdentity(identityToken); 561 } 562 } 563 564 public int getIsSyncable(Account account, String providerName) { 565 mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS, 566 "no permission to read the sync settings"); 567 int userId = UserHandle.getCallingUserId(); 568 569 long identityToken = clearCallingIdentity(); 570 try { 571 SyncManager syncManager = getSyncManager(); 572 if (syncManager != null) { 573 return syncManager.getIsSyncable( 574 account, userId, providerName); 575 } 576 } finally { 577 restoreCallingIdentity(identityToken); 578 } 579 return -1; 580 } 581 582 @Override 583 public void setIsSyncable(Account account, String providerName, int syncable) { 584 if (TextUtils.isEmpty(providerName)) { 585 throw new IllegalArgumentException("Authority must not be empty"); 586 } 587 mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, 588 "no permission to write the sync settings"); 589 590 int userId = UserHandle.getCallingUserId(); 591 long identityToken = clearCallingIdentity(); 592 try { 593 SyncManager syncManager = getSyncManager(); 594 if (syncManager != null) { 595 syncManager.getSyncStorageEngine().setIsSyncable( 596 account, userId, providerName, syncable); 597 } 598 } finally { 599 restoreCallingIdentity(identityToken); 600 } 601 } 602 603 @Override 604 public boolean getMasterSyncAutomatically() { 605 mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_SETTINGS, 606 "no permission to read the sync settings"); 607 608 int userId = UserHandle.getCallingUserId(); 609 long identityToken = clearCallingIdentity(); 610 try { 611 SyncManager syncManager = getSyncManager(); 612 if (syncManager != null) { 613 return syncManager.getSyncStorageEngine().getMasterSyncAutomatically(userId); 614 } 615 } finally { 616 restoreCallingIdentity(identityToken); 617 } 618 return false; 619 } 620 621 @Override 622 public void setMasterSyncAutomatically(boolean flag) { 623 mContext.enforceCallingOrSelfPermission(Manifest.permission.WRITE_SYNC_SETTINGS, 624 "no permission to write the sync settings"); 625 626 int userId = UserHandle.getCallingUserId(); 627 long identityToken = clearCallingIdentity(); 628 try { 629 SyncManager syncManager = getSyncManager(); 630 if (syncManager != null) { 631 syncManager.getSyncStorageEngine().setMasterSyncAutomatically(flag, userId); 632 } 633 } finally { 634 restoreCallingIdentity(identityToken); 635 } 636 } 637 638 public boolean isSyncActive(Account account, String authority) { 639 mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS, 640 "no permission to read the sync stats"); 641 int userId = UserHandle.getCallingUserId(); 642 643 long identityToken = clearCallingIdentity(); 644 try { 645 SyncManager syncManager = getSyncManager(); 646 if (syncManager != null) { 647 return syncManager.getSyncStorageEngine().isSyncActive( 648 account, userId, authority); 649 } 650 } finally { 651 restoreCallingIdentity(identityToken); 652 } 653 return false; 654 } 655 656 public List<SyncInfo> getCurrentSyncs() { 657 mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS, 658 "no permission to read the sync stats"); 659 660 int userId = UserHandle.getCallingUserId(); 661 long identityToken = clearCallingIdentity(); 662 try { 663 return getSyncManager().getSyncStorageEngine().getCurrentSyncsCopy(userId); 664 } finally { 665 restoreCallingIdentity(identityToken); 666 } 667 } 668 669 public SyncStatusInfo getSyncStatus(Account account, String authority) { 670 if (TextUtils.isEmpty(authority)) { 671 throw new IllegalArgumentException("Authority must not be empty"); 672 } 673 mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS, 674 "no permission to read the sync stats"); 675 676 int userId = UserHandle.getCallingUserId(); 677 long identityToken = clearCallingIdentity(); 678 try { 679 SyncManager syncManager = getSyncManager(); 680 if (syncManager != null) { 681 return syncManager.getSyncStorageEngine().getStatusByAccountAndAuthority( 682 account, userId, authority); 683 } 684 } finally { 685 restoreCallingIdentity(identityToken); 686 } 687 return null; 688 } 689 690 public boolean isSyncPending(Account account, String authority) { 691 mContext.enforceCallingOrSelfPermission(Manifest.permission.READ_SYNC_STATS, 692 "no permission to read the sync stats"); 693 694 int userId = UserHandle.getCallingUserId(); 695 long identityToken = clearCallingIdentity(); 696 try { 697 SyncManager syncManager = getSyncManager(); 698 if (syncManager != null) { 699 return syncManager.getSyncStorageEngine().isSyncPending(account, userId, authority); 700 } 701 } finally { 702 restoreCallingIdentity(identityToken); 703 } 704 return false; 705 } 706 707 public void addStatusChangeListener(int mask, ISyncStatusObserver callback) { 708 long identityToken = clearCallingIdentity(); 709 try { 710 SyncManager syncManager = getSyncManager(); 711 if (syncManager != null && callback != null) { 712 syncManager.getSyncStorageEngine().addStatusChangeListener(mask, callback); 713 } 714 } finally { 715 restoreCallingIdentity(identityToken); 716 } 717 } 718 719 public void removeStatusChangeListener(ISyncStatusObserver callback) { 720 long identityToken = clearCallingIdentity(); 721 try { 722 SyncManager syncManager = getSyncManager(); 723 if (syncManager != null && callback != null) { 724 syncManager.getSyncStorageEngine().removeStatusChangeListener(callback); 725 } 726 } finally { 727 restoreCallingIdentity(identityToken); 728 } 729 } 730 731 public static ContentService main(Context context, boolean factoryTest) { 732 ContentService service = new ContentService(context, factoryTest); 733 ServiceManager.addService(ContentResolver.CONTENT_SERVICE_NAME, service); 734 return service; 735 } 736 737 /** 738 * Hide this class since it is not part of api, 739 * but current unittest framework requires it to be public 740 * @hide 741 */ 742 public static final class ObserverNode { 743 private class ObserverEntry implements IBinder.DeathRecipient { 744 public final IContentObserver observer; 745 public final int uid; 746 public final int pid; 747 public final boolean notifyForDescendants; 748 private final int userHandle; 749 private final Object observersLock; 750 751 public ObserverEntry(IContentObserver o, boolean n, Object observersLock, 752 int _uid, int _pid, int _userHandle) { 753 this.observersLock = observersLock; 754 observer = o; 755 uid = _uid; 756 pid = _pid; 757 userHandle = _userHandle; 758 notifyForDescendants = n; 759 try { 760 observer.asBinder().linkToDeath(this, 0); 761 } catch (RemoteException e) { 762 binderDied(); 763 } 764 } 765 766 public void binderDied() { 767 synchronized (observersLock) { 768 removeObserverLocked(observer); 769 } 770 } 771 772 public void dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args, 773 String name, String prefix, SparseIntArray pidCounts) { 774 pidCounts.put(pid, pidCounts.get(pid)+1); 775 pw.print(prefix); pw.print(name); pw.print(": pid="); 776 pw.print(pid); pw.print(" uid="); 777 pw.print(uid); pw.print(" user="); 778 pw.print(userHandle); pw.print(" target="); 779 pw.println(Integer.toHexString(System.identityHashCode( 780 observer != null ? observer.asBinder() : null))); 781 } 782 } 783 784 public static final int INSERT_TYPE = 0; 785 public static final int UPDATE_TYPE = 1; 786 public static final int DELETE_TYPE = 2; 787 788 private String mName; 789 private ArrayList<ObserverNode> mChildren = new ArrayList<ObserverNode>(); 790 private ArrayList<ObserverEntry> mObservers = new ArrayList<ObserverEntry>(); 791 792 public ObserverNode(String name) { 793 mName = name; 794 } 795 796 public void dumpLocked(FileDescriptor fd, PrintWriter pw, String[] args, 797 String name, String prefix, int[] counts, SparseIntArray pidCounts) { 798 String innerName = null; 799 if (mObservers.size() > 0) { 800 if ("".equals(name)) { 801 innerName = mName; 802 } else { 803 innerName = name + "/" + mName; 804 } 805 for (int i=0; i<mObservers.size(); i++) { 806 counts[1]++; 807 mObservers.get(i).dumpLocked(fd, pw, args, innerName, prefix, 808 pidCounts); 809 } 810 } 811 if (mChildren.size() > 0) { 812 if (innerName == null) { 813 if ("".equals(name)) { 814 innerName = mName; 815 } else { 816 innerName = name + "/" + mName; 817 } 818 } 819 for (int i=0; i<mChildren.size(); i++) { 820 counts[0]++; 821 mChildren.get(i).dumpLocked(fd, pw, args, innerName, prefix, 822 counts, pidCounts); 823 } 824 } 825 } 826 827 private String getUriSegment(Uri uri, int index) { 828 if (uri != null) { 829 if (index == 0) { 830 return uri.getAuthority(); 831 } else { 832 return uri.getPathSegments().get(index - 1); 833 } 834 } else { 835 return null; 836 } 837 } 838 839 private int countUriSegments(Uri uri) { 840 if (uri == null) { 841 return 0; 842 } 843 return uri.getPathSegments().size() + 1; 844 } 845 846 // Invariant: userHandle is either a hard user number or is USER_ALL 847 public void addObserverLocked(Uri uri, IContentObserver observer, 848 boolean notifyForDescendants, Object observersLock, 849 int uid, int pid, int userHandle) { 850 addObserverLocked(uri, 0, observer, notifyForDescendants, observersLock, 851 uid, pid, userHandle); 852 } 853 854 private void addObserverLocked(Uri uri, int index, IContentObserver observer, 855 boolean notifyForDescendants, Object observersLock, 856 int uid, int pid, int userHandle) { 857 // If this is the leaf node add the observer 858 if (index == countUriSegments(uri)) { 859 mObservers.add(new ObserverEntry(observer, notifyForDescendants, observersLock, 860 uid, pid, userHandle)); 861 return; 862 } 863 864 // Look to see if the proper child already exists 865 String segment = getUriSegment(uri, index); 866 if (segment == null) { 867 throw new IllegalArgumentException("Invalid Uri (" + uri + ") used for observer"); 868 } 869 int N = mChildren.size(); 870 for (int i = 0; i < N; i++) { 871 ObserverNode node = mChildren.get(i); 872 if (node.mName.equals(segment)) { 873 node.addObserverLocked(uri, index + 1, observer, notifyForDescendants, 874 observersLock, uid, pid, userHandle); 875 return; 876 } 877 } 878 879 // No child found, create one 880 ObserverNode node = new ObserverNode(segment); 881 mChildren.add(node); 882 node.addObserverLocked(uri, index + 1, observer, notifyForDescendants, 883 observersLock, uid, pid, userHandle); 884 } 885 886 public boolean removeObserverLocked(IContentObserver observer) { 887 int size = mChildren.size(); 888 for (int i = 0; i < size; i++) { 889 boolean empty = mChildren.get(i).removeObserverLocked(observer); 890 if (empty) { 891 mChildren.remove(i); 892 i--; 893 size--; 894 } 895 } 896 897 IBinder observerBinder = observer.asBinder(); 898 size = mObservers.size(); 899 for (int i = 0; i < size; i++) { 900 ObserverEntry entry = mObservers.get(i); 901 if (entry.observer.asBinder() == observerBinder) { 902 mObservers.remove(i); 903 // We no longer need to listen for death notifications. Remove it. 904 observerBinder.unlinkToDeath(entry, 0); 905 break; 906 } 907 } 908 909 if (mChildren.size() == 0 && mObservers.size() == 0) { 910 return true; 911 } 912 return false; 913 } 914 915 private void collectMyObserversLocked(boolean leaf, IContentObserver observer, 916 boolean observerWantsSelfNotifications, int targetUserHandle, 917 ArrayList<ObserverCall> calls) { 918 int N = mObservers.size(); 919 IBinder observerBinder = observer == null ? null : observer.asBinder(); 920 for (int i = 0; i < N; i++) { 921 ObserverEntry entry = mObservers.get(i); 922 923 // Don't notify the observer if it sent the notification and isn't interested 924 // in self notifications 925 boolean selfChange = (entry.observer.asBinder() == observerBinder); 926 if (selfChange && !observerWantsSelfNotifications) { 927 continue; 928 } 929 930 // Does this observer match the target user? 931 if (targetUserHandle == UserHandle.USER_ALL 932 || entry.userHandle == UserHandle.USER_ALL 933 || targetUserHandle == entry.userHandle) { 934 // Make sure the observer is interested in the notification 935 if (leaf || (!leaf && entry.notifyForDescendants)) { 936 calls.add(new ObserverCall(this, entry.observer, selfChange)); 937 } 938 } 939 } 940 } 941 942 /** 943 * targetUserHandle is either a hard user handle or is USER_ALL 944 */ 945 public void collectObserversLocked(Uri uri, int index, IContentObserver observer, 946 boolean observerWantsSelfNotifications, int targetUserHandle, 947 ArrayList<ObserverCall> calls) { 948 String segment = null; 949 int segmentCount = countUriSegments(uri); 950 if (index >= segmentCount) { 951 // This is the leaf node, notify all observers 952 collectMyObserversLocked(true, observer, observerWantsSelfNotifications, 953 targetUserHandle, calls); 954 } else if (index < segmentCount){ 955 segment = getUriSegment(uri, index); 956 // Notify any observers at this level who are interested in descendants 957 collectMyObserversLocked(false, observer, observerWantsSelfNotifications, 958 targetUserHandle, calls); 959 } 960 961 int N = mChildren.size(); 962 for (int i = 0; i < N; i++) { 963 ObserverNode node = mChildren.get(i); 964 if (segment == null || node.mName.equals(segment)) { 965 // We found the child, 966 node.collectObserversLocked(uri, index + 1, 967 observer, observerWantsSelfNotifications, targetUserHandle, calls); 968 if (segment != null) { 969 break; 970 } 971 } 972 } 973 } 974 } 975 } 976
