XFDF Example

1
/*
2
 *   Copyright © 2018-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.view.Menu
14
import android.view.MenuItem
15
import android.widget.Toast
16
import androidx.appcompat.app.AppCompatActivity
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.extract
21
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
22
import com.pspdfkit.document.formatters.XfdfFormatter
23
import com.pspdfkit.document.providers.ContentResolverDataProvider
24
import com.pspdfkit.ui.PdfActivity
25
import com.pspdfkit.ui.PdfActivityIntentBuilder
26
import kotlinx.coroutines.CoroutineScope
27
import kotlinx.coroutines.Dispatchers
28
import kotlinx.coroutines.launch
29
import kotlinx.coroutines.withContext
30
import java.io.FileNotFoundException
31
import java.util.EnumSet
32

33
/** Shows how to import and export annotations in XFDF format. */
34
class XfdfExample(context: Context) :
35
    SdkExample(
36
        context,
37
        R.string.xfdfExampleTitle,
38
        R.string.xfdfExampleDescription,
39
    ) {
40
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
41
        // Extract the document from the assets and launch example activity.
42
        extract(WELCOME_DOC, title, context) { documentFile ->
43
            val intent =
44
                PdfActivityIntentBuilder
45
                    .fromUri(context, Uri.fromFile(documentFile))
46
                    .configuration(configuration.build())
47
                    .activityClass(XfdfExampleActivity::class.java)
48
                    .build()
49
            context.startActivity(intent)
50
        }
51
    }
52
}
53

54
/** This activity shows how to import and export annotations in XFDF format. */
55
class XfdfExampleActivity : PdfActivity() {
56
    override fun onCreateOptionsMenu(menu: Menu): Boolean {
57
        super.onCreateOptionsMenu(menu)
58
        menu.add(0, EXPORT_TO_XFDF_ITEM_ID, 0, "Export to XFDF")
59
        menu.add(0, IMPORT_FROM_XFDF_ITEM_ID, 0, "Import from XFDF")
60
        return true
61
    }
62

63
    override fun onOptionsItemSelected(item: MenuItem): Boolean = when (item.itemId) {
64
        EXPORT_TO_XFDF_ITEM_ID -> {
65
            pickFileForXfdfExport()
66
            true
67
        }
68

69
        IMPORT_FROM_XFDF_ITEM_ID -> {
70
            pickFileForXfdfImport()
71
            true
72
        }
73

74
        else -> {
75
            super.onOptionsItemSelected(item)
76
        }
77
    }
78

79
    /**
80
     * Fires up [Intent.ACTION_CREATE_DOCUMENT] to allows user to pick output file for XFDF
81
     * export.
82
     */
83
    @Suppress("DEPRECATION")
84
    private fun pickFileForXfdfExport() {
85
        if (document == null) return
86

87
        val intent =
88
            Intent(Intent.ACTION_CREATE_DOCUMENT).apply {
89
                type = "application/*"
90
                addCategory(Intent.CATEGORY_OPENABLE)
91
                // This sets the default name of the output file.
92
                putExtra(Intent.EXTRA_TITLE, "annotations.xfdf")
93
            }
94

95
        startActivityForResult(intent, PICK_EXPORT_FILE_RESULT)
96
    }
97

98
    /**
99
     * Fires up [Intent.ACTION_OPEN_DOCUMENT] to allows user to pick input file for XFDF
100
     * import.
101
     */
102
    @Suppress("DEPRECATION")
103
    private fun pickFileForXfdfImport() {
104
        if (document == null) return
105

106
        val intent =
107
            Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
108
                type = "application/*"
109
                addCategory(Intent.CATEGORY_OPENABLE)
110
            }
111

112
        startActivityForResult(intent, PICK_IMPORT_FILE_RESULT)
113
    }
114

115
    @Deprecated("Deprecated in Java")
116
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
117
        super.onActivityResult(requestCode, resultCode, data)
118

119
        if (resultCode != AppCompatActivity.RESULT_OK || data == null) return
120
        val uri = data.data ?: return
121

122
        when (requestCode) {
123
            PICK_EXPORT_FILE_RESULT -> exportToXfdf(uri)
124
            PICK_IMPORT_FILE_RESULT -> importFromXfdf(uri)
125
        }
126
    }
127

128
    /**
129
     * Exports annotations from the first page to the XFDF file.
130
     *
131
     * @param uri Uri of the target file for XFDF export.
132
     */
133
    private fun exportToXfdf(uri: Uri) {
134
        try {
135
            val outputStream = contentResolver.openOutputStream(uri) ?: return
136

137
            CoroutineScope(Dispatchers.Main).launch {
138
                try {
139
                    val doc = document ?: return@launch
140

141
                    val allAnnotations =
142
                        doc.annotationProvider.getAllAnnotationsOfType(
143
                            EnumSet.allOf(AnnotationType::class.java),
144
                        )
145
                    withContext(Dispatchers.IO) {
146
                        XfdfFormatter.writeXfdf(doc, allAnnotations, emptyList(), outputStream)
147
                        outputStream.close()
148
                    }
149
                    Toast
150
                        .makeText(
151
                            this@XfdfExampleActivity,
152
                            "Annotations successfully exported",
153
                            Toast.LENGTH_LONG,
154
                        ).show()
155
                } catch (e: Exception) {
156
                    Toast
157
                        .makeText(
158
                            this@XfdfExampleActivity,
159
                            "Annotations export failed",
160
                            Toast.LENGTH_LONG,
161
                        ).show()
162
                }
163
            }
164
        } catch (ignored: FileNotFoundException) {
165
        }
166
    }
167

168
    /**
169
     * Imports annotations from XFDF file and adds them to the document.
170
     *
171
     * @param uri Uri of the XFDF file from which to import annotations.
172
     */
173
    private fun importFromXfdf(uri: Uri) {
174
        CoroutineScope(Dispatchers.Main).launch {
175
            try {
176
                val doc = document ?: return@launch
177
                val annotations =
178
                    withContext(Dispatchers.IO) {
179
                        XfdfFormatter.parseXfdf(doc, ContentResolverDataProvider(uri))
180
                    }
181
                // Annotations parsed from XFDF are not added to document automatically.
182
                // We need to add them manually.
183
                for (annotation in annotations) {
184
                    pdfFragment?.addAnnotationToPage(annotation, false)
185
                }
186

187
                Toast
188
                    .makeText(
189
                        this@XfdfExampleActivity,
190
                        "Annotations successfully imported",
191
                        Toast.LENGTH_LONG,
192
                    ).show()
193
            } catch (e: Exception) {
194
                Toast
195
                    .makeText(
196
                        this@XfdfExampleActivity,
197
                        "Annotations import failed",
198
                        Toast.LENGTH_LONG,
199
                    ).show()
200
            }
201
        }
202
    }
203

204
    companion object {
205
        private const val EXPORT_TO_XFDF_ITEM_ID = 1
206
        private const val IMPORT_FROM_XFDF_ITEM_ID = 2
207

208
        private const val PICK_EXPORT_FILE_RESULT = 1
209
        private const val PICK_IMPORT_FILE_RESULT = 2
210
    }
211
}