blob: a79f0602ad11bca62809d6fca2cb5fd432b553be (
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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/**
* Copyright (c) 2010, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.content;
import android.content.Context;
import android.os.Message;
import android.os.RemoteException;
import android.os.Handler;
import android.os.IBinder;
import android.os.ServiceManager;
import android.util.Log;
import java.util.ArrayList;
/**
* Interface to the clipboard service, for placing and retrieving text in
* the global clipboard.
*
* <p>
* You do not instantiate this class directly; instead, retrieve it through
* {@link android.content.Context#getSystemService}.
*
* <p>
* The ClipboardManager API itself is very simple: it consists of methods
* to atomically get and set the current primary clipboard data. That data
* is expressed as a {@link ClipData} object, which defines the protocol
* for data exchange between applications.
*
* @see android.content.Context#getSystemService
*/
public class ClipboardManager extends android.text.ClipboardManager {
private final static Object sStaticLock = new Object();
private static IClipboard sService;
private final Context mContext;
private final ArrayList<OnPrimaryClipChangedListener> mPrimaryClipChangedListeners
= new ArrayList<OnPrimaryClipChangedListener>();
private final IOnPrimaryClipChangedListener.Stub mPrimaryClipChangedServiceListener
= new IOnPrimaryClipChangedListener.Stub() {
public void dispatchPrimaryClipChanged() {
mHandler.sendEmptyMessage(MSG_REPORT_PRIMARY_CLIP_CHANGED);
}
};
static final int MSG_REPORT_PRIMARY_CLIP_CHANGED = 1;
private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG_REPORT_PRIMARY_CLIP_CHANGED:
reportPrimaryClipChanged();
}
}
};
public interface OnPrimaryClipChangedListener {
void onPrimaryClipChanged();
}
static private IClipboard getService() {
synchronized (sStaticLock) {
if (sService != null) {
return sService;
}
IBinder b = ServiceManager.getService("clipboard");
sService = IClipboard.Stub.asInterface(b);
return sService;
}
}
/** {@hide} */
public ClipboardManager(Context context, Handler handler) {
mContext = context;
}
/**
* Sets the current primary clip on the clipboard. This is the clip that
* is involved in normal cut and paste operations.
*
* @param clip The clipped data item to set.
*/
public void setPrimaryClip(ClipData clip) {
try {
getService().setPrimaryClip(clip);
} catch (RemoteException e) {
}
}
/**
* Returns the current primary clip on the clipboard.
*/
public ClipData getPrimaryClip() {
try {
return getService().getPrimaryClip(mContext.getPackageName());
} catch (RemoteException e) {
return null;
}
}
/**
* Returns a description of the current primary clip on the clipboard
* but not a copy of its data.
*/
public ClipDescription getPrimaryClipDescription() {
try {
return getService().getPrimaryClipDescription();
} catch (RemoteException e) {
return null;
}
}
/**
* Returns true if there is currently a primary clip on the clipboard.
*/
public boolean hasPrimaryClip() {
try {
return getService().hasPrimaryClip();
} catch (RemoteException e) {
return false;
}
}
public void addPrimaryClipChangedListener(OnPrimaryClipChangedListener what) {
synchronized (mPrimaryClipChangedListeners) {
if (mPrimaryClipChangedListeners.size() == 0) {
try {
getService().addPrimaryClipChangedListener(
mPrimaryClipChangedServiceListener);
} catch (RemoteException e) {
}
}
mPrimaryClipChangedListeners.add(what);
}
}
public void removePrimaryClipChangedListener(OnPrimaryClipChangedListener what) {
synchronized (mPrimaryClipChangedListeners) {
mPrimaryClipChangedListeners.remove(what);
if (mPrimaryClipChangedListeners.size() == 0) {
try {
getService().removePrimaryClipChangedListener(
mPrimaryClipChangedServiceListener);
} catch (RemoteException e) {
}
}
}
}
/**
* @deprecated Use {@link #getPrimaryClip()} instead. This retrieves
* the primary clip and tries to coerce it to a string.
*/
public CharSequence getText() {
ClipData clip = getPrimaryClip();
if (clip != null && clip.getItemCount() > 0) {
return clip.getItemAt(0).coerceToText(mContext);
}
return null;
}
/**
* @deprecated Use {@link #setPrimaryClip(ClipData)} instead. This
* creates a ClippedItem holding the given text and sets it as the
* primary clip. It has no label or icon.
*/
public void setText(CharSequence text) {
setPrimaryClip(ClipData.newPlainText(null, text));
}
/**
* @deprecated Use {@link #hasPrimaryClip()} instead.
*/
public boolean hasText() {
try {
return getService().hasClipboardText();
} catch (RemoteException e) {
return false;
}
}
void reportPrimaryClipChanged() {
Object[] listeners;
synchronized (mPrimaryClipChangedListeners) {
final int N = mPrimaryClipChangedListeners.size();
if (N <= 0) {
return;
}
listeners = mPrimaryClipChangedListeners.toArray();
}
for (int i=0; i<listeners.length; i++) {
((OnPrimaryClipChangedListener)listeners[i]).onPrimaryClipChanged();
}
}
}
|
