/*
* 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.example.android.apis.app;
import android.app.ListActivity;
import android.content.Context;
import android.content.res.Configuration;
import android.graphics.pdf.PdfDocument.Page;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.CancellationSignal;
import android.os.CancellationSignal.OnCancelListener;
import android.os.ParcelFileDescriptor;
import android.print.PageRange;
import android.print.PrintAttributes;
import android.print.PrintDocumentAdapter;
import android.print.PrintDocumentInfo;
import android.print.PrintManager;
import android.print.pdf.PrintedPdfDocument;
import android.util.SparseIntArray;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.MeasureSpec;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.example.android.apis.R;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* This class demonstrates how to implement custom printing support.
* <p>
* This activity shows the list of the MotoGP champions by year and
* brand. The print option in the overflow menu allows the user to
* print the content. The list list of items is laid out to such that
* it fits the options selected by the user from the UI such as page
* size. Hence, for different page sizes the printed content will have
* different page count.
* </p>
* <p>
* This sample demonstrates how to completely implement a {@link
* PrintDocumentAdapter} in which:
* <ul>
* <li>Layout based on the selected print options is performed.</li>
* <li>Layout work is performed only if print options change would change the content.</li>
* <li>Layout result is properly reported.</li>
* <li>Only requested pages are written.</li>
* <li>Write result is properly reported.</li>
* <li>Both Layout and write respond to cancellation.</li>
* <li>Layout and render of views is demonstrated.</li>
* </ul>
* </p>
*
* @see PrintManager
* @see PrintDocumentAdapter
*/
public class PrintCustomContent extends ListActivity {
private static final int MILS_IN_INCH = 1000;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setListAdapter(new MotoGpStatAdapter(loadMotoGpStats(),
getLayoutInflater()));
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
super.onCreateOptionsMenu(menu);
getMenuInflater().inflate(R.menu.print_custom_content, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (item.getItemId() == R.id.menu_print) {
print();
return true;
}
return super.onOptionsItemSelected(item);
}
private void print() {
PrintManager printManager = (PrintManager) getSystemService(
Context.PRINT_SERVICE);
printManager.print("MotoGP stats",
new PrintDocumentAdapter() {
private int mRenderPageWidth;
private int mRenderPageHeight;
private PrintAttributes mPrintAttributes;
private PrintDocumentInfo mDocumentInfo;
private Context mPrintContext;
@Override
public void onLayout(final PrintAttributes oldAttributes,
final PrintAttributes newAttributes,
final CancellationSignal cancellationSignal,
final LayoutResultCallback callback,
final Bundle metadata) {
// If we are already cancelled, don't do any work.
if (cancellationSignal.isCanceled()) {
callback.onLayoutCancelled();
return;
}
// Now we determined if the print attributes changed in a way that
// would change the layout and if so we will do a layout pass.
boolean layoutNeeded = false;
final int density = Math.max(newAttributes.getResolution().getHorizontalDpi(),
newAttributes.getResolution().getVerticalDpi());
// Note that we are using the PrintedPdfDocument class which creates
// a PDF generating canvas whose size is in points (1/72") not screen
// pixels. Hence, this canvas is pretty small compared to the screen.
// The recommended way is to layout the content in the desired size,
// in this case as large as the printer can do, and set a translation
// to the PDF canvas to shrink in. Note that PDF is a vector format
// and you will not lose data during the transformation.
// The content width is equal to the page width minus the margins times
// the horizontal printer density. This way we get the maximal number
// of pixels the printer can put horizontally.
final int marginLeft = (int) (density * (float) newAttributes.getMinMargins()
.getLeftMils() / MILS_IN_INCH);
final int marginRight = (int) (density * (float) newAttributes.getMinMargins()
.getRightMils() / MILS_IN_INCH);
final int contentWidth = (int) (density * (float) newAttributes.getMediaSize()
.getWidthMils() / MILS_IN_INCH) - marginLeft - marginRight;
if (mRenderPageWidth != contentWidth) {
mRenderPageWidth = contentWidth;
layoutNeeded = true;
}
// The content height is equal to the page height minus the margins times
// the vertical printer resolution. This way we get the maximal number
// of pixels the printer can put vertically.
final int marginTop = (int) (density * (float) newAttributes.getMinMargins()
.getTopMils() / MILS_IN_INCH);
final int marginBottom = (int) (density * (float) newAttributes.getMinMargins()
.getBottomMils() / MILS_IN_INCH);
final int contentHeight = (int) (density * (float) newAttributes.getMediaSize()
.getHeightMils() / MILS_IN_INCH) - marginTop - marginBottom;
if (mRenderPageHeight != contentHeight) {
mRenderPageHeight = contentHeight;
layoutNeeded = true;
}
// Create a context for resources at printer density. We will
// be inflating views to render them and would like them to use
// resources for a density the printer supports.
if (mPrintContext == null || mPrintContext.getResources()
.getConfiguration().densityDpi != density) {
Configuration configuration = new Configuration();
configuration.densityDpi = density;
mPrintContext = createConfigurationContext(
configuration);
mPrintContext.setTheme(android.R.style.Theme_Holo_Light);
}
// If no layout is needed that we did a layout at least once and
// the document info is not null, also the second argument is false
// to notify the system that the content did not change. This is
// important as if the system has some pages and the content didn't
// change the system will ask, the application to write them again.
if (!layoutNeeded) {
callback.onLayoutFinished(mDocumentInfo, false);
return;
}
// For demonstration purposes we will do the layout off the main
// thread but for small content sizes like this one it is OK to do
// that on the main thread.
// Store the data as we will layout off the main thread.
final List<MotoGpStatItem> items = ((MotoGpStatAdapter)
getListAdapter()).cloneItems();
new AsyncTask<Void, Void, PrintDocumentInfo>() {
@Override
protected void onPreExecute() {
// First register for cancellation requests.
cancellationSignal.setOnCancelListener(new OnCancelListener() {
@Override
public void onCancel() {
cancel(true);
}
});
// Stash the attributes as we will need them for rendering.
mPrintAttributes = newAttributes;
}
@Override
protected PrintDocumentInfo doInBackground(Void... params) {
try {
// Create an adapter with the stats and an inflater
// to load resources for the printer density.
MotoGpStatAdapter adapter = new MotoGpStatAdapter(items,
(LayoutInflater) mPrintContext.getSystemService(
Context.LAYOUT_INFLATER_SERVICE));
int currentPage = 0;
int pageContentHeight = 0;
int viewType = -1;
View view = null;
LinearLayout dummyParent = new LinearLayout(mPrintContext);
dummyParent.setOrientation(LinearLayout.VERTICAL);
final int itemCount = adapter.getCount();
for (int i = 0; i < itemCount; i++) {
// Be nice and respond to cancellation.
if (isCancelled()) {
return null;
}
// Get the next view.
final int nextViewType = adapter.getItemViewType(i);
if (viewType == nextViewType) {
view = adapter.getView(i, view, dummyParent);
} else {
view = adapter.getView(i, null, dummyParent);
}
viewType = nextViewType;
// Measure the next view
measureView(view);
// Add the height but if the view crosses the page
// boundary we will put it to the next page.
pageContentHeight += view.getMeasuredHeight();
if (pageContentHeight > mRenderPageHeight) {
pageContentHeight = view.getMeasuredHeight();
currentPage++;
}
}
// Create a document info describing the result.
PrintDocumentInfo info = new PrintDocumentInfo
.Builder("MotoGP_stats.pdf")
.setContentType(PrintDocumentInfo.CONTENT_TYPE_DOCUMENT)
.setPageCount(currentPage + 1)
.build();
// We completed the layout as a result of print attributes
// change. Hence, if we are here the content changed for
// sure which is why we pass true as the second argument.
callback.onLayoutFinished(info, true);
return info;
} catch (Exception e) {
// An unexpected error, report that we failed and
// one may pass in a human readable localized text
// for what the error is if known.
callback.onLayoutFailed(null);
throw new RuntimeException(e);
}
}
@Override
protected void onPostExecute(PrintDocumentInfo result) {
// Update the cached info to send it over if the next
// layout pass does not result in a content change.
mDocumentInfo = result;
}
@Override
protected void onCancelled(PrintDocumentInfo result) {
// Task was cancelled, report that.
callback.onLayoutCancelled();
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null);
}
@Override
public void onWrite(final PageRange[] pages,
final ParcelFileDescriptor destination,
final CancellationSignal cancellationSignal,
final WriteResultCallback callback) {
// If we are already cancelled, don't do any work.
if (cancellationSignal.isCanceled()) {
callback.onWriteCancelled();
return;
}
// Store the data as we will layout off the main thread.
final List<MotoGpStatItem> items = ((MotoGpStatAdapter)
getListAdapter()).cloneItems();
new AsyncTask<Void, Void, Void>() {
private final SparseIntArray mWrittenPages = new SparseIntArray();
private final PrintedPdfDocument mPdfDocument = new PrintedPdfDocument(
PrintCustomContent.this, mPrintAttributes);
@Override
protected void onPreExecute() {
// First register for cancellation requests.
cancellationSignal.setOnCancelListener(new OnCancelListener() {
@Override
public void onCancel() {
cancel(true);
}
});
}
@Override
protected Void doInBackground(Void... params) {
// Go over all the pages and write only the requested ones.
// Create an adapter with the stats and an inflater
// to load resources for the printer density.
MotoGpStatAdapter adapter = new MotoGpStatAdapter(items,
(LayoutInflater) mPrintContext.getSystemService(
Context.LAYOUT_INFLATER_SERVICE));
int currentPage = -1;
int pageContentHeight = 0;
int viewType = -1;
View view = null;
Page page = null;
LinearLayout dummyParent = new LinearLayout(mPrintContext);
dummyParent.setOrientation(LinearLayout.VERTICAL);
// The content is laid out and rendered in screen pixels with
// the width and height of the paper size times the print
// density but the PDF canvas size is in points which are 1/72",
// so we will scale down the content.
final float scale = Math.min(
(float) mPdfDocument.getPageContentRect().width()
/ mRenderPageWidth,
(float) mPdfDocument.getPageContentRect().height()
/ mRenderPageHeight);
final int itemCount = adapter.getCount();
for (int i = 0; i < itemCount; i++) {
// Be nice and respond to cancellation.
if (isCancelled()) {
return null;
}
// Get the next view.
final int nextViewType = adapter.getItemViewType(i);
if (viewType == nextViewType) {
view = adapter.getView(i, view, dummyParent);
} else {
view = adapter.getView(i, null, dummyParent);
}
viewType = nextViewType;
// Measure the next view
measureView(view);
// Add the height but if the view crosses the page
// boundary we will put it to the next one.
pageContentHeight += view.getMeasuredHeight();
if (currentPage < 0 || pageContentHeight > mRenderPageHeight) {
pageContentHeight = view.getMeasuredHeight();
currentPage++;
// Done with the current page - finish it.
if (page != null) {
mPdfDocument.finishPage(page);
}
// If the page is requested, render it.
if (containsPage(pages, currentPage)) {
page = mPdfDocument.startPage(currentPage);
page.getCanvas().scale(scale, scale);
// Keep track which pages are written.
mWrittenPages.append(mWrittenPages.size(), currentPage);
} else {
page = null;
}
}
// If the current view is on a requested page, render it.
if (page != null) {
// Layout an render the content.
view.layout(0, 0, view.getMeasuredWidth(),
view.getMeasuredHeight());
view.draw(page.getCanvas());
// Move the canvas for the next view.
page.getCanvas().translate(0, view.getHeight());
}
}
// Done with the last page.
if (page != null) {
mPdfDocument.finishPage(page);
}
// Write the data and return success or failure.
try {
mPdfDocument.writeTo(new FileOutputStream(
destination.getFileDescriptor()));
// Compute which page ranges were written based on
// the bookkeeping we maintained.
PageRange[] pageRanges = computeWrittenPageRanges(mWrittenPages);
callback.onWriteFinished(pageRanges);
} catch (IOException ioe) {
callback.onWriteFailed(null);
} finally {
mPdfDocument.close();
}
return null;
}
@Override
protected void onCancelled(Void result) {
// Task was cancelled, report that.
callback.onWriteCancelled();
mPdfDocument.close();
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, (Void[]) null);
}
private void measureView(View view) {
final int widthMeasureSpec = ViewGroup.getChildMeasureSpec(
MeasureSpec.makeMeasureSpec(mRenderPageWidth,
MeasureSpec.EXACTLY), 0, view.getLayoutParams().width);
final int heightMeasureSpec = ViewGroup.getChildMeasureSpec(
MeasureSpec.makeMeasureSpec(mRenderPageHeight,
MeasureSpec.EXACTLY), 0, view.getLayoutParams().height);
view.measure(widthMeasureSpec, heightMeasureSpec);
}
private PageRange[] computeWrittenPageRanges(SparseIntArray writtenPages) {
List<PageRange> pageRanges = new ArrayList<PageRange>();
int start = -1;
int end = -1;
final int writtenPageCount = writtenPages.size();
for (int i = 0; i < writtenPageCount; i++) {
if (start < 0) {
start = writtenPages.valueAt(i);
}
int oldEnd = end = start;
while (i < writtenPageCount && (end - oldEnd) <= 1) {
oldEnd = end;
end = writtenPages.valueAt(i);
i++;
}
PageRange pageRange = new PageRange(start, end);
pageRanges.add(pageRange);
start = end = -1;
}
PageRange[] pageRangesArray = new PageRange[pageRanges.size()];
pageRanges.toArray(pageRangesArray);
return pageRangesArray;
}
private boolean containsPage(PageRange[] pageRanges, int page) {
final int pageRangeCount = pageRanges.length;
for (int i = 0; i < pageRangeCount; i++) {
if (pageRanges[i].getStart() <= page
&& pageRanges[i].getEnd() >= page) {
return true;
}
}
return false;
}
}, null);
}
private List<MotoGpStatItem> loadMotoGpStats() {
String[] years = getResources().getStringArray(R.array.motogp_years);
String[] champions = getResources().getStringArray(R.array.motogp_champions);
String[] constructors = getResources().getStringArray(R.array.motogp_constructors);
List<MotoGpStatItem> items = new ArrayList<MotoGpStatItem>();
final int itemCount = years.length;
for (int i = 0; i < itemCount; i++) {
MotoGpStatItem item = new MotoGpStatItem();
item.year = years[i];
item.champion = champions[i];
item.constructor = constructors[i];
items.add(item);
}
return items;
}
private static final class MotoGpStatItem {
String year;
String champion;
String constructor;
}
private class MotoGpStatAdapter extends BaseAdapter {
private final List<MotoGpStatItem> mItems;
private final LayoutInflater mInflater;
public MotoGpStatAdapter(List<MotoGpStatItem> items, LayoutInflater inflater) {
mItems = items;
mInflater = inflater;
}
public List<MotoGpStatItem> cloneItems() {
return new ArrayList<MotoGpStatItem>(mItems);
}
@Override
public int getCount() {
return mItems.size();
}
@Override
public Object getItem(int position) {
return mItems.get(position);
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
if (convertView == null) {
convertView = mInflater.inflate(R.layout.motogp_stat_item, parent, false);
}
MotoGpStatItem item = (MotoGpStatItem) getItem(position);
TextView yearView = (TextView) convertView.findViewById(R.id.year);
yearView.setText(item.year);
TextView championView = (TextView) convertView.findViewById(R.id.champion);
championView.setText(item.champion);
TextView constructorView = (TextView) convertView.findViewById(R.id.constructor);
constructorView.setText(item.constructor);
return convertView;
}
}
}