| Fields Summary |
|---|
| private static final String | LOG_TAG |
| private static final boolean | DEBUG |
| public static final String | INTENT_EXTRA_PRINTER_ID |
| private static final String | FRAGMENT_TAG |
| private static final int | ORIENTATION_PORTRAIT |
| private static final int | ORIENTATION_LANDSCAPE |
| private static final int | ACTIVITY_REQUEST_CREATE_FILE |
| private static final int | ACTIVITY_REQUEST_SELECT_PRINTER |
| private static final int | ACTIVITY_REQUEST_POPULATE_ADVANCED_PRINT_OPTIONS |
| private static final int | DEST_ADAPTER_MAX_ITEM_COUNT |
| private static final int | DEST_ADAPTER_ITEM_ID_SAVE_AS_PDF |
| private static final int | DEST_ADAPTER_ITEM_ID_ALL_PRINTERS |
| private static final int | STATE_INITIALIZING |
| private static final int | STATE_CONFIGURING |
| private static final int | STATE_PRINT_CONFIRMED |
| private static final int | STATE_PRINT_CANCELED |
| private static final int | STATE_UPDATE_FAILED |
| private static final int | STATE_CREATE_FILE_FAILED |
| private static final int | STATE_PRINTER_UNAVAILABLE |
| private static final int | STATE_UPDATE_SLOW |
| private static final int | STATE_PRINT_COMPLETED |
| private static final int | UI_STATE_PREVIEW |
| private static final int | UI_STATE_ERROR |
| private static final int | UI_STATE_PROGRESS |
| private static final int | MIN_COPIES |
| private static final String | MIN_COPIES_STRING |
| private static final Pattern | PATTERN_DIGITS |
| private static final Pattern | PATTERN_ESCAPE_SPECIAL_CHARS |
| private static final Pattern | PATTERN_PAGE_RANGE |
| public static final android.print.PageRange[] | ALL_PAGES_ARRAY |
| private final PrinterAvailabilityDetector | mPrinterAvailabilityDetector |
| private final android.text.TextUtils.SimpleStringSplitter | mStringCommaSplitter |
| private final android.view.View.OnFocusChangeListener | mSelectAllOnFocusListener |
| private com.android.printspooler.model.PrintSpoolerProvider | mSpoolerProvider |
| private PrintPreviewController | mPrintPreviewController |
| private android.print.PrintJobInfo | mPrintJob |
| private com.android.printspooler.model.RemotePrintDocument | mPrintedDocument |
| private PrinterRegistry | mPrinterRegistry |
| private android.widget.EditText | mCopiesEditText |
| private android.widget.TextView | mPageRangeTitle |
| private android.widget.EditText | mPageRangeEditText |
| private android.widget.Spinner | mDestinationSpinner |
| private DestinationAdapter | mDestinationSpinnerAdapter |
| private android.widget.Spinner | mMediaSizeSpinner |
| private android.widget.ArrayAdapter | mMediaSizeSpinnerAdapter |
| private android.widget.Spinner | mColorModeSpinner |
| private android.widget.ArrayAdapter | mColorModeSpinnerAdapter |
| private android.widget.Spinner | mOrientationSpinner |
| private android.widget.ArrayAdapter | mOrientationSpinnerAdapter |
| private android.widget.Spinner | mRangeOptionsSpinner |
| private com.android.printspooler.widget.PrintContentView | mOptionsContent |
| private android.view.View | mSummaryContainer |
| private android.widget.TextView | mSummaryCopies |
| private android.widget.TextView | mSummaryPaperSize |
| private android.widget.Button | mMoreOptionsButton |
| private android.widget.ImageView | mPrintButton |
| private ProgressMessageController | mProgressMessageController |
| private com.android.printspooler.model.MutexFileProvider | mFileProvider |
| private com.android.printspooler.util.MediaSizeUtils.MediaSizeComparator | mMediaSizeComparator |
| private android.print.PrinterInfo | mCurrentPrinter |
| private android.print.PageRange[] | mSelectedPages |
| private String | mCallingPackageName |
| private int | mCurrentPageCount |
| private int | mState |
| private int | mUiState |
| Methods Summary |
|---|
| private void | addCurrentPrinterToHistory()
if (mCurrentPrinter != null) {
PrinterId fakePdfPrinterId = mDestinationSpinnerAdapter.getPdfPrinter().getId();
if (!mCurrentPrinter.getId().equals(fakePdfPrinterId)) {
mPrinterRegistry.addHistoricalPrinter(mCurrentPrinter);
}
}
|
| private void | bindUi()
// Summary
mSummaryContainer = findViewById(R.id.summary_content);
mSummaryCopies = (TextView) findViewById(R.id.copies_count_summary);
mSummaryPaperSize = (TextView) findViewById(R.id.paper_size_summary);
// Options container
mOptionsContent = (PrintContentView) findViewById(R.id.options_content);
mOptionsContent.setOptionsStateChangeListener(this);
mOptionsContent.setOpenOptionsController(this);
OnItemSelectedListener itemSelectedListener = new MyOnItemSelectedListener();
OnClickListener clickListener = new MyClickListener();
// Copies
mCopiesEditText = (EditText) findViewById(R.id.copies_edittext);
mCopiesEditText.setOnFocusChangeListener(mSelectAllOnFocusListener);
mCopiesEditText.setText(MIN_COPIES_STRING);
mCopiesEditText.setSelection(mCopiesEditText.getText().length());
mCopiesEditText.addTextChangedListener(new EditTextWatcher());
// Destination.
mDestinationSpinnerAdapter.registerDataSetObserver(new PrintersObserver());
mDestinationSpinner = (Spinner) findViewById(R.id.destination_spinner);
mDestinationSpinner.setAdapter(mDestinationSpinnerAdapter);
mDestinationSpinner.setOnItemSelectedListener(itemSelectedListener);
// Media size.
mMediaSizeSpinnerAdapter = new ArrayAdapter<>(
this, android.R.layout.simple_spinner_dropdown_item, android.R.id.text1);
mMediaSizeSpinner = (Spinner) findViewById(R.id.paper_size_spinner);
mMediaSizeSpinner.setAdapter(mMediaSizeSpinnerAdapter);
mMediaSizeSpinner.setOnItemSelectedListener(itemSelectedListener);
// Color mode.
mColorModeSpinnerAdapter = new ArrayAdapter<>(
this, android.R.layout.simple_spinner_dropdown_item, android.R.id.text1);
mColorModeSpinner = (Spinner) findViewById(R.id.color_spinner);
mColorModeSpinner.setAdapter(mColorModeSpinnerAdapter);
mColorModeSpinner.setOnItemSelectedListener(itemSelectedListener);
// Orientation
mOrientationSpinnerAdapter = new ArrayAdapter<>(
this, android.R.layout.simple_spinner_dropdown_item, android.R.id.text1);
String[] orientationLabels = getResources().getStringArray(
R.array.orientation_labels);
mOrientationSpinnerAdapter.add(new SpinnerItem<>(
ORIENTATION_PORTRAIT, orientationLabels[0]));
mOrientationSpinnerAdapter.add(new SpinnerItem<>(
ORIENTATION_LANDSCAPE, orientationLabels[1]));
mOrientationSpinner = (Spinner) findViewById(R.id.orientation_spinner);
mOrientationSpinner.setAdapter(mOrientationSpinnerAdapter);
mOrientationSpinner.setOnItemSelectedListener(itemSelectedListener);
// Range options
ArrayAdapter<SpinnerItem<Integer>> rangeOptionsSpinnerAdapter = new ArrayAdapter<>(
this, android.R.layout.simple_spinner_dropdown_item, android.R.id.text1);
mRangeOptionsSpinner = (Spinner) findViewById(R.id.range_options_spinner);
mRangeOptionsSpinner.setAdapter(rangeOptionsSpinnerAdapter);
mRangeOptionsSpinner.setOnItemSelectedListener(itemSelectedListener);
updatePageRangeOptions(PrintDocumentInfo.PAGE_COUNT_UNKNOWN);
// Page range
mPageRangeTitle = (TextView) findViewById(R.id.page_range_title);
mPageRangeEditText = (EditText) findViewById(R.id.page_range_edittext);
mPageRangeEditText.setOnFocusChangeListener(mSelectAllOnFocusListener);
mPageRangeEditText.addTextChangedListener(new RangeTextWatcher());
// Advanced options button.
mMoreOptionsButton = (Button) findViewById(R.id.more_options_button);
mMoreOptionsButton.setOnClickListener(clickListener);
// Print button
mPrintButton = (ImageView) findViewById(R.id.print_button);
mPrintButton.setOnClickListener(clickListener);
|
| public boolean | canCloseOptions()
return !hasErrors();
|
| public boolean | canOpenOptions()
return true;
|
| private static boolean | canPrint(android.print.PrinterInfo printer)
return printer.getCapabilities() != null
&& printer.getStatus() != PrinterInfo.STATUS_UNAVAILABLE;
|
| private boolean | canUpdateDocument()
if (mPrintedDocument.isDestroyed()) {
return false;
}
if (hasErrors()) {
return false;
}
PrintAttributes attributes = mPrintJob.getAttributes();
final int colorMode = attributes.getColorMode();
if (colorMode != PrintAttributes.COLOR_MODE_COLOR
&& colorMode != PrintAttributes.COLOR_MODE_MONOCHROME) {
return false;
}
if (attributes.getMediaSize() == null) {
return false;
}
if (attributes.getMinMargins() == null) {
return false;
}
if (attributes.getResolution() == null) {
return false;
}
if (mCurrentPrinter == null) {
return false;
}
PrinterCapabilitiesInfo capabilities = mCurrentPrinter.getCapabilities();
if (capabilities == null) {
return false;
}
if (mCurrentPrinter.getStatus() == PrinterInfo.STATUS_UNAVAILABLE) {
return false;
}
return true;
|
| private void | cancelPrint()
setState(STATE_PRINT_CANCELED);
updateOptionsUi();
if (mPrintedDocument.isUpdating()) {
mPrintedDocument.cancel();
}
doFinish();
|
| private android.print.PageRange[] | computeSelectedPages()
if (hasErrors()) {
return null;
}
if (mRangeOptionsSpinner.getSelectedItemPosition() > 0) {
List<PageRange> pageRanges = new ArrayList<>();
mStringCommaSplitter.setString(mPageRangeEditText.getText().toString());
while (mStringCommaSplitter.hasNext()) {
String range = mStringCommaSplitter.next().trim();
if (TextUtils.isEmpty(range)) {
continue;
}
final int dashIndex = range.indexOf('-");
final int fromIndex;
final int toIndex;
if (dashIndex > 0) {
fromIndex = Integer.parseInt(range.substring(0, dashIndex).trim()) - 1;
// It is possible that the dash is at the end since the input
// verification can has to allow the user to keep entering if
// this would lead to a valid input. So we handle this.
if (dashIndex < range.length() - 1) {
String fromString = range.substring(dashIndex + 1, range.length()).trim();
toIndex = Integer.parseInt(fromString) - 1;
} else {
toIndex = fromIndex;
}
} else {
fromIndex = toIndex = Integer.parseInt(range) - 1;
}
PageRange pageRange = new PageRange(Math.min(fromIndex, toIndex),
Math.max(fromIndex, toIndex));
pageRanges.add(pageRange);
}
PageRange[] pageRangesArray = new PageRange[pageRanges.size()];
pageRanges.toArray(pageRangesArray);
return PageRangeUtils.normalize(pageRangesArray);
}
return ALL_PAGES_ARRAY;
|
| private void | confirmPrint()
setState(STATE_PRINT_CONFIRMED);
updateOptionsUi();
addCurrentPrinterToHistory();
PageRange[] selectedPages = computeSelectedPages();
if (!Arrays.equals(mSelectedPages, selectedPages)) {
mSelectedPages = selectedPages;
// Update preview.
updatePrintPreviewController(false);
}
updateSelectedPagesFromPreview();
mPrintPreviewController.closeOptions();
if (canUpdateDocument()) {
updateDocument(false);
}
if (!mPrintedDocument.isUpdating()) {
requestCreatePdfFileOrFinish();
}
|
| private void | doFinish()
if (mState != STATE_INITIALIZING) {
mProgressMessageController.cancel();
mPrinterRegistry.setTrackedPrinter(null);
mSpoolerProvider.destroy();
mPrintedDocument.finish();
mPrintedDocument.destroy();
mPrintPreviewController.destroy(new Runnable() {
@Override
public void run() {
finish();
}
});
} else {
finish();
}
|
| private void | ensureErrorUiShown(java.lang.CharSequence message, int action)
if (isFinishing()) {
return;
}
if (mUiState != UI_STATE_ERROR) {
mUiState = UI_STATE_ERROR;
mPrintPreviewController.setUiShown(false);
Fragment fragment = PrintErrorFragment.newInstance(message, action);
showFragment(fragment);
}
|
| private void | ensurePreviewUiShown()
if (isFinishing()) {
return;
}
if (mUiState != UI_STATE_PREVIEW) {
mUiState = UI_STATE_PREVIEW;
mPrintPreviewController.setUiShown(true);
showFragment(null);
}
|
| private void | ensureProgressUiShown()
if (isFinishing()) {
return;
}
if (mUiState != UI_STATE_PROGRESS) {
mUiState = UI_STATE_PROGRESS;
mPrintPreviewController.setUiShown(false);
Fragment fragment = PrintProgressFragment.newInstance();
showFragment(fragment);
}
|
| private int | getAdjustedPageCount(android.print.PrintDocumentInfo info)
if (info != null) {
final int pageCount = info.getPageCount();
if (pageCount != PrintDocumentInfo.PAGE_COUNT_UNKNOWN) {
return pageCount;
}
}
// If the app does not tell us how many pages are in the
// doc we ask for all pages and use the document page count.
return mPrintPreviewController.getFilePageCount();
|
| private boolean | hasErrors()
return (mCopiesEditText.getError() != null)
|| (mPageRangeEditText.getVisibility() == View.VISIBLE
&& mPageRangeEditText.getError() != null);
|
| private static boolean | isFinalState(int state)
return state == STATE_PRINT_CONFIRMED
|| state == STATE_PRINT_CANCELED
|| state == STATE_PRINT_COMPLETED;
|
| public void | onActionPerformed()
if (mState == STATE_UPDATE_FAILED
&& canUpdateDocument() && updateDocument(true)) {
ensurePreviewUiShown();
setState(STATE_CONFIGURING);
updateOptionsUi();
}
|
| protected void | onActivityResult(int requestCode, int resultCode, android.content.Intent data)
switch (requestCode) {
case ACTIVITY_REQUEST_CREATE_FILE: {
onStartCreateDocumentActivityResult(resultCode, data);
} break;
case ACTIVITY_REQUEST_SELECT_PRINTER: {
onSelectPrinterActivityResult(resultCode, data);
} break;
case ACTIVITY_REQUEST_POPULATE_ADVANCED_PRINT_OPTIONS: {
onAdvancedPrintOptionsActivityResult(resultCode, data);
} break;
}
|
| private void | onAdvancedPrintOptionsActivityResult(int resultCode, android.content.Intent data)
if (resultCode != RESULT_OK || data == null) {
return;
}
PrintJobInfo printJobInfo = data.getParcelableExtra(PrintService.EXTRA_PRINT_JOB_INFO);
if (printJobInfo == null) {
return;
}
// Take the advanced options without interpretation.
mPrintJob.setAdvancedOptions(printJobInfo.getAdvancedOptions());
// Take copies without interpretation as the advanced print dialog
// cannot create a print job info with invalid copies.
mCopiesEditText.setText(String.valueOf(printJobInfo.getCopies()));
mPrintJob.setCopies(printJobInfo.getCopies());
PrintAttributes currAttributes = mPrintJob.getAttributes();
PrintAttributes newAttributes = printJobInfo.getAttributes();
if (newAttributes != null) {
// Take the media size only if the current printer supports is.
MediaSize oldMediaSize = currAttributes.getMediaSize();
MediaSize newMediaSize = newAttributes.getMediaSize();
if (!oldMediaSize.equals(newMediaSize)) {
final int mediaSizeCount = mMediaSizeSpinnerAdapter.getCount();
MediaSize newMediaSizePortrait = newAttributes.getMediaSize().asPortrait();
for (int i = 0; i < mediaSizeCount; i++) {
MediaSize supportedSizePortrait = mMediaSizeSpinnerAdapter.getItem(i)
.value.asPortrait();
if (supportedSizePortrait.equals(newMediaSizePortrait)) {
currAttributes.setMediaSize(newMediaSize);
mMediaSizeSpinner.setSelection(i);
if (currAttributes.getMediaSize().isPortrait()) {
if (mOrientationSpinner.getSelectedItemPosition() != 0) {
mOrientationSpinner.setSelection(0);
}
} else {
if (mOrientationSpinner.getSelectedItemPosition() != 1) {
mOrientationSpinner.setSelection(1);
}
}
break;
}
}
}
// Take the resolution only if the current printer supports is.
Resolution oldResolution = currAttributes.getResolution();
Resolution newResolution = newAttributes.getResolution();
if (!oldResolution.equals(newResolution)) {
PrinterCapabilitiesInfo capabilities = mCurrentPrinter.getCapabilities();
if (capabilities != null) {
List<Resolution> resolutions = capabilities.getResolutions();
final int resolutionCount = resolutions.size();
for (int i = 0; i < resolutionCount; i++) {
Resolution resolution = resolutions.get(i);
if (resolution.equals(newResolution)) {
currAttributes.setResolution(resolution);
break;
}
}
}
}
// Take the color mode only if the current printer supports it.
final int currColorMode = currAttributes.getColorMode();
final int newColorMode = newAttributes.getColorMode();
if (currColorMode != newColorMode) {
final int colorModeCount = mColorModeSpinner.getCount();
for (int i = 0; i < colorModeCount; i++) {
final int supportedColorMode = mColorModeSpinnerAdapter.getItem(i).value;
if (supportedColorMode == newColorMode) {
currAttributes.setColorMode(newColorMode);
mColorModeSpinner.setSelection(i);
break;
}
}
}
}
// Handle selected page changes making sure they are in the doc.
PrintDocumentInfo info = mPrintedDocument.getDocumentInfo().info;
final int pageCount = (info != null) ? getAdjustedPageCount(info) : 0;
PageRange[] pageRanges = printJobInfo.getPages();
if (pageRanges != null && pageCount > 0) {
pageRanges = PageRangeUtils.normalize(pageRanges);
List<PageRange> validatedList = new ArrayList<>();
final int rangeCount = pageRanges.length;
for (int i = 0; i < rangeCount; i++) {
PageRange pageRange = pageRanges[i];
if (pageRange.getEnd() >= pageCount) {
final int rangeStart = pageRange.getStart();
final int rangeEnd = pageCount - 1;
if (rangeStart <= rangeEnd) {
pageRange = new PageRange(rangeStart, rangeEnd);
validatedList.add(pageRange);
}
break;
}
validatedList.add(pageRange);
}
if (!validatedList.isEmpty()) {
PageRange[] validatedArray = new PageRange[validatedList.size()];
validatedList.toArray(validatedArray);
updateSelectedPages(validatedArray, pageCount);
}
}
// Update the content if needed.
if (canUpdateDocument()) {
updateDocument(false);
}
|
| public void | onConfigurationChanged(android.content.res.Configuration newConfig)
super.onConfigurationChanged(newConfig);
if (mPrintPreviewController != null) {
mPrintPreviewController.onOrientationChanged();
}
|
| private void | onConnectedToPrintSpooler(android.os.IBinder documentAdapter)
// Now that we are bound to the print spooler service,
// create the printer registry and wait for it to get
// the first batch of results which will be delivered
// after reading historical data. This should be pretty
// fast, so just wait before showing the UI.
mPrinterRegistry = new PrinterRegistry(PrintActivity.this,
new Runnable() {
@Override
public void run() {
onPrinterRegistryReady(documentAdapter);
}
});
|
| public void | onCreate(android.os.Bundle savedInstanceState)
super.onCreate(savedInstanceState);
Bundle extras = getIntent().getExtras();
mPrintJob = extras.getParcelable(PrintManager.EXTRA_PRINT_JOB);
if (mPrintJob == null) {
throw new IllegalArgumentException(PrintManager.EXTRA_PRINT_JOB
+ " cannot be null");
}
mPrintJob.setAttributes(new PrintAttributes.Builder().build());
final IBinder adapter = extras.getBinder(PrintManager.EXTRA_PRINT_DOCUMENT_ADAPTER);
if (adapter == null) {
throw new IllegalArgumentException(PrintManager.EXTRA_PRINT_DOCUMENT_ADAPTER
+ " cannot be null");
}
mCallingPackageName = extras.getString(DocumentsContract.EXTRA_PACKAGE_NAME);
// This will take just a few milliseconds, so just wait to
// bind to the local service before showing the UI.
mSpoolerProvider = new PrintSpoolerProvider(this,
new Runnable() {
@Override
public void run() {
onConnectedToPrintSpooler(adapter);
}
});
|
| public boolean | onKeyDown(int keyCode, android.view.KeyEvent event)
if (keyCode == KeyEvent.KEYCODE_BACK) {
event.startTracking();
return true;
}
return super.onKeyDown(keyCode, event);
|
| public boolean | onKeyUp(int keyCode, android.view.KeyEvent event)
if (mState == STATE_INITIALIZING) {
doFinish();
return true;
}
if (mState == STATE_PRINT_CANCELED || mState == STATE_PRINT_CONFIRMED
|| mState == STATE_PRINT_COMPLETED) {
return true;
}
if (keyCode == KeyEvent.KEYCODE_BACK
&& event.isTracking() && !event.isCanceled()) {
if (mPrintPreviewController != null && mPrintPreviewController.isOptionsOpened()
&& !hasErrors()) {
mPrintPreviewController.closeOptions();
} else {
cancelPrint();
}
return true;
}
return super.onKeyUp(keyCode, event);
|
| public void | onMalformedPdfFile()
onPrintDocumentError("Cannot print a malformed PDF file");
|
| public void | onOptionsClosed()
PageRange[] selectedPages = computeSelectedPages();
if (!Arrays.equals(mSelectedPages, selectedPages)) {
mSelectedPages = selectedPages;
// Update preview.
updatePrintPreviewController(false);
}
// Make sure the IME is not on the way of preview as
// the user may have used it to type copies or range.
InputMethodManager imm = (InputMethodManager) getSystemService(
Context.INPUT_METHOD_SERVICE);
imm.hideSoftInputFromWindow(mDestinationSpinner.getWindowToken(), 0);
|
| public void | onOptionsOpened()
updateSelectedPagesFromPreview();
|
| public void | onPause()
PrintSpoolerService spooler = mSpoolerProvider.getSpooler();
if (mState == STATE_INITIALIZING) {
if (isFinishing()) {
spooler.setPrintJobState(mPrintJob.getId(), PrintJobInfo.STATE_CANCELED, null);
}
super.onPause();
return;
}
if (isFinishing()) {
spooler.updatePrintJobUserConfigurableOptionsNoPersistence(mPrintJob);
switch (mState) {
case STATE_PRINT_CONFIRMED: {
spooler.setPrintJobState(mPrintJob.getId(), PrintJobInfo.STATE_QUEUED, null);
} break;
case STATE_PRINT_COMPLETED: {
spooler.setPrintJobState(mPrintJob.getId(), PrintJobInfo.STATE_COMPLETED, null);
} break;
case STATE_CREATE_FILE_FAILED: {
spooler.setPrintJobState(mPrintJob.getId(), PrintJobInfo.STATE_FAILED,
getString(R.string.print_write_error_message));
} break;
default: {
spooler.setPrintJobState(mPrintJob.getId(), PrintJobInfo.STATE_CANCELED, null);
} break;
}
}
mPrinterAvailabilityDetector.cancel();
mPrinterRegistry.setTrackedPrinter(null);
super.onPause();
|
| private void | onPrintDocumentError(java.lang.String message)
mProgressMessageController.cancel();
ensureErrorUiShown(null, PrintErrorFragment.ACTION_RETRY);
setState(STATE_UPDATE_FAILED);
updateOptionsUi();
mPrintedDocument.kill(message);
|
| public void | onPrinterAvailable(android.print.PrinterInfo printer)
if (mCurrentPrinter.equals(printer)) {
setState(STATE_CONFIGURING);
if (canUpdateDocument()) {
updateDocument(false);
}
ensurePreviewUiShown();
updateOptionsUi();
}
|
| private void | onPrinterRegistryReady(android.os.IBinder documentAdapter)
// Now that we are bound to the local print spooler service
// and the printer registry loaded the historical printers
// we can show the UI without flickering.
setTitle(R.string.print_dialog);
setContentView(R.layout.print_activity);
try {
mFileProvider = new MutexFileProvider(
PrintSpoolerService.generateFileForPrintJob(
PrintActivity.this, mPrintJob.getId()));
} catch (IOException ioe) {
// At this point we cannot recover, so just take it down.
throw new IllegalStateException("Cannot create print job file", ioe);
}
mPrintPreviewController = new PrintPreviewController(PrintActivity.this,
mFileProvider);
mPrintedDocument = new RemotePrintDocument(PrintActivity.this,
IPrintDocumentAdapter.Stub.asInterface(documentAdapter),
mFileProvider, new RemotePrintDocument.RemoteAdapterDeathObserver() {
@Override
public void onDied() {
// If we are finishing or we are in a state that we do not need any
// data from the printing app, then no need to finish.
if (isFinishing() || (isFinalState(mState) && !mPrintedDocument.isUpdating())) {
return;
}
if (mPrintedDocument.isUpdating()) {
mPrintedDocument.cancel();
}
setState(STATE_PRINT_CANCELED);
doFinish();
}
}, PrintActivity.this);
mProgressMessageController = new ProgressMessageController(
PrintActivity.this);
mMediaSizeComparator = new MediaSizeComparator(PrintActivity.this);
mDestinationSpinnerAdapter = new DestinationAdapter();
bindUi();
updateOptionsUi();
// Now show the updated UI to avoid flicker.
mOptionsContent.setVisibility(View.VISIBLE);
mSelectedPages = computeSelectedPages();
mPrintedDocument.start();
ensurePreviewUiShown();
setState(STATE_CONFIGURING);
|
| public void | onPrinterUnavailable(android.print.PrinterInfo printer)
if (mCurrentPrinter.getId().equals(printer.getId())) {
setState(STATE_PRINTER_UNAVAILABLE);
if (mPrintedDocument.isUpdating()) {
mPrintedDocument.cancel();
}
ensureErrorUiShown(getString(R.string.print_error_printer_unavailable),
PrintErrorFragment.ACTION_NONE);
updateOptionsUi();
}
|
| public void | onRequestContentUpdate()
if (canUpdateDocument()) {
updateDocument(false);
}
|
| public void | onResume()
super.onResume();
if (mState != STATE_INITIALIZING && mCurrentPrinter != null) {
mPrinterRegistry.setTrackedPrinter(mCurrentPrinter.getId());
}
|
| public void | onSecurePdfFile()
onPrintDocumentError("Cannot print a password protected PDF file");
|
| private void | onSelectPrinterActivityResult(int resultCode, android.content.Intent data)
if (resultCode == RESULT_OK && data != null) {
PrinterId printerId = data.getParcelableExtra(INTENT_EXTRA_PRINTER_ID);
if (printerId != null) {
mDestinationSpinnerAdapter.ensurePrinterInVisibleAdapterPosition(printerId);
final int index = mDestinationSpinnerAdapter.getPrinterIndex(printerId);
if (index != AdapterView.INVALID_POSITION) {
mDestinationSpinner.setSelection(index);
return;
}
}
}
PrinterId printerId = mCurrentPrinter.getId();
final int index = mDestinationSpinnerAdapter.getPrinterIndex(printerId);
mDestinationSpinner.setSelection(index);
|
| private void | onStartCreateDocumentActivityResult(int resultCode, android.content.Intent data)
if (resultCode == RESULT_OK && data != null) {
setState(STATE_PRINT_COMPLETED);
updateOptionsUi();
final Uri uri = data.getData();
// Calling finish here does not invoke lifecycle callbacks but we
// update the print job in onPause if finishing, hence post a message.
mDestinationSpinner.post(new Runnable() {
@Override
public void run() {
transformDocumentAndFinish(uri);
}
});
} else if (resultCode == RESULT_CANCELED) {
mState = STATE_CONFIGURING;
updateOptionsUi();
} else {
setState(STATE_CREATE_FILE_FAILED);
updateOptionsUi();
// Calling finish here does not invoke lifecycle callbacks but we
// update the print job in onPause if finishing, hence post a message.
mDestinationSpinner.post(new Runnable() {
@Override
public void run() {
doFinish();
}
});
}
|
| public void | onUpdateCanceled()
if (DEBUG) {
Log.i(LOG_TAG, "onUpdateCanceled()");
}
mProgressMessageController.cancel();
ensurePreviewUiShown();
switch (mState) {
case STATE_PRINT_CONFIRMED: {
requestCreatePdfFileOrFinish();
} break;
case STATE_PRINT_CANCELED: {
doFinish();
} break;
}
|
| public void | onUpdateCompleted(com.android.printspooler.model.RemotePrintDocument.RemotePrintDocumentInfo document)
if (DEBUG) {
Log.i(LOG_TAG, "onUpdateCompleted()");
}
mProgressMessageController.cancel();
ensurePreviewUiShown();
// Update the print job with the info for the written document. The page
// count we get from the remote document is the pages in the document from
// the app perspective but the print job should contain the page count from
// print service perspective which is the pages in the written PDF not the
// pages in the printed document.
PrintDocumentInfo info = document.info;
if (info != null) {
final int pageCount = PageRangeUtils.getNormalizedPageCount(document.writtenPages,
getAdjustedPageCount(info));
PrintDocumentInfo adjustedInfo = new PrintDocumentInfo.Builder(info.getName())
.setContentType(info.getContentType())
.setPageCount(pageCount)
.build();
mPrintJob.setDocumentInfo(adjustedInfo);
mPrintJob.setPages(document.printedPages);
}
switch (mState) {
case STATE_PRINT_CONFIRMED: {
requestCreatePdfFileOrFinish();
} break;
case STATE_PRINT_CANCELED: {
updateOptionsUi();
} break;
default: {
updatePrintPreviewController(document.changed);
setState(STATE_CONFIGURING);
updateOptionsUi();
} break;
}
|
| public void | onUpdateFailed(java.lang.CharSequence error)
if (DEBUG) {
Log.i(LOG_TAG, "onUpdateFailed()");
}
mProgressMessageController.cancel();
ensureErrorUiShown(error, PrintErrorFragment.ACTION_RETRY);
setState(STATE_UPDATE_FAILED);
updateOptionsUi();
|
| private void | requestCreatePdfFileOrFinish()
if (mCurrentPrinter == mDestinationSpinnerAdapter.getPdfPrinter()) {
startCreateDocumentActivity();
} else {
transformDocumentAndFinish(null);
}
|
| private void | setState(int state)
if (isFinalState(mState)) {
if (isFinalState(state)) {
mState = state;
}
} else {
mState = state;
}
|
| private void | showFragment(android.app.Fragment newFragment)
FragmentTransaction transaction = getFragmentManager().beginTransaction();
Fragment oldFragment = getFragmentManager().findFragmentByTag(FRAGMENT_TAG);
if (oldFragment != null) {
transaction.remove(oldFragment);
}
if (newFragment != null) {
transaction.add(R.id.embedded_content_container, newFragment, FRAGMENT_TAG);
}
transaction.commit();
getFragmentManager().executePendingTransactions();
|
| private void | startAdvancedPrintOptionsActivity(android.print.PrinterInfo printer)
ComponentName serviceName = printer.getId().getServiceName();
String activityName = PrintOptionUtils.getAdvancedOptionsActivityName(this, serviceName);
if (TextUtils.isEmpty(activityName)) {
return;
}
Intent intent = new Intent(Intent.ACTION_MAIN);
intent.setComponent(new ComponentName(serviceName.getPackageName(), activityName));
List<ResolveInfo> resolvedActivities = getPackageManager()
.queryIntentActivities(intent, 0);
if (resolvedActivities.isEmpty()) {
return;
}
// The activity is a component name, therefore it is one or none.
if (resolvedActivities.get(0).activityInfo.exported) {
intent.putExtra(PrintService.EXTRA_PRINT_JOB_INFO, mPrintJob);
intent.putExtra(PrintService.EXTRA_PRINTER_INFO, printer);
// This is external activity and may not be there.
try {
startActivityForResult(intent, ACTIVITY_REQUEST_POPULATE_ADVANCED_PRINT_OPTIONS);
} catch (ActivityNotFoundException anfe) {
Log.e(LOG_TAG, "Error starting activity for intent: " + intent, anfe);
}
}
|
| private void | startCreateDocumentActivity()
if (!isResumed()) {
return;
}
PrintDocumentInfo info = mPrintedDocument.getDocumentInfo().info;
if (info == null) {
return;
}
Intent intent = new Intent(Intent.ACTION_CREATE_DOCUMENT);
intent.setType("application/pdf");
intent.putExtra(Intent.EXTRA_TITLE, info.getName());
intent.putExtra(DocumentsContract.EXTRA_PACKAGE_NAME, mCallingPackageName);
startActivityForResult(intent, ACTIVITY_REQUEST_CREATE_FILE);
|
| private void | startSelectPrinterActivity()
Intent intent = new Intent(this, SelectPrinterActivity.class);
startActivityForResult(intent, ACTIVITY_REQUEST_SELECT_PRINTER);
|
| private void | transformDocumentAndFinish(android.net.Uri writeToUri)
// If saving to PDF, apply the attibutes as we are acting as a print service.
PrintAttributes attributes = mDestinationSpinnerAdapter.getPdfPrinter() == mCurrentPrinter
? mPrintJob.getAttributes() : null;
new DocumentTransformer(this, mPrintJob, mFileProvider, attributes, new Runnable() {
@Override
public void run() {
if (writeToUri != null) {
mPrintedDocument.writeContent(getContentResolver(), writeToUri);
}
doFinish();
}
}).transform();
|
| private boolean | updateDocument(boolean clearLastError)
if (!clearLastError && mPrintedDocument.hasUpdateError()) {
return false;
}
if (clearLastError && mPrintedDocument.hasUpdateError()) {
mPrintedDocument.clearUpdateError();
}
final boolean preview = mState != STATE_PRINT_CONFIRMED;
final PageRange[] pages;
if (preview) {
pages = mPrintPreviewController.getRequestedPages();
} else {
pages = mPrintPreviewController.getSelectedPages();
}
final boolean willUpdate = mPrintedDocument.update(mPrintJob.getAttributes(),
pages, preview);
if (willUpdate && !mPrintedDocument.hasLaidOutPages()) {
// When the update is done we update the print preview.
mProgressMessageController.post();
return true;
} else if (!willUpdate) {
// Update preview.
updatePrintPreviewController(false);
}
return false;
|
| void | updateOptionsUi()
// Always update the summary.
updateSummary();
if (mState == STATE_PRINT_CONFIRMED
|| mState == STATE_PRINT_COMPLETED
|| mState == STATE_PRINT_CANCELED
|| mState == STATE_UPDATE_FAILED
|| mState == STATE_CREATE_FILE_FAILED
|| mState == STATE_PRINTER_UNAVAILABLE
|| mState == STATE_UPDATE_SLOW) {
if (mState != STATE_PRINTER_UNAVAILABLE) {
mDestinationSpinner.setEnabled(false);
}
mCopiesEditText.setEnabled(false);
mCopiesEditText.setFocusable(false);
mMediaSizeSpinner.setEnabled(false);
mColorModeSpinner.setEnabled(false);
mOrientationSpinner.setEnabled(false);
mRangeOptionsSpinner.setEnabled(false);
mPageRangeEditText.setEnabled(false);
mPrintButton.setVisibility(View.GONE);
mMoreOptionsButton.setEnabled(false);
return;
}
// If no current printer, or it has no capabilities, or it is not
// available, we disable all print options except the destination.
if (mCurrentPrinter == null || !canPrint(mCurrentPrinter)) {
mCopiesEditText.setEnabled(false);
mCopiesEditText.setFocusable(false);
mMediaSizeSpinner.setEnabled(false);
mColorModeSpinner.setEnabled(false);
mOrientationSpinner.setEnabled(false);
mRangeOptionsSpinner.setEnabled(false);
mPageRangeEditText.setEnabled(false);
mPrintButton.setVisibility(View.GONE);
mMoreOptionsButton.setEnabled(false);
return;
}
PrinterCapabilitiesInfo capabilities = mCurrentPrinter.getCapabilities();
PrintAttributes defaultAttributes = capabilities.getDefaults();
// Destination.
mDestinationSpinner.setEnabled(true);
// Media size.
mMediaSizeSpinner.setEnabled(true);
List<MediaSize> mediaSizes = new ArrayList<>(capabilities.getMediaSizes());
// Sort the media sizes based on the current locale.
Collections.sort(mediaSizes, mMediaSizeComparator);
PrintAttributes attributes = mPrintJob.getAttributes();
// If the media sizes changed, we update the adapter and the spinner.
boolean mediaSizesChanged = false;
final int mediaSizeCount = mediaSizes.size();
if (mediaSizeCount != mMediaSizeSpinnerAdapter.getCount()) {
mediaSizesChanged = true;
} else {
for (int i = 0; i < mediaSizeCount; i++) {
if (!mediaSizes.get(i).equals(mMediaSizeSpinnerAdapter.getItem(i).value)) {
mediaSizesChanged = true;
break;
}
}
}
if (mediaSizesChanged) {
// Remember the old media size to try selecting it again.
int oldMediaSizeNewIndex = AdapterView.INVALID_POSITION;
MediaSize oldMediaSize = attributes.getMediaSize();
// Rebuild the adapter data.
mMediaSizeSpinnerAdapter.clear();
for (int i = 0; i < mediaSizeCount; i++) {
MediaSize mediaSize = mediaSizes.get(i);
if (oldMediaSize != null
&& mediaSize.asPortrait().equals(oldMediaSize.asPortrait())) {
// Update the index of the old selection.
oldMediaSizeNewIndex = i;
}
mMediaSizeSpinnerAdapter.add(new SpinnerItem<>(
mediaSize, mediaSize.getLabel(getPackageManager())));
}
if (oldMediaSizeNewIndex != AdapterView.INVALID_POSITION) {
// Select the old media size - nothing really changed.
if (mMediaSizeSpinner.getSelectedItemPosition() != oldMediaSizeNewIndex) {
mMediaSizeSpinner.setSelection(oldMediaSizeNewIndex);
}
} else {
// Select the first or the default.
final int mediaSizeIndex = Math.max(mediaSizes.indexOf(
defaultAttributes.getMediaSize()), 0);
if (mMediaSizeSpinner.getSelectedItemPosition() != mediaSizeIndex) {
mMediaSizeSpinner.setSelection(mediaSizeIndex);
}
// Respect the orientation of the old selection.
if (oldMediaSize != null) {
if (oldMediaSize.isPortrait()) {
attributes.setMediaSize(mMediaSizeSpinnerAdapter
.getItem(mediaSizeIndex).value.asPortrait());
} else {
attributes.setMediaSize(mMediaSizeSpinnerAdapter
.getItem(mediaSizeIndex).value.asLandscape());
}
}
}
}
// Color mode.
mColorModeSpinner.setEnabled(true);
final int colorModes = capabilities.getColorModes();
// If the color modes changed, we update the adapter and the spinner.
boolean colorModesChanged = false;
if (Integer.bitCount(colorModes) != mColorModeSpinnerAdapter.getCount()) {
colorModesChanged = true;
} else {
int remainingColorModes = colorModes;
int adapterIndex = 0;
while (remainingColorModes != 0) {
final int colorBitOffset = Integer.numberOfTrailingZeros(remainingColorModes);
final int colorMode = 1 << colorBitOffset;
remainingColorModes &= ~colorMode;
if (colorMode != mColorModeSpinnerAdapter.getItem(adapterIndex).value) {
colorModesChanged = true;
break;
}
adapterIndex++;
}
}
if (colorModesChanged) {
// Remember the old color mode to try selecting it again.
int oldColorModeNewIndex = AdapterView.INVALID_POSITION;
final int oldColorMode = attributes.getColorMode();
// Rebuild the adapter data.
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;
if (colorMode == oldColorMode) {
// Update the index of the old selection.
oldColorModeNewIndex = colorBitOffset;
}
remainingColorModes &= ~colorMode;
mColorModeSpinnerAdapter.add(new SpinnerItem<>(colorMode,
colorModeLabels[colorBitOffset]));
}
if (oldColorModeNewIndex != AdapterView.INVALID_POSITION) {
// Select the old color mode - nothing really changed.
if (mColorModeSpinner.getSelectedItemPosition() != oldColorModeNewIndex) {
mColorModeSpinner.setSelection(oldColorModeNewIndex);
}
} else {
// Select the default.
final int selectedColorMode = colorModes & defaultAttributes.getColorMode();
final int itemCount = mColorModeSpinnerAdapter.getCount();
for (int i = 0; i < itemCount; i++) {
SpinnerItem<Integer> item = mColorModeSpinnerAdapter.getItem(i);
if (selectedColorMode == item.value) {
if (mColorModeSpinner.getSelectedItemPosition() != i) {
mColorModeSpinner.setSelection(i);
}
attributes.setColorMode(selectedColorMode);
}
}
}
}
// Orientation
mOrientationSpinner.setEnabled(true);
MediaSize mediaSize = attributes.getMediaSize();
if (mediaSize != null) {
if (mediaSize.isPortrait()
&& mOrientationSpinner.getSelectedItemPosition() != 0) {
mOrientationSpinner.setSelection(0);
} else if (!mediaSize.isPortrait()
&& mOrientationSpinner.getSelectedItemPosition() != 1) {
mOrientationSpinner.setSelection(1);
}
}
// Range options
PrintDocumentInfo info = mPrintedDocument.getDocumentInfo().info;
final int pageCount = getAdjustedPageCount(info);
if (info != null && pageCount > 0) {
if (pageCount == 1) {
mRangeOptionsSpinner.setEnabled(false);
} else {
mRangeOptionsSpinner.setEnabled(true);
if (mRangeOptionsSpinner.getSelectedItemPosition() > 0) {
if (!mPageRangeEditText.isEnabled()) {
mPageRangeEditText.setEnabled(true);
mPageRangeEditText.setVisibility(View.VISIBLE);
mPageRangeTitle.setVisibility(View.VISIBLE);
mPageRangeEditText.requestFocus();
InputMethodManager imm = (InputMethodManager)
getSystemService(Context.INPUT_METHOD_SERVICE);
imm.showSoftInput(mPageRangeEditText, 0);
}
} else {
mPageRangeEditText.setEnabled(false);
mPageRangeEditText.setVisibility(View.INVISIBLE);
mPageRangeTitle.setVisibility(View.INVISIBLE);
}
}
} else {
if (mRangeOptionsSpinner.getSelectedItemPosition() != 0) {
mRangeOptionsSpinner.setSelection(0);
mPageRangeEditText.setText("");
}
mRangeOptionsSpinner.setEnabled(false);
mPageRangeEditText.setEnabled(false);
mPageRangeEditText.setVisibility(View.INVISIBLE);
mPageRangeTitle.setVisibility(View.INVISIBLE);
}
final int newPageCount = getAdjustedPageCount(info);
if (newPageCount != mCurrentPageCount) {
mCurrentPageCount = newPageCount;
updatePageRangeOptions(newPageCount);
}
// Advanced print options
ComponentName serviceName = mCurrentPrinter.getId().getServiceName();
if (!TextUtils.isEmpty(PrintOptionUtils.getAdvancedOptionsActivityName(
this, serviceName))) {
mMoreOptionsButton.setVisibility(View.VISIBLE);
mMoreOptionsButton.setEnabled(true);
} else {
mMoreOptionsButton.setVisibility(View.GONE);
mMoreOptionsButton.setEnabled(false);
}
// Print
if (mDestinationSpinnerAdapter.getPdfPrinter() != mCurrentPrinter) {
mPrintButton.setImageResource(com.android.internal.R.drawable.ic_print);
mPrintButton.setContentDescription(getString(R.string.print_button));
} else {
mPrintButton.setImageResource(R.drawable.ic_menu_savetopdf);
mPrintButton.setContentDescription(getString(R.string.savetopdf_button));
}
if (!mPrintedDocument.getDocumentInfo().laidout
||(mRangeOptionsSpinner.getSelectedItemPosition() == 1
&& (TextUtils.isEmpty(mPageRangeEditText.getText()) || hasErrors()))
|| (mRangeOptionsSpinner.getSelectedItemPosition() == 0
&& (mPrintedDocument.getDocumentInfo() == null || hasErrors()))) {
mPrintButton.setVisibility(View.GONE);
} else {
mPrintButton.setVisibility(View.VISIBLE);
}
// Copies
if (mDestinationSpinnerAdapter.getPdfPrinter() != mCurrentPrinter) {
mCopiesEditText.setEnabled(true);
mCopiesEditText.setFocusableInTouchMode(true);
} else {
CharSequence text = mCopiesEditText.getText();
if (TextUtils.isEmpty(text) || !MIN_COPIES_STRING.equals(text.toString())) {
mCopiesEditText.setText(MIN_COPIES_STRING);
}
mCopiesEditText.setEnabled(false);
mCopiesEditText.setFocusable(false);
}
if (mCopiesEditText.getError() == null
&& TextUtils.isEmpty(mCopiesEditText.getText())) {
mCopiesEditText.setText(MIN_COPIES_STRING);
mCopiesEditText.requestFocus();
}
|
| private void | updatePageRangeOptions(int pageCount)
ArrayAdapter<SpinnerItem<Integer>> rangeOptionsSpinnerAdapter =
(ArrayAdapter) mRangeOptionsSpinner.getAdapter();
rangeOptionsSpinnerAdapter.clear();
final int[] rangeOptionsValues = getResources().getIntArray(
R.array.page_options_values);
String pageCountLabel = (pageCount > 0) ? String.valueOf(pageCount) : "";
String[] rangeOptionsLabels = new String[] {
getString(R.string.template_all_pages, pageCountLabel),
getString(R.string.template_page_range, pageCountLabel)
};
final int rangeOptionsCount = rangeOptionsLabels.length;
for (int i = 0; i < rangeOptionsCount; i++) {
rangeOptionsSpinnerAdapter.add(new SpinnerItem<>(
rangeOptionsValues[i], rangeOptionsLabels[i]));
}
|
| private void | updatePrintAttributesFromCapabilities(android.print.PrinterCapabilitiesInfo capabilities)
PrintAttributes defaults = capabilities.getDefaults();
// Sort the media sizes based on the current locale.
List<MediaSize> sortedMediaSizes = new ArrayList<>(capabilities.getMediaSizes());
Collections.sort(sortedMediaSizes, mMediaSizeComparator);
PrintAttributes attributes = mPrintJob.getAttributes();
// Media size.
MediaSize currMediaSize = attributes.getMediaSize();
if (currMediaSize == null) {
attributes.setMediaSize(defaults.getMediaSize());
} else {
boolean foundCurrentMediaSize = false;
// Try to find the current media size in the capabilities as
// it may be in a different orientation.
MediaSize currMediaSizePortrait = currMediaSize.asPortrait();
final int mediaSizeCount = sortedMediaSizes.size();
for (int i = 0; i < mediaSizeCount; i++) {
MediaSize mediaSize = sortedMediaSizes.get(i);
if (currMediaSizePortrait.equals(mediaSize.asPortrait())) {
attributes.setMediaSize(currMediaSize);
foundCurrentMediaSize = true;
break;
}
}
// If we did not find the current media size fall back to default.
if (!foundCurrentMediaSize) {
attributes.setMediaSize(defaults.getMediaSize());
}
}
// Color mode.
final int colorMode = attributes.getColorMode();
if ((capabilities.getColorModes() & colorMode) == 0) {
attributes.setColorMode(defaults.getColorMode());
}
// Resolution
Resolution resolution = attributes.getResolution();
if (resolution == null || !capabilities.getResolutions().contains(resolution)) {
attributes.setResolution(defaults.getResolution());
}
// Margins.
attributes.setMinMargins(defaults.getMinMargins());
|
| private void | updatePrintPreviewController(boolean contentUpdated)
// If we have not heard from the application, do nothing.
RemotePrintDocumentInfo documentInfo = mPrintedDocument.getDocumentInfo();
if (!documentInfo.laidout) {
return;
}
// Update the preview controller.
mPrintPreviewController.onContentUpdated(contentUpdated,
getAdjustedPageCount(documentInfo.info),
mPrintedDocument.getDocumentInfo().writtenPages,
mSelectedPages, mPrintJob.getAttributes().getMediaSize(),
mPrintJob.getAttributes().getMinMargins());
|
| private void | updateSelectedPages(android.print.PageRange[] selectedPages, int pageInDocumentCount)
if (selectedPages == null || selectedPages.length <= 0) {
return;
}
selectedPages = PageRangeUtils.normalize(selectedPages);
// Handle the case where all pages are specified explicitly
// instead of the *all pages* constant.
if (PageRangeUtils.isAllPages(selectedPages, pageInDocumentCount)) {
selectedPages = new PageRange[] {PageRange.ALL_PAGES};
}
if (Arrays.equals(mSelectedPages, selectedPages)) {
return;
}
mSelectedPages = selectedPages;
mPrintJob.setPages(selectedPages);
if (Arrays.equals(selectedPages, ALL_PAGES_ARRAY)) {
if (mRangeOptionsSpinner.getSelectedItemPosition() != 0) {
mRangeOptionsSpinner.setSelection(0);
mPageRangeEditText.setText("");
}
} else if (selectedPages[0].getStart() >= 0
&& selectedPages[selectedPages.length - 1].getEnd() < pageInDocumentCount) {
if (mRangeOptionsSpinner.getSelectedItemPosition() != 1) {
mRangeOptionsSpinner.setSelection(1);
}
StringBuilder builder = new StringBuilder();
final int pageRangeCount = selectedPages.length;
for (int i = 0; i < pageRangeCount; i++) {
if (builder.length() > 0) {
builder.append(',");
}
final int shownStartPage;
final int shownEndPage;
PageRange pageRange = selectedPages[i];
if (pageRange.equals(PageRange.ALL_PAGES)) {
shownStartPage = 1;
shownEndPage = pageInDocumentCount;
} else {
shownStartPage = pageRange.getStart() + 1;
shownEndPage = pageRange.getEnd() + 1;
}
builder.append(shownStartPage);
if (shownStartPage != shownEndPage) {
builder.append('-");
builder.append(shownEndPage);
}
}
mPageRangeEditText.setText(builder.toString());
}
|
| private void | updateSelectedPagesFromPreview()
PageRange[] selectedPages = mPrintPreviewController.getSelectedPages();
if (!Arrays.equals(mSelectedPages, selectedPages)) {
updateSelectedPages(selectedPages,
getAdjustedPageCount(mPrintedDocument.getDocumentInfo().info));
}
|
| private void | updateSummary()
CharSequence copiesText = null;
CharSequence mediaSizeText = null;
if (!TextUtils.isEmpty(mCopiesEditText.getText())) {
copiesText = mCopiesEditText.getText();
mSummaryCopies.setText(copiesText);
}
final int selectedMediaIndex = mMediaSizeSpinner.getSelectedItemPosition();
if (selectedMediaIndex >= 0) {
SpinnerItem<MediaSize> mediaItem = mMediaSizeSpinnerAdapter.getItem(selectedMediaIndex);
mediaSizeText = mediaItem.label;
mSummaryPaperSize.setText(mediaSizeText);
}
if (!TextUtils.isEmpty(copiesText) && !TextUtils.isEmpty(mediaSizeText)) {
String summaryText = getString(R.string.summary_template, copiesText, mediaSizeText);
mSummaryContainer.setContentDescription(summaryText);
}
|
