CallbackProxies.java revision e8df3093f53fa992f89e019b2fc87ff4fac0f335 
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 */
16package android.hardware.camera2.impl;
17
18import android.hardware.camera2.CameraCaptureSession;
19import android.hardware.camera2.CameraDevice;
20import android.hardware.camera2.CaptureFailure;
21import android.hardware.camera2.CaptureRequest;
22import android.hardware.camera2.CaptureResult;
23import android.hardware.camera2.TotalCaptureResult;
24import android.hardware.camera2.dispatch.Dispatchable;
25import android.hardware.camera2.dispatch.MethodNameInvoker;
26
27import static com.android.internal.util.Preconditions.*;
28
29/**
30 * Proxy out invocations to the camera2 API callbacks into a {@link Dispatchable}.
31 *
32 * <p>Since abstract classes do not support Java's dynamic {@code Proxy}, we have to
33 * to use our own proxy mechanism.</p>
34 */
35public class CallbackProxies {
36
37    // TODO: replace with codegen
38
39    public static class DeviceStateCallbackProxy extends CameraDeviceImpl.StateCallbackKK {
40        private final MethodNameInvoker<CameraDeviceImpl.StateCallbackKK> mProxy;
41
42        public DeviceStateCallbackProxy(
43                Dispatchable<CameraDeviceImpl.StateCallbackKK> dispatchTarget) {
44            dispatchTarget = checkNotNull(dispatchTarget, "dispatchTarget must not be null");
45            mProxy = new MethodNameInvoker<>(dispatchTarget, CameraDeviceImpl.StateCallbackKK.class);
46        }
47
48        @Override
49        public void onOpened(CameraDevice camera) {
50            mProxy.invoke("onOpened", camera);
51        }
52
53        @Override
54        public void onDisconnected(CameraDevice camera) {
55            mProxy.invoke("onDisconnected", camera);
56        }
57
58        @Override
59        public void onError(CameraDevice camera, int error) {
60            mProxy.invoke("onError", camera, error);
61        }
62
63        @Override
64        public void onUnconfigured(CameraDevice camera) {
65            mProxy.invoke("onUnconfigured", camera);
66        }
67
68        @Override
69        public void onActive(CameraDevice camera) {
70            mProxy.invoke("onActive", camera);
71        }
72
73        @Override
74        public void onBusy(CameraDevice camera) {
75            mProxy.invoke("onBusy", camera);
76        }
77
78        @Override
79        public void onClosed(CameraDevice camera) {
80            mProxy.invoke("onClosed", camera);
81        }
82
83        @Override
84        public void onIdle(CameraDevice camera) {
85            mProxy.invoke("onIdle", camera);
86        }
87    }
88
89    @SuppressWarnings("deprecation")
90    public static class DeviceCaptureCallbackProxy extends CameraDeviceImpl.CaptureCallback {
91        private final MethodNameInvoker<CameraDeviceImpl.CaptureCallback> mProxy;
92
93        public DeviceCaptureCallbackProxy(
94                Dispatchable<CameraDeviceImpl.CaptureCallback> dispatchTarget) {
95            dispatchTarget = checkNotNull(dispatchTarget, "dispatchTarget must not be null");
96            mProxy = new MethodNameInvoker<>(dispatchTarget, CameraDeviceImpl.CaptureCallback.class);
97        }
98
99        @Override
100        public void onCaptureStarted(CameraDevice camera,
101                CaptureRequest request, long timestamp, long frameNumber) {
102            mProxy.invoke("onCaptureStarted", camera, request, timestamp, frameNumber);
103        }
104
105        @Override
106        public void onCapturePartial(CameraDevice camera,
107                CaptureRequest request, CaptureResult result) {
108            mProxy.invoke("onCapturePartial", camera, request, result);
109        }
110
111        @Override
112        public void onCaptureProgressed(CameraDevice camera,
113                CaptureRequest request, CaptureResult partialResult) {
114            mProxy.invoke("onCaptureProgressed", camera, request, partialResult);
115        }
116
117        @Override
118        public void onCaptureCompleted(CameraDevice camera,
119                CaptureRequest request, TotalCaptureResult result) {
120            mProxy.invoke("onCaptureCompleted", camera, request, result);
121        }
122
123        @Override
124        public void onCaptureFailed(CameraDevice camera,
125                CaptureRequest request, CaptureFailure failure) {
126            mProxy.invoke("onCaptureFailed", camera, request, failure);
127        }
128
129        @Override
130        public void onCaptureSequenceCompleted(CameraDevice camera,
131                int sequenceId, long frameNumber) {
132            mProxy.invoke("onCaptureSequenceCompleted", camera, sequenceId, frameNumber);
133        }
134
135        @Override
136        public void onCaptureSequenceAborted(CameraDevice camera,
137                int sequenceId) {
138            mProxy.invoke("onCaptureSequenceAborted", camera, sequenceId);
139        }
140    }
141
142    public static class SessionStateCallbackProxy
143            extends CameraCaptureSession.StateCallback {
144        private final MethodNameInvoker<CameraCaptureSession.StateCallback> mProxy;
145
146        public SessionStateCallbackProxy(
147                Dispatchable<CameraCaptureSession.StateCallback> dispatchTarget) {
148            dispatchTarget = checkNotNull(dispatchTarget, "dispatchTarget must not be null");
149            mProxy = new MethodNameInvoker<>(dispatchTarget,
150                    CameraCaptureSession.StateCallback.class);
151        }
152
153        @Override
154        public void onConfigured(CameraCaptureSession session) {
155            mProxy.invoke("onConfigured", session);
156        }
157
158
159        @Override
160        public void onConfigureFailed(CameraCaptureSession session) {
161            mProxy.invoke("onConfigureFailed", session);
162        }
163
164        @Override
165        public void onReady(CameraCaptureSession session) {
166            mProxy.invoke("onReady", session);
167        }
168
169        @Override
170        public void onActive(CameraCaptureSession session) {
171            mProxy.invoke("onActive", session);
172        }
173
174        @Override
175        public void onClosed(CameraCaptureSession session) {
176            mProxy.invoke("onClosed", session);
177        }
178    }
179
180    private CallbackProxies() {
181        throw new AssertionError();
182    }
183}
184