1 /*
2 **
3 ** Copyright (C) 2013, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 ** http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17
18 //#define LOG_NDEBUG 0
19 #define LOG_TAG "CameraBase"
20 #include <utils/Log.h>
21 #include <utils/threads.h>
22 #include <utils/Mutex.h>
23 #include <cutils/properties.h>
24
25 #include <android/hardware/ICameraService.h>
26
27 #include <binder/IPCThreadState.h>
28 #include <binder/IServiceManager.h>
29 #include <binder/IMemory.h>
30
31 #include <camera/CameraBase.h>
32 #include <camera/CameraUtils.h>
33
34 // needed to instantiate
35 #include <camera/Camera.h>
36
37 #include <system/camera_metadata.h>
38
39 namespace android {
40
41 namespace hardware {
42
writeToParcel(android::Parcel * parcel) const43 status_t CameraInfo::writeToParcel(android::Parcel* parcel) const {
44 status_t res;
45 res = parcel->writeInt32(facing);
46 if (res != OK) return res;
47 res = parcel->writeInt32(orientation);
48 return res;
49 }
50
readFromParcel(const android::Parcel * parcel)51 status_t CameraInfo::readFromParcel(const android::Parcel* parcel) {
52 status_t res;
53 res = parcel->readInt32(&facing);
54 if (res != OK) return res;
55 res = parcel->readInt32(&orientation);
56 return res;
57 }
58
writeToParcel(android::Parcel * parcel) const59 status_t CameraStatus::writeToParcel(android::Parcel* parcel) const {
60 auto res = parcel->writeString16(String16(cameraId));
61 if (res != OK) return res;
62
63 res = parcel->writeInt32(status);
64 if (res != OK) return res;
65
66 std::vector<String16> unavailablePhysicalIds16;
67 for (auto& id8 : unavailablePhysicalIds) {
68 unavailablePhysicalIds16.push_back(String16(id8));
69 }
70 res = parcel->writeString16Vector(unavailablePhysicalIds16);
71 return res;
72 }
73
readFromParcel(const android::Parcel * parcel)74 status_t CameraStatus::readFromParcel(const android::Parcel* parcel) {
75 String16 tempCameraId;
76 auto res = parcel->readString16(&tempCameraId);
77 if (res != OK) return res;
78 cameraId = String8(tempCameraId);
79
80 res = parcel->readInt32(&status);
81 if (res != OK) return res;
82
83 std::vector<String16> unavailablePhysicalIds16;
84 res = parcel->readString16Vector(&unavailablePhysicalIds16);
85 if (res != OK) return res;
86 for (auto& id16 : unavailablePhysicalIds16) {
87 unavailablePhysicalIds.push_back(String8(id16));
88 }
89 return res;
90 }
91
92 } // namespace hardware
93
94 namespace {
95 sp<::android::hardware::ICameraService> gCameraService;
96 const int kCameraServicePollDelay = 500000; // 0.5s
97 const char* kCameraServiceName = "media.camera";
98
99 Mutex gLock;
100
101 class DeathNotifier : public IBinder::DeathRecipient
102 {
103 public:
DeathNotifier()104 DeathNotifier() {
105 }
106
binderDied(const wp<IBinder> &)107 virtual void binderDied(const wp<IBinder>& /*who*/) {
108 ALOGV("binderDied");
109 Mutex::Autolock _l(gLock);
110 gCameraService.clear();
111 ALOGW("Camera service died!");
112 }
113 };
114
115 sp<DeathNotifier> gDeathNotifier;
116 }; // namespace anonymous
117
118 ///////////////////////////////////////////////////////////
119 // CameraBase definition
120 ///////////////////////////////////////////////////////////
121
122 // establish binder interface to camera service
123 template <typename TCam, typename TCamTraits>
getCameraService()124 const sp<::android::hardware::ICameraService> CameraBase<TCam, TCamTraits>::getCameraService()
125 {
126 Mutex::Autolock _l(gLock);
127 if (gCameraService.get() == 0) {
128 if (CameraUtils::isCameraServiceDisabled()) {
129 return gCameraService;
130 }
131
132 sp<IServiceManager> sm = defaultServiceManager();
133 sp<IBinder> binder;
134 do {
135 binder = sm->getService(String16(kCameraServiceName));
136 if (binder != 0) {
137 break;
138 }
139 ALOGW("CameraService not published, waiting...");
140 usleep(kCameraServicePollDelay);
141 } while(true);
142 if (gDeathNotifier == NULL) {
143 gDeathNotifier = new DeathNotifier();
144 }
145 binder->linkToDeath(gDeathNotifier);
146 gCameraService = interface_cast<::android::hardware::ICameraService>(binder);
147 }
148 ALOGE_IF(gCameraService == 0, "no CameraService!?");
149 return gCameraService;
150 }
151
152 template <typename TCam, typename TCamTraits>
connect(int cameraId,const String16 & clientPackageName,int clientUid,int clientPid,int targetSdkVersion)153 sp<TCam> CameraBase<TCam, TCamTraits>::connect(int cameraId,
154 const String16& clientPackageName,
155 int clientUid, int clientPid, int targetSdkVersion)
156 {
157 ALOGV("%s: connect", __FUNCTION__);
158 sp<TCam> c = new TCam(cameraId);
159 sp<TCamCallbacks> cl = c;
160 const sp<::android::hardware::ICameraService> cs = getCameraService();
161
162 binder::Status ret;
163 if (cs != nullptr) {
164 TCamConnectService fnConnectService = TCamTraits::fnConnectService;
165 ret = (cs.get()->*fnConnectService)(cl, cameraId, clientPackageName, clientUid,
166 clientPid, targetSdkVersion, /*out*/ &c->mCamera);
167 }
168 if (ret.isOk() && c->mCamera != nullptr) {
169 IInterface::asBinder(c->mCamera)->linkToDeath(c);
170 c->mStatus = NO_ERROR;
171 } else {
172 ALOGW("An error occurred while connecting to camera %d: %s", cameraId,
173 (cs == nullptr) ? "Service not available" : ret.toString8().string());
174 c.clear();
175 }
176 return c;
177 }
178
179 template <typename TCam, typename TCamTraits>
disconnect()180 void CameraBase<TCam, TCamTraits>::disconnect()
181 {
182 ALOGV("%s: disconnect", __FUNCTION__);
183 if (mCamera != 0) {
184 mCamera->disconnect();
185 IInterface::asBinder(mCamera)->unlinkToDeath(this);
186 mCamera = 0;
187 }
188 ALOGV("%s: disconnect (done)", __FUNCTION__);
189 }
190
191 template <typename TCam, typename TCamTraits>
CameraBase(int cameraId)192 CameraBase<TCam, TCamTraits>::CameraBase(int cameraId) :
193 mStatus(UNKNOWN_ERROR),
194 mCameraId(cameraId)
195 {
196 }
197
198 template <typename TCam, typename TCamTraits>
~CameraBase()199 CameraBase<TCam, TCamTraits>::~CameraBase()
200 {
201 }
202
203 template <typename TCam, typename TCamTraits>
remote()204 sp<typename TCamTraits::TCamUser> CameraBase<TCam, TCamTraits>::remote()
205 {
206 return mCamera;
207 }
208
209 template <typename TCam, typename TCamTraits>
getStatus()210 status_t CameraBase<TCam, TCamTraits>::getStatus()
211 {
212 return mStatus;
213 }
214
215 template <typename TCam, typename TCamTraits>
binderDied(const wp<IBinder> &)216 void CameraBase<TCam, TCamTraits>::binderDied(const wp<IBinder>& /*who*/) {
217 ALOGW("mediaserver's remote binder Camera object died");
218 notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_SERVER_DIED, /*ext2*/0);
219 }
220
221 template <typename TCam, typename TCamTraits>
setListener(const sp<TCamListener> & listener)222 void CameraBase<TCam, TCamTraits>::setListener(const sp<TCamListener>& listener)
223 {
224 Mutex::Autolock _l(mLock);
225 mListener = listener;
226 }
227
228 // callback from camera service
229 template <typename TCam, typename TCamTraits>
notifyCallback(int32_t msgType,int32_t ext1,int32_t ext2)230 void CameraBase<TCam, TCamTraits>::notifyCallback(int32_t msgType,
231 int32_t ext1,
232 int32_t ext2)
233 {
234 sp<TCamListener> listener;
235 {
236 Mutex::Autolock _l(mLock);
237 listener = mListener;
238 }
239 if (listener != NULL) {
240 listener->notify(msgType, ext1, ext2);
241 }
242 }
243
244 template <typename TCam, typename TCamTraits>
getNumberOfCameras()245 int CameraBase<TCam, TCamTraits>::getNumberOfCameras() {
246 const sp<::android::hardware::ICameraService> cs = getCameraService();
247
248 if (!cs.get()) {
249 // as required by the public Java APIs
250 return 0;
251 }
252 int32_t count;
253 binder::Status res = cs->getNumberOfCameras(
254 ::android::hardware::ICameraService::CAMERA_TYPE_BACKWARD_COMPATIBLE,
255 &count);
256 if (!res.isOk()) {
257 ALOGE("Error reading number of cameras: %s",
258 res.toString8().string());
259 count = 0;
260 }
261 return count;
262 }
263
264 // this can be in BaseCamera but it should be an instance method
265 template <typename TCam, typename TCamTraits>
getCameraInfo(int cameraId,struct hardware::CameraInfo * cameraInfo)266 status_t CameraBase<TCam, TCamTraits>::getCameraInfo(int cameraId,
267 struct hardware::CameraInfo* cameraInfo) {
268 const sp<::android::hardware::ICameraService> cs = getCameraService();
269 if (cs == 0) return UNKNOWN_ERROR;
270 binder::Status res = cs->getCameraInfo(cameraId, cameraInfo);
271 return res.isOk() ? OK : res.serviceSpecificErrorCode();
272 }
273
274 template class CameraBase<Camera>;
275
276 } // namespace android
277