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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
|
/* Communication module for Android terminals. -*- c-file-style: "GNU" -*-
Copyright (C) 2023-2026 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
package org.gnu.emacs;
import android.content.ClipboardManager;
import android.content.Context;
import android.content.ContentResolver;
import android.content.ClipData;
import android.content.ClipDescription;
import android.content.res.AssetFileDescriptor;
import android.net.Uri;
import android.util.Log;
import android.os.Build;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
/* This class implements EmacsClipboard for Android 3.0 and later
systems. */
public final class EmacsSdk11Clipboard extends EmacsClipboard
implements ClipboardManager.OnPrimaryClipChangedListener
{
private static final String TAG = "EmacsSdk11Clipboard";
private ClipboardManager manager;
private boolean ownsClipboard;
private int clipboardChangedCount;
private int monitoredClipboardChangedCount;
private ContentResolver resolver;
public
EmacsSdk11Clipboard ()
{
manager = EmacsService.SERVICE.getClipboardManager ();
/* The system forbids Emacs from reading clipboard data in the
background under Android 10 or later. */
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q)
manager.addPrimaryClipChangedListener (this);
/* Now obtain the content resolver used to open file
descriptors. */
resolver = EmacsService.SERVICE.getContentResolver ();
}
@Override
public synchronized void
onPrimaryClipChanged ()
{
/* Increment monitoredClipboardChangeCount. If it is now greater
than clipboardChangedCount, then Emacs no longer owns the
clipboard. */
monitoredClipboardChangedCount++;
if (monitoredClipboardChangedCount > clipboardChangedCount)
{
ownsClipboard = false;
/* Reset both values back to 0. */
monitoredClipboardChangedCount = 0;
clipboardChangedCount = 0;
}
}
/* Save the STRING into the clipboard by way of text copied by the
user. */
@Override
public synchronized void
setClipboard (String string)
{
ClipData data;
data = ClipData.newPlainText ("Emacs", string);
manager.setPrimaryClip (data);
ownsClipboard = true;
/* onPrimaryClipChanged will be called again. Use this
variable to keep track of how many times the clipboard has
been changed. */
++clipboardChangedCount;
}
/* Return whether or not Emacs owns the clipboard. Value is 1 if
Emacs does, 0 if Emacs does not, and -1 if that information is
unavailable. */
@Override
public synchronized int
ownsClipboard ()
{
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
return -1;
return ownsClipboard ? 1 : 0;
}
/* Return whether or not clipboard content currently exists. */
@Override
public boolean
clipboardExists ()
{
return manager.hasPrimaryClip ();
}
/* Return the current content of the clipboard, as plain text, or
NULL if no content is available. */
@Override
public String
getClipboard ()
{
ClipData clip;
CharSequence text;
Context context;
clip = manager.getPrimaryClip ();
if (clip == null || clip.getItemCount () < 1)
return null;
context = EmacsService.SERVICE;
text = clip.getItemAt (0).coerceToText (context);
return text.toString ();
}
/* Return an array of targets currently provided by the
clipboard, or NULL if there are none. */
@Override
public String[]
getClipboardTargets ()
{
ClipData clip;
ClipDescription description;
String[] typeArray;
int i;
/* N.B. that Android calls the clipboard the ``primary clip''; it
is not related to the X primary selection. */
clip = manager.getPrimaryClip ();
if (clip == null)
return null;
description = clip.getDescription ();
i = description.getMimeTypeCount ();
typeArray = new String[i];
for (i = 0; i < description.getMimeTypeCount (); ++i)
typeArray[i] = description.getMimeType (i);
return typeArray;
}
/* Return the clipboard data for the given target, or NULL if it
does not exist.
Value is normally an asset file descriptor, which in turn holds
three important values: the file descriptor, the start offset of
the data, and its length; length may be
AssetFileDescriptor.UNKNOWN_LENGTH, meaning that the data extends
from that offset to the end of the file.
Do not use this function to open text targets; use `getClipboard'
for that instead, as it will handle selection data consisting
solely of a URI. */
@Override
public AssetFileDescriptor
getClipboardData (String target)
{
ClipData data;
String mimeType;
AssetFileDescriptor assetFd;
Uri uri;
/* Now obtain the clipboard data and the data corresponding to
that MIME type. */
mimeType = target;
data = manager.getPrimaryClip ();
if (data == null || data.getItemCount () < 1)
return null;
try
{
uri = data.getItemAt (0).getUri ();
if (uri == null)
return null;
/* Now open the file descriptor. */
assetFd = resolver.openTypedAssetFileDescriptor (uri, mimeType,
null);
return assetFd;
}
catch (SecurityException e)
{
return null;
}
catch (FileNotFoundException e)
{
return null;
}
}
};
|
