2fbd2a7f07
1. The UI of a printing app was freezing a little when calling the print method since the print manager service was waiting for it to bind to the print spooler which generated the print job id (and the initial print job info really). Now the print manager service is responsible for job id generation and does not not wait for the print spooler to spin. Hence, the app UI is not blocked at all. Note that the print manager initiates the binding to the spooler and as soon as it completes the spooler shows the print UI which is hosted in its process. It is not possible to show the print UI before the system is bound to the spooler since during this binding the system passes a callback to the spooler so the latter can talk to the system. 2. Changed the print job id to be an opaque class allowing us to vary the way we generate print job ids in the future. 3. The queued print job state was hidden but the print job returned by the print method of the print manager is in that state. Now now hidden. 4. We were incorrecly removing print job infos if they are completed or cancelled. Doing that is problematic since the print job returned by the print method allows the app to query for the job info after the job has been say completed. Hence, an app can initiate printing and get a print job whose state is "created" and hold onto it until after the job is completed, now if the app asks for the print job info it will get an info in "created" state even though the job is "completed" since the spooler was not retaining the completed jobs. Now the spooler removes the PDF files for the completed and cancelled print jobs but keeps around the infos (also persisting them to disc) so it can answer questions about them. On first boot or switch to a user we purge the persisted print jobs in completed/cancelled state since they are obsolete - no app can have a handle to them. 5. Removed the print method that takes a file since we have a public PrintDocumentAdapter implementation for printing files. Once can instantiate a PrintFileDocumentAdapter and pass it to the print method. This class also allows overriding of the finish method to know when the data is spooled and deleted the file if desired, etc. 6. Replaced the wrong code to slice a large list of parcelables to use ParceledListSlice class. bug:10748093 Change-Id: I1ebeeb47576e88fce550851cdd3e401fcede6e2b
808 lines
29 KiB
Java
808 lines
29 KiB
Java
/*
|
|
* 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.content.ComponentName;
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.ServiceConnection;
|
|
import android.content.pm.ParceledListSlice;
|
|
import android.os.Binder;
|
|
import android.os.Handler;
|
|
import android.os.IBinder;
|
|
import android.os.IBinder.DeathRecipient;
|
|
import android.os.Looper;
|
|
import android.os.Message;
|
|
import android.os.ParcelFileDescriptor;
|
|
import android.os.RemoteException;
|
|
import android.os.UserHandle;
|
|
import android.print.PrintJobId;
|
|
import android.print.PrintJobInfo;
|
|
import android.print.PrintManager;
|
|
import android.print.PrinterId;
|
|
import android.print.PrinterInfo;
|
|
import android.printservice.IPrintService;
|
|
import android.printservice.IPrintServiceClient;
|
|
import android.util.Slog;
|
|
|
|
import java.io.PrintWriter;
|
|
import java.lang.ref.WeakReference;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/**
|
|
* This class represents a remote print service. It abstracts away the binding
|
|
* and unbinding from the remote implementation. Clients can call methods of
|
|
* this class without worrying about when and how to bind/unbind.
|
|
*/
|
|
final class RemotePrintService implements DeathRecipient {
|
|
|
|
private static final String LOG_TAG = "RemotePrintService";
|
|
|
|
private static final boolean DEBUG = false;
|
|
|
|
private final Context mContext;
|
|
|
|
private final ComponentName mComponentName;
|
|
|
|
private final Intent mIntent;
|
|
|
|
private final RemotePrintSpooler mSpooler;
|
|
|
|
private final PrintServiceCallbacks mCallbacks;
|
|
|
|
private final int mUserId;
|
|
|
|
private final List<Runnable> mPendingCommands = new ArrayList<Runnable>();
|
|
|
|
private final ServiceConnection mServiceConnection = new RemoteServiceConneciton();
|
|
|
|
private final RemotePrintServiceClient mPrintServiceClient;
|
|
|
|
private final Handler mHandler;
|
|
|
|
private IPrintService mPrintService;
|
|
|
|
private boolean mBinding;
|
|
|
|
private boolean mDestroyed;
|
|
|
|
private boolean mHasActivePrintJobs;
|
|
|
|
private boolean mHasPrinterDiscoverySession;
|
|
|
|
private boolean mServiceDead;
|
|
|
|
private List<PrinterId> mDiscoveryPriorityList;
|
|
|
|
private List<PrinterId> mTrackedPrinterList;
|
|
|
|
public static interface PrintServiceCallbacks {
|
|
public void onPrintersAdded(List<PrinterInfo> printers);
|
|
public void onPrintersRemoved(List<PrinterId> printerIds);
|
|
public void onServiceDied(RemotePrintService service);
|
|
}
|
|
|
|
public RemotePrintService(Context context, ComponentName componentName, int userId,
|
|
RemotePrintSpooler spooler, PrintServiceCallbacks callbacks) {
|
|
mContext = context;
|
|
mCallbacks = callbacks;
|
|
mComponentName = componentName;
|
|
mIntent = new Intent().setComponent(mComponentName);
|
|
mUserId = userId;
|
|
mSpooler = spooler;
|
|
mHandler = new MyHandler(context.getMainLooper());
|
|
mPrintServiceClient = new RemotePrintServiceClient(this);
|
|
mServiceDead = true;
|
|
}
|
|
|
|
public ComponentName getComponentName() {
|
|
return mComponentName;
|
|
}
|
|
|
|
public void destroy() {
|
|
mHandler.sendEmptyMessage(MyHandler.MSG_DESTROY);
|
|
}
|
|
|
|
private void handleDestroy() {
|
|
throwIfDestroyed();
|
|
|
|
// Stop tracking printers.
|
|
if (mTrackedPrinterList != null) {
|
|
final int trackedPrinterCount = mTrackedPrinterList.size();
|
|
for (int i = 0; i < trackedPrinterCount; i++) {
|
|
PrinterId printerId = mTrackedPrinterList.get(i);
|
|
if (printerId.getServiceName().equals(mComponentName)) {
|
|
handleStopPrinterStateTracking(printerId);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Stop printer discovery.
|
|
if (mDiscoveryPriorityList != null) {
|
|
handleStopPrinterDiscovery();
|
|
}
|
|
|
|
// Destroy the discovery session.
|
|
if (mHasPrinterDiscoverySession) {
|
|
handleDestroyPrinterDiscoverySession();
|
|
}
|
|
|
|
// Unbind.
|
|
ensureUnbound();
|
|
|
|
// Done
|
|
mDestroyed = true;
|
|
}
|
|
|
|
@Override
|
|
public void binderDied() {
|
|
mHandler.sendEmptyMessage(MyHandler.MSG_BINDER_DIED);
|
|
}
|
|
|
|
private void handleBinderDied() {
|
|
mPrintService.asBinder().unlinkToDeath(this, 0);
|
|
mPrintService = null;
|
|
mServiceDead = true;
|
|
mCallbacks.onServiceDied(this);
|
|
}
|
|
|
|
public void onAllPrintJobsHandled() {
|
|
mHandler.sendEmptyMessage(MyHandler.MSG_ON_ALL_PRINT_JOBS_HANDLED);
|
|
}
|
|
|
|
private void handleOnAllPrintJobsHandled() {
|
|
throwIfDestroyed();
|
|
mHasActivePrintJobs = false;
|
|
if (!isBound()) {
|
|
// The service is dead and neither has active jobs nor discovery
|
|
// session, so ensure we are unbound since the service has no work.
|
|
if (mServiceDead && !mHasPrinterDiscoverySession) {
|
|
ensureUnbound();
|
|
return;
|
|
}
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleOnAllPrintJobsHandled();
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] onAllPrintJobsHandled()");
|
|
}
|
|
// If the service has a printer discovery session
|
|
// created we should not disconnect from it just yet.
|
|
if (!mHasPrinterDiscoverySession) {
|
|
ensureUnbound();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onRequestCancelPrintJob(PrintJobInfo printJob) {
|
|
mHandler.obtainMessage(MyHandler.MSG_ON_REQUEST_CANCEL_PRINT_JOB,
|
|
printJob).sendToTarget();
|
|
}
|
|
|
|
private void handleRequestCancelPrintJob(final PrintJobInfo printJob) {
|
|
throwIfDestroyed();
|
|
if (!isBound()) {
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleRequestCancelPrintJob(printJob);
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] requestCancelPrintJob()");
|
|
}
|
|
try {
|
|
mPrintService.requestCancelPrintJob(printJob);
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error canceling a pring job.", re);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void onPrintJobQueued(PrintJobInfo printJob) {
|
|
mHandler.obtainMessage(MyHandler.MSG_ON_PRINT_JOB_QUEUED,
|
|
printJob).sendToTarget();
|
|
}
|
|
|
|
private void handleOnPrintJobQueued(final PrintJobInfo printJob) {
|
|
throwIfDestroyed();
|
|
mHasActivePrintJobs = true;
|
|
if (!isBound()) {
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleOnPrintJobQueued(printJob);
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] onPrintJobQueued()");
|
|
}
|
|
try {
|
|
mPrintService.onPrintJobQueued(printJob);
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error announcing queued pring job.", re);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void createPrinterDiscoverySession() {
|
|
mHandler.sendEmptyMessage(MyHandler.MSG_CREATE_PRINTER_DISCOVERY_SESSION);
|
|
}
|
|
|
|
private void handleCreatePrinterDiscoverySession() {
|
|
throwIfDestroyed();
|
|
mHasPrinterDiscoverySession = true;
|
|
if (!isBound()) {
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleCreatePrinterDiscoverySession();
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] createPrinterDiscoverySession()");
|
|
}
|
|
try {
|
|
mPrintService.createPrinterDiscoverySession();
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error creating printer dicovery session.", re);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void destroyPrinterDiscoverySession() {
|
|
mHandler.sendEmptyMessage(MyHandler.MSG_DESTROY_PRINTER_DISCOVERY_SESSION);
|
|
}
|
|
|
|
private void handleDestroyPrinterDiscoverySession() {
|
|
throwIfDestroyed();
|
|
mHasPrinterDiscoverySession = false;
|
|
if (!isBound()) {
|
|
// The service is dead and neither has active jobs nor discovery
|
|
// session, so ensure we are unbound since the service has no work.
|
|
if (mServiceDead && !mHasActivePrintJobs) {
|
|
ensureUnbound();
|
|
return;
|
|
}
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleDestroyPrinterDiscoverySession();
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] destroyPrinterDiscoverySession()");
|
|
}
|
|
try {
|
|
mPrintService.destroyPrinterDiscoverySession();
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error destroying printer dicovery session.", re);
|
|
}
|
|
// If the service has no print jobs and no active discovery
|
|
// session anymore we should disconnect from it.
|
|
if (!mHasActivePrintJobs) {
|
|
ensureUnbound();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void startPrinterDiscovery(List<PrinterId> priorityList) {
|
|
mHandler.obtainMessage(MyHandler.MSG_START_PRINTER_DISCOVERY,
|
|
priorityList).sendToTarget();
|
|
}
|
|
|
|
private void handleStartPrinterDiscovery(final List<PrinterId> priorityList) {
|
|
throwIfDestroyed();
|
|
// Take a note that we are doing discovery.
|
|
mDiscoveryPriorityList = new ArrayList<PrinterId>();
|
|
if (priorityList != null) {
|
|
mDiscoveryPriorityList.addAll(priorityList);
|
|
}
|
|
if (!isBound()) {
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleStartPrinterDiscovery(priorityList);
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] startPrinterDiscovery()");
|
|
}
|
|
try {
|
|
mPrintService.startPrinterDiscovery(priorityList);
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error starting printer dicovery.", re);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopPrinterDiscovery() {
|
|
mHandler.sendEmptyMessage(MyHandler.MSG_STOP_PRINTER_DISCOVERY);
|
|
}
|
|
|
|
private void handleStopPrinterDiscovery() {
|
|
throwIfDestroyed();
|
|
// We are not doing discovery anymore.
|
|
mDiscoveryPriorityList = null;
|
|
if (!isBound()) {
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleStopPrinterDiscovery();
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] stopPrinterDiscovery()");
|
|
}
|
|
try {
|
|
mPrintService.stopPrinterDiscovery();
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error stopping printer dicovery.", re);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void validatePrinters(List<PrinterId> printerIds) {
|
|
mHandler.obtainMessage(MyHandler.MSG_VALIDATE_PRINTERS,
|
|
printerIds).sendToTarget();
|
|
}
|
|
|
|
private void handleValidatePrinters(final List<PrinterId> printerIds) {
|
|
throwIfDestroyed();
|
|
if (!isBound()) {
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleValidatePrinters(printerIds);
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] validatePrinters()");
|
|
}
|
|
try {
|
|
mPrintService.validatePrinters(printerIds);
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error requesting printers validation.", re);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void startPrinterStateTracking(PrinterId printerId) {
|
|
mHandler.obtainMessage(MyHandler.MSG_START_PRINTER_STATE_TRACKING,
|
|
printerId).sendToTarget();
|
|
}
|
|
|
|
private void handleStartPrinterStateTracking(final PrinterId printerId) {
|
|
throwIfDestroyed();
|
|
// Take a note we are tracking the printer.
|
|
if (mTrackedPrinterList == null) {
|
|
mTrackedPrinterList = new ArrayList<PrinterId>();
|
|
}
|
|
mTrackedPrinterList.add(printerId);
|
|
if (!isBound()) {
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleStartPrinterStateTracking(printerId);
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] startPrinterTracking()");
|
|
}
|
|
try {
|
|
mPrintService.startPrinterStateTracking(printerId);
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error requesting start printer tracking.", re);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopPrinterStateTracking(PrinterId printerId) {
|
|
mHandler.obtainMessage(MyHandler.MSG_STOP_PRINTER_STATE_TRACKING,
|
|
printerId).sendToTarget();
|
|
}
|
|
|
|
private void handleStopPrinterStateTracking(final PrinterId printerId) {
|
|
throwIfDestroyed();
|
|
// We are no longer tracking the printer.
|
|
if (mTrackedPrinterList == null || !mTrackedPrinterList.remove(printerId)) {
|
|
return;
|
|
}
|
|
if (mTrackedPrinterList.isEmpty()) {
|
|
mTrackedPrinterList = null;
|
|
}
|
|
if (!isBound()) {
|
|
ensureBound();
|
|
mPendingCommands.add(new Runnable() {
|
|
@Override
|
|
public void run() {
|
|
handleStopPrinterStateTracking(printerId);
|
|
}
|
|
});
|
|
} else {
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] stopPrinterTracking()");
|
|
}
|
|
try {
|
|
mPrintService.stopPrinterStateTracking(printerId);
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error requesting stop printer tracking.", re);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void dump(PrintWriter pw, String prefix) {
|
|
String tab = " ";
|
|
pw.append(prefix).append("service:").println();
|
|
pw.append(prefix).append(tab).append("componentName=")
|
|
.append(mComponentName.flattenToString()).println();
|
|
pw.append(prefix).append(tab).append("destroyed=")
|
|
.append(String.valueOf(mDestroyed)).println();
|
|
pw.append(prefix).append(tab).append("bound=")
|
|
.append(String.valueOf(isBound())).println();
|
|
pw.append(prefix).append(tab).append("hasDicoverySession=")
|
|
.append(String.valueOf(mHasPrinterDiscoverySession)).println();
|
|
pw.append(prefix).append(tab).append("hasActivePrintJobs=")
|
|
.append(String.valueOf(mHasActivePrintJobs)).println();
|
|
pw.append(prefix).append(tab).append("isDiscoveringPrinters=")
|
|
.append(String.valueOf(mDiscoveryPriorityList != null)).println();
|
|
pw.append(prefix).append(tab).append("trackedPrinters=")
|
|
.append((mTrackedPrinterList != null) ? mTrackedPrinterList.toString() : "null");
|
|
}
|
|
|
|
private boolean isBound() {
|
|
return mPrintService != null;
|
|
}
|
|
|
|
private void ensureBound() {
|
|
if (isBound() || mBinding) {
|
|
return;
|
|
}
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] ensureBound()");
|
|
}
|
|
mBinding = true;
|
|
mContext.bindServiceAsUser(mIntent, mServiceConnection,
|
|
Context.BIND_AUTO_CREATE, new UserHandle(mUserId));
|
|
}
|
|
|
|
private void ensureUnbound() {
|
|
if (!isBound() && !mBinding) {
|
|
return;
|
|
}
|
|
if (DEBUG) {
|
|
Slog.i(LOG_TAG, "[user: " + mUserId + "] ensureUnbound()");
|
|
}
|
|
mBinding = false;
|
|
mPendingCommands.clear();
|
|
mHasActivePrintJobs = false;
|
|
mHasPrinterDiscoverySession = false;
|
|
mDiscoveryPriorityList = null;
|
|
mTrackedPrinterList = null;
|
|
if (isBound()) {
|
|
try {
|
|
mPrintService.setClient(null);
|
|
} catch (RemoteException re) {
|
|
/* ignore */
|
|
}
|
|
mPrintService.asBinder().unlinkToDeath(this, 0);
|
|
mPrintService = null;
|
|
mContext.unbindService(mServiceConnection);
|
|
}
|
|
}
|
|
|
|
private void throwIfDestroyed() {
|
|
if (mDestroyed) {
|
|
throw new IllegalStateException("Cannot interact with a destroyed service");
|
|
}
|
|
}
|
|
|
|
private class RemoteServiceConneciton implements ServiceConnection {
|
|
@Override
|
|
public void onServiceConnected(ComponentName name, IBinder service) {
|
|
if (mDestroyed || !mBinding) {
|
|
mContext.unbindService(mServiceConnection);
|
|
return;
|
|
}
|
|
mBinding = false;
|
|
mPrintService = IPrintService.Stub.asInterface(service);
|
|
try {
|
|
service.linkToDeath(RemotePrintService.this, 0);
|
|
} catch (RemoteException re) {
|
|
handleBinderDied();
|
|
return;
|
|
}
|
|
try {
|
|
mPrintService.setClient(mPrintServiceClient);
|
|
} catch (RemoteException re) {
|
|
Slog.e(LOG_TAG, "Error setting client for: " + service, re);
|
|
handleBinderDied();
|
|
return;
|
|
}
|
|
// If the service died and there is a discovery session, recreate it.
|
|
if (mServiceDead && mHasPrinterDiscoverySession) {
|
|
handleCreatePrinterDiscoverySession();
|
|
}
|
|
// If the service died and there is discovery started, restart it.
|
|
if (mServiceDead && mDiscoveryPriorityList != null) {
|
|
handleStartPrinterDiscovery(mDiscoveryPriorityList);
|
|
}
|
|
// If the service died and printers were tracked, start tracking.
|
|
if (mServiceDead && mTrackedPrinterList != null) {
|
|
final int trackedPrinterCount = mTrackedPrinterList.size();
|
|
for (int i = 0; i < trackedPrinterCount; i++) {
|
|
handleStartPrinterStateTracking(mTrackedPrinterList.get(i));
|
|
}
|
|
}
|
|
// Finally, do all the pending work.
|
|
while (!mPendingCommands.isEmpty()) {
|
|
Runnable pendingCommand = mPendingCommands.remove(0);
|
|
pendingCommand.run();
|
|
}
|
|
// We did a best effort to get to the last state if we crashed.
|
|
// If we do not have print jobs and no discovery is in progress,
|
|
// then no need to be bound.
|
|
if (!mHasPrinterDiscoverySession && !mHasActivePrintJobs) {
|
|
ensureUnbound();
|
|
}
|
|
mServiceDead = false;
|
|
}
|
|
|
|
@Override
|
|
public void onServiceDisconnected(ComponentName name) {
|
|
mBinding = true;
|
|
}
|
|
}
|
|
|
|
private final class MyHandler extends Handler {
|
|
public static final int MSG_CREATE_PRINTER_DISCOVERY_SESSION = 1;
|
|
public static final int MSG_DESTROY_PRINTER_DISCOVERY_SESSION = 2;
|
|
public static final int MSG_START_PRINTER_DISCOVERY = 3;
|
|
public static final int MSG_STOP_PRINTER_DISCOVERY = 4;
|
|
public static final int MSG_VALIDATE_PRINTERS = 5;
|
|
public static final int MSG_START_PRINTER_STATE_TRACKING = 6;
|
|
public static final int MSG_STOP_PRINTER_STATE_TRACKING = 7;
|
|
public static final int MSG_ON_ALL_PRINT_JOBS_HANDLED = 8;
|
|
public static final int MSG_ON_REQUEST_CANCEL_PRINT_JOB = 9;
|
|
public static final int MSG_ON_PRINT_JOB_QUEUED = 10;
|
|
public static final int MSG_DESTROY = 11;
|
|
public static final int MSG_BINDER_DIED = 12;
|
|
|
|
public MyHandler(Looper looper) {
|
|
super(looper, null, false);
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings("unchecked")
|
|
public void handleMessage(Message message) {
|
|
switch (message.what) {
|
|
case MSG_CREATE_PRINTER_DISCOVERY_SESSION: {
|
|
handleCreatePrinterDiscoverySession();
|
|
} break;
|
|
|
|
case MSG_DESTROY_PRINTER_DISCOVERY_SESSION: {
|
|
handleDestroyPrinterDiscoverySession();
|
|
} break;
|
|
|
|
case MSG_START_PRINTER_DISCOVERY: {
|
|
List<PrinterId> priorityList = (ArrayList<PrinterId>) message.obj;
|
|
handleStartPrinterDiscovery(priorityList);
|
|
} break;
|
|
|
|
case MSG_STOP_PRINTER_DISCOVERY: {
|
|
handleStopPrinterDiscovery();
|
|
} break;
|
|
|
|
case MSG_VALIDATE_PRINTERS: {
|
|
List<PrinterId> printerIds = (List<PrinterId>) message.obj;
|
|
handleValidatePrinters(printerIds);
|
|
} break;
|
|
|
|
case MSG_START_PRINTER_STATE_TRACKING: {
|
|
PrinterId printerId = (PrinterId) message.obj;
|
|
handleStartPrinterStateTracking(printerId);
|
|
} break;
|
|
|
|
case MSG_STOP_PRINTER_STATE_TRACKING: {
|
|
PrinterId printerId = (PrinterId) message.obj;
|
|
handleStopPrinterStateTracking(printerId);
|
|
} break;
|
|
|
|
case MSG_ON_ALL_PRINT_JOBS_HANDLED: {
|
|
handleOnAllPrintJobsHandled();
|
|
} break;
|
|
|
|
case MSG_ON_REQUEST_CANCEL_PRINT_JOB: {
|
|
PrintJobInfo printJob = (PrintJobInfo) message.obj;
|
|
handleRequestCancelPrintJob(printJob);
|
|
} break;
|
|
|
|
case MSG_ON_PRINT_JOB_QUEUED: {
|
|
PrintJobInfo printJob = (PrintJobInfo) message.obj;
|
|
handleOnPrintJobQueued(printJob);
|
|
} break;
|
|
|
|
case MSG_DESTROY: {
|
|
handleDestroy();
|
|
} break;
|
|
|
|
case MSG_BINDER_DIED: {
|
|
handleBinderDied();
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static final class RemotePrintServiceClient extends IPrintServiceClient.Stub {
|
|
private final WeakReference<RemotePrintService> mWeakService;
|
|
|
|
public RemotePrintServiceClient(RemotePrintService service) {
|
|
mWeakService = new WeakReference<RemotePrintService>(service);
|
|
}
|
|
|
|
@Override
|
|
public List<PrintJobInfo> getPrintJobInfos() {
|
|
RemotePrintService service = mWeakService.get();
|
|
if (service != null) {
|
|
final long identity = Binder.clearCallingIdentity();
|
|
try {
|
|
return service.mSpooler.getPrintJobInfos(service.mComponentName,
|
|
PrintJobInfo.STATE_ANY_VISIBLE_TO_CLIENTS, PrintManager.APP_ID_ANY);
|
|
} finally {
|
|
Binder.restoreCallingIdentity(identity);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public PrintJobInfo getPrintJobInfo(PrintJobId printJobId) {
|
|
RemotePrintService service = mWeakService.get();
|
|
if (service != null) {
|
|
final long identity = Binder.clearCallingIdentity();
|
|
try {
|
|
return service.mSpooler.getPrintJobInfo(printJobId,
|
|
PrintManager.APP_ID_ANY);
|
|
} finally {
|
|
Binder.restoreCallingIdentity(identity);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public boolean setPrintJobState(PrintJobId printJobId, int state, String error) {
|
|
RemotePrintService service = mWeakService.get();
|
|
if (service != null) {
|
|
final long identity = Binder.clearCallingIdentity();
|
|
try {
|
|
return service.mSpooler.setPrintJobState(printJobId, state, error);
|
|
} finally {
|
|
Binder.restoreCallingIdentity(identity);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean setPrintJobTag(PrintJobId printJobId, String tag) {
|
|
RemotePrintService service = mWeakService.get();
|
|
if (service != null) {
|
|
final long identity = Binder.clearCallingIdentity();
|
|
try {
|
|
return service.mSpooler.setPrintJobTag(printJobId, tag);
|
|
} finally {
|
|
Binder.restoreCallingIdentity(identity);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void writePrintJobData(ParcelFileDescriptor fd, PrintJobId printJobId) {
|
|
RemotePrintService service = mWeakService.get();
|
|
if (service != null) {
|
|
final long identity = Binder.clearCallingIdentity();
|
|
try {
|
|
service.mSpooler.writePrintJobData(fd, printJobId);
|
|
} finally {
|
|
Binder.restoreCallingIdentity(identity);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings({"rawtypes", "unchecked"})
|
|
public void onPrintersAdded(ParceledListSlice printers) {
|
|
RemotePrintService service = mWeakService.get();
|
|
if (service != null) {
|
|
List<PrinterInfo> addedPrinters = (List<PrinterInfo>) printers.getList();
|
|
throwIfPrinterIdsForPrinterInfoTampered(service.mComponentName, addedPrinters);
|
|
final long identity = Binder.clearCallingIdentity();
|
|
try {
|
|
service.mCallbacks.onPrintersAdded(addedPrinters);
|
|
} finally {
|
|
Binder.restoreCallingIdentity(identity);
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings({"rawtypes", "unchecked"})
|
|
public void onPrintersRemoved(ParceledListSlice printerIds) {
|
|
RemotePrintService service = mWeakService.get();
|
|
if (service != null) {
|
|
List<PrinterId> removedPrinterIds = (List<PrinterId>) printerIds.getList();
|
|
throwIfPrinterIdsTampered(service.mComponentName, removedPrinterIds);
|
|
final long identity = Binder.clearCallingIdentity();
|
|
try {
|
|
service.mCallbacks.onPrintersRemoved(removedPrinterIds);
|
|
} finally {
|
|
Binder.restoreCallingIdentity(identity);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void throwIfPrinterIdsForPrinterInfoTampered(ComponentName serviceName,
|
|
List<PrinterInfo> printerInfos) {
|
|
final int printerInfoCount = printerInfos.size();
|
|
for (int i = 0; i < printerInfoCount; i++) {
|
|
PrinterId printerId = printerInfos.get(i).getId();
|
|
throwIfPrinterIdTampered(serviceName, printerId);
|
|
}
|
|
}
|
|
|
|
private void throwIfPrinterIdsTampered(ComponentName serviceName,
|
|
List<PrinterId> printerIds) {
|
|
final int printerIdCount = printerIds.size();
|
|
for (int i = 0; i < printerIdCount; i++) {
|
|
PrinterId printerId = printerIds.get(i);
|
|
throwIfPrinterIdTampered(serviceName, printerId);
|
|
}
|
|
}
|
|
|
|
private void throwIfPrinterIdTampered(ComponentName serviceName, PrinterId printerId) {
|
|
if (printerId == null || printerId.getServiceName() == null
|
|
|| !printerId.getServiceName().equals(serviceName)) {
|
|
throw new IllegalArgumentException("Invalid printer id: " + printerId);
|
|
}
|
|
}
|
|
}
|
|
}
|