Android Generate PDF from view

PDFUtil.java

import android.annotation.TargetApi;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.pdf.PdfDocument;
import android.graphics.pdf.PdfRenderer;
import android.os.AsyncTask;
import android.os.Build;
import android.os.ParcelFileDescriptor;
import android.util.Log;
import android.view.View;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * A Class used to generate PDF for the given Views.
 */

@TargetApi(Build.VERSION_CODES.KITKAT)
public class PDFUtil {


    /**
     * TAG.
     */
    private static final String TAG = PDFUtil.class.getName();
    /**
     * Page width for our PDF.
     */
    public static final double PDF_PAGE_WIDTH = 8.3 * 72;
    /**
     * Page height for our PDF.
     */
    public static final double PDF_PAGE_HEIGHT = 11.7 * 72;
    /**
     * Page width for our PDF in inch.
     */
//    public static final double PDF_PAGE_WIDTH_INCH = 8.3;
    /**
     * Page height for our PDF in inch.
     */
//    public static final double PDF_PAGE_HEIGHT_INCH = 11.7;
    /**
     * Singleton instance for PDFUtil.
     */
    private static PDFUtil sInstance;

    /**
     * Constructor.
     */
    private PDFUtil() {

    }

    /**
     * Return singleton instance of PDFUtil.
     *
     * @return singleton instance of PDFUtil.
     */
    public static PDFUtil getInstance() {
        if (sInstance == null) {
            sInstance = new PDFUtil();
        }
        return sInstance;
    }

    /**
     * Generates PDF for the given content views to the file path specified.
     * <p/>
     * Method gets List of views as the input and each view will be written to the single page in
     * the PDF.
     * <p/>
     * If API is not support then PDFUtilListener's  pdfGenerationFailure method will be called with
     * APINotSupportedException.
     *
     * @param contentViews List of Content Views to be converted as PDF.
     * @param filePath     FilePath where the PDF has to be stored.
     * @param listener     PDFUtilListener to send callback for PDF generation.
     */
    public final void generatePDF(final List<View> contentViews, final String filePath,
                                  final PDFUtilListener listener) {
        // Check Api Version.
        int currentApiVersion = Build.VERSION.SDK_INT;
        if (currentApiVersion >= Build.VERSION_CODES.KITKAT) {
            // Kitkat
            new GeneratePDFAsync(contentViews, filePath, listener).execute();
        } else {
            // Before Kitkat
            Log.e(TAG, "Generate PDF is not available for your android version.");
            listener.pdfGenerationFailure(
                    new APINotSupportedException("Generate PDF is not available for your android version."));
        }

    }


    /**
     * Listener used to send PDF Generation callback.
     */
    public interface PDFUtilListener {
        /**
         * Called on the success of PDF Generation.
         */
        void pdfGenerationSuccess(File savedPDFFile);

        /**
         * Called when PDF Generation failed.
         *
         * @param exception Exception occurred during PDFGeneration.
         */
        void pdfGenerationFailure(final Exception exception);
    }

    /**
     * Async task class used to generate PDF in separate thread.
     */
    private class GeneratePDFAsync extends AsyncTask<Void, Void, File> {

        // mContentViews.
        private List<View> mContentViews;

        // mFilePath.
        private String mFilePath;

        // mListener.
        private PDFUtilListener mListener = null;

        // mException.
        private Exception mException;

        /**
         * Constructor.
         *
         * @param contentViews List of Content Views to be converted as PDF.
         * @param filePath     FilePath where the PDF has to be stored.
         * @param listener     PDFUtilListener to send callback for PDF generation.
         */
        public GeneratePDFAsync(final List<View> contentViews, final String filePath, final PDFUtilListener listener) {
            this.mContentViews = contentViews;
            this.mFilePath = filePath;
            this.mListener = listener;
        }


        /**
         * Do In Background.
         *
         * @param params Params
         * @return TRUE if PDF successfully generated else FALSE.
         */
        @Override
        protected File doInBackground(Void... params) {
            try {
                // Create PDF Document.
                PdfDocument pdfDocument = new PdfDocument();

                // Write content to PDFDocument.
                writePDFDocument(pdfDocument);

                // Save document to file.
                return savePDFDocumentToStorage(pdfDocument);
            } catch (Exception exception) {
                Log.e(TAG, exception.getMessage());
                return null;
            }
        }

        /**
         * On Post Execute.
         *
         * @param savedPDFFile Saved pdf file, null if not generated successfully
         */
        @Override
        protected void onPostExecute(File savedPDFFile) {
            super.onPostExecute(savedPDFFile);
            if (savedPDFFile != null) {
                //Send Success callback.
                mListener.pdfGenerationSuccess(savedPDFFile);
            } else {
                //Send Error callback.
                mListener.pdfGenerationFailure(mException);
            }
        }

        /**
         * Writes given PDFDocument using content views.
         *
         * @param pdfDocument PDFDocument to be written.
         */
        private void writePDFDocument(final PdfDocument pdfDocument) {

            for (int i = 0; i < mContentViews.size(); i++) {

                //Get Content View.
                View contentView = mContentViews.get(i);

                // crate a page description
                PdfDocument.PageInfo pageInfo = new PdfDocument.PageInfo.
                        Builder((int) PDF_PAGE_WIDTH, (int) PDF_PAGE_HEIGHT, i + 1).create();

                // start a page
                PdfDocument.Page page = pdfDocument.startPage(pageInfo);

                // draw view on the page
                Canvas pageCanvas = page.getCanvas();
                pageCanvas.scale(1f, 1f);
                int pageWidth = pageCanvas.getWidth();
                int pageHeight = pageCanvas.getHeight();
                int measureWidth = View.MeasureSpec.makeMeasureSpec(pageWidth, View.MeasureSpec.EXACTLY);
                int measuredHeight = View.MeasureSpec.makeMeasureSpec(pageHeight, View.MeasureSpec.EXACTLY);
                contentView.measure(measureWidth, measuredHeight);
                contentView.layout(0, 0, pageWidth, pageHeight);
                contentView.draw(pageCanvas);

                // finish the page
                pdfDocument.finishPage(page);

            }
        }

        /**
         * Save PDFDocument to the File in the storage.
         *
         * @param pdfDocument Document to be written to the Storage.
         * @throws java.io.IOException
         */
        private File savePDFDocumentToStorage(final PdfDocument pdfDocument) throws IOException {
            FileOutputStream fos = null;
            // Create file.
            File pdfFile = null;
            if (mFilePath == null || mFilePath.isEmpty()) {
                pdfFile = File.createTempFile(Long.toString(new Date().getTime()), "pdf");
            } else {
                pdfFile = new File(mFilePath);
            }

            //Create parent directories
            File parentFile = pdfFile.getParentFile();
            if (!parentFile.exists() && !parentFile.mkdirs()) {
                throw new IllegalStateException("Couldn't create directory: " + parentFile);
            }
            boolean fileExists = pdfFile.exists();
            // If File already Exists. delete it.
            if (fileExists) {
                fileExists = !pdfFile.delete();
            }
            try {
                if (!fileExists) {
                    // Create New File.
                    fileExists = pdfFile.createNewFile();
                }

                if (fileExists) {
                    // Write PDFDocument to the file.
                    fos = new FileOutputStream(pdfFile);
                    pdfDocument.writeTo(fos);

                    //Close output stream
                    fos.close();

                    // close the document
                    pdfDocument.close();
                }
                return pdfFile;
            } catch (IOException exception) {
                exception.printStackTrace();
                if (fos != null) {
                    fos.close();
                }
                throw exception;
            }
        }
    }

    /**
     * APINotSupportedException will be thrown If the device doesn't support PDF methods.
     */
    private static class APINotSupportedException extends Exception {
        // mErrorMessage.
        private String mErrorMessage;

        /**
         * Constructor.
         *
         * @param errorMessage Error Message.
         */
        public APINotSupportedException(final String errorMessage) {
            this.mErrorMessage = errorMessage;
        }

        /**
         * To String.
         *
         * @return error message as a string.
         */
        @Override
        public String toString() {
            return "APINotSupportedException{" +
                    "mErrorMessage='" + mErrorMessage + '\'' +
                    '}';
        }
    }

    /**
     * Convert PDF to bitmap, only works on devices above LOLLIPOP
     *
     * @param pdfFile pdf file
     * @return list of bitmap of every page
     * @throws MyOPDException
     */
    public static ArrayList<Bitmap> pdfToBitmap(File pdfFile) throws MyOPDException, IllegalStateException {
        if (pdfFile == null || pdfFile.exists() == false) {
            throw new IllegalStateException("");
        }
        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
            throw new MyOPDException("PDF preview image cannot be generated in this device");
        }
        if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.LOLLIPOP) {
            return null;
        }

        ArrayList<Bitmap> bitmaps = new ArrayList<>();

        try {
            PdfRenderer renderer = new PdfRenderer(ParcelFileDescriptor.open(pdfFile, ParcelFileDescriptor.MODE_READ_ONLY));

            Bitmap bitmap;
            final int pageCount = renderer.getPageCount();
            for (int i = 0; i < pageCount; i++) {
                PdfRenderer.Page page = renderer.openPage(i);


                int width = page.getWidth();
                int height = page.getHeight();

                /* FOR HIGHER QUALITY IMAGES, USE:
                int width = context.getResources().getDisplayMetrics().densityDpi / 72 * page.getWidth();
                int height = context.getResources().getDisplayMetrics().densityDpi / 72 * page.getHeight();
                */

                bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
                page.render(bitmap, null, null, PdfRenderer.Page.RENDER_MODE_FOR_DISPLAY);

                bitmaps.add(bitmap);

                // close the page
                page.close();

            }

            // close the renderer
            renderer.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return bitmaps;

    }
}