| /* |
| * 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.printspooler; |
| |
| import android.app.Activity; |
| import android.content.Intent; |
| 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.RemoteException; |
| import android.os.UserHandle; |
| import android.print.IPrintDocumentAdapter; |
| import android.print.IPrinterDiscoveryObserver; |
| import android.print.PageRange; |
| import android.print.PrintAttributes; |
| import android.print.PrintAttributes.MediaSize; |
| import android.print.PrintAttributes.Resolution; |
| import android.print.PrintAttributes.Tray; |
| import android.print.PrintDocumentAdapter.LayoutResultCallback; |
| import android.print.PrintDocumentAdapter.WriteResultCallback; |
| import android.print.PrintDocumentInfo; |
| import android.print.PrintJobInfo; |
| import android.print.PrinterId; |
| import android.print.PrinterInfo; |
| import android.text.Editable; |
| import android.text.InputFilter; |
| import android.text.Spanned; |
| import android.text.TextUtils; |
| import android.text.TextWatcher; |
| import android.util.Log; |
| import android.view.Choreographer; |
| import android.view.Menu; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.view.WindowManager; |
| import android.widget.AdapterView; |
| import android.widget.AdapterView.OnItemSelectedListener; |
| import android.widget.ArrayAdapter; |
| import android.widget.EditText; |
| import android.widget.Spinner; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * Activity for configuring a print job. |
| */ |
| public class PrintJobConfigActivity extends Activity { |
| |
| private static final boolean DEBUG = false; |
| |
| private static final String LOG_TAG = PrintJobConfigActivity.class.getSimpleName(); |
| |
| public static final String EXTRA_PRINTABLE = "printable"; |
| public static final String EXTRA_APP_ID = "appId"; |
| public static final String EXTRA_ATTRIBUTES = "attributes"; |
| public static final String EXTRA_PRINT_JOB_ID = "printJobId"; |
| |
| private static final int MIN_COPIES = 1; |
| |
| private final PrintSpooler mPrintSpooler = PrintSpooler.getInstance(this); |
| |
| private IPrinterDiscoveryObserver mPrinterDiscoveryObserver; |
| |
| private int mAppId; |
| private int mPrintJobId; |
| |
| private PrintAttributes mPrintAttributes; |
| |
| private RemotePrintDocumentAdapter mRemotePrintAdapter; |
| |
| // UI elements |
| |
| private EditText mCopiesEditText; |
| |
| private Spinner mDestinationSpinner; |
| public ArrayAdapter<SpinnerItem<PrinterInfo>> mDestinationSpinnerAdapter; |
| |
| private Spinner mMediaSizeSpinner; |
| public ArrayAdapter<SpinnerItem<MediaSize>> mMediaSizeSpinnerAdapter; |
| |
| private Spinner mResolutionSpinner; |
| public ArrayAdapter<SpinnerItem<Resolution>> mResolutionSpinnerAdapter; |
| |
| private Spinner mInputTraySpinner; |
| public ArrayAdapter<SpinnerItem<Tray>> mInputTraySpinnerAdapter; |
| |
| private Spinner mOutputTraySpinner; |
| public ArrayAdapter<SpinnerItem<Tray>> mOutputTraySpinnerAdapter; |
| |
| private Spinner mDuplexModeSpinner; |
| public ArrayAdapter<SpinnerItem<Integer>> mDuplexModeSpinnerAdapter; |
| |
| private Spinner mColorModeSpinner; |
| public ArrayAdapter<SpinnerItem<Integer>> mColorModeSpinnerAdapter; |
| |
| private Spinner mFittingModeSpinner; |
| public ArrayAdapter<SpinnerItem<Integer>> mFittingModeSpinnerAdapter; |
| |
| private Spinner mOrientationSpinner; |
| public ArrayAdapter<SpinnerItem<Integer>> mOrientationSpinnerAdapter; |
| |
| private boolean mPrintConfirmed; |
| |
| private boolean mStarted; |
| |
| private IBinder mIPrintDocumentAdapter; |
| |
| // TODO: Implement store/restore state. |
| |
| private final OnItemSelectedListener mOnItemSelectedListener = |
| new AdapterView.OnItemSelectedListener() { |
| @Override |
| public void onItemSelected(AdapterView<?> spinner, View view, int position, long id) { |
| if (spinner == mDestinationSpinner) { |
| updateUi(); |
| notifyPrintableStartIfNeeded(); |
| } else if (spinner == mMediaSizeSpinner) { |
| SpinnerItem<MediaSize> mediaItem = mMediaSizeSpinnerAdapter.getItem(position); |
| mPrintAttributes.setMediaSize(mediaItem.value); |
| updatePrintableContentIfNeeded(); |
| } else if (spinner == mResolutionSpinner) { |
| SpinnerItem<Resolution> resolutionItem = |
| mResolutionSpinnerAdapter.getItem(position); |
| mPrintAttributes.setResolution(resolutionItem.value); |
| updatePrintableContentIfNeeded(); |
| } else if (spinner == mInputTraySpinner) { |
| SpinnerItem<Tray> inputTrayItem = |
| mInputTraySpinnerAdapter.getItem(position); |
| mPrintAttributes.setInputTray(inputTrayItem.value); |
| } else if (spinner == mOutputTraySpinner) { |
| SpinnerItem<Tray> outputTrayItem = |
| mOutputTraySpinnerAdapter.getItem(position); |
| mPrintAttributes.setOutputTray(outputTrayItem.value); |
| } else if (spinner == mDuplexModeSpinner) { |
| SpinnerItem<Integer> duplexModeItem = |
| mDuplexModeSpinnerAdapter.getItem(position); |
| mPrintAttributes.setDuplexMode(duplexModeItem.value); |
| } else if (spinner == mColorModeSpinner) { |
| SpinnerItem<Integer> colorModeItem = |
| mColorModeSpinnerAdapter.getItem(position); |
| mPrintAttributes.setColorMode(colorModeItem.value); |
| } else if (spinner == mFittingModeSpinner) { |
| SpinnerItem<Integer> fittingModeItem = |
| mFittingModeSpinnerAdapter.getItem(position); |
| mPrintAttributes.setFittingMode(fittingModeItem.value); |
| } else if (spinner == mOrientationSpinner) { |
| SpinnerItem<Integer> orientationItem = |
| mOrientationSpinnerAdapter.getItem(position); |
| mPrintAttributes.setOrientation(orientationItem.value); |
| } |
| } |
| |
| @Override |
| public void onNothingSelected(AdapterView<?> parent) { |
| /* do nothing*/ |
| } |
| }; |
| |
| private final TextWatcher mTextWatcher = new TextWatcher() { |
| @Override |
| public void onTextChanged(CharSequence s, int start, int before, int count) { |
| final int copies = Integer.parseInt(mCopiesEditText.getText().toString()); |
| mPrintAttributes.setCopies(copies); |
| } |
| |
| @Override |
| public void beforeTextChanged(CharSequence s, int start, int count, int after) { |
| /* do nothing */ |
| } |
| |
| @Override |
| public void afterTextChanged(Editable s) { |
| /* do nothing */ |
| } |
| }; |
| |
| private final InputFilter mInputFilter = new InputFilter() { |
| @Override |
| public CharSequence filter(CharSequence source, int start, int end, |
| Spanned dest, int dstart, int dend) { |
| StringBuffer text = new StringBuffer(dest.toString()); |
| text.replace(dstart, dend, source.subSequence(start, end).toString()); |
| if (TextUtils.isEmpty(text)) { |
| return dest; |
| } |
| final int copies = Integer.parseInt(text.toString()); |
| if (copies < MIN_COPIES) { |
| return dest; |
| } |
| return null; |
| } |
| }; |
| |
| private final DeathRecipient mDeathRecipient = new DeathRecipient() { |
| @Override |
| public void binderDied() { |
| finish(); |
| } |
| }; |
| |
| @Override |
| protected void onCreate(Bundle bundle) { |
| super.onCreate(bundle); |
| setContentView(R.layout.print_job_config_activity); |
| |
| getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_PAN |
| | WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN); |
| |
| Bundle extras = getIntent().getExtras(); |
| |
| mPrintJobId = extras.getInt(EXTRA_PRINT_JOB_ID, -1); |
| if (mPrintJobId < 0) { |
| throw new IllegalArgumentException("Invalid print job id: " + mPrintJobId); |
| } |
| |
| mAppId = extras.getInt(EXTRA_APP_ID, -1); |
| if (mAppId < 0) { |
| throw new IllegalArgumentException("Invalid app id: " + mAppId); |
| } |
| |
| mPrintAttributes = getIntent().getParcelableExtra(EXTRA_ATTRIBUTES); |
| if (mPrintAttributes == null) { |
| mPrintAttributes = new PrintAttributes.Builder().create(); |
| } |
| |
| mIPrintDocumentAdapter = extras.getBinder(EXTRA_PRINTABLE); |
| if (mIPrintDocumentAdapter == null) { |
| throw new IllegalArgumentException("Printable cannot be null"); |
| } |
| mRemotePrintAdapter = new RemotePrintDocumentAdapter( |
| IPrintDocumentAdapter.Stub.asInterface(mIPrintDocumentAdapter), |
| mPrintSpooler.generateFileForPrintJob(mPrintJobId)); |
| |
| try { |
| mIPrintDocumentAdapter.linkToDeath(mDeathRecipient, 0); |
| } catch (RemoteException re) { |
| finish(); |
| } |
| |
| mPrinterDiscoveryObserver = new PrintDiscoveryObserver(getMainLooper()); |
| |
| bindUi(); |
| } |
| |
| @Override |
| protected void onDestroy() { |
| mIPrintDocumentAdapter.unlinkToDeath(mDeathRecipient, 0); |
| super.onDestroy(); |
| } |
| |
| private void bindUi() { |
| // Copies |
| mCopiesEditText = (EditText) findViewById(R.id.copies_edittext); |
| mCopiesEditText.setText(String.valueOf(MIN_COPIES)); |
| mCopiesEditText.addTextChangedListener(mTextWatcher); |
| mCopiesEditText.setFilters(new InputFilter[] {mInputFilter}); |
| |
| // Destination. |
| mDestinationSpinner = (Spinner) findViewById(R.id.destination_spinner); |
| mDestinationSpinnerAdapter = new ArrayAdapter<SpinnerItem<PrinterInfo>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mDestinationSpinner.setAdapter(mDestinationSpinnerAdapter); |
| mDestinationSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| |
| // Media size. |
| mMediaSizeSpinner = (Spinner) findViewById(R.id.media_size_spinner); |
| mMediaSizeSpinnerAdapter = new ArrayAdapter<SpinnerItem<MediaSize>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mMediaSizeSpinner.setAdapter(mMediaSizeSpinnerAdapter); |
| mMediaSizeSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| |
| // Resolution. |
| mResolutionSpinner = (Spinner) findViewById(R.id.resolution_spinner); |
| mResolutionSpinnerAdapter = new ArrayAdapter<SpinnerItem<Resolution>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mResolutionSpinner.setAdapter(mResolutionSpinnerAdapter); |
| mResolutionSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| |
| // Input tray. |
| mInputTraySpinner = (Spinner) findViewById(R.id.input_tray_spinner); |
| mInputTraySpinnerAdapter = new ArrayAdapter<SpinnerItem<Tray>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mInputTraySpinner.setAdapter(mInputTraySpinnerAdapter); |
| |
| // Output tray. |
| mOutputTraySpinner = (Spinner) findViewById(R.id.output_tray_spinner); |
| mOutputTraySpinnerAdapter = new ArrayAdapter<SpinnerItem<Tray>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mOutputTraySpinner.setAdapter(mOutputTraySpinnerAdapter); |
| mOutputTraySpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| |
| // Duplex mode. |
| mDuplexModeSpinner = (Spinner) findViewById(R.id.duplex_mode_spinner); |
| mDuplexModeSpinnerAdapter = new ArrayAdapter<SpinnerItem<Integer>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mDuplexModeSpinner.setAdapter(mDuplexModeSpinnerAdapter); |
| mDuplexModeSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| |
| // Color mode. |
| mColorModeSpinner = (Spinner) findViewById(R.id.color_mode_spinner); |
| mColorModeSpinnerAdapter = new ArrayAdapter<SpinnerItem<Integer>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mColorModeSpinner.setAdapter(mColorModeSpinnerAdapter); |
| mColorModeSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| |
| // Color mode. |
| mFittingModeSpinner = (Spinner) findViewById(R.id.fitting_mode_spinner); |
| mFittingModeSpinnerAdapter = new ArrayAdapter<SpinnerItem<Integer>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mFittingModeSpinner.setAdapter(mFittingModeSpinnerAdapter); |
| mFittingModeSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| |
| // Orientation |
| mOrientationSpinner = (Spinner) findViewById(R.id.orientation_spinner); |
| mOrientationSpinnerAdapter = new ArrayAdapter<SpinnerItem<Integer>>(this, |
| android.R.layout.simple_spinner_dropdown_item); |
| mOrientationSpinner.setAdapter(mOrientationSpinnerAdapter); |
| mOrientationSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| } |
| |
| private void updateUi() { |
| final int selectedIndex = mDestinationSpinner.getSelectedItemPosition(); |
| PrinterInfo printer = mDestinationSpinnerAdapter.getItem(selectedIndex).value; |
| printer.getDefaults(mPrintAttributes); |
| |
| // Copies. |
| mCopiesEditText.setText(String.valueOf( |
| Math.max(mPrintAttributes.getCopies(), MIN_COPIES))); |
| |
| // Media size. |
| mMediaSizeSpinnerAdapter.clear(); |
| List<MediaSize> mediaSizes = printer.getMediaSizes(); |
| final int mediaSizeCount = mediaSizes.size(); |
| for (int i = 0; i < mediaSizeCount; i++) { |
| MediaSize mediaSize = mediaSizes.get(i); |
| mMediaSizeSpinnerAdapter.add(new SpinnerItem<MediaSize>( |
| mediaSize, mediaSize.getLabel())); |
| } |
| final int selectedMediaSizeIndex = mediaSizes.indexOf( |
| mPrintAttributes.getMediaSize()); |
| mMediaSizeSpinner.setOnItemSelectedListener(null); |
| mMediaSizeSpinner.setSelection(selectedMediaSizeIndex); |
| |
| // Resolution. |
| mResolutionSpinnerAdapter.clear(); |
| List<Resolution> resolutions = printer.getResolutions(); |
| final int resolutionCount = resolutions.size(); |
| for (int i = 0; i < resolutionCount; i++) { |
| Resolution resolution = resolutions.get(i); |
| mResolutionSpinnerAdapter.add(new SpinnerItem<Resolution>( |
| resolution, resolution.getLabel(getPackageManager()))); |
| } |
| final int selectedResolutionIndex = resolutions.indexOf( |
| mPrintAttributes.getResolution()); |
| mResolutionSpinner.setOnItemSelectedListener(null); |
| mResolutionSpinner.setSelection(selectedResolutionIndex); |
| |
| // AdapterView has the weird behavior to notify the selection listener for a |
| // selection event that occurred *before* the listener was registered because |
| // it does the real selection change on the next layout pass. To avoid this |
| // behavior we re-attach the listener in the next traversal window - fun! |
| Choreographer.getInstance().postCallback( |
| Choreographer.CALLBACK_TRAVERSAL, new Runnable() { |
| @Override |
| public void run() { |
| mMediaSizeSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| mResolutionSpinner.setOnItemSelectedListener(mOnItemSelectedListener); |
| } |
| }, null); |
| |
| // Input tray. |
| mInputTraySpinnerAdapter.clear(); |
| List<Tray> inputTrays = printer.getInputTrays(); |
| if (inputTrays != null) { |
| final int inputTrayCount = inputTrays.size(); |
| for (int i = 0; i < inputTrayCount; i++) { |
| Tray inputTray = inputTrays.get(i); |
| mInputTraySpinnerAdapter.add(new SpinnerItem<Tray>( |
| inputTray, inputTray.getLabel(getPackageManager()))); |
| } |
| final int selectedInputTrayIndex = inputTrays.indexOf( |
| mPrintAttributes.getInputTray()); |
| mInputTraySpinner.setSelection(selectedInputTrayIndex); |
| } |
| |
| // Output tray. |
| mOutputTraySpinnerAdapter.clear(); |
| List<Tray> outputTrays = printer.getOutputTrays(); |
| if (outputTrays != null) { |
| final int outputTrayCount = outputTrays.size(); |
| for (int i = 0; i < outputTrayCount; i++) { |
| Tray outputTray = outputTrays.get(i); |
| mOutputTraySpinnerAdapter.add(new SpinnerItem<Tray>( |
| outputTray, outputTray.getLabel(getPackageManager()))); |
| } |
| final int selectedOutputTrayIndex = outputTrays.indexOf( |
| mPrintAttributes.getOutputTray()); |
| mOutputTraySpinner.setSelection(selectedOutputTrayIndex); |
| } |
| |
| // Duplex mode. |
| final int duplexModes = printer.getDuplexModes(); |
| mDuplexModeSpinnerAdapter.clear(); |
| String[] duplexModeLabels = getResources().getStringArray( |
| R.array.duplex_mode_labels); |
| int remainingDuplexModes = duplexModes; |
| while (remainingDuplexModes != 0) { |
| final int duplexBitOffset = Integer.numberOfTrailingZeros(remainingDuplexModes); |
| final int duplexMode = 1 << duplexBitOffset; |
| remainingDuplexModes &= ~duplexMode; |
| mDuplexModeSpinnerAdapter.add(new SpinnerItem<Integer>(duplexMode, |
| duplexModeLabels[duplexBitOffset])); |
| } |
| final int selectedDuplexModeIndex = Integer.numberOfTrailingZeros( |
| (duplexModes & mPrintAttributes.getDuplexMode())); |
| mDuplexModeSpinner.setSelection(selectedDuplexModeIndex); |
| |
| // Color mode. |
| final int colorModes = printer.getColorModes(); |
| mColorModeSpinnerAdapter.clear(); |
| String[] colorModeLabels = getResources().getStringArray( |
| R.array.color_mode_labels); |
| int remainingColorModes = colorModes; |
| while (remainingColorModes != 0) { |
| final int colorBitOffset = Integer.numberOfTrailingZeros(remainingColorModes); |
| final int colorMode = 1 << colorBitOffset; |
| remainingColorModes &= ~colorMode; |
| mColorModeSpinnerAdapter.add(new SpinnerItem<Integer>(colorMode, |
| colorModeLabels[colorBitOffset])); |
| } |
| final int selectedColorModeIndex = Integer.numberOfTrailingZeros( |
| (colorModes & mPrintAttributes.getColorMode())); |
| mColorModeSpinner.setSelection(selectedColorModeIndex); |
| |
| // Fitting mode. |
| final int fittingModes = printer.getFittingModes(); |
| mFittingModeSpinnerAdapter.clear(); |
| String[] fittingModeLabels = getResources().getStringArray( |
| R.array.fitting_mode_labels); |
| int remainingFittingModes = fittingModes; |
| while (remainingFittingModes != 0) { |
| final int fittingBitOffset = Integer.numberOfTrailingZeros(remainingFittingModes); |
| final int fittingMode = 1 << fittingBitOffset; |
| remainingFittingModes &= ~fittingMode; |
| mFittingModeSpinnerAdapter.add(new SpinnerItem<Integer>(fittingMode, |
| fittingModeLabels[fittingBitOffset])); |
| } |
| final int selectedFittingModeIndex = Integer.numberOfTrailingZeros( |
| (fittingModes & mPrintAttributes.getFittingMode())); |
| mFittingModeSpinner.setSelection(selectedFittingModeIndex); |
| |
| // Orientation. |
| final int orientations = printer.getOrientations(); |
| mOrientationSpinnerAdapter.clear(); |
| String[] orientationLabels = getResources().getStringArray( |
| R.array.orientation_labels); |
| int remainingOrientations = orientations; |
| while (remainingOrientations != 0) { |
| final int orientationBitOffset = Integer.numberOfTrailingZeros(remainingOrientations); |
| final int orientation = 1 << orientationBitOffset; |
| remainingOrientations &= ~orientation; |
| mOrientationSpinnerAdapter.add(new SpinnerItem<Integer>(orientation, |
| orientationLabels[orientationBitOffset])); |
| } |
| final int selectedOrientationIndex = Integer.numberOfTrailingZeros( |
| (orientations & mPrintAttributes.getOrientation())); |
| mOrientationSpinner.setSelection(selectedOrientationIndex); |
| } |
| |
| @Override |
| protected void onResume() { |
| super.onResume(); |
| mPrintSpooler.startPrinterDiscovery(mPrinterDiscoveryObserver); |
| notifyPrintableStartIfNeeded(); |
| } |
| |
| @Override |
| protected void onPause() { |
| super.onPause(); |
| mPrintSpooler.stopPrinterDiscovery(); |
| notifyPrintableFinishIfNeeded(); |
| } |
| |
| @Override |
| public boolean onCreateOptionsMenu(Menu menu) { |
| getMenuInflater().inflate(R.menu.print_job_config_activity, menu); |
| return true; |
| } |
| |
| @Override |
| public boolean onOptionsItemSelected(MenuItem item) { |
| if (item.getItemId() == R.id.print_button) { |
| mPrintConfirmed = true; |
| finish(); |
| } |
| return super.onOptionsItemSelected(item); |
| } |
| |
| private void notifyPrintableStartIfNeeded() { |
| if (mDestinationSpinner.getSelectedItemPosition() < 0 |
| || mStarted) { |
| return; |
| } |
| mStarted = true; |
| mRemotePrintAdapter.start(); |
| updatePrintableContentIfNeeded(); |
| } |
| |
| private void updatePrintableContentIfNeeded() { |
| if (!mStarted) { |
| return; |
| } |
| |
| // TODO: Implement old attributes tracking |
| mPrintSpooler.setPrintJobAttributes(mPrintJobId, mPrintAttributes); |
| |
| // TODO: Implement setting the print preview attribute |
| mRemotePrintAdapter.layout(new PrintAttributes.Builder().create(), |
| mPrintAttributes, new LayoutResultCallback() { |
| @Override |
| public void onLayoutFinished(PrintDocumentInfo info, boolean changed) { |
| // TODO: Handle the case of unchanged content |
| mPrintSpooler.setPrintJobPrintDocumentInfo(mPrintJobId, info); |
| |
| // TODO: Implement page selector. |
| final List<PageRange> pages = new ArrayList<PageRange>(); |
| pages.add(PageRange.ALL_PAGES); |
| |
| mRemotePrintAdapter.write(pages, new WriteResultCallback() { |
| @Override |
| public void onWriteFinished(List<PageRange> pages) { |
| updatePrintPreview(mRemotePrintAdapter.getFile()); |
| } |
| |
| @Override |
| public void onWriteFailed(CharSequence error) { |
| Log.e(LOG_TAG, "Error write layout: " + error); |
| finishActivity(Activity.RESULT_CANCELED); |
| } |
| }); |
| } |
| |
| @Override |
| public void onLayoutFailed(CharSequence error) { |
| Log.e(LOG_TAG, "Error during layout: " + error); |
| finishActivity(Activity.RESULT_CANCELED); |
| } |
| }, new Bundle()); |
| } |
| |
| private void notifyPrintableFinishIfNeeded() { |
| if (!mStarted) { |
| return; |
| } |
| |
| if (!mPrintConfirmed) { |
| mRemotePrintAdapter.cancel(); |
| } |
| mRemotePrintAdapter.finish(); |
| |
| // If canceled or no printer, nothing to do. |
| final int selectedIndex = mDestinationSpinner.getSelectedItemPosition(); |
| if (!mPrintConfirmed || selectedIndex < 0) { |
| // Update the print job's status. |
| mPrintSpooler.setPrintJobState(mPrintJobId, |
| PrintJobInfo.STATE_CANCELED); |
| return; |
| } |
| |
| // Update the print job's printer. |
| SpinnerItem<PrinterInfo> printerItem = |
| mDestinationSpinnerAdapter.getItem(selectedIndex); |
| PrinterId printerId = printerItem.value.getId(); |
| mPrintSpooler.setPrintJobPrinterId(mPrintJobId, printerId); |
| |
| // Update the print job's status. |
| mPrintSpooler.setPrintJobState(mPrintJobId, |
| PrintJobInfo.STATE_QUEUED); |
| |
| if (DEBUG) { |
| if (mPrintConfirmed) { |
| File file = mRemotePrintAdapter.getFile(); |
| if (file.exists()) { |
| new ViewSpooledFileAsyncTask(file).executeOnExecutor( |
| AsyncTask.SERIAL_EXECUTOR, (Void[]) null); |
| } |
| } |
| } |
| } |
| |
| private void updatePrintPreview(File file) { |
| // TODO: Implement |
| } |
| |
| private void addPrinters(List<PrinterInfo> addedPrinters) { |
| final int addedPrinterCount = addedPrinters.size(); |
| for (int i = 0; i < addedPrinterCount; i++) { |
| PrinterInfo addedPrinter = addedPrinters.get(i); |
| boolean duplicate = false; |
| final int existingPrinterCount = mDestinationSpinnerAdapter.getCount(); |
| for (int j = 0; j < existingPrinterCount; j++) { |
| PrinterInfo existingPrinter = mDestinationSpinnerAdapter.getItem(j).value; |
| if (addedPrinter.getId().equals(existingPrinter.getId())) { |
| duplicate = true; |
| break; |
| } |
| } |
| if (!duplicate) { |
| mDestinationSpinnerAdapter.add(new SpinnerItem<PrinterInfo>( |
| addedPrinter, addedPrinter.getLabel())); |
| } else { |
| Log.w(LOG_TAG, "Skipping a duplicate printer: " + addedPrinter); |
| } |
| } |
| } |
| |
| private void removePrinters(List<PrinterId> pritnerIds) { |
| final int printerIdCount = pritnerIds.size(); |
| for (int i = 0; i < printerIdCount; i++) { |
| PrinterId removedPrinterId = pritnerIds.get(i); |
| boolean removed = false; |
| final int existingPrinterCount = mDestinationSpinnerAdapter.getCount(); |
| for (int j = 0; j < existingPrinterCount; j++) { |
| PrinterInfo existingPrinter = mDestinationSpinnerAdapter.getItem(j).value; |
| if (removedPrinterId.equals(existingPrinter.getId())) { |
| mDestinationSpinnerAdapter.remove(mDestinationSpinnerAdapter.getItem(j)); |
| removed = true; |
| break; |
| } |
| } |
| if (!removed) { |
| Log.w(LOG_TAG, "Ignoring not added printer with id: " + removedPrinterId); |
| } |
| } |
| } |
| |
| // Caution: Use this only for debugging |
| private final class ViewSpooledFileAsyncTask extends AsyncTask<Void, Void, Void> { |
| |
| private final File mFile; |
| |
| public ViewSpooledFileAsyncTask(File file) { |
| mFile = file; |
| } |
| |
| @Override |
| protected Void doInBackground(Void... params) { |
| mFile.setExecutable(true, false); |
| mFile.setWritable(true, false); |
| mFile.setReadable(true, false); |
| |
| final long identity = Binder.clearCallingIdentity(); |
| Intent intent = new Intent(Intent.ACTION_VIEW); |
| intent.setDataAndType(Uri.fromFile(mFile), "application/pdf"); |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); |
| startActivityAsUser(intent, null, UserHandle.CURRENT); |
| Binder.restoreCallingIdentity(identity); |
| return null; |
| } |
| } |
| |
| private final class PrintDiscoveryObserver extends IPrinterDiscoveryObserver.Stub { |
| private static final int MESSAGE_ADD_DICOVERED_PRINTERS = 1; |
| private static final int MESSAGE_REMOVE_DICOVERED_PRINTERS = 2; |
| |
| private final Handler mHandler; |
| |
| @SuppressWarnings("unchecked") |
| public PrintDiscoveryObserver(Looper looper) { |
| mHandler = new Handler(looper, null, true) { |
| @Override |
| public void handleMessage(Message message) { |
| switch (message.what) { |
| case MESSAGE_ADD_DICOVERED_PRINTERS: { |
| List<PrinterInfo> printers = (List<PrinterInfo>) message.obj; |
| addPrinters(printers); |
| // Just added the first printer, so select it and start printing. |
| if (mDestinationSpinnerAdapter.getCount() == 1) { |
| mDestinationSpinner.setSelection(0); |
| } |
| } break; |
| case MESSAGE_REMOVE_DICOVERED_PRINTERS: { |
| List<PrinterId> printerIds = (List<PrinterId>) message.obj; |
| removePrinters(printerIds); |
| // TODO: Handle removing the last printer. |
| } break; |
| } |
| } |
| }; |
| } |
| |
| @Override |
| public void addDiscoveredPrinters(List<PrinterInfo> printers) { |
| mHandler.obtainMessage(MESSAGE_ADD_DICOVERED_PRINTERS, printers).sendToTarget(); |
| } |
| |
| @Override |
| public void removeDiscoveredPrinters(List<PrinterId> printers) { |
| mHandler.obtainMessage(MESSAGE_REMOVE_DICOVERED_PRINTERS, printers).sendToTarget(); |
| } |
| } |
| |
| private final class SpinnerItem<T> { |
| final T value; |
| CharSequence label; |
| |
| public SpinnerItem(T value, CharSequence label) { |
| this.value = value; |
| this.label = label; |
| } |
| |
| public String toString() { |
| return label.toString(); |
| } |
| } |
| } |