Document JSON

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.content.Context
11
import android.content.Intent
12
import android.net.Uri
13
import android.util.Log
14
import android.view.Menu
15
import android.view.MenuItem
16
import android.widget.Toast
17
import androidx.appcompat.app.AppCompatActivity
18
import androidx.lifecycle.lifecycleScope
19
import com.pspdfkit.catalog.R
20
import com.pspdfkit.catalog.SdkExample
21
import com.pspdfkit.catalog.SdkExample.Companion.TAG
22
import com.pspdfkit.catalog.tasks.ExtractAssetTask
23
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
24
import com.pspdfkit.configuration.sharing.ShareFeatures
25
import com.pspdfkit.document.formatters.DocumentJsonFormatter
26
import com.pspdfkit.document.providers.ContentResolverDataProvider
27
import com.pspdfkit.ui.PdfActivity
28
import com.pspdfkit.ui.PdfActivityIntentBuilder
29
import kotlinx.coroutines.Dispatchers
30
import kotlinx.coroutines.launch
31
import kotlinx.coroutines.withContext
32
import java.util.EnumSet
33

34
/**
35
 * This example shows how annotation changes can be exported to the Instant Document JSON format,
36
 * and how they can be imported. You can launch the example and then modify, remove, or add
37
 * annotations to the document. When exporting to JSON, all changes to the document will be
38
 * included. You can always reapply the changes by tapping import, but the example works best if you
39
 * close the example and reopen it before importing (so the document's original state is restored).
40
 */
41
class DocumentJsonExample(context: Context) : SdkExample(context, R.string.documentJsonExampleTitle, R.string.documentJsonExampleDescription) {
42
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
43
        // Disable auto-save so we get the original document when example is opened.
44
        configuration.autosaveEnabled(false)
45

46
        // Clean-up the primary toolbar for the sake of simplicity in this example.
47
        configuration
48
            .annotationListEnabled(false)
49
            .bookmarkListEnabled(false)
50
            .thumbnailGridEnabled(false)
51
            .settingsMenuEnabled(false)
52
            .documentEditorEnabled(false)
53
            .outlineEnabled(false)
54
            .printingEnabled(false)
55
            .setEnabledShareFeatures(EnumSet.noneOf(ShareFeatures::class.java))
56
            .searchEnabled(false)
57

58
        // Load and show the a custom activity for importing and exporting document JSON.
59
        ExtractAssetTask.extract(ANNOTATIONS_EXAMPLE, title, context, false) { documentFile ->
60
            val intent = PdfActivityIntentBuilder.fromUri(context, Uri.fromFile(documentFile))
61
                .activityClass(DocumentJsonExampleActivity::class)
62
                .configuration(configuration.build())
63
                .build()
64
            context.startActivity(intent)
65
        }
66
    }
67
}
68

69
/**
70
 * This activity allows editing of annotations and exporting and importing of changes
71
 * to an Instant Document JSON file on the external storage.
72
 */
73
// We're temporarily suppressing the warning for startActivityForResult being deprecated.
74
// Issue: https://github.com/PSPDFKit/PSPDFKit/issues/31881
75
@Suppress("DEPRECATION")
76
class DocumentJsonExampleActivity : PdfActivity() {
77

78
    /** Adds import/export actions to the toolbar.  */
79
    override fun onCreateOptionsMenu(menu: Menu): Boolean {
80
        super.onCreateOptionsMenu(menu)
81
        menuInflater.inflate(R.menu.document_json_example, menu)
82
        return true
83
    }
84

85
    override fun onOptionsItemSelected(item: MenuItem): Boolean {
86
        return when (item.itemId) {
87
            R.id.import_json -> {
88
                pickFileForJsonImport()
89
                true
90
            }
91
            R.id.export_json -> {
92
                pickFileForJsonExport()
93
                true
94
            }
95
            else -> super.onOptionsItemSelected(item)
96
        }
97
    }
98

99
    /**
100
     * Fires up [Intent.ACTION_CREATE_DOCUMENT] to allow user to pick output file for Document JSON export.
101
     */
102
    private fun pickFileForJsonExport() {
103
        if (document == null) return
104
        val intent = Intent(Intent.ACTION_CREATE_DOCUMENT)
105
        intent.type = "application/*"
106
        intent.addCategory(Intent.CATEGORY_OPENABLE)
107
        // This sets the default name of the output file.
108
        intent.putExtra(Intent.EXTRA_TITLE, "document.json")
109
        startActivityForResult(intent, PICK_EXPORT_FILE_RESULT)
110
    }
111

112
    /**
113
     * Fires up [Intent.ACTION_OPEN_DOCUMENT] to allow user to pick input file for Document JSON import.
114
     */
115
    private fun pickFileForJsonImport() {
116
        if (document == null) return
117
        val intent = Intent(Intent.ACTION_OPEN_DOCUMENT)
118
        intent.type = "application/*"
119
        intent.addCategory(Intent.CATEGORY_OPENABLE)
120
        startActivityForResult(intent, PICK_IMPORT_FILE_RESULT)
121
    }
122

123
    @Deprecated("Deprecated in Java")
124
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
125
        super.onActivityResult(requestCode, resultCode, data)
126

127
        if (resultCode != AppCompatActivity.RESULT_OK) return
128
        val uri = data?.data ?: return
129

130
        when (requestCode) {
131
            PICK_EXPORT_FILE_RESULT -> exportDocumentJson(uri)
132
            PICK_IMPORT_FILE_RESULT -> importDocumentJson(uri)
133
        }
134
    }
135

136
    private fun exportDocumentJson(uri: Uri) {
137
        val document = document ?: return
138

139
        val outputStream = try {
140
            contentResolver.openOutputStream(uri)
141
        } catch (e: Throwable) {
142
            Toast.makeText(this, "Error while opening '$uri' for export. See logcat for more info.", Toast.LENGTH_LONG).show()
143
            Log.e(TAG, "Error while opening '$uri' for export", e)
144
            return
145
        } ?: run {
146
            Toast.makeText(this, "Error while opening '$uri' for export.", Toast.LENGTH_LONG).show()
147
            return
148
        }
149

150
        lifecycleScope.launch {
151
            try {
152
                withContext(Dispatchers.IO) {
153
                    outputStream.use {
154
                        DocumentJsonFormatter.exportDocumentJson(document, it)
155
                    }
156
                }
157
                showToast("Export successful!.")
158
            } catch (throwable: Throwable) {
159
                showToast("Error while exporting document JSON. See logcat for more info.")
160
                Log.e(TAG, "Error while exporting document JSON", throwable)
161
            }
162
        }
163
    }
164

165
    private fun importDocumentJson(uri: Uri) {
166
        val document = document ?: return
167

168
        lifecycleScope.launch {
169
            try {
170
                withContext(Dispatchers.IO) {
171
                    DocumentJsonFormatter.importDocumentJson(document, ContentResolverDataProvider(uri))
172
                }
173
                showToast("Import successful!")
174
            } catch (throwable: Throwable) {
175
                showToast("Error while importing document JSON. See logcat for more info.")
176
                Log.e(TAG, "Error while importing document JSON", throwable)
177
            }
178
        }
179
    }
180

181
    private fun showToast(msg: String) {
182
        Toast.makeText(this, msg, Toast.LENGTH_LONG).show()
183
    }
184

185
    companion object {
186
        private const val PICK_EXPORT_FILE_RESULT = 1
187
        private const val PICK_IMPORT_FILE_RESULT = 2
188
    }
189
}