blob: 5ec5ab5b31f3d1802d7433c2a07558c840633578 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
package juloo.keyboard2;
import android.content.ClipData;
import android.content.ClipboardManager;
import android.content.Context;
import android.os.Build.VERSION;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.TimeUnit;
public final class ClipboardHistoryService
{
/** Start the service on startup and start listening to clipboard changes. */
public static void on_startup(Context ctx, ClipboardPasteCallback cb)
{
get_service(ctx);
_paste_callback = cb;
}
/** Start the service if it hasn't been started before. Returns [null] if the
feature is unsupported. */
public static ClipboardHistoryService get_service(Context ctx)
{
if (VERSION.SDK_INT <= 11)
return null;
if (_service == null)
_service = new ClipboardHistoryService(ctx);
return _service;
}
public static void set_history_enabled(boolean e)
{
Config.globalConfig().set_clipboard_history_enabled(e);
if (_service == null)
return;
if (e)
_service.add_current_clip();
else
_service.clear_history();
}
/** Send the given string to the editor. */
public static void paste(String clip)
{
if (_paste_callback != null)
_paste_callback.paste_from_clipboard_pane(clip);
}
/** The maximum size limits the amount of user data stored in memory but also
gives a sense to the user that the history is not persisted and can be
forgotten as soon as the app stops. */
public static final int MAX_HISTORY_SIZE = 6;
static ClipboardHistoryService _service = null;
static ClipboardPasteCallback _paste_callback = null;
ClipboardManager _cm;
List<HistoryEntry> _history;
OnClipboardHistoryChange _listener = null;
ClipboardHistoryService(Context ctx)
{
_history = new ArrayList<HistoryEntry>();
_cm = (ClipboardManager)ctx.getSystemService(Context.CLIPBOARD_SERVICE);
_cm.addPrimaryClipChangedListener(this.new SystemListener());
}
public synchronized List<String> clear_expired_and_get_history()
{
long now_ms = System.currentTimeMillis();
List<String> dst = new ArrayList<String>();
Iterator<HistoryEntry> it = _history.iterator();
while (it.hasNext())
{
HistoryEntry ent = it.next();
if (ent.expiry_timestamp <= now_ms)
it.remove();
else
dst.add(ent.content);
}
return dst;
}
/** This will call [on_clipboard_history_change]. */
public synchronized void remove_history_entry(String clip)
{
int last_pos = _history.size() - 1;
boolean last_pos_changed = false;
for (int pos = last_pos; pos >= 0; pos--)
{
if (!_history.get(pos).content.equals(clip))
continue;
// Removing the current clipboard, clear the system clipboard.
if (pos == last_pos)
last_pos_changed = true;
_history.remove(pos);
}
if (last_pos_changed)
{
if (VERSION.SDK_INT >= 28)
_cm.clearPrimaryClip();
else
_cm.setText("");
}
if (_listener != null)
_listener.on_clipboard_history_change();
}
/** Add clipboard entries to the history, skipping consecutive duplicates and
empty strings. */
public synchronized void add_clip(String clip)
{
if (!Config.globalConfig().clipboard_history_enabled)
return;
int size = _history.size();
if (clip.equals("") || (size > 0 && _history.get(size - 1).content.equals(clip)))
return;
if (size >= MAX_HISTORY_SIZE)
_history.remove(0);
_history.add(new HistoryEntry(clip));
if (_listener != null)
_listener.on_clipboard_history_change();
}
public synchronized void clear_history()
{
_history.clear();
if (_listener != null)
_listener.on_clipboard_history_change();
}
public void set_on_clipboard_history_change(OnClipboardHistoryChange l) { _listener = l; }
public static interface OnClipboardHistoryChange
{
public void on_clipboard_history_change();
}
/** Add what is currently in the system clipboard into the history. */
void add_current_clip()
{
ClipData clip = null;
// getPrimaryClip might throw when the keyboard is disconnected.
try { clip = _cm.getPrimaryClip(); } catch (Exception _e) {}
if (clip == null)
return;
int count = clip.getItemCount();
for (int i = 0; i < count; i++)
{
CharSequence text = clip.getItemAt(i).getText();
if (text != null)
add_clip(text.toString());
}
}
int get_history_ttl_minutes() {
return Config.globalConfig().clipboard_history_duration;
}
final class SystemListener implements ClipboardManager.OnPrimaryClipChangedListener
{
public SystemListener() {}
@Override
public void onPrimaryClipChanged()
{
add_current_clip();
}
}
static final class HistoryEntry
{
public final String content;
/** Time at which the entry expires. */
public final long expiry_timestamp;
public HistoryEntry(String c)
{
content = c;
final int historyTtlMinutes = _service.get_history_ttl_minutes();
if (historyTtlMinutes >= 0) {
expiry_timestamp = System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(historyTtlMinutes);
} else {
expiry_timestamp = Long.MAX_VALUE;
}
}
}
public interface ClipboardPasteCallback
{
public void paste_from_clipboard_pane(String content);
}
}
|
