Annotation Overlay

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.java;
9

10
import android.content.Context;
11
import android.content.Intent;
12
import android.net.Uri;
13
import android.os.Bundle;
14
import android.view.ContextMenu;
15
import android.view.MenuItem;
16
import android.view.View;
17
import androidx.annotation.NonNull;
18
import com.google.android.material.floatingactionbutton.FloatingActionButton;
19
import com.pspdfkit.annotations.Annotation;
20
import com.pspdfkit.annotations.AnnotationType;
21
import com.pspdfkit.catalog.R;
22
import com.pspdfkit.catalog.SdkExample;
23
import com.pspdfkit.catalog.tasks.ExtractAssetTask;
24
import com.pspdfkit.compose.toolbar.state.ToolbarIcon;
25
import com.pspdfkit.compose.toolbar.state.ToolbarItem;
26
import com.pspdfkit.compose.toolbar.state.ToolbarItemState;
27
import com.pspdfkit.configuration.activity.PdfActivityConfiguration;
28
import com.pspdfkit.ui.PdfActivity;
29
import com.pspdfkit.ui.PdfActivityIntentBuilder;
30
import com.pspdfkit.ui.annotations.OnAnnotationSelectedListener;
31
import com.pspdfkit.ui.rendering.AnnotationOverlayRenderStrategy;
32
import java.util.ArrayList;
33
import java.util.EnumSet;
34
import java.util.List;
35

36
/** Showcases how to display annotations in overlay mode. */
37
public class AnnotationOverlayExample extends SdkExample {
38

39
    public AnnotationOverlayExample(@NonNull final Context context) {
40
        super(context, R.string.annotationOverlayExampleTitle, R.string.annotationOverlayExampleDescription);
41
    }
42

43
    @Override
44
    public void launchExample(
45
            @NonNull final Context context, @NonNull final PdfActivityConfiguration.Builder configuration) {
46
        // Use custom layout with FAB for per-annotation overlay toggle.
47
        configuration.layout(R.layout.activity_annotation_overlay);
48

49
        // Extract the document from the assets.
50
        ExtractAssetTask.extract(ANNOTATIONS_EXAMPLE, getTitle(), context, documentFile -> {
51
            // To start the example create a launch intent using the builder.
52
            final Intent intent = PdfActivityIntentBuilder.fromUri(context, Uri.fromFile(documentFile))
53
                    .configuration(configuration.build())
54
                    .activityClass(AnnotationOverlayActivity.class)
55
                    .build();
56

57
            context.startActivity(intent);
58
        });
59
    }
60

61
    /** Showcases how to enable overlay mode for annotations. */
62
    public static class AnnotationOverlayActivity extends PdfActivity implements OnAnnotationSelectedListener {
63

64
        /**
65
         * Holds per-type overlay overrides. When overlay is globally off, these types are
66
         * included in overlay. When overlay is globally on, these types are excluded from overlay.
67
         */
68
        @NonNull
69
        private final EnumSet<AnnotationType> perTypeOverrides = EnumSet.noneOf(AnnotationType.class);
70

71
        /** Current strategy used for rendering annotations in overlay. */
72
        @NonNull
73
        private AnnotationOverlayRenderStrategy.Strategy currentOverlayRenderingStrategy =
74
                AnnotationOverlayRenderStrategy.Strategy.AP_STREAM_RENDERING;
75

76
        /** Flag indicating whether annotation overlay is enabled. */
77
        private boolean annotationOverlayEnabled = false;
78

79
        /** FAB for toggling overlay on selected annotations. */
80
        private FloatingActionButton overlayFab;
81

82
        @Override
83
        public void onCreate(Bundle savedInstanceState) {
84
            super.onCreate(savedInstanceState);
85

86
            // Set up the FAB for toggling overlay on selected annotation types.
87
            overlayFab = findViewById(R.id.fab_toggle_annotation_overlay);
88
            registerForContextMenu(overlayFab);
89
            overlayFab.setOnClickListener(View::showContextMenu);
90

91
            // Listen for annotation selection changes to show/hide the FAB.
92
            requirePdfFragment().addOnAnnotationSelectedListener(this);
93

94
            // We'll set overlay render strategy that just returns currently configured strategy for all
95
            // annotations.
96
            requirePdfFragment().setAnnotationOverlayRenderStrategy(annotation -> currentOverlayRenderingStrategy);
97

98
            // Add custom toolbar items, computing their labels/visibility from current state.
99
            setToolbarItemsProvider(defaultItems -> {
100
                final List<ToolbarItem> items = new ArrayList<>(defaultItems);
101
                items.add(new ToolbarItem.Button(
102
                        "toggle_annotation_overlay",
103
                        R.id.toggle_annotation_overlay,
104
                        annotationOverlayEnabled ? "Disable annotation overlay" : "Enable annotation overlay",
105
                        ToolbarIcon.None.INSTANCE,
106
                        new ToolbarItemState(true, false, true),
107
                        ToolbarItem.ItemEdge.End,
108
                        ToolbarItem.OverflowBehavior.Never));
109
                // Toggling overlay strategy only makes sense when annotation overlay is enabled,
110
                // so the item is hidden otherwise.
111
                final String renderingStrategyTitle =
112
                        currentOverlayRenderingStrategy == AnnotationOverlayRenderStrategy.Strategy.PLATFORM_RENDERING
113
                                ? "Use AP stream rendering"
114
                                : "Use platform rendering";
115
                items.add(new ToolbarItem.Button(
116
                        "toggle_overlay_rendering_strategy",
117
                        R.id.toggle_overlay_rendering_strategy,
118
                        renderingStrategyTitle,
119
                        ToolbarIcon.None.INSTANCE,
120
                        new ToolbarItemState(true, false, annotationOverlayEnabled),
121
                        ToolbarItem.ItemEdge.End,
122
                        ToolbarItem.OverflowBehavior.Never));
123
                items.add(new ToolbarItem.Button(
124
                        "fire_low_memory_notification",
125
                        R.id.fire_low_memory_notification,
126
                        "Fire low memory notification",
127
                        ToolbarIcon.None.INSTANCE,
128
                        new ToolbarItemState(true, false, true),
129
                        ToolbarItem.ItemEdge.End,
130
                        ToolbarItem.OverflowBehavior.Never));
131
                return items;
132
            });
133

134
            setOnToolbarItemClickListener(id -> {
135
                if (id == R.id.toggle_annotation_overlay) {
136
                    if (annotationOverlayEnabled) {
137
                        disableOverlayForAllAnnotationTypes();
138
                    } else {
139
                        enableOverlayForSupportedAnnotationTypes();
140
                    }
141
                    invalidateToolbarItems();
142
                    return true;
143
                } else if (id == R.id.fire_low_memory_notification) {
144
                    // We fire low memory notification manually to showcase how annotation overlay
145
                    // mode behaves when system is low on memory.
146
                    requirePdfFragment().onLowMemory();
147
                    return true;
148
                } else if (id == R.id.toggle_overlay_rendering_strategy) {
149
                    // Toggle the current overlay rendering strategy.
150
                    if (currentOverlayRenderingStrategy
151
                            == AnnotationOverlayRenderStrategy.Strategy.AP_STREAM_RENDERING) {
152
                        currentOverlayRenderingStrategy = AnnotationOverlayRenderStrategy.Strategy.PLATFORM_RENDERING;
153
                    } else {
154
                        currentOverlayRenderingStrategy = AnnotationOverlayRenderStrategy.Strategy.AP_STREAM_RENDERING;
155
                    }
156
                    // Invalidate items to change button text to current state.
157
                    invalidateToolbarItems();
158
                    return true;
159
                }
160
                return false;
161
            });
162

163
            // We'll enable overlay for all supported annotation types immediately after activity
164
            // creation.
165
            enableOverlayForSupportedAnnotationTypes();
166
            invalidateToolbarItems();
167
        }
168

169
        @Override
170
        public void onDestroy() {
171
            super.onDestroy();
172
            requirePdfFragment().removeOnAnnotationSelectedListener(this);
173
        }
174

175
        @Override
176
        public void onAnnotationSelected(@NonNull Annotation annotation, boolean annotationCreated) {
177
            overlayFab.setVisibility(View.VISIBLE);
178
        }
179

180
        @Override
181
        public void onAnnotationDeselected(@NonNull Annotation annotation, boolean reselected) {
182
            if (!reselected) {
183
                overlayFab.setVisibility(View.GONE);
184
            }
185
        }
186

187
        private void disableOverlayForAllAnnotationTypes() {
188
            annotationOverlayEnabled = false;
189
            perTypeOverrides.clear();
190
            applyOverlayTypes();
191
        }
192

193
        private void enableOverlayForSupportedAnnotationTypes() {
194
            annotationOverlayEnabled = true;
195
            perTypeOverrides.clear();
196
            applyOverlayTypes();
197
        }
198

199
        private void applyOverlayTypes() {
200
            final EnumSet<AnnotationType> overlayTypes;
201
            if (annotationOverlayEnabled) {
202
                // Start with all types, then remove manually excluded ones.
203
                overlayTypes = EnumSet.allOf(AnnotationType.class);
204
                overlayTypes.removeAll(perTypeOverrides);
205
            } else {
206
                // Start with none, then add manually included ones.
207
                overlayTypes = EnumSet.noneOf(AnnotationType.class);
208
                overlayTypes.addAll(perTypeOverrides);
209
            }
210
            requirePdfFragment().setOverlaidAnnotationTypes(overlayTypes);
211
        }
212

213
        @Override
214
        public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
215
            super.onCreateContextMenu(menu, v, menuInfo);
216

217
            List<Annotation> selectedAnnotations = requirePdfFragment().getSelectedAnnotations();
218
            if (selectedAnnotations.size() != 1) return;
219

220
            final AnnotationType annotationType = selectedAnnotations.get(0).getType();
221
            // The effective overlay state for this type is: globally on XOR overridden.
222
            final boolean effectivelyOverlaid = annotationOverlayEnabled ^ perTypeOverrides.contains(annotationType);
223
            menu.add(0, R.id.toggle_annotation_overlay, 0, effectivelyOverlaid ? "Disable overlay" : "Enable overlay");
224
        }
225

226
        @Override
227
        public boolean onContextItemSelected(@NonNull MenuItem item) {
228
            if (requirePdfFragment().getSelectedAnnotations().size() != 1) {
229
                return super.onContextItemSelected(item);
230
            }
231
            final Annotation annotation =
232
                    requirePdfFragment().getSelectedAnnotations().get(0);
233
            final AnnotationType annotationType = annotation.getType();
234

235
            final int itemId = item.getItemId();
236
            if (itemId == R.id.toggle_annotation_overlay) {
237
                if (perTypeOverrides.contains(annotationType)) {
238
                    perTypeOverrides.remove(annotationType);
239
                } else {
240
                    perTypeOverrides.add(annotationType);
241
                }
242
                applyOverlayTypes();
243
                return true;
244
            }
245
            return super.onContextItemSelected(item);
246
        }
247
    }
248
}