Android PDF viewer zoom and pan using Kotlin

1
/*
2
 *   Copyright © 2020-2025 PSPDFKit GmbH. All rights reserved.
3
 *
4
 *   The PSPDFKit Sample applications are licensed with a modified BSD license.
5
 *   Please see License for details. This notice may not be removed from this file.
6
 */
7

8
package com.pspdfkit.catalog.examples.kotlin
9

10
import android.content.Context
11
import android.net.Uri
12
import android.view.Menu
13
import android.view.MenuItem
14
import androidx.activity.viewModels
15
import androidx.annotation.UiThread
16
import com.pspdfkit.annotations.Annotation
17
import com.pspdfkit.annotations.AnnotationType
18
import com.pspdfkit.catalog.R
19
import com.pspdfkit.catalog.SdkExample
20
import com.pspdfkit.catalog.tasks.ExtractAssetTask
21
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
22
import com.pspdfkit.document.PdfDocument
23
import com.pspdfkit.ui.PdfActivity
24
import com.pspdfkit.ui.PdfActivityIntentBuilder
25
import com.pspdfkit.ui.PdfFragment
26
import io.reactivex.rxjava3.disposables.Disposable
27
import java.util.EnumSet
28
import kotlin.math.max
29
import kotlin.math.min
30

31
/**
32
 * Simple example that shows how to zoom to page annotations, using the [PdfFragment.zoomTo] method.
33
 */
34
class ZoomExample(context: Context) : SdkExample(context, R.string.zoomExampleTitle, R.string.zoomExampleDescription) {
35

36
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
37
        // This example uses a custom activity which adds some option menu items.
38
        // The default menu items are deactivated for simplicity.
39
        configuration.searchEnabled(false)
40
            .outlineEnabled(false)
41
            .thumbnailGridEnabled(false)
42

43
        // Start the activity once the example document has been extracted from the app's assets.
44
        ExtractAssetTask.extract(WELCOME_DOC, title, context) { documentFile ->
45
            val intent = PdfActivityIntentBuilder.fromUri(context, Uri.fromFile(documentFile))
46
                .configuration(configuration.build())
47
                .activityClass(ZoomExampleActivity::class)
48
                .build()
49

50
            // Start the ZoomExampleActivity for the extracted document.
51
            context.startActivity(intent)
52
        }
53
    }
54
}
55

56
/**
57
 * This example shows how to zoom/animate between annotations of a document using the [PdfFragment.zoomTo] method.
58
 */
59
class ZoomExampleActivity : PdfActivity() {
60
    companion object {
61
        /** Padding around annotation bounding box used when zooming. */
62
        private const val ANNOTATION_BOUNDING_BOX_PADDING_PX = 16
63
    }
64

65
    /**
66
     * This list holds all annotations of the loaded document. It is populated in onDocumentLoaded().
67
     */
68
    private val documentAnnotations = mutableListOf<Annotation>()
69

70
    /** This holds reference to the currently zoomed annotation. */
71
    private var currentAnnotation: Annotation? = null
72

73
    private var annotationLoadingDisposable: Disposable? = null
74

75
    private val viewModel: AnnotationCreationViewModel by viewModels()
76

77
    /**
78
     * Once the document is loaded, we extract all the annotations and put them into our list.
79
     * That way we can easily move forth and back between the annotations.
80
     */
81
    @UiThread
82
    override fun onDocumentLoaded(document: PdfDocument) {
83
        viewModel.createObjects {
84
            annotationLoadingDisposable = document.annotationProvider
85
                .getAllAnnotationsOfTypeAsync(EnumSet.allOf(AnnotationType::class.java))
86
                .toList()
87
                .subscribe { annotations -> documentAnnotations.addAll(annotations) }
88
        }
89
    }
90

91
    override fun onDestroy() {
92
        super.onDestroy()
93

94
        // Dispose the annotation loading subscription.
95
        annotationLoadingDisposable?.dispose()
96
        annotationLoadingDisposable = null
97
    }
98

99
    /**
100
     * Creates our custom navigation menu.
101
     */
102
    override fun onCreateOptionsMenu(menu: Menu): Boolean {
103
        // It's important to call super before inflating the
104
        // custom menu, or the custom menu won't be shown.
105
        super.onCreateOptionsMenu(menu)
106

107
        // Inflate our custom menu items, for navigation between annotations.
108
        menuInflater.inflate(R.menu.activity_zoom_example, menu)
109

110
        return true
111
    }
112

113
    /**
114
     * Handles clicks on the navigation option menu items.
115
     */
116
    override fun onOptionsItemSelected(item: MenuItem): Boolean {
117
        return when (item.itemId) {
118
            R.id.nextAnnotation -> {
119
                zoomToNextAnnotation()
120
                true
121
            }
122
            R.id.previousAnnotation -> {
123
                zoomToPreviousAnnotation()
124
                true
125
            }
126
            else -> super.onOptionsItemSelected(item)
127
        }
128
    }
129

130
    /**
131
     * Called when pressing the "next annotation" button. Finds the next annotation and issues a call
132
     * to [PdfFragment.zoomTo].
133
     */
134
    private fun zoomToNextAnnotation() {
135
        if (documentAnnotations.isEmpty()) return
136

137
        var currentAnnotation = this.currentAnnotation
138
        val currentAnnotationIndex = if (currentAnnotation == null) {
139
            -1
140
        } else {
141
            documentAnnotations.indexOf(currentAnnotation)
142
        }
143
        val nextAnnotationIndex = min(currentAnnotationIndex + 1, documentAnnotations.size - 1)
144

145
        if (nextAnnotationIndex != currentAnnotationIndex) {
146
            currentAnnotation = documentAnnotations[nextAnnotationIndex]
147
            this.currentAnnotation = currentAnnotation
148

149
            val boundingBox = currentAnnotation.boundingBox
150
            boundingBox.inset(-ANNOTATION_BOUNDING_BOX_PADDING_PX.toFloat(), -ANNOTATION_BOUNDING_BOX_PADDING_PX.toFloat())
151

152
            requirePdfFragment().zoomTo(boundingBox, currentAnnotation.pageIndex, 300)
153
        }
154
    }
155

156
    /**
157
     * Called when pressing the "previous annotation" button. Finds the previous annotation and issues a call
158
     * to [PdfFragment.zoomTo].
159
     */
160
    private fun zoomToPreviousAnnotation() {
161
        if (documentAnnotations.isEmpty()) return
162

163
        var currentAnnotation = this.currentAnnotation ?: return
164

165
        val currentAnnotationIndex = documentAnnotations.indexOf(currentAnnotation)
166
        val nextAnnotationIndex = max(currentAnnotationIndex - 1, 0)
167
        if (nextAnnotationIndex != currentAnnotationIndex) {
168
            currentAnnotation = documentAnnotations[nextAnnotationIndex]
169
            this.currentAnnotation = currentAnnotation
170

171
            val boundingBox = currentAnnotation.boundingBox
172
            boundingBox.inset(-ANNOTATION_BOUNDING_BOX_PADDING_PX.toFloat(), -ANNOTATION_BOUNDING_BOX_PADDING_PX.toFloat())
173
            requirePdfFragment().zoomTo(boundingBox, currentAnnotation.pageIndex, 300)
174
        }
175
    }
176
}