| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * Copyright (C) 2016 Mopria Alliance, Inc. |
| * |
| * 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.bips; |
| |
| import android.net.Uri; |
| import android.print.PrintJobId; |
| import android.printservice.PrintJob; |
| import android.util.Log; |
| |
| import com.android.bips.discovery.ConnectionListener; |
| import com.android.bips.discovery.DiscoveredPrinter; |
| import com.android.bips.discovery.MdnsDiscovery; |
| import com.android.bips.ipp.Backend; |
| import com.android.bips.ipp.CapabilitiesCache; |
| import com.android.bips.ipp.JobStatus; |
| import com.android.bips.jni.BackendConstants; |
| import com.android.bips.jni.LocalPrinterCapabilities; |
| import com.android.bips.p2p.P2pPrinterConnection; |
| import com.android.bips.p2p.P2pUtils; |
| |
| import java.util.function.Consumer; |
| |
| /** |
| * Manage the process of delivering a print job |
| */ |
| class LocalPrintJob implements MdnsDiscovery.Listener, ConnectionListener, |
| CapabilitiesCache.OnLocalPrinterCapabilities { |
| private static final String TAG = LocalPrintJob.class.getSimpleName(); |
| private static final boolean DEBUG = false; |
| |
| /** Maximum time to wait to find a printer before failing the job */ |
| private static final int DISCOVERY_TIMEOUT = 2 * 60 * 1000; |
| |
| // Internal job states |
| private static final int STATE_INIT = 0; |
| private static final int STATE_DISCOVERY = 1; |
| private static final int STATE_CAPABILITIES = 2; |
| private static final int STATE_DELIVERING = 3; |
| private static final int STATE_CANCEL = 4; |
| private static final int STATE_DONE = 5; |
| |
| private final BuiltInPrintService mPrintService; |
| private final PrintJob mPrintJob; |
| private final Backend mBackend; |
| |
| private int mState; |
| private Consumer<LocalPrintJob> mCompleteConsumer; |
| private Uri mPath; |
| private DelayedAction mDiscoveryTimeout; |
| private P2pPrinterConnection mConnection; |
| |
| /** |
| * Construct the object; use {@link #start(Consumer)} to begin job processing. |
| */ |
| LocalPrintJob(BuiltInPrintService printService, Backend backend, PrintJob printJob) { |
| mPrintService = printService; |
| mBackend = backend; |
| mPrintJob = printJob; |
| mState = STATE_INIT; |
| |
| // Tell the job it is blocked (until start()) |
| mPrintJob.start(); |
| mPrintJob.block(printService.getString(R.string.waiting_to_send)); |
| } |
| |
| /** |
| * Begin the process of delivering the job. Internally, discovers the target printer, |
| * obtains its capabilities, delivers the job to the printer, and waits for job completion. |
| * |
| * @param callback Callback to be issued when job processing is complete |
| */ |
| void start(Consumer<LocalPrintJob> callback) { |
| if (DEBUG) Log.d(TAG, "start() " + mPrintJob); |
| if (mState != STATE_INIT) { |
| Log.w(TAG, "Invalid start state " + mState); |
| return; |
| } |
| mPrintJob.start(); |
| |
| // Acquire a lock so that WiFi isn't put to sleep while we send the job |
| mPrintService.lockWifi(); |
| |
| mState = STATE_DISCOVERY; |
| mCompleteConsumer = callback; |
| mDiscoveryTimeout = mPrintService.delay(DISCOVERY_TIMEOUT, () -> { |
| if (DEBUG) Log.d(TAG, "Discovery timeout"); |
| if (mState == STATE_DISCOVERY) { |
| finish(false, mPrintService.getString(R.string.printer_offline)); |
| } |
| }); |
| |
| mPrintService.getDiscovery().start(this); |
| } |
| |
| void cancel() { |
| if (DEBUG) Log.d(TAG, "cancel() " + mPrintJob + " in state " + mState); |
| |
| switch (mState) { |
| case STATE_DISCOVERY: |
| case STATE_CAPABILITIES: |
| // Cancel immediately |
| mState = STATE_CANCEL; |
| finish(false, null); |
| break; |
| |
| case STATE_DELIVERING: |
| // Request cancel and wait for completion |
| mState = STATE_CANCEL; |
| mBackend.cancel(); |
| break; |
| } |
| } |
| |
| PrintJobId getPrintJobId() { |
| return mPrintJob.getId(); |
| } |
| |
| @Override |
| public void onPrinterFound(DiscoveredPrinter printer) { |
| if (mState != STATE_DISCOVERY) { |
| return; |
| } |
| if (!printer.getId(mPrintService).equals(mPrintJob.getInfo().getPrinterId())) { |
| return; |
| } |
| |
| if (DEBUG) Log.d(TAG, "onPrinterFound() " + printer.name + " state=" + mState); |
| |
| if (P2pUtils.isP2p(printer)) { |
| // Launch a P2P connection attempt |
| mConnection = new P2pPrinterConnection(mPrintService, printer, this); |
| return; |
| } |
| |
| if (P2pUtils.isOnConnectedInterface(mPrintService, printer) && mConnection == null) { |
| // Hold the P2P connection up during printing |
| mConnection = new P2pPrinterConnection(mPrintService, printer, this); |
| } |
| |
| // We have a good path so stop discovering and get capabilities |
| mPrintService.getDiscovery().stop(this); |
| mState = STATE_CAPABILITIES; |
| mPath = printer.path; |
| mPrintService.getCapabilitiesCache().request(printer, true, this); |
| } |
| |
| @Override |
| public void onPrinterLost(DiscoveredPrinter printer) { |
| // Ignore (the capability request, if any, will fail) |
| } |
| |
| @Override |
| public void onConnectionComplete(DiscoveredPrinter printer) { |
| // Ignore late connection events |
| if (mState != STATE_DISCOVERY) { |
| return; |
| } |
| |
| if (printer == null) { |
| finish(false, mPrintService.getString(R.string.failed_printer_connection)); |
| } else if (mPrintJob.isBlocked()) { |
| mPrintJob.start(); |
| } |
| } |
| |
| @Override |
| public void onConnectionDelayed(boolean delayed) { |
| if (DEBUG) Log.d(TAG, "onConnectionDelayed " + delayed); |
| |
| // Ignore late events |
| if (mState != STATE_DISCOVERY) { |
| return; |
| } |
| |
| if (delayed) { |
| mPrintJob.block(mPrintService.getString(R.string.connect_hint_text)); |
| } else { |
| // Remove block message |
| mPrintJob.start(); |
| } |
| } |
| |
| PrintJob getPrintJob() { |
| return mPrintJob; |
| } |
| |
| @Override |
| public void onCapabilities(LocalPrinterCapabilities capabilities) { |
| if (DEBUG) Log.d(TAG, "Capabilities for " + mPath + " are " + capabilities); |
| if (mState != STATE_CAPABILITIES) { |
| return; |
| } |
| |
| if (capabilities == null) { |
| finish(false, mPrintService.getString(R.string.printer_offline)); |
| } else { |
| if (DEBUG) Log.d(TAG, "Starting backend print of " + mPrintJob); |
| if (mDiscoveryTimeout != null) { |
| mDiscoveryTimeout.cancel(); |
| } |
| mState = STATE_DELIVERING; |
| mPrintJob.start(); |
| mBackend.print(mPath, mPrintJob, capabilities, this::handleJobStatus); |
| } |
| } |
| |
| private void handleJobStatus(JobStatus jobStatus) { |
| if (DEBUG) Log.d(TAG, "onJobStatus() " + jobStatus); |
| switch (jobStatus.getJobState()) { |
| case BackendConstants.JOB_STATE_DONE: |
| switch (jobStatus.getJobResult()) { |
| case BackendConstants.JOB_DONE_OK: |
| finish(true, null); |
| break; |
| case BackendConstants.JOB_DONE_CANCELLED: |
| mState = STATE_CANCEL; |
| finish(false, null); |
| break; |
| case BackendConstants.JOB_DONE_CORRUPT: |
| finish(false, mPrintService.getString(R.string.unreadable_input)); |
| break; |
| default: |
| // Job failed |
| finish(false, null); |
| break; |
| } |
| break; |
| |
| case BackendConstants.JOB_STATE_BLOCKED: |
| if (mState == STATE_CANCEL) { |
| return; |
| } |
| int blockedId = jobStatus.getBlockedReasonId(); |
| blockedId = (blockedId == 0) ? R.string.printer_check : blockedId; |
| String blockedReason = mPrintService.getString(blockedId); |
| mPrintJob.block(blockedReason); |
| break; |
| |
| case BackendConstants.JOB_STATE_RUNNING: |
| if (mState == STATE_CANCEL) { |
| return; |
| } |
| mPrintJob.start(); |
| break; |
| } |
| } |
| |
| /** |
| * Terminate the job, issuing appropriate notifications. |
| * |
| * @param success true if the printer reported successful job completion |
| * @param error reason for job failure if known |
| */ |
| private void finish(boolean success, String error) { |
| if (DEBUG) Log.d(TAG, "finish() success=" + success + ", error=" + error); |
| mPrintService.getDiscovery().stop(this); |
| if (mDiscoveryTimeout != null) { |
| mDiscoveryTimeout.cancel(); |
| } |
| if (mConnection != null) { |
| mConnection.close(); |
| } |
| mPrintService.unlockWifi(); |
| mBackend.closeDocument(); |
| if (success) { |
| // Job must not be blocked before completion |
| mPrintJob.start(); |
| mPrintJob.complete(); |
| } else if (mState == STATE_CANCEL) { |
| mPrintJob.cancel(); |
| } else { |
| mPrintJob.fail(error); |
| } |
| mState = STATE_DONE; |
| mCompleteConsumer.accept(LocalPrintJob.this); |
| } |
| } |
