1 /*
2 * Copyright (C) 2015 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 //#define LOG_NDEBUG 0
18 #define LOG_TAG "NdkCameraManager"
19 #define ATRACE_TAG ATRACE_TAG_CAMERA
20
21 #include <utils/Log.h>
22 #include <utils/Trace.h>
23
24 #include <camera/NdkCameraManager.h>
25
26 #ifdef __ANDROID_VNDK__
27 #include "ndk_vendor/impl/ACameraManager.h"
28 #else
29 #include "impl/ACameraManager.h"
30 #include <com_android_internal_camera_flags.h>
31 namespace flags = com::android::internal::camera::flags;
32 #endif
33 #include "impl/ACameraMetadata.h"
34
35 using namespace android::acam;
36
37 EXPORT
ACameraManager_create()38 ACameraManager* ACameraManager_create() {
39 ATRACE_CALL();
40 return new ACameraManager();
41 }
42
43 EXPORT
ACameraManager_delete(ACameraManager * manager)44 void ACameraManager_delete(ACameraManager* manager) {
45 ATRACE_CALL();
46 if (manager != nullptr) {
47 delete manager;
48 }
49 }
50
51 EXPORT
ACameraManager_getCameraIdList(ACameraManager * manager,ACameraIdList ** cameraIdList)52 camera_status_t ACameraManager_getCameraIdList(
53 ACameraManager* manager, ACameraIdList** cameraIdList) {
54 ATRACE_CALL();
55 if (manager == nullptr || cameraIdList == nullptr) {
56 ALOGE("%s: invalid argument! manager %p, cameraIdList %p",
57 __FUNCTION__, manager, cameraIdList);
58 return ACAMERA_ERROR_INVALID_PARAMETER;
59 }
60 return manager->getCameraIdList(cameraIdList);
61 }
62
63 EXPORT
ACameraManager_deleteCameraIdList(ACameraIdList * cameraIdList)64 void ACameraManager_deleteCameraIdList(ACameraIdList* cameraIdList) {
65 ATRACE_CALL();
66 if (cameraIdList != nullptr) {
67 ACameraManager::deleteCameraIdList(cameraIdList);
68 }
69 }
70
71 EXPORT
ACameraManager_registerAvailabilityCallback(ACameraManager * manager,const ACameraManager_AvailabilityCallbacks * callback)72 camera_status_t ACameraManager_registerAvailabilityCallback(
73 ACameraManager* manager, const ACameraManager_AvailabilityCallbacks* callback) {
74 ATRACE_CALL();
75 if (callback == nullptr) {
76 ALOGE("%s: invalid argument! callback is null!", __FUNCTION__);
77 return ACAMERA_ERROR_INVALID_PARAMETER;
78 }
79 if (callback->onCameraAvailable == nullptr || callback->onCameraUnavailable == nullptr) {
80 ALOGE("%s: invalid argument! callback %p, "
81 "onCameraAvailable %p, onCameraUnavailable %p",
82 __FUNCTION__, callback,
83 callback->onCameraAvailable, callback->onCameraUnavailable);
84 return ACAMERA_ERROR_INVALID_PARAMETER;
85 }
86 manager->registerAvailabilityCallback(callback);
87 return ACAMERA_OK;
88 }
89
90 EXPORT
ACameraManager_unregisterAvailabilityCallback(ACameraManager * manager,const ACameraManager_AvailabilityCallbacks * callback)91 camera_status_t ACameraManager_unregisterAvailabilityCallback(
92 ACameraManager* manager, const ACameraManager_AvailabilityCallbacks* callback) {
93 ATRACE_CALL();
94 if (callback == nullptr) {
95 ALOGE("%s: invalid argument! callback is null!", __FUNCTION__);
96 return ACAMERA_ERROR_INVALID_PARAMETER;
97 }
98 if (callback->onCameraAvailable == nullptr || callback->onCameraUnavailable == nullptr) {
99 ALOGE("%s: invalid argument! callback %p, "
100 "onCameraAvailable %p, onCameraUnavailable %p",
101 __FUNCTION__, callback,
102 callback->onCameraAvailable, callback->onCameraUnavailable);
103 return ACAMERA_ERROR_INVALID_PARAMETER;
104 }
105 manager->unregisterAvailabilityCallback(callback);
106 return ACAMERA_OK;
107 }
108
109 EXPORT
ACameraManager_registerExtendedAvailabilityCallback(ACameraManager * manager,const ACameraManager_ExtendedAvailabilityCallbacks * callback)110 camera_status_t ACameraManager_registerExtendedAvailabilityCallback(
111 ACameraManager* manager, const ACameraManager_ExtendedAvailabilityCallbacks* callback) {
112 ATRACE_CALL();
113 if (callback == nullptr) {
114 ALOGE("%s: invalid argument! callback is null!", __FUNCTION__);
115 return ACAMERA_ERROR_INVALID_PARAMETER;
116 }
117 if ((callback->availabilityCallbacks.onCameraAvailable == nullptr) ||
118 (callback->availabilityCallbacks.onCameraUnavailable == nullptr) ||
119 (callback->onCameraAccessPrioritiesChanged == nullptr)) {
120 ALOGE("%s: invalid argument! callback %p, "
121 "onCameraAvailable %p, onCameraUnavailable %p onCameraAccessPrioritiesChanged %p",
122 __FUNCTION__, callback,
123 callback->availabilityCallbacks.onCameraAvailable,
124 callback->availabilityCallbacks.onCameraUnavailable,
125 callback->onCameraAccessPrioritiesChanged);
126 return ACAMERA_ERROR_INVALID_PARAMETER;
127 }
128 auto reservedEntriesCount = sizeof(callback->reserved) / sizeof(callback->reserved[0]);
129 for (size_t i = 0; i < reservedEntriesCount; i++) {
130 if (callback->reserved[i] != nullptr) {
131 ALOGE("%s: invalid argument! callback reserved entries must be set to NULL",
132 __FUNCTION__);
133 return ACAMERA_ERROR_INVALID_PARAMETER;
134 }
135 }
136 manager->registerExtendedAvailabilityCallback(callback);
137 return ACAMERA_OK;
138 }
139
140 EXPORT
ACameraManager_unregisterExtendedAvailabilityCallback(ACameraManager * manager,const ACameraManager_ExtendedAvailabilityCallbacks * callback)141 camera_status_t ACameraManager_unregisterExtendedAvailabilityCallback(
142 ACameraManager* manager, const ACameraManager_ExtendedAvailabilityCallbacks* callback) {
143 ATRACE_CALL();
144 if (callback == nullptr) {
145 ALOGE("%s: invalid argument! callback is null!", __FUNCTION__);
146 return ACAMERA_ERROR_INVALID_PARAMETER;
147 }
148 if ((callback->availabilityCallbacks.onCameraAvailable == nullptr) ||
149 (callback->availabilityCallbacks.onCameraUnavailable == nullptr) ||
150 (callback->onCameraAccessPrioritiesChanged == nullptr)) {
151 ALOGE("%s: invalid argument! callback %p, "
152 "onCameraAvailable %p, onCameraUnavailable %p onCameraAccessPrioritiesChanged %p",
153 __FUNCTION__, callback,
154 callback->availabilityCallbacks.onCameraAvailable,
155 callback->availabilityCallbacks.onCameraUnavailable,
156 callback->onCameraAccessPrioritiesChanged);
157 return ACAMERA_ERROR_INVALID_PARAMETER;
158 }
159 manager->unregisterExtendedAvailabilityCallback(callback);
160 return ACAMERA_OK;
161 }
162
163 EXPORT
ACameraManager_isCameraDeviceSharingSupported(ACameraManager * mgr,const char * cameraId,bool * isSharingSupported)164 camera_status_t ACameraManager_isCameraDeviceSharingSupported(ACameraManager *mgr,
165 const char *cameraId, bool *isSharingSupported) {
166 ATRACE_CALL();
167 #ifndef __ANDROID_VNDK__
168 if (!flags::camera_multi_client()) {
169 return ACAMERA_ERROR_UNSUPPORTED_OPERATION;
170 }
171 #endif
172 if (mgr == nullptr || cameraId == nullptr || isSharingSupported == nullptr) {
173 ALOGE("%s: invalid argument! mgr %p cameraId %p isSharingSupported %p",
174 __FUNCTION__, mgr, cameraId, isSharingSupported);
175 return ACAMERA_ERROR_INVALID_PARAMETER;
176 }
177 return mgr->isCameraDeviceSharingSupported(cameraId, isSharingSupported);
178 }
179
180 EXPORT
ACameraManager_getCameraCharacteristics(ACameraManager * mgr,const char * cameraId,ACameraMetadata ** chars)181 camera_status_t ACameraManager_getCameraCharacteristics(
182 ACameraManager* mgr, const char* cameraId, ACameraMetadata** chars){
183 ATRACE_CALL();
184 if (mgr == nullptr || cameraId == nullptr || chars == nullptr) {
185 ALOGE("%s: invalid argument! mgr %p cameraId %p chars %p",
186 __FUNCTION__, mgr, cameraId, chars);
187 return ACAMERA_ERROR_INVALID_PARAMETER;
188 }
189 sp<ACameraMetadata> spChars;
190 camera_status_t status = mgr->getCameraCharacteristics(cameraId, &spChars);
191 if (status != ACAMERA_OK) {
192 return status;
193 }
194 spChars->incStrong((void*) ACameraManager_getCameraCharacteristics);
195 *chars = spChars.get();
196 return ACAMERA_OK;
197 }
198
199 EXPORT
ACameraManager_openCamera(ACameraManager * mgr,const char * cameraId,ACameraDevice_StateCallbacks * callback,ACameraDevice ** device)200 camera_status_t ACameraManager_openCamera(
201 ACameraManager* mgr, const char* cameraId,
202 ACameraDevice_StateCallbacks* callback,
203 /*out*/ACameraDevice** device) {
204 ATRACE_CALL();
205 if (mgr == nullptr || cameraId == nullptr || callback == nullptr || device == nullptr) {
206 ALOGE("%s: invalid argument! mgr %p cameraId %p callback %p device %p",
207 __FUNCTION__, mgr, cameraId, callback, device);
208 return ACAMERA_ERROR_INVALID_PARAMETER;
209 }
210 bool primaryClient;
211 return mgr->openCamera(cameraId, /*sharedMode*/false, callback, device, &primaryClient);
212 }
213
214 EXPORT
ACameraManager_openSharedCamera(ACameraManager * mgr,const char * cameraId,ACameraDevice_StateCallbacks * callback,ACameraDevice ** device,bool * primaryClient)215 camera_status_t ACameraManager_openSharedCamera(
216 ACameraManager* mgr, const char* cameraId, ACameraDevice_StateCallbacks* callback,
217 /*out*/ACameraDevice** device, /*out*/bool* primaryClient) {
218 ATRACE_CALL();
219 #ifndef __ANDROID_VNDK__
220 if (!flags::camera_multi_client()) {
221 return ACAMERA_ERROR_UNSUPPORTED_OPERATION;
222 }
223 #endif
224 if (mgr == nullptr || cameraId == nullptr || callback == nullptr || device == nullptr ||
225 primaryClient == nullptr) {
226 ALOGE("%s: invalid argument! mgr %p cameraId %p callback %p device %p primary %p",
227 __FUNCTION__, mgr, cameraId, callback, device, primaryClient);
228 return ACAMERA_ERROR_INVALID_PARAMETER;
229 }
230 return mgr->openCamera(cameraId, /*sharedMode*/true, callback, device, primaryClient);
231 }
232
233 #ifdef __ANDROID_VNDK__
234 EXPORT
ACameraManager_getTagFromName(ACameraManager * mgr,const char * cameraId,const char * name,uint32_t * tag)235 camera_status_t ACameraManager_getTagFromName(ACameraManager *mgr, const char* cameraId,
236 const char *name, /*out*/uint32_t *tag) {
237 ATRACE_CALL();
238 if (mgr == nullptr || cameraId == nullptr || name == nullptr) {
239 ALOGE("%s: invalid argument! mgr %p cameraId %p name %p",
240 __FUNCTION__, mgr, cameraId, name);
241 return ACAMERA_ERROR_INVALID_PARAMETER;
242 }
243 return mgr->getTagFromName(cameraId, name, tag);
244 }
245 #endif
246