初始化

pdflibrary/.gitignore

+/build
\ No newline at end of file

pdflibrary/build.gradle

+//apply plugin: 'com.android.library'
+plugins {
+    id 'com.android.library'
+    id 'org.jetbrains.kotlin.android'
+}
+android {
+    namespace "com.lonelypluto.pdfviewerlibrary"
+    compileSdk 34
+
+    defaultConfig {
+        minSdk 24
+        targetSdk 34
+
+        ndk {
+            //noinspection ChromeOsAbiSupport
+            abiFilters "arm64-v8a", "armeabi-v7a"
+        }
+
+        sourceSets {
+            main {
+                jniLibs.srcDirs = ['src/main/jniLibs']
+            }
+        }
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation(libs.androidx.appcompat)
+
+//    api 'com.artifex.mupdf:viewer:1.24.9a'
+}
\ No newline at end of file

pdflibrary/proguard-rules.pro

+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
\ No newline at end of file

pdflibrary/src/main/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+   >
+
+</manifest>
\ No newline at end of file

pdflibrary/src/main/java/com/artifex/mupdfdemo/Annotation.java

+package com.artifex.mupdfdemo;
+
+import android.graphics.RectF;
+
+public class Annotation extends RectF {
+    public enum Type {
+        TEXT, LINK, FREETEXT, LINE, SQUARE, CIRCLE, POLYGON, POLYLINE, HIGHLIGHT,
+        UNDERLINE, SQUIGGLY, STRIKEOUT, STAMP, CARET, INK, POPUP, FILEATTACHMENT,
+        SOUND, MOVIE, WIDGET, SCREEN, PRINTERMARK, TRAPNET, WATERMARK, A3D, UNKNOWN
+    }
+
+    public final Type type;
+
+    public Annotation(float x0, float y0, float x1, float y1, int _type) {
+        super(x0, y0, x1, y1);
+        type = _type == -1 ? Type.UNKNOWN : Type.values()[_type];
+    }
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/CancellableAsyncTask.java

+package com.artifex.mupdfdemo;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+
+// Ideally this would be a subclass of AsyncTask, however the cancel() method is final, and cannot
+// be overridden. I felt that having two different, but similar cancel methods was a bad idea.
+public class CancellableAsyncTask<Params, Result>
+{
+	private final AsyncTask<Params, Void, Result> asyncTask;
+	private final CancellableTaskDefinition<Params, Result> ourTask;
+
+	public void onPreExecute()
+	{
+
+	}
+
+	public void onPostExecute(Result result)
+	{
+
+	}
+
+	public CancellableAsyncTask(final CancellableTaskDefinition<Params, Result> task)
+	{
+		if (task == null)
+				throw new IllegalArgumentException();
+
+		this.ourTask = task;
+		asyncTask = new AsyncTask<Params, Void, Result>()
+				{
+					@Override
+					protected Result doInBackground(Params... params)
+					{
+						return task.doInBackground(params);
+					}
+
+					@Override
+					protected void onPreExecute()
+					{
+						CancellableAsyncTask.this.onPreExecute();
+					}
+
+					@Override
+					protected void onPostExecute(Result result)
+					{
+						CancellableAsyncTask.this.onPostExecute(result);
+						task.doCleanup();
+					}
+				};
+	}
+
+	public void cancelAndWait()
+	{
+		this.asyncTask.cancel(true);
+		ourTask.doCancel();
+
+		try
+		{
+			this.asyncTask.get();
+		}
+		catch (InterruptedException e)
+		{
+		}
+		catch (ExecutionException e)
+		{
+		}
+		catch (CancellationException e)
+		{
+		}
+
+		ourTask.doCleanup();
+	}
+
+	public void execute(Params ... params)
+	{
+		asyncTask.execute(params);
+	}
+
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/CancellableTaskDefinition.java

+package com.artifex.mupdfdemo;
+
+public interface CancellableTaskDefinition <Params, Result>
+{
+	public Result doInBackground(Params ... params);
+	public void doCancel();
+	public void doCleanup();
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/ChoosePDFActivity.java

+package com.artifex.mupdfdemo;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+
+import android.app.AlertDialog;
+import android.app.ListActivity;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Environment;
+import android.os.FileObserver;
+import android.os.Handler;
+import android.view.View;
+import android.widget.ListView;
+
+import com.lonelypluto.pdfviewerlibrary.R;
+
+enum Purpose {
+    PickPDF,
+    PickKeyFile
+}
+
+public class ChoosePDFActivity extends ListActivity {
+    static public final String PICK_KEY_FILE = "com.artifex.mupdfdemo.PICK_KEY_FILE";
+    static private File mDirectory;
+    static private Map<String, Integer> mPositions = new HashMap<String, Integer>();
+    private File mParent;
+    private File[] mDirs;
+    private File[] mFiles;
+    private Handler mHandler;
+    private Runnable mUpdateFiles;
+    private ChoosePDFAdapter adapter;
+    private Purpose mPurpose;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mPurpose = PICK_KEY_FILE.equals(getIntent().getAction()) ? Purpose.PickKeyFile : Purpose.PickPDF;
+
+
+        String storageState = Environment.getExternalStorageState();
+
+        if (!Environment.MEDIA_MOUNTED.equals(storageState)
+                && !Environment.MEDIA_MOUNTED_READ_ONLY.equals(storageState)) {
+            AlertDialog.Builder builder = new AlertDialog.Builder(this);
+            builder.setTitle(R.string.no_media_warning);
+            builder.setMessage(R.string.no_media_hint);
+            AlertDialog alert = builder.create();
+            alert.setButton(AlertDialog.BUTTON_POSITIVE, getString(R.string.dismiss),
+                    new OnClickListener() {
+                        public void onClick(DialogInterface dialog, int which) {
+                            finish();
+                        }
+                    });
+            alert.show();
+            return;
+        }
+
+        if (mDirectory == null)
+            mDirectory = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS);
+
+        // Create a list adapter...
+        adapter = new ChoosePDFAdapter(getLayoutInflater());
+        setListAdapter(adapter);
+
+        // ...that is updated dynamically when files are scanned
+        mHandler = new Handler();
+        mUpdateFiles = new Runnable() {
+            public void run() {
+                Resources res = getResources();
+                String appName = "app_name";
+                String version = "1.0";
+                String title = res.getString(R.string.picker_title_App_Ver_Dir);
+                setTitle(String.format(title, appName, version, mDirectory));
+
+                mParent = mDirectory.getParentFile();
+
+                mDirs = mDirectory.listFiles(new FileFilter() {
+
+                    public boolean accept(File file) {
+                        return file.isDirectory();
+                    }
+                });
+                if (mDirs == null)
+                    mDirs = new File[0];
+
+                mFiles = mDirectory.listFiles(new FileFilter() {
+
+                    public boolean accept(File file) {
+                        if (file.isDirectory())
+                            return false;
+                        String fname = file.getName().toLowerCase();
+                        switch (mPurpose) {
+                            case PickPDF:
+                                if (fname.endsWith(".pdf"))
+                                    return true;
+                                if (fname.endsWith(".xps"))
+                                    return true;
+                                if (fname.endsWith(".cbz"))
+                                    return true;
+                                if (fname.endsWith(".epub"))
+                                    return true;
+                                if (fname.endsWith(".png"))
+                                    return true;
+                                if (fname.endsWith(".jpe"))
+                                    return true;
+                                if (fname.endsWith(".jpeg"))
+                                    return true;
+                                if (fname.endsWith(".jpg"))
+                                    return true;
+                                if (fname.endsWith(".jfif"))
+                                    return true;
+                                if (fname.endsWith(".jfif-tbnl"))
+                                    return true;
+                                if (fname.endsWith(".tif"))
+                                    return true;
+                                if (fname.endsWith(".tiff"))
+                                    return true;
+                                return false;
+                            case PickKeyFile:
+                                if (fname.endsWith(".pfx"))
+                                    return true;
+                                return false;
+                            default:
+                                return false;
+                        }
+                    }
+                });
+                if (mFiles == null)
+                    mFiles = new File[0];
+
+                Arrays.sort(mFiles, new Comparator<File>() {
+                    public int compare(File arg0, File arg1) {
+                        return arg0.getName().compareToIgnoreCase(arg1.getName());
+                    }
+                });
+
+                Arrays.sort(mDirs, new Comparator<File>() {
+                    public int compare(File arg0, File arg1) {
+                        return arg0.getName().compareToIgnoreCase(arg1.getName());
+                    }
+                });
+
+                adapter.clear();
+                if (mParent != null)
+                    adapter.add(new ChoosePDFItem(ChoosePDFItem.Type.PARENT, getString(R.string.parent_directory)));
+                for (File f : mDirs)
+                    adapter.add(new ChoosePDFItem(ChoosePDFItem.Type.DIR, f.getName()));
+                for (File f : mFiles)
+                    adapter.add(new ChoosePDFItem(ChoosePDFItem.Type.DOC, f.getName()));
+
+                lastPosition();
+            }
+        };
+
+        // Start initial file scan...
+        mHandler.post(mUpdateFiles);
+
+        // ...and observe the directory and scan files upon changes.
+        FileObserver observer = new FileObserver(mDirectory.getPath(), FileObserver.CREATE | FileObserver.DELETE) {
+            public void onEvent(int event, String path) {
+                mHandler.post(mUpdateFiles);
+            }
+        };
+        observer.startWatching();
+    }
+
+    private void lastPosition() {
+        String p = mDirectory.getAbsolutePath();
+        if (mPositions.containsKey(p))
+            getListView().setSelection(mPositions.get(p));
+    }
+
+    @Override
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        super.onListItemClick(l, v, position, id);
+
+        mPositions.put(mDirectory.getAbsolutePath(), getListView().getFirstVisiblePosition());
+
+        if (position < (mParent == null ? 0 : 1)) {
+            mDirectory = mParent;
+            mHandler.post(mUpdateFiles);
+            return;
+        }
+
+        position -= (mParent == null ? 0 : 1);
+
+        if (position < mDirs.length) {
+            mDirectory = mDirs[position];
+            mHandler.post(mUpdateFiles);
+            return;
+        }
+
+        position -= mDirs.length;
+
+        Uri uri = Uri.fromFile(mFiles[position]);
+        Intent intent = new Intent(this, MuPDFActivity.class);
+        intent.setAction(Intent.ACTION_VIEW);
+        intent.setData(uri);
+        switch (mPurpose) {
+            case PickPDF:
+                // Start an activity to display the PDF file
+                startActivity(intent);
+                break;
+            case PickKeyFile:
+                // Return the uri to the caller
+                setResult(RESULT_OK, intent);
+                finish();
+                break;
+        }
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        if (mDirectory != null)
+            mPositions.put(mDirectory.getAbsolutePath(), getListView().getFirstVisiblePosition());
+    }
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/ChoosePDFAdapter.java

+package com.artifex.mupdfdemo;
+
+import android.graphics.Color;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import com.lonelypluto.pdfviewerlibrary.R;
+
+import java.util.LinkedList;
+
+public class ChoosePDFAdapter extends BaseAdapter {
+    private final LinkedList<ChoosePDFItem> mItems;
+    private final LayoutInflater mInflater;
+
+    public ChoosePDFAdapter(LayoutInflater inflater) {
+        mInflater = inflater;
+        mItems = new LinkedList<ChoosePDFItem>();
+    }
+
+    public void clear() {
+        mItems.clear();
+    }
+
+    public void add(ChoosePDFItem item) {
+        mItems.add(item);
+        notifyDataSetChanged();
+    }
+
+    public int getCount() {
+        return mItems.size();
+    }
+
+    public Object getItem(int i) {
+        return null;
+    }
+
+    public long getItemId(int arg0) {
+        return 0;
+    }
+
+    private int iconForType(ChoosePDFItem.Type type) {
+        switch (type) {
+            case PARENT:
+                return R.drawable.ic_arrow_up;
+            case DIR:
+                return R.drawable.ic_dir;
+            case DOC:
+                return R.drawable.ic_doc;
+            default:
+                return 0;
+        }
+    }
+
+    public View getView(int position, View convertView, ViewGroup parent) {
+        View v;
+        if (convertView == null) {
+            v = mInflater.inflate(R.layout.picker_entry, null);
+        } else {
+            v = convertView;
+        }
+        ChoosePDFItem item = mItems.get(position);
+        ((TextView) v.findViewById(R.id.name)).setText(item.name);
+        ((ImageView) v.findViewById(R.id.icon)).setImageResource(iconForType(item.type));
+        ((ImageView) v.findViewById(R.id.icon)).setColorFilter(Color.argb(255, 0, 0, 0));
+        return v;
+    }
+
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/ChoosePDFItem.java

+package com.artifex.mupdfdemo;
+
+public class ChoosePDFItem {
+	enum Type {
+		PARENT, DIR, DOC
+	}
+
+	final public Type type;
+	final public String name;
+
+	public ChoosePDFItem (Type t, String n) {
+		type = t;
+		name = n;
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/FilePicker.java

+package com.artifex.mupdfdemo;
+
+import android.net.Uri;
+
+public abstract class FilePicker {
+	public interface FilePickerSupport {
+		void performPickFor(FilePicker picker);
+	}
+
+	private final FilePickerSupport support;
+
+	FilePicker(FilePickerSupport _support) {
+		support = _support;
+	}
+
+	void pick() {
+		support.performPickFor(this);
+	}
+
+	abstract void onPick(Uri uri);
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/Hit.java

+package com.artifex.mupdfdemo;
+
+public enum Hit {
+    Nothing, Widget, Annotation
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/LinkInfo.java

+package com.artifex.mupdfdemo;
+
+import android.graphics.RectF;
+
+public class LinkInfo {
+	final public RectF rect;
+
+	public LinkInfo(float l, float t, float r, float b) {
+		rect = new RectF(l, t, r, b);
+	}
+
+	public void acceptVisitor(LinkInfoVisitor visitor) {
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/LinkInfoExternal.java

+package com.artifex.mupdfdemo;
+
+public class LinkInfoExternal extends LinkInfo {
+	final public String url;
+
+	public LinkInfoExternal(float l, float t, float r, float b, String u) {
+		super(l, t, r, b);
+		url = u;
+	}
+
+	public void acceptVisitor(LinkInfoVisitor visitor) {
+		visitor.visitExternal(this);
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/LinkInfoInternal.java

+package com.artifex.mupdfdemo;
+
+public class LinkInfoInternal extends LinkInfo {
+	final public int pageNumber;
+
+	public LinkInfoInternal(float l, float t, float r, float b, int p) {
+		super(l, t, r, b);
+		pageNumber = p;
+	}
+
+	public void acceptVisitor(LinkInfoVisitor visitor) {
+		visitor.visitInternal(this);
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/LinkInfoRemote.java

+package com.artifex.mupdfdemo;
+
+public class LinkInfoRemote extends LinkInfo {
+	final public String fileSpec;
+	final public int pageNumber;
+	final public boolean newWindow;
+
+	public LinkInfoRemote(float l, float t, float r, float b, String f, int p, boolean n) {
+		super(l, t, r, b);
+		fileSpec = f;
+		pageNumber = p;
+		newWindow = n;
+	}
+
+	public void acceptVisitor(LinkInfoVisitor visitor) {
+		visitor.visitRemote(this);
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/LinkInfoVisitor.java

+package com.artifex.mupdfdemo;
+
+abstract public class LinkInfoVisitor {
+	public abstract void visitInternal(LinkInfoInternal li);
+	public abstract void visitExternal(LinkInfoExternal li);
+	public abstract void visitRemote(LinkInfoRemote li);
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/MuPDFAlert.java

+package com.artifex.mupdfdemo;
+
+public class MuPDFAlert {
+	public enum IconType {Error,Warning,Question,Status};
+	public enum ButtonPressed {None,Ok,Cancel,No,Yes};
+	public enum ButtonGroupType {Ok,OkCancel,YesNo,YesNoCancel};
+
+	public final String message;
+	public final IconType iconType;
+	public final ButtonGroupType buttonGroupType;
+	public final String title;
+	public ButtonPressed buttonPressed;
+
+	MuPDFAlert(String aMessage, IconType aIconType, ButtonGroupType aButtonGroupType, String aTitle, ButtonPressed aButtonPressed) {
+		message = aMessage;
+		iconType = aIconType;
+		buttonGroupType = aButtonGroupType;
+		title = aTitle;
+		buttonPressed = aButtonPressed;
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/MuPDFAlertInternal.java

+package com.artifex.mupdfdemo;
+
+// Version of MuPDFAlert without enums to simplify JNI
+public class MuPDFAlertInternal {
+	public final String message;
+	public final int iconType;
+	public final int buttonGroupType;
+	public final String title;
+	public int buttonPressed;
+
+	MuPDFAlertInternal(String aMessage, int aIconType, int aButtonGroupType, String aTitle, int aButtonPressed) {
+		message = aMessage;
+		iconType = aIconType;
+		buttonGroupType = aButtonGroupType;
+		title = aTitle;
+		buttonPressed = aButtonPressed;
+	}
+
+	MuPDFAlertInternal(MuPDFAlert alert) {
+		message = alert.message;
+		iconType = alert.iconType.ordinal();
+		buttonGroupType = alert.buttonGroupType.ordinal();
+		title = alert.message;
+		buttonPressed = alert.buttonPressed.ordinal();
+	}
+
+	MuPDFAlert toAlert() {
+		return new MuPDFAlert(message, MuPDFAlert.IconType.values()[iconType], MuPDFAlert.ButtonGroupType.values()[buttonGroupType], title, MuPDFAlert.ButtonPressed.values()[buttonPressed]);
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/MuPDFCancellableTaskDefinition.java

+package com.artifex.mupdfdemo;
+
+public abstract class MuPDFCancellableTaskDefinition<Params, Result> implements CancellableTaskDefinition<Params, Result>
+{
+	private MuPDFCore.Cookie cookie;
+
+	public MuPDFCancellableTaskDefinition(MuPDFCore core)
+	{
+		this.cookie = core.new Cookie();
+	}
+
+	@Override
+	public void doCancel()
+	{
+		if (cookie == null)
+			return;
+
+		cookie.abort();
+	}
+
+	@Override
+	public void doCleanup()
+	{
+		if (cookie == null)
+			return;
+
+		cookie.destroy();
+		cookie = null;
+	}
+
+	@Override
+	public final Result doInBackground(Params ... params)
+	{
+		return doInBackground(cookie, params);
+	}
+
+	public abstract Result doInBackground(MuPDFCore.Cookie cookie, Params ... params);
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/MuPDFPageAdapter.java

+package com.artifex.mupdfdemo;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.util.SparseArray;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+
+public class MuPDFPageAdapter extends BaseAdapter {
+	private final Context mContext;
+	private final FilePicker.FilePickerSupport mFilePickerSupport;
+	private final MuPDFCore mCore;
+	private final SparseArray<PointF> mPageSizes = new SparseArray<PointF>();
+	private       Bitmap mSharedHqBm;
+
+	public MuPDFPageAdapter(Context c, FilePicker.FilePickerSupport filePickerSupport, MuPDFCore core) {
+		mContext = c;
+		mFilePickerSupport = filePickerSupport;
+		mCore = core;
+	}
+
+	public int getCount() {
+		return mCore.countPages();
+	}
+
+	public Object getItem(int position) {
+		return null;
+	}
+
+	public long getItemId(int position) {
+		return 0;
+	}
+
+	public void releaseBitmaps()
+	{
+		//  recycle and release the shared bitmap.
+		if (mSharedHqBm!=null)
+			mSharedHqBm.recycle();
+		mSharedHqBm = null;
+	}
+
+	public View getView(final int position, View convertView, ViewGroup parent) {
+		final MuPDFPageView pageView;
+		if (convertView == null) {
+			if (mSharedHqBm == null || mSharedHqBm.getWidth() != parent.getWidth() || mSharedHqBm.getHeight() != parent.getHeight())
+				mSharedHqBm = Bitmap.createBitmap(parent.getWidth(), parent.getHeight(), Bitmap.Config.ARGB_8888);
+
+			pageView = new MuPDFPageView(mContext, mFilePickerSupport, mCore, new Point(parent.getWidth(), parent.getHeight()), mSharedHqBm);
+		} else {
+			pageView = (MuPDFPageView) convertView;
+		}
+
+		PointF pageSize = mPageSizes.get(position);
+		if (pageSize != null) {
+			// We already know the page size. Set it up
+			// immediately
+			pageView.setPage(position, pageSize);
+		} else {
+			// Page size as yet unknown. Blank it for now, and
+			// start a background task to find the size
+			pageView.blank(position);
+			AsyncTask<Void,Void,PointF> sizingTask = new AsyncTask<Void,Void,PointF>() {
+				@Override
+				protected PointF doInBackground(Void... arg0) {
+					return mCore.getPageSize(position);
+				}
+
+				@Override
+				protected void onPostExecute(PointF result) {
+					super.onPostExecute(result);
+					// We now know the page size
+					mPageSizes.put(position, result);
+					// Check that this view hasn't been reused for
+					// another page since we started
+					if (pageView.getPage() == position)
+						pageView.setPage(position, result);
+				}
+			};
+
+			sizingTask.execute((Void)null);
+		}
+		return pageView;
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/MuPDFReaderViewListener.java

+package com.artifex.mupdfdemo;
+
+public interface MuPDFReaderViewListener {
+    void onMoveToChild(int i);
+
+    void onTapMainDocArea();
+
+    void onDocMotion();
+
+    void onHit(Hit item);
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/MuPDFReflowAdapter.java

+package com.artifex.mupdfdemo;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+
+public class MuPDFReflowAdapter extends BaseAdapter {
+	private final Context mContext;
+	private final MuPDFCore mCore;
+
+	public MuPDFReflowAdapter(Context c, MuPDFCore core) {
+		mContext = c;
+		mCore = core;
+	}
+
+	public int getCount() {
+		return mCore.countPages();
+	}
+
+	public Object getItem(int arg0) {
+		return null;
+	}
+
+	public long getItemId(int arg0) {
+		return 0;
+	}
+
+	public View getView(int position, View convertView, ViewGroup parent) {
+		final MuPDFReflowView reflowView;
+		if (convertView == null) {
+			reflowView = new MuPDFReflowView(mContext, mCore, new Point(parent.getWidth(), parent.getHeight()));
+		} else {
+			reflowView = (MuPDFReflowView) convertView;
+		}
+
+		reflowView.setPage(position, new PointF());
+
+		return reflowView;
+	}
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/MuPDFReflowView.java

+package com.artifex.mupdfdemo;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.graphics.PointF;
+import android.graphics.RectF;
+import android.os.Handler;
+import android.util.Base64;
+import android.view.MotionEvent;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+
+public class MuPDFReflowView extends WebView implements MuPDFView {
+    private final MuPDFCore mCore;
+    private final Handler mHandler;
+    private final Point mParentSize;
+    private int mPage;
+    private float mScale;
+    private int mContentHeight;
+    AsyncTask<Void, Void, byte[]> mLoadHTML;
+
+    public MuPDFReflowView(Context c, MuPDFCore core, Point parentSize) {
+        super(c);
+        mHandler = new Handler();
+        mCore = core;
+        mParentSize = parentSize;
+        mScale = 1.0f;
+        mContentHeight = parentSize.y;
+        getSettings().setJavaScriptEnabled(true);
+        addJavascriptInterface(new Object() {
+            public void reportContentHeight(String value) {
+                mContentHeight = (int) Float.parseFloat(value);
+                mHandler.post(new Runnable() {
+                    public void run() {
+                        requestLayout();
+                    }
+                });
+            }
+        }, "HTMLOUT");
+        setWebViewClient(new WebViewClient() {
+            @Override
+            public void onPageFinished(WebView view, String url) {
+                setScale(mScale);
+            }
+        });
+    }
+
+    private void requestHeight() {
+        // Get the webview to report the content height via the interface setup
+        // above. Workaround for getContentHeight not working
+        loadUrl("javascript:elem=document.getElementById('content');window.HTMLOUT.reportContentHeight(" + mParentSize.x + "*elem.offsetHeight/elem.offsetWidth)");
+    }
+
+    public void setPage(int page, PointF size) {
+        mPage = page;
+        if (mLoadHTML != null) {
+            mLoadHTML.cancel(true);
+        }
+        mLoadHTML = new AsyncTask<Void, Void, byte[]>() {
+            @Override
+            protected byte[] doInBackground(Void... params) {
+                return mCore.html(mPage);
+            }
+
+            @Override
+            protected void onPostExecute(byte[] result) {
+                String b64 = Base64.encodeToString(result, Base64.DEFAULT);
+                loadData(b64, "text/html; charset=utf-8", "base64");
+            }
+        };
+        mLoadHTML.execute();
+    }
+
+    public int getPage() {
+        return mPage;
+    }
+
+    public void setScale(float scale) {
+        mScale = scale;
+        loadUrl("javascript:document.getElementById('content').style.zoom=\"" + (int) (mScale * 100) + "%\"");
+        requestHeight();
+    }
+
+    public void blank(int page) {
+    }
+
+    public Hit passClickEvent(float x, float y) {
+        return Hit.Nothing;
+    }
+
+    public LinkInfo hitLink(float x, float y) {
+        return null;
+    }
+
+    public void selectText(float x0, float y0, float x1, float y1) {
+    }
+
+    public void deselectText() {
+    }
+
+    public boolean copySelection() {
+        return false;
+    }
+
+    public boolean markupSelection(Annotation.Type type) {
+        return false;
+    }
+
+    public void startDraw(float x, float y) {
+    }
+
+    public void continueDraw(float x, float y) {
+    }
+
+    public void cancelDraw() {
+    }
+
+    public boolean saveDraw() {
+        return false;
+    }
+
+    public void setSearchBoxes(RectF[] searchBoxes) {
+    }
+
+    public void setLinkHighlighting(boolean f) {
+    }
+
+    public void deleteSelectedAnnotation() {
+    }
+
+    public void deselectAnnotation() {
+    }
+
+    public void setChangeReporter(Runnable reporter) {
+    }
+
+    public void update() {
+    }
+
+    public void updateHq(boolean update) {
+    }
+
+    public void removeHq() {
+    }
+
+    public void releaseResources() {
+        if (mLoadHTML != null) {
+            mLoadHTML.cancel(true);
+            mLoadHTML = null;
+        }
+    }
+
+    public void releaseBitmaps() {
+    }
+
+    @Override
+    public void setLinkHighlightColor(int color) {
+
+    }
+
+    @Override
+    public void setInkColor(int color) {
+
+    }
+
+    @Override
+    public void setPaintStrockWidth(float inkThickness) {
+
+    }
+
+    @Override
+    public float getCurrentScale() {
+        return 0;
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        int x, y;
+        switch (MeasureSpec.getMode(widthMeasureSpec)) {
+            case MeasureSpec.UNSPECIFIED:
+                x = mParentSize.x;
+                break;
+            default:
+                x = MeasureSpec.getSize(widthMeasureSpec);
+        }
+        switch (MeasureSpec.getMode(heightMeasureSpec)) {
+            case MeasureSpec.UNSPECIFIED:
+                y = mContentHeight;
+                break;
+            default:
+                y = MeasureSpec.getSize(heightMeasureSpec);
+        }
+
+        setMeasuredDimension(x, y);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+}

pdflibrary/src/main/java/com/artifex/mupdfdemo/OutlineActivityData.java

+package com.artifex.mupdfdemo;
+
+public class OutlineActivityData {
+	public OutlineItem items[];
+	public int         position;
+	static private OutlineActivityData singleton;
+
+	static public void set(OutlineActivityData d) {
+		singleton = d;
+	}
+
+	static public OutlineActivityData get() {
+		if (singleton == null)
+			singleton = new OutlineActivityData();
+		return singleton;
+	}
+}