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
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
|
/*
* Copyright (C) 2013 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.telecom;
import android.annotation.SystemApi;
import android.annotation.SdkConstant;
import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.view.Surface;
import com.android.internal.os.SomeArgs;
import com.android.internal.telecom.IInCallAdapter;
import com.android.internal.telecom.IInCallService;
import java.lang.String;
/**
* This service is implemented by any app that wishes to provide the user-interface for managing
* phone calls. Telecom binds to this service while there exists a live (active or incoming) call,
* and uses it to notify the in-call app of any live and and recently disconnected calls.
*
* {@hide}
*/
@SystemApi
public abstract class InCallService extends Service {
/**
* The {@link Intent} that must be declared as handled by the service.
*/
@SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION)
public static final String SERVICE_INTERFACE = "android.telecom.InCallService";
private static final int MSG_SET_IN_CALL_ADAPTER = 1;
private static final int MSG_ADD_CALL = 2;
private static final int MSG_UPDATE_CALL = 3;
private static final int MSG_SET_POST_DIAL_WAIT = 4;
private static final int MSG_ON_AUDIO_STATE_CHANGED = 5;
private static final int MSG_BRING_TO_FOREGROUND = 6;
private static final int MSG_ON_CAN_ADD_CALL_CHANGED = 7;
/** Default Handler used to consolidate binder method calls onto a single thread. */
private final Handler mHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
if (mPhone == null && msg.what != MSG_SET_IN_CALL_ADAPTER) {
return;
}
switch (msg.what) {
case MSG_SET_IN_CALL_ADAPTER:
mPhone = new Phone(new InCallAdapter((IInCallAdapter) msg.obj));
onPhoneCreated(mPhone);
break;
case MSG_ADD_CALL:
mPhone.internalAddCall((ParcelableCall) msg.obj);
break;
case MSG_UPDATE_CALL:
mPhone.internalUpdateCall((ParcelableCall) msg.obj);
break;
case MSG_SET_POST_DIAL_WAIT: {
SomeArgs args = (SomeArgs) msg.obj;
try {
String callId = (String) args.arg1;
String remaining = (String) args.arg2;
mPhone.internalSetPostDialWait(callId, remaining);
} finally {
args.recycle();
}
break;
}
case MSG_ON_AUDIO_STATE_CHANGED:
mPhone.internalAudioStateChanged((AudioState) msg.obj);
break;
case MSG_BRING_TO_FOREGROUND:
mPhone.internalBringToForeground(msg.arg1 == 1);
break;
case MSG_ON_CAN_ADD_CALL_CHANGED:
mPhone.internalSetCanAddCall(msg.arg1 == 1);
break;
default:
break;
}
}
};
/** Manages the binder calls so that the implementor does not need to deal with it. */
private final class InCallServiceBinder extends IInCallService.Stub {
@Override
public void setInCallAdapter(IInCallAdapter inCallAdapter) {
mHandler.obtainMessage(MSG_SET_IN_CALL_ADAPTER, inCallAdapter).sendToTarget();
}
@Override
public void addCall(ParcelableCall call) {
mHandler.obtainMessage(MSG_ADD_CALL, call).sendToTarget();
}
@Override
public void updateCall(ParcelableCall call) {
mHandler.obtainMessage(MSG_UPDATE_CALL, call).sendToTarget();
}
@Override
public void setPostDial(String callId, String remaining) {
// TODO: Unused
}
@Override
public void setPostDialWait(String callId, String remaining) {
SomeArgs args = SomeArgs.obtain();
args.arg1 = callId;
args.arg2 = remaining;
mHandler.obtainMessage(MSG_SET_POST_DIAL_WAIT, args).sendToTarget();
}
@Override
public void onAudioStateChanged(AudioState audioState) {
mHandler.obtainMessage(MSG_ON_AUDIO_STATE_CHANGED, audioState).sendToTarget();
}
@Override
public void bringToForeground(boolean showDialpad) {
mHandler.obtainMessage(MSG_BRING_TO_FOREGROUND, showDialpad ? 1 : 0, 0).sendToTarget();
}
@Override
public void onCanAddCallChanged(boolean canAddCall) {
mHandler.obtainMessage(MSG_ON_CAN_ADD_CALL_CHANGED, canAddCall ? 1 : 0, 0)
.sendToTarget();
}
}
private Phone mPhone;
public InCallService() {
}
@Override
public IBinder onBind(Intent intent) {
return new InCallServiceBinder();
}
@Override
public boolean onUnbind(Intent intent) {
if (mPhone != null) {
Phone oldPhone = mPhone;
mPhone = null;
oldPhone.destroy();
onPhoneDestroyed(oldPhone);
}
return false;
}
/**
* Obtain the {@code Phone} associated with this {@code InCallService}.
*
* @return The {@code Phone} object associated with this {@code InCallService}, or {@code null}
* if the {@code InCallService} is not in a state where it has an associated
* {@code Phone}.
*/
public Phone getPhone() {
return mPhone;
}
/**
* Invoked when the {@code Phone} has been created. This is a signal to the in-call experience
* to start displaying in-call information to the user. Each instance of {@code InCallService}
* will have only one {@code Phone}, and this method will be called exactly once in the lifetime
* of the {@code InCallService}.
*
* @param phone The {@code Phone} object associated with this {@code InCallService}.
*/
public void onPhoneCreated(Phone phone) {
}
/**
* Invoked when a {@code Phone} has been destroyed. This is a signal to the in-call experience
* to stop displaying in-call information to the user. This method will be called exactly once
* in the lifetime of the {@code InCallService}, and it will always be called after a previous
* call to {@link #onPhoneCreated(Phone)}.
*
* @param phone The {@code Phone} object associated with this {@code InCallService}.
*/
public void onPhoneDestroyed(Phone phone) {
}
/**
* Class to invoke functionality related to video calls.
* @hide
*/
public static abstract class VideoCall {
/**
* Sets a listener to invoke callback methods in the InCallUI after performing video
* telephony actions.
*
* @param videoCallListener The call video client.
*/
public abstract void setVideoCallListener(VideoCall.Listener videoCallListener);
/**
* Sets the camera to be used for video recording in a video call.
*
* @param cameraId The id of the camera.
*/
public abstract void setCamera(String cameraId);
/**
* Sets the surface to be used for displaying a preview of what the user's camera is
* currently capturing. When video transmission is enabled, this is the video signal which
* is sent to the remote device.
*
* @param surface The surface.
*/
public abstract void setPreviewSurface(Surface surface);
/**
* Sets the surface to be used for displaying the video received from the remote device.
*
* @param surface The surface.
*/
public abstract void setDisplaySurface(Surface surface);
/**
* Sets the device orientation, in degrees. Assumes that a standard portrait orientation of
* the device is 0 degrees.
*
* @param rotation The device orientation, in degrees.
*/
public abstract void setDeviceOrientation(int rotation);
/**
* Sets camera zoom ratio.
*
* @param value The camera zoom ratio.
*/
public abstract void setZoom(float value);
/**
* Issues a request to modify the properties of the current session. The request is sent to
* the remote device where it it handled by
* {@link VideoCall.Listener#onSessionModifyRequestReceived}.
* Some examples of session modification requests: upgrade call from audio to video,
* downgrade call from video to audio, pause video.
*
* @param requestProfile The requested call video properties.
*/
public abstract void sendSessionModifyRequest(VideoProfile requestProfile);
/**
* Provides a response to a request to change the current call session video
* properties.
* This is in response to a request the InCall UI has received via
* {@link VideoCall.Listener#onSessionModifyRequestReceived}.
* The response is handled on the remove device by
* {@link VideoCall.Listener#onSessionModifyResponseReceived}.
*
* @param responseProfile The response call video properties.
*/
public abstract void sendSessionModifyResponse(VideoProfile responseProfile);
/**
* Issues a request to the video provider to retrieve the camera capabilities.
* Camera capabilities are reported back to the caller via
* {@link VideoCall.Listener#onCameraCapabilitiesChanged(CameraCapabilities)}.
*/
public abstract void requestCameraCapabilities();
/**
* Issues a request to the video telephony framework to retrieve the cumulative data usage for
* the current call. Data usage is reported back to the caller via
* {@link VideoCall.Listener#onCallDataUsageChanged}.
*/
public abstract void requestCallDataUsage();
/**
* Provides the video telephony framework with the URI of an image to be displayed to remote
* devices when the video signal is paused.
*
* @param uri URI of image to display.
*/
public abstract void setPauseImage(String uri);
/**
* Listener class which invokes callbacks after video call actions occur.
* @hide
*/
public static abstract class Listener {
/**
* Called when a session modification request is received from the remote device.
* The remote request is sent via
* {@link Connection.VideoProvider#onSendSessionModifyRequest}. The InCall UI
* is responsible for potentially prompting the user whether they wish to accept the new
* call profile (e.g. prompt user if they wish to accept an upgrade from an audio to a
* video call) and should call
* {@link Connection.VideoProvider#onSendSessionModifyResponse} to indicate
* the video settings the user has agreed to.
*
* @param videoProfile The requested video call profile.
*/
public abstract void onSessionModifyRequestReceived(VideoProfile videoProfile);
/**
* Called when a response to a session modification request is received from the remote
* device. The remote InCall UI sends the response using
* {@link Connection.VideoProvider#onSendSessionModifyResponse}.
*
* @param status Status of the session modify request. Valid values are
* {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_SUCCESS},
* {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_FAIL},
* {@link Connection.VideoProvider#SESSION_MODIFY_REQUEST_INVALID}
* @param requestedProfile The original request which was sent to the remote device.
* @param responseProfile The actual profile changes made by the remote device.
*/
public abstract void onSessionModifyResponseReceived(int status,
VideoProfile requestedProfile, VideoProfile responseProfile);
/**
* Handles events related to the current session which the client may wish to handle.
* These are separate from requested changes to the session due to the underlying
* protocol or connection.
*
* Valid values are:
* {@link Connection.VideoProvider#SESSION_EVENT_RX_PAUSE},
* {@link Connection.VideoProvider#SESSION_EVENT_RX_RESUME},
* {@link Connection.VideoProvider#SESSION_EVENT_TX_START},
* {@link Connection.VideoProvider#SESSION_EVENT_TX_STOP},
* {@link Connection.VideoProvider#SESSION_EVENT_CAMERA_FAILURE},
* {@link Connection.VideoProvider#SESSION_EVENT_CAMERA_READY}
*
* @param event The event.
*/
public abstract void onCallSessionEvent(int event);
/**
* Handles a change to the video dimensions from the remote caller (peer). This could
* happen if, for example, the peer changes orientation of their device.
*
* @param width The updated peer video width.
* @param height The updated peer video height.
*/
public abstract void onPeerDimensionsChanged(int width, int height);
/**
* Handles a change to the video quality.
*
* @param videoQuality The updated peer video quality.
*/
public abstract void onVideoQualityChanged(int videoQuality);
/**
* Handles an update to the total data used for the current session.
*
* @param dataUsage The updated data usage.
*/
public abstract void onCallDataUsageChanged(long dataUsage);
/**
* Handles a change in camera capabilities.
*
* @param cameraCapabilities The changed camera capabilities.
*/
public abstract void onCameraCapabilitiesChanged(
CameraCapabilities cameraCapabilities);
}
}
}
|