PDF form filling in 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.net.Uri
12
import android.view.Menu
13
import android.view.MenuItem
14
import androidx.annotation.UiThread
15
import com.pspdfkit.catalog.R
16
import com.pspdfkit.catalog.SdkExample
17
import com.pspdfkit.catalog.tasks.ExtractAssetTask
18
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
19
import com.pspdfkit.document.PdfDocument
20
import com.pspdfkit.forms.CheckBoxFormElement
21
import com.pspdfkit.forms.FormType
22
import com.pspdfkit.forms.RadioButtonFormElement
23
import com.pspdfkit.forms.RadioButtonFormField
24
import com.pspdfkit.forms.TextFormElement
25
import com.pspdfkit.forms.TextInputFormat
26
import com.pspdfkit.ui.PdfActivity
27
import com.pspdfkit.ui.PdfActivityIntentBuilder
28
import io.reactivex.rxjava3.disposables.CompositeDisposable
29
import io.reactivex.rxjava3.disposables.Disposable
30

31
/**
32
 * Showcases how to fill forms programmatically.
33
 */
34
class FormFillingExample(context: Context) : SdkExample(context, R.string.formFillingExampleTitle, R.string.formFillingExampleDescription) {
35
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
36
        // Turn off saving, so we have the clean original document every time the example is launched.
37
        configuration.autosaveEnabled(false)
38

39
        // Enable form editing UI.
40
        configuration.formEditingEnabled(true)
41

42
        // Extract the example document from the assets.
43
        ExtractAssetTask.extract("Form_example.pdf", title, context) { documentFile ->
44
            val intent = PdfActivityIntentBuilder.fromUri(context, Uri.fromFile(documentFile))
45
                .configuration(configuration.build())
46
                .activityClass(FormFillingActivity::class)
47
                .build()
48
            context.startActivity(intent)
49
        }
50
    }
51
}
52

53
class FormFillingActivity : PdfActivity() {
54

55
    /** Holds disposables for all async operations done in this example. We dispose this when destroying the activity. */
56
    private val disposables = CompositeDisposable()
57

58
    @UiThread
59
    override fun onDocumentLoaded(document: PdfDocument) {
60
        super.onDocumentLoaded(document)
61
        fillAllFormFields()
62
    }
63

64
    /**
65
     * Fills form fields in the document with text "Example <field name>".
66
     */
67
    private fun fillAllFormFields() {
68
        val document = document ?: return
69
        document.formProvider.formElementsAsync.subscribe { formElements ->
70
            for (formElement in formElements) {
71
                when (formElement.type) {
72
                    FormType.TEXT -> {
73
                        val textFormElement = formElement as TextFormElement
74
                        when (textFormElement.inputFormat) {
75
                            TextInputFormat.DATE -> textFormElement.setText("03/14/1994")
76
                            else -> textFormElement.setText("Example " + formElement.getName())
77
                        }
78
                    }
79
                    FormType.CHECKBOX -> (formElement as CheckBoxFormElement).toggleSelection()
80
                    FormType.RADIOBUTTON -> (formElement as RadioButtonFormElement).toggleSelection()
81
                    else -> Unit
82
                }
83
            }
84
        }.addToDisposables()
85
    }
86

87
    /**
88
     * Resets all form fields in the document to their default values.
89
     */
90
    private fun resetForm() {
91
        val document = document ?: return
92

93
        document.formProvider.formFieldsAsync.subscribe { formFields ->
94
            for (formField in formFields) {
95
                formField.reset()
96
            }
97
        }.addToDisposables()
98
    }
99

100
    /**
101
     * Shows how to query form fields/elements by their name.
102
     */
103
    private fun fillByName() {
104
        val document = document ?: return
105

106
        // Form fields can be queried by their fully qualified name.
107
        // Each form field can have multiple child form elements that are
108
        // the widget annotations that are visually representing actionable
109
        // controls inside the form field.
110
        document.formProvider.getFormFieldWithFullyQualifiedNameAsync("Sex").subscribe { formField ->
111
            val formElement = formField as RadioButtonFormField
112
            // Sex radio button field has 2 child form elements. These represent 2 radio buttons in the radio group.
113
            // First radio element has the name "Sex.0" and represents the MALE option.
114
            //      formElement.getFormElements().get(0)
115
            // Second radio element has name "Sex.1" and represents the FEMALE option.
116
            //      formElement.getFormElements().get(1)
117
            // Select the MALE radio option.
118
            formElement.formElements[0].select()
119
        }.addToDisposables()
120

121
        // Form elements (visible portion of the form field) can be queried by their name and filled that way.
122
        document.formProvider.getFormElementWithNameAsync("First Name").subscribe { formElement ->
123
            (formElement as TextFormElement).setText("John")
124
        }.addToDisposables()
125
        document.formProvider.getFormElementWithNameAsync("Last Name").subscribe { formElement ->
126
            (formElement as TextFormElement).setText("Appleseed")
127
        }.addToDisposables()
128

129
        // Querying form elements by name can be slow. If you need to fill many form elements
130
        // at once, retrieve list of all form fields/elements first and iterate through it.
131
        document.formProvider.formElementsAsync.subscribe { formElements ->
132
            // For the sake of example we'll fill only address fields here.
133
            val formFillMap = mapOf(
134
                "Address_1" to "7440-7498 S Hanna St.",
135
                "Address_2" to "",
136
                "City" to "Fort Wayne",
137
                "STATE" to "IN",
138
                "ZIP" to "46774"
139
            )
140

141
            formElements.asSequence()
142
                .filterIsInstance(TextFormElement::class.java)
143
                .forEach { textElement ->
144
                    formFillMap[textElement.name]?.let { textElement.setText(it) }
145
                }
146
        }.addToDisposables()
147
    }
148

149
    override fun onCreateOptionsMenu(menu: Menu): Boolean {
150
        super.onCreateOptionsMenu(menu)
151
        menu.add(0, RESET_FORM_MENU_ITEM_ID, 0, "Reset form")
152
        menu.add(0, FILL_BY_FIELD_NAME, 0, "Fill by field name")
153
        return true
154
    }
155

156
    override fun onOptionsItemSelected(item: MenuItem): Boolean {
157
        return when (item.itemId) {
158
            RESET_FORM_MENU_ITEM_ID -> {
159
                resetForm()
160
                true
161
            }
162
            FILL_BY_FIELD_NAME -> {
163
                fillByName()
164
                true
165
            }
166
            else -> super.onOptionsItemSelected(item)
167
        }
168
    }
169

170
    override fun onDestroy() {
171
        super.onDestroy()
172
        disposables.clear()
173
    }
174

175
    private fun Disposable.addToDisposables() = disposables.add(this)
176

177
    companion object {
178
        private const val RESET_FORM_MENU_ITEM_ID = 1
179
        private const val FILL_BY_FIELD_NAME = 2
180
    }
181
}