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  R* limitations under the License.
15  */
16 
17 package android.telecom;
18 
19 import com.android.internal.os.SomeArgs;
20 import com.android.internal.telecom.IVideoCallback;
21 
22 import android.os.Handler;
23 import android.os.Message;
24 import android.os.RemoteException;
25 
26 /**
27  * A component that provides an RPC servant implementation of {@link IVideoCallback},
28  * posting incoming messages on the main thread on a client-supplied delegate object.
29  *
30  * TODO: Generate this and similar classes using a compiler starting from AIDL interfaces.
31  *
32  * @hide
33  */
34 final class VideoCallbackServant {
35     private static final int MSG_RECEIVE_SESSION_MODIFY_REQUEST = 0;
36     private static final int MSG_RECEIVE_SESSION_MODIFY_RESPONSE = 1;
37     private static final int MSG_HANDLE_CALL_SESSION_EVENT = 2;
38     private static final int MSG_CHANGE_PEER_DIMENSIONS = 3;
39     private static final int MSG_CHANGE_CALL_DATA_USAGE = 4;
40     private static final int MSG_CHANGE_CAMERA_CAPABILITIES = 5;
41 
42     private final IVideoCallback mDelegate;
43 
44     private final Handler mHandler = new Handler() {
45         @Override
46         public void handleMessage(Message msg) {
47             try {
48                 internalHandleMessage(msg);
49             } catch (RemoteException e) {
50             }
51         }
52 
53         // Internal method defined to centralize handling of RemoteException
54         private void internalHandleMessage(Message msg) throws RemoteException {
55             switch (msg.what) {
56                 case MSG_RECEIVE_SESSION_MODIFY_REQUEST: {
57                     mDelegate.receiveSessionModifyRequest((VideoProfile) msg.obj);
58                     break;
59                 }
60                 case MSG_RECEIVE_SESSION_MODIFY_RESPONSE: {
61                     SomeArgs args = (SomeArgs) msg.obj;
62                     try {
63                         mDelegate.receiveSessionModifyResponse(
64                                 args.argi1,
65                                 (VideoProfile) args.arg1,
66                                 (VideoProfile) args.arg2);
67                     } finally {
68                         args.recycle();
69                     }
70                     break;
71                 }
72                 case MSG_HANDLE_CALL_SESSION_EVENT: {
73                     SomeArgs args = (SomeArgs) msg.obj;
74                     try {
75                         mDelegate.handleCallSessionEvent(args.argi1);
76                     } finally {
77                         args.recycle();
78                     }
79                     break;
80                 }
81                 case MSG_CHANGE_PEER_DIMENSIONS: {
82                     SomeArgs args = (SomeArgs) msg.obj;
83                     try {
84                         mDelegate.changePeerDimensions(args.argi1, args.argi2);
85                     } finally {
86                         args.recycle();
87                     }
88                     break;
89                 }
90                 case MSG_CHANGE_CALL_DATA_USAGE: {
91                     SomeArgs args = (SomeArgs) msg.obj;
92                     try {
93                         mDelegate.changeCallDataUsage(args.argi1);
94                     } finally {
95                         args.recycle();
96                     }
97                     break;
98                 }
99                 case MSG_CHANGE_CAMERA_CAPABILITIES: {
100                     mDelegate.changeCameraCapabilities((CameraCapabilities) msg.obj);
101                     break;
102                 }
103             }
104         }
105     };
106 
107     private final IVideoCallback mStub = new IVideoCallback.Stub() {
108         @Override
109         public void receiveSessionModifyRequest(VideoProfile videoProfile) throws RemoteException {
110             mHandler.obtainMessage(MSG_RECEIVE_SESSION_MODIFY_REQUEST, videoProfile).sendToTarget();
111         }
112 
113         @Override
114         public void receiveSessionModifyResponse(int status, VideoProfile requestedProfile,
115                 VideoProfile responseProfile) throws RemoteException {
116             SomeArgs args = SomeArgs.obtain();
117             args.argi1 = status;
118             args.arg1 = requestedProfile;
119             args.arg2 = responseProfile;
120             mHandler.obtainMessage(MSG_RECEIVE_SESSION_MODIFY_RESPONSE, args).sendToTarget();
121         }
122 
123         @Override
124         public void handleCallSessionEvent(int event) throws RemoteException {
125             SomeArgs args = SomeArgs.obtain();
126             args.argi1 = event;
127             mHandler.obtainMessage(MSG_HANDLE_CALL_SESSION_EVENT, args).sendToTarget();
128         }
129 
130         @Override
131         public void changePeerDimensions(int width, int height) throws RemoteException {
132             SomeArgs args = SomeArgs.obtain();
133             args.argi1 = width;
134             args.argi2 = height;
135             mHandler.obtainMessage(MSG_CHANGE_PEER_DIMENSIONS, args).sendToTarget();
136         }
137 
138         @Override
139         public void changeCallDataUsage(int dataUsage) throws RemoteException {
140             SomeArgs args = SomeArgs.obtain();
141             args.argi1 = dataUsage;
142             mHandler.obtainMessage(MSG_CHANGE_CALL_DATA_USAGE, args).sendToTarget();
143         }
144 
145         @Override
146         public void changeCameraCapabilities(CameraCapabilities cameraCapabilities)
147                 throws RemoteException {
148             mHandler.obtainMessage(MSG_CHANGE_CAMERA_CAPABILITIES, cameraCapabilities)
149                     .sendToTarget();
150         }
151     };
152 
VideoCallbackServant(IVideoCallback delegate)153     public VideoCallbackServant(IVideoCallback delegate) {
154         mDelegate = delegate;
155     }
156 
getStub()157     public IVideoCallback getStub() {
158         return mStub;
159     }
160 }
161