react-native-pdf-sdk 0.0.0-stage → 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +16 -0
- package/LICENSE +21 -0
- package/PdfSdk.podspec +32 -0
- package/README.md +265 -2
- package/android/CMakeLists.txt +24 -0
- package/android/build.gradle +132 -0
- package/android/gradle.properties +4 -0
- package/android/src/main/AndroidManifest.xml +1 -0
- package/android/src/main/cpp/cpp-adapter.cpp +9 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/HybridPdfDocument.kt +72 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/HybridPdfSdk.kt +17 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/HybridPdfView.kt +194 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/PdfDocumentLayout.kt +109 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/PdfFailure.kt +36 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/PdfPageSource.kt +141 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/PdfSdkPackage.kt +35 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/PdfSourceLoader.kt +117 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/PdfSurface.kt +839 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/PdfTileStore.kt +210 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/PdfViewport.kt +255 -0
- package/android/src/main/java/com/margelo/nitro/pdfsdk/TileGrid.kt +276 -0
- package/ios/HybridPdfDocument.swift +71 -0
- package/ios/HybridPdfSdk.swift +10 -0
- package/ios/HybridPdfView.swift +202 -0
- package/ios/PdfDocumentLayout.swift +174 -0
- package/ios/PdfFailure.swift +46 -0
- package/ios/PdfImageCache.swift +83 -0
- package/ios/PdfPageSource.swift +221 -0
- package/ios/PdfScrollPlan.swift +108 -0
- package/ios/PdfSourceLoader.swift +120 -0
- package/ios/PdfSurface.swift +711 -0
- package/ios/PdfTileCanvas.swift +148 -0
- package/ios/PdfTileGrid.swift +518 -0
- package/ios/PdfTileStore.swift +346 -0
- package/ios/PdfViewport.swift +200 -0
- package/lib/commonjs/PdfView.js +149 -0
- package/lib/commonjs/PdfView.js.map +1 -0
- package/lib/commonjs/document.js +38 -0
- package/lib/commonjs/document.js.map +1 -0
- package/lib/commonjs/index.js +26 -0
- package/lib/commonjs/index.js.map +1 -0
- package/lib/commonjs/package.json +1 -0
- package/lib/commonjs/specs/PdfSdk.nitro.js +6 -0
- package/lib/commonjs/specs/PdfSdk.nitro.js.map +1 -0
- package/lib/commonjs/specs/PdfView.nitro.js +6 -0
- package/lib/commonjs/specs/PdfView.nitro.js.map +1 -0
- package/lib/module/PdfView.js +143 -0
- package/lib/module/PdfView.js.map +1 -0
- package/lib/module/document.js +34 -0
- package/lib/module/document.js.map +1 -0
- package/lib/module/index.js +5 -0
- package/lib/module/index.js.map +1 -0
- package/lib/module/specs/PdfSdk.nitro.js +4 -0
- package/lib/module/specs/PdfSdk.nitro.js.map +1 -0
- package/lib/module/specs/PdfView.nitro.js +4 -0
- package/lib/module/specs/PdfView.nitro.js.map +1 -0
- package/lib/typescript/src/PdfView.d.ts +65 -0
- package/lib/typescript/src/PdfView.d.ts.map +1 -0
- package/lib/typescript/src/document.d.ts +22 -0
- package/lib/typescript/src/document.d.ts.map +1 -0
- package/lib/typescript/src/index.d.ts +6 -0
- package/lib/typescript/src/index.d.ts.map +1 -0
- package/lib/typescript/src/specs/PdfSdk.nitro.d.ts +60 -0
- package/lib/typescript/src/specs/PdfSdk.nitro.d.ts.map +1 -0
- package/lib/typescript/src/specs/PdfView.nitro.d.ts +131 -0
- package/lib/typescript/src/specs/PdfView.nitro.d.ts.map +1 -0
- package/nitro.json +40 -0
- package/nitrogen/generated/.gitattributes +1 -0
- package/nitrogen/generated/android/PdfSdk+autolinking.cmake +87 -0
- package/nitrogen/generated/android/PdfSdk+autolinking.gradle +27 -0
- package/nitrogen/generated/android/PdfSdkOnLoad.cpp +84 -0
- package/nitrogen/generated/android/PdfSdkOnLoad.hpp +34 -0
- package/nitrogen/generated/android/c++/JFunc_void_PdfErrorEvent.hpp +80 -0
- package/nitrogen/generated/android/c++/JFunc_void_PdfLoadEvent.hpp +77 -0
- package/nitrogen/generated/android/c++/JFunc_void_PdfPageEvent.hpp +77 -0
- package/nitrogen/generated/android/c++/JFunc_void_PdfTapEvent.hpp +77 -0
- package/nitrogen/generated/android/c++/JFunc_void_PdfZoomEvent.hpp +77 -0
- package/nitrogen/generated/android/c++/JHybridNativePdfViewSpec.cpp +266 -0
- package/nitrogen/generated/android/c++/JHybridNativePdfViewSpec.hpp +92 -0
- package/nitrogen/generated/android/c++/JHybridPdfDocumentSpec.cpp +87 -0
- package/nitrogen/generated/android/c++/JHybridPdfDocumentSpec.hpp +65 -0
- package/nitrogen/generated/android/c++/JHybridPdfSdkSpec.cpp +58 -0
- package/nitrogen/generated/android/c++/JHybridPdfSdkSpec.hpp +63 -0
- package/nitrogen/generated/android/c++/JPdfErrorCode.hpp +67 -0
- package/nitrogen/generated/android/c++/JPdfErrorEvent.hpp +63 -0
- package/nitrogen/generated/android/c++/JPdfFit.hpp +64 -0
- package/nitrogen/generated/android/c++/JPdfLoadEvent.hpp +65 -0
- package/nitrogen/generated/android/c++/JPdfPageEvent.hpp +61 -0
- package/nitrogen/generated/android/c++/JPdfPageSize.hpp +61 -0
- package/nitrogen/generated/android/c++/JPdfRenderRequest.hpp +86 -0
- package/nitrogen/generated/android/c++/JPdfTapEvent.hpp +65 -0
- package/nitrogen/generated/android/c++/JPdfViewSource.hpp +84 -0
- package/nitrogen/generated/android/c++/JPdfZoomEvent.hpp +61 -0
- package/nitrogen/generated/android/c++/views/JHybridNativePdfViewStateUpdater.cpp +108 -0
- package/nitrogen/generated/android/c++/views/JHybridNativePdfViewStateUpdater.hpp +49 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/Func_void_PdfErrorEvent.kt +80 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/Func_void_PdfLoadEvent.kt +80 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/Func_void_PdfPageEvent.kt +80 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/Func_void_PdfTapEvent.kt +80 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/Func_void_PdfZoomEvent.kt +80 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/HybridNativePdfViewSpec.kt +185 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/HybridPdfDocumentSpec.kt +65 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/HybridPdfSdkSpec.kt +54 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfErrorCode.kt +26 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfErrorEvent.kt +56 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfFit.kt +25 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfLoadEvent.kt +61 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfPageEvent.kt +56 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfPageSize.kt +56 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfRenderRequest.kt +86 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfSdkOnLoad.kt +35 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfTapEvent.kt +61 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfViewSource.kt +66 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/PdfZoomEvent.kt +56 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/views/HybridNativePdfViewManager.kt +80 -0
- package/nitrogen/generated/android/kotlin/com/margelo/nitro/pdfsdk/views/HybridNativePdfViewStateUpdater.kt +23 -0
- package/nitrogen/generated/ios/PdfSdk+autolinking.rb +62 -0
- package/nitrogen/generated/ios/PdfSdk-Swift-Cxx-Bridge.cpp +123 -0
- package/nitrogen/generated/ios/PdfSdk-Swift-Cxx-Bridge.hpp +474 -0
- package/nitrogen/generated/ios/PdfSdk-Swift-Cxx-Umbrella.hpp +88 -0
- package/nitrogen/generated/ios/PdfSdkAutolinking.mm +41 -0
- package/nitrogen/generated/ios/PdfSdkAutolinking.swift +38 -0
- package/nitrogen/generated/ios/c++/HybridNativePdfViewSpecSwift.cpp +11 -0
- package/nitrogen/generated/ios/c++/HybridNativePdfViewSpecSwift.hpp +209 -0
- package/nitrogen/generated/ios/c++/HybridPdfDocumentSpecSwift.cpp +11 -0
- package/nitrogen/generated/ios/c++/HybridPdfDocumentSpecSwift.hpp +105 -0
- package/nitrogen/generated/ios/c++/HybridPdfSdkSpecSwift.cpp +11 -0
- package/nitrogen/generated/ios/c++/HybridPdfSdkSpecSwift.hpp +86 -0
- package/nitrogen/generated/ios/c++/views/HybridNativePdfViewComponent.mm +187 -0
- package/nitrogen/generated/ios/swift/Func_void_PdfErrorEvent.swift +46 -0
- package/nitrogen/generated/ios/swift/Func_void_PdfLoadEvent.swift +46 -0
- package/nitrogen/generated/ios/swift/Func_void_PdfPageEvent.swift +46 -0
- package/nitrogen/generated/ios/swift/Func_void_PdfTapEvent.swift +46 -0
- package/nitrogen/generated/ios/swift/Func_void_PdfZoomEvent.swift +46 -0
- package/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift +46 -0
- package/nitrogen/generated/ios/swift/Func_void_std__string.swift +46 -0
- package/nitrogen/generated/ios/swift/HybridNativePdfViewSpec.swift +70 -0
- package/nitrogen/generated/ios/swift/HybridNativePdfViewSpec_cxx.swift +438 -0
- package/nitrogen/generated/ios/swift/HybridPdfDocumentSpec.swift +57 -0
- package/nitrogen/generated/ios/swift/HybridPdfDocumentSpec_cxx.swift +173 -0
- package/nitrogen/generated/ios/swift/HybridPdfSdkSpec.swift +55 -0
- package/nitrogen/generated/ios/swift/HybridPdfSdkSpec_cxx.swift +148 -0
- package/nitrogen/generated/ios/swift/PdfErrorCode.swift +52 -0
- package/nitrogen/generated/ios/swift/PdfErrorEvent.swift +34 -0
- package/nitrogen/generated/ios/swift/PdfFit.swift +48 -0
- package/nitrogen/generated/ios/swift/PdfLoadEvent.swift +39 -0
- package/nitrogen/generated/ios/swift/PdfPageEvent.swift +34 -0
- package/nitrogen/generated/ios/swift/PdfPageSize.swift +34 -0
- package/nitrogen/generated/ios/swift/PdfRenderRequest.swift +129 -0
- package/nitrogen/generated/ios/swift/PdfTapEvent.swift +39 -0
- package/nitrogen/generated/ios/swift/PdfViewSource.swift +97 -0
- package/nitrogen/generated/ios/swift/PdfZoomEvent.swift +34 -0
- package/nitrogen/generated/shared/c++/HybridNativePdfViewSpec.cpp +51 -0
- package/nitrogen/generated/shared/c++/HybridNativePdfViewSpec.hpp +112 -0
- package/nitrogen/generated/shared/c++/HybridPdfDocumentSpec.cpp +24 -0
- package/nitrogen/generated/shared/c++/HybridPdfDocumentSpec.hpp +70 -0
- package/nitrogen/generated/shared/c++/HybridPdfSdkSpec.cpp +21 -0
- package/nitrogen/generated/shared/c++/HybridPdfSdkSpec.hpp +66 -0
- package/nitrogen/generated/shared/c++/PdfErrorCode.hpp +88 -0
- package/nitrogen/generated/shared/c++/PdfErrorEvent.hpp +89 -0
- package/nitrogen/generated/shared/c++/PdfFit.hpp +84 -0
- package/nitrogen/generated/shared/c++/PdfLoadEvent.hpp +91 -0
- package/nitrogen/generated/shared/c++/PdfPageEvent.hpp +87 -0
- package/nitrogen/generated/shared/c++/PdfPageSize.hpp +87 -0
- package/nitrogen/generated/shared/c++/PdfRenderRequest.hpp +112 -0
- package/nitrogen/generated/shared/c++/PdfTapEvent.hpp +91 -0
- package/nitrogen/generated/shared/c++/PdfViewSource.hpp +97 -0
- package/nitrogen/generated/shared/c++/PdfZoomEvent.hpp +87 -0
- package/nitrogen/generated/shared/c++/views/HybridNativePdfViewComponent.cpp +226 -0
- package/nitrogen/generated/shared/c++/views/HybridNativePdfViewComponent.hpp +130 -0
- package/nitrogen/generated/shared/json/NativePdfViewConfig.json +23 -0
- package/package.json +80 -4
- package/react-native.config.js +10 -0
- package/src/PdfView.tsx +221 -0
- package/src/document.ts +34 -0
- package/src/index.ts +16 -0
- package/src/specs/PdfSdk.nitro.ts +60 -0
- package/src/specs/PdfView.nitro.ts +149 -0
|
@@ -0,0 +1,839 @@
|
|
|
1
|
+
package com.margelo.nitro.pdfsdk
|
|
2
|
+
|
|
3
|
+
import android.animation.Animator
|
|
4
|
+
import android.animation.AnimatorListenerAdapter
|
|
5
|
+
import android.animation.ValueAnimator
|
|
6
|
+
import android.content.Context
|
|
7
|
+
import android.graphics.Canvas
|
|
8
|
+
import android.graphics.Color
|
|
9
|
+
import android.graphics.Paint
|
|
10
|
+
import android.graphics.RectF
|
|
11
|
+
import android.os.Handler
|
|
12
|
+
import android.os.Looper
|
|
13
|
+
import android.view.GestureDetector
|
|
14
|
+
import android.view.MotionEvent
|
|
15
|
+
import android.view.View
|
|
16
|
+
import android.view.ViewConfiguration
|
|
17
|
+
import android.widget.OverScroller
|
|
18
|
+
import java.util.concurrent.Executors
|
|
19
|
+
import kotlin.math.abs
|
|
20
|
+
import kotlin.math.hypot
|
|
21
|
+
import kotlin.math.roundToInt
|
|
22
|
+
|
|
23
|
+
/**
|
|
24
|
+
* The viewer itself: one view that owns the document, the zoom, the movement
|
|
25
|
+
* and the drawing.
|
|
26
|
+
*
|
|
27
|
+
* Keeping all of that in one place is the point. When the transform lived in
|
|
28
|
+
* one thread and the layout of what it moved in another, the two could not be
|
|
29
|
+
* changed together, and every change of zoom showed a frame or two of the
|
|
30
|
+
* document in the wrong place. Here the zoom, the tile grid and the drawing are
|
|
31
|
+
* read from the same numbers in the same pass.
|
|
32
|
+
*/
|
|
33
|
+
class PdfSurface(context: Context) : View(context) {
|
|
34
|
+
|
|
35
|
+
val viewport = PdfViewport()
|
|
36
|
+
|
|
37
|
+
var onLoad: ((pageCount: Int, width: Float, height: Float) -> Unit)? = null
|
|
38
|
+
/** Zero based, so it matches the page property. A caller adds one to show it. */
|
|
39
|
+
var onPageChange: ((page: Int, pageCount: Int) -> Unit)? = null
|
|
40
|
+
/** The zoom as a multiple of what the document opened at, and what that is. */
|
|
41
|
+
var onZoom: ((zoom: Float, scale: Float) -> Unit)? = null
|
|
42
|
+
var onFailure: ((failure: PdfFailure) -> Unit)? = null
|
|
43
|
+
/** A tap that was not part of a double tap, and the page under it. */
|
|
44
|
+
var onTap: ((x: Float, y: Float, page: Int) -> Unit)? = null
|
|
45
|
+
|
|
46
|
+
private val main = Handler(Looper.getMainLooper())
|
|
47
|
+
private val loader = Executors.newSingleThreadExecutor { runnable ->
|
|
48
|
+
Thread(runnable, "pdf-sdk-loader")
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
private var source: PdfPageSource? = null
|
|
52
|
+
private var store: PdfTileStore? = null
|
|
53
|
+
private var layout = PdfDocumentLayout(emptyList())
|
|
54
|
+
|
|
55
|
+
private var uri: String? = null
|
|
56
|
+
private var headers: Map<String, String> = emptyMap()
|
|
57
|
+
private var password: String? = null
|
|
58
|
+
private var cache = true
|
|
59
|
+
private var openAtPage = 0
|
|
60
|
+
private var pageGap = PdfDocumentLayout.DEFAULT_GAP
|
|
61
|
+
private var pageSizes: List<PageSize> = emptyList()
|
|
62
|
+
private var reportedPage = -1
|
|
63
|
+
private var reportedZoom = 0f
|
|
64
|
+
private var lastZoomAt = 0L
|
|
65
|
+
private var zoomQueued = false
|
|
66
|
+
|
|
67
|
+
/** Which tiles are wanted and where they go: arithmetic, tested on its own. */
|
|
68
|
+
private val grid = TileGrid(TILE_PX, LEVEL_DRIFT, LOOKAHEAD_SECONDS)
|
|
69
|
+
|
|
70
|
+
private val tilePaint = Paint(Paint.FILTER_BITMAP_FLAG or Paint.ANTI_ALIAS_FLAG)
|
|
71
|
+
private val pagePaint = Paint().apply { color = Color.WHITE }
|
|
72
|
+
private val destination = RectF()
|
|
73
|
+
|
|
74
|
+
private val scroller = OverScroller(context)
|
|
75
|
+
private var zoomAnimator: ValueAnimator? = null
|
|
76
|
+
private var lastEnsure = 0L
|
|
77
|
+
private var ensureQueued = false
|
|
78
|
+
private var velocityX = 0f
|
|
79
|
+
private var velocityY = 0f
|
|
80
|
+
private var lastFlingAt = 0L
|
|
81
|
+
|
|
82
|
+
private val configuration = ViewConfiguration.get(context)
|
|
83
|
+
private val touchSlop = configuration.scaledTouchSlop.toFloat()
|
|
84
|
+
private val doubleTapSlop = configuration.scaledDoubleTapSlop.toFloat()
|
|
85
|
+
private val doubleTapTimeout = ViewConfiguration.getDoubleTapTimeout().toLong()
|
|
86
|
+
private var downX = 0f
|
|
87
|
+
private var downY = 0f
|
|
88
|
+
private var wasDragged = false
|
|
89
|
+
private var lastTapAt = 0L
|
|
90
|
+
private var lastTapX = 0f
|
|
91
|
+
private var lastTapY = 0f
|
|
92
|
+
|
|
93
|
+
// ─── Loading ────────────────────────────────────────────────────────────────
|
|
94
|
+
|
|
95
|
+
fun load(
|
|
96
|
+
uri: String,
|
|
97
|
+
headers: Map<String, String>,
|
|
98
|
+
password: String?,
|
|
99
|
+
cache: Boolean,
|
|
100
|
+
page: Int,
|
|
101
|
+
) {
|
|
102
|
+
val same = uri == this.uri && password == this.password && source != null
|
|
103
|
+
this.headers = headers
|
|
104
|
+
this.cache = cache
|
|
105
|
+
|
|
106
|
+
if (same) {
|
|
107
|
+
if (page != openAtPage) {
|
|
108
|
+
openAtPage = page
|
|
109
|
+
goToPage(page, animated = false)
|
|
110
|
+
}
|
|
111
|
+
return
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
this.uri = uri
|
|
115
|
+
this.password = password
|
|
116
|
+
this.openAtPage = page
|
|
117
|
+
reportedPage = -1
|
|
118
|
+
reportedZoom = 0f
|
|
119
|
+
|
|
120
|
+
closeDocument()
|
|
121
|
+
invalidate()
|
|
122
|
+
if (uri.isEmpty()) return
|
|
123
|
+
|
|
124
|
+
loader.execute {
|
|
125
|
+
val opened = try {
|
|
126
|
+
PdfPageSource(PdfSourceLoader.open(context, uri, headers, cache), password)
|
|
127
|
+
} catch (error: Throwable) {
|
|
128
|
+
report(error)
|
|
129
|
+
return@execute
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
val first = try {
|
|
133
|
+
opened.pageSize(0)
|
|
134
|
+
} catch (error: Throwable) {
|
|
135
|
+
opened.close()
|
|
136
|
+
report(error)
|
|
137
|
+
return@execute
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
val size = PageSize(first.first, first.second)
|
|
141
|
+
val tiles = PdfTileStore(
|
|
142
|
+
source = opened,
|
|
143
|
+
onTileReady = { postInvalidateOnAnimation() },
|
|
144
|
+
onError = { error -> report(error) },
|
|
145
|
+
)
|
|
146
|
+
|
|
147
|
+
main.post {
|
|
148
|
+
if (this.uri != uri || !isAttachedToWindow) {
|
|
149
|
+
tiles.close()
|
|
150
|
+
opened.close()
|
|
151
|
+
return@post
|
|
152
|
+
}
|
|
153
|
+
source = opened
|
|
154
|
+
store = tiles
|
|
155
|
+
// Every page is taken to be the size of the first one until it has been
|
|
156
|
+
// measured, which is true of almost every document and lets the first
|
|
157
|
+
// page be drawn now rather than after the whole file has been walked.
|
|
158
|
+
pageSizes = List(opened.pageCount) { size }
|
|
159
|
+
layout = PdfDocumentLayout.of(size, opened.pageCount, pageGap)
|
|
160
|
+
viewport.setDocument(layout)
|
|
161
|
+
if (viewport.ready) {
|
|
162
|
+
viewport.reset()
|
|
163
|
+
scrollToPage(openAtPage)
|
|
164
|
+
ensureTiles(force = true)
|
|
165
|
+
}
|
|
166
|
+
onLoad?.invoke(opened.pageCount, size.width, size.height)
|
|
167
|
+
invalidate()
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
measureRemainingPages(opened, uri, size)
|
|
171
|
+
}
|
|
172
|
+
}
|
|
173
|
+
|
|
174
|
+
private fun report(error: Throwable) {
|
|
175
|
+
val failure = PdfFailure.from(error)
|
|
176
|
+
main.post { onFailure?.invoke(failure) }
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
/**
|
|
180
|
+
* Measures the pages that were assumed to be the size of the first.
|
|
181
|
+
*
|
|
182
|
+
* Done after the document is on screen rather than before: opening a page is
|
|
183
|
+
* where the platform parses it, and on a large drawing that is a third of a
|
|
184
|
+
* second each. Almost every document has pages of one size, so this usually
|
|
185
|
+
* confirms what is already drawn and changes nothing.
|
|
186
|
+
*/
|
|
187
|
+
private fun measureRemainingPages(source: PdfPageSource, uri: String, first: PageSize) {
|
|
188
|
+
if (source.pageCount <= 1) return
|
|
189
|
+
|
|
190
|
+
val sizes = ArrayList<PageSize>(source.pageCount)
|
|
191
|
+
sizes.add(first)
|
|
192
|
+
var differs = false
|
|
193
|
+
|
|
194
|
+
for (index in 1 until source.pageCount) {
|
|
195
|
+
if (this.uri != uri) return
|
|
196
|
+
val size = try {
|
|
197
|
+
val measured = source.pageSize(index)
|
|
198
|
+
PageSize(measured.first, measured.second)
|
|
199
|
+
} catch (error: Throwable) {
|
|
200
|
+
first
|
|
201
|
+
}
|
|
202
|
+
if (size != first) differs = true
|
|
203
|
+
sizes.add(size)
|
|
204
|
+
}
|
|
205
|
+
|
|
206
|
+
if (!differs) return
|
|
207
|
+
|
|
208
|
+
main.post {
|
|
209
|
+
if (this.uri != uri || this.source !== source) return@post
|
|
210
|
+
pageSizes = sizes
|
|
211
|
+
applyLayout(PdfDocumentLayout(sizes, pageGap))
|
|
212
|
+
}
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
/**
|
|
216
|
+
* Puts a corrected layout in place without moving what the reader is looking
|
|
217
|
+
* at: the page they are on stays where it is on screen, and the pages below
|
|
218
|
+
* it move instead.
|
|
219
|
+
*/
|
|
220
|
+
private fun applyLayout(next: PdfDocumentLayout) {
|
|
221
|
+
val anchor = layout.pageAt(viewport.screenToDocumentY(0f))
|
|
222
|
+
val before = layout.pages.getOrNull(anchor)?.y ?: 0f
|
|
223
|
+
val after = next.pages.getOrNull(anchor)?.y ?: 0f
|
|
224
|
+
|
|
225
|
+
layout = next
|
|
226
|
+
viewport.setDocument(next)
|
|
227
|
+
viewport.panBy(0f, -(after - before) * viewport.scale)
|
|
228
|
+
grid.clear()
|
|
229
|
+
ensureTiles(force = true)
|
|
230
|
+
invalidate()
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
fun scrollToPage(page: Int) {
|
|
234
|
+
val box = layout.pages.getOrNull(page) ?: return
|
|
235
|
+
if (!viewport.ready) return
|
|
236
|
+
viewport.moveTo(viewport.offsetX, -box.y * viewport.scale)
|
|
237
|
+
ensureTiles(force = true)
|
|
238
|
+
invalidate()
|
|
239
|
+
}
|
|
240
|
+
|
|
241
|
+
// ─── What the reader is allowed to do ──────────────────────────────────────
|
|
242
|
+
|
|
243
|
+
fun setFit(policy: PdfFitPolicy) {
|
|
244
|
+
if (viewport.fit == policy) return
|
|
245
|
+
viewport.fit = policy
|
|
246
|
+
refit()
|
|
247
|
+
}
|
|
248
|
+
|
|
249
|
+
fun setZoomRange(min: Float?, max: Float?) {
|
|
250
|
+
if (viewport.minZoom == min && viewport.maxZoom == max) return
|
|
251
|
+
viewport.minZoom = min
|
|
252
|
+
viewport.maxZoom = max
|
|
253
|
+
refit()
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
fun setDoubleTapZoom(value: Float?) {
|
|
257
|
+
viewport.doubleTapZoom = value
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
fun setPageGap(gap: Float) {
|
|
261
|
+
if (gap == pageGap) return
|
|
262
|
+
pageGap = gap
|
|
263
|
+
if (pageSizes.isEmpty()) return
|
|
264
|
+
layout = PdfDocumentLayout(pageSizes, gap)
|
|
265
|
+
viewport.setDocument(layout)
|
|
266
|
+
refit()
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
fun setBackdropColor(color: Int?) {
|
|
270
|
+
setBackgroundColor(color ?: Color.TRANSPARENT)
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
/** Something about the shape of the document changed, so it opens again. */
|
|
274
|
+
private fun refit() {
|
|
275
|
+
if (!viewport.ready || source == null) return
|
|
276
|
+
val page = if (reportedPage < 0) openAtPage else reportedPage
|
|
277
|
+
viewport.reset()
|
|
278
|
+
scrollToPage(page)
|
|
279
|
+
grid.clear()
|
|
280
|
+
ensureTiles(force = true)
|
|
281
|
+
invalidate()
|
|
282
|
+
}
|
|
283
|
+
|
|
284
|
+
// ─── What a caller can ask for ─────────────────────────────────────────────
|
|
285
|
+
|
|
286
|
+
fun goToPage(page: Int, animated: Boolean) {
|
|
287
|
+
val box = layout.pages.getOrNull(page) ?: return
|
|
288
|
+
if (!viewport.ready) return
|
|
289
|
+
zoomAnimator?.cancel()
|
|
290
|
+
scroller.forceFinished(true)
|
|
291
|
+
val target = -box.y * viewport.scale
|
|
292
|
+
if (!animated) {
|
|
293
|
+
scrollToPage(page)
|
|
294
|
+
return
|
|
295
|
+
}
|
|
296
|
+
scroller.startScroll(
|
|
297
|
+
viewport.offsetX.roundToInt(),
|
|
298
|
+
viewport.offsetY.roundToInt(),
|
|
299
|
+
0,
|
|
300
|
+
(target - viewport.offsetY).roundToInt(),
|
|
301
|
+
SCROLL_MS,
|
|
302
|
+
)
|
|
303
|
+
lastFlingAt = 0L
|
|
304
|
+
postInvalidateOnAnimation()
|
|
305
|
+
}
|
|
306
|
+
|
|
307
|
+
/** `zoom` is a multiple of the zoom the document opened at. */
|
|
308
|
+
fun setZoom(zoom: Float, animated: Boolean) {
|
|
309
|
+
if (!viewport.ready) return
|
|
310
|
+
val rest = viewport.restScale()
|
|
311
|
+
val target = (rest * zoom).coerceIn(viewport.minScale(), viewport.maxScale())
|
|
312
|
+
if (animated) {
|
|
313
|
+
animateZoom(target, width / 2f, height / 2f)
|
|
314
|
+
return
|
|
315
|
+
}
|
|
316
|
+
zoomAnimator?.cancel()
|
|
317
|
+
scroller.forceFinished(true)
|
|
318
|
+
viewport.zoomAround(width / 2f, height / 2f, target / viewport.scale)
|
|
319
|
+
velocityX = 0f
|
|
320
|
+
velocityY = 0f
|
|
321
|
+
ensureTiles(force = true)
|
|
322
|
+
invalidate()
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
fun release() {
|
|
326
|
+
closeDocument()
|
|
327
|
+
loader.shutdown()
|
|
328
|
+
}
|
|
329
|
+
|
|
330
|
+
private fun closeDocument() {
|
|
331
|
+
zoomAnimator?.cancel()
|
|
332
|
+
scroller.forceFinished(true)
|
|
333
|
+
val currentStore = store
|
|
334
|
+
val currentSource = source
|
|
335
|
+
store = null
|
|
336
|
+
source = null
|
|
337
|
+
pageSizes = emptyList()
|
|
338
|
+
layout = PdfDocumentLayout(emptyList())
|
|
339
|
+
grid.clear()
|
|
340
|
+
if (currentStore != null || currentSource != null) {
|
|
341
|
+
loader.execute {
|
|
342
|
+
currentStore?.close()
|
|
343
|
+
currentSource?.close()
|
|
344
|
+
}
|
|
345
|
+
}
|
|
346
|
+
}
|
|
347
|
+
|
|
348
|
+
override fun onAttachedToWindow() {
|
|
349
|
+
super.onAttachedToWindow()
|
|
350
|
+
val current = uri ?: return
|
|
351
|
+
if (source == null) {
|
|
352
|
+
val page = openAtPage
|
|
353
|
+
uri = null
|
|
354
|
+
load(current, headers, password, cache, page)
|
|
355
|
+
}
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
override fun onDetachedFromWindow() {
|
|
359
|
+
super.onDetachedFromWindow()
|
|
360
|
+
// An open PDF is a file handle and a page parsed into memory; a view that
|
|
361
|
+
// has left the screen should be holding neither.
|
|
362
|
+
val current = uri
|
|
363
|
+
closeDocument()
|
|
364
|
+
uri = current
|
|
365
|
+
}
|
|
366
|
+
|
|
367
|
+
// ─── Layout ─────────────────────────────────────────────────────────────────
|
|
368
|
+
|
|
369
|
+
override fun onSizeChanged(width: Int, height: Int, oldWidth: Int, oldHeight: Int) {
|
|
370
|
+
super.onSizeChanged(width, height, oldWidth, oldHeight)
|
|
371
|
+
viewport.setView(width.toFloat(), height.toFloat())
|
|
372
|
+
if (viewport.ready) {
|
|
373
|
+
viewport.reset()
|
|
374
|
+
scrollToPage(openAtPage)
|
|
375
|
+
ensureTiles(force = true)
|
|
376
|
+
}
|
|
377
|
+
}
|
|
378
|
+
|
|
379
|
+
// ─── Drawing ────────────────────────────────────────────────────────────────
|
|
380
|
+
|
|
381
|
+
override fun onDraw(canvas: Canvas) {
|
|
382
|
+
if (!viewport.ready) return
|
|
383
|
+
|
|
384
|
+
// Kept inside our own bounds. React Native leaves overflow visible on the
|
|
385
|
+
// views around us, so without this the document is drawn over whatever the
|
|
386
|
+
// screen puts above and below it, the header included.
|
|
387
|
+
canvas.clipRect(0, 0, width, height)
|
|
388
|
+
|
|
389
|
+
val tiles = store ?: return
|
|
390
|
+
val visible = viewport.visible()
|
|
391
|
+
|
|
392
|
+
// The pages themselves: a white sheet each, with the page's own small
|
|
393
|
+
// drawing on it until the tiles for this zoom arrive. What falls between
|
|
394
|
+
// two pages is left to the background behind this view.
|
|
395
|
+
for (page in layout.pagesIn(visible.y, visible.bottom)) {
|
|
396
|
+
destination.set(
|
|
397
|
+
viewport.documentToScreenX(page.x),
|
|
398
|
+
viewport.documentToScreenY(page.y),
|
|
399
|
+
viewport.documentToScreenX(page.right),
|
|
400
|
+
viewport.documentToScreenY(page.bottom),
|
|
401
|
+
)
|
|
402
|
+
canvas.drawRect(destination, pagePaint)
|
|
403
|
+
tiles.thumbnail(page.index)?.let { canvas.drawBitmap(it, null, destination, tilePaint) }
|
|
404
|
+
}
|
|
405
|
+
|
|
406
|
+
// What was drawn for the zoom before this one keeps the screen covered
|
|
407
|
+
// until the tiles for this one have arrived.
|
|
408
|
+
for (planned in grid.toDraw(viewport) { tiles.bitmap(it) != null }) {
|
|
409
|
+
val bitmap = tiles.bitmap(planned.spec.key) ?: continue
|
|
410
|
+
destination.set(
|
|
411
|
+
planned.destination.left,
|
|
412
|
+
planned.destination.top,
|
|
413
|
+
planned.destination.right,
|
|
414
|
+
planned.destination.bottom,
|
|
415
|
+
)
|
|
416
|
+
canvas.drawBitmap(bitmap, null, destination, tilePaint)
|
|
417
|
+
}
|
|
418
|
+
}
|
|
419
|
+
|
|
420
|
+
// ─── Tiles ──────────────────────────────────────────────────────────────────
|
|
421
|
+
|
|
422
|
+
private fun ensureTiles(force: Boolean = false) {
|
|
423
|
+
val tiles = store ?: return
|
|
424
|
+
if (!viewport.ready || layout.pageCount == 0) return
|
|
425
|
+
// A movement that knows where it is going has already asked for what it
|
|
426
|
+
// needs, and what is on screen on the way there is not worth a renderer.
|
|
427
|
+
if (zoomAnimator?.isRunning == true) return
|
|
428
|
+
|
|
429
|
+
val now = System.currentTimeMillis()
|
|
430
|
+
if (!force && now - lastEnsure < ENSURE_MS) {
|
|
431
|
+
if (!ensureQueued) {
|
|
432
|
+
ensureQueued = true
|
|
433
|
+
main.postDelayed({
|
|
434
|
+
ensureQueued = false
|
|
435
|
+
ensureTiles(force = true)
|
|
436
|
+
}, ENSURE_MS)
|
|
437
|
+
}
|
|
438
|
+
return
|
|
439
|
+
}
|
|
440
|
+
lastEnsure = now
|
|
441
|
+
|
|
442
|
+
grid.update(viewport, layout, velocityX, velocityY)
|
|
443
|
+
|
|
444
|
+
val visible = viewport.visible()
|
|
445
|
+
tiles.request(
|
|
446
|
+
specs = grid.missing(viewport) { tiles.bitmap(it) != null },
|
|
447
|
+
focusX = visible.x + visible.width / 2f,
|
|
448
|
+
focusY = visible.y + visible.height / 2f,
|
|
449
|
+
)
|
|
450
|
+
|
|
451
|
+
// A page coming into view should never be a blank rectangle, so each one
|
|
452
|
+
// on screen is asked for its own small drawing as well.
|
|
453
|
+
for (page in layout.pagesIn(visible.y, visible.bottom)) {
|
|
454
|
+
tiles.requestThumbnail(page.index, PageSize(page.width, page.height))
|
|
455
|
+
}
|
|
456
|
+
|
|
457
|
+
notifyPage(visible)
|
|
458
|
+
notifyZoom()
|
|
459
|
+
measureCoverage()
|
|
460
|
+
invalidate()
|
|
461
|
+
}
|
|
462
|
+
|
|
463
|
+
/** The page the reader would say they are on: the one under the middle of the view. */
|
|
464
|
+
private fun notifyPage(visible: PageRect) {
|
|
465
|
+
val page = layout.pageAt(visible.y + visible.height / 2f)
|
|
466
|
+
if (page == reportedPage) return
|
|
467
|
+
reportedPage = page
|
|
468
|
+
onPageChange?.invoke(page, layout.pageCount)
|
|
469
|
+
}
|
|
470
|
+
|
|
471
|
+
/**
|
|
472
|
+
* The zoom, as a multiple of what the document opened at.
|
|
473
|
+
*
|
|
474
|
+
* Held to a few a second on purpose. A pinch changes the zoom on every frame,
|
|
475
|
+
* and whoever is listening is almost certainly putting the number on the
|
|
476
|
+
* screen, which means a React render per frame and a JavaScript thread on its
|
|
477
|
+
* knees while the fingers are still moving. What matters is that the reader
|
|
478
|
+
* sees a number that keeps up and that the last one is right, so one that
|
|
479
|
+
* comes too early is sent late rather than dropped.
|
|
480
|
+
*/
|
|
481
|
+
private fun notifyZoom() {
|
|
482
|
+
if (!viewport.ready) return
|
|
483
|
+
val rest = viewport.restScale()
|
|
484
|
+
if (rest <= 0f) return
|
|
485
|
+
val zoom = viewport.scale / rest
|
|
486
|
+
if (abs(zoom - reportedZoom) <= reportedZoom * 0.005f) return
|
|
487
|
+
|
|
488
|
+
val now = System.currentTimeMillis()
|
|
489
|
+
if (now - lastZoomAt < ZOOM_REPORT_MS) {
|
|
490
|
+
if (!zoomQueued) {
|
|
491
|
+
zoomQueued = true
|
|
492
|
+
main.postDelayed({
|
|
493
|
+
zoomQueued = false
|
|
494
|
+
notifyZoom()
|
|
495
|
+
}, ZOOM_REPORT_MS)
|
|
496
|
+
}
|
|
497
|
+
return
|
|
498
|
+
}
|
|
499
|
+
|
|
500
|
+
lastZoomAt = now
|
|
501
|
+
reportedZoom = zoom
|
|
502
|
+
onZoom?.invoke(zoom, viewport.scale)
|
|
503
|
+
}
|
|
504
|
+
|
|
505
|
+
// ─── Movement ───────────────────────────────────────────────────────────────
|
|
506
|
+
|
|
507
|
+
/**
|
|
508
|
+
* Pinch, counted here.
|
|
509
|
+
*
|
|
510
|
+
* Android's own detector stops reporting once the fingers come within a few
|
|
511
|
+
* centimetres of each other, so zooming out died halfway through the
|
|
512
|
+
* movement and had to be started again. The distance between two fingers and
|
|
513
|
+
* the point between them is all this needs, and neither has a lower bound.
|
|
514
|
+
*/
|
|
515
|
+
private var isPinching = false
|
|
516
|
+
private var lastSpan = 0f
|
|
517
|
+
private var lastFocusX = 0f
|
|
518
|
+
private var lastFocusY = 0f
|
|
519
|
+
/** Set when a finger lands or leaves, so the span and focus are taken afresh. */
|
|
520
|
+
private var focusIsStale = true
|
|
521
|
+
|
|
522
|
+
private fun trackPinch(event: MotionEvent) {
|
|
523
|
+
if (event.pointerCount < 2) {
|
|
524
|
+
isPinching = false
|
|
525
|
+
return
|
|
526
|
+
}
|
|
527
|
+
|
|
528
|
+
val span = hypot(event.getX(1) - event.getX(0), event.getY(1) - event.getY(0))
|
|
529
|
+
val focusX = (event.getX(0) + event.getX(1)) / 2f
|
|
530
|
+
val focusY = (event.getY(0) + event.getY(1)) / 2f
|
|
531
|
+
|
|
532
|
+
// A finger landing or leaving moves the point between them and changes the
|
|
533
|
+
// distance, neither of which the reader did. Taken as movement, that jump
|
|
534
|
+
// threw the document sideways.
|
|
535
|
+
if (!isPinching || focusIsStale) {
|
|
536
|
+
isPinching = true
|
|
537
|
+
focusIsStale = false
|
|
538
|
+
lastSpan = span
|
|
539
|
+
lastFocusX = focusX
|
|
540
|
+
lastFocusY = focusY
|
|
541
|
+
zoomAnimator?.cancel()
|
|
542
|
+
scroller.forceFinished(true)
|
|
543
|
+
return
|
|
544
|
+
}
|
|
545
|
+
|
|
546
|
+
if (span > 1f && lastSpan > 1f) {
|
|
547
|
+
// Two fingers do two things at once: what is between them moves the
|
|
548
|
+
// document, and how far apart they are zooms it.
|
|
549
|
+
viewport.panBy(focusX - lastFocusX, focusY - lastFocusY)
|
|
550
|
+
viewport.zoomAround(focusX, focusY, pinchGain(span / lastSpan))
|
|
551
|
+
velocityX = 0f
|
|
552
|
+
velocityY = 0f
|
|
553
|
+
ensureTiles()
|
|
554
|
+
invalidate()
|
|
555
|
+
}
|
|
556
|
+
|
|
557
|
+
lastSpan = span
|
|
558
|
+
lastFocusX = focusX
|
|
559
|
+
lastFocusY = focusY
|
|
560
|
+
}
|
|
561
|
+
|
|
562
|
+
private val gestureDetector = GestureDetector(context, object :
|
|
563
|
+
GestureDetector.SimpleOnGestureListener() {
|
|
564
|
+
|
|
565
|
+
override fun onDown(event: MotionEvent): Boolean {
|
|
566
|
+
scroller.forceFinished(true)
|
|
567
|
+
zoomAnimator?.cancel()
|
|
568
|
+
velocityX = 0f
|
|
569
|
+
velocityY = 0f
|
|
570
|
+
return true
|
|
571
|
+
}
|
|
572
|
+
|
|
573
|
+
override fun onScroll(
|
|
574
|
+
down: MotionEvent?,
|
|
575
|
+
event: MotionEvent,
|
|
576
|
+
distanceX: Float,
|
|
577
|
+
distanceY: Float,
|
|
578
|
+
): Boolean {
|
|
579
|
+
if (isPinching || event.pointerCount > 1) return false
|
|
580
|
+
viewport.panBy(-distanceX, -distanceY)
|
|
581
|
+
velocityX = -distanceX * 60f
|
|
582
|
+
velocityY = -distanceY * 60f
|
|
583
|
+
ensureTiles()
|
|
584
|
+
invalidate()
|
|
585
|
+
return true
|
|
586
|
+
}
|
|
587
|
+
|
|
588
|
+
override fun onFling(
|
|
589
|
+
down: MotionEvent?,
|
|
590
|
+
event: MotionEvent,
|
|
591
|
+
speedX: Float,
|
|
592
|
+
speedY: Float,
|
|
593
|
+
): Boolean {
|
|
594
|
+
if (isPinching || event.pointerCount > 1) return false
|
|
595
|
+
// The document carries on and slows down, so that crossing a sheet metres
|
|
596
|
+
// wide, or a document of forty pages, is one flick rather than a dozen
|
|
597
|
+
// drags.
|
|
598
|
+
scroller.forceFinished(true)
|
|
599
|
+
lastFlingAt = 0L
|
|
600
|
+
scroller.fling(
|
|
601
|
+
viewport.offsetX.roundToInt(),
|
|
602
|
+
viewport.offsetY.roundToInt(),
|
|
603
|
+
speedX.roundToInt(),
|
|
604
|
+
speedY.roundToInt(),
|
|
605
|
+
viewport.minOffsetX().roundToInt(),
|
|
606
|
+
viewport.maxOffsetX().roundToInt(),
|
|
607
|
+
viewport.minOffsetY().roundToInt(),
|
|
608
|
+
viewport.maxOffsetY().roundToInt(),
|
|
609
|
+
)
|
|
610
|
+
velocityX = speedX
|
|
611
|
+
velocityY = speedY
|
|
612
|
+
postInvalidateOnAnimation()
|
|
613
|
+
return true
|
|
614
|
+
}
|
|
615
|
+
})
|
|
616
|
+
|
|
617
|
+
init {
|
|
618
|
+
// A long press has no meaning on a document, and left on it interrupts a drag.
|
|
619
|
+
gestureDetector.setIsLongpressEnabled(false)
|
|
620
|
+
}
|
|
621
|
+
|
|
622
|
+
/**
|
|
623
|
+
* Double tap, counted here.
|
|
624
|
+
*
|
|
625
|
+
* The platform's gesture detector was given the job first and never called
|
|
626
|
+
* back: its pinch detector claims the second tap as the start of a one
|
|
627
|
+
* fingered zoom, and turning that off was not enough, with the events also
|
|
628
|
+
* passing through react-native's own touch handling on the way here. Two taps
|
|
629
|
+
* close together in time and place is a small enough thing to count.
|
|
630
|
+
*/
|
|
631
|
+
private fun onDoubleTapAt(x: Float, y: Float) {
|
|
632
|
+
animateZoom(viewport.doubleTapTarget(), x, y)
|
|
633
|
+
}
|
|
634
|
+
|
|
635
|
+
private fun pinchGain(factor: Float): Float {
|
|
636
|
+
if (factor <= 0f) return 1f
|
|
637
|
+
return Math.pow(factor.toDouble(), PINCH_GAIN.toDouble()).toFloat()
|
|
638
|
+
}
|
|
639
|
+
|
|
640
|
+
/**
|
|
641
|
+
* Moves the zoom over a fifth of a second, and asks for where it lands before
|
|
642
|
+
* it starts.
|
|
643
|
+
*
|
|
644
|
+
* The tiles of the zoom being arrived at take about as long to draw as the
|
|
645
|
+
* movement takes to run, so asking for them at the start means they are there
|
|
646
|
+
* as it lands. Without this the level changed in the middle of the movement,
|
|
647
|
+
* the tiles were thrown away and asked for again, and the page stepped from
|
|
648
|
+
* coarse to sharp two or three times on the way. That reads as a stuttering
|
|
649
|
+
* animation even while every frame is drawn on time.
|
|
650
|
+
*/
|
|
651
|
+
private fun animateZoom(target: Float, focusX: Float, focusY: Float) {
|
|
652
|
+
zoomAnimator?.cancel()
|
|
653
|
+
askForWhereItLands(target, focusX, focusY)
|
|
654
|
+
|
|
655
|
+
val from = viewport.scale
|
|
656
|
+
zoomAnimator = ValueAnimator.ofFloat(0f, 1f).apply {
|
|
657
|
+
duration = ZOOM_MS
|
|
658
|
+
addUpdateListener { animation ->
|
|
659
|
+
val progress = animation.animatedValue as Float
|
|
660
|
+
val wanted = from + (target - from) * progress
|
|
661
|
+
viewport.zoomAround(focusX, focusY, wanted / viewport.scale)
|
|
662
|
+
invalidate()
|
|
663
|
+
}
|
|
664
|
+
addListener(object : AnimatorListenerAdapter() {
|
|
665
|
+
override fun onAnimationEnd(animation: Animator) {
|
|
666
|
+
grid.stopAiming()
|
|
667
|
+
velocityX = 0f
|
|
668
|
+
velocityY = 0f
|
|
669
|
+
ensureTiles(force = true)
|
|
670
|
+
}
|
|
671
|
+
})
|
|
672
|
+
start()
|
|
673
|
+
}
|
|
674
|
+
}
|
|
675
|
+
|
|
676
|
+
/** The tiles of where a movement is going, worked out before it goes. */
|
|
677
|
+
private fun askForWhereItLands(target: Float, focusX: Float, focusY: Float) {
|
|
678
|
+
val tiles = store ?: return
|
|
679
|
+
if (!viewport.ready) return
|
|
680
|
+
|
|
681
|
+
val anchorX = viewport.screenToDocumentX(focusX)
|
|
682
|
+
val anchorY = viewport.screenToDocumentY(focusY)
|
|
683
|
+
val landing = PdfViewport().apply {
|
|
684
|
+
fit = viewport.fit
|
|
685
|
+
minZoom = viewport.minZoom
|
|
686
|
+
maxZoom = viewport.maxZoom
|
|
687
|
+
setDocument(layout)
|
|
688
|
+
setView(width.toFloat(), height.toFloat())
|
|
689
|
+
place(target, focusX - anchorX * target, focusY - anchorY * target)
|
|
690
|
+
}
|
|
691
|
+
|
|
692
|
+
grid.aim(landing.scale)
|
|
693
|
+
grid.update(landing, layout)
|
|
694
|
+
val visible = landing.visible()
|
|
695
|
+
tiles.request(
|
|
696
|
+
specs = grid.missing(landing) { tiles.bitmap(it) != null },
|
|
697
|
+
focusX = visible.x + visible.width / 2f,
|
|
698
|
+
focusY = visible.y + visible.height / 2f,
|
|
699
|
+
)
|
|
700
|
+
invalidate()
|
|
701
|
+
}
|
|
702
|
+
|
|
703
|
+
override fun computeScroll() {
|
|
704
|
+
if (!scroller.computeScrollOffset()) {
|
|
705
|
+
if (velocityX != 0f || velocityY != 0f) {
|
|
706
|
+
velocityX = 0f
|
|
707
|
+
velocityY = 0f
|
|
708
|
+
ensureTiles(force = true)
|
|
709
|
+
}
|
|
710
|
+
return
|
|
711
|
+
}
|
|
712
|
+
|
|
713
|
+
// Measured from the movement itself rather than taken from the scroller,
|
|
714
|
+
// which reports a speed without a direction.
|
|
715
|
+
val now = System.nanoTime()
|
|
716
|
+
val seconds = ((now - lastFlingAt) / 1_000_000_000.0).toFloat()
|
|
717
|
+
val x = scroller.currX.toFloat()
|
|
718
|
+
val y = scroller.currY.toFloat()
|
|
719
|
+
if (lastFlingAt != 0L && seconds > 0.001f) {
|
|
720
|
+
velocityX = (x - viewport.offsetX) / seconds
|
|
721
|
+
velocityY = (y - viewport.offsetY) / seconds
|
|
722
|
+
}
|
|
723
|
+
lastFlingAt = now
|
|
724
|
+
|
|
725
|
+
viewport.moveTo(x, y)
|
|
726
|
+
ensureTiles()
|
|
727
|
+
postInvalidateOnAnimation()
|
|
728
|
+
invalidate()
|
|
729
|
+
}
|
|
730
|
+
|
|
731
|
+
@Suppress("ClickableViewAccessibility")
|
|
732
|
+
override fun onTouchEvent(event: MotionEvent): Boolean {
|
|
733
|
+
when (event.actionMasked) {
|
|
734
|
+
MotionEvent.ACTION_DOWN -> {
|
|
735
|
+
// A drag on the document is the document's own, not a list's underneath it.
|
|
736
|
+
parent?.requestDisallowInterceptTouchEvent(true)
|
|
737
|
+
downX = event.x
|
|
738
|
+
downY = event.y
|
|
739
|
+
wasDragged = false
|
|
740
|
+
}
|
|
741
|
+
MotionEvent.ACTION_POINTER_DOWN, MotionEvent.ACTION_POINTER_UP -> {
|
|
742
|
+
focusIsStale = true
|
|
743
|
+
wasDragged = true
|
|
744
|
+
}
|
|
745
|
+
MotionEvent.ACTION_MOVE -> {
|
|
746
|
+
if (!wasDragged &&
|
|
747
|
+
(abs(event.x - downX) > touchSlop || abs(event.y - downY) > touchSlop)
|
|
748
|
+
) {
|
|
749
|
+
wasDragged = true
|
|
750
|
+
}
|
|
751
|
+
trackPinch(event)
|
|
752
|
+
}
|
|
753
|
+
MotionEvent.ACTION_UP -> {
|
|
754
|
+
countTap(event)
|
|
755
|
+
isPinching = false
|
|
756
|
+
}
|
|
757
|
+
MotionEvent.ACTION_CANCEL -> isPinching = false
|
|
758
|
+
}
|
|
759
|
+
|
|
760
|
+
gestureDetector.onTouchEvent(event)
|
|
761
|
+
|
|
762
|
+
if (event.actionMasked == MotionEvent.ACTION_UP ||
|
|
763
|
+
event.actionMasked == MotionEvent.ACTION_CANCEL
|
|
764
|
+
) {
|
|
765
|
+
if (scroller.isFinished) {
|
|
766
|
+
velocityX = 0f
|
|
767
|
+
velocityY = 0f
|
|
768
|
+
ensureTiles(force = true)
|
|
769
|
+
}
|
|
770
|
+
parent?.requestDisallowInterceptTouchEvent(false)
|
|
771
|
+
}
|
|
772
|
+
return true
|
|
773
|
+
}
|
|
774
|
+
|
|
775
|
+
private fun countTap(event: MotionEvent) {
|
|
776
|
+
if (wasDragged || isPinching) {
|
|
777
|
+
lastTapAt = 0L
|
|
778
|
+
return
|
|
779
|
+
}
|
|
780
|
+
|
|
781
|
+
val now = event.eventTime
|
|
782
|
+
val nearLast = abs(event.x - lastTapX) < doubleTapSlop &&
|
|
783
|
+
abs(event.y - lastTapY) < doubleTapSlop
|
|
784
|
+
if (lastTapAt != 0L && now - lastTapAt <= doubleTapTimeout && nearLast) {
|
|
785
|
+
lastTapAt = 0L
|
|
786
|
+
removeCallbacks(reportTap)
|
|
787
|
+
onDoubleTapAt(event.x, event.y)
|
|
788
|
+
return
|
|
789
|
+
}
|
|
790
|
+
|
|
791
|
+
lastTapAt = now
|
|
792
|
+
lastTapX = event.x
|
|
793
|
+
lastTapY = event.y
|
|
794
|
+
|
|
795
|
+
// A single tap is only a single tap once the moment for a second one has
|
|
796
|
+
// passed, so whoever is listening is told then rather than now.
|
|
797
|
+
if (onTap != null) {
|
|
798
|
+
tapX = event.x
|
|
799
|
+
tapY = event.y
|
|
800
|
+
removeCallbacks(reportTap)
|
|
801
|
+
postDelayed(reportTap, doubleTapTimeout)
|
|
802
|
+
}
|
|
803
|
+
}
|
|
804
|
+
|
|
805
|
+
private var tapX = 0f
|
|
806
|
+
private var tapY = 0f
|
|
807
|
+
private val reportTap = Runnable {
|
|
808
|
+
if (viewport.ready) {
|
|
809
|
+
onTap?.invoke(tapX, tapY, layout.pageAt(viewport.screenToDocumentY(tapY)))
|
|
810
|
+
}
|
|
811
|
+
}
|
|
812
|
+
|
|
813
|
+
/**
|
|
814
|
+
* How much of what is on screen has been drawn for the zoom it is shown at,
|
|
815
|
+
* worked out whenever the tiles are, and read from anywhere.
|
|
816
|
+
*/
|
|
817
|
+
@Volatile
|
|
818
|
+
var lastCoverage = 0f
|
|
819
|
+
private set
|
|
820
|
+
|
|
821
|
+
private fun measureCoverage() {
|
|
822
|
+
val tiles = store
|
|
823
|
+
lastCoverage = if (tiles == null) 0f
|
|
824
|
+
else grid.coverage(viewport, layout) { tiles.bitmap(it) != null }
|
|
825
|
+
}
|
|
826
|
+
|
|
827
|
+
private companion object {
|
|
828
|
+
const val TILE_PX = 512
|
|
829
|
+
const val LEVEL_DRIFT = 1.45f
|
|
830
|
+
const val LOOKAHEAD_SECONDS = 0.3f
|
|
831
|
+
const val ENSURE_MS = 60L
|
|
832
|
+
|
|
833
|
+
/** How often the zoom is worth telling anyone about. */
|
|
834
|
+
const val ZOOM_REPORT_MS = 120L
|
|
835
|
+
const val ZOOM_MS = 220L
|
|
836
|
+
const val SCROLL_MS = 260
|
|
837
|
+
const val PINCH_GAIN = 1.8f
|
|
838
|
+
}
|
|
839
|
+
}
|