FTS Indexing Example

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.net.Uri
13
import android.os.Bundle
14
import androidx.activity.ComponentActivity
15
import androidx.activity.compose.setContent
16
import androidx.compose.foundation.clickable
17
import androidx.compose.foundation.layout.Arrangement
18
import androidx.compose.foundation.layout.Column
19
import androidx.compose.foundation.layout.fillMaxSize
20
import androidx.compose.foundation.layout.fillMaxWidth
21
import androidx.compose.foundation.layout.padding
22
import androidx.compose.foundation.lazy.LazyColumn
23
import androidx.compose.foundation.lazy.items
24
import androidx.compose.material3.Card
25
import androidx.compose.material3.CardDefaults
26
import androidx.compose.material3.CircularProgressIndicator
27
import androidx.compose.material3.MaterialTheme
28
import androidx.compose.material3.OutlinedTextField
29
import androidx.compose.material3.Scaffold
30
import androidx.compose.material3.Text
31
import androidx.compose.runtime.Composable
32
import androidx.compose.runtime.DisposableEffect
33
import androidx.compose.runtime.LaunchedEffect
34
import androidx.compose.runtime.getValue
35
import androidx.compose.runtime.mutableStateOf
36
import androidx.compose.runtime.remember
37
import androidx.compose.runtime.setValue
38
import androidx.compose.ui.Alignment
39
import androidx.compose.ui.Modifier
40
import androidx.compose.ui.text.font.FontWeight
41
import androidx.compose.ui.unit.dp
42
import com.pspdfkit.catalog.R
43
import com.pspdfkit.catalog.SdkExample
44
import com.pspdfkit.catalog.ui.theming.CatalogTheme
45
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
46
import com.pspdfkit.document.library.LibraryFileSystemDataSource
47
import com.pspdfkit.document.library.PdfLibrary
48
import com.pspdfkit.document.library.QueryOptions
49
import com.pspdfkit.document.library.QueryPreviewResult
50
import com.pspdfkit.document.library.QueryResultListener
51
import com.pspdfkit.ui.PdfActivityIntentBuilder
52
import kotlinx.coroutines.Dispatchers
53
import kotlinx.coroutines.withContext
54
import java.io.File
55

56
class IndexedFullTextSearchExample(context: Context) : SdkExample(
57
    context,
58
    R.string.indexedFtsExampleTitle,
59
    R.string.indexedFtsExampleDescription
60
) {
61
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
62
        val intent = Intent(context, IndexedFullTextSearchActivity::class.java)
63
        context.startActivity(intent)
64
    }
65
}
66

67
class IndexedFullTextSearchActivity : ComponentActivity() {
68

69
    companion object {
70
        private const val EXTRACTED_PDFS_DIR = "extracted_pdfs"
71
    }
72

73
    private var pdfLibrary: PdfLibrary? = null
74
    private var dataSource: LibraryFileSystemDataSource? = null
75

76
    override fun onCreate(savedInstanceState: Bundle?) {
77
        super.onCreate(savedInstanceState)
78

79
        setContent {
80
            CatalogTheme {
81
                LibrarySearchScreen()
82
            }
83
        }
84
    }
85

86
    override fun onDestroy() {
87
        super.onDestroy()
88
        dataSource?.cleanup()
89
        pdfLibrary = null
90
        dataSource = null
91
    }
92

93
    @Composable
94
    private fun LibrarySearchScreen() {
95
        var searchQuery by remember { mutableStateOf("") }
96
        var searchResults by remember { mutableStateOf<Map<String, Set<QueryPreviewResult>>>(emptyMap()) }
97
        var isIndexing by remember { mutableStateOf(true) }
98
        var indexingProgress by remember { mutableStateOf("Preparing to index...") }
99
        var extractedDirectory by remember { mutableStateOf<File?>(null) }
100

101
        LaunchedEffect(Unit) {
102
            withContext(Dispatchers.IO) {
103
                try {
104
                    extractedDirectory = extractAllPdfAssets()
105
                    initializePdfLibrary(extractedDirectory!!) { progress ->
106
                        indexingProgress = progress
107
                        if (progress.contains("completed")) {
108
                            isIndexing = false
109
                        }
110
                    }
111
                } catch (e: Exception) {
112
                    indexingProgress = "Error: ${e.message}"
113
                    isIndexing = false
114
                }
115
            }
116
        }
117

118
        LaunchedEffect(searchQuery, isIndexing) {
119
            if (searchQuery.isNotEmpty() && pdfLibrary != null && !isIndexing) {
120
                performSearch(searchQuery) { results ->
121
                    searchResults = results
122
                }
123
            } else if (searchQuery.isEmpty()) {
124
                searchResults = emptyMap()
125
            }
126
        }
127

128
        DisposableEffect(Unit) {
129
            onDispose {
130
                dataSource?.cleanup()
131
            }
132
        }
133

134
        Scaffold(
135
            modifier = Modifier.fillMaxSize()
136
        ) { paddingValues ->
137
            Column(
138
                modifier = Modifier
139
                    .fillMaxSize()
140
                    .padding(paddingValues)
141
                    .padding(16.dp)
142
            ) {
143
                OutlinedTextField(
144
                    value = searchQuery,
145
                    onValueChange = { searchQuery = it },
146
                    label = { Text("Search PDFs") },
147
                    placeholder = { Text("Enter search terms...") },
148
                    modifier = Modifier.fillMaxWidth(),
149
                    enabled = !isIndexing
150
                )
151

152
                if (isIndexing) {
153
                    Column(
154
                        modifier = Modifier
155
                            .fillMaxWidth()
156
                            .padding(vertical = 16.dp),
157
                        horizontalAlignment = Alignment.CenterHorizontally
158
                    ) {
159
                        CircularProgressIndicator()
160
                        Text(
161
                            text = indexingProgress,
162
                            style = MaterialTheme.typography.bodyMedium,
163
                            modifier = Modifier.padding(top = 8.dp)
164
                        )
165
                    }
166
                } else if (searchQuery.isEmpty()) {
167
                    Text(
168
                        text = "Enter a search term to find content in the PDF library",
169
                        style = MaterialTheme.typography.bodyLarge,
170
                        modifier = Modifier.padding(vertical = 16.dp)
171
                    )
172
                } else if (searchResults.isEmpty()) {
173
                    Text(
174
                        text = "No results found for \"$searchQuery\"",
175
                        style = MaterialTheme.typography.bodyLarge,
176
                        modifier = Modifier.padding(vertical = 16.dp)
177
                    )
178
                }
179

180
                LazyColumn(
181
                    verticalArrangement = Arrangement.spacedBy(8.dp)
182
                ) {
183
                    searchResults.forEach { (_, results) ->
184
                        items(results.toList()) { result ->
185
                            SearchResultCard(
186
                                result = result,
187
                                onResultClick = { clickedResult ->
188
                                    openDocumentAtPage(clickedResult)
189
                                }
190
                            )
191
                        }
192
                    }
193
                }
194
            }
195
        }
196
    }
197

198
    @Composable
199
    private fun SearchResultCard(
200
        result: QueryPreviewResult,
201
        onResultClick: (QueryPreviewResult) -> Unit
202
    ) {
203
        Card(
204
            modifier = Modifier
205
                .fillMaxWidth()
206
                .clickable { onResultClick(result) },
207
            elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
208
        ) {
209
            Column(
210
                modifier = Modifier.padding(12.dp)
211
            ) {
212
                Text(
213
                    text = "Document: ${getDocumentName(result.uid)}",
214
                    style = MaterialTheme.typography.titleMedium,
215
                    fontWeight = FontWeight.Bold
216
                )
217
                Text(
218
                    text = "Page ${result.pageIndex + 1}",
219
                    style = MaterialTheme.typography.bodySmall,
220
                    color = MaterialTheme.colorScheme.onSurfaceVariant,
221
                    modifier = Modifier.padding(bottom = 4.dp)
222
                )
223
                Text(
224
                    text = result.previewText,
225
                    style = MaterialTheme.typography.bodyMedium,
226
                    modifier = Modifier.padding(top = 4.dp)
227
                )
228
            }
229
        }
230
    }
231

232
    private suspend fun extractAllPdfAssets(): File {
233
        return withContext(Dispatchers.IO) {
234
            val extractedDir = File(filesDir, EXTRACTED_PDFS_DIR)
235
            if (!extractedDir.exists()) {
236
                extractedDir.mkdirs()
237
            }
238

239
            val assetManager = assets
240
            val pdfAssets = assetManager.list("")?.filter { it.endsWith(".pdf") } ?: emptyList()
241

242
            for (assetName in pdfAssets) {
243
                val outputFile = File(extractedDir, assetName)
244
                if (!outputFile.exists()) {
245
                    assetManager.open(assetName).use { input ->
246
                        outputFile.outputStream().use { output ->
247
                            input.copyTo(output)
248
                        }
249
                    }
250
                }
251
            }
252

253
            extractedDir
254
        }
255
    }
256

257
    private suspend fun initializePdfLibrary(
258
        documentsDirectory: File,
259
        onProgress: (String) -> Unit
260
    ) {
261
        withContext(Dispatchers.IO) {
262
            try {
263
                onProgress("Initializing PDF library...")
264

265
                val libraryDbPath = File(filesDir, "pdf_library.db").absolutePath
266
                pdfLibrary = PdfLibrary(libraryDbPath)
267
                val library = pdfLibrary ?: throw IllegalStateException("Failed to create PdfLibrary instance")
268
                onProgress("Setting up data source...")
269
                dataSource = LibraryFileSystemDataSource(library, documentsDirectory)
270
                library.dataSource = dataSource
271

272
                onProgress("Indexing...")
273
                library.updateIndexFromDataSource()
274

275
                onProgress("Indexing completed!")
276
            } catch (e: Exception) {
277
                onProgress("Error during initialization: ${e.message}")
278
                throw e
279
            }
280
        }
281
    }
282

283
    private fun performSearch(
284
        query: String,
285
        onResults: (Map<String, Set<QueryPreviewResult>>) -> Unit
286
    ) {
287
        val library = pdfLibrary ?: return
288

289
        val queryOptions = QueryOptions.Builder()
290
            .generateTextPreviews(true)
291
            .maximumPreviewResultsPerDocument(3)
292
            .maximumPreviewResultsTotal(20)
293
            .build()
294

295
        library.search(
296
            query,
297
            queryOptions,
298
            object : QueryResultListener {
299
                override fun onSearchCompleted(searchString: String, results: Map<String, Set<Int>>) {
300
                    // Basic results handled by preview callback
301
                }
302

303
                override fun onSearchPreviewsGenerated(
304
                    searchString: String,
305
                    results: Map<String, Set<QueryPreviewResult>>
306
                ) {
307
                    runOnUiThread {
308
                        onResults(results)
309
                    }
310
                }
311
            }
312
        )
313
    }
314

315
    private fun openDocumentAtPage(result: QueryPreviewResult) {
316
        val descriptor = dataSource?.indexItemDescriptorForDocumentWithUid(result.uid)
317
        if (descriptor != null) {
318
            try {
319
                // Construct the full path to the extracted file
320
                val extractedDir = File(filesDir, EXTRACTED_PDFS_DIR)
321
                val documentFile = File(extractedDir, descriptor.documentPath)
322
                val fileUri = Uri.fromFile(documentFile)
323

324
                val configuration = PdfActivityConfiguration.Builder(this)
325
                    .page(result.pageIndex)
326
                    .build()
327

328
                val intent = PdfActivityIntentBuilder.fromUri(this, fileUri)
329
                    .configuration(configuration)
330
                    .build()
331

332
                startActivity(intent)
333
            } catch (e: Exception) {
334
                // Handle error - could show a toast or log
335
                android.util.Log.e("LibraryAssetSearch", "Error opening document: ${e.message}")
336
            }
337
        }
338
    }
339

340
    private fun getDocumentName(uid: String): String {
341
        val descriptor = dataSource?.indexItemDescriptorForDocumentWithUid(uid)
342
        return descriptor?.documentPath?.substringAfterLast("/") ?: "Unknown Document"
343
    }
344
}