\nandroid.useDeprecatedNdk=true"
},
{
"path": "proguard-rules.pro",
"content": "# Add project specific ProGuard rules here.\n# By default, the flags in this file are appended to flags specified\n# in /Applications/android-sdk-macosx/tools/proguard/proguard-android.txt\n# You can edit the include path and order by changing the proguardFiles\n# directive in build.gradle.\n#\n# For more details, see\n# http://developer.android.com/guide/developing/tools/proguard.html\n\n# Add any project specific keep options here:\n\n# If your project uses WebView with JS, uncomment the following\n# and specify the fully qualified class name to the JavaScript interface\n# class:\n#-keepclassmembers class fqcn.of.javascript.interface.for.webview {\n# public *;\n#}\n"
},
{
"path": "src/androidTest/java/com/artifex/viafirma/mupdf/ApplicationTest.java",
"content": "package com.artifex.viafirma.mupdf;\n\nimport android.app.Application;\nimport android.test.ApplicationTestCase;\n\n/**\n * Testing Fundamentals\n */\npublic class ApplicationTest extends ApplicationTestCase {\n public ApplicationTest() {\n super(Application.class);\n }\n}"
},
{
"path": "src/main/AndroidManifest.xml",
"content": "\n\n \n \n \n\n \n\n \n\n\n"
},
{
"path": "src/main/java/com/artifex/mupdfdemo/Annotation.java",
"content": "package com.artifex.mupdfdemo;\n\nimport android.graphics.RectF;\n\npublic class Annotation extends RectF {\n\tenum Type {\n\t\tTEXT, LINK, FREETEXT, LINE, SQUARE, CIRCLE, POLYGON, POLYLINE, HIGHLIGHT,\n\t\tUNDERLINE, SQUIGGLY, STRIKEOUT, STAMP, CARET, INK, POPUP, FILEATTACHMENT,\n\t\tSOUND, MOVIE, WIDGET, SCREEN, PRINTERMARK, TRAPNET, WATERMARK, A3D, UNKNOWN\n\t}\n\n\tpublic final Type type;\n\n\tpublic Annotation(float x0, float y0, float x1, float y1, int _type) {\n\t\tsuper(x0, y0, x1, y1);\n\t\ttype = _type == -1 ? Type.UNKNOWN : Type.values()[_type];\n\t}\n}\n"
},
{
"path": "src/main/java/com/artifex/mupdfdemo/ArrayDeque.java",
"content": "/*\n * Written by Josh Bloch of Google Inc. and released to the public domain,\n * as explained at http://creativecommons.org/publicdomain/zero/1.0/.\n */\n\npackage com.artifex.mupdfdemo;\n\nimport java.util.AbstractCollection;\nimport java.util.Arrays;\nimport java.util.Collection;\nimport java.util.ConcurrentModificationException;\nimport java.util.Iterator;\nimport java.util.LinkedList;\nimport java.util.List;\nimport java.util.NoSuchElementException;\nimport java.util.Queue;\nimport java.util.Stack;\n\n// BEGIN android-note\n// removed link to collections framework docs\n// END android-note\n\n/**\n * Resizable-array implementation of the {@link Deque} interface. Array\n * deques have no capacity restrictions; they grow as necessary to support\n * usage. They are not thread-safe; in the absence of external\n * synchronization, they do not support concurrent access by multiple threads.\n * Null elements are prohibited. This class is likely to be faster than\n * {@link java.util.Stack} when used as a stack, and faster than {@link java.util.LinkedList}\n * when used as a queue.\n *\n * Most ArrayDeque operations run in amortized constant time.\n * Exceptions include {@link #remove(Object) remove}, {@link\n * #removeFirstOccurrence removeFirstOccurrence}, {@link #removeLastOccurrence\n * removeLastOccurrence}, {@link #contains contains}, {@link #iterator\n * iterator.remove()}, and the bulk operations, all of which run in linear\n * time.\n *\n *
The iterators returned by this class's iterator method are\n * fail-fast: If the deque is modified at any time after the iterator\n * is created, in any way except through the iterator's own remove\n * method, the iterator will generally throw a {@link\n * java.util.ConcurrentModificationException}. Thus, in the face of concurrent\n * modification, the iterator fails quickly and cleanly, rather than risking\n * arbitrary, non-deterministic behavior at an undetermined time in the\n * future.\n *\n *
Note that the fail-fast behavior of an iterator cannot be guaranteed\n * as it is, generally speaking, impossible to make any hard guarantees in the\n * presence of unsynchronized concurrent modification. Fail-fast iterators\n * throw ConcurrentModificationException on a best-effort basis.\n * Therefore, it would be wrong to write a program that depended on this\n * exception for its correctness: the fail-fast behavior of iterators\n * should be used only to detect bugs.\n *\n *
This class and its iterator implement all of the\n * optional methods of the {@link java.util.Collection} and {@link\n * java.util.Iterator} interfaces.\n *\n * @author Josh Bloch and Doug Lea\n * @since 1.6\n * @param the type of elements held in this collection\n */\npublic class ArrayDeque extends AbstractCollection\n implements Deque, Cloneable, java.io.Serializable\n{\n /**\n * The array in which the elements of the deque are stored.\n * The capacity of the deque is the length of this array, which is\n * always a power of two. The array is never allowed to become\n * full, except transiently within an addX method where it is\n * resized (see doubleCapacity) immediately upon becoming full,\n * thus avoiding head and tail wrapping around to equal each\n * other. We also guarantee that all array cells not holding\n * deque elements are always null.\n */\n private transient Object[] elements;\n\n /**\n * The index of the element at the head of the deque (which is the\n * element that would be removed by remove() or pop()); or an\n * arbitrary number equal to tail if the deque is empty.\n */\n private transient int head;\n\n /**\n * The index at which the next element would be added to the tail\n * of the deque (via addLast(E), add(E), or push(E)).\n */\n private transient int tail;\n\n /**\n * The minimum capacity that we'll use for a newly created deque.\n * Must be a power of 2.\n */\n private static final int MIN_INITIAL_CAPACITY = 8;\n\n // ****** Array allocation and resizing utilities ******\n\n /**\n * Allocate empty array to hold the given number of elements.\n *\n * @param numElements the number of elements to hold\n */\n private void allocateElements(int numElements) {\n int initialCapacity = MIN_INITIAL_CAPACITY;\n // Find the best power of two to hold elements.\n // Tests \"<=\" because arrays aren't kept full.\n if (numElements >= initialCapacity) {\n initialCapacity = numElements;\n initialCapacity |= (initialCapacity >>> 1);\n initialCapacity |= (initialCapacity >>> 2);\n initialCapacity |= (initialCapacity >>> 4);\n initialCapacity |= (initialCapacity >>> 8);\n initialCapacity |= (initialCapacity >>> 16);\n initialCapacity++;\n\n if (initialCapacity < 0) // Too many elements, must back off\n initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements\n }\n elements = new Object[initialCapacity];\n }\n\n /**\n * Double the capacity of this deque. Call only when full, i.e.,\n * when head and tail have wrapped around to become equal.\n */\n private void doubleCapacity() {\n // assert head == tail;\n int p = head;\n int n = elements.length;\n int r = n - p; // number of elements to the right of p\n int newCapacity = n << 1;\n if (newCapacity < 0)\n throw new IllegalStateException(\"Sorry, deque too big\");\n Object[] a = new Object[newCapacity];\n System.arraycopy(elements, p, a, 0, r);\n System.arraycopy(elements, 0, a, r, p);\n elements = a;\n head = 0;\n tail = n;\n }\n\n /**\n * Copies the elements from our element array into the specified array,\n * in order (from first to last element in the deque). It is assumed\n * that the array is large enough to hold all elements in the deque.\n *\n * @return its argument\n */\n private T[] copyElements(T[] a) {\n if (head < tail) {\n System.arraycopy(elements, head, a, 0, size());\n } else if (head > tail) {\n int headPortionLen = elements.length - head;\n System.arraycopy(elements, head, a, 0, headPortionLen);\n System.arraycopy(elements, 0, a, headPortionLen, tail);\n }\n return a;\n }\n\n /**\n * Constructs an empty array deque with an initial capacity\n * sufficient to hold 16 elements.\n */\n public ArrayDeque() {\n elements = new Object[16];\n }\n\n /**\n * Constructs an empty array deque with an initial capacity\n * sufficient to hold the specified number of elements.\n *\n * @param numElements lower bound on initial capacity of the deque\n */\n public ArrayDeque(int numElements) {\n allocateElements(numElements);\n }\n\n /**\n * Constructs a deque containing the elements of the specified\n * collection, in the order they are returned by the collection's\n * iterator. (The first element returned by the collection's\n * iterator becomes the first element, or front of the\n * deque.)\n *\n * @param c the collection whose elements are to be placed into the deque\n * @throws NullPointerException if the specified collection is null\n */\n public ArrayDeque(Collection c) {\n allocateElements(c.size());\n addAll(c);\n }\n\n // The main insertion and extraction methods are addFirst,\n // addLast, pollFirst, pollLast. The other methods are defined in\n // terms of these.\n\n /**\n * Inserts the specified element at the front of this deque.\n *\n * @param e the element to add\n * @throws NullPointerException if the specified element is null\n */\n public void addFirst(E e) {\n if (e == null)\n throw new NullPointerException(\"e == null\");\n elements[head = (head - 1) & (elements.length - 1)] = e;\n if (head == tail)\n doubleCapacity();\n }\n\n /**\n * Inserts the specified element at the end of this deque.\n *\n * This method is equivalent to {@link #add}.\n *\n * @param e the element to add\n * @throws NullPointerException if the specified element is null\n */\n public void addLast(E e) {\n if (e == null)\n throw new NullPointerException(\"e == null\");\n elements[tail] = e;\n if ( (tail = (tail + 1) & (elements.length - 1)) == head)\n doubleCapacity();\n }\n\n /**\n * Inserts the specified element at the front of this deque.\n *\n * @param e the element to add\n * @return true (as specified by {@link Deque#offerFirst})\n * @throws NullPointerException if the specified element is null\n */\n public boolean offerFirst(E e) {\n addFirst(e);\n return true;\n }\n\n /**\n * Inserts the specified element at the end of this deque.\n *\n * @param e the element to add\n * @return true (as specified by {@link Deque#offerLast})\n * @throws NullPointerException if the specified element is null\n */\n public boolean offerLast(E e) {\n addLast(e);\n return true;\n }\n\n /**\n * @throws java.util.NoSuchElementException {@inheritDoc}\n */\n public E removeFirst() {\n E x = pollFirst();\n if (x == null)\n throw new NoSuchElementException();\n return x;\n }\n\n /**\n * @throws java.util.NoSuchElementException {@inheritDoc}\n */\n public E removeLast() {\n E x = pollLast();\n if (x == null)\n throw new NoSuchElementException();\n return x;\n }\n\n public E pollFirst() {\n int h = head;\n @SuppressWarnings(\"unchecked\") E result = (E) elements[h];\n // Element is null if deque empty\n if (result == null)\n return null;\n elements[h] = null; // Must null out slot\n head = (h + 1) & (elements.length - 1);\n return result;\n }\n\n public E pollLast() {\n int t = (tail - 1) & (elements.length - 1);\n @SuppressWarnings(\"unchecked\") E result = (E) elements[t];\n if (result == null)\n return null;\n elements[t] = null;\n tail = t;\n return result;\n }\n\n /**\n * @throws java.util.NoSuchElementException {@inheritDoc}\n */\n public E getFirst() {\n @SuppressWarnings(\"unchecked\") E result = (E) elements[head];\n if (result == null)\n throw new NoSuchElementException();\n return result;\n }\n\n /**\n * @throws java.util.NoSuchElementException {@inheritDoc}\n */\n public E getLast() {\n @SuppressWarnings(\"unchecked\")\n E result = (E) elements[(tail - 1) & (elements.length - 1)];\n if (result == null)\n throw new NoSuchElementException();\n return result;\n }\n\n public E peekFirst() {\n @SuppressWarnings(\"unchecked\") E result = (E) elements[head];\n // elements[head] is null if deque empty\n return result;\n }\n\n public E peekLast() {\n @SuppressWarnings(\"unchecked\")\n E result = (E) elements[(tail - 1) & (elements.length - 1)];\n return result;\n }\n\n /**\n * Removes the first occurrence of the specified element in this\n * deque (when traversing the deque from head to tail).\n * If the deque does not contain the element, it is unchanged.\n * More formally, removes the first element e such that\n * o.equals(e) (if such an element exists).\n * Returns true if this deque contained the specified element\n * (or equivalently, if this deque changed as a result of the call).\n *\n * @param o element to be removed from this deque, if present\n * @return true if the deque contained the specified element\n */\n public boolean removeFirstOccurrence(Object o) {\n if (o == null)\n return false;\n int mask = elements.length - 1;\n int i = head;\n Object x;\n while ( (x = elements[i]) != null) {\n if (o.equals(x)) {\n delete(i);\n return true;\n }\n i = (i + 1) & mask;\n }\n return false;\n }\n\n /**\n * Removes the last occurrence of the specified element in this\n * deque (when traversing the deque from head to tail).\n * If the deque does not contain the element, it is unchanged.\n * More formally, removes the last element e such that\n * o.equals(e) (if such an element exists).\n * Returns true if this deque contained the specified element\n * (or equivalently, if this deque changed as a result of the call).\n *\n * @param o element to be removed from this deque, if present\n * @return true if the deque contained the specified element\n */\n public boolean removeLastOccurrence(Object o) {\n if (o == null)\n return false;\n int mask = elements.length - 1;\n int i = (tail - 1) & mask;\n Object x;\n while ( (x = elements[i]) != null) {\n if (o.equals(x)) {\n delete(i);\n return true;\n }\n i = (i - 1) & mask;\n }\n return false;\n }\n\n // *** Queue methods ***\n\n /**\n * Inserts the specified element at the end of this deque.\n *\n *
This method is equivalent to {@link #addLast}.\n *\n * @param e the element to add\n * @return true (as specified by {@link java.util.Collection#add})\n * @throws NullPointerException if the specified element is null\n */\n public boolean add(E e) {\n addLast(e);\n return true;\n }\n\n /**\n * Inserts the specified element at the end of this deque.\n *\n *
This method is equivalent to {@link #offerLast}.\n *\n * @param e the element to add\n * @return true (as specified by {@link java.util.Queue#offer})\n * @throws NullPointerException if the specified element is null\n */\n public boolean offer(E e) {\n return offerLast(e);\n }\n\n /**\n * Retrieves and removes the head of the queue represented by this deque.\n *\n * This method differs from {@link #poll poll} only in that it throws an\n * exception if this deque is empty.\n *\n *
This method is equivalent to {@link #removeFirst}.\n *\n * @return the head of the queue represented by this deque\n * @throws java.util.NoSuchElementException {@inheritDoc}\n */\n public E remove() {\n return removeFirst();\n }\n\n /**\n * Retrieves and removes the head of the queue represented by this deque\n * (in other words, the first element of this deque), or returns\n * null if this deque is empty.\n *\n *
This method is equivalent to {@link #pollFirst}.\n *\n * @return the head of the queue represented by this deque, or\n * null if this deque is empty\n */\n public E poll() {\n return pollFirst();\n }\n\n /**\n * Retrieves, but does not remove, the head of the queue represented by\n * this deque. This method differs from {@link #peek peek} only in\n * that it throws an exception if this deque is empty.\n *\n *
This method is equivalent to {@link #getFirst}.\n *\n * @return the head of the queue represented by this deque\n * @throws java.util.NoSuchElementException {@inheritDoc}\n */\n public E element() {\n return getFirst();\n }\n\n /**\n * Retrieves, but does not remove, the head of the queue represented by\n * this deque, or returns null if this deque is empty.\n *\n *
This method is equivalent to {@link #peekFirst}.\n *\n * @return the head of the queue represented by this deque, or\n * null if this deque is empty\n */\n public E peek() {\n return peekFirst();\n }\n\n // *** Stack methods ***\n\n /**\n * Pushes an element onto the stack represented by this deque. In other\n * words, inserts the element at the front of this deque.\n *\n *
This method is equivalent to {@link #addFirst}.\n *\n * @param e the element to push\n * @throws NullPointerException if the specified element is null\n */\n public void push(E e) {\n addFirst(e);\n }\n\n /**\n * Pops an element from the stack represented by this deque. In other\n * words, removes and returns the first element of this deque.\n *\n *
This method is equivalent to {@link #removeFirst()}.\n *\n * @return the element at the front of this deque (which is the top\n * of the stack represented by this deque)\n * @throws java.util.NoSuchElementException {@inheritDoc}\n */\n public E pop() {\n return removeFirst();\n }\n\n private void checkInvariants() {\n // assert elements[tail] == null;\n // assert head == tail ? elements[head] == null :\n // (elements[head] != null &&\n // elements[(tail - 1) & (elements.length - 1)] != null);\n // assert elements[(head - 1) & (elements.length - 1)] == null;\n }\n\n /**\n * Removes the element at the specified position in the elements array,\n * adjusting head and tail as necessary. This can result in motion of\n * elements backwards or forwards in the array.\n *\n *
This method is called delete rather than remove to emphasize\n * that its semantics differ from those of {@link java.util.List#remove(int)}.\n *\n * @return true if elements moved backwards\n */\n private boolean delete(int i) {\n //checkInvariants();\n final Object[] elements = this.elements;\n final int mask = elements.length - 1;\n final int h = head;\n final int t = tail;\n final int front = (i - h) & mask;\n final int back = (t - i) & mask;\n\n // Invariant: head <= i < tail mod circularity\n if (front >= ((t - h) & mask))\n throw new ConcurrentModificationException();\n\n // Optimize for least element motion\n if (front < back) {\n if (h <= i) {\n System.arraycopy(elements, h, elements, h + 1, front);\n } else { // Wrap around\n System.arraycopy(elements, 0, elements, 1, i);\n elements[0] = elements[mask];\n System.arraycopy(elements, h, elements, h + 1, mask - h);\n }\n elements[h] = null;\n head = (h + 1) & mask;\n return false;\n } else {\n if (i < t) { // Copy the null tail as well\n System.arraycopy(elements, i + 1, elements, i, back);\n tail = t - 1;\n } else { // Wrap around\n System.arraycopy(elements, i + 1, elements, i, mask - i);\n elements[mask] = elements[0];\n System.arraycopy(elements, 1, elements, 0, t);\n tail = (t - 1) & mask;\n }\n return true;\n }\n }\n\n // *** Collection Methods ***\n\n /**\n * Returns the number of elements in this deque.\n *\n * @return the number of elements in this deque\n */\n public int size() {\n return (tail - head) & (elements.length - 1);\n }\n\n /**\n * Returns true if this deque contains no elements.\n *\n * @return true if this deque contains no elements\n */\n public boolean isEmpty() {\n return head == tail;\n }\n\n /**\n * Returns an iterator over the elements in this deque. The elements\n * will be ordered from first (head) to last (tail). This is the same\n * order that elements would be dequeued (via successive calls to\n * {@link #remove} or popped (via successive calls to {@link #pop}).\n *\n * @return an iterator over the elements in this deque\n */\n public Iterator iterator() {\n return new DeqIterator();\n }\n\n public Iterator descendingIterator() {\n return new DescendingIterator();\n }\n\n private class DeqIterator implements Iterator {\n /**\n * Index of element to be returned by subsequent call to next.\n */\n private int cursor = head;\n\n /**\n * Tail recorded at construction (also in remove), to stop\n * iterator and also to check for comodification.\n */\n private int fence = tail;\n\n /**\n * Index of element returned by most recent call to next.\n * Reset to -1 if element is deleted by a call to remove.\n */\n private int lastRet = -1;\n\n public boolean hasNext() {\n return cursor != fence;\n }\n\n public E next() {\n if (cursor == fence)\n throw new NoSuchElementException();\n @SuppressWarnings(\"unchecked\") E result = (E) elements[cursor];\n // This check doesn't catch all possible comodifications,\n // but does catch the ones that corrupt traversal\n if (tail != fence || result == null)\n throw new ConcurrentModificationException();\n lastRet = cursor;\n cursor = (cursor + 1) & (elements.length - 1);\n return result;\n }\n\n public void remove() {\n if (lastRet < 0)\n throw new IllegalStateException();\n if (delete(lastRet)) { // if left-shifted, undo increment in next()\n cursor = (cursor - 1) & (elements.length - 1);\n fence = tail;\n }\n lastRet = -1;\n }\n }\n\n private class DescendingIterator implements Iterator {\n /*\n * This class is nearly a mirror-image of DeqIterator, using\n * tail instead of head for initial cursor, and head instead of\n * tail for fence.\n */\n private int cursor = tail;\n private int fence = head;\n private int lastRet = -1;\n\n public boolean hasNext() {\n return cursor != fence;\n }\n\n public E next() {\n if (cursor == fence)\n throw new NoSuchElementException();\n cursor = (cursor - 1) & (elements.length - 1);\n @SuppressWarnings(\"unchecked\") E result = (E) elements[cursor];\n if (head != fence || result == null)\n throw new ConcurrentModificationException();\n lastRet = cursor;\n return result;\n }\n\n public void remove() {\n if (lastRet < 0)\n throw new IllegalStateException();\n if (!delete(lastRet)) {\n cursor = (cursor + 1) & (elements.length - 1);\n fence = head;\n }\n lastRet = -1;\n }\n }\n\n /**\n * Returns true if this deque contains the specified element.\n * More formally, returns true if and only if this deque contains\n * at least one element e such that o.equals(e).\n *\n * @param o object to be checked for containment in this deque\n * @return true if this deque contains the specified element\n */\n public boolean contains(Object o) {\n if (o == null)\n return false;\n int mask = elements.length - 1;\n int i = head;\n Object x;\n while ( (x = elements[i]) != null) {\n if (o.equals(x))\n return true;\n i = (i + 1) & mask;\n }\n return false;\n }\n\n /**\n * Removes a single instance of the specified element from this deque.\n * If the deque does not contain the element, it is unchanged.\n * More formally, removes the first element e such that\n * o.equals(e) (if such an element exists).\n * Returns true if this deque contained the specified element\n * (or equivalently, if this deque changed as a result of the call).\n *\n * This method is equivalent to {@link #removeFirstOccurrence}.\n *\n * @param o element to be removed from this deque, if present\n * @return true if this deque contained the specified element\n */\n public boolean remove(Object o) {\n return removeFirstOccurrence(o);\n }\n\n /**\n * Removes all of the elements from this deque.\n * The deque will be empty after this call returns.\n */\n public void clear() {\n int h = head;\n int t = tail;\n if (h != t) { // clear all cells\n head = tail = 0;\n int i = h;\n int mask = elements.length - 1;\n do {\n elements[i] = null;\n i = (i + 1) & mask;\n } while (i != t);\n }\n }\n\n /**\n * Returns an array containing all of the elements in this deque\n * in proper sequence (from first to last element).\n *\n *
The returned array will be \"safe\" in that no references to it are\n * maintained by this deque. (In other words, this method must allocate\n * a new array). The caller is thus free to modify the returned array.\n *\n *
This method acts as bridge between array-based and collection-based\n * APIs.\n *\n * @return an array containing all of the elements in this deque\n */\n public Object[] toArray() {\n return copyElements(new Object[size()]);\n }\n\n /**\n * Returns an array containing all of the elements in this deque in\n * proper sequence (from first to last element); the runtime type of the\n * returned array is that of the specified array. If the deque fits in\n * the specified array, it is returned therein. Otherwise, a new array\n * is allocated with the runtime type of the specified array and the\n * size of this deque.\n *\n *
If this deque fits in the specified array with room to spare\n * (i.e., the array has more elements than this deque), the element in\n * the array immediately following the end of the deque is set to\n * null.\n *\n *
Like the {@link #toArray()} method, this method acts as bridge between\n * array-based and collection-based APIs. Further, this method allows\n * precise control over the runtime type of the output array, and may,\n * under certain circumstances, be used to save allocation costs.\n *\n *
Suppose x is a deque known to contain only strings.\n * The following code can be used to dump the deque into a newly\n * allocated array of String:\n *\n *
{@code String[] y = x.toArray(new String[0]);}\n *\n * Note that toArray(new Object[0]) is identical in function to\n * toArray().\n *\n * @param a the array into which the elements of the deque are to\n * be stored, if it is big enough; otherwise, a new array of the\n * same runtime type is allocated for this purpose\n * @return an array containing all of the elements in this deque\n * @throws ArrayStoreException if the runtime type of the specified array\n * is not a supertype of the runtime type of every element in\n * this deque\n * @throws NullPointerException if the specified array is null\n */\n @SuppressWarnings(\"unchecked\")\n public T[] toArray(T[] a) {\n int size = size();\n if (a.length < size)\n a = (T[])java.lang.reflect.Array.newInstance(\n a.getClass().getComponentType(), size);\n copyElements(a);\n if (a.length > size)\n a[size] = null;\n return a;\n }\n\n // *** Object methods ***\n\n /**\n * Returns a copy of this deque.\n *\n * @return a copy of this deque\n */\n public ArrayDeque clone() {\n try {\n @SuppressWarnings(\"unchecked\")\n ArrayDeque result = (ArrayDeque) super.clone();\n result.elements = Arrays.copyOf(elements, elements.length);\n return result;\n\n } catch (CloneNotSupportedException e) {\n throw new AssertionError();\n }\n }\n\n /**\n * Appease the serialization gods.\n */\n private static final long serialVersionUID = 2340985798034038923L;\n\n /**\n * Serialize this deque.\n *\n * @serialData The current size (int) of the deque,\n * followed by all of its elements (each an object reference) in\n * first-to-last order.\n */\n private void writeObject(java.io.ObjectOutputStream s)\n throws java.io.IOException {\n s.defaultWriteObject();\n\n // Write out size\n s.writeInt(size());\n\n // Write out elements in order.\n int mask = elements.length - 1;\n for (int i = head; i != tail; i = (i + 1) & mask)\n s.writeObject(elements[i]);\n }\n\n /**\n * Deserialize this deque.\n */\n private void readObject(java.io.ObjectInputStream s)\n throws java.io.IOException, ClassNotFoundException {\n s.defaultReadObject();\n\n // Read in size and allocate array\n int size = s.readInt();\n allocateElements(size);\n head = 0;\n tail = size;\n\n // Read in all elements in the proper order.\n for (int i = 0; i < size; i++)\n elements[i] = s.readObject();\n }\n}\n"
},
{
"path": "src/main/java/com/artifex/mupdfdemo/AsyncTask.java",
"content": "/*\n * Copyright (C) 2008 The Android Open Source Project\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\npackage com.artifex.mupdfdemo;\n\nimport java.util.concurrent.BlockingQueue;\nimport java.util.concurrent.Callable;\nimport java.util.concurrent.CancellationException;\nimport java.util.concurrent.ExecutionException;\nimport java.util.concurrent.Executor;\nimport java.util.concurrent.FutureTask;\nimport java.util.concurrent.LinkedBlockingQueue;\nimport java.util.concurrent.ThreadFactory;\nimport java.util.concurrent.ThreadPoolExecutor;\nimport java.util.concurrent.TimeUnit;\nimport java.util.concurrent.TimeoutException;\nimport java.util.concurrent.atomic.AtomicBoolean;\nimport java.util.concurrent.atomic.AtomicInteger;\n\nimport android.os.Process;\nimport android.os.Handler;\nimport android.os.Message;\n\n/**\n * AsyncTask enables proper and easy use of the UI thread. This class allows to\n * perform background operations and publish results on the UI thread without\n * having to manipulate threads and/or handlers.
\n *\n * AsyncTask is designed to be a helper class around {@link Thread} and {@link android.os.Handler}\n * and does not constitute a generic threading framework. AsyncTasks should ideally be\n * used for short operations (a few seconds at the most.) If you need to keep threads\n * running for long periods of time, it is highly recommended you use the various APIs\n * provided by the java.util.concurrent pacakge such as {@link java.util.concurrent.Executor},\n * {@link java.util.concurrent.ThreadPoolExecutor} and {@link java.util.concurrent.FutureTask}.
\n *\n * An asynchronous task is defined by a computation that runs on a background thread and\n * whose result is published on the UI thread. An asynchronous task is defined by 3 generic\n * types, called Params, Progress and Result,\n * and 4 steps, called onPreExecute, doInBackground,\n * onProgressUpdate and onPostExecute.
\n *\n * \n *
Developer Guides
\n *
For more information about using tasks and threads, read the\n * Processes and\n * Threads developer guide.
\n *
Usage
\n * AsyncTask must be subclassed to be used. The subclass will override at least\n * one method ({@link #doInBackground}), and most often will override a\n * second one ({@link #onPostExecute}.)
\n *\n * Here is an example of subclassing:
\n * \n * private class DownloadFilesTask extends AsyncTask<URL, Integer, Long> {\n * protected Long doInBackground(URL... urls) {\n * int count = urls.length;\n * long totalSize = 0;\n * for (int i = 0; i < count; i++) {\n * totalSize += Downloader.downloadFile(urls[i]);\n * publishProgress((int) ((i / (float) count) * 100));\n * // Escape early if cancel() is called\n * if (isCancelled()) break;\n * }\n * return totalSize;\n * }\n *\n * protected void onProgressUpdate(Integer... progress) {\n * setProgressPercent(progress[0]);\n * }\n *\n * protected void onPostExecute(Long result) {\n * showDialog(\"Downloaded \" + result + \" bytes\");\n * }\n * }\n * \n *\n * Once created, a task is executed very simply:
\n * \n * new DownloadFilesTask().execute(url1, url2, url3);\n *
\n *\n * AsyncTask's generic types
\n * The three types used by an asynchronous task are the following:
\n * \n * Params, the type of the parameters sent to the task upon\n * execution.Progress, the type of the progress units published during\n * the background computation.Result, the type of the result of the background\n * computation.
\n * Not all types are always used by an asynchronous task. To mark a type as unused,\n * simply use the type {@link Void}:
\n * \n * private class MyTask extends AsyncTask<Void, Void, Void> { ... }\n * \n *\n * The 4 steps
\n * When an asynchronous task is executed, the task goes through 4 steps:
\n * \n * - {@link #onPreExecute()}, invoked on the UI thread before the task\n * is executed. This step is normally used to setup the task, for instance by\n * showing a progress bar in the user interface.
\n * - {@link #doInBackground}, invoked on the background thread\n * immediately after {@link #onPreExecute()} finishes executing. This step is used\n * to perform background computation that can take a long time. The parameters\n * of the asynchronous task are passed to this step. The result of the computation must\n * be returned by this step and will be passed back to the last step. This step\n * can also use {@link #publishProgress} to publish one or more units\n * of progress. These values are published on the UI thread, in the\n * {@link #onProgressUpdate} step.
\n * - {@link #onProgressUpdate}, invoked on the UI thread after a\n * call to {@link #publishProgress}. The timing of the execution is\n * undefined. This method is used to display any form of progress in the user\n * interface while the background computation is still executing. For instance,\n * it can be used to animate a progress bar or show logs in a text field.
\n * - {@link #onPostExecute}, invoked on the UI thread after the background\n * computation finishes. The result of the background computation is passed to\n * this step as a parameter.
\n *
\n *\n * Cancelling a task
\n * A task can be cancelled at any time by invoking {@link #cancel(boolean)}. Invoking\n * this method will cause subsequent calls to {@link #isCancelled()} to return true.\n * After invoking this method, {@link #onCancelled(Object)}, instead of\n * {@link #onPostExecute(Object)} will be invoked after {@link #doInBackground(Object[])}\n * returns. To ensure that a task is cancelled as quickly as possible, you should always\n * check the return value of {@link #isCancelled()} periodically from\n * {@link #doInBackground(Object[])}, if possible (inside a loop for instance.)
\n *\n * Threading rules
\n * There are a few threading rules that must be followed for this class to\n * work properly:
\n * \n * - The AsyncTask class must be loaded on the UI thread. This is done\n * automatically as of {@link android.os.Build.VERSION_CODES#JELLY_BEAN}.
\n * - The task instance must be created on the UI thread.
\n * - {@link #execute} must be invoked on the UI thread.
\n * - Do not call {@link #onPreExecute()}, {@link #onPostExecute},\n * {@link #doInBackground}, {@link #onProgressUpdate} manually.
\n * - The task can be executed only once (an exception will be thrown if\n * a second execution is attempted.)
\n *
\n *\n * Memory observability
\n * AsyncTask guarantees that all callback calls are synchronized in such a way that the following\n * operations are safe without explicit synchronizations.
\n * \n * - Set member fields in the constructor or {@link #onPreExecute}, and refer to them\n * in {@link #doInBackground}.\n *
- Set member fields in {@link #doInBackground}, and refer to them in\n * {@link #onProgressUpdate} and {@link #onPostExecute}.\n *
\n *\n * Order of execution
\n * When first introduced, AsyncTasks were executed serially on a single background\n * thread. Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed\n * to a pool of threads allowing multiple tasks to operate in parallel. Starting with\n * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, tasks are executed on a single\n * thread to avoid common application errors caused by parallel execution.
\n * If you truly want parallel execution, you can invoke\n * {@link #executeOnExecutor(java.util.concurrent.Executor, Object[])} with\n * {@link #THREAD_POOL_EXECUTOR}.
\n */\npublic abstract class AsyncTask {\n private static final String LOG_TAG = \"AsyncTask\";\n\n private static final int CORE_POOL_SIZE = 5;\n private static final int MAXIMUM_POOL_SIZE = 128;\n private static final int KEEP_ALIVE = 1;\n\n private static final ThreadFactory sThreadFactory = new ThreadFactory() {\n private final AtomicInteger mCount = new AtomicInteger(1);\n\n public Thread newThread(Runnable r) {\n return new Thread(r, \"AsyncTask #\" + mCount.getAndIncrement());\n }\n };\n\n private static final BlockingQueue sPoolWorkQueue =\n new LinkedBlockingQueue(10);\n\n /**\n * An {@link java.util.concurrent.Executor} that can be used to execute tasks in parallel.\n */\n public static final Executor THREAD_POOL_EXECUTOR\n = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,\n TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);\n\n /**\n * An {@link java.util.concurrent.Executor} that executes tasks one at a time in serial\n * order. This serialization is global to a particular process.\n */\n public static final Executor SERIAL_EXECUTOR = new SerialExecutor();\n\n private static final int MESSAGE_POST_RESULT = 0x1;\n private static final int MESSAGE_POST_PROGRESS = 0x2;\n\n private static final InternalHandler sHandler = new InternalHandler();\n\n private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;\n private final WorkerRunnable mWorker;\n private final FutureTask mFuture;\n\n private volatile Status mStatus = Status.PENDING;\n\n private final AtomicBoolean mCancelled = new AtomicBoolean();\n private final AtomicBoolean mTaskInvoked = new AtomicBoolean();\n\n private static class SerialExecutor implements Executor {\n final ArrayDeque mTasks = new ArrayDeque();\n Runnable mActive;\n\n public synchronized void execute(final Runnable r) {\n mTasks.offer(new Runnable() {\n public void run() {\n try {\n r.run();\n } finally {\n scheduleNext();\n }\n }\n });\n if (mActive == null) {\n scheduleNext();\n }\n }\n\n protected synchronized void scheduleNext() {\n if ((mActive = mTasks.poll()) != null) {\n THREAD_POOL_EXECUTOR.execute(mActive);\n }\n }\n }\n\n /**\n * Indicates the current status of the task. Each status will be set only once\n * during the lifetime of a task.\n */\n public enum Status {\n /**\n * Indicates that the task has not been executed yet.\n */\n PENDING,\n /**\n * Indicates that the task is running.\n */\n RUNNING,\n /**\n * Indicates that {@link com.artifex.mupdfdemo.AsyncTask#onPostExecute} has finished.\n */\n FINISHED,\n }\n\n /** @hide Used to force static handler to be created. */\n public static void init() {\n sHandler.getLooper();\n }\n\n /** @hide */\n public static void setDefaultExecutor(Executor exec) {\n sDefaultExecutor = exec;\n }\n\n /**\n * Creates a new asynchronous task. This constructor must be invoked on the UI thread.\n */\n public AsyncTask() {\n mWorker = new WorkerRunnable() {\n public Result call() throws Exception {\n mTaskInvoked.set(true);\n\n Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);\n //noinspection unchecked\n return postResult(doInBackground(mParams));\n }\n };\n\n mFuture = new FutureTask(mWorker) {\n @Override\n protected void done() {\n try {\n postResultIfNotInvoked(get());\n } catch (InterruptedException e) {\n android.util.Log.w(LOG_TAG, e);\n } catch (ExecutionException e) {\n throw new RuntimeException(\"An error occured while executing doInBackground()\",\n e.getCause());\n } catch (CancellationException e) {\n postResultIfNotInvoked(null);\n }\n }\n };\n }\n\n private void postResultIfNotInvoked(Result result) {\n final boolean wasTaskInvoked = mTaskInvoked.get();\n if (!wasTaskInvoked) {\n postResult(result);\n }\n }\n\n private Result postResult(Result result) {\n @SuppressWarnings(\"unchecked\")\n Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,\n new AsyncTaskResult(this, result));\n message.sendToTarget();\n return result;\n }\n\n /**\n * Returns the current status of this task.\n *\n * @return The current status.\n */\n public final Status getStatus() {\n return mStatus;\n }\n\n /**\n * Override this method to perform a computation on a background thread. The\n * specified parameters are the parameters passed to {@link #execute}\n * by the caller of this task.\n *\n * This method can call {@link #publishProgress} to publish updates\n * on the UI thread.\n *\n * @param params The parameters of the task.\n *\n * @return A result, defined by the subclass of this task.\n *\n * @see #onPreExecute()\n * @see #onPostExecute\n * @see #publishProgress\n */\n protected abstract Result doInBackground(Params... params);\n\n /**\n * Runs on the UI thread before {@link #doInBackground}.\n *\n * @see #onPostExecute\n * @see #doInBackground\n */\n protected void onPreExecute() {\n }\n\n /**\n * Runs on the UI thread after {@link #doInBackground}. The\n * specified result is the value returned by {@link #doInBackground}.
\n *\n * This method won't be invoked if the task was cancelled.
\n *\n * @param result The result of the operation computed by {@link #doInBackground}.\n *\n * @see #onPreExecute\n * @see #doInBackground\n * @see #onCancelled(Object)\n */\n @SuppressWarnings({\"UnusedDeclaration\"})\n protected void onPostExecute(Result result) {\n }\n\n /**\n * Runs on the UI thread after {@link #publishProgress} is invoked.\n * The specified values are the values passed to {@link #publishProgress}.\n *\n * @param values The values indicating progress.\n *\n * @see #publishProgress\n * @see #doInBackground\n */\n @SuppressWarnings({\"UnusedDeclaration\"})\n protected void onProgressUpdate(Progress... values) {\n }\n\n /**\n * Runs on the UI thread after {@link #cancel(boolean)} is invoked and\n * {@link #doInBackground(Object[])} has finished.
\n *\n * The default implementation simply invokes {@link #onCancelled()} and\n * ignores the result. If you write your own implementation, do not call\n * super.onCancelled(result).
\n *\n * @param result The result, if any, computed in\n * {@link #doInBackground(Object[])}, can be null\n *\n * @see #cancel(boolean)\n * @see #isCancelled()\n */\n @SuppressWarnings({\"UnusedParameters\"})\n protected void onCancelled(Result result) {\n onCancelled();\n }\n\n /**\n * Applications should preferably override {@link #onCancelled(Object)}.\n * This method is invoked by the default implementation of\n * {@link #onCancelled(Object)}.
\n *\n * Runs on the UI thread after {@link #cancel(boolean)} is invoked and\n * {@link #doInBackground(Object[])} has finished.
\n *\n * @see #onCancelled(Object)\n * @see #cancel(boolean)\n * @see #isCancelled()\n */\n protected void onCancelled() {\n }\n\n /**\n * Returns true if this task was cancelled before it completed\n * normally. If you are calling {@link #cancel(boolean)} on the task,\n * the value returned by this method should be checked periodically from\n * {@link #doInBackground(Object[])} to end the task as soon as possible.\n *\n * @return true if task was cancelled before it completed\n *\n * @see #cancel(boolean)\n */\n public final boolean isCancelled() {\n return mCancelled.get();\n }\n\n /**\n * Attempts to cancel execution of this task. This attempt will\n * fail if the task has already completed, already been cancelled,\n * or could not be cancelled for some other reason. If successful,\n * and this task has not started when cancel is called,\n * this task should never run. If the task has already started,\n * then the mayInterruptIfRunning parameter determines\n * whether the thread executing this task should be interrupted in\n * an attempt to stop the task.
\n *\n * Calling this method will result in {@link #onCancelled(Object)} being\n * invoked on the UI thread after {@link #doInBackground(Object[])}\n * returns. Calling this method guarantees that {@link #onPostExecute(Object)}\n * is never invoked. After invoking this method, you should check the\n * value returned by {@link #isCancelled()} periodically from\n * {@link #doInBackground(Object[])} to finish the task as early as\n * possible.
\n *\n * @param mayInterruptIfRunning true if the thread executing this\n * task should be interrupted; otherwise, in-progress tasks are allowed\n * to complete.\n *\n * @return false if the task could not be cancelled,\n * typically because it has already completed normally;\n * true otherwise\n *\n * @see #isCancelled()\n * @see #onCancelled(Object)\n */\n public final boolean cancel(boolean mayInterruptIfRunning) {\n mCancelled.set(true);\n return mFuture.cancel(mayInterruptIfRunning);\n }\n\n /**\n * Waits if necessary for the computation to complete, and then\n * retrieves its result.\n *\n * @return The computed result.\n *\n * @throws java.util.concurrent.CancellationException If the computation was cancelled.\n * @throws java.util.concurrent.ExecutionException If the computation threw an exception.\n * @throws InterruptedException If the current thread was interrupted\n * while waiting.\n */\n public final Result get() throws InterruptedException, ExecutionException {\n return mFuture.get();\n }\n\n /**\n * Waits if necessary for at most the given time for the computation\n * to complete, and then retrieves its result.\n *\n * @param timeout Time to wait before cancelling the operation.\n * @param unit The time unit for the timeout.\n *\n * @return The computed result.\n *\n * @throws java.util.concurrent.CancellationException If the computation was cancelled.\n * @throws java.util.concurrent.ExecutionException If the computation threw an exception.\n * @throws InterruptedException If the current thread was interrupted\n * while waiting.\n * @throws java.util.concurrent.TimeoutException If the wait timed out.\n */\n public final Result get(long timeout, TimeUnit unit) throws InterruptedException,\n ExecutionException, TimeoutException {\n return mFuture.get(timeout, unit);\n }\n\n /**\n * Executes the task with the specified parameters. The task returns\n * itself (this) so that the caller can keep a reference to it.\n *\n * Note: this function schedules the task on a queue for a single background\n * thread or pool of threads depending on the platform version. When first\n * introduced, AsyncTasks were executed serially on a single background thread.\n * Starting with {@link android.os.Build.VERSION_CODES#DONUT}, this was changed\n * to a pool of threads allowing multiple tasks to operate in parallel. Starting\n * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, tasks are back to being\n * executed on a single thread to avoid common application errors caused\n * by parallel execution. If you truly want parallel execution, you can use\n * the {@link #executeOnExecutor} version of this method\n * with {@link #THREAD_POOL_EXECUTOR}; however, see commentary there for warnings\n * on its use.\n *\n *
This method must be invoked on the UI thread.\n *\n * @param params The parameters of the task.\n *\n * @return This instance of AsyncTask.\n *\n * @throws IllegalStateException If {@link #getStatus()} returns either\n * {@link com.artifex.mupdfdemo.AsyncTask.Status#RUNNING} or {@link com.artifex.mupdfdemo.AsyncTask.Status#FINISHED}.\n *\n * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])\n * @see #execute(Runnable)\n */\n public final AsyncTask execute(Params... params) {\n return executeOnExecutor(sDefaultExecutor, params);\n }\n\n /**\n * Executes the task with the specified parameters. The task returns\n * itself (this) so that the caller can keep a reference to it.\n *\n * This method is typically used with {@link #THREAD_POOL_EXECUTOR} to\n * allow multiple tasks to run in parallel on a pool of threads managed by\n * AsyncTask, however you can also use your own {@link java.util.concurrent.Executor} for custom\n * behavior.\n *\n *
Warning: Allowing multiple tasks to run in parallel from\n * a thread pool is generally not what one wants, because the order\n * of their operation is not defined. For example, if these tasks are used\n * to modify any state in common (such as writing a file due to a button click),\n * there are no guarantees on the order of the modifications.\n * Without careful work it is possible in rare cases for the newer version\n * of the data to be over-written by an older one, leading to obscure data\n * loss and stability issues. Such changes are best\n * executed in serial; to guarantee such work is serialized regardless of\n * platform version you can use this function with {@link #SERIAL_EXECUTOR}.\n *\n *
This method must be invoked on the UI thread.\n *\n * @param exec The executor to use. {@link #THREAD_POOL_EXECUTOR} is available as a\n * convenient process-wide thread pool for tasks that are loosely coupled.\n * @param params The parameters of the task.\n *\n * @return This instance of AsyncTask.\n *\n * @throws IllegalStateException If {@link #getStatus()} returns either\n * {@link com.artifex.mupdfdemo.AsyncTask.Status#RUNNING} or {@link com.artifex.mupdfdemo.AsyncTask.Status#FINISHED}.\n *\n * @see #execute(Object[])\n */\n public final AsyncTask executeOnExecutor(Executor exec,\n Params... params) {\n if (mStatus != Status.PENDING) {\n switch (mStatus) {\n case RUNNING:\n throw new IllegalStateException(\"Cannot execute task:\"\n + \" the task is already running.\");\n case FINISHED:\n throw new IllegalStateException(\"Cannot execute task:\"\n + \" the task has already been executed \"\n + \"(a task can be executed only once)\");\n }\n }\n\n mStatus = Status.RUNNING;\n\n onPreExecute();\n\n mWorker.mParams = params;\n exec.execute(mFuture);\n\n return this;\n }\n\n /**\n * Convenience version of {@link #execute(Object...)} for use with\n * a simple Runnable object. See {@link #execute(Object[])} for more\n * information on the order of execution.\n *\n * @see #execute(Object[])\n * @see #executeOnExecutor(java.util.concurrent.Executor, Object[])\n */\n public static void execute(Runnable runnable) {\n sDefaultExecutor.execute(runnable);\n }\n\n /**\n * This method can be invoked from {@link #doInBackground} to\n * publish updates on the UI thread while the background computation is\n * still running. Each call to this method will trigger the execution of\n * {@link #onProgressUpdate} on the UI thread.\n *\n * {@link #onProgressUpdate} will note be called if the task has been\n * canceled.\n *\n * @param values The progress values to update the UI with.\n *\n * @see #onProgressUpdate\n * @see #doInBackground\n */\n protected final void publishProgress(Progress... values) {\n if (!isCancelled()) {\n sHandler.obtainMessage(MESSAGE_POST_PROGRESS,\n new AsyncTaskResult