UI View Modes

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.net.Uri
12
import android.os.Bundle
13
import android.view.View
14
import com.pspdfkit.catalog.R
15
import com.pspdfkit.catalog.SdkExample
16
import com.pspdfkit.catalog.tasks.ExtractAssetTask
17
import com.pspdfkit.compose.toolbar.state.ToolbarItem
18
import com.pspdfkit.compose.toolbar.state.ToolbarItem.ItemEdge
19
import com.pspdfkit.compose.toolbar.state.ToolbarItem.OverflowBehavior
20
import com.pspdfkit.configuration.activity.PdfActivityConfiguration
21
import com.pspdfkit.configuration.activity.TabBarHidingMode
22
import com.pspdfkit.configuration.activity.UserInterfaceViewMode
23
import com.pspdfkit.ui.PdfActivity
24
import com.pspdfkit.ui.PdfActivityIntentBuilder
25

26
/**
27
 * This example shows how to change user interface view modes. To do so, it subclasses the
28
 * [PdfActivity] and calls [PdfActivity.setUserInterfaceViewMode] method
29
 * to toggle between various user interface view modes.
30
 */
31
class UserInterfaceViewModesExample(context: Context) :
32
    SdkExample(context, R.string.userInterfaceViewModesExampleTitle, R.string.userInterfaceViewModesExampleDescription) {
33
    override fun launchExample(context: Context, configuration: PdfActivityConfiguration.Builder) {
34
        // Configure the PdfActivity to use the examples subclass. This is
35
        // important if your app wants to tweak the default behavior of its implementation.
36
        configuration.layout(R.layout.user_interface_view_modes_activity)
37

38
        // Hide navigation buttons and tab bar since they are not used by this example.
39
        configuration.navigationButtonsEnabled(false)
40
        configuration.setTabBarHidingMode(TabBarHidingMode.HIDE)
41

42
        // The custom layout has no content editor. In order to prevent the activity from accessing
43
        // it we have to deactivate it in the configuration.
44
        configuration.contentEditingEnabled(false)
45

46
        // Disable measurements as well
47
        configuration.setMeasurementToolsEnabled(false)
48

49
        // We use a custom utility class to extract the example document from the assets.
50
        ExtractAssetTask.extract(WELCOME_DOC, title, context) { documentFile ->
51
            // Launch the custom example activity using the document and configuration.
52
            val intent =
53
                PdfActivityIntentBuilder
54
                    .fromUri(context, Uri.fromFile(documentFile))
55
                    .configuration(configuration.build())
56
                    .activityClass(UserInterfaceViewModesActivity::class)
57
                    .build()
58

59
            // Start the UserInterfaceViewModesActivity for the extracted document.
60
            context.startActivity(intent)
61
        }
62
    }
63
}
64

65
/**
66
 * This subclass of [PdfActivity] adds a set of actions to change user interface view modes.
67
 */
68
class UserInterfaceViewModesActivity : PdfActivity() {
69
    companion object {
70
        private const val VIEW_MODE_AUTOMATIC = 90
71
        private const val VIEW_MODE_AUTOMATIC_BORDER_PAGES = 91
72
        private const val VIEW_MODE_VISIBLE = 92
73
        private const val VIEW_MODE_HIDDEN = 93
74
        private const val VIEW_MODE_MANUAL = 94
75
    }
76

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

80
        findViewById<View>(R.id.show_user_interface_button).setOnClickListener {
81
            // This method overrides all restraints on showing user interface.
82
            // Shows user interface even when using USER_INTERFACE_VIEW_MODE_HIDDEN.
83
            setUserInterfaceVisible(true, true)
84
        }
85

86
        findViewById<View>(R.id.hide_user_interface_button).setOnClickListener {
87
            // This method overrides all restraints on hiding user interface.
88
            // Hides user interface even when using USER_INTERFACE_MODE_VISIBLE.
89
            setUserInterfaceVisible(false, true)
90
        }
91

92
        setToolbarItemsProvider { defaultItems ->
93
            defaultItems +
94
                viewModeButton(
95
                    VIEW_MODE_AUTOMATIC,
96
                    "user_interface_view_mode_automatic",
97
                    R.string.user_interface_view_mode_automatic,
98
                ) +
99
                viewModeButton(
100
                    VIEW_MODE_AUTOMATIC_BORDER_PAGES,
101
                    "user_interface_view_mode_automatic_border_pages",
102
                    R.string.user_interface_view_mode_automatic_border_pages,
103
                ) +
104
                viewModeButton(
105
                    VIEW_MODE_VISIBLE,
106
                    "user_interface_view_mode_visible",
107
                    R.string.user_interface_view_mode_visible,
108
                ) +
109
                viewModeButton(
110
                    VIEW_MODE_HIDDEN,
111
                    "user_interface_view_mode_hidden",
112
                    R.string.user_interface_view_mode_hidden,
113
                ) +
114
                viewModeButton(
115
                    VIEW_MODE_MANUAL,
116
                    "user_interface_view_mode_manual",
117
                    R.string.user_interface_view_mode_manual,
118
                )
119
        }
120

121
        setOnToolbarItemClickListener { itemId -> onToolbarItemClick(itemId) }
122
    }
123

124
    private fun viewModeButton(itemId: Int, actionId: String, titleRes: Int): ToolbarItem.Button = ToolbarItem.Button(
125
        id = itemId,
126
        actionId = actionId,
127
        contentDescription = getString(titleRes),
128
        position = ItemEdge.End,
129
        overflowBehavior = OverflowBehavior.Never,
130
    )
131

132
    private fun onToolbarItemClick(itemId: Int): Boolean {
133
        val newUserInterfaceViewMode =
134
            when (itemId) {
135
                VIEW_MODE_AUTOMATIC -> {
136
                    UserInterfaceViewMode.USER_INTERFACE_VIEW_MODE_AUTOMATIC
137
                }
138

139
                VIEW_MODE_AUTOMATIC_BORDER_PAGES -> {
140
                    UserInterfaceViewMode.USER_INTERFACE_VIEW_MODE_AUTOMATIC_BORDER_PAGES
141
                }
142

143
                VIEW_MODE_VISIBLE -> {
144
                    UserInterfaceViewMode.USER_INTERFACE_VIEW_MODE_VISIBLE
145
                }
146

147
                VIEW_MODE_HIDDEN -> {
148
                    UserInterfaceViewMode.USER_INTERFACE_VIEW_MODE_HIDDEN
149
                }
150

151
                VIEW_MODE_MANUAL -> {
152
                    UserInterfaceViewMode.USER_INTERFACE_VIEW_MODE_MANUAL
153
                }
154

155
                else -> {
156
                    null
157
                }
158
            } ?: return false
159

160
        this.userInterfaceViewMode = newUserInterfaceViewMode
161
        return true
162
    }
163

164
    override fun onUserInterfaceVisibilityChanged(visible: Boolean) {
165
        super.onUserInterfaceVisibilityChanged(visible)
166
        // You can monitor UI visibility changes by overriding this method.
167
    }
168
}