AI Assistant (Single Document)

1
/*
2
 *   Copyright © 2025-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.graphics.RectF
13
import android.os.Bundle
14
import androidx.activity.compose.setContent
15
import androidx.activity.enableEdgeToEdge
16
import androidx.appcompat.app.AppCompatActivity
17
import androidx.compose.animation.AnimatedVisibility
18
import androidx.compose.animation.expandVertically
19
import androidx.compose.animation.fadeIn
20
import androidx.compose.animation.fadeOut
21
import androidx.compose.animation.shrinkVertically
22
import androidx.compose.animation.slideInVertically
23
import androidx.compose.animation.slideOutVertically
24
import androidx.compose.foundation.layout.Box
25
import androidx.compose.foundation.layout.fillMaxSize
26
import androidx.compose.foundation.layout.navigationBarsPadding
27
import androidx.compose.material3.ExperimentalMaterial3Api
28
import androidx.compose.material3.Icon
29
import androidx.compose.material3.IconButton
30
import androidx.compose.material3.MaterialTheme
31
import androidx.compose.material3.Text
32
import androidx.compose.material3.TopAppBar
33
import androidx.compose.material3.TopAppBarDefaults
34
import androidx.compose.runtime.Composable
35
import androidx.compose.runtime.getValue
36
import androidx.compose.runtime.mutableStateOf
37
import androidx.compose.runtime.remember
38
import androidx.compose.runtime.setValue
39
import androidx.compose.ui.Alignment
40
import androidx.compose.ui.Modifier
41
import androidx.compose.ui.graphics.Color
42
import androidx.compose.ui.platform.LocalContext
43
import androidx.compose.ui.platform.LocalDensity
44
import androidx.compose.ui.res.painterResource
45
import androidx.compose.ui.unit.dp
46
import com.pspdfkit.ai.createAiAssistant
47
import com.pspdfkit.catalog.R
48
import com.pspdfkit.catalog.SdkExample
49
import com.pspdfkit.catalog.SdkExample.Companion.WELCOME_DOC
50
import com.pspdfkit.catalog.ui.theming.CatalogTheme
51
import com.pspdfkit.catalog.utils.JwtGenerator
52
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
53
import com.pspdfkit.document.providers.AssetDataProvider
54
import com.pspdfkit.jetpack.compose.interactors.DefaultListeners
55
import com.pspdfkit.jetpack.compose.interactors.DocumentState
56
import com.pspdfkit.jetpack.compose.interactors.getDefaultDocumentManager
57
import com.pspdfkit.jetpack.compose.interactors.rememberDocumentState
58
import com.pspdfkit.jetpack.compose.views.DocumentView
59
import com.pspdfkit.ui.DocumentDescriptor
60
import com.pspdfkit.ui.PdfActivity
61
import io.nutrient.domain.ai.AiAssistant
62
import io.nutrient.domain.ai.AiAssistantProvider
63

64
/**
65
 * Shows how to implement AI Assistant for the DocumentView in a Compose way.
66
 */
67
class AiAssistantComposeExample(context: Context) :
68
    SdkExample(
69
        context,
70
        R.string.jetpackAiAssistantExampleTitle,
71
        R.string.jetpackAiAssistantExampleDescription,
72
    ) {
73
    override val launchRequirements = setOf(SdkExample.LaunchRequirement.AI_ASSISTANT_SERVER)
74

75
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
76
        val intent = Intent(context, AiAssistantComposeActivity::class.java)
77
        context.startActivity(intent)
78
    }
79
}
80

81
class AiAssistantComposeActivity :
82
    AppCompatActivity(),
83
    AiAssistantProvider {
84
    private lateinit var documentState: DocumentState
85
    private val sessionId = AiAssistantComposeActivity::class.java.simpleName
86
    private val assetProvider = AssetDataProvider(WELCOME_DOC)
87
    private var ipAddressValue: String? = null
88

89
    override fun onCreate(savedInstanceState: Bundle?) {
90
        enableEdgeToEdge()
91
        super.onCreate(savedInstanceState)
92

93
        val preferences = getSharedPreferences(PREFERENCES_NAME, MODE_PRIVATE)
94
        ipAddressValue = preferences.getString(PREF_AI_IP_ADDRESS, "") ?: ""
95

96
        setContent {
97
            var enabled by remember { mutableStateOf(false) }
98
            var toolbarVisibility by remember { mutableStateOf(true) }
99

100
            CatalogTheme {
101
                val activityConfiguration =
102
                    PdfActivityConfiguration
103
                        .Builder(LocalContext.current)
104
                        .setAiAssistantEnabled(true)
105
                        .defaultToolbarEnabled(false)
106
                        .theme(R.style.PSPDFCatalog_AIAssistantDialog)
107
                        .themeDark(R.style.PSPDFCatalog_AIAssistantDialog_Dark)
108
                        .build()
109

110
                documentState = rememberDocumentState(assetProvider, activityConfiguration)
111

112
                Box(
113
                    modifier =
114
                    Modifier
115
                        .fillMaxSize()
116
                        .navigationBarsPadding(),
117
                ) {
118
                    DocumentView(
119
                        documentState = documentState,
120
                        documentManager =
121
                        getDefaultDocumentManager(
122
                            documentListener =
123
                            DefaultListeners.documentListeners(
124
                                onDocumentLoaded = {
125
                                    enabled = true
126
                                },
127
                            ),
128
                            uiListener =
129
                            DefaultListeners.uiListeners(
130
                                onImmersiveModeEnabled = { toolbarVisibility = !it },
131
                            ),
132
                        ),
133
                    )
134
                }
135
                CustomToolbar(documentState, enabled, toolbarVisibility)
136
            }
137
        }
138
    }
139

140
    var assistant: AiAssistant? = null
141

142
    override fun getAiAssistant(): AiAssistant {
143
        // Prefer the currently opened document descriptor so runtime state is preserved
144
        // (for example, a password-protected PDF that has already been unlocked in the viewer).
145
        // Fall back to a source-based descriptor when the UI document is not available yet.
146
        // For encrypted PDFs, this fallback path requires the password to be provided in DocumentSource.
147
        val documentDescriptor =
148
            runCatching { documentState.documentConnection.pdfUi.document?.let(DocumentDescriptor::fromDocument) }
149
                .getOrNull()
150
                ?: DocumentDescriptor.fromDataProviders(listOf(assetProvider), null, null)
151

152
        return assistant ?: run {
153
            createAiAssistant(
154
                context = this@AiAssistantComposeActivity,
155
                documentsDescriptors = listOf(documentDescriptor),
156
                serverUrl = "http://$ipAddressValue:4000",
157
                sessionId = sessionId,
158
                jwtToken = { documentIds ->
159
                    JwtGenerator.generateJwtToken(
160
                        this@AiAssistantComposeActivity,
161
                        claims =
162
                        mapOf(
163
                            "document_ids" to documentIds,
164
                            "session_ids" to listOf(sessionId),
165
                            "request_limit" to
166
                                mapOf(
167
                                    "requests" to 160,
168
                                    "time_period_s" to 1000 * 60 * 10,
169
                                ),
170
                        ),
171
                    )
172
                },
173
            ).also {
174
                // Enable/disable text selection in AI Assistant chat messages
175
                // false = disable, true = enable (default)
176
                // it.enableTextSelection(false)
177
                assistant = it
178
            }
179
        }
180
    }
181

182
    override fun navigateTo(documentRect: List<RectF>, pageIndex: Int, documentIndex: Int) {
183
        documentState.documentConnection.highlight(pageIndex, documentRect)
184
    }
185

186
    companion object {
187
        const val EXTRA_URI = "JetpackComposeImageActivity.DocumentUri"
188
        const val PREFERENCES_NAME = "Nutrient.AiAssistant"
189
        const val PREF_AI_IP_ADDRESS = "ai_ip_address"
190
    }
191
}
192

193
/**
194
 * A custom toolbar component for document viewer with animated visibility.
195
 *
196
 * @param documentState The current state of the document being viewed
197
 * @param enabled Whether the toolbar actions are enabled
198
 * @param toolbarVisibility Whether the toolbar should be visible
199
 */
200
@OptIn(ExperimentalMaterial3Api::class)
201
@Composable
202
fun CustomToolbar(documentState: DocumentState, enabled: Boolean, toolbarVisibility: Boolean) {
203
    val localDensity = LocalDensity.current
204

205
    // Animate toolbar appearance/disappearance with slide, expand and fade effects
206
    AnimatedVisibility(
207
        visible = toolbarVisibility,
208
        enter =
209
        slideInVertically { with(localDensity) { -40.dp.roundToPx() } } +
210
            expandVertically(expandFrom = Alignment.Top) +
211
            fadeIn(initialAlpha = 0.3f),
212
        exit = slideOutVertically() + shrinkVertically() + fadeOut(),
213
    ) {
214
        TopAppBar(
215
            title = {
216
                // Display document title or empty string if null
217
                Text(
218
                    text = documentState.getTitle().orEmpty(),
219
                    color = Color.White,
220
                )
221
            },
222
            actions = {
223
                // AI Assistant action button
224
                IconButton(
225
                    onClick = {
226
                        documentState.toggleView(PdfActivity.MENU_OPTION_AI_ASSISTANT)
227
                    },
228
                    enabled = enabled,
229
                ) {
230
                    Icon(
231
                        painter = painterResource(id = R.drawable.ic_ai_assistant),
232
                        contentDescription = "AI Assistant",
233
                        tint = Color.White,
234
                    )
235
                }
236

237
                // Settings action button
238
                IconButton(
239
                    onClick = {
240
                        documentState.toggleView(PdfActivity.MENU_OPTION_SETTINGS)
241
                    },
242
                    enabled = enabled,
243
                ) {
244
                    Icon(
245
                        painter = painterResource(id = R.drawable.ic_topbar_settings),
246
                        contentDescription = "Settings",
247
                        tint = Color.White,
248
                    )
249
                }
250
            },
251
            colors =
252
            TopAppBarDefaults.topAppBarColors(
253
                containerColor = MaterialTheme.colorScheme.primary,
254
                titleContentColor = MaterialTheme.colorScheme.onPrimary,
255
            ),
256
        )
257
    }
258
}