Open PDFs in Android 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.app.Activity
11
import android.app.AlertDialog
12
import android.content.Context
13
import android.content.Intent
14
import android.net.Uri
15
import android.os.Build
16
import android.os.Build.VERSION.SDK_INT
17
import android.os.Bundle
18
import android.os.Environment
19
import android.widget.Toast
20
import androidx.fragment.app.FragmentActivity
21
import com.pspdfkit.Nutrient
22
import com.pspdfkit.catalog.R
23
import com.pspdfkit.catalog.SdkExample
24
import com.pspdfkit.catalog.utils.Utils
25
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
26
import com.pspdfkit.document.ImageDocumentLoader
27
import com.pspdfkit.document.ImageDocumentUtils
28
import com.pspdfkit.document.download.DownloadJob
29
import com.pspdfkit.document.download.DownloadProgressFragment
30
import com.pspdfkit.document.download.DownloadRequest
31
import com.pspdfkit.ui.PdfActivityIntentBuilder
32
import com.pspdfkit.utils.getSupportParcelableExtra
33
import java.io.File
34

35
/**
36
 * This example shows how to build a custom activity that allows the user to pick a document.
37
 */
38
class ExternalDocumentExample(context: Context) :
39
    SdkExample(context, R.string.externalDocumentExampleTitle, R.string.externalDocumentExampleDescription) {
40

41
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
42
        val intent = Intent(context, ExternalExampleActivity::class.java)
43
        intent.putExtra(ExternalExampleActivity.EXTRA_CONFIGURATION, configuration.build())
44
        context.startActivity(intent)
45
    }
46
}
47

48
class ExternalExampleActivity : FragmentActivity() {
49

50
    private lateinit var configuration: PdfActivityConfiguration
51

52
    private var waitingForResult = false
53

54
    override fun onCreate(savedInstanceState: Bundle?) {
55
        super.onCreate(savedInstanceState)
56

57
        // Extract the configuration for displaying the viewer activity.
58
        configuration = intent.getSupportParcelableExtra(EXTRA_CONFIGURATION, PdfActivityConfiguration::class.java)
59
            ?: throw ExceptionInInitializerError(
60
                ExternalExampleActivity::class.java.simpleName +
61
                    " was started without a PdfActivityConfiguration."
62
            )
63

64
        // Check if the activity was recreated, and see if the user already started document picking.
65
        waitingForResult = savedInstanceState?.getBoolean(IS_WAITING_FOR_RESULT, false) ?: false
66

67
        // Prevent the example from requesting multiple documents at the same time.
68
        if (!waitingForResult) {
69
            waitingForResult = true
70
            if (Utils.hasExternalStorageRwPermission(this)) {
71
                showOpenFileDialog()
72
            } else {
73
                showPermissionExplanationDialog()
74
            }
75
        }
76
    }
77

78
    @Deprecated("Deprecated in Java")
79
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
80
        super.onActivityResult(requestCode, resultCode, data)
81

82
        if (requestCode == REQUEST_OPEN_DOCUMENT) {
83
            waitingForResult = false
84
            if (resultCode == Activity.RESULT_OK && data != null) {
85
                val uri = data.data ?: return
86

87
                val isImageFile = ImageDocumentUtils.isImageUri(this, uri)
88

89
                // Some URIs can be opened directly, including local filesystem, app assets, and content provider URIs.
90
                if (Nutrient.isOpenableUri(this, uri)) {
91
                    startActivity(createActivityIntent(uri, configuration, isImageFile))
92
                    finish()
93
                } else {
94
                    // Find the DownloadProgressFragment for showing download progress, or create a new one.
95
                    val downloadFragment = supportFragmentManager.findFragmentByTag(
96
                        DOWNLOAD_PROGRESS_FRAGMENT
97
                    ) as DownloadProgressFragment? ?: run {
98
                        DownloadProgressFragment().apply {
99
                            val request = DownloadRequest.Builder(this@ExternalExampleActivity).uri(uri).build()
100
                            this.job = DownloadJob.startDownload(request)
101
                            show(supportFragmentManager, DOWNLOAD_PROGRESS_FRAGMENT)
102
                        }
103
                    }
104

105
                    // Once the download is complete we launch the PdfActivity from the downloaded file.
106
                    downloadFragment.job.setProgressListener(object : DownloadJob.ProgressListenerAdapter() {
107
                        override fun onComplete(output: File) {
108
                            startActivity(createActivityIntent(Uri.fromFile(output), configuration, isImageFile))
109
                            finish()
110
                        }
111
                    })
112
                }
113
            } else if (resultCode == Activity.RESULT_CANCELED) {
114
                // If the user cancelled document selection, we just close the activity.
115
                finish()
116
            }
117
        } else if (requestCode == REQUEST_ASK_FOR_PERMISSION) {
118
            if (SDK_INT >= Build.VERSION_CODES.R) {
119
                if (Environment.isExternalStorageManager()) {
120
                    showOpenFileDialog()
121
                } else {
122
                    Toast.makeText(this, "Allow permission for storage access!", Toast.LENGTH_SHORT)
123
                        .show()
124
                }
125
            }
126
        }
127
    }
128

129
    private fun createActivityIntent(uri: Uri, baseConfiguration: PdfActivityConfiguration, isImageFile: Boolean): Intent {
130
        val pdfActivityIntentBuilder: PdfActivityIntentBuilder
131
        var configuration = baseConfiguration
132

133
        if (isImageFile) {
134
            pdfActivityIntentBuilder = PdfActivityIntentBuilder.fromImageUri(this, uri)
135
            // Get the default image document configuration.
136
            // Default options in this configuration are specifically thought to enhance the user
137
            // experience for image documents (e.g. thumbnail bar and page number overlay are hidden).
138
            configuration = ImageDocumentLoader.getDefaultImageDocumentActivityConfiguration(configuration)
139
        } else {
140
            pdfActivityIntentBuilder = PdfActivityIntentBuilder.fromUri(this, uri)
141
        }
142
        return pdfActivityIntentBuilder.configuration(configuration).build()
143
    }
144

145
    override fun onSaveInstanceState(outState: Bundle) {
146
        super.onSaveInstanceState(outState)
147
        // Retain if we are currently waiting for an intent to return, so we don't set it off twice by accident.
148
        outState.putBoolean(IS_WAITING_FOR_RESULT, waitingForResult)
149
    }
150

151
    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
152
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
153
        if (requestCode == REQUEST_ASK_FOR_PERMISSION) {
154
            // We attempt to open document after permissions have been requested.
155
            // Nutrient can open documents without the permissions when SAF is used, however the access
156
            // without permissions will be significantly slower.
157
            showOpenFileDialog()
158
        }
159
    }
160

161
    private fun showPermissionExplanationDialog() {
162
        AlertDialog.Builder(this)
163
            .setMessage(R.string.externalDocumentExamplePermissionExplanation)
164
            .setCancelable(false)
165
            .setPositiveButton(R.string.grantAccess) { _, _ ->
166
                Utils.requestExternalStorageRwPermission(this, REQUEST_ASK_FOR_PERMISSION)
167
            }
168
            .setNegativeButton(R.string.continueWithout) { dialog, _ ->
169
                dialog.cancel()
170
                Toast.makeText(this, "Allow permission for storage access!", Toast.LENGTH_SHORT).show()
171
            }
172
            .show()
173
    }
174

175
    // We're temporarily suppressing the warning for startActivityForResult being deprecated.
176
    // Issue: https://github.com/PSPDFKit/PSPDFKit/issues/31881
177
    @Suppress("DEPRECATION")
178
    private fun showOpenFileDialog() {
179
        // Prepare an implicit intent which allows the user to select any document.
180
        val intent = Intent(Intent.ACTION_OPEN_DOCUMENT)
181
        intent.addCategory(Intent.CATEGORY_OPENABLE)
182
        intent.type = "*/*"
183

184
        // We accept PDF files and images (for image documents).
185
        intent.putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("application/pdf", "image/*"))
186

187
        // Set of the intent for result, so we can retrieve the Uri of the selected document.
188
        startActivityForResult(intent, REQUEST_OPEN_DOCUMENT)
189
    }
190

191
    companion object {
192
        internal const val EXTRA_CONFIGURATION = "Nutrient.ExternalExampleActivity.configuration"
193

194
        private const val REQUEST_OPEN_DOCUMENT = 1
195
        private const val REQUEST_ASK_FOR_PERMISSION = 2
196
        private const val IS_WAITING_FOR_RESULT = "Nutrient.ExternalExampleActivity.waitingForResult"
197
        private const val DOWNLOAD_PROGRESS_FRAGMENT = "DownloadProgressFragment"
198
    }
199
}