C++语法学习笔记
考虑到要做Android系统层的开发,所以还是需要学习一下C++的语法
我先去找一个C++的代码段来看看
CameraBase.h
#ifndef ANDROID_HARDWARE_CAMERA_BASE_H
#define ANDROID_HARDWARE_CAMERA_BASE_H
#include <android/hardware/ICameraServiceListener.h>
#include <utils/Mutex.h>
#include <binder/BinderService.h>
struct camera_frame_metadata;
namespace android {
namespace hardware {
class ICameraService;
class ICameraServiceListener;
enum {
/** The facing of the camera is opposite to that of the screen. */
CAMERA_FACING_BACK = 0,
/** The facing of the camera is the same as that of the screen. */
CAMERA_FACING_FRONT = 1,
};
struct CameraInfo : public android::Parcelable {
/**
* The direction that the camera faces to. It should be CAMERA_FACING_BACK
* or CAMERA_FACING_FRONT.
*/
int facing;
/**
* The orientation of the camera image. The value is the angle that the
* camera image needs to be rotated clockwise so it shows correctly on the
* display in its natural orientation. It should be 0, 90, 180, or 270.
*
* For example, suppose a device has a naturally tall screen. The
* back-facing camera sensor is mounted in landscape. You are looking at
* the screen. If the top side of the camera sensor is aligned with the
* right edge of the screen in natural orientation, the value should be
* 90. If the top side of a front-facing camera sensor is aligned with the
* right of the screen, the value should be 270.
*/
int orientation;
virtual status_t writeToParcel(android::Parcel* parcel) const;
virtual status_t readFromParcel(const android::Parcel* parcel);
};
/**
* Basic status information about a camera device - its name and its current
* state.
*/
struct CameraStatus : public android::Parcelable {
/**
* The name of the camera device
*/
String8 cameraId;
/**
* Its current status, one of the ICameraService::STATUS_* fields
*/
int32_t status;
virtual status_t writeToParcel(android::Parcel* parcel) const;
virtual status_t readFromParcel(const android::Parcel* parcel);
CameraStatus(String8 id, int32_t s) : cameraId(id), status(s) {}
CameraStatus() : status(ICameraServiceListener::STATUS_PRESENT) {}
};
} // namespace hardware
using hardware::CameraInfo;
template <typename TCam>
struct CameraTraits {
};
template <typename TCam, typename TCamTraits = CameraTraits<TCam> >
class CameraBase : public IBinder::DeathRecipient
{
public:
typedef typename TCamTraits::TCamListener TCamListener;
typedef typename TCamTraits::TCamUser TCamUser;
typedef typename TCamTraits::TCamCallbacks TCamCallbacks;
typedef typename TCamTraits::TCamConnectService TCamConnectService;
static sp<TCam> connect(int cameraId,
const String16& clientPackageName,
int clientUid, int clientPid);
virtual void disconnect();
void setListener(const sp<TCamListener>& listener);
static int getNumberOfCameras();
static status_t getCameraInfo(int cameraId,
/*out*/
struct hardware::CameraInfo* cameraInfo);
sp<TCamUser> remote();
// Status is set to 'UNKNOWN_ERROR' after successful (re)connection
status_t getStatus();
protected:
CameraBase(int cameraId);
virtual ~CameraBase();
// TCamCallbacks implementation
virtual void notifyCallback(int32_t msgType, int32_t ext,
int32_t ext2);
// Common instance variables
Mutex mLock;
virtual void binderDied(const wp<IBinder>& who);
// helper function to obtain camera service handle
static const sp<::android::hardware::ICameraService> getCameraService();
sp<TCamUser> mCamera;
status_t mStatus;
sp<TCamListener> mListener;
const int mCameraId;
typedef CameraBase<TCam> CameraBaseT;
};
}; // namespace android
CameraBase.cpp
//#define LOG_NDEBUG 0
#define LOG_TAG "CameraBase"
#include <utils/Log.h>
#include <utils/threads.h>
#include <utils/Mutex.h>
#include <cutils/properties.h>
#include <android/hardware/ICameraService.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/IMemory.h>
#include <camera/CameraBase.h>
// needed to instantiate
#include <camera/Camera.h>
#include <system/camera_metadata.h>
namespace android {
namespace hardware {
status_t CameraInfo::writeToParcel(android::Parcel* parcel) const {
status_t res;
res = parcel->writeInt32(facing);
if (res != OK) return res;
res = parcel->writeInt32(orientation);
return res;
}
status_t CameraInfo::readFromParcel(const android::Parcel* parcel) {
status_t res;
res = parcel->readInt32(&facing);
if (res != OK) return res;
res = parcel->readInt32(&orientation);
return res;
}
status_t CameraStatus::writeToParcel(android::Parcel* parcel) const {
auto res = parcel->writeString16(String16(cameraId));
if (res != OK) return res;
res = parcel->writeInt32(status);
return res;
}
status_t CameraStatus::readFromParcel(const android::Parcel* parcel) {
String16 tempCameraId;
auto res = parcel->readString16(&tempCameraId);
if (res != OK) return res;
cameraId = String8(tempCameraId);
res = parcel->readInt32(&status);
return res;
}
} // namespace hardware
namespace {
sp<::android::hardware::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<::android::hardware::ICameraService> CameraBase<TCam, TCamTraits>::getCameraService()
{
Mutex::Autolock _l(gLock);
if (gCameraService.get() == 0) {
char value[PROPERTY_VALUE_MAX];
property_get("config.disable_cameraservice", value, "0");
if (strncmp(value, "0", 2) != 0 && strncasecmp(value, "false", 6) != 0) {
return gCameraService;
}
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<::android::hardware::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, int clientPid)
{
ALOGV("%s: connect", __FUNCTION__);
sp<TCam> c = new TCam(cameraId);
sp<TCamCallbacks> cl = c;
const sp<::android::hardware::ICameraService> cs = getCameraService();
binder::Status ret;
if (cs != nullptr) {
TCamConnectService fnConnectService = TCamTraits::fnConnectService;
ret = (cs.get()->*fnConnectService)(cl, cameraId, clientPackageName, clientUid,
clientPid, /*out*/ &c->mCamera);
}
if (ret.isOk() && c->mCamera != nullptr) {
IInterface::asBinder(c->mCamera)->linkToDeath(c);
c->mStatus = NO_ERROR;
} else {
ALOGW("An error occurred while connecting to camera %d: %s", cameraId,
(cs == nullptr) ? "Service not available" : ret.toString8().string());
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<::android::hardware::ICameraService> cs = getCameraService();
if (!cs.get()) {
// as required by the public Java APIs
return 0;
}
int32_t count;
binder::Status res = cs->getNumberOfCameras(
::android::hardware::ICameraService::CAMERA_TYPE_BACKWARD_COMPATIBLE,
&count);
if (!res.isOk()) {
ALOGE("Error reading number of cameras: %s",
res.toString8().string());
count = 1;
}
return count;
}
// 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 hardware::CameraInfo* cameraInfo) {
const sp<::android::hardware::ICameraService> cs = getCameraService();
if (cs == 0) return UNKNOWN_ERROR;
binder::Status res = cs->getCameraInfo(cameraId, cameraInfo);
return res.isOk() ? OK : res.serviceSpecificErrorCode();
}
template class CameraBase<Camera>;
} // namespace android
就照着这个C++文件来一句句学习
先看这句
#define LOG_TAG "CameraBase"
编译器在处理这个代码之前会对LOG_TAG 进行处理替换为"CameraBase"。
#include <utils/Log.h>
#include <> 的查找位置是标准库头文件所在目录, #include “” 的查找位置是当前源文件所在目录
namespace android
status_t CameraInfo::writeToParcel(android::Parcel* parcel) const {
status_t res;
res = parcel->writeInt32(facing);
if (res != OK) return res;
res = parcel->writeInt32(orientation);
return res;
}
作用域解析运算符(::)
表示定义某个域的函数或类型;
Test::Test()引用Test类的Test()构造函数;
表示调用全局的函数或类型;
::value引用全局变量;
例:
#include <iostream>
using namespace std;
int value = 1;
int main(int argc, char *argv[])
{
int value = 10;
cout<<::value<<endl;
cout<<value<<endl;
return 0;
}
c++ 函数前面和后面 使用const 的作用:
前面使用const 表示返回值为const
后面加 const表示函数不可以修改class的成员
例:
/*
* FunctionConst.h
*/
#ifndef FUNCTIONCONST_H_
#define FUNCTIONCONST_H_
class FunctionConst {
public:
int value;
FunctionConst();
virtual ~FunctionConst();
const int getValue();
int getValue2() const;
};
#endif /* FUNCTIONCONST_H_ */
/*
* FunctionConst.cpp
*/
#include "FunctionConst.h"
FunctionConst::FunctionConst():value(100) {
// TODO Auto-generated constructor stub
}
FunctionConst::~FunctionConst() {
// TODO Auto-generated destructor stub
}
const int FunctionConst::getValue(){
return value;//返回值是 const, 使用指针时很有用.
}
int FunctionConst::getValue2() const{
//此函数不能修改class FunctionConst的成员函数 value
value = 15;//错误的, 因为函数后面加 const
return value;
}
点运算符“.”应用于实际的对象,箭头运算符“->”与一个指针对象的指针一起使用
例:
class A
{
public:
int a = 0;
};
int main()
{
A b;
A *p = &b;
b.a; //类型的对象访问类的成员
p->a; //类型的指针访问类的成员
}
模板
template <typename TCam, typename TCamTraits>
status_t CameraBase<TCam, TCamTraits>::getCameraInfo(int cameraId,
struct hardware::CameraInfo* cameraInfo) {
const sp<::android::hardware::ICameraService> cs = getCameraService();
if (cs == 0) return UNKNOWN_ERROR;
binder::Status res = cs->getCameraInfo(cameraId, cameraInfo);
return res.isOk() ? OK : res.serviceSpecificErrorCode();
}
C++的模板有点类似java的泛型看这个博客