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
17package android.telecom;
18
19import android.os.Handler;
20import android.os.IBinder;
21import android.os.Looper;
22import android.os.Message;
23import android.os.RemoteException;
24import android.telecom.InCallService.VideoCall;
25import android.view.Surface;
26
27import com.android.internal.os.SomeArgs;
28import com.android.internal.telecom.IVideoCallback;
29import com.android.internal.telecom.IVideoProvider;
30
31/**
32 * Implementation of a Video Call, which allows InCallUi to communicate commands to the underlying
33 * {@link Connection.VideoProvider}, and direct callbacks from the
34 * {@link Connection.VideoProvider} to the appropriate {@link VideoCall.Listener}.
35 *
36 * {@hide}
37 */
38public class VideoCallImpl extends VideoCall {
39    private static final int MSG_RECEIVE_SESSION_MODIFY_REQUEST = 1;
40    private static final int MSG_RECEIVE_SESSION_MODIFY_RESPONSE = 2;
41    private static final int MSG_HANDLE_CALL_SESSION_EVENT = 3;
42    private static final int MSG_CHANGE_PEER_DIMENSIONS = 4;
43    private static final int MSG_CHANGE_CALL_DATA_USAGE = 5;
44    private static final int MSG_CHANGE_CAMERA_CAPABILITIES = 6;
45
46    private final IVideoProvider mVideoProvider;
47    private final VideoCallListenerBinder mBinder;
48    private VideoCall.Listener mVideoCallListener;
49
50    private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
51        @Override
52        public void binderDied() {
53            mVideoProvider.asBinder().unlinkToDeath(this, 0);
54        }
55    };
56
57    /**
58     * IVideoCallback stub implementation.
59     */
60    private final class VideoCallListenerBinder extends IVideoCallback.Stub {
61        @Override
62        public void receiveSessionModifyRequest(VideoProfile videoProfile) {
63            mHandler.obtainMessage(MSG_RECEIVE_SESSION_MODIFY_REQUEST,
64                    videoProfile).sendToTarget();
65        }
66
67        @Override
68        public void receiveSessionModifyResponse(int status, VideoProfile requestProfile,
69                VideoProfile responseProfile) {
70            SomeArgs args = SomeArgs.obtain();
71            args.arg1 = status;
72            args.arg2 = requestProfile;
73            args.arg3 = responseProfile;
74            mHandler.obtainMessage(MSG_RECEIVE_SESSION_MODIFY_RESPONSE, args).sendToTarget();
75        }
76
77        @Override
78        public void handleCallSessionEvent(int event) {
79            mHandler.obtainMessage(MSG_HANDLE_CALL_SESSION_EVENT, event).sendToTarget();
80        }
81
82        @Override
83        public void changePeerDimensions(int width, int height) {
84            SomeArgs args = SomeArgs.obtain();
85            args.arg1 = width;
86            args.arg2 = height;
87            mHandler.obtainMessage(MSG_CHANGE_PEER_DIMENSIONS, args).sendToTarget();
88        }
89
90        @Override
91        public void changeCallDataUsage(int dataUsage) {
92            mHandler.obtainMessage(MSG_CHANGE_CALL_DATA_USAGE, dataUsage).sendToTarget();
93        }
94
95        @Override
96        public void changeCameraCapabilities(CameraCapabilities cameraCapabilities) {
97            mHandler.obtainMessage(MSG_CHANGE_CAMERA_CAPABILITIES,
98                    cameraCapabilities).sendToTarget();
99        }
100    }
101
102    /** Default handler used to consolidate binder method calls onto a single thread. */
103    private final Handler mHandler = new Handler(Looper.getMainLooper()) {
104        @Override
105        public void handleMessage(Message msg) {
106            if (mVideoCallListener == null) {
107                return;
108            }
109
110            SomeArgs args;
111            switch (msg.what) {
112                case MSG_RECEIVE_SESSION_MODIFY_REQUEST:
113                    mVideoCallListener.onSessionModifyRequestReceived((VideoProfile) msg.obj);
114                    break;
115                case MSG_RECEIVE_SESSION_MODIFY_RESPONSE:
116                    args = (SomeArgs) msg.obj;
117                    try {
118                        int status = (int) args.arg1;
119                        VideoProfile requestProfile = (VideoProfile) args.arg2;
120                        VideoProfile responseProfile = (VideoProfile) args.arg3;
121
122                        mVideoCallListener.onSessionModifyResponseReceived(
123                                status, requestProfile, responseProfile);
124                    } finally {
125                        args.recycle();
126                    }
127                    break;
128                case MSG_HANDLE_CALL_SESSION_EVENT:
129                    mVideoCallListener.onCallSessionEvent((int) msg.obj);
130                    break;
131                case MSG_CHANGE_PEER_DIMENSIONS:
132                    args = (SomeArgs) msg.obj;
133                    try {
134                        int width = (int) args.arg1;
135                        int height = (int) args.arg2;
136                        mVideoCallListener.onPeerDimensionsChanged(width, height);
137                    } finally {
138                        args.recycle();
139                    }
140                    break;
141                case MSG_CHANGE_CALL_DATA_USAGE:
142                    mVideoCallListener.onCallDataUsageChanged(msg.arg1);
143                    break;
144                case MSG_CHANGE_CAMERA_CAPABILITIES:
145                    mVideoCallListener.onCameraCapabilitiesChanged(
146                            (CameraCapabilities) msg.obj);
147                    break;
148                default:
149                    break;
150            }
151        }
152    };
153
154    /** {@hide} */
155    VideoCallImpl(IVideoProvider videoProvider) throws RemoteException {
156        mVideoProvider = videoProvider;
157        mVideoProvider.asBinder().linkToDeath(mDeathRecipient, 0);
158
159        mBinder = new VideoCallListenerBinder();
160        mVideoProvider.setVideoCallback(mBinder);
161    }
162
163    /** {@inheritDoc} */
164    public void setVideoCallListener(VideoCall.Listener videoCallListener) {
165        mVideoCallListener = videoCallListener;
166    }
167
168    /** {@inheritDoc} */
169    public void setCamera(String cameraId) {
170        try {
171            mVideoProvider.setCamera(cameraId);
172        } catch (RemoteException e) {
173        }
174    }
175
176    /** {@inheritDoc} */
177    public void setPreviewSurface(Surface surface) {
178        try {
179            mVideoProvider.setPreviewSurface(surface);
180        } catch (RemoteException e) {
181        }
182    }
183
184    /** {@inheritDoc} */
185    public void setDisplaySurface(Surface surface) {
186        try {
187            mVideoProvider.setDisplaySurface(surface);
188        } catch (RemoteException e) {
189        }
190    }
191
192    /** {@inheritDoc} */
193    public void setDeviceOrientation(int rotation) {
194        try {
195            mVideoProvider.setDeviceOrientation(rotation);
196        } catch (RemoteException e) {
197        }
198    }
199
200    /** {@inheritDoc} */
201    public void setZoom(float value) {
202        try {
203            mVideoProvider.setZoom(value);
204        } catch (RemoteException e) {
205        }
206    }
207
208    /** {@inheritDoc} */
209    public void sendSessionModifyRequest(VideoProfile requestProfile) {
210        try {
211            mVideoProvider.sendSessionModifyRequest(requestProfile);
212        } catch (RemoteException e) {
213        }
214    }
215
216    /** {@inheritDoc} */
217    public void sendSessionModifyResponse(VideoProfile responseProfile) {
218        try {
219            mVideoProvider.sendSessionModifyResponse(responseProfile);
220        } catch (RemoteException e) {
221        }
222    }
223
224    /** {@inheritDoc} */
225    public void requestCameraCapabilities() {
226        try {
227            mVideoProvider.requestCameraCapabilities();
228        } catch (RemoteException e) {
229        }
230    }
231
232    /** {@inheritDoc} */
233    public void requestCallDataUsage() {
234        try {
235            mVideoProvider.requestCallDataUsage();
236        } catch (RemoteException e) {
237        }
238    }
239
240    /** {@inheritDoc} */
241    public void setPauseImage(String uri) {
242        try {
243            mVideoProvider.setPauseImage(uri);
244        } catch (RemoteException e) {
245        }
246    }
247}