Bookmark Highlighting

1
/*
2
 *   Copyright © 2020-2026 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.annotation.SuppressLint
11
import android.content.Context
12
import android.graphics.Canvas
13
import android.graphics.ColorFilter
14
import android.graphics.PixelFormat
15
import android.graphics.Rect
16
import android.graphics.drawable.Drawable
17
import android.net.Uri
18
import androidx.core.content.ContextCompat
19
import com.pspdfkit.bookmarks.Bookmark
20
import com.pspdfkit.catalog.R
21
import com.pspdfkit.catalog.SdkExample
22
import com.pspdfkit.catalog.tasks.ExtractAssetTask
23
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
24
import com.pspdfkit.configuration.activity.ThumbnailBarMode
25
import com.pspdfkit.document.PdfDocument
26
import com.pspdfkit.ui.PdfActivity
27
import com.pspdfkit.ui.PdfActivityIntentBuilder
28
import com.pspdfkit.ui.drawable.PdfDrawable
29
import com.pspdfkit.ui.drawable.PdfDrawableProvider
30
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
31
import io.reactivex.rxjava3.disposables.Disposable
32

33
/**
34
 * Example showing how to use the drawable API to put a drawn highlight on all pages that contain a bookmark.
35
 */
36
class BookmarkHighlightingExample(private val context: Context) : SdkExample(context, R.string.bookmarkHighlightingExampleTitle, R.string.bookmarkHighlightingExampleDescription) {
37

38
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
39
        // This uses larger thumbnails making our bookmark indicator more easily visible.
40
        configuration
41
            .setThumbnailBarMode(ThumbnailBarMode.THUMBNAIL_BAR_MODE_SCROLLABLE)
42
            .title("Bookmark Indicator")
43

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

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

56
    companion object {
57
        const val BOOKMARK_DOCUMENT = "bookmark_highlight_example.pdf"
58
    }
59
}
60

61
class BookmarkHighlightingActivity : PdfActivity() {
62

63
    /** List of bookmarks that current exist in the document. */
64
    private val currentBookmarks = mutableListOf<Bookmark>()
65

66
    /** Drawable provider that will put a bookmark icon on bookmarked pages. */
67
    private val drawableProvider = object : PdfDrawableProvider() {
68
        override suspend fun getDrawablesForPage(context: Context, document: PdfDocument, pageIndex: Int): List<PdfDrawable> {
69
            if (currentBookmarks.any { it.pageIndex == pageIndex }) {
70
                // If there's bookmark for the given page index, add our drawable.
71
                return listOf(BookmarkDrawable(this@BookmarkHighlightingActivity))
72
            } else {
73
                // Otherwise we draw nothing.
74
                return emptyList()
75
            }
76
        }
77
    }
78

79
    /** Used to stop the bookmark loading process when closing the activity. */
80
    private var bookmarkLoadingDisposable: Disposable? = null
81

82
    override fun onDocumentLoaded(document: PdfDocument) {
83
        super.onDocumentLoaded(document)
84
        // When the document is initially loaded we prepare the first set of bookmarks to be displayed.
85
        bookmarkLoadingDisposable = document
86
            .bookmarkProvider
87
            .bookmarksAsync
88
            .firstOrError()
89
            .observeOn(AndroidSchedulers.mainThread())
90
            .subscribe { bookmarks ->
91
                updateBookmarkDrawables(bookmarks)
92
            }
93

94
        // Afterwards we subscribe to be updated whenever the list of bookmarks change.
95
        document.bookmarkProvider.addBookmarkListener {
96
            // This is always called on the UI thread so no need for special concurrency handling.
97
            updateBookmarkDrawables(it)
98
        }
99
    }
100

101
    private fun updateBookmarkDrawables(newBookmarks: List<Bookmark>) {
102
        currentBookmarks.clear()
103
        currentBookmarks.addAll(newBookmarks)
104

105
        // We need to add and remove the provider so the drawables are correctly redrawn.
106
        pspdfKitViews.thumbnailBarView?.apply {
107
            removeDrawableProvider(drawableProvider)
108
            addDrawableProvider(drawableProvider)
109
        }
110
        pspdfKitViews.thumbnailGridView?.apply {
111
            removeDrawableProvider(drawableProvider)
112
            addDrawableProvider(drawableProvider)
113
        }
114
    }
115

116
    override fun onDestroy() {
117
        super.onDestroy()
118
        // Make sure to dispose of this before closing the activity.
119
        bookmarkLoadingDisposable?.dispose()
120
    }
121
}
122

123
/**
124
 * An implementation of [PdfDrawable], which shows an indicator on bookmarked pages.
125
 */
126
private class BookmarkDrawable(private val context: Context) : PdfDrawable() {
127

128
    // This has to be non null, otherwise this whole example will do nothing.
129
    private val bookmarkDrawable: Drawable = ContextCompat.getDrawable(context, R.drawable.ic_bookmark_highlight)!!
130

131
    /**
132
     * This will draw our bookmarkDrawable on to the page.
133
     */
134
    @SuppressLint("CanvasSize")
135
    override fun draw(canvas: Canvas) {
136
        // First we convert our DP constants to their respective pixel sizes.
137
        val baseSize = BASE_SIZE_DP * context.resources.displayMetrics.density
138
        val bookmarkSize = BOOKMARK_SIZE_DP * context.resources.displayMetrics.density
139
        val margin = MARGIN_DP * context.resources.displayMetrics.density
140

141
        // We use the canvas size here since that will be the size of the entire page in the thumbnail bar / grid.
142
        // Based on this size we calculate the real size our bookmark icon will be.
143
        val ratio = canvas.width / baseSize
144
        val effectiveBookmarkSize = bookmarkSize * ratio
145
        val effectiveMargin = margin * ratio
146

147
        // Then we place the bookmark in top right edge, with some margin to the right,
148
        // and moving it up a bit so it sits flush with the page edge.
149
        bookmarkDrawable.bounds = Rect(
150
            (canvas.width - effectiveBookmarkSize - effectiveMargin).toInt(),
151
            -effectiveMargin.toInt(),
152
            (canvas.width - effectiveMargin).toInt(),
153
            effectiveBookmarkSize.toInt()
154
        )
155

156
        // Finally we simply draw it onto the page.
157
        bookmarkDrawable.draw(canvas)
158
    }
159

160
    override fun setAlpha(alpha: Int) {
161
        // Not required.
162
    }
163

164
    @Deprecated("Deprecated in Java")
165
    override fun getOpacity(): Int {
166
        return PixelFormat.TRANSLUCENT
167
    }
168

169
    override fun setColorFilter(colorFilter: ColorFilter?) {
170
        // Not required.
171
    }
172

173
    companion object {
174
        /** The width in DP at which the bookmark icon will have it's size, used to scale depending on context. */
175
        const val BASE_SIZE_DP = 100
176

177
        /** The size of the bookmark icon assuming the size of the canvas is BASE_SIZE_DP. */
178
        const val BOOKMARK_SIZE_DP = 24
179

180
        /** The margin to apply to the bookmark icon. */
181
        const val MARGIN_DP = 8
182
    }
183
}