/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.server.print;
import android.app.PendingIntent;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentSender;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ParceledListSlice;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Binder;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.IBinder.DeathRecipient;
import android.os.Looper;
import android.os.Message;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.os.UserHandle;
import android.print.IPrintDocumentAdapter;
import android.print.IPrintJobStateChangeListener;
import android.print.IPrinterDiscoveryObserver;
import android.print.PrintAttributes;
import android.print.PrintJobId;
import android.print.PrintJobInfo;
import android.print.PrintManager;
import android.print.PrinterId;
import android.print.PrinterInfo;
import android.printservice.PrintServiceInfo;
import android.provider.DocumentsContract;
import android.provider.Settings;
import android.text.TextUtils;
import android.text.TextUtils.SimpleStringSplitter;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.Log;
import android.util.Slog;
import android.util.SparseArray;
import com.android.internal.R;
import com.android.internal.os.BackgroundThread;
import com.android.internal.os.SomeArgs;
import com.android.server.print.RemotePrintService.PrintServiceCallbacks;
import com.android.server.print.RemotePrintSpooler.PrintSpoolerCallbacks;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* Represents the print state for a user.
*/
final class UserState implements PrintSpoolerCallbacks, PrintServiceCallbacks {
private static final String LOG_TAG = "UserState";
private static final boolean DEBUG = false;
private static final char COMPONENT_NAME_SEPARATOR = ':';
private final SimpleStringSplitter mStringColonSplitter =
new SimpleStringSplitter(COMPONENT_NAME_SEPARATOR);
private final Intent mQueryIntent =
new Intent(android.printservice.PrintService.SERVICE_INTERFACE);
private final ArrayMap<ComponentName, RemotePrintService> mActiveServices =
new ArrayMap<ComponentName, RemotePrintService>();
private final List<PrintServiceInfo> mInstalledServices =
new ArrayList<PrintServiceInfo>();
private final Set<ComponentName> mEnabledServices =
new ArraySet<ComponentName>();
private final PrintJobForAppCache mPrintJobForAppCache =
new PrintJobForAppCache();
private final Object mLock;
private final Context mContext;
private final int mUserId;
private final RemotePrintSpooler mSpooler;
private final Handler mHandler;
private PrinterDiscoverySessionMediator mPrinterDiscoverySession;
private List<PrintJobStateChangeListenerRecord> mPrintJobStateChangeListenerRecords;
private boolean mDestroyed;
public UserState(Context context, int userId, Object lock) {
mContext = context;
mUserId = userId;
mLock = lock;
mSpooler = new RemotePrintSpooler(context, userId, this);
mHandler = new UserStateHandler(context.getMainLooper());
synchronized (mLock) {
enableSystemPrintServicesLocked();
onConfigurationChangedLocked();
}
}
@Override
public void onPrintJobQueued(PrintJobInfo printJob) {
final RemotePrintService service;
synchronized (mLock) {
throwIfDestroyedLocked();
ComponentName printServiceName = printJob.getPrinterId().getServiceName();
service = mActiveServices.get(printServiceName);
}
if (service != null) {
service.onPrintJobQueued(printJob);
} else {
// The service for the job is no longer enabled, so just
// fail the job with the appropriate message.
mSpooler.setPrintJobState(printJob.getId(), PrintJobInfo.STATE_FAILED,
mContext.getString(R.string.reason_service_unavailable));
}
}
@Override
public void onAllPrintJobsForServiceHandled(ComponentName printService) {
final RemotePrintService service;
synchronized (mLock) {
throwIfDestroyedLocked();
service = mActiveServices.get(printService);
}
if (service != null) {
service.onAllPrintJobsHandled();
}
}
public void removeObsoletePrintJobs() {
mSpooler.removeObsoletePrintJobs();
}
@SuppressWarnings("deprecation")
public Bundle print(String printJobName, IPrintDocumentAdapter adapter,
PrintAttributes attributes, String packageName, int appId) {
// Create print job place holder.
final PrintJobInfo printJob = new PrintJobInfo();
printJob.setId(new PrintJobId());
printJob.setAppId(appId);
printJob.setLabel(printJobName);
printJob.setAttributes(attributes);
printJob.setState(PrintJobInfo.STATE_CREATED);
printJob.setCopies(1);
printJob.setCreationTime(System.currentTimeMillis());
// Track this job so we can forget it when the creator dies.
if (!mPrintJobForAppCache.onPrintJobCreated(adapter.asBinder(), appId,
printJob)) {
// Not adding a print job means the client is dead - done.
return null;
}
// Spin the spooler to add the job and show the config UI.
new AsyncTask<Void, Void, Void>() {
@Override
protected Void doInBackground(Void... params) {
mSpooler.createPrintJob(printJob);
return null;
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null);
final long identity = Binder.clearCallingIdentity();
try {
Intent intent = new Intent(PrintManager.ACTION_PRINT_DIALOG);
intent.setData(Uri.fromParts("printjob", printJob.getId().flattenToString(), null));
intent.putExtra(PrintManager.EXTRA_PRINT_DOCUMENT_ADAPTER, adapter.asBinder());
intent.putExtra(PrintManager.EXTRA_PRINT_JOB, printJob);
intent.putExtra(DocumentsContract.EXTRA_PACKAGE_NAME, packageName);
IntentSender intentSender = PendingIntent.getActivityAsUser(
mContext, 0, intent, PendingIntent.FLAG_ONE_SHOT
| PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_IMMUTABLE,
null, new UserHandle(mUserId)) .getIntentSender();
Bundle result = new Bundle();
result.putParcelable(PrintManager.EXTRA_PRINT_JOB, printJob);
result.putParcelable(PrintManager.EXTRA_PRINT_DIALOG_INTENT, intentSender);
return result;
} finally {
Binder.restoreCallingIdentity(identity);
}
}
public List<PrintJobInfo> getPrintJobInfos(int appId) {
List<PrintJobInfo> cachedPrintJobs = mPrintJobForAppCache.getPrintJobs(appId);
// Note that the print spooler is not storing print jobs that
// are in a terminal state as it is non-trivial to properly update
// the spooler state for when to forget print jobs in terminal state.
// Therefore, we fuse the cached print jobs for running apps (some
// jobs are in a terminal state) with the ones that the print
// spooler knows about (some jobs are being processed).
ArrayMap<PrintJobId, PrintJobInfo> result =
new ArrayMap<PrintJobId, PrintJobInfo>();
// Add the cached print jobs for running apps.
final int cachedPrintJobCount = cachedPrintJobs.size();
for (int i = 0; i < cachedPrintJobCount; i++) {
PrintJobInfo cachedPrintJob = cachedPrintJobs.get(i);
result.put(cachedPrintJob.getId(), cachedPrintJob);
// Strip out the tag and the advanced print options.
// They are visible only to print services.
cachedPrintJob.setTag(null);
cachedPrintJob.setAdvancedOptions(null);
}
// Add everything else the spooler knows about.
List<PrintJobInfo> printJobs = mSpooler.getPrintJobInfos(null,
PrintJobInfo.STATE_ANY, appId);
if (printJobs != null) {
final int printJobCount = printJobs.size();
for (int i = 0; i < printJobCount; i++) {
PrintJobInfo printJob = printJobs.get(i);
result.put(printJob.getId(), printJob);
// Strip out the tag and the advanced print options.
// They are visible only to print services.
printJob.setTag(null);
printJob.setAdvancedOptions(null);
}
}
return new ArrayList<PrintJobInfo>(result.values());
}
public PrintJobInfo getPrintJobInfo(PrintJobId printJobId, int appId) {
PrintJobInfo printJob = mPrintJobForAppCache.getPrintJob(printJobId, appId);
if (printJob == null) {
printJob = mSpooler.getPrintJobInfo(printJobId, appId);
}
if (printJob != null) {
// Strip out the tag and the advanced print options.
// They are visible only to print services.
printJob.setTag(null);
printJob.setAdvancedOptions(null);
}
return printJob;
}
public void cancelPrintJob(PrintJobId printJobId, int appId) {
PrintJobInfo printJobInfo = mSpooler.getPrintJobInfo(printJobId, appId);
if (printJobInfo == null) {
return;
}
// Take a note that we are trying to cancel the job.
mSpooler.setPrintJobCancelling(printJobId, true);
if (printJobInfo.getState() != PrintJobInfo.STATE_FAILED) {
ComponentName printServiceName = printJobInfo.getPrinterId().getServiceName();
RemotePrintService printService = null;
synchronized (mLock) {
printService = mActiveServices.get(printServiceName);
}
if (printService == null) {
return;
}
printService.onRequestCancelPrintJob(printJobInfo);
} else {
// If the print job is failed we do not need cooperation
// from the print service.
mSpooler.setPrintJobState(printJobId, PrintJobInfo.STATE_CANCELED, null);
}
}
public void restartPrintJob(PrintJobId printJobId, int appId) {
PrintJobInfo printJobInfo = getPrintJobInfo(printJobId, appId);
if (printJobInfo == null || printJobInfo.getState() != PrintJobInfo.STATE_FAILED) {
return;
}
mSpooler.setPrintJobState(printJobId, PrintJobInfo.STATE_QUEUED, null);
}
public List<PrintServiceInfo> getEnabledPrintServices() {
synchronized (mLock) {
List<PrintServiceInfo> enabledServices = null;
final int installedServiceCount = mInstalledServices.size();
for (int i = 0; i < installedServiceCount; i++) {
PrintServiceInfo installedService = mInstalledServices.get(i);
ComponentName componentName = new ComponentName(
installedService.getResolveInfo().serviceInfo.packageName,
installedService.getResolveInfo().serviceInfo.name);
if (mActiveServices.containsKey(componentName)) {
if (enabledServices == null) {
enabledServices = new ArrayList<PrintServiceInfo>();
}
enabledServices.add(installedService);
}
}
return enabledServices;
}
}
public List<PrintServiceInfo> getInstalledPrintServices() {
synchronized (mLock) {
return mInstalledServices;
}
}
public void createPrinterDiscoverySession(IPrinterDiscoveryObserver observer) {
synchronized (mLock) {
throwIfDestroyedLocked();
if (mActiveServices.isEmpty()) {
return;
}
if (mPrinterDiscoverySession == null) {
// If we do not have a session, tell all service to create one.
mPrinterDiscoverySession = new PrinterDiscoverySessionMediator(mContext) {
@Override
public void onDestroyed() {
mPrinterDiscoverySession = null;
}
};
// Add the observer to the brand new session.
mPrinterDiscoverySession.addObserverLocked(observer);
} else {
// If services have created session, just add the observer.
mPrinterDiscoverySession.addObserverLocked(observer);
}
}
}
public void destroyPrinterDiscoverySession(IPrinterDiscoveryObserver observer) {
synchronized (mLock) {
// Already destroyed - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
// Remove this observer.
mPrinterDiscoverySession.removeObserverLocked(observer);
}
}
public void startPrinterDiscovery(IPrinterDiscoveryObserver observer,
List<PrinterId> printerIds) {
synchronized (mLock) {
throwIfDestroyedLocked();
// No services - nothing to do.
if (mActiveServices.isEmpty()) {
return;
}
// No session - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
// Kick of discovery.
mPrinterDiscoverySession.startPrinterDiscoveryLocked(observer,
printerIds);
}
}
public void stopPrinterDiscovery(IPrinterDiscoveryObserver observer) {
synchronized (mLock) {
throwIfDestroyedLocked();
// No services - nothing to do.
if (mActiveServices.isEmpty()) {
return;
}
// No session - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
// Kick of discovery.
mPrinterDiscoverySession.stopPrinterDiscoveryLocked(observer);
}
}
public void validatePrinters(List<PrinterId> printerIds) {
synchronized (mLock) {
throwIfDestroyedLocked();
// No services - nothing to do.
if (mActiveServices.isEmpty()) {
return;
}
// No session - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
// Request an updated.
mPrinterDiscoverySession.validatePrintersLocked(printerIds);
}
}
public void startPrinterStateTracking(PrinterId printerId) {
synchronized (mLock) {
throwIfDestroyedLocked();
// No services - nothing to do.
if (mActiveServices.isEmpty()) {
return;
}
// No session - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
// Request start tracking the printer.
mPrinterDiscoverySession.startPrinterStateTrackingLocked(printerId);
}
}
public void stopPrinterStateTracking(PrinterId printerId) {
synchronized (mLock) {
throwIfDestroyedLocked();
// No services - nothing to do.
if (mActiveServices.isEmpty()) {
return;
}
// No session - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
// Request stop tracking the printer.
mPrinterDiscoverySession.stopPrinterStateTrackingLocked(printerId);
}
}
public void addPrintJobStateChangeListener(IPrintJobStateChangeListener listener,
int appId) throws RemoteException {
synchronized (mLock) {
throwIfDestroyedLocked();
if (mPrintJobStateChangeListenerRecords == null) {
mPrintJobStateChangeListenerRecords =
new ArrayList<PrintJobStateChangeListenerRecord>();
}
mPrintJobStateChangeListenerRecords.add(
new PrintJobStateChangeListenerRecord(listener, appId) {
@Override
public void onBinderDied() {
mPrintJobStateChangeListenerRecords.remove(this);
}
});
}
}
public void removePrintJobStateChangeListener(IPrintJobStateChangeListener listener) {
synchronized (mLock) {
throwIfDestroyedLocked();
if (mPrintJobStateChangeListenerRecords == null) {
return;
}
final int recordCount = mPrintJobStateChangeListenerRecords.size();
for (int i = 0; i < recordCount; i++) {
PrintJobStateChangeListenerRecord record =
mPrintJobStateChangeListenerRecords.get(i);
if (record.listener.asBinder().equals(listener.asBinder())) {
mPrintJobStateChangeListenerRecords.remove(i);
break;
}
}
if (mPrintJobStateChangeListenerRecords.isEmpty()) {
mPrintJobStateChangeListenerRecords = null;
}
}
}
@Override
public void onPrintJobStateChanged(PrintJobInfo printJob) {
mPrintJobForAppCache.onPrintJobStateChanged(printJob);
mHandler.obtainMessage(UserStateHandler.MSG_DISPATCH_PRINT_JOB_STATE_CHANGED,
printJob.getAppId(), 0, printJob.getId()).sendToTarget();
}
@Override
public void onPrintersAdded(List<PrinterInfo> printers) {
synchronized (mLock) {
throwIfDestroyedLocked();
// No services - nothing to do.
if (mActiveServices.isEmpty()) {
return;
}
// No session - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
mPrinterDiscoverySession.onPrintersAddedLocked(printers);
}
}
@Override
public void onPrintersRemoved(List<PrinterId> printerIds) {
synchronized (mLock) {
throwIfDestroyedLocked();
// No services - nothing to do.
if (mActiveServices.isEmpty()) {
return;
}
// No session - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
mPrinterDiscoverySession.onPrintersRemovedLocked(printerIds);
}
}
@Override
public void onServiceDied(RemotePrintService service) {
synchronized (mLock) {
throwIfDestroyedLocked();
// No services - nothing to do.
if (mActiveServices.isEmpty()) {
return;
}
// Fail all print jobs.
failActivePrintJobsForService(service.getComponentName());
service.onAllPrintJobsHandled();
// No session - nothing to do.
if (mPrinterDiscoverySession == null) {
return;
}
mPrinterDiscoverySession.onServiceDiedLocked(service);
}
}
public void updateIfNeededLocked() {
throwIfDestroyedLocked();
if (readConfigurationLocked()) {
onConfigurationChangedLocked();
}
}
public Set<ComponentName> getEnabledServices() {
synchronized(mLock) {
throwIfDestroyedLocked();
return mEnabledServices;
}
}
public void destroyLocked() {
throwIfDestroyedLocked();
mSpooler.destroy();
for (RemotePrintService service : mActiveServices.values()) {
service.destroy();
}
mActiveServices.clear();
mInstalledServices.clear();
mEnabledServices.clear();
if (mPrinterDiscoverySession != null) {
mPrinterDiscoverySession.destroyLocked();
mPrinterDiscoverySession = null;
}
mDestroyed = true;
}
public void dump(FileDescriptor fd, PrintWriter pw, String prefix) {
pw.append(prefix).append("user state ").append(String.valueOf(mUserId)).append(":");
pw.println();
String tab = " ";
pw.append(prefix).append(tab).append("installed services:").println();
final int installedServiceCount = mInstalledServices.size();
for (int i = 0; i < installedServiceCount; i++) {
PrintServiceInfo installedService = mInstalledServices.get(i);
String installedServicePrefix = prefix + tab + tab;
pw.append(installedServicePrefix).append("service:").println();
ResolveInfo resolveInfo = installedService.getResolveInfo();
ComponentName componentName = new ComponentName(
resolveInfo.serviceInfo.packageName,
resolveInfo.serviceInfo.name);
pw.append(installedServicePrefix).append(tab).append("componentName=")
.append(componentName.flattenToString()).println();
pw.append(installedServicePrefix).append(tab).append("settingsActivity=")
.append(installedService.getSettingsActivityName()).println();
pw.append(installedServicePrefix).append(tab).append("addPrintersActivity=")
.append(installedService.getAddPrintersActivityName()).println();
pw.append(installedServicePrefix).append(tab).append("avancedOptionsActivity=")
.append(installedService.getAdvancedOptionsActivityName()).println();
}
pw.append(prefix).append(tab).append("enabled services:").println();
for (ComponentName enabledService : mEnabledServices) {
String enabledServicePrefix = prefix + tab + tab;
pw.append(enabledServicePrefix).append("service:").println();
pw.append(enabledServicePrefix).append(tab).append("componentName=")
.append(enabledService.flattenToString());
pw.println();
}
pw.append(prefix).append(tab).append("active services:").println();
final int activeServiceCount = mActiveServices.size();
for (int i = 0; i < activeServiceCount; i++) {
RemotePrintService activeService = mActiveServices.valueAt(i);
activeService.dump(pw, prefix + tab + tab);
pw.println();
}
pw.append(prefix).append(tab).append("cached print jobs:").println();
mPrintJobForAppCache.dump(pw, prefix + tab + tab);
pw.append(prefix).append(tab).append("discovery mediator:").println();
if (mPrinterDiscoverySession != null) {
mPrinterDiscoverySession.dump(pw, prefix + tab + tab);
}
pw.append(prefix).append(tab).append("print spooler:").println();
mSpooler.dump(fd, pw, prefix + tab + tab);
pw.println();
}
private boolean readConfigurationLocked() {
boolean somethingChanged = false;
somethingChanged |= readInstalledPrintServicesLocked();
somethingChanged |= readEnabledPrintServicesLocked();
return somethingChanged;
}
private boolean readInstalledPrintServicesLocked() {
Set<PrintServiceInfo> tempPrintServices = new HashSet<PrintServiceInfo>();
List<ResolveInfo> installedServices = mContext.getPackageManager()
.queryIntentServicesAsUser(mQueryIntent, PackageManager.GET_SERVICES
| PackageManager.GET_META_DATA, mUserId);
final int installedCount = installedServices.size();
for (int i = 0, count = installedCount; i < count; i++) {
ResolveInfo installedService = installedServices.get(i);
if (!android.Manifest.permission.BIND_PRINT_SERVICE.equals(
installedService.serviceInfo.permission)) {
ComponentName serviceName = new ComponentName(
installedService.serviceInfo.packageName,
installedService.serviceInfo.name);
Slog.w(LOG_TAG, "Skipping print service "
+ serviceName.flattenToShortString()
+ " since it does not require permission "
+ android.Manifest.permission.BIND_PRINT_SERVICE);
continue;
}
tempPrintServices.add(PrintServiceInfo.create(installedService, mContext));
}
boolean someServiceChanged = false;
if (tempPrintServices.size() != mInstalledServices.size()) {
someServiceChanged = true;
} else {
for (PrintServiceInfo newService: tempPrintServices) {
final int oldServiceIndex = mInstalledServices.indexOf(newService);
if (oldServiceIndex < 0) {
someServiceChanged = true;
break;
}
// PrintServiceInfo#equals compares only the id not all members,
// so we are also comparing the members coming from meta-data.
PrintServiceInfo oldService = mInstalledServices.get(oldServiceIndex);
if (!TextUtils.equals(oldService.getAddPrintersActivityName(),
newService.getAddPrintersActivityName())
|| !TextUtils.equals(oldService.getAdvancedOptionsActivityName(),
newService.getAdvancedOptionsActivityName())
|| !TextUtils.equals(oldService.getSettingsActivityName(),
newService.getSettingsActivityName())) {
someServiceChanged = true;
break;
}
}
}
if (someServiceChanged) {
mInstalledServices.clear();
mInstalledServices.addAll(tempPrintServices);
return true;
}
return false;
}
private boolean readEnabledPrintServicesLocked() {
Set<ComponentName> tempEnabledServiceNameSet = new HashSet<ComponentName>();
readPrintServicesFromSettingLocked(Settings.Secure.ENABLED_PRINT_SERVICES,
tempEnabledServiceNameSet);
if (!tempEnabledServiceNameSet.equals(mEnabledServices)) {
mEnabledServices.clear();
mEnabledServices.addAll(tempEnabledServiceNameSet);
return true;
}
return false;
}
private void readPrintServicesFromSettingLocked(String setting,
Set<ComponentName> outServiceNames) {
String settingValue = Settings.Secure.getStringForUser(mContext.getContentResolver(),
setting, mUserId);
if (!TextUtils.isEmpty(settingValue)) {
TextUtils.SimpleStringSplitter splitter = mStringColonSplitter;
splitter.setString(settingValue);
while (splitter.hasNext()) {
String string = splitter.next();
if (TextUtils.isEmpty(string)) {
continue;
}
ComponentName componentName = ComponentName.unflattenFromString(string);
if (componentName != null) {
outServiceNames.add(componentName);
}
}
}
}
private void enableSystemPrintServicesLocked() {
// Load enabled and installed services.
readEnabledPrintServicesLocked();
readInstalledPrintServicesLocked();
// Load the system services once enabled on first boot.
Set<ComponentName> enabledOnFirstBoot = new HashSet<ComponentName>();
readPrintServicesFromSettingLocked(
Settings.Secure.ENABLED_ON_FIRST_BOOT_SYSTEM_PRINT_SERVICES,
enabledOnFirstBoot);
StringBuilder builder = new StringBuilder();
final int serviceCount = mInstalledServices.size();
for (int i = 0; i < serviceCount; i++) {
ServiceInfo serviceInfo = mInstalledServices.get(i).getResolveInfo().serviceInfo;
// Enable system print services if we never did that and are not enabled.
if ((serviceInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
ComponentName serviceName = new ComponentName(
serviceInfo.packageName, serviceInfo.name);
if (!mEnabledServices.contains(serviceName)
&& !enabledOnFirstBoot.contains(serviceName)) {
if (builder.length() > 0) {
builder.append(":");
}
builder.append(serviceName.flattenToString());
}
}
}
// Nothing to be enabled - done.
if (builder.length() <= 0) {
return;
}
String servicesToEnable = builder.toString();
// Update the enabled services setting.
String enabledServices = Settings.Secure.getStringForUser(
mContext.getContentResolver(), Settings.Secure.ENABLED_PRINT_SERVICES, mUserId);
if (TextUtils.isEmpty(enabledServices)) {
enabledServices = servicesToEnable;
} else {
enabledServices = enabledServices + ":" + servicesToEnable;
}
Settings.Secure.putStringForUser(mContext.getContentResolver(),
Settings.Secure.ENABLED_PRINT_SERVICES, enabledServices, mUserId);
// Update the enabled on first boot services setting.
String enabledOnFirstBootServices = Settings.Secure.getStringForUser(
mContext.getContentResolver(),
Settings.Secure.ENABLED_ON_FIRST_BOOT_SYSTEM_PRINT_SERVICES, mUserId);
if (TextUtils.isEmpty(enabledOnFirstBootServices)) {
enabledOnFirstBootServices = servicesToEnable;
} else {
enabledOnFirstBootServices = enabledOnFirstBootServices + ":" + enabledServices;
}
Settings.Secure.putStringForUser(mContext.getContentResolver(),
Settings.Secure.ENABLED_ON_FIRST_BOOT_SYSTEM_PRINT_SERVICES,
enabledOnFirstBootServices, mUserId);
}
private void onConfigurationChangedLocked() {
Set<ComponentName> installedComponents = new ArraySet<ComponentName>();
final int installedCount = mInstalledServices.size();
for (int i = 0; i < installedCount; i++) {
ResolveInfo resolveInfo = mInstalledServices.get(i).getResolveInfo();
ComponentName serviceName = new ComponentName(resolveInfo.serviceInfo.packageName,
resolveInfo.serviceInfo.name);
installedComponents.add(serviceName);
if (mEnabledServices.contains(serviceName)) {
if (!mActiveServices.containsKey(serviceName)) {
RemotePrintService service = new RemotePrintService(
mContext, serviceName, mUserId, mSpooler, this);
addServiceLocked(service);
}
} else {
RemotePrintService service = mActiveServices.remove(serviceName);
if (service != null) {
removeServiceLocked(service);
}
}
}
Iterator<Map.Entry<ComponentName, RemotePrintService>> iterator =
mActiveServices.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<ComponentName, RemotePrintService> entry = iterator.next();
ComponentName serviceName = entry.getKey();
RemotePrintService service = entry.getValue();
if (!installedComponents.contains(serviceName)) {
removeServiceLocked(service);
iterator.remove();
}
}
}
private void addServiceLocked(RemotePrintService service) {
mActiveServices.put(service.getComponentName(), service);
if (mPrinterDiscoverySession != null) {
mPrinterDiscoverySession.onServiceAddedLocked(service);
}
}
private void removeServiceLocked(RemotePrintService service) {
// Fail all print jobs.
failActivePrintJobsForService(service.getComponentName());
// If discovery is in progress, tear down the service.
if (mPrinterDiscoverySession != null) {
mPrinterDiscoverySession.onServiceRemovedLocked(service);
} else {
// Otherwise, just destroy it.
service.destroy();
}
}
private void failActivePrintJobsForService(final ComponentName serviceName) {
// Makes sure all active print jobs are failed since the service
// just died. Do this off the main thread since we do to allow
// calls into the spooler on the main thread.
if (Looper.getMainLooper().isCurrentThread()) {
BackgroundThread.getHandler().post(new Runnable() {
@Override
public void run() {
failScheduledPrintJobsForServiceInternal(serviceName);
}
});
} else {
failScheduledPrintJobsForServiceInternal(serviceName);
}
}
private void failScheduledPrintJobsForServiceInternal(ComponentName serviceName) {
List<PrintJobInfo> printJobs = mSpooler.getPrintJobInfos(serviceName,
PrintJobInfo.STATE_ANY_SCHEDULED, PrintManager.APP_ID_ANY);
if (printJobs == null) {
return;
}
final long identity = Binder.clearCallingIdentity();
try {
final int printJobCount = printJobs.size();
for (int i = 0; i < printJobCount; i++) {
PrintJobInfo printJob = printJobs.get(i);
mSpooler.setPrintJobState(printJob.getId(), PrintJobInfo.STATE_FAILED,
mContext.getString(R.string.reason_service_unavailable));
}
} finally {
Binder.restoreCallingIdentity(identity);
}
}
private void throwIfDestroyedLocked() {
if (mDestroyed) {
throw new IllegalStateException("Cannot interact with a destroyed instance.");
}
}
private void handleDispatchPrintJobStateChanged(PrintJobId printJobId, int appId) {
final List<PrintJobStateChangeListenerRecord> records;
synchronized (mLock) {
if (mPrintJobStateChangeListenerRecords == null) {
return;
}
records = new ArrayList<PrintJobStateChangeListenerRecord>(
mPrintJobStateChangeListenerRecords);
}
final int recordCount = records.size();
for (int i = 0; i < recordCount; i++) {
PrintJobStateChangeListenerRecord record = records.get(i);
if (record.appId == PrintManager.APP_ID_ANY
|| record.appId == appId)
try {
record.listener.onPrintJobStateChanged(printJobId);
} catch (RemoteException re) {
Log.e(LOG_TAG, "Error notifying for print job state change", re);
}
}
}
private final class UserStateHandler extends Handler {
public static final int MSG_DISPATCH_PRINT_JOB_STATE_CHANGED = 1;
public UserStateHandler(Looper looper) {
super(looper, null, false);
}
@Override
public void handleMessage(Message message) {
if (message.what == MSG_DISPATCH_PRINT_JOB_STATE_CHANGED) {
PrintJobId printJobId = (PrintJobId) message.obj;
final int appId = message.arg1;
handleDispatchPrintJobStateChanged(printJobId, appId);
}
}
}
private abstract class PrintJobStateChangeListenerRecord implements DeathRecipient {
final IPrintJobStateChangeListener listener;
final int appId;
public PrintJobStateChangeListenerRecord(IPrintJobStateChangeListener listener,
int appId) throws RemoteException {
this.listener = listener;
this.appId = appId;
listener.asBinder().linkToDeath(this, 0);
}
@Override
public void binderDied() {
listener.asBinder().unlinkToDeath(this, 0);
onBinderDied();
}
public abstract void onBinderDied();
}
private class PrinterDiscoverySessionMediator {
private final ArrayMap<PrinterId, PrinterInfo> mPrinters =
new ArrayMap<PrinterId, PrinterInfo>();
private final RemoteCallbackList<IPrinterDiscoveryObserver> mDiscoveryObservers =
new RemoteCallbackList<IPrinterDiscoveryObserver>() {
@Override
public void onCallbackDied(IPrinterDiscoveryObserver observer) {
synchronized (mLock) {
stopPrinterDiscoveryLocked(observer);
removeObserverLocked(observer);
}
}
};
private final List<IBinder> mStartedPrinterDiscoveryTokens = new ArrayList<IBinder>();
private final List<PrinterId> mStateTrackedPrinters = new ArrayList<PrinterId>();
private final Handler mHandler;
private boolean mIsDestroyed;
public PrinterDiscoverySessionMediator(Context context) {
mHandler = new SessionHandler(context.getMainLooper());
// Kick off the session creation.
List<RemotePrintService> services = new ArrayList<RemotePrintService>(
mActiveServices.values());
mHandler.obtainMessage(SessionHandler
.MSG_DISPATCH_CREATE_PRINTER_DISCOVERY_SESSION, services)
.sendToTarget();
}
public void addObserverLocked(IPrinterDiscoveryObserver observer) {
// Add the observer.
mDiscoveryObservers.register(observer);
// Bring the added observer up to speed with the printers.
if (!mPrinters.isEmpty()) {
List<PrinterInfo> printers = new ArrayList<PrinterInfo>(mPrinters.values());
SomeArgs args = SomeArgs.obtain();
args.arg1 = observer;
args.arg2 = printers;
mHandler.obtainMessage(SessionHandler.MSG_PRINTERS_ADDED,
args).sendToTarget();
}
}
public void removeObserverLocked(IPrinterDiscoveryObserver observer) {
// Remove the observer.
mDiscoveryObservers.unregister(observer);
// No one else observing - then kill it.
if (mDiscoveryObservers.getRegisteredCallbackCount() == 0) {
destroyLocked();
}
}
public final void startPrinterDiscoveryLocked(IPrinterDiscoveryObserver observer,
List<PrinterId> priorityList) {
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not starting dicovery - session destroyed");
return;
}
final boolean discoveryStarted = !mStartedPrinterDiscoveryTokens.isEmpty();
// Remember we got a start request to match with an end.
mStartedPrinterDiscoveryTokens.add(observer.asBinder());
// If printer discovery is ongoing and the start request has a list
// of printer to be checked, then we just request validating them.
if (discoveryStarted && priorityList != null && !priorityList.isEmpty()) {
validatePrinters(priorityList);
return;
}
// The service are already performing discovery - nothing to do.
if (mStartedPrinterDiscoveryTokens.size() > 1) {
return;
}
List<RemotePrintService> services = new ArrayList<RemotePrintService>(
mActiveServices.values());
SomeArgs args = SomeArgs.obtain();
args.arg1 = services;
args.arg2 = priorityList;
mHandler.obtainMessage(SessionHandler
.MSG_DISPATCH_START_PRINTER_DISCOVERY, args)
.sendToTarget();
}
public final void stopPrinterDiscoveryLocked(IPrinterDiscoveryObserver observer) {
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not stopping dicovery - session destroyed");
return;
}
// This one did not make an active discovery request - nothing to do.
if (!mStartedPrinterDiscoveryTokens.remove(observer.asBinder())) {
return;
}
// There are other interested observers - do not stop discovery.
if (!mStartedPrinterDiscoveryTokens.isEmpty()) {
return;
}
List<RemotePrintService> services = new ArrayList<RemotePrintService>(
mActiveServices.values());
mHandler.obtainMessage(SessionHandler
.MSG_DISPATCH_STOP_PRINTER_DISCOVERY, services)
.sendToTarget();
}
public void validatePrintersLocked(List<PrinterId> printerIds) {
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not validating pritners - session destroyed");
return;
}
List<PrinterId> remainingList = new ArrayList<PrinterId>(printerIds);
while (!remainingList.isEmpty()) {
Iterator<PrinterId> iterator = remainingList.iterator();
// Gather the printers per service and request a validation.
List<PrinterId> updateList = new ArrayList<PrinterId>();
ComponentName serviceName = null;
while (iterator.hasNext()) {
PrinterId printerId = iterator.next();
if (updateList.isEmpty()) {
updateList.add(printerId);
serviceName = printerId.getServiceName();
iterator.remove();
} else if (printerId.getServiceName().equals(serviceName)) {
updateList.add(printerId);
iterator.remove();
}
}
// Schedule a notification of the service.
RemotePrintService service = mActiveServices.get(serviceName);
if (service != null) {
SomeArgs args = SomeArgs.obtain();
args.arg1 = service;
args.arg2 = updateList;
mHandler.obtainMessage(SessionHandler
.MSG_VALIDATE_PRINTERS, args)
.sendToTarget();
}
}
}
public final void startPrinterStateTrackingLocked(PrinterId printerId) {
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not starting printer state tracking - session destroyed");
return;
}
// If printer discovery is not started - nothing to do.
if (mStartedPrinterDiscoveryTokens.isEmpty()) {
return;
}
final boolean containedPrinterId = mStateTrackedPrinters.contains(printerId);
// Keep track of the number of requests to track this one.
mStateTrackedPrinters.add(printerId);
// If we were tracking this printer - nothing to do.
if (containedPrinterId) {
return;
}
// No service - nothing to do.
RemotePrintService service = mActiveServices.get(printerId.getServiceName());
if (service == null) {
return;
}
// Ask the service to start tracking.
SomeArgs args = SomeArgs.obtain();
args.arg1 = service;
args.arg2 = printerId;
mHandler.obtainMessage(SessionHandler
.MSG_START_PRINTER_STATE_TRACKING, args)
.sendToTarget();
}
public final void stopPrinterStateTrackingLocked(PrinterId printerId) {
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not stopping printer state tracking - session destroyed");
return;
}
// If printer discovery is not started - nothing to do.
if (mStartedPrinterDiscoveryTokens.isEmpty()) {
return;
}
// If we did not track this printer - nothing to do.
if (!mStateTrackedPrinters.remove(printerId)) {
return;
}
// No service - nothing to do.
RemotePrintService service = mActiveServices.get(printerId.getServiceName());
if (service == null) {
return;
}
// Ask the service to start tracking.
SomeArgs args = SomeArgs.obtain();
args.arg1 = service;
args.arg2 = printerId;
mHandler.obtainMessage(SessionHandler
.MSG_STOP_PRINTER_STATE_TRACKING, args)
.sendToTarget();
}
public void onDestroyed() {
/* do nothing */
}
public void destroyLocked() {
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not destroying - session destroyed");
return;
}
mIsDestroyed = true;
// Make sure printer tracking is stopped.
final int printerCount = mStateTrackedPrinters.size();
for (int i = 0; i < printerCount; i++) {
PrinterId printerId = mStateTrackedPrinters.get(i);
stopPrinterStateTracking(printerId);
}
// Make sure discovery is stopped.
final int observerCount = mStartedPrinterDiscoveryTokens.size();
for (int i = 0; i < observerCount; i++) {
IBinder token = mStartedPrinterDiscoveryTokens.get(i);
stopPrinterDiscoveryLocked(IPrinterDiscoveryObserver.Stub.asInterface(token));
}
// Tell the services we are done.
List<RemotePrintService> services = new ArrayList<RemotePrintService>(
mActiveServices.values());
mHandler.obtainMessage(SessionHandler
.MSG_DISPATCH_DESTROY_PRINTER_DISCOVERY_SESSION, services)
.sendToTarget();
}
public void onPrintersAddedLocked(List<PrinterInfo> printers) {
if (DEBUG) {
Log.i(LOG_TAG, "onPrintersAddedLocked()");
}
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not adding printers - session destroyed");
return;
}
List<PrinterInfo> addedPrinters = null;
final int addedPrinterCount = printers.size();
for (int i = 0; i < addedPrinterCount; i++) {
PrinterInfo printer = printers.get(i);
PrinterInfo oldPrinter = mPrinters.put(printer.getId(), printer);
if (oldPrinter == null || !oldPrinter.equals(printer)) {
if (addedPrinters == null) {
addedPrinters = new ArrayList<PrinterInfo>();
}
addedPrinters.add(printer);
}
}
if (addedPrinters != null) {
mHandler.obtainMessage(SessionHandler.MSG_DISPATCH_PRINTERS_ADDED,
addedPrinters).sendToTarget();
}
}
public void onPrintersRemovedLocked(List<PrinterId> printerIds) {
if (DEBUG) {
Log.i(LOG_TAG, "onPrintersRemovedLocked()");
}
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not removing printers - session destroyed");
return;
}
List<PrinterId> removedPrinterIds = null;
final int removedPrinterCount = printerIds.size();
for (int i = 0; i < removedPrinterCount; i++) {
PrinterId removedPrinterId = printerIds.get(i);
if (mPrinters.remove(removedPrinterId) != null) {
if (removedPrinterIds == null) {
removedPrinterIds = new ArrayList<PrinterId>();
}
removedPrinterIds.add(removedPrinterId);
}
}
if (removedPrinterIds != null) {
mHandler.obtainMessage(SessionHandler.MSG_DISPATCH_PRINTERS_REMOVED,
removedPrinterIds).sendToTarget();
}
}
public void onServiceRemovedLocked(RemotePrintService service) {
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not updating removed service - session destroyed");
return;
}
// Remove the reported and tracked printers for that service.
ComponentName serviceName = service.getComponentName();
removePrintersForServiceLocked(serviceName);
service.destroy();
}
public void onServiceDiedLocked(RemotePrintService service) {
// Remove the reported by that service.
removePrintersForServiceLocked(service.getComponentName());
}
public void onServiceAddedLocked(RemotePrintService service) {
if (mIsDestroyed) {
Log.w(LOG_TAG, "Not updating added service - session destroyed");
return;
}
// Tell the service to create a session.
mHandler.obtainMessage(
SessionHandler.MSG_CREATE_PRINTER_DISCOVERY_SESSION,
service).sendToTarget();
// Start printer discovery if necessary.
if (!mStartedPrinterDiscoveryTokens.isEmpty()) {
mHandler.obtainMessage(
SessionHandler.MSG_START_PRINTER_DISCOVERY,
service).sendToTarget();
}
// Start tracking printers if necessary
final int trackedPrinterCount = mStateTrackedPrinters.size();
for (int i = 0; i < trackedPrinterCount; i++) {
PrinterId printerId = mStateTrackedPrinters.get(i);
if (printerId.getServiceName().equals(service.getComponentName())) {
SomeArgs args = SomeArgs.obtain();
args.arg1 = service;
args.arg2 = printerId;
mHandler.obtainMessage(SessionHandler
.MSG_START_PRINTER_STATE_TRACKING, args)
.sendToTarget();
}
}
}
public void dump(PrintWriter pw, String prefix) {
pw.append(prefix).append("destroyed=")
.append(String.valueOf(mDestroyed)).println();
pw.append(prefix).append("printDiscoveryInProgress=")
.append(String.valueOf(!mStartedPrinterDiscoveryTokens.isEmpty())).println();
String tab = " ";
pw.append(prefix).append(tab).append("printer discovery observers:").println();
final int observerCount = mDiscoveryObservers.beginBroadcast();
for (int i = 0; i < observerCount; i++) {
IPrinterDiscoveryObserver observer = mDiscoveryObservers.getBroadcastItem(i);
pw.append(prefix).append(prefix).append(observer.toString());
pw.println();
}
mDiscoveryObservers.finishBroadcast();
pw.append(prefix).append(tab).append("start discovery requests:").println();
final int tokenCount = this.mStartedPrinterDiscoveryTokens.size();
for (int i = 0; i < tokenCount; i++) {
IBinder token = mStartedPrinterDiscoveryTokens.get(i);
pw.append(prefix).append(tab).append(tab).append(token.toString()).println();
}
pw.append(prefix).append(tab).append("tracked printer requests:").println();
final int trackedPrinters = mStateTrackedPrinters.size();
for (int i = 0; i < trackedPrinters; i++) {
PrinterId printer = mStateTrackedPrinters.get(i);
pw.append(prefix).append(tab).append(tab).append(printer.toString()).println();
}
pw.append(prefix).append(tab).append("printers:").println();
final int pritnerCount = mPrinters.size();
for (int i = 0; i < pritnerCount; i++) {
PrinterInfo printer = mPrinters.valueAt(i);
pw.append(prefix).append(tab).append(tab).append(
printer.toString()).println();
}
}
private void removePrintersForServiceLocked(ComponentName serviceName) {
// No printers - nothing to do.
if (mPrinters.isEmpty()) {
return;
}
// Remove the printers for that service.
List<PrinterId> removedPrinterIds = null;
final int printerCount = mPrinters.size();
for (int i = 0; i < printerCount; i++) {
PrinterId printerId = mPrinters.keyAt(i);
if (printerId.getServiceName().equals(serviceName)) {
if (removedPrinterIds == null) {
removedPrinterIds = new ArrayList<PrinterId>();
}
removedPrinterIds.add(printerId);
}
}
if (removedPrinterIds != null) {
final int removedPrinterCount = removedPrinterIds.size();
for (int i = 0; i < removedPrinterCount; i++) {
mPrinters.remove(removedPrinterIds.get(i));
}
mHandler.obtainMessage(
SessionHandler.MSG_DISPATCH_PRINTERS_REMOVED,
removedPrinterIds).sendToTarget();
}
}
private void handleDispatchPrintersAdded(List<PrinterInfo> addedPrinters) {
final int observerCount = mDiscoveryObservers.beginBroadcast();
for (int i = 0; i < observerCount; i++) {
IPrinterDiscoveryObserver observer = mDiscoveryObservers.getBroadcastItem(i);
handlePrintersAdded(observer, addedPrinters);
}
mDiscoveryObservers.finishBroadcast();
}
private void handleDispatchPrintersRemoved(List<PrinterId> removedPrinterIds) {
final int observerCount = mDiscoveryObservers.beginBroadcast();
for (int i = 0; i < observerCount; i++) {
IPrinterDiscoveryObserver observer = mDiscoveryObservers.getBroadcastItem(i);
handlePrintersRemoved(observer, removedPrinterIds);
}
mDiscoveryObservers.finishBroadcast();
}
private void handleDispatchCreatePrinterDiscoverySession(
List<RemotePrintService> services) {
final int serviceCount = services.size();
for (int i = 0; i < serviceCount; i++) {
RemotePrintService service = services.get(i);
service.createPrinterDiscoverySession();
}
}
private void handleDispatchDestroyPrinterDiscoverySession(
List<RemotePrintService> services) {
final int serviceCount = services.size();
for (int i = 0; i < serviceCount; i++) {
RemotePrintService service = services.get(i);
service.destroyPrinterDiscoverySession();
}
onDestroyed();
}
private void handleDispatchStartPrinterDiscovery(
List<RemotePrintService> services, List<PrinterId> printerIds) {
final int serviceCount = services.size();
for (int i = 0; i < serviceCount; i++) {
RemotePrintService service = services.get(i);
service.startPrinterDiscovery(printerIds);
}
}
private void handleDispatchStopPrinterDiscovery(List<RemotePrintService> services) {
final int serviceCount = services.size();
for (int i = 0; i < serviceCount; i++) {
RemotePrintService service = services.get(i);
service.stopPrinterDiscovery();
}
}
private void handleValidatePrinters(RemotePrintService service,
List<PrinterId> printerIds) {
service.validatePrinters(printerIds);
}
private void handleStartPrinterStateTracking(RemotePrintService service,
PrinterId printerId) {
service.startPrinterStateTracking(printerId);
}
private void handleStopPrinterStateTracking(RemotePrintService service,
PrinterId printerId) {
service.stopPrinterStateTracking(printerId);
}
private void handlePrintersAdded(IPrinterDiscoveryObserver observer,
List<PrinterInfo> printers) {
try {
observer.onPrintersAdded(new ParceledListSlice<PrinterInfo>(printers));
} catch (RemoteException re) {
Log.e(LOG_TAG, "Error sending added printers", re);
}
}
private void handlePrintersRemoved(IPrinterDiscoveryObserver observer,
List<PrinterId> printerIds) {
try {
observer.onPrintersRemoved(new ParceledListSlice<PrinterId>(printerIds));
} catch (RemoteException re) {
Log.e(LOG_TAG, "Error sending removed printers", re);
}
}
private final class SessionHandler extends Handler {
public static final int MSG_PRINTERS_ADDED = 1;
public static final int MSG_PRINTERS_REMOVED = 2;
public static final int MSG_DISPATCH_PRINTERS_ADDED = 3;
public static final int MSG_DISPATCH_PRINTERS_REMOVED = 4;
public static final int MSG_CREATE_PRINTER_DISCOVERY_SESSION = 5;
public static final int MSG_DESTROY_PRINTER_DISCOVERY_SESSION = 6;
public static final int MSG_START_PRINTER_DISCOVERY = 7;
public static final int MSG_STOP_PRINTER_DISCOVERY = 8;
public static final int MSG_DISPATCH_CREATE_PRINTER_DISCOVERY_SESSION = 9;
public static final int MSG_DISPATCH_DESTROY_PRINTER_DISCOVERY_SESSION = 10;
public static final int MSG_DISPATCH_START_PRINTER_DISCOVERY = 11;
public static final int MSG_DISPATCH_STOP_PRINTER_DISCOVERY = 12;
public static final int MSG_VALIDATE_PRINTERS = 13;
public static final int MSG_START_PRINTER_STATE_TRACKING = 14;
public static final int MSG_STOP_PRINTER_STATE_TRACKING = 15;
public static final int MSG_DESTROY_SERVICE = 16;
SessionHandler(Looper looper) {
super(looper, null, false);
}
@Override
@SuppressWarnings("unchecked")
public void handleMessage(Message message) {
switch (message.what) {
case MSG_PRINTERS_ADDED: {
SomeArgs args = (SomeArgs) message.obj;
IPrinterDiscoveryObserver observer = (IPrinterDiscoveryObserver) args.arg1;
List<PrinterInfo> addedPrinters = (List<PrinterInfo>) args.arg2;
args.recycle();
handlePrintersAdded(observer, addedPrinters);
} break;
case MSG_PRINTERS_REMOVED: {
SomeArgs args = (SomeArgs) message.obj;
IPrinterDiscoveryObserver observer = (IPrinterDiscoveryObserver) args.arg1;
List<PrinterId> removedPrinterIds = (List<PrinterId>) args.arg2;
args.recycle();
handlePrintersRemoved(observer, removedPrinterIds);
}
case MSG_DISPATCH_PRINTERS_ADDED: {
List<PrinterInfo> addedPrinters = (List<PrinterInfo>) message.obj;
handleDispatchPrintersAdded(addedPrinters);
} break;
case MSG_DISPATCH_PRINTERS_REMOVED: {
List<PrinterId> removedPrinterIds = (List<PrinterId>) message.obj;
handleDispatchPrintersRemoved(removedPrinterIds);
} break;
case MSG_CREATE_PRINTER_DISCOVERY_SESSION: {
RemotePrintService service = (RemotePrintService) message.obj;
service.createPrinterDiscoverySession();
} break;
case MSG_DESTROY_PRINTER_DISCOVERY_SESSION: {
RemotePrintService service = (RemotePrintService) message.obj;
service.destroyPrinterDiscoverySession();
} break;
case MSG_START_PRINTER_DISCOVERY: {
RemotePrintService service = (RemotePrintService) message.obj;
service.startPrinterDiscovery(null);
} break;
case MSG_STOP_PRINTER_DISCOVERY: {
RemotePrintService service = (RemotePrintService) message.obj;
service.stopPrinterDiscovery();
} break;
case MSG_DISPATCH_CREATE_PRINTER_DISCOVERY_SESSION: {
List<RemotePrintService> services = (List<RemotePrintService>) message.obj;
handleDispatchCreatePrinterDiscoverySession(services);
} break;
case MSG_DISPATCH_DESTROY_PRINTER_DISCOVERY_SESSION: {
List<RemotePrintService> services = (List<RemotePrintService>) message.obj;
handleDispatchDestroyPrinterDiscoverySession(services);
} break;
case MSG_DISPATCH_START_PRINTER_DISCOVERY: {
SomeArgs args = (SomeArgs) message.obj;
List<RemotePrintService> services = (List<RemotePrintService>) args.arg1;
List<PrinterId> printerIds = (List<PrinterId>) args.arg2;
args.recycle();
handleDispatchStartPrinterDiscovery(services, printerIds);
} break;
case MSG_DISPATCH_STOP_PRINTER_DISCOVERY: {
List<RemotePrintService> services = (List<RemotePrintService>) message.obj;
handleDispatchStopPrinterDiscovery(services);
} break;
case MSG_VALIDATE_PRINTERS: {
SomeArgs args = (SomeArgs) message.obj;
RemotePrintService service = (RemotePrintService) args.arg1;
List<PrinterId> printerIds = (List<PrinterId>) args.arg2;
args.recycle();
handleValidatePrinters(service, printerIds);
} break;
case MSG_START_PRINTER_STATE_TRACKING: {
SomeArgs args = (SomeArgs) message.obj;
RemotePrintService service = (RemotePrintService) args.arg1;
PrinterId printerId = (PrinterId) args.arg2;
args.recycle();
handleStartPrinterStateTracking(service, printerId);
} break;
case MSG_STOP_PRINTER_STATE_TRACKING: {
SomeArgs args = (SomeArgs) message.obj;
RemotePrintService service = (RemotePrintService) args.arg1;
PrinterId printerId = (PrinterId) args.arg2;
args.recycle();
handleStopPrinterStateTracking(service, printerId);
} break;
case MSG_DESTROY_SERVICE: {
RemotePrintService service = (RemotePrintService) message.obj;
service.destroy();
} break;
}
}
}
}
private final class PrintJobForAppCache {
private final SparseArray<List<PrintJobInfo>> mPrintJobsForRunningApp =
new SparseArray<List<PrintJobInfo>>();
public boolean onPrintJobCreated(final IBinder creator, final int appId,
PrintJobInfo printJob) {
try {
creator.linkToDeath(new DeathRecipient() {
@Override
public void binderDied() {
creator.unlinkToDeath(this, 0);
synchronized (mLock) {
mPrintJobsForRunningApp.remove(appId);
}
}
}, 0);
} catch (RemoteException re) {
/* The process is already dead - we just failed. */
return false;
}
synchronized (mLock) {
List<PrintJobInfo> printJobsForApp = mPrintJobsForRunningApp.get(appId);
if (printJobsForApp == null) {
printJobsForApp = new ArrayList<PrintJobInfo>();
mPrintJobsForRunningApp.put(appId, printJobsForApp);
}
printJobsForApp.add(printJob);
}
return true;
}
public void onPrintJobStateChanged(PrintJobInfo printJob) {
synchronized (mLock) {
List<PrintJobInfo> printJobsForApp = mPrintJobsForRunningApp.get(
printJob.getAppId());
if (printJobsForApp == null) {
return;
}
final int printJobCount = printJobsForApp.size();
for (int i = 0; i < printJobCount; i++) {
PrintJobInfo oldPrintJob = printJobsForApp.get(i);
if (oldPrintJob.getId().equals(printJob.getId())) {
printJobsForApp.set(i, printJob);
}
}
}
}
public PrintJobInfo getPrintJob(PrintJobId printJobId, int appId) {
synchronized (mLock) {
List<PrintJobInfo> printJobsForApp = mPrintJobsForRunningApp.get(appId);
if (printJobsForApp == null) {
return null;
}
final int printJobCount = printJobsForApp.size();
for (int i = 0; i < printJobCount; i++) {
PrintJobInfo printJob = printJobsForApp.get(i);
if (printJob.getId().equals(printJobId)) {
return printJob;
}
}
}
return null;
}
public List<PrintJobInfo> getPrintJobs(int appId) {
synchronized (mLock) {
List<PrintJobInfo> printJobs = null;
if (appId == PrintManager.APP_ID_ANY) {
final int bucketCount = mPrintJobsForRunningApp.size();
for (int i = 0; i < bucketCount; i++) {
List<PrintJobInfo> bucket = mPrintJobsForRunningApp.valueAt(i);
if (printJobs == null) {
printJobs = new ArrayList<PrintJobInfo>();
}
printJobs.addAll(bucket);
}
} else {
List<PrintJobInfo> bucket = mPrintJobsForRunningApp.get(appId);
if (bucket != null) {
if (printJobs == null) {
printJobs = new ArrayList<PrintJobInfo>();
}
printJobs.addAll(bucket);
}
}
if (printJobs != null) {
return printJobs;
}
return Collections.emptyList();
}
}
public void dump(PrintWriter pw, String prefix) {
synchronized (mLock) {
String tab = " ";
final int bucketCount = mPrintJobsForRunningApp.size();
for (int i = 0; i < bucketCount; i++) {
final int appId = mPrintJobsForRunningApp.keyAt(i);
pw.append(prefix).append("appId=" + appId).append(':').println();
List<PrintJobInfo> bucket = mPrintJobsForRunningApp.valueAt(i);
final int printJobCount = bucket.size();
for (int j = 0; j < printJobCount; j++) {
PrintJobInfo printJob = bucket.get(j);
pw.append(prefix).append(tab).append(printJob.toString()).println();
}
}
}
}
}
}