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
|
/*
* Copyright (C) 2009 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.os.storage;
import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;
/**
* Callback class for receiving events from MountService.
*
* @hide - Applications should use IStorageEventListener for storage event
* callbacks.
*/
public interface IMountServiceListener extends IInterface {
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends Binder implements IMountServiceListener {
private static final String DESCRIPTOR = "IMountServiceListener";
/** Construct the stub at attach it to the interface. */
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an IMountServiceListener interface,
* generating a proxy if needed.
*/
public static IMountServiceListener asInterface(IBinder obj) {
if ((obj == null)) {
return null;
}
IInterface iin = (IInterface) obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof IMountServiceListener))) {
return ((IMountServiceListener) iin);
}
return new IMountServiceListener.Stub.Proxy(obj);
}
public IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_onUsbMassStorageConnectionChanged: {
data.enforceInterface(DESCRIPTOR);
boolean connected;
connected = (0 != data.readInt());
this.onUsbMassStorageConnectionChanged(connected);
reply.writeNoException();
return true;
}
case TRANSACTION_onStorageStateChanged: {
data.enforceInterface(DESCRIPTOR);
final String path = data.readString();
final String oldState = data.readString();
final String newState = data.readString();
this.onStorageStateChanged(path, oldState, newState);
reply.writeNoException();
return true;
}
case TRANSACTION_onVolumeStateChanged: {
data.enforceInterface(DESCRIPTOR);
final VolumeInfo vol = (VolumeInfo) data.readParcelable(null);
final int oldState = data.readInt();
final int newState = data.readInt();
onVolumeStateChanged(vol, oldState, newState);
reply.writeNoException();
return true;
}
case TRANSACTION_onVolumeMetadataChanged: {
data.enforceInterface(DESCRIPTOR);
final VolumeInfo vol = (VolumeInfo) data.readParcelable(null);
onVolumeMetadataChanged(vol);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements IMountServiceListener {
private IBinder mRemote;
Proxy(IBinder remote) {
mRemote = remote;
}
public IBinder asBinder() {
return mRemote;
}
public String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* Detection state of USB Mass Storage has changed
*
* @param available true if a UMS host is connected.
*/
public void onUsbMassStorageConnectionChanged(boolean connected) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(((connected) ? (1) : (0)));
mRemote.transact(Stub.TRANSACTION_onUsbMassStorageConnectionChanged, _data,
_reply, android.os.IBinder.FLAG_ONEWAY);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
/**
* Storage state has changed.
*
* @param path The volume mount path.
* @param oldState The old state of the volume.
* @param newState The new state of the volume. Note: State is one
* of the values returned by
* Environment.getExternalStorageState()
*/
public void onStorageStateChanged(String path, String oldState, String newState)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeString(path);
_data.writeString(oldState);
_data.writeString(newState);
mRemote.transact(Stub.TRANSACTION_onStorageStateChanged, _data, _reply,
android.os.IBinder.FLAG_ONEWAY);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
@Override
public void onVolumeStateChanged(VolumeInfo vol, int oldState, int newState)
throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeParcelable(vol, 0);
_data.writeInt(oldState);
_data.writeInt(newState);
mRemote.transact(Stub.TRANSACTION_onVolumeStateChanged, _data, _reply,
android.os.IBinder.FLAG_ONEWAY);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
@Override
public void onVolumeMetadataChanged(VolumeInfo vol) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeParcelable(vol, 0);
mRemote.transact(Stub.TRANSACTION_onVolumeMetadataChanged, _data, _reply,
android.os.IBinder.FLAG_ONEWAY);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_onUsbMassStorageConnectionChanged = (IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_onStorageStateChanged = (IBinder.FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_onVolumeStateChanged = (IBinder.FIRST_CALL_TRANSACTION + 2);
static final int TRANSACTION_onVolumeMetadataChanged = (IBinder.FIRST_CALL_TRANSACTION + 3);
}
/**
* Detection state of USB Mass Storage has changed
*
* @param available true if a UMS host is connected.
*/
public void onUsbMassStorageConnectionChanged(boolean connected) throws RemoteException;
/**
* Storage state has changed.
*
* @param path The volume mount path.
* @param oldState The old state of the volume.
* @param newState The new state of the volume. Note: State is one of the
* values returned by Environment.getExternalStorageState()
*/
public void onStorageStateChanged(String path, String oldState, String newState)
throws RemoteException;
public void onVolumeStateChanged(VolumeInfo vol, int oldState, int newState)
throws RemoteException;
public void onVolumeMetadataChanged(VolumeInfo vol) throws RemoteException;
}
|
