pdfViewReference;
private PdfiumCore pdfiumCore;
private String password;
private DocumentSource docSource;
private int[] userPages;
private PdfFile pdfFile;
DecodingAsyncTask(DocumentSource docSource, String password, int[] userPages, PDFView pdfView, PdfiumCore pdfiumCore) {
this.docSource = docSource;
this.userPages = userPages;
this.cancelled = false;
this.pdfViewReference = new WeakReference<>(pdfView);
this.password = password;
this.pdfiumCore = pdfiumCore;
}
@Override
protected Throwable doInBackground(Void... params) {
try {
PDFView pdfView = pdfViewReference.get();
if (pdfView != null) {
PdfDocument pdfDocument = docSource.createDocument(pdfView.getContext(), pdfiumCore, password);
pdfFile = new PdfFile(pdfiumCore, pdfDocument, pdfView.getPageFitPolicy(), getViewSize(pdfView),
userPages, pdfView.isSwipeVertical(), pdfView.getSpacingPx(), pdfView.isAutoSpacingEnabled(),
pdfView.isFitEachPage());
return null;
} else {
return new NullPointerException("pdfView == null");
}
} catch (Throwable t) {
return t;
}
}
private Size getViewSize(PDFView pdfView) {
return new Size(pdfView.getWidth(), pdfView.getHeight());
}
@Override
protected void onPostExecute(Throwable t) {
PDFView pdfView = pdfViewReference.get();
if (pdfView != null) {
if (t != null) {
pdfView.loadError(t);
return;
}
if (!cancelled) {
pdfView.loadComplete(pdfFile);
}
}
}
@Override
protected void onCancelled() {
cancelled = true;
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/DragPinchManager.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer;
import android.graphics.PointF;
import android.graphics.RectF;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.ScaleGestureDetector;
import android.view.View;
import com.github.barteksc.pdfviewer.model.LinkTapEvent;
import com.github.barteksc.pdfviewer.scroll.ScrollHandle;
import com.github.barteksc.pdfviewer.util.SnapEdge;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.util.SizeF;
import static com.github.barteksc.pdfviewer.util.Constants.Pinch.MAXIMUM_ZOOM;
import static com.github.barteksc.pdfviewer.util.Constants.Pinch.MINIMUM_ZOOM;
/**
* This Manager takes care of moving the PDFView,
* set its zoom track user actions.
*/
class DragPinchManager implements GestureDetector.OnGestureListener, GestureDetector.OnDoubleTapListener, ScaleGestureDetector.OnScaleGestureListener, View.OnTouchListener {
private PDFView pdfView;
private AnimationManager animationManager;
private GestureDetector gestureDetector;
private ScaleGestureDetector scaleGestureDetector;
private boolean scrolling = false;
private boolean scaling = false;
private boolean enabled = false;
DragPinchManager(PDFView pdfView, AnimationManager animationManager) {
this.pdfView = pdfView;
this.animationManager = animationManager;
gestureDetector = new GestureDetector(pdfView.getContext(), this);
scaleGestureDetector = new ScaleGestureDetector(pdfView.getContext(), this);
pdfView.setOnTouchListener(this);
}
void enable() {
enabled = true;
}
void disable() {
enabled = false;
}
void disableLongpress(){
gestureDetector.setIsLongpressEnabled(false);
}
@Override
public boolean onSingleTapConfirmed(MotionEvent e) {
boolean onTapHandled = pdfView.callbacks.callOnTap(e);
boolean linkTapped = checkLinkTapped(e.getX(), e.getY());
if (!onTapHandled && !linkTapped) {
ScrollHandle ps = pdfView.getScrollHandle();
if (ps != null && !pdfView.documentFitsView()) {
if (!ps.shown()) {
ps.show();
} else {
ps.hide();
}
}
}
pdfView.performClick();
return true;
}
private boolean checkLinkTapped(float x, float y) {
PdfFile pdfFile = pdfView.pdfFile;
if (pdfFile == null) {
return false;
}
float mappedX = -pdfView.getCurrentXOffset() + x;
float mappedY = -pdfView.getCurrentYOffset() + y;
int page = pdfFile.getPageAtOffset(pdfView.isSwipeVertical() ? mappedY : mappedX, pdfView.getZoom());
SizeF pageSize = pdfFile.getScaledPageSize(page, pdfView.getZoom());
int pageX, pageY;
if (pdfView.isSwipeVertical()) {
pageX = (int) pdfFile.getSecondaryPageOffset(page, pdfView.getZoom());
pageY = (int) pdfFile.getPageOffset(page, pdfView.getZoom());
} else {
pageY = (int) pdfFile.getSecondaryPageOffset(page, pdfView.getZoom());
pageX = (int) pdfFile.getPageOffset(page, pdfView.getZoom());
}
for (PdfDocument.Link link : pdfFile.getPageLinks(page)) {
RectF mapped = pdfFile.mapRectToDevice(page, pageX, pageY, (int) pageSize.getWidth(),
(int) pageSize.getHeight(), link.getBounds());
mapped.sort();
if (mapped.contains(mappedX, mappedY)) {
pdfView.callbacks.callLinkHandler(new LinkTapEvent(x, y, mappedX, mappedY, mapped, link));
return true;
}
}
return false;
}
private void startPageFling(MotionEvent downEvent, MotionEvent ev, float velocityX, float velocityY) {
if (!checkDoPageFling(velocityX, velocityY)) {
return;
}
int direction;
if (pdfView.isSwipeVertical()) {
direction = velocityY > 0 ? -1 : 1;
} else {
direction = velocityX > 0 ? -1 : 1;
}
// get the focused page during the down event to ensure only a single page is changed
float delta = pdfView.isSwipeVertical() ? ev.getY() - downEvent.getY() : ev.getX() - downEvent.getX();
float offsetX = pdfView.getCurrentXOffset() - delta * pdfView.getZoom();
float offsetY = pdfView.getCurrentYOffset() - delta * pdfView.getZoom();
int startingPage = pdfView.findFocusPage(offsetX, offsetY);
int targetPage = Math.max(0, Math.min(pdfView.getPageCount() - 1, startingPage + direction));
SnapEdge edge = pdfView.findSnapEdge(targetPage);
float offset = pdfView.snapOffsetForPage(targetPage, edge);
animationManager.startPageFlingAnimation(-offset);
}
@Override
public boolean onDoubleTap(MotionEvent e) {
if (!pdfView.isDoubletapEnabled()) {
return false;
}
if (pdfView.getZoom() < pdfView.getMidZoom()) {
pdfView.zoomWithAnimation(e.getX(), e.getY(), pdfView.getMidZoom());
} else if (pdfView.getZoom() < pdfView.getMaxZoom()) {
pdfView.zoomWithAnimation(e.getX(), e.getY(), pdfView.getMaxZoom());
} else {
pdfView.resetZoomWithAnimation();
}
return true;
}
@Override
public boolean onDoubleTapEvent(MotionEvent e) {
return false;
}
@Override
public boolean onDown(MotionEvent e) {
animationManager.stopFling();
return true;
}
@Override
public void onShowPress(MotionEvent e) {
}
@Override
public boolean onSingleTapUp(MotionEvent e) {
return false;
}
@Override
public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
scrolling = true;
if (pdfView.isZooming() || pdfView.isSwipeEnabled()) {
pdfView.moveRelativeTo(-distanceX, -distanceY);
}
if (!scaling || pdfView.doRenderDuringScale()) {
pdfView.loadPageByOffset();
}
return true;
}
private void onScrollEnd(MotionEvent event) {
pdfView.loadPages();
hideHandle();
if (!animationManager.isFlinging()) {
pdfView.performPageSnap();
}
}
@Override
public void onLongPress(MotionEvent e) {
pdfView.callbacks.callOnLongPress(e);
}
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
if (!pdfView.isSwipeEnabled()) {
return false;
}
if (pdfView.isPageFlingEnabled()) {
if (pdfView.pageFillsScreen()) {
onBoundedFling(velocityX, velocityY);
} else {
startPageFling(e1, e2, velocityX, velocityY);
}
return true;
}
int xOffset = (int) pdfView.getCurrentXOffset();
int yOffset = (int) pdfView.getCurrentYOffset();
float minX, minY;
PdfFile pdfFile = pdfView.pdfFile;
if (pdfView.isSwipeVertical()) {
minX = -(pdfView.toCurrentScale(pdfFile.getMaxPageWidth()) - pdfView.getWidth());
minY = -(pdfFile.getDocLen(pdfView.getZoom()) - pdfView.getHeight());
} else {
minX = -(pdfFile.getDocLen(pdfView.getZoom()) - pdfView.getWidth());
minY = -(pdfView.toCurrentScale(pdfFile.getMaxPageHeight()) - pdfView.getHeight());
}
animationManager.startFlingAnimation(xOffset, yOffset, (int) (velocityX), (int) (velocityY),
(int) minX, 0, (int) minY, 0);
return true;
}
private void onBoundedFling(float velocityX, float velocityY) {
int xOffset = (int) pdfView.getCurrentXOffset();
int yOffset = (int) pdfView.getCurrentYOffset();
PdfFile pdfFile = pdfView.pdfFile;
float pageStart = -pdfFile.getPageOffset(pdfView.getCurrentPage(), pdfView.getZoom());
float pageEnd = pageStart - pdfFile.getPageLength(pdfView.getCurrentPage(), pdfView.getZoom());
float minX, minY, maxX, maxY;
if (pdfView.isSwipeVertical()) {
minX = -(pdfView.toCurrentScale(pdfFile.getMaxPageWidth()) - pdfView.getWidth());
minY = pageEnd + pdfView.getHeight();
maxX = 0;
maxY = pageStart;
} else {
minX = pageEnd + pdfView.getWidth();
minY = -(pdfView.toCurrentScale(pdfFile.getMaxPageHeight()) - pdfView.getHeight());
maxX = pageStart;
maxY = 0;
}
animationManager.startFlingAnimation(xOffset, yOffset, (int) (velocityX), (int) (velocityY),
(int) minX, (int) maxX, (int) minY, (int) maxY);
}
@Override
public boolean onScale(ScaleGestureDetector detector) {
float dr = detector.getScaleFactor();
float wantedZoom = pdfView.getZoom() * dr;
float minZoom = Math.min(MINIMUM_ZOOM, pdfView.getMinZoom());
float maxZoom = Math.min(MAXIMUM_ZOOM, pdfView.getMaxZoom());
if (wantedZoom < minZoom) {
dr = minZoom / pdfView.getZoom();
} else if (wantedZoom > maxZoom) {
dr = maxZoom / pdfView.getZoom();
}
pdfView.zoomCenteredRelativeTo(dr, new PointF(detector.getFocusX(), detector.getFocusY()));
return true;
}
@Override
public boolean onScaleBegin(ScaleGestureDetector detector) {
scaling = true;
return true;
}
@Override
public void onScaleEnd(ScaleGestureDetector detector) {
pdfView.loadPages();
hideHandle();
scaling = false;
}
@Override
public boolean onTouch(View v, MotionEvent event) {
if (!enabled) {
return false;
}
boolean retVal = scaleGestureDetector.onTouchEvent(event);
retVal = gestureDetector.onTouchEvent(event) || retVal;
if (event.getAction() == MotionEvent.ACTION_UP) {
if (scrolling) {
scrolling = false;
onScrollEnd(event);
}
}
return retVal;
}
private void hideHandle() {
ScrollHandle scrollHandle = pdfView.getScrollHandle();
if (scrollHandle != null && scrollHandle.shown()) {
scrollHandle.hideDelayed();
}
}
private boolean checkDoPageFling(float velocityX, float velocityY) {
float absX = Math.abs(velocityX);
float absY = Math.abs(velocityY);
return pdfView.isSwipeVertical() ? absY > absX : absX > absY;
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/PDFView.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.ColorMatrix;
import android.graphics.ColorMatrixColorFilter;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.PaintFlagsDrawFilter;
import android.graphics.PointF;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.HandlerThread;
import android.util.AttributeSet;
import android.util.Log;
import android.widget.RelativeLayout;
import com.github.barteksc.pdfviewer.exception.PageRenderingException;
import com.github.barteksc.pdfviewer.link.DefaultLinkHandler;
import com.github.barteksc.pdfviewer.link.LinkHandler;
import com.github.barteksc.pdfviewer.listener.Callbacks;
import com.github.barteksc.pdfviewer.listener.OnDrawListener;
import com.github.barteksc.pdfviewer.listener.OnErrorListener;
import com.github.barteksc.pdfviewer.listener.OnLoadCompleteListener;
import com.github.barteksc.pdfviewer.listener.OnLongPressListener;
import com.github.barteksc.pdfviewer.listener.OnPageChangeListener;
import com.github.barteksc.pdfviewer.listener.OnPageErrorListener;
import com.github.barteksc.pdfviewer.listener.OnPageScrollListener;
import com.github.barteksc.pdfviewer.listener.OnRenderListener;
import com.github.barteksc.pdfviewer.listener.OnTapListener;
import com.github.barteksc.pdfviewer.model.PagePart;
import com.github.barteksc.pdfviewer.scroll.ScrollHandle;
import com.github.barteksc.pdfviewer.source.AssetSource;
import com.github.barteksc.pdfviewer.source.ByteArraySource;
import com.github.barteksc.pdfviewer.source.DocumentSource;
import com.github.barteksc.pdfviewer.source.FileSource;
import com.github.barteksc.pdfviewer.source.InputStreamSource;
import com.github.barteksc.pdfviewer.source.UriSource;
import com.github.barteksc.pdfviewer.util.Constants;
import com.github.barteksc.pdfviewer.util.FitPolicy;
import com.github.barteksc.pdfviewer.util.MathUtils;
import com.github.barteksc.pdfviewer.util.SnapEdge;
import com.github.barteksc.pdfviewer.util.Util;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.PdfiumCore;
import com.shockwave.pdfium.util.Size;
import com.shockwave.pdfium.util.SizeF;
import java.io.File;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* It supports animations, zoom, cache, and swipe.
*
* To fully understand this class you must know its principles :
* - The PDF document is seen as if we always want to draw all the pages.
* - The thing is that we only draw the visible parts.
* - All parts are the same size, this is because we can't interrupt a native page rendering,
* so we need these renderings to be as fast as possible, and be able to interrupt them
* as soon as we can.
* - The parts are loaded when the current offset or the current zoom level changes
*
* Important :
* - DocumentPage = A page of the PDF document.
* - UserPage = A page as defined by the user.
* By default, they're the same. But the user can change the pages order
* using {@link #load(DocumentSource, String, int[])}. In this
* particular case, a userPage of 5 can refer to a documentPage of 17.
*/
public class PDFView extends RelativeLayout {
private static final String TAG = PDFView.class.getSimpleName();
public static final float DEFAULT_MAX_SCALE = 3.0f;
public static final float DEFAULT_MID_SCALE = 1.75f;
public static final float DEFAULT_MIN_SCALE = 1.0f;
private float minZoom = DEFAULT_MIN_SCALE;
private float midZoom = DEFAULT_MID_SCALE;
private float maxZoom = DEFAULT_MAX_SCALE;
/**
* START - scrolling in first page direction
* END - scrolling in last page direction
* NONE - not scrolling
*/
enum ScrollDir {
NONE, START, END
}
private ScrollDir scrollDir = ScrollDir.NONE;
/** Rendered parts go to the cache manager */
CacheManager cacheManager;
/** Animation manager manage all offset and zoom animation */
private AnimationManager animationManager;
/** Drag manager manage all touch events */
private DragPinchManager dragPinchManager;
PdfFile pdfFile;
/** The index of the current sequence */
private int currentPage;
/**
* If you picture all the pages side by side in their optimal width,
* and taking into account the zoom level, the current offset is the
* position of the left border of the screen in this big picture
*/
private float currentXOffset = 0;
/**
* If you picture all the pages side by side in their optimal width,
* and taking into account the zoom level, the current offset is the
* position of the left border of the screen in this big picture
*/
private float currentYOffset = 0;
/** The zoom level, always >= 1 */
private float zoom = 1f;
/** True if the PDFView has been recycled */
private boolean recycled = true;
/** Current state of the view */
private State state = State.DEFAULT;
/** Async task used during the loading phase to decode a PDF document */
private DecodingAsyncTask decodingAsyncTask;
/** The thread {@link #renderingHandler} will run on */
private HandlerThread renderingHandlerThread;
/** Handler always waiting in the background and rendering tasks */
RenderingHandler renderingHandler;
private PagesLoader pagesLoader;
Callbacks callbacks = new Callbacks();
/** Paint object for drawing */
private Paint paint;
/** Paint object for drawing debug stuff */
private Paint debugPaint;
/** Policy for fitting pages to screen */
private FitPolicy pageFitPolicy = FitPolicy.WIDTH;
private boolean fitEachPage = false;
private int defaultPage = 0;
/** True if should scroll through pages vertically instead of horizontally */
private boolean swipeVertical = true;
private boolean enableSwipe = true;
private boolean doubletapEnabled = true;
private boolean nightMode = false;
private boolean pageSnap = true;
/** Pdfium core for loading and rendering PDFs */
private PdfiumCore pdfiumCore;
private ScrollHandle scrollHandle;
private boolean isScrollHandleInit = false;
ScrollHandle getScrollHandle() {
return scrollHandle;
}
/**
* True if bitmap should use ARGB_8888 format and take more memory
* False if bitmap should be compressed by using RGB_565 format and take less memory
*/
private boolean bestQuality = false;
/**
* True if annotations should be rendered
* False otherwise
*/
private boolean annotationRendering = false;
/**
* True if the view should render during scaling
* Can not be forced on older API versions (< Build.VERSION_CODES.KITKAT) as the GestureDetector does
* not detect scrolling while scaling.
* False otherwise
*/
private boolean renderDuringScale = false;
/** Antialiasing and bitmap filtering */
private boolean enableAntialiasing = true;
private PaintFlagsDrawFilter antialiasFilter =
new PaintFlagsDrawFilter(0, Paint.ANTI_ALIAS_FLAG | Paint.FILTER_BITMAP_FLAG);
/** Spacing between pages, in px */
private int spacingPx = 0;
/** Add dynamic spacing to fit each page separately on the screen. */
private boolean autoSpacing = false;
/** Fling a single page at a time */
private boolean pageFling = true;
/** Pages numbers used when calling onDrawAllListener */
private List onDrawPagesNums = new ArrayList<>(10);
/** Holds info whether view has been added to layout and has width and height */
private boolean hasSize = false;
/** Holds last used Configurator that should be loaded when view has size */
private Configurator waitingDocumentConfigurator;
/** Construct the initial view */
public PDFView(Context context, AttributeSet set) {
super(context, set);
renderingHandlerThread = new HandlerThread("PDF renderer");
if (isInEditMode()) {
return;
}
cacheManager = new CacheManager();
animationManager = new AnimationManager(this);
dragPinchManager = new DragPinchManager(this, animationManager);
pagesLoader = new PagesLoader(this);
paint = new Paint();
debugPaint = new Paint();
debugPaint.setStyle(Style.STROKE);
pdfiumCore = new PdfiumCore(context);
setWillNotDraw(false);
}
private void load(DocumentSource docSource, String password) {
load(docSource, password, null);
}
private void load(DocumentSource docSource, String password, int[] userPages) {
if (!recycled) {
throw new IllegalStateException("Don't call load on a PDF View without recycling it first.");
}
recycled = false;
// Start decoding document
decodingAsyncTask = new DecodingAsyncTask(docSource, password, userPages, this, pdfiumCore);
decodingAsyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
/**
* Go to the given page.
*
* @param page Page index.
*/
public void jumpTo(int page, boolean withAnimation) {
if (pdfFile == null) {
return;
}
page = pdfFile.determineValidPageNumberFrom(page);
float offset = page == 0 ? 0 : -pdfFile.getPageOffset(page, zoom);
if (swipeVertical) {
if (withAnimation) {
animationManager.startYAnimation(currentYOffset, offset);
} else {
moveTo(currentXOffset, offset);
}
} else {
if (withAnimation) {
animationManager.startXAnimation(currentXOffset, offset);
} else {
moveTo(offset, currentYOffset);
}
}
showPage(page);
}
public void jumpTo(int page) {
jumpTo(page, false);
}
void showPage(int pageNb) {
if (recycled) {
return;
}
// Check the page number and makes the
// difference between UserPages and DocumentPages
pageNb = pdfFile.determineValidPageNumberFrom(pageNb);
currentPage = pageNb;
loadPages();
if (scrollHandle != null && !documentFitsView()) {
scrollHandle.setPageNum(currentPage + 1);
}
callbacks.callOnPageChange(currentPage, pdfFile.getPagesCount());
}
/**
* Get current position as ratio of document length to visible area.
* 0 means that document start is visible, 1 that document end is visible
*
* @return offset between 0 and 1
*/
public float getPositionOffset() {
float offset;
if (swipeVertical) {
offset = -currentYOffset / (pdfFile.getDocLen(zoom) - getHeight());
} else {
offset = -currentXOffset / (pdfFile.getDocLen(zoom) - getWidth());
}
return MathUtils.limit(offset, 0, 1);
}
/**
* @param progress must be between 0 and 1
* @param moveHandle whether to move scroll handle
* @see PDFView#getPositionOffset()
*/
public void setPositionOffset(float progress, boolean moveHandle) {
if (swipeVertical) {
moveTo(currentXOffset, (-pdfFile.getDocLen(zoom) + getHeight()) * progress, moveHandle);
} else {
moveTo((-pdfFile.getDocLen(zoom) + getWidth()) * progress, currentYOffset, moveHandle);
}
loadPageByOffset();
}
public void setPositionOffset(float progress) {
setPositionOffset(progress, true);
}
public void stopFling() {
animationManager.stopFling();
}
public int getPageCount() {
if (pdfFile == null) {
return 0;
}
return pdfFile.getPagesCount();
}
public void setSwipeEnabled(boolean enableSwipe) {
this.enableSwipe = enableSwipe;
}
public void setNightMode(boolean nightMode) {
this.nightMode = nightMode;
if (nightMode) {
ColorMatrix colorMatrixInverted =
new ColorMatrix(new float[]{
-1, 0, 0, 0, 255,
0, -1, 0, 0, 255,
0, 0, -1, 0, 255,
0, 0, 0, 1, 0});
ColorMatrixColorFilter filter = new ColorMatrixColorFilter(colorMatrixInverted);
paint.setColorFilter(filter);
} else {
paint.setColorFilter(null);
}
}
void enableDoubletap(boolean enableDoubletap) {
this.doubletapEnabled = enableDoubletap;
}
boolean isDoubletapEnabled() {
return doubletapEnabled;
}
void onPageError(PageRenderingException ex) {
if (!callbacks.callOnPageError(ex.getPage(), ex.getCause())) {
Log.e(TAG, "Cannot open page " + ex.getPage(), ex.getCause());
}
}
public void recycle() {
waitingDocumentConfigurator = null;
animationManager.stopAll();
dragPinchManager.disable();
// Stop tasks
if (renderingHandler != null) {
renderingHandler.stop();
renderingHandler.removeMessages(RenderingHandler.MSG_RENDER_TASK);
}
if (decodingAsyncTask != null) {
decodingAsyncTask.cancel(true);
}
// Clear caches
cacheManager.recycle();
if (scrollHandle != null && isScrollHandleInit) {
scrollHandle.destroyLayout();
}
if (pdfFile != null) {
pdfFile.dispose();
pdfFile = null;
}
renderingHandler = null;
scrollHandle = null;
isScrollHandleInit = false;
currentXOffset = currentYOffset = 0;
zoom = 1f;
recycled = true;
callbacks = new Callbacks();
state = State.DEFAULT;
}
public boolean isRecycled() {
return recycled;
}
/** Handle fling animation */
@Override
public void computeScroll() {
super.computeScroll();
if (isInEditMode()) {
return;
}
animationManager.computeFling();
}
@Override
protected void onDetachedFromWindow() {
recycle();
if (renderingHandlerThread != null) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
renderingHandlerThread.quitSafely();
} else {
renderingHandlerThread.quit();
}
renderingHandlerThread = null;
}
super.onDetachedFromWindow();
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
hasSize = true;
if (waitingDocumentConfigurator != null) {
waitingDocumentConfigurator.load();
}
if (isInEditMode() || state != State.SHOWN) {
return;
}
// calculates the position of the point which in the center of view relative to big strip
float centerPointInStripXOffset = -currentXOffset + oldw * 0.5f;
float centerPointInStripYOffset = -currentYOffset + oldh * 0.5f;
float relativeCenterPointInStripXOffset;
float relativeCenterPointInStripYOffset;
if (swipeVertical){
relativeCenterPointInStripXOffset = centerPointInStripXOffset / pdfFile.getMaxPageWidth();
relativeCenterPointInStripYOffset = centerPointInStripYOffset / pdfFile.getDocLen(zoom);
}else {
relativeCenterPointInStripXOffset = centerPointInStripXOffset / pdfFile.getDocLen(zoom);
relativeCenterPointInStripYOffset = centerPointInStripYOffset / pdfFile.getMaxPageHeight();
}
animationManager.stopAll();
pdfFile.recalculatePageSizes(new Size(w, h));
if (swipeVertical) {
currentXOffset = -relativeCenterPointInStripXOffset * pdfFile.getMaxPageWidth() + w * 0.5f;
currentYOffset = -relativeCenterPointInStripYOffset * pdfFile.getDocLen(zoom) + h * 0.5f ;
}else {
currentXOffset = -relativeCenterPointInStripXOffset * pdfFile.getDocLen(zoom) + w * 0.5f;
currentYOffset = -relativeCenterPointInStripYOffset * pdfFile.getMaxPageHeight() + h * 0.5f;
}
moveTo(currentXOffset,currentYOffset);
loadPageByOffset();
}
@Override
public boolean canScrollHorizontally(int direction) {
if (pdfFile == null) {
return true;
}
if (swipeVertical) {
if (direction < 0 && currentXOffset < 0) {
return true;
} else if (direction > 0 && currentXOffset + toCurrentScale(pdfFile.getMaxPageWidth()) > getWidth()) {
return true;
}
} else {
if (direction < 0 && currentXOffset < 0) {
return true;
} else if (direction > 0 && currentXOffset + pdfFile.getDocLen(zoom) > getWidth()) {
return true;
}
}
return false;
}
@Override
public boolean canScrollVertically(int direction) {
if (pdfFile == null) {
return true;
}
if (swipeVertical) {
if (direction < 0 && currentYOffset < 0) {
return true;
} else if (direction > 0 && currentYOffset + pdfFile.getDocLen(zoom) > getHeight()) {
return true;
}
} else {
if (direction < 0 && currentYOffset < 0) {
return true;
} else if (direction > 0 && currentYOffset + toCurrentScale(pdfFile.getMaxPageHeight()) > getHeight()) {
return true;
}
}
return false;
}
@Override
protected void onDraw(Canvas canvas) {
if (isInEditMode()) {
return;
}
// As I said in this class javadoc, we can think of this canvas as a huge
// strip on which we draw all the images. We actually only draw the rendered
// parts, of course, but we render them in the place they belong in this huge
// strip.
// That's where Canvas.translate(x, y) becomes very helpful.
// This is the situation :
// _______________________________________________
// | | |
// | the actual | The big strip |
// | canvas | |
// |_____________| |
// |_______________________________________________|
//
// If the rendered part is on the bottom right corner of the strip
// we can draw it but we won't see it because the canvas is not big enough.
// But if we call translate(-X, -Y) on the canvas just before drawing the object :
// _______________________________________________
// | _____________|
// | The big strip | |
// | | the actual |
// | | canvas |
// |_________________________________|_____________|
//
// The object will be on the canvas.
// This technique is massively used in this method, and allows
// abstraction of the screen position when rendering the parts.
// Draws background
if (enableAntialiasing) {
canvas.setDrawFilter(antialiasFilter);
}
Drawable bg = getBackground();
if (bg == null) {
canvas.drawColor(nightMode ? Color.BLACK : Color.WHITE);
} else {
bg.draw(canvas);
}
if (recycled) {
return;
}
if (state != State.SHOWN) {
return;
}
// Moves the canvas before drawing any element
float currentXOffset = this.currentXOffset;
float currentYOffset = this.currentYOffset;
canvas.translate(currentXOffset, currentYOffset);
// Draws thumbnails
for (PagePart part : cacheManager.getThumbnails()) {
drawPart(canvas, part);
}
// Draws parts
for (PagePart part : cacheManager.getPageParts()) {
drawPart(canvas, part);
if (callbacks.getOnDrawAll() != null
&& !onDrawPagesNums.contains(part.getPage())) {
onDrawPagesNums.add(part.getPage());
}
}
for (Integer page : onDrawPagesNums) {
drawWithListener(canvas, page, callbacks.getOnDrawAll());
}
onDrawPagesNums.clear();
drawWithListener(canvas, currentPage, callbacks.getOnDraw());
// Restores the canvas position
canvas.translate(-currentXOffset, -currentYOffset);
}
private void drawWithListener(Canvas canvas, int page, OnDrawListener listener) {
if (listener != null) {
float translateX, translateY;
if (swipeVertical) {
translateX = 0;
translateY = pdfFile.getPageOffset(page, zoom);
} else {
translateY = 0;
translateX = pdfFile.getPageOffset(page, zoom);
}
canvas.translate(translateX, translateY);
SizeF size = pdfFile.getPageSize(page);
listener.onLayerDrawn(canvas,
toCurrentScale(size.getWidth()),
toCurrentScale(size.getHeight()),
page);
canvas.translate(-translateX, -translateY);
}
}
/** Draw a given PagePart on the canvas */
private void drawPart(Canvas canvas, PagePart part) {
// Can seem strange, but avoid lot of calls
RectF pageRelativeBounds = part.getPageRelativeBounds();
Bitmap renderedBitmap = part.getRenderedBitmap();
if (renderedBitmap.isRecycled()) {
return;
}
// Move to the target page
float localTranslationX = 0;
float localTranslationY = 0;
SizeF size = pdfFile.getPageSize(part.getPage());
if (swipeVertical) {
localTranslationY = pdfFile.getPageOffset(part.getPage(), zoom);
float maxWidth = pdfFile.getMaxPageWidth();
localTranslationX = toCurrentScale(maxWidth - size.getWidth()) / 2;
} else {
localTranslationX = pdfFile.getPageOffset(part.getPage(), zoom);
float maxHeight = pdfFile.getMaxPageHeight();
localTranslationY = toCurrentScale(maxHeight - size.getHeight()) / 2;
}
canvas.translate(localTranslationX, localTranslationY);
Rect srcRect = new Rect(0, 0, renderedBitmap.getWidth(),
renderedBitmap.getHeight());
float offsetX = toCurrentScale(pageRelativeBounds.left * size.getWidth());
float offsetY = toCurrentScale(pageRelativeBounds.top * size.getHeight());
float width = toCurrentScale(pageRelativeBounds.width() * size.getWidth());
float height = toCurrentScale(pageRelativeBounds.height() * size.getHeight());
// If we use float values for this rectangle, there will be
// a possible gap between page parts, especially when
// the zoom level is high.
RectF dstRect = new RectF((int) offsetX, (int) offsetY,
(int) (offsetX + width),
(int) (offsetY + height));
// Check if bitmap is in the screen
float translationX = currentXOffset + localTranslationX;
float translationY = currentYOffset + localTranslationY;
if (translationX + dstRect.left >= getWidth() || translationX + dstRect.right <= 0 ||
translationY + dstRect.top >= getHeight() || translationY + dstRect.bottom <= 0) {
canvas.translate(-localTranslationX, -localTranslationY);
return;
}
canvas.drawBitmap(renderedBitmap, srcRect, dstRect, paint);
if (Constants.DEBUG_MODE) {
debugPaint.setColor(part.getPage() % 2 == 0 ? Color.RED : Color.BLUE);
canvas.drawRect(dstRect, debugPaint);
}
// Restore the canvas position
canvas.translate(-localTranslationX, -localTranslationY);
}
/**
* Load all the parts around the center of the screen,
* taking into account X and Y offsets, zoom level, and
* the current page displayed
*/
public void loadPages() {
if (pdfFile == null || renderingHandler == null) {
return;
}
// Cancel all current tasks
renderingHandler.removeMessages(RenderingHandler.MSG_RENDER_TASK);
cacheManager.makeANewSet();
pagesLoader.loadPages();
redraw();
}
/** Called when the PDF is loaded */
void loadComplete(PdfFile pdfFile) {
state = State.LOADED;
this.pdfFile = pdfFile;
if (!renderingHandlerThread.isAlive()) {
renderingHandlerThread.start();
}
renderingHandler = new RenderingHandler(renderingHandlerThread.getLooper(), this);
renderingHandler.start();
if (scrollHandle != null) {
scrollHandle.setupLayout(this);
isScrollHandleInit = true;
}
dragPinchManager.enable();
callbacks.callOnLoadComplete(pdfFile.getPagesCount());
jumpTo(defaultPage, false);
}
void loadError(Throwable t) {
state = State.ERROR;
// store reference, because callbacks will be cleared in recycle() method
OnErrorListener onErrorListener = callbacks.getOnError();
recycle();
invalidate();
if (onErrorListener != null) {
onErrorListener.onError(t);
} else {
Log.e("PDFView", "load pdf error", t);
}
}
void redraw() {
invalidate();
}
/**
* Called when a rendering task is over and
* a PagePart has been freshly created.
*
* @param part The created PagePart.
*/
public void onBitmapRendered(PagePart part) {
// when it is first rendered part
if (state == State.LOADED) {
state = State.SHOWN;
callbacks.callOnRender(pdfFile.getPagesCount());
}
if (part.isThumbnail()) {
cacheManager.cacheThumbnail(part);
} else {
cacheManager.cachePart(part);
}
redraw();
}
public void moveTo(float offsetX, float offsetY) {
moveTo(offsetX, offsetY, true);
}
/**
* Move to the given X and Y offsets, but check them ahead of time
* to be sure not to go outside the the big strip.
*
* @param offsetX The big strip X offset to use as the left border of the screen.
* @param offsetY The big strip Y offset to use as the right border of the screen.
* @param moveHandle whether to move scroll handle or not
*/
public void moveTo(float offsetX, float offsetY, boolean moveHandle) {
if (swipeVertical) {
// Check X offset
float scaledPageWidth = toCurrentScale(pdfFile.getMaxPageWidth());
if (scaledPageWidth < getWidth()) {
offsetX = getWidth() / 2 - scaledPageWidth / 2;
} else {
if (offsetX > 0) {
offsetX = 0;
} else if (offsetX + scaledPageWidth < getWidth()) {
offsetX = getWidth() - scaledPageWidth;
}
}
// Check Y offset
float contentHeight = pdfFile.getDocLen(zoom);
if (contentHeight < getHeight()) { // whole document height visible on screen
offsetY = (getHeight() - contentHeight) / 2;
} else {
if (offsetY > 0) { // top visible
offsetY = 0;
} else if (offsetY + contentHeight < getHeight()) { // bottom visible
offsetY = -contentHeight + getHeight();
}
}
if (offsetY < currentYOffset) {
scrollDir = ScrollDir.END;
} else if (offsetY > currentYOffset) {
scrollDir = ScrollDir.START;
} else {
scrollDir = ScrollDir.NONE;
}
} else {
// Check Y offset
float scaledPageHeight = toCurrentScale(pdfFile.getMaxPageHeight());
if (scaledPageHeight < getHeight()) {
offsetY = getHeight() / 2 - scaledPageHeight / 2;
} else {
if (offsetY > 0) {
offsetY = 0;
} else if (offsetY + scaledPageHeight < getHeight()) {
offsetY = getHeight() - scaledPageHeight;
}
}
// Check X offset
float contentWidth = pdfFile.getDocLen(zoom);
if (contentWidth < getWidth()) { // whole document width visible on screen
offsetX = (getWidth() - contentWidth) / 2;
} else {
if (offsetX > 0) { // left visible
offsetX = 0;
} else if (offsetX + contentWidth < getWidth()) { // right visible
offsetX = -contentWidth + getWidth();
}
}
if (offsetX < currentXOffset) {
scrollDir = ScrollDir.END;
} else if (offsetX > currentXOffset) {
scrollDir = ScrollDir.START;
} else {
scrollDir = ScrollDir.NONE;
}
}
currentXOffset = offsetX;
currentYOffset = offsetY;
float positionOffset = getPositionOffset();
if (moveHandle && scrollHandle != null && !documentFitsView()) {
scrollHandle.setScroll(positionOffset);
}
callbacks.callOnPageScroll(getCurrentPage(), positionOffset);
redraw();
}
void loadPageByOffset() {
if (0 == pdfFile.getPagesCount()) {
return;
}
float offset, screenCenter;
if (swipeVertical) {
offset = currentYOffset;
screenCenter = ((float) getHeight()) / 2;
} else {
offset = currentXOffset;
screenCenter = ((float) getWidth()) / 2;
}
int page = pdfFile.getPageAtOffset(-(offset - screenCenter), zoom);
if (page >= 0 && page <= pdfFile.getPagesCount() - 1 && page != getCurrentPage()) {
showPage(page);
} else {
loadPages();
}
}
/**
* Animate to the nearest snapping position for the current SnapPolicy
*/
public void performPageSnap() {
if (!pageSnap || pdfFile == null || pdfFile.getPagesCount() == 0) {
return;
}
int centerPage = findFocusPage(currentXOffset, currentYOffset);
SnapEdge edge = findSnapEdge(centerPage);
if (edge == SnapEdge.NONE) {
return;
}
float offset = snapOffsetForPage(centerPage, edge);
if (swipeVertical) {
animationManager.startYAnimation(currentYOffset, -offset);
} else {
animationManager.startXAnimation(currentXOffset, -offset);
}
}
/**
* Find the edge to snap to when showing the specified page
*/
SnapEdge findSnapEdge(int page) {
if (!pageSnap || page < 0) {
return SnapEdge.NONE;
}
float currentOffset = swipeVertical ? currentYOffset : currentXOffset;
float offset = -pdfFile.getPageOffset(page, zoom);
int length = swipeVertical ? getHeight() : getWidth();
float pageLength = pdfFile.getPageLength(page, zoom);
if (length >= pageLength) {
return SnapEdge.CENTER;
} else if (currentOffset >= offset) {
return SnapEdge.START;
} else if (offset - pageLength > currentOffset - length) {
return SnapEdge.END;
} else {
return SnapEdge.NONE;
}
}
/**
* Get the offset to move to in order to snap to the page
*/
float snapOffsetForPage(int pageIndex, SnapEdge edge) {
float offset = pdfFile.getPageOffset(pageIndex, zoom);
float length = swipeVertical ? getHeight() : getWidth();
float pageLength = pdfFile.getPageLength(pageIndex, zoom);
if (edge == SnapEdge.CENTER) {
offset = offset - length / 2f + pageLength / 2f;
} else if (edge == SnapEdge.END) {
offset = offset - length + pageLength;
}
return offset;
}
int findFocusPage(float xOffset, float yOffset) {
float currOffset = swipeVertical ? yOffset : xOffset;
float length = swipeVertical ? getHeight() : getWidth();
// make sure first and last page can be found
if (currOffset > -1) {
return 0;
} else if (currOffset < -pdfFile.getDocLen(zoom) + length + 1) {
return pdfFile.getPagesCount() - 1;
}
// else find page in center
float center = currOffset - length / 2f;
return pdfFile.getPageAtOffset(-center, zoom);
}
/**
* @return true if single page fills the entire screen in the scrolling direction
*/
public boolean pageFillsScreen() {
float start = -pdfFile.getPageOffset(currentPage, zoom);
float end = start - pdfFile.getPageLength(currentPage, zoom);
if (isSwipeVertical()) {
return start > currentYOffset && end < currentYOffset - getHeight();
} else {
return start > currentXOffset && end < currentXOffset - getWidth();
}
}
/**
* Move relatively to the current position.
*
* @param dx The X difference you want to apply.
* @param dy The Y difference you want to apply.
* @see #moveTo(float, float)
*/
public void moveRelativeTo(float dx, float dy) {
moveTo(currentXOffset + dx, currentYOffset + dy);
}
/**
* Change the zoom level
*/
public void zoomTo(float zoom) {
this.zoom = zoom;
}
/**
* Change the zoom level, relatively to a pivot point.
* It will call moveTo() to make sure the given point stays
* in the middle of the screen.
*
* @param zoom The zoom level.
* @param pivot The point on the screen that should stays.
*/
public void zoomCenteredTo(float zoom, PointF pivot) {
float dzoom = zoom / this.zoom;
zoomTo(zoom);
float baseX = currentXOffset * dzoom;
float baseY = currentYOffset * dzoom;
baseX += (pivot.x - pivot.x * dzoom);
baseY += (pivot.y - pivot.y * dzoom);
moveTo(baseX, baseY);
}
/**
* @see #zoomCenteredTo(float, PointF)
*/
public void zoomCenteredRelativeTo(float dzoom, PointF pivot) {
zoomCenteredTo(zoom * dzoom, pivot);
}
/**
* Checks if whole document can be displayed on screen, doesn't include zoom
*
* @return true if whole document can displayed at once, false otherwise
*/
public boolean documentFitsView() {
float len = pdfFile.getDocLen(1);
if (swipeVertical) {
return len < getHeight();
} else {
return len < getWidth();
}
}
public void fitToWidth(int page) {
if (state != State.SHOWN) {
Log.e(TAG, "Cannot fit, document not rendered yet");
return;
}
zoomTo(getWidth() / pdfFile.getPageSize(page).getWidth());
jumpTo(page);
}
public SizeF getPageSize(int pageIndex) {
if (pdfFile == null) {
return new SizeF(0, 0);
}
return pdfFile.getPageSize(pageIndex);
}
public int getCurrentPage() {
return currentPage;
}
public float getCurrentXOffset() {
return currentXOffset;
}
public float getCurrentYOffset() {
return currentYOffset;
}
public float toRealScale(float size) {
return size / zoom;
}
public float toCurrentScale(float size) {
return size * zoom;
}
public float getZoom() {
return zoom;
}
public boolean isZooming() {
return zoom != minZoom;
}
private void setDefaultPage(int defaultPage) {
this.defaultPage = defaultPage;
}
public void resetZoom() {
zoomTo(minZoom);
}
public void resetZoomWithAnimation() {
zoomWithAnimation(minZoom);
}
public void zoomWithAnimation(float centerX, float centerY, float scale) {
animationManager.startZoomAnimation(centerX, centerY, zoom, scale);
}
public void zoomWithAnimation(float scale) {
animationManager.startZoomAnimation(getWidth() / 2, getHeight() / 2, zoom, scale);
}
private void setScrollHandle(ScrollHandle scrollHandle) {
this.scrollHandle = scrollHandle;
}
/**
* Get page number at given offset
*
* @param positionOffset scroll offset between 0 and 1
* @return page number at given offset, starting from 0
*/
public int getPageAtPositionOffset(float positionOffset) {
return pdfFile.getPageAtOffset(pdfFile.getDocLen(zoom) * positionOffset, zoom);
}
public float getMinZoom() {
return minZoom;
}
public void setMinZoom(float minZoom) {
this.minZoom = minZoom;
}
public float getMidZoom() {
return midZoom;
}
public void setMidZoom(float midZoom) {
this.midZoom = midZoom;
}
public float getMaxZoom() {
return maxZoom;
}
public void setMaxZoom(float maxZoom) {
this.maxZoom = maxZoom;
}
public void useBestQuality(boolean bestQuality) {
this.bestQuality = bestQuality;
}
public boolean isBestQuality() {
return bestQuality;
}
public boolean isSwipeVertical() {
return swipeVertical;
}
public boolean isSwipeEnabled() {
return enableSwipe;
}
private void setSwipeVertical(boolean swipeVertical) {
this.swipeVertical = swipeVertical;
}
public void enableAnnotationRendering(boolean annotationRendering) {
this.annotationRendering = annotationRendering;
}
public boolean isAnnotationRendering() {
return annotationRendering;
}
public void enableRenderDuringScale(boolean renderDuringScale) {
this.renderDuringScale = renderDuringScale;
}
public boolean isAntialiasing() {
return enableAntialiasing;
}
public void enableAntialiasing(boolean enableAntialiasing) {
this.enableAntialiasing = enableAntialiasing;
}
public int getSpacingPx() {
return spacingPx;
}
public boolean isAutoSpacingEnabled() {
return autoSpacing;
}
public void setPageFling(boolean pageFling) {
this.pageFling = pageFling;
}
public boolean isPageFlingEnabled() {
return pageFling;
}
private void setSpacing(int spacingDp) {
this.spacingPx = Util.getDP(getContext(), spacingDp);
}
private void setAutoSpacing(boolean autoSpacing) {
this.autoSpacing = autoSpacing;
}
private void setPageFitPolicy(FitPolicy pageFitPolicy) {
this.pageFitPolicy = pageFitPolicy;
}
public FitPolicy getPageFitPolicy() {
return pageFitPolicy;
}
private void setFitEachPage(boolean fitEachPage) {
this.fitEachPage = fitEachPage;
}
public boolean isFitEachPage() {
return fitEachPage;
}
public boolean isPageSnap() {
return pageSnap;
}
public void setPageSnap(boolean pageSnap) {
this.pageSnap = pageSnap;
}
public boolean doRenderDuringScale() {
return renderDuringScale;
}
/** Returns null if document is not loaded */
public PdfDocument.Meta getDocumentMeta() {
if (pdfFile == null) {
return null;
}
return pdfFile.getMetaData();
}
/** Will be empty until document is loaded */
public List getTableOfContents() {
if (pdfFile == null) {
return Collections.emptyList();
}
return pdfFile.getBookmarks();
}
/** Will be empty until document is loaded */
public List getLinks(int page) {
if (pdfFile == null) {
return Collections.emptyList();
}
return pdfFile.getPageLinks(page);
}
/** Use an asset file as the pdf source */
public Configurator fromAsset(String assetName) {
return new Configurator(new AssetSource(assetName));
}
/** Use a file as the pdf source */
public Configurator fromFile(File file) {
return new Configurator(new FileSource(file));
}
/** Use URI as the pdf source, for use with content providers */
public Configurator fromUri(Uri uri) {
return new Configurator(new UriSource(uri));
}
/** Use bytearray as the pdf source, documents is not saved */
public Configurator fromBytes(byte[] bytes) {
return new Configurator(new ByteArraySource(bytes));
}
/** Use stream as the pdf source. Stream will be written to bytearray, because native code does not support Java Streams */
public Configurator fromStream(InputStream stream) {
return new Configurator(new InputStreamSource(stream));
}
/** Use custom source as pdf source */
public Configurator fromSource(DocumentSource docSource) {
return new Configurator(docSource);
}
private enum State {DEFAULT, LOADED, SHOWN, ERROR}
public class Configurator {
private final DocumentSource documentSource;
private int[] pageNumbers = null;
private boolean enableSwipe = true;
private boolean enableDoubletap = true;
private OnDrawListener onDrawListener;
private OnDrawListener onDrawAllListener;
private OnLoadCompleteListener onLoadCompleteListener;
private OnErrorListener onErrorListener;
private OnPageChangeListener onPageChangeListener;
private OnPageScrollListener onPageScrollListener;
private OnRenderListener onRenderListener;
private OnTapListener onTapListener;
private OnLongPressListener onLongPressListener;
private OnPageErrorListener onPageErrorListener;
private LinkHandler linkHandler = new DefaultLinkHandler(PDFView.this);
private int defaultPage = 0;
private boolean swipeHorizontal = false;
private boolean annotationRendering = false;
private String password = null;
private ScrollHandle scrollHandle = null;
private boolean antialiasing = true;
private int spacing = 0;
private boolean autoSpacing = false;
private FitPolicy pageFitPolicy = FitPolicy.WIDTH;
private boolean fitEachPage = false;
private boolean pageFling = false;
private boolean pageSnap = false;
private boolean nightMode = false;
private Configurator(DocumentSource documentSource) {
this.documentSource = documentSource;
}
public Configurator pages(int... pageNumbers) {
this.pageNumbers = pageNumbers;
return this;
}
public Configurator enableSwipe(boolean enableSwipe) {
this.enableSwipe = enableSwipe;
return this;
}
public Configurator enableDoubletap(boolean enableDoubletap) {
this.enableDoubletap = enableDoubletap;
return this;
}
public Configurator enableAnnotationRendering(boolean annotationRendering) {
this.annotationRendering = annotationRendering;
return this;
}
public Configurator onDraw(OnDrawListener onDrawListener) {
this.onDrawListener = onDrawListener;
return this;
}
public Configurator onDrawAll(OnDrawListener onDrawAllListener) {
this.onDrawAllListener = onDrawAllListener;
return this;
}
public Configurator onLoad(OnLoadCompleteListener onLoadCompleteListener) {
this.onLoadCompleteListener = onLoadCompleteListener;
return this;
}
public Configurator onPageScroll(OnPageScrollListener onPageScrollListener) {
this.onPageScrollListener = onPageScrollListener;
return this;
}
public Configurator onError(OnErrorListener onErrorListener) {
this.onErrorListener = onErrorListener;
return this;
}
public Configurator onPageError(OnPageErrorListener onPageErrorListener) {
this.onPageErrorListener = onPageErrorListener;
return this;
}
public Configurator onPageChange(OnPageChangeListener onPageChangeListener) {
this.onPageChangeListener = onPageChangeListener;
return this;
}
public Configurator onRender(OnRenderListener onRenderListener) {
this.onRenderListener = onRenderListener;
return this;
}
public Configurator onTap(OnTapListener onTapListener) {
this.onTapListener = onTapListener;
return this;
}
public Configurator onLongPress(OnLongPressListener onLongPressListener) {
this.onLongPressListener = onLongPressListener;
return this;
}
public Configurator linkHandler(LinkHandler linkHandler) {
this.linkHandler = linkHandler;
return this;
}
public Configurator defaultPage(int defaultPage) {
this.defaultPage = defaultPage;
return this;
}
public Configurator swipeHorizontal(boolean swipeHorizontal) {
this.swipeHorizontal = swipeHorizontal;
return this;
}
public Configurator password(String password) {
this.password = password;
return this;
}
public Configurator scrollHandle(ScrollHandle scrollHandle) {
this.scrollHandle = scrollHandle;
return this;
}
public Configurator enableAntialiasing(boolean antialiasing) {
this.antialiasing = antialiasing;
return this;
}
public Configurator spacing(int spacing) {
this.spacing = spacing;
return this;
}
public Configurator autoSpacing(boolean autoSpacing) {
this.autoSpacing = autoSpacing;
return this;
}
public Configurator pageFitPolicy(FitPolicy pageFitPolicy) {
this.pageFitPolicy = pageFitPolicy;
return this;
}
public Configurator fitEachPage(boolean fitEachPage) {
this.fitEachPage = fitEachPage;
return this;
}
public Configurator pageSnap(boolean pageSnap) {
this.pageSnap = pageSnap;
return this;
}
public Configurator pageFling(boolean pageFling) {
this.pageFling = pageFling;
return this;
}
public Configurator nightMode(boolean nightMode) {
this.nightMode = nightMode;
return this;
}
public Configurator disableLongpress() {
PDFView.this.dragPinchManager.disableLongpress();
return this;
}
public void load() {
if (!hasSize) {
waitingDocumentConfigurator = this;
return;
}
PDFView.this.recycle();
PDFView.this.callbacks.setOnLoadComplete(onLoadCompleteListener);
PDFView.this.callbacks.setOnError(onErrorListener);
PDFView.this.callbacks.setOnDraw(onDrawListener);
PDFView.this.callbacks.setOnDrawAll(onDrawAllListener);
PDFView.this.callbacks.setOnPageChange(onPageChangeListener);
PDFView.this.callbacks.setOnPageScroll(onPageScrollListener);
PDFView.this.callbacks.setOnRender(onRenderListener);
PDFView.this.callbacks.setOnTap(onTapListener);
PDFView.this.callbacks.setOnLongPress(onLongPressListener);
PDFView.this.callbacks.setOnPageError(onPageErrorListener);
PDFView.this.callbacks.setLinkHandler(linkHandler);
PDFView.this.setSwipeEnabled(enableSwipe);
PDFView.this.setNightMode(nightMode);
PDFView.this.enableDoubletap(enableDoubletap);
PDFView.this.setDefaultPage(defaultPage);
PDFView.this.setSwipeVertical(!swipeHorizontal);
PDFView.this.enableAnnotationRendering(annotationRendering);
PDFView.this.setScrollHandle(scrollHandle);
PDFView.this.enableAntialiasing(antialiasing);
PDFView.this.setSpacing(spacing);
PDFView.this.setAutoSpacing(autoSpacing);
PDFView.this.setPageFitPolicy(pageFitPolicy);
PDFView.this.setFitEachPage(fitEachPage);
PDFView.this.setPageSnap(pageSnap);
PDFView.this.setPageFling(pageFling);
if (pageNumbers != null) {
PDFView.this.load(documentSource, password, pageNumbers);
} else {
PDFView.this.load(documentSource, password);
}
}
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/PagesLoader.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer;
import android.graphics.RectF;
import com.github.barteksc.pdfviewer.util.Constants;
import com.github.barteksc.pdfviewer.util.MathUtils;
import com.github.barteksc.pdfviewer.util.Util;
import com.shockwave.pdfium.util.SizeF;
import java.util.LinkedList;
import java.util.List;
import static com.github.barteksc.pdfviewer.util.Constants.Cache.CACHE_SIZE;
import static com.github.barteksc.pdfviewer.util.Constants.PRELOAD_OFFSET;
class PagesLoader {
private PDFView pdfView;
private int cacheOrder;
private float xOffset;
private float yOffset;
private float pageRelativePartWidth;
private float pageRelativePartHeight;
private float partRenderWidth;
private float partRenderHeight;
private final RectF thumbnailRect = new RectF(0, 0, 1, 1);
private final int preloadOffset;
private class Holder {
int row;
int col;
@Override
public String toString() {
return "Holder{" +
"row=" + row +
", col=" + col +
'}';
}
}
private class RenderRange {
int page;
GridSize gridSize;
Holder leftTop;
Holder rightBottom;
RenderRange() {
this.page = 0;
this.gridSize = new GridSize();
this.leftTop = new Holder();
this.rightBottom = new Holder();
}
@Override
public String toString() {
return "RenderRange{" +
"page=" + page +
", gridSize=" + gridSize +
", leftTop=" + leftTop +
", rightBottom=" + rightBottom +
'}';
}
}
private class GridSize {
int rows;
int cols;
@Override
public String toString() {
return "GridSize{" +
"rows=" + rows +
", cols=" + cols +
'}';
}
}
PagesLoader(PDFView pdfView) {
this.pdfView = pdfView;
this.preloadOffset = Util.getDP(pdfView.getContext(), PRELOAD_OFFSET);
}
private void getPageColsRows(GridSize grid, int pageIndex) {
SizeF size = pdfView.pdfFile.getPageSize(pageIndex);
float ratioX = 1f / size.getWidth();
float ratioY = 1f / size.getHeight();
final float partHeight = (Constants.PART_SIZE * ratioY) / pdfView.getZoom();
final float partWidth = (Constants.PART_SIZE * ratioX) / pdfView.getZoom();
grid.rows = MathUtils.ceil(1f / partHeight);
grid.cols = MathUtils.ceil(1f / partWidth);
}
private void calculatePartSize(GridSize grid) {
pageRelativePartWidth = 1f / (float) grid.cols;
pageRelativePartHeight = 1f / (float) grid.rows;
partRenderWidth = Constants.PART_SIZE / pageRelativePartWidth;
partRenderHeight = Constants.PART_SIZE / pageRelativePartHeight;
}
/**
* calculate the render range of each page
*/
private List getRenderRangeList(float firstXOffset, float firstYOffset, float lastXOffset, float lastYOffset) {
float fixedFirstXOffset = -MathUtils.max(firstXOffset, 0);
float fixedFirstYOffset = -MathUtils.max(firstYOffset, 0);
float fixedLastXOffset = -MathUtils.max(lastXOffset, 0);
float fixedLastYOffset = -MathUtils.max(lastYOffset, 0);
float offsetFirst = pdfView.isSwipeVertical() ? fixedFirstYOffset : fixedFirstXOffset;
float offsetLast = pdfView.isSwipeVertical() ? fixedLastYOffset : fixedLastXOffset;
int firstPage = pdfView.pdfFile.getPageAtOffset(offsetFirst, pdfView.getZoom());
int lastPage = pdfView.pdfFile.getPageAtOffset(offsetLast, pdfView.getZoom());
int pageCount = lastPage - firstPage + 1;
List renderRanges = new LinkedList<>();
for (int page = firstPage; page <= lastPage; page++) {
RenderRange range = new RenderRange();
range.page = page;
float pageFirstXOffset, pageFirstYOffset, pageLastXOffset, pageLastYOffset;
if (page == firstPage) {
pageFirstXOffset = fixedFirstXOffset;
pageFirstYOffset = fixedFirstYOffset;
if (pageCount == 1) {
pageLastXOffset = fixedLastXOffset;
pageLastYOffset = fixedLastYOffset;
} else {
float pageOffset = pdfView.pdfFile.getPageOffset(page, pdfView.getZoom());
SizeF pageSize = pdfView.pdfFile.getScaledPageSize(page, pdfView.getZoom());
if (pdfView.isSwipeVertical()) {
pageLastXOffset = fixedLastXOffset;
pageLastYOffset = pageOffset + pageSize.getHeight();
} else {
pageLastYOffset = fixedLastYOffset;
pageLastXOffset = pageOffset + pageSize.getWidth();
}
}
} else if (page == lastPage) {
float pageOffset = pdfView.pdfFile.getPageOffset(page, pdfView.getZoom());
if (pdfView.isSwipeVertical()) {
pageFirstXOffset = fixedFirstXOffset;
pageFirstYOffset = pageOffset;
} else {
pageFirstYOffset = fixedFirstYOffset;
pageFirstXOffset = pageOffset;
}
pageLastXOffset = fixedLastXOffset;
pageLastYOffset = fixedLastYOffset;
} else {
float pageOffset = pdfView.pdfFile.getPageOffset(page, pdfView.getZoom());
SizeF pageSize = pdfView.pdfFile.getScaledPageSize(page, pdfView.getZoom());
if (pdfView.isSwipeVertical()) {
pageFirstXOffset = fixedFirstXOffset;
pageFirstYOffset = pageOffset;
pageLastXOffset = fixedLastXOffset;
pageLastYOffset = pageOffset + pageSize.getHeight();
} else {
pageFirstXOffset = pageOffset;
pageFirstYOffset = fixedFirstYOffset;
pageLastXOffset = pageOffset + pageSize.getWidth();
pageLastYOffset = fixedLastYOffset;
}
}
getPageColsRows(range.gridSize, range.page); // get the page's grid size that rows and cols
SizeF scaledPageSize = pdfView.pdfFile.getScaledPageSize(range.page, pdfView.getZoom());
float rowHeight = scaledPageSize.getHeight() / range.gridSize.rows;
float colWidth = scaledPageSize.getWidth() / range.gridSize.cols;
// get the page offset int the whole file
// ---------------------------------------
// | | | |
// |<--offset-->| (page) |<--offset-->|
// | | | |
// | | | |
// ---------------------------------------
float secondaryOffset = pdfView.pdfFile.getSecondaryPageOffset(page, pdfView.getZoom());
// calculate the row,col of the point in the leftTop and rightBottom
if (pdfView.isSwipeVertical()) {
range.leftTop.row = MathUtils.floor(Math.abs(pageFirstYOffset - pdfView.pdfFile.getPageOffset(range.page, pdfView.getZoom())) / rowHeight);
range.leftTop.col = MathUtils.floor(MathUtils.min(pageFirstXOffset - secondaryOffset, 0) / colWidth);
range.rightBottom.row = MathUtils.ceil(Math.abs(pageLastYOffset - pdfView.pdfFile.getPageOffset(range.page, pdfView.getZoom())) / rowHeight);
range.rightBottom.col = MathUtils.floor(MathUtils.min(pageLastXOffset - secondaryOffset, 0) / colWidth);
} else {
range.leftTop.col = MathUtils.floor(Math.abs(pageFirstXOffset - pdfView.pdfFile.getPageOffset(range.page, pdfView.getZoom())) / colWidth);
range.leftTop.row = MathUtils.floor(MathUtils.min(pageFirstYOffset - secondaryOffset, 0) / rowHeight);
range.rightBottom.col = MathUtils.floor(Math.abs(pageLastXOffset - pdfView.pdfFile.getPageOffset(range.page, pdfView.getZoom())) / colWidth);
range.rightBottom.row = MathUtils.floor(MathUtils.min(pageLastYOffset - secondaryOffset, 0) / rowHeight);
}
renderRanges.add(range);
}
return renderRanges;
}
private void loadVisible() {
int parts = 0;
float scaledPreloadOffset = preloadOffset;
float firstXOffset = -xOffset + scaledPreloadOffset;
float lastXOffset = -xOffset - pdfView.getWidth() - scaledPreloadOffset;
float firstYOffset = -yOffset + scaledPreloadOffset;
float lastYOffset = -yOffset - pdfView.getHeight() - scaledPreloadOffset;
List rangeList = getRenderRangeList(firstXOffset, firstYOffset, lastXOffset, lastYOffset);
for (RenderRange range : rangeList) {
loadThumbnail(range.page);
}
for (RenderRange range : rangeList) {
calculatePartSize(range.gridSize);
parts += loadPage(range.page, range.leftTop.row, range.rightBottom.row, range.leftTop.col, range.rightBottom.col, CACHE_SIZE - parts);
if (parts >= CACHE_SIZE) {
break;
}
}
}
private int loadPage(int page, int firstRow, int lastRow, int firstCol, int lastCol,
int nbOfPartsLoadable) {
int loaded = 0;
for (int row = firstRow; row <= lastRow; row++) {
for (int col = firstCol; col <= lastCol; col++) {
if (loadCell(page, row, col, pageRelativePartWidth, pageRelativePartHeight)) {
loaded++;
}
if (loaded >= nbOfPartsLoadable) {
return loaded;
}
}
}
return loaded;
}
private boolean loadCell(int page, int row, int col, float pageRelativePartWidth, float pageRelativePartHeight) {
float relX = pageRelativePartWidth * col;
float relY = pageRelativePartHeight * row;
float relWidth = pageRelativePartWidth;
float relHeight = pageRelativePartHeight;
float renderWidth = partRenderWidth;
float renderHeight = partRenderHeight;
if (relX + relWidth > 1) {
relWidth = 1 - relX;
}
if (relY + relHeight > 1) {
relHeight = 1 - relY;
}
renderWidth *= relWidth;
renderHeight *= relHeight;
RectF pageRelativeBounds = new RectF(relX, relY, relX + relWidth, relY + relHeight);
if (renderWidth > 0 && renderHeight > 0) {
if (!pdfView.cacheManager.upPartIfContained(page, pageRelativeBounds, cacheOrder)) {
pdfView.renderingHandler.addRenderingTask(page, renderWidth, renderHeight,
pageRelativeBounds, false, cacheOrder, pdfView.isBestQuality(),
pdfView.isAnnotationRendering());
}
cacheOrder++;
return true;
}
return false;
}
private void loadThumbnail(int page) {
SizeF pageSize = pdfView.pdfFile.getPageSize(page);
float thumbnailWidth = pageSize.getWidth() * Constants.THUMBNAIL_RATIO;
float thumbnailHeight = pageSize.getHeight() * Constants.THUMBNAIL_RATIO;
if (!pdfView.cacheManager.containsThumbnail(page, thumbnailRect)) {
pdfView.renderingHandler.addRenderingTask(page,
thumbnailWidth, thumbnailHeight, thumbnailRect,
true, 0, pdfView.isBestQuality(), pdfView.isAnnotationRendering());
}
}
void loadPages() {
cacheOrder = 1;
xOffset = -MathUtils.max(pdfView.getCurrentXOffset(), 0);
yOffset = -MathUtils.max(pdfView.getCurrentYOffset(), 0);
loadVisible();
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/PdfFile.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.graphics.RectF;
import android.util.SparseBooleanArray;
import com.github.barteksc.pdfviewer.exception.PageRenderingException;
import com.github.barteksc.pdfviewer.util.FitPolicy;
import com.github.barteksc.pdfviewer.util.PageSizeCalculator;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.PdfiumCore;
import com.shockwave.pdfium.util.Size;
import com.shockwave.pdfium.util.SizeF;
import java.util.ArrayList;
import java.util.List;
class PdfFile {
private static final Object lock = new Object();
private PdfDocument pdfDocument;
private PdfiumCore pdfiumCore;
private int pagesCount = 0;
/** Original page sizes */
private List originalPageSizes = new ArrayList<>();
/** Scaled page sizes */
private List pageSizes = new ArrayList<>();
/** Opened pages with indicator whether opening was successful */
private SparseBooleanArray openedPages = new SparseBooleanArray();
/** Page with maximum width */
private Size originalMaxWidthPageSize = new Size(0, 0);
/** Page with maximum height */
private Size originalMaxHeightPageSize = new Size(0, 0);
/** Scaled page with maximum height */
private SizeF maxHeightPageSize = new SizeF(0, 0);
/** Scaled page with maximum width */
private SizeF maxWidthPageSize = new SizeF(0, 0);
/** True if scrolling is vertical, else it's horizontal */
private boolean isVertical;
/** Fixed spacing between pages in pixels */
private int spacingPx;
/** Calculate spacing automatically so each page fits on it's own in the center of the view */
private boolean autoSpacing;
/** Calculated offsets for pages */
private List pageOffsets = new ArrayList<>();
/** Calculated auto spacing for pages */
private List pageSpacing = new ArrayList<>();
/** Calculated document length (width or height, depending on swipe mode) */
private float documentLength = 0;
private final FitPolicy pageFitPolicy;
/**
* True if every page should fit separately according to the FitPolicy,
* else the largest page fits and other pages scale relatively
*/
private final boolean fitEachPage;
/**
* The pages the user want to display in order
* (ex: 0, 2, 2, 8, 8, 1, 1, 1)
*/
private int[] originalUserPages;
PdfFile(PdfiumCore pdfiumCore, PdfDocument pdfDocument, FitPolicy pageFitPolicy, Size viewSize, int[] originalUserPages,
boolean isVertical, int spacing, boolean autoSpacing, boolean fitEachPage) {
this.pdfiumCore = pdfiumCore;
this.pdfDocument = pdfDocument;
this.pageFitPolicy = pageFitPolicy;
this.originalUserPages = originalUserPages;
this.isVertical = isVertical;
this.spacingPx = spacing;
this.autoSpacing = autoSpacing;
this.fitEachPage = fitEachPage;
setup(viewSize);
}
private void setup(Size viewSize) {
if (originalUserPages != null) {
pagesCount = originalUserPages.length;
} else {
pagesCount = pdfiumCore.getPageCount(pdfDocument);
}
for (int i = 0; i < pagesCount; i++) {
Size pageSize = pdfiumCore.getPageSize(pdfDocument, documentPage(i));
if (pageSize.getWidth() > originalMaxWidthPageSize.getWidth()) {
originalMaxWidthPageSize = pageSize;
}
if (pageSize.getHeight() > originalMaxHeightPageSize.getHeight()) {
originalMaxHeightPageSize = pageSize;
}
originalPageSizes.add(pageSize);
}
recalculatePageSizes(viewSize);
}
/**
* Call after view size change to recalculate page sizes, offsets and document length
*
* @param viewSize new size of changed view
*/
public void recalculatePageSizes(Size viewSize) {
pageSizes.clear();
PageSizeCalculator calculator = new PageSizeCalculator(pageFitPolicy, originalMaxWidthPageSize,
originalMaxHeightPageSize, viewSize, fitEachPage);
maxWidthPageSize = calculator.getOptimalMaxWidthPageSize();
maxHeightPageSize = calculator.getOptimalMaxHeightPageSize();
for (Size size : originalPageSizes) {
pageSizes.add(calculator.calculate(size));
}
if (autoSpacing) {
prepareAutoSpacing(viewSize);
}
prepareDocLen();
preparePagesOffset();
}
public int getPagesCount() {
return pagesCount;
}
public SizeF getPageSize(int pageIndex) {
int docPage = documentPage(pageIndex);
if (docPage < 0) {
return new SizeF(0, 0);
}
return pageSizes.get(pageIndex);
}
public SizeF getScaledPageSize(int pageIndex, float zoom) {
SizeF size = getPageSize(pageIndex);
return new SizeF(size.getWidth() * zoom, size.getHeight() * zoom);
}
/**
* get page size with biggest dimension (width in vertical mode and height in horizontal mode)
*
* @return size of page
*/
public SizeF getMaxPageSize() {
return isVertical ? maxWidthPageSize : maxHeightPageSize;
}
public float getMaxPageWidth() {
return getMaxPageSize().getWidth();
}
public float getMaxPageHeight() {
return getMaxPageSize().getHeight();
}
private void prepareAutoSpacing(Size viewSize) {
pageSpacing.clear();
for (int i = 0; i < getPagesCount(); i++) {
SizeF pageSize = pageSizes.get(i);
float spacing = Math.max(0, isVertical ? viewSize.getHeight() - pageSize.getHeight() :
viewSize.getWidth() - pageSize.getWidth());
if (i < getPagesCount() - 1) {
spacing += spacingPx;
}
pageSpacing.add(spacing);
}
}
private void prepareDocLen() {
float length = 0;
for (int i = 0; i < getPagesCount(); i++) {
SizeF pageSize = pageSizes.get(i);
length += isVertical ? pageSize.getHeight() : pageSize.getWidth();
if (autoSpacing) {
length += pageSpacing.get(i);
} else if (i < getPagesCount() - 1) {
length += spacingPx;
}
}
documentLength = length;
}
private void preparePagesOffset() {
pageOffsets.clear();
float offset = 0;
for (int i = 0; i < getPagesCount(); i++) {
SizeF pageSize = pageSizes.get(i);
float size = isVertical ? pageSize.getHeight() : pageSize.getWidth();
if (autoSpacing) {
offset += pageSpacing.get(i) / 2f;
if (i == 0) {
offset -= spacingPx / 2f;
} else if (i == getPagesCount() - 1) {
offset += spacingPx / 2f;
}
pageOffsets.add(offset);
offset += size + pageSpacing.get(i) / 2f;
} else {
pageOffsets.add(offset);
offset += size + spacingPx;
}
}
}
public float getDocLen(float zoom) {
return documentLength * zoom;
}
/**
* Get the page's height if swiping vertical, or width if swiping horizontal.
*/
public float getPageLength(int pageIndex, float zoom) {
SizeF size = getPageSize(pageIndex);
return (isVertical ? size.getHeight() : size.getWidth()) * zoom;
}
public float getPageSpacing(int pageIndex, float zoom) {
float spacing = autoSpacing ? pageSpacing.get(pageIndex) : spacingPx;
return spacing * zoom;
}
/** Get primary page offset, that is Y for vertical scroll and X for horizontal scroll */
public float getPageOffset(int pageIndex, float zoom) {
int docPage = documentPage(pageIndex);
if (docPage < 0) {
return 0;
}
return pageOffsets.get(pageIndex) * zoom;
}
/** Get secondary page offset, that is X for vertical scroll and Y for horizontal scroll */
public float getSecondaryPageOffset(int pageIndex, float zoom) {
SizeF pageSize = getPageSize(pageIndex);
if (isVertical) {
float maxWidth = getMaxPageWidth();
return zoom * (maxWidth - pageSize.getWidth()) / 2; //x
} else {
float maxHeight = getMaxPageHeight();
return zoom * (maxHeight - pageSize.getHeight()) / 2; //y
}
}
public int getPageAtOffset(float offset, float zoom) {
int currentPage = 0;
for (int i = 0; i < getPagesCount(); i++) {
float off = pageOffsets.get(i) * zoom - getPageSpacing(i, zoom) / 2f;
if (off >= offset) {
break;
}
currentPage++;
}
return --currentPage >= 0 ? currentPage : 0;
}
public boolean openPage(int pageIndex) throws PageRenderingException {
int docPage = documentPage(pageIndex);
if (docPage < 0) {
return false;
}
synchronized (lock) {
if (openedPages.indexOfKey(docPage) < 0) {
try {
pdfiumCore.openPage(pdfDocument, docPage);
openedPages.put(docPage, true);
return true;
} catch (Exception e) {
openedPages.put(docPage, false);
throw new PageRenderingException(pageIndex, e);
}
}
return false;
}
}
public boolean pageHasError(int pageIndex) {
int docPage = documentPage(pageIndex);
return !openedPages.get(docPage, false);
}
public void renderPageBitmap(Bitmap bitmap, int pageIndex, Rect bounds, boolean annotationRendering) {
int docPage = documentPage(pageIndex);
pdfiumCore.renderPageBitmap(pdfDocument, bitmap, docPage,
bounds.left, bounds.top, bounds.width(), bounds.height(), annotationRendering);
}
public PdfDocument.Meta getMetaData() {
if (pdfDocument == null) {
return null;
}
return pdfiumCore.getDocumentMeta(pdfDocument);
}
public List getBookmarks() {
if (pdfDocument == null) {
return new ArrayList<>();
}
return pdfiumCore.getTableOfContents(pdfDocument);
}
public List getPageLinks(int pageIndex) {
int docPage = documentPage(pageIndex);
return pdfiumCore.getPageLinks(pdfDocument, docPage);
}
public RectF mapRectToDevice(int pageIndex, int startX, int startY, int sizeX, int sizeY,
RectF rect) {
int docPage = documentPage(pageIndex);
return pdfiumCore.mapRectToDevice(pdfDocument, docPage, startX, startY, sizeX, sizeY, 0, rect);
}
public void dispose() {
if (pdfiumCore != null && pdfDocument != null) {
pdfiumCore.closeDocument(pdfDocument);
}
pdfDocument = null;
originalUserPages = null;
}
/**
* Given the UserPage number, this method restrict it
* to be sure it's an existing page. It takes care of
* using the user defined pages if any.
*
* @param userPage A page number.
* @return A restricted valid page number (example : -2 => 0)
*/
public int determineValidPageNumberFrom(int userPage) {
if (userPage <= 0) {
return 0;
}
if (originalUserPages != null) {
if (userPage >= originalUserPages.length) {
return originalUserPages.length - 1;
}
} else {
if (userPage >= getPagesCount()) {
return getPagesCount() - 1;
}
}
return userPage;
}
public int documentPage(int userPage) {
int documentPage = userPage;
if (originalUserPages != null) {
if (userPage < 0 || userPage >= originalUserPages.length) {
return -1;
} else {
documentPage = originalUserPages[userPage];
}
}
if (documentPage < 0 || userPage >= getPagesCount()) {
return -1;
}
return documentPage;
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/RenderingHandler.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer;
import android.graphics.Bitmap;
import android.graphics.Color;
import android.graphics.Matrix;
import android.graphics.Rect;
import android.graphics.RectF;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import com.github.barteksc.pdfviewer.exception.PageRenderingException;
import com.github.barteksc.pdfviewer.model.PagePart;
/**
* A {@link Handler} that will process incoming {@link RenderingTask} messages
* and alert {@link PDFView#onBitmapRendered(PagePart)} when the portion of the
* PDF is ready to render.
*/
class RenderingHandler extends Handler {
/**
* {@link Message#what} kind of message this handler processes.
*/
static final int MSG_RENDER_TASK = 1;
private static final String TAG = RenderingHandler.class.getName();
private PDFView pdfView;
private RectF renderBounds = new RectF();
private Rect roundedRenderBounds = new Rect();
private Matrix renderMatrix = new Matrix();
private boolean running = false;
RenderingHandler(Looper looper, PDFView pdfView) {
super(looper);
this.pdfView = pdfView;
}
void addRenderingTask(int page, float width, float height, RectF bounds, boolean thumbnail, int cacheOrder, boolean bestQuality, boolean annotationRendering) {
RenderingTask task = new RenderingTask(width, height, bounds, page, thumbnail, cacheOrder, bestQuality, annotationRendering);
Message msg = obtainMessage(MSG_RENDER_TASK, task);
sendMessage(msg);
}
@Override
public void handleMessage(Message message) {
RenderingTask task = (RenderingTask) message.obj;
try {
final PagePart part = proceed(task);
if (part != null) {
if (running) {
pdfView.post(new Runnable() {
@Override
public void run() {
pdfView.onBitmapRendered(part);
}
});
} else {
part.getRenderedBitmap().recycle();
}
}
} catch (final PageRenderingException ex) {
pdfView.post(new Runnable() {
@Override
public void run() {
pdfView.onPageError(ex);
}
});
}
}
private PagePart proceed(RenderingTask renderingTask) throws PageRenderingException {
PdfFile pdfFile = pdfView.pdfFile;
pdfFile.openPage(renderingTask.page);
int w = Math.round(renderingTask.width);
int h = Math.round(renderingTask.height);
if (w == 0 || h == 0 || pdfFile.pageHasError(renderingTask.page)) {
return null;
}
Bitmap render;
try {
render = Bitmap.createBitmap(w, h, renderingTask.bestQuality ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565);
} catch (IllegalArgumentException e) {
Log.e(TAG, "Cannot create bitmap", e);
return null;
}
calculateBounds(w, h, renderingTask.bounds);
pdfFile.renderPageBitmap(render, renderingTask.page, roundedRenderBounds, renderingTask.annotationRendering);
return new PagePart(renderingTask.page, render,
renderingTask.bounds, renderingTask.thumbnail,
renderingTask.cacheOrder);
}
private void calculateBounds(int width, int height, RectF pageSliceBounds) {
renderMatrix.reset();
renderMatrix.postTranslate(-pageSliceBounds.left * width, -pageSliceBounds.top * height);
renderMatrix.postScale(1 / pageSliceBounds.width(), 1 / pageSliceBounds.height());
renderBounds.set(0, 0, width, height);
renderMatrix.mapRect(renderBounds);
renderBounds.round(roundedRenderBounds);
}
void stop() {
running = false;
}
void start() {
running = true;
}
private class RenderingTask {
float width, height;
RectF bounds;
int page;
boolean thumbnail;
int cacheOrder;
boolean bestQuality;
boolean annotationRendering;
RenderingTask(float width, float height, RectF bounds, int page, boolean thumbnail, int cacheOrder, boolean bestQuality, boolean annotationRendering) {
this.page = page;
this.width = width;
this.height = height;
this.bounds = bounds;
this.thumbnail = thumbnail;
this.cacheOrder = cacheOrder;
this.bestQuality = bestQuality;
this.annotationRendering = annotationRendering;
}
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/exception/FileNotFoundException.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.exception;
@Deprecated
public class FileNotFoundException extends RuntimeException {
public FileNotFoundException(String detailMessage) {
super(detailMessage);
}
public FileNotFoundException(String detailMessage, Throwable throwable) {
super(detailMessage, throwable);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/exception/PageRenderingException.java
================================================
package com.github.barteksc.pdfviewer.exception;
public class PageRenderingException extends Exception {
private final int page;
public PageRenderingException(int page, Throwable cause) {
super(cause);
this.page = page;
}
public int getPage() {
return page;
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/link/DefaultLinkHandler.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.link;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.util.Log;
import com.github.barteksc.pdfviewer.PDFView;
import com.github.barteksc.pdfviewer.model.LinkTapEvent;
public class DefaultLinkHandler implements LinkHandler {
private static final String TAG = DefaultLinkHandler.class.getSimpleName();
private PDFView pdfView;
public DefaultLinkHandler(PDFView pdfView) {
this.pdfView = pdfView;
}
@Override
public void handleLinkEvent(LinkTapEvent event) {
String uri = event.getLink().getUri();
Integer page = event.getLink().getDestPageIdx();
if (uri != null && !uri.isEmpty()) {
handleUri(uri);
} else if (page != null) {
handlePage(page);
}
}
private void handleUri(String uri) {
Uri parsedUri = Uri.parse(uri);
Intent intent = new Intent(Intent.ACTION_VIEW, parsedUri);
Context context = pdfView.getContext();
if (intent.resolveActivity(context.getPackageManager()) != null) {
context.startActivity(intent);
} else {
Log.w(TAG, "No activity found for URI: " + uri);
}
}
private void handlePage(int page) {
pdfView.jumpTo(page);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/link/LinkHandler.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.link;
import com.github.barteksc.pdfviewer.model.LinkTapEvent;
public interface LinkHandler {
/**
* Called when link was tapped by user
*
* @param event current event
*/
void handleLinkEvent(LinkTapEvent event);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/Callbacks.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
import android.view.MotionEvent;
import com.github.barteksc.pdfviewer.link.LinkHandler;
import com.github.barteksc.pdfviewer.model.LinkTapEvent;
public class Callbacks {
/**
* Call back object to call when the PDF is loaded
*/
private OnLoadCompleteListener onLoadCompleteListener;
/**
* Call back object to call when document loading error occurs
*/
private OnErrorListener onErrorListener;
/**
* Call back object to call when the page load error occurs
*/
private OnPageErrorListener onPageErrorListener;
/**
* Call back object to call when the document is initially rendered
*/
private OnRenderListener onRenderListener;
/**
* Call back object to call when the page has changed
*/
private OnPageChangeListener onPageChangeListener;
/**
* Call back object to call when the page is scrolled
*/
private OnPageScrollListener onPageScrollListener;
/**
* Call back object to call when the above layer is to drawn
*/
private OnDrawListener onDrawListener;
private OnDrawListener onDrawAllListener;
/**
* Call back object to call when the user does a tap gesture
*/
private OnTapListener onTapListener;
/**
* Call back object to call when the user does a long tap gesture
*/
private OnLongPressListener onLongPressListener;
/**
* Call back object to call when clicking link
*/
private LinkHandler linkHandler;
public void setOnLoadComplete(OnLoadCompleteListener onLoadCompleteListener) {
this.onLoadCompleteListener = onLoadCompleteListener;
}
public void callOnLoadComplete(int pagesCount) {
if (onLoadCompleteListener != null) {
onLoadCompleteListener.loadComplete(pagesCount);
}
}
public void setOnError(OnErrorListener onErrorListener) {
this.onErrorListener = onErrorListener;
}
public OnErrorListener getOnError() {
return onErrorListener;
}
public void setOnPageError(OnPageErrorListener onPageErrorListener) {
this.onPageErrorListener = onPageErrorListener;
}
public boolean callOnPageError(int page, Throwable error) {
if (onPageErrorListener != null) {
onPageErrorListener.onPageError(page, error);
return true;
}
return false;
}
public void setOnRender(OnRenderListener onRenderListener) {
this.onRenderListener = onRenderListener;
}
public void callOnRender(int pagesCount) {
if (onRenderListener != null) {
onRenderListener.onInitiallyRendered(pagesCount);
}
}
public void setOnPageChange(OnPageChangeListener onPageChangeListener) {
this.onPageChangeListener = onPageChangeListener;
}
public void callOnPageChange(int page, int pagesCount) {
if (onPageChangeListener != null) {
onPageChangeListener.onPageChanged(page, pagesCount);
}
}
public void setOnPageScroll(OnPageScrollListener onPageScrollListener) {
this.onPageScrollListener = onPageScrollListener;
}
public void callOnPageScroll(int currentPage, float offset) {
if (onPageScrollListener != null) {
onPageScrollListener.onPageScrolled(currentPage, offset);
}
}
public void setOnDraw(OnDrawListener onDrawListener) {
this.onDrawListener = onDrawListener;
}
public OnDrawListener getOnDraw() {
return onDrawListener;
}
public void setOnDrawAll(OnDrawListener onDrawAllListener) {
this.onDrawAllListener = onDrawAllListener;
}
public OnDrawListener getOnDrawAll() {
return onDrawAllListener;
}
public void setOnTap(OnTapListener onTapListener) {
this.onTapListener = onTapListener;
}
public boolean callOnTap(MotionEvent event) {
return onTapListener != null && onTapListener.onTap(event);
}
public void setOnLongPress(OnLongPressListener onLongPressListener) {
this.onLongPressListener = onLongPressListener;
}
public void callOnLongPress(MotionEvent event) {
if (onLongPressListener != null) {
onLongPressListener.onLongPress(event);
}
}
public void setLinkHandler(LinkHandler linkHandler) {
this.linkHandler = linkHandler;
}
public void callLinkHandler(LinkTapEvent event) {
if (linkHandler != null) {
linkHandler.handleLinkEvent(event);
}
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnDrawListener.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
import android.graphics.Canvas;
/**
* This interface allows an extern class to draw
* something on the PDFView canvas, above all images.
*/
public interface OnDrawListener {
/**
* This method is called when the PDFView is
* drawing its view.
*
* The page is starting at (0,0)
*
* @param canvas The canvas on which to draw things.
* @param pageWidth The width of the current page.
* @param pageHeight The height of the current page.
* @param displayedPage The current page index
*/
void onLayerDrawn(Canvas canvas, float pageWidth, float pageHeight, int displayedPage);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnErrorListener.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
public interface OnErrorListener {
/**
* Called if error occurred while opening PDF
* @param t Throwable with error
*/
void onError(Throwable t);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnLoadCompleteListener.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
/**
* Implement this interface to receive events from PDFView
* when loading is complete.
*/
public interface OnLoadCompleteListener {
/**
* Called when the PDF is loaded
* @param nbPages the number of pages in this PDF file
*/
void loadComplete(int nbPages);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnLongPressListener.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
import android.view.MotionEvent;
/**
* Implement this interface to receive events from PDFView
* when view has been long pressed
*/
public interface OnLongPressListener {
/**
* Called when the user has a long tap gesture, before processing scroll handle toggling
*
* @param e MotionEvent that registered as a confirmed long press
*/
void onLongPress(MotionEvent e);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnPageChangeListener.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
/**
* Implements this interface to receive events from PDFView
* when a page has changed through swipe
*/
public interface OnPageChangeListener {
/**
* Called when the user use swipe to change page
*
* @param page the new page displayed, starting from 0
* @param pageCount the total page count
*/
void onPageChanged(int page, int pageCount);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnPageErrorListener.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
public interface OnPageErrorListener {
/**
* Called if error occurred while loading PDF page
* @param t Throwable with error
*/
void onPageError(int page, Throwable t);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnPageScrollListener.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
/**
* Implements this interface to receive events from PDFView
* when a page has been scrolled
*/
public interface OnPageScrollListener {
/**
* Called on every move while scrolling
*
* @param page current page index
* @param positionOffset see {@link com.github.barteksc.pdfviewer.PDFView#getPositionOffset()}
*/
void onPageScrolled(int page, float positionOffset);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnRenderListener.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
public interface OnRenderListener {
/**
* Called only once, when document is rendered
* @param nbPages number of pages
*/
void onInitiallyRendered(int nbPages);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/listener/OnTapListener.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.listener;
import android.view.MotionEvent;
/**
* Implement this interface to receive events from PDFView
* when view has been touched
*/
public interface OnTapListener {
/**
* Called when the user has a tap gesture, before processing scroll handle toggling
*
* @param e MotionEvent that registered as a confirmed single tap
* @return true if the single tap was handled, false to toggle scroll handle
*/
boolean onTap(MotionEvent e);
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/model/LinkTapEvent.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.model;
import android.graphics.RectF;
import com.shockwave.pdfium.PdfDocument;
public class LinkTapEvent {
private float originalX;
private float originalY;
private float documentX;
private float documentY;
private RectF mappedLinkRect;
private PdfDocument.Link link;
public LinkTapEvent(float originalX, float originalY, float documentX, float documentY, RectF mappedLinkRect, PdfDocument.Link link) {
this.originalX = originalX;
this.originalY = originalY;
this.documentX = documentX;
this.documentY = documentY;
this.mappedLinkRect = mappedLinkRect;
this.link = link;
}
public float getOriginalX() {
return originalX;
}
public float getOriginalY() {
return originalY;
}
public float getDocumentX() {
return documentX;
}
public float getDocumentY() {
return documentY;
}
public RectF getMappedLinkRect() {
return mappedLinkRect;
}
public PdfDocument.Link getLink() {
return link;
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/model/PagePart.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.model;
import android.graphics.Bitmap;
import android.graphics.RectF;
public class PagePart {
private int page;
private Bitmap renderedBitmap;
private RectF pageRelativeBounds;
private boolean thumbnail;
private int cacheOrder;
public PagePart(int page, Bitmap renderedBitmap, RectF pageRelativeBounds, boolean thumbnail, int cacheOrder) {
super();
this.page = page;
this.renderedBitmap = renderedBitmap;
this.pageRelativeBounds = pageRelativeBounds;
this.thumbnail = thumbnail;
this.cacheOrder = cacheOrder;
}
public int getCacheOrder() {
return cacheOrder;
}
public int getPage() {
return page;
}
public Bitmap getRenderedBitmap() {
return renderedBitmap;
}
public RectF getPageRelativeBounds() {
return pageRelativeBounds;
}
public boolean isThumbnail() {
return thumbnail;
}
public void setCacheOrder(int cacheOrder) {
this.cacheOrder = cacheOrder;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof PagePart)) {
return false;
}
PagePart part = (PagePart) obj;
return part.getPage() == page
&& part.getPageRelativeBounds().left == pageRelativeBounds.left
&& part.getPageRelativeBounds().right == pageRelativeBounds.right
&& part.getPageRelativeBounds().top == pageRelativeBounds.top
&& part.getPageRelativeBounds().bottom == pageRelativeBounds.bottom;
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/scroll/DefaultScrollHandle.java
================================================
package com.github.barteksc.pdfviewer.scroll;
import android.content.Context;
import android.graphics.Color;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import androidx.core.content.ContextCompat;
import android.util.TypedValue;
import android.view.MotionEvent;
import android.view.ViewGroup;
import android.widget.RelativeLayout;
import android.widget.TextView;
import com.github.barteksc.pdfviewer.PDFView;
import com.github.barteksc.pdfviewer.R;
import com.github.barteksc.pdfviewer.util.Util;
public class DefaultScrollHandle extends RelativeLayout implements ScrollHandle {
private final static int HANDLE_LONG = 65;
private final static int HANDLE_SHORT = 40;
private final static int DEFAULT_TEXT_SIZE = 16;
private float relativeHandlerMiddle = 0f;
protected TextView textView;
protected Context context;
private boolean inverted;
private PDFView pdfView;
private float currentPos;
private Handler handler = new Handler();
private Runnable hidePageScrollerRunnable = new Runnable() {
@Override
public void run() {
hide();
}
};
public DefaultScrollHandle(Context context) {
this(context, false);
}
public DefaultScrollHandle(Context context, boolean inverted) {
super(context);
this.context = context;
this.inverted = inverted;
textView = new TextView(context);
setVisibility(INVISIBLE);
setTextColor(Color.BLACK);
setTextSize(DEFAULT_TEXT_SIZE);
}
@Override
public void setupLayout(PDFView pdfView) {
int align, width, height;
Drawable background;
// determine handler position, default is right (when scrolling vertically) or bottom (when scrolling horizontally)
if (pdfView.isSwipeVertical()) {
width = HANDLE_LONG;
height = HANDLE_SHORT;
if (inverted) { // left
align = ALIGN_PARENT_LEFT;
background = ContextCompat.getDrawable(context, R.drawable.default_scroll_handle_left);
} else { // right
align = ALIGN_PARENT_RIGHT;
background = ContextCompat.getDrawable(context, R.drawable.default_scroll_handle_right);
}
} else {
width = HANDLE_SHORT;
height = HANDLE_LONG;
if (inverted) { // top
align = ALIGN_PARENT_TOP;
background = ContextCompat.getDrawable(context, R.drawable.default_scroll_handle_top);
} else { // bottom
align = ALIGN_PARENT_BOTTOM;
background = ContextCompat.getDrawable(context, R.drawable.default_scroll_handle_bottom);
}
}
if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.JELLY_BEAN) {
setBackgroundDrawable(background);
} else {
setBackground(background);
}
LayoutParams lp = new LayoutParams(Util.getDP(context, width), Util.getDP(context, height));
lp.setMargins(0, 0, 0, 0);
LayoutParams tvlp = new LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
tvlp.addRule(RelativeLayout.CENTER_IN_PARENT, RelativeLayout.TRUE);
addView(textView, tvlp);
lp.addRule(align);
pdfView.addView(this, lp);
this.pdfView = pdfView;
}
@Override
public void destroyLayout() {
pdfView.removeView(this);
}
@Override
public void setScroll(float position) {
if (!shown()) {
show();
} else {
handler.removeCallbacks(hidePageScrollerRunnable);
}
if (pdfView != null) {
setPosition((pdfView.isSwipeVertical() ? pdfView.getHeight() : pdfView.getWidth()) * position);
}
}
private void setPosition(float pos) {
if (Float.isInfinite(pos) || Float.isNaN(pos)) {
return;
}
float pdfViewSize;
if (pdfView.isSwipeVertical()) {
pdfViewSize = pdfView.getHeight();
} else {
pdfViewSize = pdfView.getWidth();
}
pos -= relativeHandlerMiddle;
if (pos < 0) {
pos = 0;
} else if (pos > pdfViewSize - Util.getDP(context, HANDLE_SHORT)) {
pos = pdfViewSize - Util.getDP(context, HANDLE_SHORT);
}
if (pdfView.isSwipeVertical()) {
setY(pos);
} else {
setX(pos);
}
calculateMiddle();
invalidate();
}
private void calculateMiddle() {
float pos, viewSize, pdfViewSize;
if (pdfView.isSwipeVertical()) {
pos = getY();
viewSize = getHeight();
pdfViewSize = pdfView.getHeight();
} else {
pos = getX();
viewSize = getWidth();
pdfViewSize = pdfView.getWidth();
}
relativeHandlerMiddle = ((pos + relativeHandlerMiddle) / pdfViewSize) * viewSize;
}
@Override
public void hideDelayed() {
handler.postDelayed(hidePageScrollerRunnable, 1000);
}
@Override
public void setPageNum(int pageNum) {
String text = String.valueOf(pageNum);
if (!textView.getText().equals(text)) {
textView.setText(text);
}
}
@Override
public boolean shown() {
return getVisibility() == VISIBLE;
}
@Override
public void show() {
setVisibility(VISIBLE);
}
@Override
public void hide() {
setVisibility(INVISIBLE);
}
public void setTextColor(int color) {
textView.setTextColor(color);
}
/**
* @param size text size in dp
*/
public void setTextSize(int size) {
textView.setTextSize(TypedValue.COMPLEX_UNIT_DIP, size);
}
private boolean isPDFViewReady() {
return pdfView != null && pdfView.getPageCount() > 0 && !pdfView.documentFitsView();
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if (!isPDFViewReady()) {
return super.onTouchEvent(event);
}
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
case MotionEvent.ACTION_POINTER_DOWN:
pdfView.stopFling();
handler.removeCallbacks(hidePageScrollerRunnable);
if (pdfView.isSwipeVertical()) {
currentPos = event.getRawY() - getY();
} else {
currentPos = event.getRawX() - getX();
}
case MotionEvent.ACTION_MOVE:
if (pdfView.isSwipeVertical()) {
setPosition(event.getRawY() - currentPos + relativeHandlerMiddle);
pdfView.setPositionOffset(relativeHandlerMiddle / (float) getHeight(), false);
} else {
setPosition(event.getRawX() - currentPos + relativeHandlerMiddle);
pdfView.setPositionOffset(relativeHandlerMiddle / (float) getWidth(), false);
}
return true;
case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_UP:
case MotionEvent.ACTION_POINTER_UP:
hideDelayed();
pdfView.performPageSnap();
return true;
}
return super.onTouchEvent(event);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/scroll/ScrollHandle.java
================================================
package com.github.barteksc.pdfviewer.scroll;
import com.github.barteksc.pdfviewer.PDFView;
public interface ScrollHandle {
/**
* Used to move the handle, called internally by PDFView
*
* @param position current scroll ratio between 0 and 1
*/
void setScroll(float position);
/**
* Method called by PDFView after setting scroll handle.
* Do not call this method manually.
* For usage sample see {@link DefaultScrollHandle}
*
* @param pdfView PDFView instance
*/
void setupLayout(PDFView pdfView);
/**
* Method called by PDFView when handle should be removed from layout
* Do not call this method manually.
*/
void destroyLayout();
/**
* Set page number displayed on handle
*
* @param pageNum page number
*/
void setPageNum(int pageNum);
/**
* Get handle visibility
*
* @return true if handle is visible, false otherwise
*/
boolean shown();
/**
* Show handle
*/
void show();
/**
* Hide handle immediately
*/
void hide();
/**
* Hide handle after some time (defined by implementation)
*/
void hideDelayed();
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/source/AssetSource.java
================================================
/*
* Copyright (C) 2016 Bartosz Schiller.
*
* 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.github.barteksc.pdfviewer.source;
import android.content.Context;
import android.os.ParcelFileDescriptor;
import com.github.barteksc.pdfviewer.util.FileUtils;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.PdfiumCore;
import java.io.File;
import java.io.IOException;
public class AssetSource implements DocumentSource {
private final String assetName;
public AssetSource(String assetName) {
this.assetName = assetName;
}
@Override
public PdfDocument createDocument(Context context, PdfiumCore core, String password) throws IOException {
File f = FileUtils.fileFromAsset(context, assetName);
ParcelFileDescriptor pfd = ParcelFileDescriptor.open(f, ParcelFileDescriptor.MODE_READ_ONLY);
return core.newDocument(pfd, password);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/source/ByteArraySource.java
================================================
/*
* Copyright (C) 2016 Bartosz Schiller.
*
* 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.github.barteksc.pdfviewer.source;
import android.content.Context;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.PdfiumCore;
import java.io.IOException;
public class ByteArraySource implements DocumentSource {
private byte[] data;
public ByteArraySource(byte[] data) {
this.data = data;
}
@Override
public PdfDocument createDocument(Context context, PdfiumCore core, String password) throws IOException {
return core.newDocument(data, password);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/source/DocumentSource.java
================================================
/*
* Copyright (C) 2016 Bartosz Schiller.
*
* 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.github.barteksc.pdfviewer.source;
import android.content.Context;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.PdfiumCore;
import java.io.IOException;
public interface DocumentSource {
PdfDocument createDocument(Context context, PdfiumCore core, String password) throws IOException;
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/source/FileSource.java
================================================
/*
* Copyright (C) 2016 Bartosz Schiller.
*
* 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.github.barteksc.pdfviewer.source;
import android.content.Context;
import android.os.ParcelFileDescriptor;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.PdfiumCore;
import java.io.File;
import java.io.IOException;
public class FileSource implements DocumentSource {
private File file;
public FileSource(File file) {
this.file = file;
}
@Override
public PdfDocument createDocument(Context context, PdfiumCore core, String password) throws IOException {
ParcelFileDescriptor pfd = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
return core.newDocument(pfd, password);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/source/InputStreamSource.java
================================================
/*
* Copyright (C) 2016 Bartosz Schiller.
*
* 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.github.barteksc.pdfviewer.source;
import android.content.Context;
import com.github.barteksc.pdfviewer.util.Util;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.PdfiumCore;
import java.io.IOException;
import java.io.InputStream;
public class InputStreamSource implements DocumentSource {
private InputStream inputStream;
public InputStreamSource(InputStream inputStream) {
this.inputStream = inputStream;
}
@Override
public PdfDocument createDocument(Context context, PdfiumCore core, String password) throws IOException {
return core.newDocument(Util.toByteArray(inputStream), password);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/source/UriSource.java
================================================
/*
* Copyright (C) 2016 Bartosz Schiller.
*
* 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.github.barteksc.pdfviewer.source;
import android.content.Context;
import android.net.Uri;
import android.os.ParcelFileDescriptor;
import com.shockwave.pdfium.PdfDocument;
import com.shockwave.pdfium.PdfiumCore;
import java.io.IOException;
public class UriSource implements DocumentSource {
private Uri uri;
public UriSource(Uri uri) {
this.uri = uri;
}
@Override
public PdfDocument createDocument(Context context, PdfiumCore core, String password) throws IOException {
ParcelFileDescriptor pfd = context.getContentResolver().openFileDescriptor(uri, "r");
return core.newDocument(pfd, password);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/util/ArrayUtils.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.util;
import java.util.ArrayList;
import java.util.List;
public class ArrayUtils {
private ArrayUtils() {
// Prevents instantiation
}
/** Transforms (0,1,2,2,3) to (0,1,2,3) */
public static int[] deleteDuplicatedPages(int[] pages) {
List result = new ArrayList<>();
int lastInt = -1;
for (Integer currentInt : pages) {
if (lastInt != currentInt) {
result.add(currentInt);
}
lastInt = currentInt;
}
int[] arrayResult = new int[result.size()];
for (int i = 0; i < result.size(); i++) {
arrayResult[i] = result.get(i);
}
return arrayResult;
}
/** Transforms (0, 4, 4, 6, 6, 6, 3) into (0, 1, 1, 2, 2, 2, 3) */
public static int[] calculateIndexesInDuplicateArray(int[] originalUserPages) {
int[] result = new int[originalUserPages.length];
if (originalUserPages.length == 0) {
return result;
}
int index = 0;
result[0] = index;
for (int i = 1; i < originalUserPages.length; i++) {
if (originalUserPages[i] != originalUserPages[i - 1]) {
index++;
}
result[i] = index;
}
return result;
}
public static String arrayToString(int[] array) {
StringBuilder builder = new StringBuilder("[");
for (int i = 0; i < array.length; i++) {
builder.append(array[i]);
if (i != array.length - 1) {
builder.append(",");
}
}
builder.append("]");
return builder.toString();
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/util/Constants.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.util;
public class Constants {
public static boolean DEBUG_MODE = false;
/** Between 0 and 1, the thumbnails quality (default 0.3). Increasing this value may cause performance decrease */
public static float THUMBNAIL_RATIO = 0.3f;
/**
* The size of the rendered parts (default 256)
* Tinier : a little bit slower to have the whole page rendered but more reactive.
* Bigger : user will have to wait longer to have the first visual results
*/
public static float PART_SIZE = 256;
/** Part of document above and below screen that should be preloaded, in dp */
public static int PRELOAD_OFFSET = 20;
public static class Cache {
/** The size of the cache (number of bitmaps kept) */
public static int CACHE_SIZE = 120;
public static int THUMBNAILS_CACHE_SIZE = 8;
}
public static class Pinch {
public static float MAXIMUM_ZOOM = 10;
public static float MINIMUM_ZOOM = 1;
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/util/FileUtils.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.util;
import android.content.Context;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class FileUtils {
private FileUtils() {
// Prevents instantiation
}
public static File fileFromAsset(Context context, String assetName) throws IOException {
File outFile = new File(context.getCacheDir(), assetName + "-pdfview.pdf");
if (assetName.contains("/")) {
outFile.getParentFile().mkdirs();
}
copy(context.getAssets().open(assetName), outFile);
return outFile;
}
public static void copy(InputStream inputStream, File output) throws IOException {
OutputStream outputStream = null;
try {
outputStream = new FileOutputStream(output);
int read = 0;
byte[] bytes = new byte[1024];
while ((read = inputStream.read(bytes)) != -1) {
outputStream.write(bytes, 0, read);
}
} finally {
try {
if (inputStream != null) {
inputStream.close();
}
} finally {
if (outputStream != null) {
outputStream.close();
}
}
}
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/util/FitPolicy.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.util;
public enum FitPolicy {
WIDTH, HEIGHT, BOTH
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/util/MathUtils.java
================================================
/**
* Copyright 2016 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.util;
public class MathUtils {
static private final int BIG_ENOUGH_INT = 16 * 1024;
static private final double BIG_ENOUGH_FLOOR = BIG_ENOUGH_INT;
static private final double BIG_ENOUGH_CEIL = 16384.999999999996;
private MathUtils() {
// Prevents instantiation
}
/**
* Limits the given number between the other values
* @param number The number to limit.
* @param between The smallest value the number can take.
* @param and The biggest value the number can take.
* @return The limited number.
*/
public static int limit(int number, int between, int and) {
if (number <= between) {
return between;
}
if (number >= and) {
return and;
}
return number;
}
/**
* Limits the given number between the other values
* @param number The number to limit.
* @param between The smallest value the number can take.
* @param and The biggest value the number can take.
* @return The limited number.
*/
public static float limit(float number, float between, float and) {
if (number <= between) {
return between;
}
if (number >= and) {
return and;
}
return number;
}
public static float max(float number, float max) {
if (number > max) {
return max;
}
return number;
}
public static float min(float number, float min) {
if (number < min) {
return min;
}
return number;
}
public static int max(int number, int max) {
if (number > max) {
return max;
}
return number;
}
public static int min(int number, int min) {
if (number < min) {
return min;
}
return number;
}
/**
* Methods from libGDX - https://github.com/libgdx/libgdx
*/
/** Returns the largest integer less than or equal to the specified float. This method will only properly floor floats from
* -(2^14) to (Float.MAX_VALUE - 2^14). */
static public int floor(float value) {
return (int) (value + BIG_ENOUGH_FLOOR) - BIG_ENOUGH_INT;
}
/** Returns the smallest integer greater than or equal to the specified float. This method will only properly ceil floats from
* -(2^14) to (Float.MAX_VALUE - 2^14). */
static public int ceil(float value) {
return (int) (value + BIG_ENOUGH_CEIL) - BIG_ENOUGH_INT;
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/util/PageSizeCalculator.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.util;
import com.shockwave.pdfium.util.Size;
import com.shockwave.pdfium.util.SizeF;
public class PageSizeCalculator {
private FitPolicy fitPolicy;
private final Size originalMaxWidthPageSize;
private final Size originalMaxHeightPageSize;
private final Size viewSize;
private SizeF optimalMaxWidthPageSize;
private SizeF optimalMaxHeightPageSize;
private float widthRatio;
private float heightRatio;
private boolean fitEachPage;
public PageSizeCalculator(FitPolicy fitPolicy, Size originalMaxWidthPageSize, Size originalMaxHeightPageSize,
Size viewSize, boolean fitEachPage) {
this.fitPolicy = fitPolicy;
this.originalMaxWidthPageSize = originalMaxWidthPageSize;
this.originalMaxHeightPageSize = originalMaxHeightPageSize;
this.viewSize = viewSize;
this.fitEachPage = fitEachPage;
calculateMaxPages();
}
public SizeF calculate(Size pageSize) {
if (pageSize.getWidth() <= 0 || pageSize.getHeight() <= 0) {
return new SizeF(0, 0);
}
float maxWidth = fitEachPage ? viewSize.getWidth() : pageSize.getWidth() * widthRatio;
float maxHeight = fitEachPage ? viewSize.getHeight() : pageSize.getHeight() * heightRatio;
switch (fitPolicy) {
case HEIGHT:
return fitHeight(pageSize, maxHeight);
case BOTH:
return fitBoth(pageSize, maxWidth, maxHeight);
default:
return fitWidth(pageSize, maxWidth);
}
}
public SizeF getOptimalMaxWidthPageSize() {
return optimalMaxWidthPageSize;
}
public SizeF getOptimalMaxHeightPageSize() {
return optimalMaxHeightPageSize;
}
private void calculateMaxPages() {
switch (fitPolicy) {
case HEIGHT:
optimalMaxHeightPageSize = fitHeight(originalMaxHeightPageSize, viewSize.getHeight());
heightRatio = optimalMaxHeightPageSize.getHeight() / originalMaxHeightPageSize.getHeight();
optimalMaxWidthPageSize = fitHeight(originalMaxWidthPageSize, originalMaxWidthPageSize.getHeight() * heightRatio);
break;
case BOTH:
SizeF localOptimalMaxWidth = fitBoth(originalMaxWidthPageSize, viewSize.getWidth(), viewSize.getHeight());
float localWidthRatio = localOptimalMaxWidth.getWidth() / originalMaxWidthPageSize.getWidth();
this.optimalMaxHeightPageSize = fitBoth(originalMaxHeightPageSize, originalMaxHeightPageSize.getWidth() * localWidthRatio,
viewSize.getHeight());
heightRatio = optimalMaxHeightPageSize.getHeight() / originalMaxHeightPageSize.getHeight();
optimalMaxWidthPageSize = fitBoth(originalMaxWidthPageSize, viewSize.getWidth(), originalMaxWidthPageSize.getHeight() * heightRatio);
widthRatio = optimalMaxWidthPageSize.getWidth() / originalMaxWidthPageSize.getWidth();
break;
default:
optimalMaxWidthPageSize = fitWidth(originalMaxWidthPageSize, viewSize.getWidth());
widthRatio = optimalMaxWidthPageSize.getWidth() / originalMaxWidthPageSize.getWidth();
optimalMaxHeightPageSize = fitWidth(originalMaxHeightPageSize, originalMaxHeightPageSize.getWidth() * widthRatio);
break;
}
}
private SizeF fitWidth(Size pageSize, float maxWidth) {
float w = pageSize.getWidth(), h = pageSize.getHeight();
float ratio = w / h;
w = maxWidth;
h = (float) Math.floor(maxWidth / ratio);
return new SizeF(w, h);
}
private SizeF fitHeight(Size pageSize, float maxHeight) {
float w = pageSize.getWidth(), h = pageSize.getHeight();
float ratio = h / w;
h = maxHeight;
w = (float) Math.floor(maxHeight / ratio);
return new SizeF(w, h);
}
private SizeF fitBoth(Size pageSize, float maxWidth, float maxHeight) {
float w = pageSize.getWidth(), h = pageSize.getHeight();
float ratio = w / h;
w = maxWidth;
h = (float) Math.floor(maxWidth / ratio);
if (h > maxHeight) {
h = maxHeight;
w = (float) Math.floor(maxHeight * ratio);
}
return new SizeF(w, h);
}
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/util/SnapEdge.java
================================================
/**
* Copyright 2017 Bartosz Schiller
*
* 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.github.barteksc.pdfviewer.util;
public enum SnapEdge {
START, CENTER, END, NONE
}
================================================
FILE: android-pdf-viewer/src/main/java/com/github/barteksc/pdfviewer/util/Util.java
================================================
/*
* Copyright (C) 2016 Bartosz Schiller.
*
* 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.github.barteksc.pdfviewer.util;
import android.content.Context;
import android.util.TypedValue;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
public class Util {
private static final int DEFAULT_BUFFER_SIZE = 1024 * 4;
public static int getDP(Context context, int dp) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, context.getResources().getDisplayMetrics());
}
public static byte[] toByteArray(InputStream inputStream) throws IOException {
ByteArrayOutputStream os = new ByteArrayOutputStream();
byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
int n;
while (-1 != (n = inputStream.read(buffer))) {
os.write(buffer, 0, n);
}
return os.toByteArray();
}
}
================================================
FILE: android-pdf-viewer/src/main/res/drawable/default_scroll_handle_bottom.xml
================================================
================================================
FILE: android-pdf-viewer/src/main/res/drawable/default_scroll_handle_left.xml
================================================
================================================
FILE: android-pdf-viewer/src/main/res/drawable/default_scroll_handle_right.xml
================================================
================================================
FILE: android-pdf-viewer/src/main/res/drawable/default_scroll_handle_top.xml
================================================
================================================
FILE: android-pdf-viewer/src/main/res/values/attrs.xml
================================================
================================================
FILE: build.gradle
================================================
buildscript {
repositories {
google()
mavenCentral()
}
dependencies {
classpath 'com.android.tools.build:gradle:8.13.0'
}
}
allprojects {
repositories {
google()
mavenCentral()
}
}
subprojects {
configurations.configureEach {
resolutionStrategy {
force 'org.jetbrains.kotlin:kotlin-stdlib:1.8.22'
force 'org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.8.22'
force 'org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.8.22'
}
}
}
================================================
FILE: gradle/wrapper/gradle-wrapper.properties
================================================
#Wed Sep 10 21:17:12 IST 2025
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-8.14-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
================================================
FILE: gradle.properties
================================================
org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
android.useAndroidX=true
android.enableJetifier=true
# 16 KB page size support
android.enableR8.fullMode=true
================================================
FILE: gradlew
================================================
#!/usr/bin/env bash
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS=""
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn ( ) {
echo "$*"
}
die ( ) {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
esac
# For Cygwin, ensure paths are in UNIX format before anything is touched.
if $cygwin ; then
[ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
fi
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >&-
APP_HOME="`pwd -P`"
cd "$SAVED" >&-
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=$((i+1))
done
case $i in
(0) set -- ;;
(1) set -- "$args0" ;;
(2) set -- "$args0" "$args1" ;;
(3) set -- "$args0" "$args1" "$args2" ;;
(4) set -- "$args0" "$args1" "$args2" "$args3" ;;
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
function splitJvmOpts() {
JVM_OPTS=("$@")
}
eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
================================================
FILE: gradlew.bat
================================================
@REM
@REM Copyright 2014 Joan Zapata
@REM
@REM This file is part of Android-pdfview.
@REM
@REM Android-pdfview is free software: you can redistribute it and/or modify
@REM it under the terms of the GNU General Public License as published by
@REM the Free Software Foundation, either version 3 of the License, or
@REM (at your option) any later version.
@REM
@REM Android-pdfview is distributed in the hope that it will be useful,
@REM but WITHOUT ANY WARRANTY; without even the implied warranty of
@REM MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
@REM GNU General Public License for more details.
@REM
@REM You should have received a copy of the GNU General Public License
@REM along with Android-pdfview. If not, see .
@REM
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windowz variants
if not "%OS%" == "Windows_NT" goto win9xME_args
if "%@eval[2+2]" == "4" goto 4NT_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
goto execute
:4NT_args
@rem Get arguments from the 4NT Shell from JP Software
set CMD_LINE_ARGS=%$
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
================================================
FILE: sample/build.gradle
================================================
buildscript {
repositories {
google()
mavenCentral()
}
}
repositories {
google()
mavenCentral()
}
apply plugin: 'com.android.application'
android {
namespace 'com.github.barteksc.sample'
compileSdkVersion 36
defaultConfig {
minSdkVersion 21
targetSdkVersion 36
versionCode 3
versionName "3.0.0"
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_17
targetCompatibility JavaVersion.VERSION_17
}
buildFeatures {
buildConfig true
}
packagingOptions {
exclude 'META-INF/DEPENDENCIES'
exclude 'META-INF/LICENSE'
exclude 'META-INF/LICENSE.txt'
exclude 'META-INF/NOTICE'
exclude 'META-INF/NOTICE.txt'
// 16 KB page size support configuration
jniLibs {
useLegacyPackaging true // Use compressed shared libraries to avoid 16 KB alignment issues
}
}
// Enable 16 KB page size support for native libraries
ndkVersion "28.0.12433566" // Use NDK r28+ for 16 KB support
}
dependencies {
implementation project(':android-pdf-viewer')
implementation 'androidx.appcompat:appcompat:1.7.1'
}
================================================
FILE: sample/src/main/AndroidManifest.xml
================================================
================================================
FILE: sample/src/main/java/com/github/barteksc/sample/PDFViewActivity.java
================================================
package com.github.barteksc.sample;
import android.content.ActivityNotFoundException;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.graphics.Color;
import android.net.Uri;
import android.os.Bundle;
import android.provider.OpenableColumns;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import android.util.Log;
import android.widget.Toast;
import com.github.barteksc.pdfviewer.PDFView;
import com.github.barteksc.pdfviewer.listener.OnLoadCompleteListener;
import com.github.barteksc.pdfviewer.listener.OnPageChangeListener;
import com.github.barteksc.pdfviewer.listener.OnPageErrorListener;
import com.github.barteksc.pdfviewer.scroll.DefaultScrollHandle;
import com.github.barteksc.pdfviewer.util.FitPolicy;
import com.shockwave.pdfium.PdfDocument;
import java.util.List;
public class PDFViewActivity extends AppCompatActivity implements
OnPageChangeListener, OnLoadCompleteListener, OnPageErrorListener {
private static final String TAG = PDFViewActivity.class.getSimpleName();
private static final int PERMISSION_CODE = 42042;
private static final String SAMPLE_FILE = "sample.pdf";
private static final String READ_EXTERNAL_STORAGE = "android.permission.READ_EXTERNAL_STORAGE";
private PDFView pdfView;
private Uri uri;
private int pageNumber = 0;
private String pdfFileName;
private final ActivityResultLauncher filePickerLauncher =
registerForActivityResult(new ActivityResultContracts.StartActivityForResult(), result -> {
if (result.getResultCode() == RESULT_OK && result.getData() != null) {
uri = result.getData().getData();
displayFromUri(uri);
}
});
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
pdfView = findViewById(R.id.pdfView);
pdfView.setBackgroundColor(Color.LTGRAY);
if (uri != null) {
displayFromUri(uri);
} else {
displayFromAsset(SAMPLE_FILE);
}
}
private void pickFile() {
int permissionCheck = ContextCompat.checkSelfPermission(this, READ_EXTERNAL_STORAGE);
if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this, new String[]{READ_EXTERNAL_STORAGE}, PERMISSION_CODE);
} else {
launchPicker();
}
}
private void launchPicker() {
Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
intent.setType("application/pdf");
try {
filePickerLauncher.launch(intent);
} catch (ActivityNotFoundException e) {
Toast.makeText(this, R.string.toast_pick_file_error, Toast.LENGTH_SHORT).show();
}
}
private void displayFromAsset(String assetFileName) {
pdfFileName = assetFileName;
pdfView.fromAsset(assetFileName)
.defaultPage(pageNumber)
.onPageChange(this)
.enableAnnotationRendering(true)
.onLoad(this)
.scrollHandle(new DefaultScrollHandle(this))
.spacing(10)
.onPageError(this)
.pageFitPolicy(FitPolicy.BOTH)
.load();
}
private void displayFromUri(Uri uri) {
pdfFileName = getFileName(uri);
pdfView.fromUri(uri)
.defaultPage(pageNumber)
.onPageChange(this)
.enableAnnotationRendering(true)
.onLoad(this)
.scrollHandle(new DefaultScrollHandle(this))
.spacing(10)
.onPageError(this)
.load();
}
private String getFileName(Uri uri) {
String result = null;
if ("content".equals(uri.getScheme())) {
try (Cursor cursor = getContentResolver().query(uri, null, null, null, null)) {
if (cursor != null && cursor.moveToFirst()) {
int nameIndex = cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME);
result = cursor.getString(nameIndex);
}
}
}
if (result == null) {
result = uri.getLastPathSegment();
}
return result;
}
@Override
public void onPageChanged(int page, int pageCount) {
pageNumber = page;
setTitle(String.format("%s %s / %s", pdfFileName, page + 1, pageCount));
}
@Override
public void loadComplete(int nbPages) {
PdfDocument.Meta meta = pdfView.getDocumentMeta();
Log.e(TAG, "title = " + meta.getTitle());
Log.e(TAG, "author = " + meta.getAuthor());
Log.e(TAG, "subject = " + meta.getSubject());
Log.e(TAG, "keywords = " + meta.getKeywords());
Log.e(TAG, "creator = " + meta.getCreator());
Log.e(TAG, "producer = " + meta.getProducer());
Log.e(TAG, "creationDate = " + meta.getCreationDate());
Log.e(TAG, "modDate = " + meta.getModDate());
printBookmarksTree(pdfView.getTableOfContents(), "-");
}
private void printBookmarksTree(List tree, String sep) {
for (PdfDocument.Bookmark b : tree) {
Log.e(TAG, String.format("%s %s, p %d", sep, b.getTitle(), b.getPageIdx()));
if (b.hasChildren()) {
printBookmarksTree(b.getChildren(), sep + "-");
}
}
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
@NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode == PERMISSION_CODE && grantResults.length > 0 &&
grantResults[0] == PackageManager.PERMISSION_GRANTED) {
launchPicker();
}
}
@Override
public void onPageError(int page, Throwable t) {
Log.e(TAG, "Cannot load page " + page, t);
}
}
================================================
FILE: sample/src/main/res/layout/activity_main.xml
================================================
================================================
FILE: sample/src/main/res/menu/options.xml
================================================
================================================
FILE: sample/src/main/res/values/strings.xml
================================================
AndroidPdfViewer demo
Pick file
Unable to pick file. Check status of file manager.
================================================
FILE: sample/src/main/res/values/styles.xml
================================================
================================================
FILE: settings.gradle
================================================
include ':android-pdf-viewer'
include ':sample'