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
|
/*
* Copyright (C) 2014 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.media.midi;
import android.content.Context;
import android.os.Binder;
import android.os.IBinder;
import android.os.Bundle;
import android.os.Handler;
import android.os.RemoteException;
import android.util.Log;
import java.io.IOException;
import java.util.HashMap;
/**
* This class is the public application interface to the MIDI service.
*
* <p>You can obtain an instance of this class by calling
* {@link android.content.Context#getSystemService(java.lang.String) Context.getSystemService()}.
*
* {@samplecode
* MidiManager manager = (MidiManager) getSystemService(Context.MIDI_SERVICE);}
*
* CANDIDATE FOR PUBLIC API
* @hide
*/
public class MidiManager {
private static final String TAG = "MidiManager";
private final Context mContext;
private final IMidiManager mService;
private final IBinder mToken = new Binder();
private HashMap<DeviceCallback,DeviceListener> mDeviceListeners =
new HashMap<DeviceCallback,DeviceListener>();
// Binder stub for receiving device notifications from MidiService
private class DeviceListener extends IMidiListener.Stub {
private final DeviceCallback mCallback;
private final Handler mHandler;
public DeviceListener(DeviceCallback callback, Handler handler) {
mCallback = callback;
mHandler = handler;
}
public void onDeviceAdded(MidiDeviceInfo device) {
if (mHandler != null) {
final MidiDeviceInfo deviceF = device;
mHandler.post(new Runnable() {
@Override public void run() {
mCallback.onDeviceAdded(deviceF);
}
});
} else {
mCallback.onDeviceAdded(device);
}
}
public void onDeviceRemoved(MidiDeviceInfo device) {
if (mHandler != null) {
final MidiDeviceInfo deviceF = device;
mHandler.post(new Runnable() {
@Override public void run() {
mCallback.onDeviceRemoved(deviceF);
}
});
} else {
mCallback.onDeviceRemoved(device);
}
}
}
/**
* Callback class used for clients to receive MIDI device added and removed notifications
*/
public static class DeviceCallback {
/**
* Called to notify when a new MIDI device has been added
*
* @param device a {@link MidiDeviceInfo} for the newly added device
*/
public void onDeviceAdded(MidiDeviceInfo device) {
}
/**
* Called to notify when a MIDI device has been removed
*
* @param device a {@link MidiDeviceInfo} for the removed device
*/
public void onDeviceRemoved(MidiDeviceInfo device) {
}
}
/**
* @hide
*/
public MidiManager(Context context, IMidiManager service) {
mContext = context;
mService = service;
}
/**
* Registers a callback to receive notifications when MIDI devices are added and removed.
*
* @param callback a {@link DeviceCallback} for MIDI device notifications
* @param handler The {@link android.os.Handler Handler} that will be used for delivering the
* device notifications. If handler is null, then the thread used for the
* callback is unspecified.
*/
public void registerDeviceCallback(DeviceCallback callback, Handler handler) {
DeviceListener deviceListener = new DeviceListener(callback, handler);
try {
mService.registerListener(mToken, deviceListener);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in registerDeviceListener");
return;
}
mDeviceListeners.put(callback, deviceListener);
}
/**
* Unregisters a {@link DeviceCallback}.
*
* @param callback a {@link DeviceCallback} to unregister
*/
public void unregisterDeviceCallback(DeviceCallback callback) {
DeviceListener deviceListener = mDeviceListeners.remove(callback);
if (deviceListener != null) {
try {
mService.unregisterListener(mToken, deviceListener);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in unregisterDeviceListener");
}
}
}
/**
* Gets the list of all connected MIDI devices.
*
* @return an array of all MIDI devices
*/
public MidiDeviceInfo[] getDeviceList() {
try {
return mService.getDeviceList();
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in getDeviceList");
return new MidiDeviceInfo[0];
}
}
/**
* Opens a MIDI device for reading and writing.
*
* @param deviceInfo a {@link android.media.midi.MidiDeviceInfo} to open
* @return a {@link MidiDevice} object for the device
*/
public MidiDevice openDevice(MidiDeviceInfo deviceInfo) {
try {
IMidiDeviceServer server = mService.openDevice(mToken, deviceInfo);
if (server == null) {
Log.e(TAG, "could not open device " + deviceInfo);
return null;
}
return new MidiDevice(deviceInfo, server);
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in openDevice");
}
return null;
}
/** @hide */
public MidiDeviceServer createDeviceServer(int numInputPorts, int numOutputPorts,
Bundle properties, boolean isPrivate, int type) {
try {
MidiDeviceServer server = new MidiDeviceServer(mService);
MidiDeviceInfo deviceInfo = mService.registerDeviceServer(server.getBinderInterface(),
numInputPorts, numOutputPorts, properties, isPrivate, type);
if (deviceInfo == null) {
Log.e(TAG, "registerVirtualDevice failed");
return null;
}
server.setDeviceInfo(deviceInfo);
return server;
} catch (RemoteException e) {
Log.e(TAG, "RemoteException in createVirtualDevice");
return null;
}
}
/**
* Creates a new MIDI virtual device.
*
* @param numInputPorts number of input ports for the virtual device
* @param numOutputPorts number of output ports for the virtual device
* @param properties a {@link android.os.Bundle} containing properties describing the device
* @param isPrivate true if this device should only be visible and accessible to apps
* with the same UID as the caller
* @return a {@link MidiDeviceServer} object to locally represent the device
*/
public MidiDeviceServer createDeviceServer(int numInputPorts, int numOutputPorts,
Bundle properties, boolean isPrivate) {
return createDeviceServer(numInputPorts, numOutputPorts, properties,
isPrivate, MidiDeviceInfo.TYPE_VIRTUAL);
}
}
|
