Remove Session Id from ImsService APIs that do not need it.
[android/platform/frameworks/opt/net/ims.git] / src / java / com / android / ims / internal / ImsVideoCallProvider.java
1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License
15  */
16
17 package com.android.ims.internal;
18
19 import com.android.internal.os.SomeArgs;
20
21 import android.net.Uri;
22 import android.os.Handler;
23 import android.os.Looper;
24 import android.os.Message;
25 import android.os.RemoteException;
26 import android.telecom.Connection;
27 import android.telecom.VideoProfile;
28 import android.telecom.VideoProfile.CameraCapabilities;
29 import android.view.Surface;
30
31 public abstract class ImsVideoCallProvider {
32     private static final int MSG_SET_CALLBACK = 1;
33     private static final int MSG_SET_CAMERA = 2;
34     private static final int MSG_SET_PREVIEW_SURFACE = 3;
35     private static final int MSG_SET_DISPLAY_SURFACE = 4;
36     private static final int MSG_SET_DEVICE_ORIENTATION = 5;
37     private static final int MSG_SET_ZOOM = 6;
38     private static final int MSG_SEND_SESSION_MODIFY_REQUEST = 7;
39     private static final int MSG_SEND_SESSION_MODIFY_RESPONSE = 8;
40     private static final int MSG_REQUEST_CAMERA_CAPABILITIES = 9;
41     private static final int MSG_REQUEST_CALL_DATA_USAGE = 10;
42     private static final int MSG_SET_PAUSE_IMAGE = 11;
43
44     private final ImsVideoCallProviderBinder mBinder;
45
46     private IImsVideoCallCallback mCallback;
47
48     /**
49      * Default handler used to consolidate binder method calls onto a single thread.
50      */
51     private final Handler mProviderHandler = new Handler(Looper.getMainLooper()) {
52         @Override
53         public void handleMessage(Message msg) {
54             switch (msg.what) {
55                 case MSG_SET_CALLBACK:
56                     mCallback = (IImsVideoCallCallback) msg.obj;
57                     break;
58                 case MSG_SET_CAMERA:
59                 {
60                     SomeArgs args = (SomeArgs) msg.obj;
61                     try {
62                         onSetCamera((String) args.arg1);
63                         onSetCamera((String) args.arg1, args.argi1);
64                     } finally {
65                         args.recycle();
66                     }
67                     break;
68                 }
69                 case MSG_SET_PREVIEW_SURFACE:
70                     onSetPreviewSurface((Surface) msg.obj);
71                     break;
72                 case MSG_SET_DISPLAY_SURFACE:
73                     onSetDisplaySurface((Surface) msg.obj);
74                     break;
75                 case MSG_SET_DEVICE_ORIENTATION:
76                     onSetDeviceOrientation(msg.arg1);
77                     break;
78                 case MSG_SET_ZOOM:
79                     onSetZoom((Float) msg.obj);
80                     break;
81                 case MSG_SEND_SESSION_MODIFY_REQUEST: {
82                     SomeArgs args = (SomeArgs) msg.obj;
83                     try {
84                         VideoProfile fromProfile = (VideoProfile) args.arg1;
85                         VideoProfile toProfile = (VideoProfile) args.arg2;
86
87                         onSendSessionModifyRequest(fromProfile, toProfile);
88                     } finally {
89                         args.recycle();
90                     }
91                     break;
92                 }
93                 case MSG_SEND_SESSION_MODIFY_RESPONSE:
94                     onSendSessionModifyResponse((VideoProfile) msg.obj);
95                     break;
96                 case MSG_REQUEST_CAMERA_CAPABILITIES:
97                     onRequestCameraCapabilities();
98                     break;
99                 case MSG_REQUEST_CALL_DATA_USAGE:
100                     onRequestCallDataUsage();
101                     break;
102                 case MSG_SET_PAUSE_IMAGE:
103                     onSetPauseImage((Uri) msg.obj);
104                     break;
105                 default:
106                     break;
107             }
108         }
109     };
110
111     /**
112      * IImsVideoCallProvider stub implementation.
113      */
114     private final class ImsVideoCallProviderBinder extends IImsVideoCallProvider.Stub {
115         public void setCallback(IImsVideoCallCallback callback) {
116             mProviderHandler.obtainMessage(MSG_SET_CALLBACK, callback).sendToTarget();
117         }
118
119         public void setCamera(String cameraId, int uid) {
120             SomeArgs args = SomeArgs.obtain();
121             args.arg1 = cameraId;
122             args.argi1 = uid;
123             mProviderHandler.obtainMessage(MSG_SET_CAMERA, args).sendToTarget();
124         }
125
126         public void setPreviewSurface(Surface surface) {
127             mProviderHandler.obtainMessage(MSG_SET_PREVIEW_SURFACE, surface).sendToTarget();
128         }
129
130         public void setDisplaySurface(Surface surface) {
131             mProviderHandler.obtainMessage(MSG_SET_DISPLAY_SURFACE, surface).sendToTarget();
132         }
133
134         public void setDeviceOrientation(int rotation) {
135             mProviderHandler.obtainMessage(MSG_SET_DEVICE_ORIENTATION, rotation, 0).sendToTarget();
136         }
137
138         public void setZoom(float value) {
139             mProviderHandler.obtainMessage(MSG_SET_ZOOM, value).sendToTarget();
140         }
141
142         public void sendSessionModifyRequest(VideoProfile fromProfile, VideoProfile toProfile) {
143             SomeArgs args = SomeArgs.obtain();
144             args.arg1 = fromProfile;
145             args.arg2 = toProfile;
146             mProviderHandler.obtainMessage(MSG_SEND_SESSION_MODIFY_REQUEST, args).sendToTarget();
147         }
148
149         public void sendSessionModifyResponse(VideoProfile responseProfile) {
150             mProviderHandler.obtainMessage(
151                     MSG_SEND_SESSION_MODIFY_RESPONSE, responseProfile).sendToTarget();
152         }
153
154         public void requestCameraCapabilities() {
155             mProviderHandler.obtainMessage(MSG_REQUEST_CAMERA_CAPABILITIES).sendToTarget();
156         }
157
158         public void requestCallDataUsage() {
159             mProviderHandler.obtainMessage(MSG_REQUEST_CALL_DATA_USAGE).sendToTarget();
160         }
161
162         public void setPauseImage(Uri uri) {
163             mProviderHandler.obtainMessage(MSG_SET_PAUSE_IMAGE, uri).sendToTarget();
164         }
165     }
166
167     public ImsVideoCallProvider() {
168         mBinder = new ImsVideoCallProviderBinder();
169     }
170
171     /**
172      * Returns binder object which can be used across IPC methods.
173      */
174     public final IImsVideoCallProvider getInterface() {
175         return mBinder;
176     }
177
178     /** @see Connection.VideoProvider#onSetCamera */
179     public abstract void onSetCamera(String cameraId);
180
181     /**
182      * Similar to {@link #onSetCamera(String)}, except includes the UID of the calling process which
183      * the IMS service uses when opening the camera.  This ensures camera permissions are verified
184      * by the camera service.
185      *
186      * @param cameraId The id of the camera to be opened.
187      * @param uid The uid of the caller, used when opening the camera for permission verification.
188      * @see Connection.VideoProvider#onSetCamera
189      */
190     public void onSetCamera(String cameraId, int uid) {
191     }
192
193     /** @see Connection.VideoProvider#onSetPreviewSurface */
194     public abstract void onSetPreviewSurface(Surface surface);
195
196     /** @see Connection.VideoProvider#onSetDisplaySurface */
197     public abstract void onSetDisplaySurface(Surface surface);
198
199     /** @see Connection.VideoProvider#onSetDeviceOrientation */
200     public abstract void onSetDeviceOrientation(int rotation);
201
202     /** @see Connection.VideoProvider#onSetZoom */
203     public abstract void onSetZoom(float value);
204
205     /** @see Connection.VideoProvider#onSendSessionModifyRequest */
206     public abstract void onSendSessionModifyRequest(VideoProfile fromProfile,
207             VideoProfile toProfile);
208
209     /** @see Connection.VideoProvider#onSendSessionModifyResponse */
210     public abstract void onSendSessionModifyResponse(VideoProfile responseProfile);
211
212     /** @see Connection.VideoProvider#onRequestCameraCapabilities */
213     public abstract void onRequestCameraCapabilities();
214
215     /** @see Connection.VideoProvider#onRequestCallDataUsage */
216     public abstract void onRequestCallDataUsage();
217
218     /** @see Connection.VideoProvider#onSetPauseImage */
219     public abstract void onSetPauseImage(Uri uri);
220
221     /** @see Connection.VideoProvider#receiveSessionModifyRequest */
222     public void receiveSessionModifyRequest(VideoProfile VideoProfile) {
223         if (mCallback != null) {
224             try {
225                 mCallback.receiveSessionModifyRequest(VideoProfile);
226             } catch (RemoteException ignored) {
227             }
228         }
229     }
230
231     /** @see Connection.VideoProvider#receiveSessionModifyResponse */
232     public void receiveSessionModifyResponse(
233             int status, VideoProfile requestedProfile, VideoProfile responseProfile) {
234         if (mCallback != null) {
235             try {
236                 mCallback.receiveSessionModifyResponse(status, requestedProfile, responseProfile);
237             } catch (RemoteException ignored) {
238             }
239         }
240     }
241
242     /** @see Connection.VideoProvider#handleCallSessionEvent */
243     public void handleCallSessionEvent(int event) {
244         if (mCallback != null) {
245             try {
246                 mCallback.handleCallSessionEvent(event);
247             } catch (RemoteException ignored) {
248             }
249         }
250     }
251
252     /** @see Connection.VideoProvider#changePeerDimensions */
253     public void changePeerDimensions(int width, int height) {
254         if (mCallback != null) {
255             try {
256                 mCallback.changePeerDimensions(width, height);
257             } catch (RemoteException ignored) {
258             }
259         }
260     }
261
262     /** @see Connection.VideoProvider#changeCallDataUsage */
263     public void changeCallDataUsage(long dataUsage) {
264         if (mCallback != null) {
265             try {
266                 mCallback.changeCallDataUsage(dataUsage);
267             } catch (RemoteException ignored) {
268             }
269         }
270     }
271
272     /** @see Connection.VideoProvider#changeCameraCapabilities */
273     public void changeCameraCapabilities(CameraCapabilities CameraCapabilities) {
274         if (mCallback != null) {
275             try {
276                 mCallback.changeCameraCapabilities(CameraCapabilities);
277             } catch (RemoteException ignored) {
278             }
279         }
280     }
281
282     /** @see Connection.VideoProvider#changeVideoQuality */
283     public void changeVideoQuality(int videoQuality) {
284         if (mCallback != null) {
285             try {
286                 mCallback.changeVideoQuality(videoQuality);
287             } catch (RemoteException ignored) {
288             }
289         }
290     }
291 }