221 lines
6.7 KiB
C++
221 lines
6.7 KiB
C++
/*
|
|
**
|
|
** Copyright (C) 2013, The Android Open Source Project
|
|
**
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
**
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
**
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
*/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "CameraBase"
|
|
#include <utils/Log.h>
|
|
#include <utils/threads.h>
|
|
#include <utils/Mutex.h>
|
|
|
|
#include <binder/IPCThreadState.h>
|
|
#include <binder/IServiceManager.h>
|
|
#include <binder/IMemory.h>
|
|
|
|
#include <camera/CameraBase.h>
|
|
#include <camera/ICameraService.h>
|
|
|
|
// needed to instantiate
|
|
#include <camera/Camera.h>
|
|
|
|
#include <system/camera_metadata.h>
|
|
|
|
namespace android {
|
|
|
|
namespace {
|
|
sp<ICameraService> gCameraService;
|
|
const int kCameraServicePollDelay = 500000; // 0.5s
|
|
const char* kCameraServiceName = "media.camera";
|
|
|
|
Mutex gLock;
|
|
|
|
class DeathNotifier : public IBinder::DeathRecipient
|
|
{
|
|
public:
|
|
DeathNotifier() {
|
|
}
|
|
|
|
virtual void binderDied(const wp<IBinder>& /*who*/) {
|
|
ALOGV("binderDied");
|
|
Mutex::Autolock _l(gLock);
|
|
gCameraService.clear();
|
|
ALOGW("Camera service died!");
|
|
}
|
|
};
|
|
|
|
sp<DeathNotifier> gDeathNotifier;
|
|
}; // namespace anonymous
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// CameraBase definition
|
|
///////////////////////////////////////////////////////////
|
|
|
|
// establish binder interface to camera service
|
|
template <typename TCam, typename TCamTraits>
|
|
const sp<ICameraService>& CameraBase<TCam, TCamTraits>::getCameraService()
|
|
{
|
|
Mutex::Autolock _l(gLock);
|
|
if (gCameraService.get() == 0) {
|
|
sp<IServiceManager> sm = defaultServiceManager();
|
|
sp<IBinder> binder;
|
|
do {
|
|
binder = sm->getService(String16(kCameraServiceName));
|
|
if (binder != 0) {
|
|
break;
|
|
}
|
|
ALOGW("CameraService not published, waiting...");
|
|
usleep(kCameraServicePollDelay);
|
|
} while(true);
|
|
if (gDeathNotifier == NULL) {
|
|
gDeathNotifier = new DeathNotifier();
|
|
}
|
|
binder->linkToDeath(gDeathNotifier);
|
|
gCameraService = interface_cast<ICameraService>(binder);
|
|
}
|
|
ALOGE_IF(gCameraService == 0, "no CameraService!?");
|
|
return gCameraService;
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
sp<TCam> CameraBase<TCam, TCamTraits>::connect(int cameraId,
|
|
const String16& clientPackageName,
|
|
int clientUid)
|
|
{
|
|
ALOGV("%s: connect", __FUNCTION__);
|
|
sp<TCam> c = new TCam(cameraId);
|
|
sp<TCamCallbacks> cl = c;
|
|
status_t status = NO_ERROR;
|
|
const sp<ICameraService>& cs = getCameraService();
|
|
|
|
if (cs != 0) {
|
|
TCamConnectService fnConnectService = TCamTraits::fnConnectService;
|
|
status = (cs.get()->*fnConnectService)(cl, cameraId, clientPackageName, clientUid,
|
|
/*out*/ c->mCamera);
|
|
}
|
|
if (status == OK && c->mCamera != 0) {
|
|
IInterface::asBinder(c->mCamera)->linkToDeath(c);
|
|
c->mStatus = NO_ERROR;
|
|
} else {
|
|
ALOGW("An error occurred while connecting to camera: %d", cameraId);
|
|
c.clear();
|
|
}
|
|
return c;
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
void CameraBase<TCam, TCamTraits>::disconnect()
|
|
{
|
|
ALOGV("%s: disconnect", __FUNCTION__);
|
|
if (mCamera != 0) {
|
|
mCamera->disconnect();
|
|
IInterface::asBinder(mCamera)->unlinkToDeath(this);
|
|
mCamera = 0;
|
|
}
|
|
ALOGV("%s: disconnect (done)", __FUNCTION__);
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
CameraBase<TCam, TCamTraits>::CameraBase(int cameraId) :
|
|
mStatus(UNKNOWN_ERROR),
|
|
mCameraId(cameraId)
|
|
{
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
CameraBase<TCam, TCamTraits>::~CameraBase()
|
|
{
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
sp<typename TCamTraits::TCamUser> CameraBase<TCam, TCamTraits>::remote()
|
|
{
|
|
return mCamera;
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
status_t CameraBase<TCam, TCamTraits>::getStatus()
|
|
{
|
|
return mStatus;
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
void CameraBase<TCam, TCamTraits>::binderDied(const wp<IBinder>& /*who*/) {
|
|
ALOGW("mediaserver's remote binder Camera object died");
|
|
notifyCallback(CAMERA_MSG_ERROR, CAMERA_ERROR_SERVER_DIED, /*ext2*/0);
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
void CameraBase<TCam, TCamTraits>::setListener(const sp<TCamListener>& listener)
|
|
{
|
|
Mutex::Autolock _l(mLock);
|
|
mListener = listener;
|
|
}
|
|
|
|
// callback from camera service
|
|
template <typename TCam, typename TCamTraits>
|
|
void CameraBase<TCam, TCamTraits>::notifyCallback(int32_t msgType,
|
|
int32_t ext1,
|
|
int32_t ext2)
|
|
{
|
|
sp<TCamListener> listener;
|
|
{
|
|
Mutex::Autolock _l(mLock);
|
|
listener = mListener;
|
|
}
|
|
if (listener != NULL) {
|
|
listener->notify(msgType, ext1, ext2);
|
|
}
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
int CameraBase<TCam, TCamTraits>::getNumberOfCameras() {
|
|
const sp<ICameraService> cs = getCameraService();
|
|
|
|
if (!cs.get()) {
|
|
// as required by the public Java APIs
|
|
return 0;
|
|
}
|
|
return cs->getNumberOfCameras();
|
|
}
|
|
|
|
// this can be in BaseCamera but it should be an instance method
|
|
template <typename TCam, typename TCamTraits>
|
|
status_t CameraBase<TCam, TCamTraits>::getCameraInfo(int cameraId,
|
|
struct CameraInfo* cameraInfo) {
|
|
const sp<ICameraService>& cs = getCameraService();
|
|
if (cs == 0) return UNKNOWN_ERROR;
|
|
return cs->getCameraInfo(cameraId, cameraInfo);
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
status_t CameraBase<TCam, TCamTraits>::addServiceListener(
|
|
const sp<ICameraServiceListener>& listener) {
|
|
const sp<ICameraService>& cs = getCameraService();
|
|
if (cs == 0) return UNKNOWN_ERROR;
|
|
return cs->addListener(listener);
|
|
}
|
|
|
|
template <typename TCam, typename TCamTraits>
|
|
status_t CameraBase<TCam, TCamTraits>::removeServiceListener(
|
|
const sp<ICameraServiceListener>& listener) {
|
|
const sp<ICameraService>& cs = getCameraService();
|
|
if (cs == 0) return UNKNOWN_ERROR;
|
|
return cs->removeListener(listener);
|
|
}
|
|
|
|
template class CameraBase<Camera>;
|
|
|
|
} // namespace android
|