1 /* 2 * Copyright (C) 2013 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.print; 18 19 import static android.content.pm.PackageManager.GET_META_DATA; 20 import static android.content.pm.PackageManager.GET_SERVICES; 21 import static android.content.pm.PackageManager.MATCH_DEBUG_TRIAGED_MISSING; 22 import static android.content.pm.PackageManager.MATCH_INSTANT; 23 24 import static com.android.internal.print.DumpUtils.writePrintJobInfo; 25 import static com.android.internal.print.DumpUtils.writePrinterId; 26 import static com.android.internal.print.DumpUtils.writePrinterInfo; 27 import static com.android.internal.util.dump.DumpUtils.writeComponentName; 28 import static com.android.internal.util.dump.DumpUtils.writeStringIfNotNull; 29 import static com.android.internal.util.function.pooled.PooledLambda.obtainMessage; 30 31 import android.annotation.NonNull; 32 import android.annotation.Nullable; 33 import android.app.PendingIntent; 34 import android.content.ComponentName; 35 import android.content.Context; 36 import android.content.Intent; 37 import android.content.IntentSender; 38 import android.content.pm.ParceledListSlice; 39 import android.content.pm.ResolveInfo; 40 import android.graphics.drawable.Icon; 41 import android.net.Uri; 42 import android.os.Binder; 43 import android.os.Bundle; 44 import android.os.Handler; 45 import android.os.IBinder; 46 import android.os.IBinder.DeathRecipient; 47 import android.os.IInterface; 48 import android.os.Looper; 49 import android.os.RemoteCallbackList; 50 import android.os.RemoteException; 51 import android.os.UserHandle; 52 import android.print.IPrintDocumentAdapter; 53 import android.print.IPrintJobStateChangeListener; 54 import android.print.IPrintServicesChangeListener; 55 import android.print.IPrinterDiscoveryObserver; 56 import android.print.PrintAttributes; 57 import android.print.PrintJobId; 58 import android.print.PrintJobInfo; 59 import android.print.PrintManager; 60 import android.print.PrinterId; 61 import android.print.PrinterInfo; 62 import android.printservice.PrintServiceInfo; 63 import android.printservice.recommendation.IRecommendationsChangeListener; 64 import android.printservice.recommendation.RecommendationInfo; 65 import android.provider.DocumentsContract; 66 import android.provider.Settings; 67 import android.service.print.CachedPrintJobProto; 68 import android.service.print.InstalledPrintServiceProto; 69 import android.service.print.PrintUserStateProto; 70 import android.service.print.PrinterDiscoverySessionProto; 71 import android.text.TextUtils; 72 import android.text.TextUtils.SimpleStringSplitter; 73 import android.util.ArrayMap; 74 import android.util.ArraySet; 75 import android.util.Log; 76 import android.util.Slog; 77 import android.util.SparseArray; 78 79 import com.android.internal.R; 80 import com.android.internal.logging.MetricsLogger; 81 import com.android.internal.logging.nano.MetricsProto.MetricsEvent; 82 import com.android.internal.os.BackgroundThread; 83 import com.android.internal.util.dump.DualDumpOutputStream; 84 import com.android.internal.util.function.pooled.PooledLambda; 85 import com.android.server.print.RemotePrintService.PrintServiceCallbacks; 86 import com.android.server.print.RemotePrintServiceRecommendationService 87 .RemotePrintServiceRecommendationServiceCallbacks; 88 import com.android.server.print.RemotePrintSpooler.PrintSpoolerCallbacks; 89 90 import java.util.ArrayList; 91 import java.util.Collections; 92 import java.util.HashSet; 93 import java.util.Iterator; 94 import java.util.List; 95 import java.util.Map; 96 import java.util.Set; 97 import java.util.function.IntSupplier; 98 99 /** 100 * Represents the print state for a user. 101 */ 102 final class UserState implements PrintSpoolerCallbacks, PrintServiceCallbacks, 103 RemotePrintServiceRecommendationServiceCallbacks { 104 105 private static final String LOG_TAG = "UserState"; 106 107 private static final boolean DEBUG = false; 108 109 private static final char COMPONENT_NAME_SEPARATOR = ':'; 110 111 private static final int SERVICE_RESTART_DELAY_MILLIS = 500; 112 113 private final SimpleStringSplitter mStringColonSplitter = 114 new SimpleStringSplitter(COMPONENT_NAME_SEPARATOR); 115 116 private final Intent mQueryIntent = 117 new Intent(android.printservice.PrintService.SERVICE_INTERFACE); 118 119 private final ArrayMap<ComponentName, RemotePrintService> mActiveServices = 120 new ArrayMap<ComponentName, RemotePrintService>(); 121 122 private final List<PrintServiceInfo> mInstalledServices = 123 new ArrayList<PrintServiceInfo>(); 124 125 private final Set<ComponentName> mDisabledServices = 126 new ArraySet<ComponentName>(); 127 128 private final PrintJobForAppCache mPrintJobForAppCache = 129 new PrintJobForAppCache(); 130 131 private final Object mLock; 132 133 private final Context mContext; 134 135 private final int mUserId; 136 137 private final RemotePrintSpooler mSpooler; 138 139 private PrinterDiscoverySessionMediator mPrinterDiscoverySession; 140 141 private List<PrintJobStateChangeListenerRecord> mPrintJobStateChangeListenerRecords; 142 143 private List<ListenerRecord<IPrintServicesChangeListener>> mPrintServicesChangeListenerRecords; 144 145 private List<ListenerRecord<IRecommendationsChangeListener>> 146 mPrintServiceRecommendationsChangeListenerRecords; 147 148 private boolean mDestroyed; 149 150 /** Currently known list of print service recommendations */ 151 private List<RecommendationInfo> mPrintServiceRecommendations; 152 153 /** 154 * Connection to the service updating the {@link #mPrintServiceRecommendations print service 155 * recommendations}. 156 */ 157 private RemotePrintServiceRecommendationService mPrintServiceRecommendationsService; 158 159 /** 160 * Can services from instant apps be bound? (usually disabled, only used by testing) 161 */ 162 private boolean mIsInstantServiceAllowed; 163 164 public UserState(Context context, int userId, Object lock, boolean lowPriority) { 165 mContext = context; 166 mUserId = userId; 167 mLock = lock; 168 mSpooler = new RemotePrintSpooler(context, userId, lowPriority, this); 169 170 synchronized (mLock) { 171 readInstalledPrintServicesLocked(); 172 upgradePersistentStateIfNeeded(); 173 readDisabledPrintServicesLocked(); 174 } 175 176 // Some print services might have gotten installed before the User State came up 177 prunePrintServices(); 178 179 onConfigurationChanged(); 180 } 181 182 public void increasePriority() { 183 mSpooler.increasePriority(); 184 } 185 186 @Override 187 public void onPrintJobQueued(PrintJobInfo printJob) { 188 final RemotePrintService service; 189 synchronized (mLock) { 190 throwIfDestroyedLocked(); 191 ComponentName printServiceName = printJob.getPrinterId().getServiceName(); 192 service = mActiveServices.get(printServiceName); 193 } 194 if (service != null) { 195 service.onPrintJobQueued(printJob); 196 } else { 197 // The service for the job is no longer enabled, so just 198 // fail the job with the appropriate message. 199 mSpooler.setPrintJobState(printJob.getId(), PrintJobInfo.STATE_FAILED, 200 mContext.getString(R.string.reason_service_unavailable)); 201 } 202 } 203 204 @Override 205 public void onAllPrintJobsForServiceHandled(ComponentName printService) { 206 final RemotePrintService service; 207 synchronized (mLock) { 208 throwIfDestroyedLocked(); 209 service = mActiveServices.get(printService); 210 } 211 if (service != null) { 212 service.onAllPrintJobsHandled(); 213 } 214 } 215 216 public void removeObsoletePrintJobs() { 217 mSpooler.removeObsoletePrintJobs(); 218 } 219 220 @SuppressWarnings("deprecation") 221 public Bundle print(@NonNull String printJobName, @NonNull IPrintDocumentAdapter adapter, 222 @Nullable PrintAttributes attributes, @NonNull String packageName, int appId) { 223 // Create print job place holder. 224 final PrintJobInfo printJob = new PrintJobInfo(); 225 printJob.setId(new PrintJobId()); 226 printJob.setAppId(appId); 227 printJob.setLabel(printJobName); 228 printJob.setAttributes(attributes); 229 printJob.setState(PrintJobInfo.STATE_CREATED); 230 printJob.setCopies(1); 231 printJob.setCreationTime(System.currentTimeMillis()); 232 233 // Track this job so we can forget it when the creator dies. 234 if (!mPrintJobForAppCache.onPrintJobCreated(adapter.asBinder(), appId, 235 printJob)) { 236 // Not adding a print job means the client is dead - done. 237 return null; 238 } 239 240 final long identity = Binder.clearCallingIdentity(); 241 try { 242 Intent intent = new Intent(PrintManager.ACTION_PRINT_DIALOG); 243 intent.setData(Uri.fromParts("printjob", printJob.getId().flattenToString(), null)); 244 intent.putExtra(PrintManager.EXTRA_PRINT_DOCUMENT_ADAPTER, adapter.asBinder()); 245 intent.putExtra(PrintManager.EXTRA_PRINT_JOB, printJob); 246 intent.putExtra(DocumentsContract.EXTRA_PACKAGE_NAME, packageName); 247 248 IntentSender intentSender = PendingIntent.getActivityAsUser( 249 mContext, 0, intent, PendingIntent.FLAG_ONE_SHOT 250 | PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_IMMUTABLE, 251 null, new UserHandle(mUserId)) .getIntentSender(); 252 253 Bundle result = new Bundle(); 254 result.putParcelable(PrintManager.EXTRA_PRINT_JOB, printJob); 255 result.putParcelable(PrintManager.EXTRA_PRINT_DIALOG_INTENT, intentSender); 256 257 return result; 258 } finally { 259 Binder.restoreCallingIdentity(identity); 260 } 261 } 262 263 public List<PrintJobInfo> getPrintJobInfos(int appId) { 264 List<PrintJobInfo> cachedPrintJobs = mPrintJobForAppCache.getPrintJobs(appId); 265 // Note that the print spooler is not storing print jobs that 266 // are in a terminal state as it is non-trivial to properly update 267 // the spooler state for when to forget print jobs in terminal state. 268 // Therefore, we fuse the cached print jobs for running apps (some 269 // jobs are in a terminal state) with the ones that the print 270 // spooler knows about (some jobs are being processed). 271 ArrayMap<PrintJobId, PrintJobInfo> result = 272 new ArrayMap<PrintJobId, PrintJobInfo>(); 273 274 // Add the cached print jobs for running apps. 275 final int cachedPrintJobCount = cachedPrintJobs.size(); 276 for (int i = 0; i < cachedPrintJobCount; i++) { 277 PrintJobInfo cachedPrintJob = cachedPrintJobs.get(i); 278 result.put(cachedPrintJob.getId(), cachedPrintJob); 279 // Strip out the tag and the advanced print options. 280 // They are visible only to print services. 281 cachedPrintJob.setTag(null); 282 cachedPrintJob.setAdvancedOptions(null); 283 } 284 285 // Add everything else the spooler knows about. 286 List<PrintJobInfo> printJobs = mSpooler.getPrintJobInfos(null, 287 PrintJobInfo.STATE_ANY, appId); 288 if (printJobs != null) { 289 final int printJobCount = printJobs.size(); 290 for (int i = 0; i < printJobCount; i++) { 291 PrintJobInfo printJob = printJobs.get(i); 292 result.put(printJob.getId(), printJob); 293 // Strip out the tag and the advanced print options. 294 // They are visible only to print services. 295 printJob.setTag(null); 296 printJob.setAdvancedOptions(null); 297 } 298 } 299 300 return new ArrayList<PrintJobInfo>(result.values()); 301 } 302 303 public PrintJobInfo getPrintJobInfo(@NonNull PrintJobId printJobId, int appId) { 304 PrintJobInfo printJob = mPrintJobForAppCache.getPrintJob(printJobId, appId); 305 if (printJob == null) { 306 printJob = mSpooler.getPrintJobInfo(printJobId, appId); 307 } 308 if (printJob != null) { 309 // Strip out the tag and the advanced print options. 310 // They are visible only to print services. 311 printJob.setTag(null); 312 printJob.setAdvancedOptions(null); 313 } 314 return printJob; 315 } 316 317 /** 318 * Get the custom icon for a printer. If the icon is not cached, the icon is 319 * requested asynchronously. Once it is available the printer is updated. 320 * 321 * @param printerId the id of the printer the icon should be loaded for 322 * @return the custom icon to be used for the printer or null if the icon is 323 * not yet available 324 * @see android.print.PrinterInfo.Builder#setHasCustomPrinterIcon 325 */ 326 public @Nullable Icon getCustomPrinterIcon(@NonNull PrinterId printerId) { 327 Icon icon = mSpooler.getCustomPrinterIcon(printerId); 328 329 if (icon == null) { 330 RemotePrintService service = mActiveServices.get(printerId.getServiceName()); 331 if (service != null) { 332 service.requestCustomPrinterIcon(printerId); 333 } 334 } 335 336 return icon; 337 } 338 339 public void cancelPrintJob(@NonNull PrintJobId printJobId, int appId) { 340 PrintJobInfo printJobInfo = mSpooler.getPrintJobInfo(printJobId, appId); 341 if (printJobInfo == null) { 342 return; 343 } 344 345 // Take a note that we are trying to cancel the job. 346 mSpooler.setPrintJobCancelling(printJobId, true); 347 348 if (printJobInfo.getState() != PrintJobInfo.STATE_FAILED) { 349 PrinterId printerId = printJobInfo.getPrinterId(); 350 351 if (printerId != null) { 352 ComponentName printServiceName = printerId.getServiceName(); 353 RemotePrintService printService = null; 354 synchronized (mLock) { 355 printService = mActiveServices.get(printServiceName); 356 } 357 if (printService == null) { 358 return; 359 } 360 printService.onRequestCancelPrintJob(printJobInfo); 361 } 362 } else { 363 // If the print job is failed we do not need cooperation 364 // from the print service. 365 mSpooler.setPrintJobState(printJobId, PrintJobInfo.STATE_CANCELED, null); 366 } 367 } 368 369 public void restartPrintJob(@NonNull PrintJobId printJobId, int appId) { 370 PrintJobInfo printJobInfo = getPrintJobInfo(printJobId, appId); 371 if (printJobInfo == null || printJobInfo.getState() != PrintJobInfo.STATE_FAILED) { 372 return; 373 } 374 mSpooler.setPrintJobState(printJobId, PrintJobInfo.STATE_QUEUED, null); 375 } 376 377 public @Nullable List<PrintServiceInfo> getPrintServices(int selectionFlags) { 378 synchronized (mLock) { 379 List<PrintServiceInfo> selectedServices = null; 380 final int installedServiceCount = mInstalledServices.size(); 381 for (int i = 0; i < installedServiceCount; i++) { 382 PrintServiceInfo installedService = mInstalledServices.get(i); 383 384 ComponentName componentName = new ComponentName( 385 installedService.getResolveInfo().serviceInfo.packageName, 386 installedService.getResolveInfo().serviceInfo.name); 387 388 // Update isEnabled under the same lock the final returned list is created 389 installedService.setIsEnabled(mActiveServices.containsKey(componentName)); 390 391 if (installedService.isEnabled()) { 392 if ((selectionFlags & PrintManager.ENABLED_SERVICES) == 0) { 393 continue; 394 } 395 } else { 396 if ((selectionFlags & PrintManager.DISABLED_SERVICES) == 0) { 397 continue; 398 } 399 } 400 401 if (selectedServices == null) { 402 selectedServices = new ArrayList<>(); 403 } 404 selectedServices.add(installedService); 405 } 406 return selectedServices; 407 } 408 } 409 410 public void setPrintServiceEnabled(@NonNull ComponentName serviceName, boolean isEnabled) { 411 synchronized (mLock) { 412 boolean isChanged = false; 413 if (isEnabled) { 414 isChanged = mDisabledServices.remove(serviceName); 415 } else { 416 // Make sure to only disable services that are currently installed 417 final int numServices = mInstalledServices.size(); 418 for (int i = 0; i < numServices; i++) { 419 PrintServiceInfo service = mInstalledServices.get(i); 420 421 if (service.getComponentName().equals(serviceName)) { 422 mDisabledServices.add(serviceName); 423 isChanged = true; 424 break; 425 } 426 } 427 } 428 429 if (isChanged) { 430 writeDisabledPrintServicesLocked(mDisabledServices); 431 432 MetricsLogger.action(mContext, MetricsEvent.ACTION_PRINT_SERVICE_TOGGLE, 433 isEnabled ? 0 : 1); 434 435 onConfigurationChangedLocked(); 436 } 437 } 438 } 439 440 /** 441 * @return The currently known print service recommendations 442 */ 443 public @Nullable List<RecommendationInfo> getPrintServiceRecommendations() { 444 return mPrintServiceRecommendations; 445 } 446 447 public void createPrinterDiscoverySession(@NonNull IPrinterDiscoveryObserver observer) { 448 mSpooler.clearCustomPrinterIconCache(); 449 450 synchronized (mLock) { 451 throwIfDestroyedLocked(); 452 453 if (mPrinterDiscoverySession == null) { 454 // If we do not have a session, tell all service to create one. 455 mPrinterDiscoverySession = new PrinterDiscoverySessionMediator() { 456 @Override 457 public void onDestroyed() { 458 mPrinterDiscoverySession = null; 459 } 460 }; 461 // Add the observer to the brand new session. 462 mPrinterDiscoverySession.addObserverLocked(observer); 463 } else { 464 // If services have created session, just add the observer. 465 mPrinterDiscoverySession.addObserverLocked(observer); 466 } 467 } 468 } 469 470 public void destroyPrinterDiscoverySession(@NonNull IPrinterDiscoveryObserver observer) { 471 synchronized (mLock) { 472 // Already destroyed - nothing to do. 473 if (mPrinterDiscoverySession == null) { 474 return; 475 } 476 // Remove this observer. 477 mPrinterDiscoverySession.removeObserverLocked(observer); 478 } 479 } 480 481 public void startPrinterDiscovery(@NonNull IPrinterDiscoveryObserver observer, 482 @Nullable List<PrinterId> printerIds) { 483 synchronized (mLock) { 484 throwIfDestroyedLocked(); 485 486 // No session - nothing to do. 487 if (mPrinterDiscoverySession == null) { 488 return; 489 } 490 // Kick of discovery. 491 mPrinterDiscoverySession.startPrinterDiscoveryLocked(observer, 492 printerIds); 493 } 494 } 495 496 public void stopPrinterDiscovery(@NonNull IPrinterDiscoveryObserver observer) { 497 synchronized (mLock) { 498 throwIfDestroyedLocked(); 499 500 // No session - nothing to do. 501 if (mPrinterDiscoverySession == null) { 502 return; 503 } 504 // Kick of discovery. 505 mPrinterDiscoverySession.stopPrinterDiscoveryLocked(observer); 506 } 507 } 508 509 public void validatePrinters(@NonNull List<PrinterId> printerIds) { 510 synchronized (mLock) { 511 throwIfDestroyedLocked(); 512 // No services - nothing to do. 513 if (mActiveServices.isEmpty()) { 514 return; 515 } 516 // No session - nothing to do. 517 if (mPrinterDiscoverySession == null) { 518 return; 519 } 520 // Request an updated. 521 mPrinterDiscoverySession.validatePrintersLocked(printerIds); 522 } 523 } 524 525 public void startPrinterStateTracking(@NonNull PrinterId printerId) { 526 synchronized (mLock) { 527 throwIfDestroyedLocked(); 528 // No services - nothing to do. 529 if (mActiveServices.isEmpty()) { 530 return; 531 } 532 // No session - nothing to do. 533 if (mPrinterDiscoverySession == null) { 534 return; 535 } 536 // Request start tracking the printer. 537 mPrinterDiscoverySession.startPrinterStateTrackingLocked(printerId); 538 } 539 } 540 541 public void stopPrinterStateTracking(PrinterId printerId) { 542 synchronized (mLock) { 543 throwIfDestroyedLocked(); 544 // No services - nothing to do. 545 if (mActiveServices.isEmpty()) { 546 return; 547 } 548 // No session - nothing to do. 549 if (mPrinterDiscoverySession == null) { 550 return; 551 } 552 // Request stop tracking the printer. 553 mPrinterDiscoverySession.stopPrinterStateTrackingLocked(printerId); 554 } 555 } 556 557 public void addPrintJobStateChangeListener(@NonNull IPrintJobStateChangeListener listener, 558 int appId) throws RemoteException { 559 synchronized (mLock) { 560 throwIfDestroyedLocked(); 561 if (mPrintJobStateChangeListenerRecords == null) { 562 mPrintJobStateChangeListenerRecords = 563 new ArrayList<PrintJobStateChangeListenerRecord>(); 564 } 565 mPrintJobStateChangeListenerRecords.add( 566 new PrintJobStateChangeListenerRecord(listener, appId) { 567 @Override 568 public void onBinderDied() { 569 synchronized (mLock) { 570 if (mPrintJobStateChangeListenerRecords != null) { 571 mPrintJobStateChangeListenerRecords.remove(this); 572 } 573 } 574 } 575 }); 576 } 577 } 578 579 public void removePrintJobStateChangeListener(@NonNull IPrintJobStateChangeListener listener) { 580 synchronized (mLock) { 581 throwIfDestroyedLocked(); 582 if (mPrintJobStateChangeListenerRecords == null) { 583 return; 584 } 585 final int recordCount = mPrintJobStateChangeListenerRecords.size(); 586 for (int i = 0; i < recordCount; i++) { 587 PrintJobStateChangeListenerRecord record = 588 mPrintJobStateChangeListenerRecords.get(i); 589 if (record.listener.asBinder().equals(listener.asBinder())) { 590 record.destroy(); 591 mPrintJobStateChangeListenerRecords.remove(i); 592 break; 593 } 594 } 595 if (mPrintJobStateChangeListenerRecords.isEmpty()) { 596 mPrintJobStateChangeListenerRecords = null; 597 } 598 } 599 } 600 601 public void addPrintServicesChangeListener(@NonNull IPrintServicesChangeListener listener) 602 throws RemoteException { 603 synchronized (mLock) { 604 throwIfDestroyedLocked(); 605 if (mPrintServicesChangeListenerRecords == null) { 606 mPrintServicesChangeListenerRecords = new ArrayList<>(); 607 } 608 mPrintServicesChangeListenerRecords.add( 609 new ListenerRecord<IPrintServicesChangeListener>(listener) { 610 @Override 611 public void onBinderDied() { 612 synchronized (mLock) { 613 if (mPrintServicesChangeListenerRecords != null) { 614 mPrintServicesChangeListenerRecords.remove(this); 615 } 616 } 617 } 618 }); 619 } 620 } 621 622 public void removePrintServicesChangeListener(@NonNull IPrintServicesChangeListener listener) { 623 synchronized (mLock) { 624 throwIfDestroyedLocked(); 625 if (mPrintServicesChangeListenerRecords == null) { 626 return; 627 } 628 final int recordCount = mPrintServicesChangeListenerRecords.size(); 629 for (int i = 0; i < recordCount; i++) { 630 ListenerRecord<IPrintServicesChangeListener> record = 631 mPrintServicesChangeListenerRecords.get(i); 632 if (record.listener.asBinder().equals(listener.asBinder())) { 633 record.destroy(); 634 mPrintServicesChangeListenerRecords.remove(i); 635 break; 636 } 637 } 638 if (mPrintServicesChangeListenerRecords.isEmpty()) { 639 mPrintServicesChangeListenerRecords = null; 640 } 641 } 642 } 643 644 public void addPrintServiceRecommendationsChangeListener( 645 @NonNull IRecommendationsChangeListener listener) throws RemoteException { 646 synchronized (mLock) { 647 throwIfDestroyedLocked(); 648 if (mPrintServiceRecommendationsChangeListenerRecords == null) { 649 mPrintServiceRecommendationsChangeListenerRecords = new ArrayList<>(); 650 651 mPrintServiceRecommendationsService = 652 new RemotePrintServiceRecommendationService(mContext, 653 UserHandle.getUserHandleForUid(mUserId), this); 654 } 655 mPrintServiceRecommendationsChangeListenerRecords.add( 656 new ListenerRecord<IRecommendationsChangeListener>(listener) { 657 @Override 658 public void onBinderDied() { 659 synchronized (mLock) { 660 if (mPrintServiceRecommendationsChangeListenerRecords != null) { 661 mPrintServiceRecommendationsChangeListenerRecords.remove(this); 662 } 663 } 664 } 665 }); 666 } 667 } 668 669 public void removePrintServiceRecommendationsChangeListener( 670 @NonNull IRecommendationsChangeListener listener) { 671 synchronized (mLock) { 672 throwIfDestroyedLocked(); 673 if (mPrintServiceRecommendationsChangeListenerRecords == null) { 674 return; 675 } 676 final int recordCount = mPrintServiceRecommendationsChangeListenerRecords.size(); 677 for (int i = 0; i < recordCount; i++) { 678 ListenerRecord<IRecommendationsChangeListener> record = 679 mPrintServiceRecommendationsChangeListenerRecords.get(i); 680 if (record.listener.asBinder().equals(listener.asBinder())) { 681 record.destroy(); 682 mPrintServiceRecommendationsChangeListenerRecords.remove(i); 683 break; 684 } 685 } 686 if (mPrintServiceRecommendationsChangeListenerRecords.isEmpty()) { 687 mPrintServiceRecommendationsChangeListenerRecords = null; 688 689 mPrintServiceRecommendations = null; 690 691 mPrintServiceRecommendationsService.close(); 692 mPrintServiceRecommendationsService = null; 693 } 694 } 695 } 696 697 @Override 698 public void onPrintJobStateChanged(PrintJobInfo printJob) { 699 mPrintJobForAppCache.onPrintJobStateChanged(printJob); 700 Handler.getMain().sendMessage(obtainMessage( 701 UserState::handleDispatchPrintJobStateChanged, 702 this, printJob.getId(), 703 PooledLambda.obtainSupplier(printJob.getAppId()).recycleOnUse())); 704 } 705 706 public void onPrintServicesChanged() { 707 Handler.getMain().sendMessage(obtainMessage( 708 UserState::handleDispatchPrintServicesChanged, this)); 709 } 710 711 @Override 712 public void onPrintServiceRecommendationsUpdated(List<RecommendationInfo> recommendations) { 713 Handler.getMain().sendMessage(obtainMessage( 714 UserState::handleDispatchPrintServiceRecommendationsUpdated, 715 this, recommendations)); 716 } 717 718 @Override 719 public void onPrintersAdded(List<PrinterInfo> printers) { 720 synchronized (mLock) { 721 throwIfDestroyedLocked(); 722 // No services - nothing to do. 723 if (mActiveServices.isEmpty()) { 724 return; 725 } 726 // No session - nothing to do. 727 if (mPrinterDiscoverySession == null) { 728 return; 729 } 730 mPrinterDiscoverySession.onPrintersAddedLocked(printers); 731 } 732 } 733 734 @Override 735 public void onPrintersRemoved(List<PrinterId> printerIds) { 736 synchronized (mLock) { 737 throwIfDestroyedLocked(); 738 // No services - nothing to do. 739 if (mActiveServices.isEmpty()) { 740 return; 741 } 742 // No session - nothing to do. 743 if (mPrinterDiscoverySession == null) { 744 return; 745 } 746 mPrinterDiscoverySession.onPrintersRemovedLocked(printerIds); 747 } 748 } 749 750 @Override 751 public void onCustomPrinterIconLoaded(PrinterId printerId, Icon icon) { 752 mSpooler.onCustomPrinterIconLoaded(printerId, icon); 753 754 synchronized (mLock) { 755 throwIfDestroyedLocked(); 756 757 // No session - nothing to do. 758 if (mPrinterDiscoverySession == null) { 759 return; 760 } 761 mPrinterDiscoverySession.onCustomPrinterIconLoadedLocked(printerId); 762 } 763 } 764 765 @Override 766 public void onServiceDied(RemotePrintService service) { 767 synchronized (mLock) { 768 throwIfDestroyedLocked(); 769 // No services - nothing to do. 770 if (mActiveServices.isEmpty()) { 771 return; 772 } 773 // Fail all print jobs. 774 failActivePrintJobsForService(service.getComponentName()); 775 service.onAllPrintJobsHandled(); 776 777 mActiveServices.remove(service.getComponentName()); 778 779 // The service might need to be restarted if it died because of an update 780 Handler.getMain().sendMessageDelayed(obtainMessage( 781 UserState::onConfigurationChanged, this), 782 SERVICE_RESTART_DELAY_MILLIS); 783 784 // No session - nothing to do. 785 if (mPrinterDiscoverySession == null) { 786 return; 787 } 788 mPrinterDiscoverySession.onServiceDiedLocked(service); 789 } 790 } 791 792 public void updateIfNeededLocked() { 793 throwIfDestroyedLocked(); 794 readConfigurationLocked(); 795 onConfigurationChangedLocked(); 796 } 797 798 public void destroyLocked() { 799 throwIfDestroyedLocked(); 800 mSpooler.destroy(); 801 for (RemotePrintService service : mActiveServices.values()) { 802 service.destroy(); 803 } 804 mActiveServices.clear(); 805 mInstalledServices.clear(); 806 mDisabledServices.clear(); 807 if (mPrinterDiscoverySession != null) { 808 mPrinterDiscoverySession.destroyLocked(); 809 mPrinterDiscoverySession = null; 810 } 811 mDestroyed = true; 812 } 813 814 public void dump(@NonNull DualDumpOutputStream dumpStream) { 815 synchronized (mLock) { 816 dumpStream.write("user_id", PrintUserStateProto.USER_ID, mUserId); 817 818 final int installedServiceCount = mInstalledServices.size(); 819 for (int i = 0; i < installedServiceCount; i++) { 820 long token = dumpStream.start("installed_services", 821 PrintUserStateProto.INSTALLED_SERVICES); 822 PrintServiceInfo installedService = mInstalledServices.get(i); 823 824 ResolveInfo resolveInfo = installedService.getResolveInfo(); 825 writeComponentName(dumpStream, "component_name", 826 InstalledPrintServiceProto.COMPONENT_NAME, 827 new ComponentName(resolveInfo.serviceInfo.packageName, 828 resolveInfo.serviceInfo.name)); 829 830 writeStringIfNotNull(dumpStream, "settings_activity", 831 InstalledPrintServiceProto.SETTINGS_ACTIVITY, 832 installedService.getSettingsActivityName()); 833 writeStringIfNotNull(dumpStream, "add_printers_activity", 834 InstalledPrintServiceProto.ADD_PRINTERS_ACTIVITY, 835 installedService.getAddPrintersActivityName()); 836 writeStringIfNotNull(dumpStream, "advanced_options_activity", 837 InstalledPrintServiceProto.ADVANCED_OPTIONS_ACTIVITY, 838 installedService.getAdvancedOptionsActivityName()); 839 840 dumpStream.end(token); 841 } 842 843 for (ComponentName disabledService : mDisabledServices) { 844 writeComponentName(dumpStream, "disabled_services", 845 PrintUserStateProto.DISABLED_SERVICES, disabledService); 846 } 847 848 final int activeServiceCount = mActiveServices.size(); 849 for (int i = 0; i < activeServiceCount; i++) { 850 long token = dumpStream.start("actives_services", 851 PrintUserStateProto.ACTIVE_SERVICES); 852 mActiveServices.valueAt(i).dump(dumpStream); 853 dumpStream.end(token); 854 } 855 856 mPrintJobForAppCache.dumpLocked(dumpStream); 857 858 if (mPrinterDiscoverySession != null) { 859 long token = dumpStream.start("discovery_service", 860 PrintUserStateProto.DISCOVERY_SESSIONS); 861 mPrinterDiscoverySession.dumpLocked(dumpStream); 862 dumpStream.end(token); 863 } 864 865 } 866 867 long token = dumpStream.start("print_spooler_state", 868 PrintUserStateProto.PRINT_SPOOLER_STATE); 869 mSpooler.dump(dumpStream); 870 dumpStream.end(token); 871 } 872 873 private void readConfigurationLocked() { 874 readInstalledPrintServicesLocked(); 875 readDisabledPrintServicesLocked(); 876 } 877 878 private void readInstalledPrintServicesLocked() { 879 Set<PrintServiceInfo> tempPrintServices = new HashSet<PrintServiceInfo>(); 880 881 int queryIntentFlags = GET_SERVICES | GET_META_DATA | MATCH_DEBUG_TRIAGED_MISSING; 882 883 if (mIsInstantServiceAllowed) { 884 queryIntentFlags |= MATCH_INSTANT; 885 } 886 887 List<ResolveInfo> installedServices = mContext.getPackageManager() 888 .queryIntentServicesAsUser(mQueryIntent, queryIntentFlags, mUserId); 889 890 final int installedCount = installedServices.size(); 891 for (int i = 0, count = installedCount; i < count; i++) { 892 ResolveInfo installedService = installedServices.get(i); 893 if (!android.Manifest.permission.BIND_PRINT_SERVICE.equals( 894 installedService.serviceInfo.permission)) { 895 ComponentName serviceName = new ComponentName( 896 installedService.serviceInfo.packageName, 897 installedService.serviceInfo.name); 898 Slog.w(LOG_TAG, "Skipping print service " 899 + serviceName.flattenToShortString() 900 + " since it does not require permission " 901 + android.Manifest.permission.BIND_PRINT_SERVICE); 902 continue; 903 } 904 tempPrintServices.add(PrintServiceInfo.create(mContext, installedService)); 905 } 906 907 mInstalledServices.clear(); 908 mInstalledServices.addAll(tempPrintServices); 909 } 910 911 /** 912 * Update persistent state from a previous version of Android. 913 */ 914 private void upgradePersistentStateIfNeeded() { 915 String enabledSettingValue = Settings.Secure.getStringForUser(mContext.getContentResolver(), 916 Settings.Secure.ENABLED_PRINT_SERVICES, mUserId); 917 918 // Pre N we store the enabled services, in N and later we store the disabled services. 919 // Hence if enabledSettingValue is still set, we need to upgrade. 920 if (enabledSettingValue != null) { 921 Set<ComponentName> enabledServiceNameSet = new HashSet<ComponentName>(); 922 readPrintServicesFromSettingLocked(Settings.Secure.ENABLED_PRINT_SERVICES, 923 enabledServiceNameSet); 924 925 ArraySet<ComponentName> disabledServices = new ArraySet<>(); 926 final int numInstalledServices = mInstalledServices.size(); 927 for (int i = 0; i < numInstalledServices; i++) { 928 ComponentName serviceName = mInstalledServices.get(i).getComponentName(); 929 if (!enabledServiceNameSet.contains(serviceName)) { 930 disabledServices.add(serviceName); 931 } 932 } 933 934 writeDisabledPrintServicesLocked(disabledServices); 935 936 // We won't needed ENABLED_PRINT_SERVICES anymore, set to null to prevent upgrade to run 937 // again. 938 Settings.Secure.putStringForUser(mContext.getContentResolver(), 939 Settings.Secure.ENABLED_PRINT_SERVICES, null, mUserId); 940 } 941 } 942 943 /** 944 * Read the set of disabled print services from the secure settings. 945 * 946 * @return true if the state changed. 947 */ 948 private void readDisabledPrintServicesLocked() { 949 Set<ComponentName> tempDisabledServiceNameSet = new HashSet<ComponentName>(); 950 readPrintServicesFromSettingLocked(Settings.Secure.DISABLED_PRINT_SERVICES, 951 tempDisabledServiceNameSet); 952 if (!tempDisabledServiceNameSet.equals(mDisabledServices)) { 953 mDisabledServices.clear(); 954 mDisabledServices.addAll(tempDisabledServiceNameSet); 955 } 956 } 957 958 private void readPrintServicesFromSettingLocked(String setting, 959 Set<ComponentName> outServiceNames) { 960 String settingValue = Settings.Secure.getStringForUser(mContext.getContentResolver(), 961 setting, mUserId); 962 if (!TextUtils.isEmpty(settingValue)) { 963 TextUtils.SimpleStringSplitter splitter = mStringColonSplitter; 964 splitter.setString(settingValue); 965 while (splitter.hasNext()) { 966 String string = splitter.next(); 967 if (TextUtils.isEmpty(string)) { 968 continue; 969 } 970 ComponentName componentName = ComponentName.unflattenFromString(string); 971 if (componentName != null) { 972 outServiceNames.add(componentName); 973 } 974 } 975 } 976 } 977 978 /** 979 * Persist the disabled print services to the secure settings. 980 */ 981 private void writeDisabledPrintServicesLocked(Set<ComponentName> disabledServices) { 982 StringBuilder builder = new StringBuilder(); 983 for (ComponentName componentName : disabledServices) { 984 if (builder.length() > 0) { 985 builder.append(COMPONENT_NAME_SEPARATOR); 986 } 987 builder.append(componentName.flattenToShortString()); 988 } 989 Settings.Secure.putStringForUser(mContext.getContentResolver(), 990 Settings.Secure.DISABLED_PRINT_SERVICES, builder.toString(), mUserId); 991 } 992 993 /** 994 * Get the {@link ComponentName names} of the installed print services 995 * 996 * @return The names of the installed print services 997 */ 998 private ArrayList<ComponentName> getInstalledComponents() { 999 ArrayList<ComponentName> installedComponents = new ArrayList<ComponentName>(); 1000 1001 final int installedCount = mInstalledServices.size(); 1002 for (int i = 0; i < installedCount; i++) { 1003 ResolveInfo resolveInfo = mInstalledServices.get(i).getResolveInfo(); 1004 ComponentName serviceName = new ComponentName(resolveInfo.serviceInfo.packageName, 1005 resolveInfo.serviceInfo.name); 1006 1007 installedComponents.add(serviceName); 1008 } 1009 1010 return installedComponents; 1011 } 1012 1013 /** 1014 * Prune persistent state if a print service was uninstalled 1015 */ 1016 public void prunePrintServices() { 1017 ArrayList<ComponentName> installedComponents; 1018 1019 synchronized (mLock) { 1020 installedComponents = getInstalledComponents(); 1021 1022 // Remove unnecessary entries from persistent state "disabled services" 1023 boolean disabledServicesUninstalled = mDisabledServices.retainAll(installedComponents); 1024 if (disabledServicesUninstalled) { 1025 writeDisabledPrintServicesLocked(mDisabledServices); 1026 } 1027 } 1028 1029 // Remove unnecessary entries from persistent state "approved services" 1030 mSpooler.pruneApprovedPrintServices(installedComponents); 1031 1032 } 1033 1034 private void onConfigurationChangedLocked() { 1035 ArrayList<ComponentName> installedComponents = getInstalledComponents(); 1036 1037 final int installedCount = installedComponents.size(); 1038 for (int i = 0; i < installedCount; i++) { 1039 ComponentName serviceName = installedComponents.get(i); 1040 1041 if (!mDisabledServices.contains(serviceName)) { 1042 if (!mActiveServices.containsKey(serviceName)) { 1043 RemotePrintService service = new RemotePrintService( 1044 mContext, serviceName, mUserId, mSpooler, this); 1045 addServiceLocked(service); 1046 } 1047 } else { 1048 RemotePrintService service = mActiveServices.remove(serviceName); 1049 if (service != null) { 1050 removeServiceLocked(service); 1051 } 1052 } 1053 } 1054 1055 Iterator<Map.Entry<ComponentName, RemotePrintService>> iterator = 1056 mActiveServices.entrySet().iterator(); 1057 while (iterator.hasNext()) { 1058 Map.Entry<ComponentName, RemotePrintService> entry = iterator.next(); 1059 ComponentName serviceName = entry.getKey(); 1060 RemotePrintService service = entry.getValue(); 1061 if (!installedComponents.contains(serviceName)) { 1062 removeServiceLocked(service); 1063 iterator.remove(); 1064 } 1065 } 1066 1067 onPrintServicesChanged(); 1068 } 1069 1070 private void addServiceLocked(RemotePrintService service) { 1071 mActiveServices.put(service.getComponentName(), service); 1072 if (mPrinterDiscoverySession != null) { 1073 mPrinterDiscoverySession.onServiceAddedLocked(service); 1074 } 1075 } 1076 1077 private void removeServiceLocked(RemotePrintService service) { 1078 // Fail all print jobs. 1079 failActivePrintJobsForService(service.getComponentName()); 1080 // If discovery is in progress, tear down the service. 1081 if (mPrinterDiscoverySession != null) { 1082 mPrinterDiscoverySession.onServiceRemovedLocked(service); 1083 } else { 1084 // Otherwise, just destroy it. 1085 service.destroy(); 1086 } 1087 } 1088 1089 private void failActivePrintJobsForService(final ComponentName serviceName) { 1090 // Makes sure all active print jobs are failed since the service 1091 // just died. Do this off the main thread since we do to allow 1092 // calls into the spooler on the main thread. 1093 if (Looper.getMainLooper().isCurrentThread()) { 1094 BackgroundThread.getHandler().sendMessage(obtainMessage( 1095 UserState::failScheduledPrintJobsForServiceInternal, this, serviceName)); 1096 } else { 1097 failScheduledPrintJobsForServiceInternal(serviceName); 1098 } 1099 } 1100 1101 private void failScheduledPrintJobsForServiceInternal(ComponentName serviceName) { 1102 List<PrintJobInfo> printJobs = mSpooler.getPrintJobInfos(serviceName, 1103 PrintJobInfo.STATE_ANY_SCHEDULED, PrintManager.APP_ID_ANY); 1104 if (printJobs == null) { 1105 return; 1106 } 1107 final long identity = Binder.clearCallingIdentity(); 1108 try { 1109 final int printJobCount = printJobs.size(); 1110 for (int i = 0; i < printJobCount; i++) { 1111 PrintJobInfo printJob = printJobs.get(i); 1112 mSpooler.setPrintJobState(printJob.getId(), PrintJobInfo.STATE_FAILED, 1113 mContext.getString(R.string.reason_service_unavailable)); 1114 } 1115 } finally { 1116 Binder.restoreCallingIdentity(identity); 1117 } 1118 } 1119 1120 private void throwIfDestroyedLocked() { 1121 if (mDestroyed) { 1122 throw new IllegalStateException("Cannot interact with a destroyed instance."); 1123 } 1124 } 1125 1126 private void handleDispatchPrintJobStateChanged( 1127 PrintJobId printJobId, IntSupplier appIdSupplier) { 1128 int appId = appIdSupplier.getAsInt(); 1129 final List<PrintJobStateChangeListenerRecord> records; 1130 synchronized (mLock) { 1131 if (mPrintJobStateChangeListenerRecords == null) { 1132 return; 1133 } 1134 records = new ArrayList<>(mPrintJobStateChangeListenerRecords); 1135 } 1136 final int recordCount = records.size(); 1137 for (int i = 0; i < recordCount; i++) { 1138 PrintJobStateChangeListenerRecord record = records.get(i); 1139 if (record.appId == PrintManager.APP_ID_ANY 1140 || record.appId == appId) { 1141 try { 1142 record.listener.onPrintJobStateChanged(printJobId); 1143 } catch (RemoteException re) { 1144 Log.e(LOG_TAG, "Error notifying for print job state change", re); 1145 } 1146 } 1147 } 1148 } 1149 1150 private void handleDispatchPrintServicesChanged() { 1151 final List<ListenerRecord<IPrintServicesChangeListener>> records; 1152 synchronized (mLock) { 1153 if (mPrintServicesChangeListenerRecords == null) { 1154 return; 1155 } 1156 records = new ArrayList<>(mPrintServicesChangeListenerRecords); 1157 } 1158 final int recordCount = records.size(); 1159 for (int i = 0; i < recordCount; i++) { 1160 ListenerRecord<IPrintServicesChangeListener> record = records.get(i); 1161 1162 try { 1163 record.listener.onPrintServicesChanged();; 1164 } catch (RemoteException re) { 1165 Log.e(LOG_TAG, "Error notifying for print services change", re); 1166 } 1167 } 1168 } 1169 1170 private void handleDispatchPrintServiceRecommendationsUpdated( 1171 @Nullable List<RecommendationInfo> recommendations) { 1172 final List<ListenerRecord<IRecommendationsChangeListener>> records; 1173 synchronized (mLock) { 1174 if (mPrintServiceRecommendationsChangeListenerRecords == null) { 1175 return; 1176 } 1177 records = new ArrayList<>(mPrintServiceRecommendationsChangeListenerRecords); 1178 1179 mPrintServiceRecommendations = recommendations; 1180 } 1181 final int recordCount = records.size(); 1182 for (int i = 0; i < recordCount; i++) { 1183 ListenerRecord<IRecommendationsChangeListener> record = records.get(i); 1184 1185 try { 1186 record.listener.onRecommendationsChanged(); 1187 } catch (RemoteException re) { 1188 Log.e(LOG_TAG, "Error notifying for print service recommendations change", re); 1189 } 1190 } 1191 } 1192 1193 private void onConfigurationChanged() { 1194 synchronized (mLock) { 1195 onConfigurationChangedLocked(); 1196 } 1197 } 1198 1199 public boolean getBindInstantServiceAllowed() { 1200 return mIsInstantServiceAllowed; 1201 } 1202 1203 public void setBindInstantServiceAllowed(boolean allowed) { 1204 synchronized (mLock) { 1205 mIsInstantServiceAllowed = allowed; 1206 1207 updateIfNeededLocked(); 1208 } 1209 } 1210 1211 private abstract class PrintJobStateChangeListenerRecord implements DeathRecipient { 1212 @NonNull final IPrintJobStateChangeListener listener; 1213 final int appId; 1214 1215 public PrintJobStateChangeListenerRecord(@NonNull IPrintJobStateChangeListener listener, 1216 int appId) throws RemoteException { 1217 this.listener = listener; 1218 this.appId = appId; 1219 listener.asBinder().linkToDeath(this, 0); 1220 } 1221 1222 public void destroy() { 1223 listener.asBinder().unlinkToDeath(this, 0); 1224 } 1225 1226 @Override 1227 public void binderDied() { 1228 listener.asBinder().unlinkToDeath(this, 0); 1229 onBinderDied(); 1230 } 1231 1232 public abstract void onBinderDied(); 1233 } 1234 1235 private abstract class ListenerRecord<T extends IInterface> implements DeathRecipient { 1236 @NonNull final T listener; 1237 1238 public ListenerRecord(@NonNull T listener) throws RemoteException { 1239 this.listener = listener; 1240 listener.asBinder().linkToDeath(this, 0); 1241 } 1242 1243 public void destroy() { 1244 listener.asBinder().unlinkToDeath(this, 0); 1245 } 1246 1247 @Override 1248 public void binderDied() { 1249 listener.asBinder().unlinkToDeath(this, 0); 1250 onBinderDied(); 1251 } 1252 1253 public abstract void onBinderDied(); 1254 } 1255 1256 private class PrinterDiscoverySessionMediator { 1257 private final ArrayMap<PrinterId, PrinterInfo> mPrinters = 1258 new ArrayMap<PrinterId, PrinterInfo>(); 1259 1260 private final RemoteCallbackList<IPrinterDiscoveryObserver> mDiscoveryObservers = 1261 new RemoteCallbackList<IPrinterDiscoveryObserver>() { 1262 @Override 1263 public void onCallbackDied(IPrinterDiscoveryObserver observer) { 1264 synchronized (mLock) { 1265 stopPrinterDiscoveryLocked(observer); 1266 removeObserverLocked(observer); 1267 } 1268 } 1269 }; 1270 1271 private final List<IBinder> mStartedPrinterDiscoveryTokens = new ArrayList<IBinder>(); 1272 1273 private final List<PrinterId> mStateTrackedPrinters = new ArrayList<PrinterId>(); 1274 1275 private boolean mIsDestroyed; 1276 1277 PrinterDiscoverySessionMediator() { 1278 // Kick off the session creation. 1279 Handler.getMain().sendMessage(obtainMessage(UserState.PrinterDiscoverySessionMediator:: 1280 handleDispatchCreatePrinterDiscoverySession, 1281 this, new ArrayList<>(mActiveServices.values()))); 1282 } 1283 1284 public void addObserverLocked(@NonNull IPrinterDiscoveryObserver observer) { 1285 // Add the observer. 1286 mDiscoveryObservers.register(observer); 1287 1288 // Bring the added observer up to speed with the printers. 1289 if (!mPrinters.isEmpty()) { 1290 Handler.getMain().sendMessage(obtainMessage( 1291 UserState.PrinterDiscoverySessionMediator::handlePrintersAdded, 1292 this, observer, new ArrayList<>(mPrinters.values()))); 1293 } 1294 } 1295 1296 public void removeObserverLocked(@NonNull IPrinterDiscoveryObserver observer) { 1297 // Remove the observer. 1298 mDiscoveryObservers.unregister(observer); 1299 // No one else observing - then kill it. 1300 if (mDiscoveryObservers.getRegisteredCallbackCount() == 0) { 1301 destroyLocked(); 1302 } 1303 } 1304 1305 public final void startPrinterDiscoveryLocked(@NonNull IPrinterDiscoveryObserver observer, 1306 @Nullable List<PrinterId> priorityList) { 1307 if (mIsDestroyed) { 1308 Log.w(LOG_TAG, "Not starting dicovery - session destroyed"); 1309 return; 1310 } 1311 1312 final boolean discoveryStarted = !mStartedPrinterDiscoveryTokens.isEmpty(); 1313 1314 // Remember we got a start request to match with an end. 1315 mStartedPrinterDiscoveryTokens.add(observer.asBinder()); 1316 1317 // If printer discovery is ongoing and the start request has a list 1318 // of printer to be checked, then we just request validating them. 1319 if (discoveryStarted && priorityList != null && !priorityList.isEmpty()) { 1320 validatePrinters(priorityList); 1321 return; 1322 } 1323 1324 // The service are already performing discovery - nothing to do. 1325 if (mStartedPrinterDiscoveryTokens.size() > 1) { 1326 return; 1327 } 1328 1329 Handler.getMain().sendMessage(obtainMessage(UserState.PrinterDiscoverySessionMediator:: 1330 handleDispatchStartPrinterDiscovery, this, 1331 new ArrayList<>(mActiveServices.values()), priorityList)); 1332 } 1333 1334 public final void stopPrinterDiscoveryLocked(@NonNull IPrinterDiscoveryObserver observer) { 1335 if (mIsDestroyed) { 1336 Log.w(LOG_TAG, "Not stopping dicovery - session destroyed"); 1337 return; 1338 } 1339 // This one did not make an active discovery request - nothing to do. 1340 if (!mStartedPrinterDiscoveryTokens.remove(observer.asBinder())) { 1341 return; 1342 } 1343 // There are other interested observers - do not stop discovery. 1344 if (!mStartedPrinterDiscoveryTokens.isEmpty()) { 1345 return; 1346 } 1347 Handler.getMain().sendMessage(obtainMessage(UserState.PrinterDiscoverySessionMediator:: 1348 handleDispatchStopPrinterDiscovery, 1349 this, new ArrayList<>(mActiveServices.values()))); 1350 } 1351 1352 public void validatePrintersLocked(@NonNull List<PrinterId> printerIds) { 1353 if (mIsDestroyed) { 1354 Log.w(LOG_TAG, "Not validating pritners - session destroyed"); 1355 return; 1356 } 1357 1358 List<PrinterId> remainingList = new ArrayList<PrinterId>(printerIds); 1359 while (!remainingList.isEmpty()) { 1360 Iterator<PrinterId> iterator = remainingList.iterator(); 1361 // Gather the printers per service and request a validation. 1362 List<PrinterId> updateList = new ArrayList<PrinterId>(); 1363 ComponentName serviceName = null; 1364 while (iterator.hasNext()) { 1365 PrinterId printerId = iterator.next(); 1366 if (printerId != null) { 1367 if (updateList.isEmpty()) { 1368 updateList.add(printerId); 1369 serviceName = printerId.getServiceName(); 1370 iterator.remove(); 1371 } else if (printerId.getServiceName().equals(serviceName)) { 1372 updateList.add(printerId); 1373 iterator.remove(); 1374 } 1375 } 1376 } 1377 // Schedule a notification of the service. 1378 RemotePrintService service = mActiveServices.get(serviceName); 1379 if (service != null) { 1380 Handler.getMain().sendMessage(obtainMessage( 1381 UserState.PrinterDiscoverySessionMediator::handleValidatePrinters, 1382 this, service, updateList)); 1383 } 1384 } 1385 } 1386 1387 public final void startPrinterStateTrackingLocked(@NonNull PrinterId printerId) { 1388 if (mIsDestroyed) { 1389 Log.w(LOG_TAG, "Not starting printer state tracking - session destroyed"); 1390 return; 1391 } 1392 // If printer discovery is not started - nothing to do. 1393 if (mStartedPrinterDiscoveryTokens.isEmpty()) { 1394 return; 1395 } 1396 final boolean containedPrinterId = mStateTrackedPrinters.contains(printerId); 1397 // Keep track of the number of requests to track this one. 1398 mStateTrackedPrinters.add(printerId); 1399 // If we were tracking this printer - nothing to do. 1400 if (containedPrinterId) { 1401 return; 1402 } 1403 // No service - nothing to do. 1404 RemotePrintService service = mActiveServices.get(printerId.getServiceName()); 1405 if (service == null) { 1406 return; 1407 } 1408 // Ask the service to start tracking. 1409 Handler.getMain().sendMessage(obtainMessage(UserState.PrinterDiscoverySessionMediator:: 1410 handleStartPrinterStateTracking, this, service, printerId)); 1411 } 1412 1413 public final void stopPrinterStateTrackingLocked(PrinterId printerId) { 1414 if (mIsDestroyed) { 1415 Log.w(LOG_TAG, "Not stopping printer state tracking - session destroyed"); 1416 return; 1417 } 1418 // If printer discovery is not started - nothing to do. 1419 if (mStartedPrinterDiscoveryTokens.isEmpty()) { 1420 return; 1421 } 1422 // If we did not track this printer - nothing to do. 1423 if (!mStateTrackedPrinters.remove(printerId)) { 1424 return; 1425 } 1426 // No service - nothing to do. 1427 RemotePrintService service = mActiveServices.get(printerId.getServiceName()); 1428 if (service == null) { 1429 return; 1430 } 1431 // Ask the service to start tracking. 1432 Handler.getMain().sendMessage(obtainMessage(UserState.PrinterDiscoverySessionMediator:: 1433 handleStopPrinterStateTracking, this, service, printerId)); 1434 } 1435 1436 public void onDestroyed() { 1437 /* do nothing */ 1438 } 1439 1440 public void destroyLocked() { 1441 if (mIsDestroyed) { 1442 Log.w(LOG_TAG, "Not destroying - session destroyed"); 1443 return; 1444 } 1445 mIsDestroyed = true; 1446 // Make sure printer tracking is stopped. 1447 final int printerCount = mStateTrackedPrinters.size(); 1448 for (int i = 0; i < printerCount; i++) { 1449 PrinterId printerId = mStateTrackedPrinters.get(i); 1450 stopPrinterStateTracking(printerId); 1451 } 1452 // Make sure discovery is stopped. 1453 final int observerCount = mStartedPrinterDiscoveryTokens.size(); 1454 for (int i = 0; i < observerCount; i++) { 1455 IBinder token = mStartedPrinterDiscoveryTokens.get(i); 1456 stopPrinterDiscoveryLocked(IPrinterDiscoveryObserver.Stub.asInterface(token)); 1457 } 1458 // Tell the services we are done. 1459 Handler.getMain().sendMessage(obtainMessage(UserState.PrinterDiscoverySessionMediator:: 1460 handleDispatchDestroyPrinterDiscoverySession, 1461 this, new ArrayList<>(mActiveServices.values()))); 1462 } 1463 1464 public void onPrintersAddedLocked(List<PrinterInfo> printers) { 1465 if (DEBUG) { 1466 Log.i(LOG_TAG, "onPrintersAddedLocked()"); 1467 } 1468 if (mIsDestroyed) { 1469 Log.w(LOG_TAG, "Not adding printers - session destroyed"); 1470 return; 1471 } 1472 List<PrinterInfo> addedPrinters = null; 1473 final int addedPrinterCount = printers.size(); 1474 for (int i = 0; i < addedPrinterCount; i++) { 1475 PrinterInfo printer = printers.get(i); 1476 PrinterInfo oldPrinter = mPrinters.put(printer.getId(), printer); 1477 if (oldPrinter == null || !oldPrinter.equals(printer)) { 1478 if (addedPrinters == null) { 1479 addedPrinters = new ArrayList<PrinterInfo>(); 1480 } 1481 addedPrinters.add(printer); 1482 } 1483 } 1484 if (addedPrinters != null) { 1485 Handler.getMain().sendMessage(obtainMessage( 1486 UserState.PrinterDiscoverySessionMediator::handleDispatchPrintersAdded, 1487 this, addedPrinters)); 1488 } 1489 } 1490 1491 public void onPrintersRemovedLocked(List<PrinterId> printerIds) { 1492 if (DEBUG) { 1493 Log.i(LOG_TAG, "onPrintersRemovedLocked()"); 1494 } 1495 if (mIsDestroyed) { 1496 Log.w(LOG_TAG, "Not removing printers - session destroyed"); 1497 return; 1498 } 1499 List<PrinterId> removedPrinterIds = null; 1500 final int removedPrinterCount = printerIds.size(); 1501 for (int i = 0; i < removedPrinterCount; i++) { 1502 PrinterId removedPrinterId = printerIds.get(i); 1503 if (mPrinters.remove(removedPrinterId) != null) { 1504 if (removedPrinterIds == null) { 1505 removedPrinterIds = new ArrayList<PrinterId>(); 1506 } 1507 removedPrinterIds.add(removedPrinterId); 1508 } 1509 } 1510 if (removedPrinterIds != null) { 1511 Handler.getMain().sendMessage(obtainMessage( 1512 UserState.PrinterDiscoverySessionMediator::handleDispatchPrintersRemoved, 1513 this, removedPrinterIds)); 1514 } 1515 } 1516 1517 public void onServiceRemovedLocked(RemotePrintService service) { 1518 if (mIsDestroyed) { 1519 Log.w(LOG_TAG, "Not updating removed service - session destroyed"); 1520 return; 1521 } 1522 // Remove the reported and tracked printers for that service. 1523 ComponentName serviceName = service.getComponentName(); 1524 removePrintersForServiceLocked(serviceName); 1525 service.destroy(); 1526 } 1527 1528 /** 1529 * Handle that a custom icon for a printer was loaded. 1530 * 1531 * This increments the icon generation and adds the printer again which triggers an update 1532 * in all users of the currently known printers. 1533 * 1534 * @param printerId the id of the printer the icon belongs to 1535 * @see android.print.PrinterInfo.Builder#setHasCustomPrinterIcon 1536 */ 1537 public void onCustomPrinterIconLoadedLocked(PrinterId printerId) { 1538 if (DEBUG) { 1539 Log.i(LOG_TAG, "onCustomPrinterIconLoadedLocked()"); 1540 } 1541 if (mIsDestroyed) { 1542 Log.w(LOG_TAG, "Not updating printer - session destroyed"); 1543 return; 1544 } 1545 1546 PrinterInfo printer = mPrinters.get(printerId); 1547 if (printer != null) { 1548 PrinterInfo newPrinter = (new PrinterInfo.Builder(printer)) 1549 .incCustomPrinterIconGen().build(); 1550 mPrinters.put(printerId, newPrinter); 1551 1552 ArrayList<PrinterInfo> addedPrinters = new ArrayList<>(1); 1553 addedPrinters.add(newPrinter); 1554 Handler.getMain().sendMessage(obtainMessage( 1555 UserState.PrinterDiscoverySessionMediator::handleDispatchPrintersAdded, 1556 this, addedPrinters)); 1557 } 1558 } 1559 1560 public void onServiceDiedLocked(RemotePrintService service) { 1561 removeServiceLocked(service); 1562 } 1563 1564 public void onServiceAddedLocked(RemotePrintService service) { 1565 if (mIsDestroyed) { 1566 Log.w(LOG_TAG, "Not updating added service - session destroyed"); 1567 return; 1568 } 1569 // Tell the service to create a session. 1570 Handler.getMain().sendMessage(obtainMessage( 1571 RemotePrintService::createPrinterDiscoverySession, service)); 1572 // Start printer discovery if necessary. 1573 if (!mStartedPrinterDiscoveryTokens.isEmpty()) { 1574 Handler.getMain().sendMessage(obtainMessage( 1575 RemotePrintService::startPrinterDiscovery, service, null)); 1576 } 1577 // Start tracking printers if necessary 1578 final int trackedPrinterCount = mStateTrackedPrinters.size(); 1579 for (int i = 0; i < trackedPrinterCount; i++) { 1580 PrinterId printerId = mStateTrackedPrinters.get(i); 1581 if (printerId.getServiceName().equals(service.getComponentName())) { 1582 Handler.getMain().sendMessage(obtainMessage( 1583 RemotePrintService::startPrinterStateTracking, service, printerId)); 1584 } 1585 } 1586 } 1587 1588 public void dumpLocked(@NonNull DualDumpOutputStream dumpStream) { 1589 dumpStream.write("is_destroyed", PrinterDiscoverySessionProto.IS_DESTROYED, mDestroyed); 1590 dumpStream.write("is_printer_discovery_in_progress", 1591 PrinterDiscoverySessionProto.IS_PRINTER_DISCOVERY_IN_PROGRESS, 1592 !mStartedPrinterDiscoveryTokens.isEmpty()); 1593 1594 final int observerCount = mDiscoveryObservers.beginBroadcast(); 1595 for (int i = 0; i < observerCount; i++) { 1596 IPrinterDiscoveryObserver observer = mDiscoveryObservers.getBroadcastItem(i); 1597 dumpStream.write("printer_discovery_observers", 1598 PrinterDiscoverySessionProto.PRINTER_DISCOVERY_OBSERVERS, 1599 observer.toString()); 1600 } 1601 mDiscoveryObservers.finishBroadcast(); 1602 1603 final int tokenCount = this.mStartedPrinterDiscoveryTokens.size(); 1604 for (int i = 0; i < tokenCount; i++) { 1605 IBinder token = mStartedPrinterDiscoveryTokens.get(i); 1606 dumpStream.write("discovery_requests", 1607 PrinterDiscoverySessionProto.DISCOVERY_REQUESTS, token.toString()); 1608 } 1609 1610 final int trackedPrinters = mStateTrackedPrinters.size(); 1611 for (int i = 0; i < trackedPrinters; i++) { 1612 PrinterId printer = mStateTrackedPrinters.get(i); 1613 writePrinterId(dumpStream, "tracked_printer_requests", 1614 PrinterDiscoverySessionProto.TRACKED_PRINTER_REQUESTS, printer); 1615 } 1616 1617 final int printerCount = mPrinters.size(); 1618 for (int i = 0; i < printerCount; i++) { 1619 PrinterInfo printer = mPrinters.valueAt(i); 1620 writePrinterInfo(mContext, dumpStream, "printer", 1621 PrinterDiscoverySessionProto.PRINTER, printer); 1622 } 1623 } 1624 1625 private void removePrintersForServiceLocked(ComponentName serviceName) { 1626 // No printers - nothing to do. 1627 if (mPrinters.isEmpty()) { 1628 return; 1629 } 1630 // Remove the printers for that service. 1631 List<PrinterId> removedPrinterIds = null; 1632 final int printerCount = mPrinters.size(); 1633 for (int i = 0; i < printerCount; i++) { 1634 PrinterId printerId = mPrinters.keyAt(i); 1635 if (printerId.getServiceName().equals(serviceName)) { 1636 if (removedPrinterIds == null) { 1637 removedPrinterIds = new ArrayList<PrinterId>(); 1638 } 1639 removedPrinterIds.add(printerId); 1640 } 1641 } 1642 if (removedPrinterIds != null) { 1643 final int removedPrinterCount = removedPrinterIds.size(); 1644 for (int i = 0; i < removedPrinterCount; i++) { 1645 mPrinters.remove(removedPrinterIds.get(i)); 1646 } 1647 Handler.getMain().sendMessage(obtainMessage( 1648 UserState.PrinterDiscoverySessionMediator::handleDispatchPrintersRemoved, 1649 this, removedPrinterIds)); 1650 } 1651 } 1652 1653 private void handleDispatchPrintersAdded(List<PrinterInfo> addedPrinters) { 1654 final int observerCount = mDiscoveryObservers.beginBroadcast(); 1655 for (int i = 0; i < observerCount; i++) { 1656 IPrinterDiscoveryObserver observer = mDiscoveryObservers.getBroadcastItem(i); 1657 handlePrintersAdded(observer, addedPrinters); 1658 } 1659 mDiscoveryObservers.finishBroadcast(); 1660 } 1661 1662 private void handleDispatchPrintersRemoved(List<PrinterId> removedPrinterIds) { 1663 final int observerCount = mDiscoveryObservers.beginBroadcast(); 1664 for (int i = 0; i < observerCount; i++) { 1665 IPrinterDiscoveryObserver observer = mDiscoveryObservers.getBroadcastItem(i); 1666 handlePrintersRemoved(observer, removedPrinterIds); 1667 } 1668 mDiscoveryObservers.finishBroadcast(); 1669 } 1670 1671 private void handleDispatchCreatePrinterDiscoverySession( 1672 List<RemotePrintService> services) { 1673 final int serviceCount = services.size(); 1674 for (int i = 0; i < serviceCount; i++) { 1675 RemotePrintService service = services.get(i); 1676 service.createPrinterDiscoverySession(); 1677 } 1678 } 1679 1680 private void handleDispatchDestroyPrinterDiscoverySession( 1681 List<RemotePrintService> services) { 1682 final int serviceCount = services.size(); 1683 for (int i = 0; i < serviceCount; i++) { 1684 RemotePrintService service = services.get(i); 1685 service.destroyPrinterDiscoverySession(); 1686 } 1687 onDestroyed(); 1688 } 1689 1690 private void handleDispatchStartPrinterDiscovery( 1691 List<RemotePrintService> services, List<PrinterId> printerIds) { 1692 final int serviceCount = services.size(); 1693 for (int i = 0; i < serviceCount; i++) { 1694 RemotePrintService service = services.get(i); 1695 service.startPrinterDiscovery(printerIds); 1696 } 1697 } 1698 1699 private void handleDispatchStopPrinterDiscovery(List<RemotePrintService> services) { 1700 final int serviceCount = services.size(); 1701 for (int i = 0; i < serviceCount; i++) { 1702 RemotePrintService service = services.get(i); 1703 service.stopPrinterDiscovery(); 1704 } 1705 } 1706 1707 private void handleValidatePrinters(RemotePrintService service, 1708 List<PrinterId> printerIds) { 1709 service.validatePrinters(printerIds); 1710 } 1711 1712 private void handleStartPrinterStateTracking(@NonNull RemotePrintService service, 1713 @NonNull PrinterId printerId) { 1714 service.startPrinterStateTracking(printerId); 1715 } 1716 1717 private void handleStopPrinterStateTracking(RemotePrintService service, 1718 PrinterId printerId) { 1719 service.stopPrinterStateTracking(printerId); 1720 } 1721 1722 private void handlePrintersAdded(IPrinterDiscoveryObserver observer, 1723 List<PrinterInfo> printers) { 1724 try { 1725 observer.onPrintersAdded(new ParceledListSlice<PrinterInfo>(printers)); 1726 } catch (RemoteException re) { 1727 Log.e(LOG_TAG, "Error sending added printers", re); 1728 } 1729 } 1730 1731 private void handlePrintersRemoved(IPrinterDiscoveryObserver observer, 1732 List<PrinterId> printerIds) { 1733 try { 1734 observer.onPrintersRemoved(new ParceledListSlice<PrinterId>(printerIds)); 1735 } catch (RemoteException re) { 1736 Log.e(LOG_TAG, "Error sending removed printers", re); 1737 } 1738 } 1739 } 1740 1741 private final class PrintJobForAppCache { 1742 private final SparseArray<List<PrintJobInfo>> mPrintJobsForRunningApp = 1743 new SparseArray<List<PrintJobInfo>>(); 1744 1745 public boolean onPrintJobCreated(final IBinder creator, final int appId, 1746 PrintJobInfo printJob) { 1747 try { 1748 creator.linkToDeath(new DeathRecipient() { 1749 @Override 1750 public void binderDied() { 1751 creator.unlinkToDeath(this, 0); 1752 synchronized (mLock) { 1753 mPrintJobsForRunningApp.remove(appId); 1754 } 1755 } 1756 }, 0); 1757 } catch (RemoteException re) { 1758 /* The process is already dead - we just failed. */ 1759 return false; 1760 } 1761 synchronized (mLock) { 1762 List<PrintJobInfo> printJobsForApp = mPrintJobsForRunningApp.get(appId); 1763 if (printJobsForApp == null) { 1764 printJobsForApp = new ArrayList<PrintJobInfo>(); 1765 mPrintJobsForRunningApp.put(appId, printJobsForApp); 1766 } 1767 printJobsForApp.add(printJob); 1768 } 1769 return true; 1770 } 1771 1772 public void onPrintJobStateChanged(PrintJobInfo printJob) { 1773 synchronized (mLock) { 1774 List<PrintJobInfo> printJobsForApp = mPrintJobsForRunningApp.get( 1775 printJob.getAppId()); 1776 if (printJobsForApp == null) { 1777 return; 1778 } 1779 final int printJobCount = printJobsForApp.size(); 1780 for (int i = 0; i < printJobCount; i++) { 1781 PrintJobInfo oldPrintJob = printJobsForApp.get(i); 1782 if (oldPrintJob.getId().equals(printJob.getId())) { 1783 printJobsForApp.set(i, printJob); 1784 } 1785 } 1786 } 1787 } 1788 1789 public PrintJobInfo getPrintJob(PrintJobId printJobId, int appId) { 1790 synchronized (mLock) { 1791 List<PrintJobInfo> printJobsForApp = mPrintJobsForRunningApp.get(appId); 1792 if (printJobsForApp == null) { 1793 return null; 1794 } 1795 final int printJobCount = printJobsForApp.size(); 1796 for (int i = 0; i < printJobCount; i++) { 1797 PrintJobInfo printJob = printJobsForApp.get(i); 1798 if (printJob.getId().equals(printJobId)) { 1799 return printJob; 1800 } 1801 } 1802 } 1803 return null; 1804 } 1805 1806 public List<PrintJobInfo> getPrintJobs(int appId) { 1807 synchronized (mLock) { 1808 List<PrintJobInfo> printJobs = null; 1809 if (appId == PrintManager.APP_ID_ANY) { 1810 final int bucketCount = mPrintJobsForRunningApp.size(); 1811 for (int i = 0; i < bucketCount; i++) { 1812 List<PrintJobInfo> bucket = mPrintJobsForRunningApp.valueAt(i); 1813 if (printJobs == null) { 1814 printJobs = new ArrayList<PrintJobInfo>(); 1815 } 1816 printJobs.addAll(bucket); 1817 } 1818 } else { 1819 List<PrintJobInfo> bucket = mPrintJobsForRunningApp.get(appId); 1820 if (bucket != null) { 1821 if (printJobs == null) { 1822 printJobs = new ArrayList<PrintJobInfo>(); 1823 } 1824 printJobs.addAll(bucket); 1825 } 1826 } 1827 if (printJobs != null) { 1828 return printJobs; 1829 } 1830 return Collections.emptyList(); 1831 } 1832 } 1833 1834 public void dumpLocked(@NonNull DualDumpOutputStream dumpStream) { 1835 final int bucketCount = mPrintJobsForRunningApp.size(); 1836 for (int i = 0; i < bucketCount; i++) { 1837 final int appId = mPrintJobsForRunningApp.keyAt(i); 1838 List<PrintJobInfo> bucket = mPrintJobsForRunningApp.valueAt(i); 1839 final int printJobCount = bucket.size(); 1840 for (int j = 0; j < printJobCount; j++) { 1841 long token = dumpStream.start("cached_print_jobs", 1842 PrintUserStateProto.CACHED_PRINT_JOBS); 1843 1844 dumpStream.write("app_id", CachedPrintJobProto.APP_ID, appId); 1845 1846 writePrintJobInfo(mContext, dumpStream, "print_job", 1847 CachedPrintJobProto.PRINT_JOB, bucket.get(j)); 1848 1849 dumpStream.end(token); 1850 } 1851 } 1852 } 1853 } 1854 } 1855
