Open a PDF from a custom data provider using Kotlin for Android

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.content.res.Resources
12
import android.os.Parcel
13
import android.os.Parcelable
14
import androidx.annotation.RawRes
15
import com.pspdfkit.catalog.R
16
import com.pspdfkit.catalog.SdkExample
17
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
18
import com.pspdfkit.document.providers.DataProvider
19
import com.pspdfkit.document.providers.InputStreamDataProvider
20
import com.pspdfkit.ui.PdfActivity
21
import com.pspdfkit.ui.PdfActivityIntentBuilder
22
import java.io.IOException
23
import java.io.InputStream
24

25
/**
26
 * This example shows how to create a custom data provider that reads a document from the `raw` resources
27
 * of the app. Furthermore, it implements [Parcelable] to allow using the data provider with  [PdfActivity].
28
 */
29
class CustomDataProviderExample(context: Context) : SdkExample(context, R.string.customDataProviderExampleTitle, R.string.customDataProviderExampleDescription) {
30

31
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
32
        // Create an instance of the custom data provider. See the implementation details below.
33
        val dataProvider: DataProvider = RawResourceDataProvider(R.raw.guide)
34

35
        // Start the activity using our custom data provider.
36
        val intent = PdfActivityIntentBuilder.fromDataProvider(context, dataProvider)
37
            .configuration(configuration.build())
38
            .build()
39
        context.startActivity(intent)
40
    }
41
}
42

43
/**
44
 * Custom data provider for loading a PDF document from the app's raw resources. Since
45
 * [Resources.openRawResource] returns an `InputStream`, this provider derives from
46
 * `InputStreamDataProvider` which handles loading data from a stream object.
47
 *
48
 * @param resId The id of the PDF document inside the resources (stored within the `res/raw` folder of the application).
49
 */
50
class RawResourceDataProvider(@RawRes private val resId: Int) : InputStreamDataProvider(), Parcelable {
51

52
    /**
53
     * The size of the raw resource. This will be cached after the first call to [.getSize].
54
     */
55
    private var size = DataProvider.FILE_SIZE_UNKNOWN.toLong()
56

57
    /**
58
     * We return the InputStream for the referenced raw resource. Since InputStreamDataProvider may call this
59
     * method multiple times we have to make sure that it always returns a fresh input stream object.
60
     */
61
    @Throws(IOException::class)
62
    override fun openInputStream(): InputStream {
63
        return getContext().resources.openRawResource(resId)
64
    }
65

66
    /**
67
     * This method returns the size of our resource. Android only gives us an [InputStream] for
68
     * accessing the resources. Thus we have to reopen the input stream if current stream
69
     * position is not at the start.
70
     */
71
    override fun getSize(): Long {
72
        // If the file size is already known, return it immediately.
73
        if (size != DataProvider.FILE_SIZE_UNKNOWN.toLong()) {
74
            return size
75
        }
76

77
        val inputStreamSize = try {
78
            // Since we can only get size of the available data in the input stream we need to
79
            // reopen it here if the stream position is not 0.
80
            if (inputStreamPosition != 0L) {
81
                reopenInputStream()
82
            }
83
            openInputStream().available()
84
        } catch (e: Exception) {
85
            DataProvider.FILE_SIZE_UNKNOWN
86
        }
87

88
        size = inputStreamSize.toLong()
89
        return size
90
    }
91

92
    override fun getUid(): String {
93
        return getContext().resources.getResourceName(resId)
94
    }
95

96
    override fun getTitle(): String {
97
        // If you know the file or document name upfront, you can return it here. Otherwise return null,
98
        // which will instruct Nutrient to use the title stored within the document (if any).
99
        return "PSPDFKit Quickstart Guide"
100
    }
101

102
    // The code below is standard Android parcelation code. If you don't know how to implement the Parcelable
103
    // interface start looking at {@link http://developer.android.com/reference/android/os/Parcelable.html}.
104

105
    /**
106
     * Default parcelable implementation. The object is always parceled the same way. Thus, we return 0.
107
     */
108
    override fun describeContents(): Int {
109
        return 0
110
    }
111

112
    /**
113
     * We simply write the id of the PDF resource to the parcel.
114
     */
115
    override fun writeToParcel(dest: Parcel, flags: Int) {
116
        dest.writeInt(resId)
117
    }
118

119
    /**
120
     * Constructor required for unparcelation, takes a `input` Parcel and reads the raw resource id from it.
121
     */
122
    internal constructor(input: Parcel) : this(input.readInt())
123

124
    companion object CREATOR : Parcelable.Creator<RawResourceDataProvider> {
125
        override fun createFromParcel(parcel: Parcel): RawResourceDataProvider {
126
            return RawResourceDataProvider(parcel)
127
        }
128

129
        override fun newArray(size: Int): Array<RawResourceDataProvider?> {
130
            return arrayOfNulls(size)
131
        }
132
    }
133
}