|
|
|
#include "TerminalDevice.h"
|
|
|
|
/*
|
|
|
|
* Copyright 2018 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_TAG "CameraTestHelpers"
|
|
|
|
|
|
|
|
#include "PhoneDevice.h"
|
|
|
|
#include "TermClient.h"
|
|
|
|
|
|
|
|
#include <android/log.h>
|
|
|
|
|
|
|
|
#define ALOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
|
|
|
|
#define ALOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
|
|
|
|
#define ALOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
|
|
|
|
|
|
|
|
extern bool GetJniEnv(JavaVM *vm, JNIEnv **env);
|
|
|
|
|
|
|
|
CPhoneDevice::CPhoneDevice(JavaVM* vm, jobject service)
|
|
|
|
{
|
|
|
|
m_vm = vm;
|
|
|
|
JNIEnv* env = NULL;
|
|
|
|
bool attached = GetJniEnv(m_vm, &env);
|
|
|
|
m_javaService = env->NewGlobalRef(service);
|
|
|
|
|
|
|
|
jclass classService = env->GetObjectClass(m_javaService);
|
|
|
|
mRegisterTimerMid = env->GetMethodID(classService, "registerTimer", "(JI)Z");
|
|
|
|
mUnregisterTimerMid = env->GetMethodID(classService, "unregisterTimer", "(J)Z");
|
|
|
|
|
|
|
|
env->DeleteLocalRef(classService);
|
|
|
|
|
|
|
|
if (attached)
|
|
|
|
{
|
|
|
|
vm->DetachCurrentThread();
|
|
|
|
}
|
|
|
|
|
|
|
|
m_timerUidFeed = time(NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
CPhoneDevice::~CPhoneDevice()
|
|
|
|
{
|
|
|
|
JNIEnv* env = NULL;
|
|
|
|
bool attached = GetJniEnv(m_vm, &env);
|
|
|
|
env->DeleteGlobalRef(m_javaService);
|
|
|
|
if (attached)
|
|
|
|
{
|
|
|
|
m_vm->DetachCurrentThread();
|
|
|
|
}
|
|
|
|
m_javaService = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CPhoneDevice::SetListener(IListener* listener)
|
|
|
|
{
|
|
|
|
m_listener = listener;
|
|
|
|
}
|
|
|
|
|
|
|
|
IDevice::timer_uid_t CPhoneDevice::registerTimer(unsigned int timerType, unsigned int timeout)
|
|
|
|
{
|
|
|
|
IDevice::timer_uid_t uid = m_timerUidFeed.fetch_add(1);
|
|
|
|
|
|
|
|
ALOGI("NDK RegTimer: uid=%lld Type=%u timeout=%u", uid, timerType, timeout);
|
|
|
|
|
|
|
|
JNIEnv* env = NULL;
|
|
|
|
jboolean ret = JNI_FALSE;
|
|
|
|
bool attached = GetJniEnv(m_vm, &env);
|
|
|
|
if (attached)
|
|
|
|
{
|
|
|
|
ret = env->CallBooleanMethod(m_javaService, mRegisterTimerMid, (jlong)uid, (jint)timeout);
|
|
|
|
m_vm->DetachCurrentThread();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == JNI_TRUE)
|
|
|
|
{
|
|
|
|
unsigned long val = timerType;
|
|
|
|
mTimers.insert(mTimers.end(), std::pair<IDevice::timer_uid_t, unsigned long>(uid, val));
|
|
|
|
return uid;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CPhoneDevice::unregisterTimer(IDevice::timer_uid_t uid)
|
|
|
|
{
|
|
|
|
JNIEnv* env = NULL;
|
|
|
|
jboolean ret = JNI_FALSE;
|
|
|
|
bool attached = GetJniEnv(m_vm, &env);
|
|
|
|
if (attached)
|
|
|
|
{
|
|
|
|
ret = env->CallBooleanMethod(m_javaService, mUnregisterTimerMid, (jlong)uid);
|
|
|
|
m_vm->DetachCurrentThread();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == JNI_TRUE)
|
|
|
|
{
|
|
|
|
mTimers.erase(uid);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CPhoneDevice::FireTimer(timer_uid_t uid)
|
|
|
|
{
|
|
|
|
std::map<IDevice::timer_uid_t, unsigned long>::iterator it = mTimers.find(uid);
|
|
|
|
if (it == mTimers.end())
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long timerType = it->second & 0xFFFFFFFF;
|
|
|
|
unsigned long times = (it->second & 0xFFFFFFFF00000000) >> 32;
|
|
|
|
times++;
|
|
|
|
|
|
|
|
if (timerType != 100)
|
|
|
|
{
|
|
|
|
int aa = 0;
|
|
|
|
}
|
|
|
|
it->second = timerType | (times << 32);
|
|
|
|
|
|
|
|
if (m_listener == NULL)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_listener->OnTimeout(uid, timerType, times);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
IDevice::timer_uid_t CPhoneDevice::RegisterHeartbeat(unsigned int timerType, unsigned int timeout)
|
|
|
|
{
|
|
|
|
return registerTimer(timerType, timeout);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CPhoneDevice::TakePhoto(const IDevice::PHOTO_INFO& photoInfo, const string& path)
|
|
|
|
{
|
|
|
|
LOGI("TAKE_PHOTO: CH=%u PR=%u\n", (unsigned int)photoInfo.channel, (unsigned int)photoInfo.preset);
|
|
|
|
mPhotoInfo = photoInfo;
|
|
|
|
mPath = path;
|
|
|
|
|
|
|
|
int cameraId = (int)photoInfo.channel - 1;
|
|
|
|
|
|
|
|
ACameraIdList *cameraIdList = NULL;
|
|
|
|
ACameraMetadata *cameraMetadata = NULL;
|
|
|
|
|
|
|
|
const char *selectedCameraId = NULL;
|
|
|
|
camera_status_t camera_status = ACAMERA_OK;
|
|
|
|
ACameraManager *cameraManager = ACameraManager_create();
|
|
|
|
|
|
|
|
camera_status = ACameraManager_getCameraIdList(cameraManager, &cameraIdList);
|
|
|
|
if (camera_status != ACAMERA_OK) {
|
|
|
|
LOGI("Failed to get camera id list (reason: %d)\n", camera_status);
|
|
|
|
TakePhotoCb(false, photoInfo, path, 0);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cameraIdList->numCameras < 1 ) {
|
|
|
|
LOGI("No camera device detected.\n");
|
|
|
|
TakePhotoCb(false, photoInfo, path, 0);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cameraIdList->numCameras <= cameraId ) {
|
|
|
|
LOGI("No required camera device %d detected.\n", cameraId);
|
|
|
|
TakePhotoCb(false, photoInfo, path, 0);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
selectedCameraId = cameraIdList->cameraIds[cameraId];
|
|
|
|
|
|
|
|
LOGI("Trying to open Camera2 (id: %s, num of camera : %d)\n", selectedCameraId,
|
|
|
|
cameraIdList->numCameras);
|
|
|
|
|
|
|
|
camera_status = ACameraManager_getCameraCharacteristics(cameraManager, selectedCameraId,
|
|
|
|
&cameraMetadata);
|
|
|
|
|
|
|
|
if (camera_status != ACAMERA_OK) {
|
|
|
|
LOGI("Failed to get camera meta data of ID:%s\n", selectedCameraId);
|
|
|
|
}
|
|
|
|
|
|
|
|
deviceStateCallbacks.onDisconnected = camera_device_on_disconnected;
|
|
|
|
deviceStateCallbacks.onError = camera_device_on_error;
|
|
|
|
|
|
|
|
camera_status = ACameraManager_openCamera(cameraManager, selectedCameraId,
|
|
|
|
&deviceStateCallbacks, &cameraDevice);
|
|
|
|
|
|
|
|
if (camera_status != ACAMERA_OK) {
|
|
|
|
LOGI("Failed to open camera device (id: %s)\n", selectedCameraId);
|
|
|
|
}
|
|
|
|
|
|
|
|
camera_status = ACameraDevice_createCaptureRequest(cameraDevice, TEMPLATE_PREVIEW,
|
|
|
|
&captureRequest);
|
|
|
|
|
|
|
|
if (camera_status != ACAMERA_OK) {
|
|
|
|
LOGI("Failed to create preview capture request (id: %s)\n", selectedCameraId);
|
|
|
|
}
|
|
|
|
|
|
|
|
ACaptureSessionOutputContainer_create(&captureSessionOutputContainer);
|
|
|
|
|
|
|
|
captureSessionStateCallbacks.onReady = capture_session_on_ready;
|
|
|
|
captureSessionStateCallbacks.onActive = capture_session_on_active;
|
|
|
|
captureSessionStateCallbacks.onClosed = capture_session_on_closed;
|
|
|
|
|
|
|
|
ACameraMetadata_free(cameraMetadata);
|
|
|
|
ACameraManager_deleteCameraIdList(cameraIdList);
|
|
|
|
ACameraManager_delete(cameraManager);
|
|
|
|
|
|
|
|
media_status_t status;
|
|
|
|
// status = AImageReader_new(1920, 1080, AIMAGE_FORMAT_YUV_420_888, 5, &mAImageReader);
|
|
|
|
status = AImageReader_new(1920, 1080, AIMAGE_FORMAT_JPEG, 5, &mAImageReader);
|
|
|
|
if (status != AMEDIA_OK)
|
|
|
|
{
|
|
|
|
LOGI("AImageReader_new error\n");
|
|
|
|
TakePhotoCb(false, photoInfo, path, 0);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
AImageReader_ImageListener listener{
|
|
|
|
.context = this,
|
|
|
|
.onImageAvailable = OnImageCallback,
|
|
|
|
};
|
|
|
|
AImageReader_setImageListener(mAImageReader, &listener);
|
|
|
|
|
|
|
|
//ANativeWindow *mNativeWindow;
|
|
|
|
status = AImageReader_getWindow(mAImageReader, &theNativeWindow);
|
|
|
|
if (status != AMEDIA_OK)
|
|
|
|
{
|
|
|
|
LOGI("AImageReader_getWindow error\n");
|
|
|
|
TakePhotoCb(false, photoInfo, path, 0);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
LOGI("Surface is prepared in %p.\n", theNativeWindow);
|
|
|
|
|
|
|
|
ACameraOutputTarget_create(theNativeWindow, &cameraOutputTarget);
|
|
|
|
ACaptureRequest_addTarget(captureRequest, cameraOutputTarget);
|
|
|
|
|
|
|
|
ACaptureSessionOutput_create(theNativeWindow, &sessionOutput);
|
|
|
|
ACaptureSessionOutputContainer_add(captureSessionOutputContainer, sessionOutput);
|
|
|
|
|
|
|
|
ACameraDevice_createCaptureSession(cameraDevice, captureSessionOutputContainer,
|
|
|
|
&captureSessionStateCallbacks, &captureSession);
|
|
|
|
|
|
|
|
// ACameraCaptureSession_setRepeatingRequest(captureSession, NULL, 1, &captureRequest, NULL);
|
|
|
|
ACameraCaptureSession_capture(captureSession, NULL, 1, &captureRequest, NULL);
|
|
|
|
LOGI("Surface is prepared in here.\n");
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ACameraCaptureSession_stateCallbacks* CPhoneDevice::GetSessionListener()
|
|
|
|
{
|
|
|
|
static ACameraCaptureSession_stateCallbacks sessionListener = {
|
|
|
|
.context = this,
|
|
|
|
.onClosed = CPhoneDevice::capture_session_on_closed,
|
|
|
|
.onReady = CPhoneDevice::capture_session_on_ready,
|
|
|
|
.onActive = CPhoneDevice::capture_session_on_active,
|
|
|
|
};
|
|
|
|
return &sessionListener;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CPhoneDevice::ImageCallback(AImageReader *reader)
|
|
|
|
{
|
|
|
|
AImage *image = nullptr;
|
|
|
|
media_status_t status = AImageReader_acquireNextImage(reader, &image);
|
|
|
|
if (status == AMEDIA_OK && image)
|
|
|
|
{
|
|
|
|
bool res = WriteFile(image);
|
|
|
|
AImage_delete(image);
|
|
|
|
// delete pThis;
|
|
|
|
|
|
|
|
TakePhotoCb(res, mPhotoInfo, mPath, time(NULL));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void CPhoneDevice::OnImageCallback(void *ctx, AImageReader *reader)
|
|
|
|
{
|
|
|
|
CPhoneDevice* pThis = reinterpret_cast<CPhoneDevice*>(ctx);
|
|
|
|
if (pThis != NULL)
|
|
|
|
{
|
|
|
|
pThis->ImageCallback(reader);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool CPhoneDevice::WriteFile(AImage *image)
|
|
|
|
{
|
|
|
|
int planeCount = 0;
|
|
|
|
media_status_t status = AImage_getNumberOfPlanes(image, &planeCount);
|
|
|
|
|
|
|
|
LOGI("Info: getNumberOfPlanes() planeCount = %d", planeCount);
|
|
|
|
if (!(status == AMEDIA_OK && planeCount == 1))
|
|
|
|
{
|
|
|
|
LOGE("Error: getNumberOfPlanes() planeCount = %d", planeCount);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint8_t *data = nullptr;
|
|
|
|
int len = 0;
|
|
|
|
AImage_getPlaneData(image, 0, &data, &len);
|
|
|
|
|
|
|
|
std::string path = GetFileName();
|
|
|
|
|
|
|
|
bool res = false;
|
|
|
|
FILE *file = fopen(path.c_str(), "wb");
|
|
|
|
if (file && data && len)
|
|
|
|
{
|
|
|
|
fwrite(data, 1, len, file);
|
|
|
|
fclose(file);
|
|
|
|
|
|
|
|
LOGE("Capture: %s", path.c_str());
|
|
|
|
|
|
|
|
|
|
|
|
res = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (file)
|
|
|
|
fclose(file);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CPhoneDevice::WriteFile(CPhoneDevice* pThis, AImage *image)
|
|
|
|
{
|
|
|
|
return pThis->WriteFile(image);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string CPhoneDevice::GetFileName() const
|
|
|
|
{
|
|
|
|
return mPath;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
bool CPhoneDevice::SendBroadcastMessage(String16 action, int value)
|
|
|
|
{
|
|
|
|
TM_INFO_LOG("sendBroadcastMessage(): Action: %s, Value: %d ", action.string(), value);
|
|
|
|
sp <IServiceManager> sm = defaultServiceManager();
|
|
|
|
sp <IBinder> am = sm->getService(String16("activity"));
|
|
|
|
if (am != NULL) {
|
|
|
|
Parcel data, reply;
|
|
|
|
data.writeInterfaceToken(String16("android.app.IActivityManager"));
|
|
|
|
data.writeStrongBinder(NULL);
|
|
|
|
// intent begin
|
|
|
|
data.writeString16(action); // action
|
|
|
|
data.writeInt32(0); // URI data type
|
|
|
|
data.writeString16(NULL, 0); // type
|
|
|
|
data.writeInt32(0); // flags
|
|
|
|
data.writeString16(NULL, 0); // package name
|
|
|
|
data.writeString16(NULL, 0); // component name
|
|
|
|
data.writeInt32(0); // source bound - size
|
|
|
|
data.writeInt32(0); // categories - size
|
|
|
|
data.writeInt32(0); // selector - size
|
|
|
|
data.writeInt32(0); // clipData - size
|
|
|
|
data.writeInt32(-2); // contentUserHint: -2 -> UserHandle.USER_CURRENT
|
|
|
|
data.writeInt32(-1); // bundle extras length
|
|
|
|
data.writeInt32(0x4C444E42); // 'B' 'N' 'D' 'L'
|
|
|
|
int oldPos = data.dataPosition();
|
|
|
|
data.writeInt32(1); // size
|
|
|
|
// data.writeInt32(0); // VAL_STRING, need to remove because of analyze common intent
|
|
|
|
data.writeString16(String16("type"));
|
|
|
|
data.writeInt32(1); // VAL_INTEGER
|
|
|
|
data.writeInt32(value);
|
|
|
|
int newPos = data.dataPosition();
|
|
|
|
data.setDataPosition(oldPos - 8);
|
|
|
|
data.writeInt32(newPos - oldPos); // refill bundle extras length
|
|
|
|
data.setDataPosition(newPos);
|
|
|
|
// intent end
|
|
|
|
data.writeString16(NULL, 0); // resolvedType
|
|
|
|
data.writeStrongBinder(NULL); // resultTo
|
|
|
|
data.writeInt32(0); // resultCode
|
|
|
|
data.writeString16(NULL, 0); // resultData
|
|
|
|
data.writeInt32(-1); // resultExtras
|
|
|
|
data.writeString16(NULL, 0); // permission
|
|
|
|
data.writeInt32(0); // appOp
|
|
|
|
data.writeInt32(-1); // option
|
|
|
|
data.writeInt32(1); // serialized: != 0 -> ordered
|
|
|
|
data.writeInt32(0); // sticky
|
|
|
|
data.writeInt32(-2); // userId: -2 -> UserHandle.USER_CURRENT
|
|
|
|
|
|
|
|
status_t ret = am->transact(IBinder::FIRST_CALL_TRANSACTION + 13, data,
|
|
|
|
&reply); // BROADCAST_INTENT_TRANSACTION
|
|
|
|
if (ret == NO_ERROR) {
|
|
|
|
int exceptionCode = reply.readExceptionCode();
|
|
|
|
if (exceptionCode) {
|
|
|
|
TM_INFO_LOG("sendBroadcastMessage(%s) caught exception %d\n",
|
|
|
|
action.string(), exceptionCode);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
TM_INFO_LOG("getService() couldn't find activity service!\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
void CPhoneDevice::camera_device_on_disconnected(void *context, ACameraDevice *device)
|
|
|
|
{
|
|
|
|
LOGI("Camera(id: %s) is diconnected.\n", ACameraDevice_getId(device));
|
|
|
|
CPhoneDevice* pThis = (CPhoneDevice*)context;
|
|
|
|
// delete pThis;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CPhoneDevice::camera_device_on_error(void *context, ACameraDevice *device, int error)
|
|
|
|
{
|
|
|
|
LOGI("Error(code: %d) on Camera(id: %s).\n", error, ACameraDevice_getId(device));
|
|
|
|
}
|
|
|
|
|
|
|
|
void CPhoneDevice::capture_session_on_ready(void *context, ACameraCaptureSession *session)
|
|
|
|
{
|
|
|
|
LOGI("Session is ready. %p\n", session);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CPhoneDevice::capture_session_on_active(void *context, ACameraCaptureSession *session)
|
|
|
|
{
|
|
|
|
LOGI("Session is activated. %p\n", session);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CPhoneDevice::capture_session_on_closed(void *context, ACameraCaptureSession *session)
|
|
|
|
{
|
|
|
|
LOGI("Session is closed. %p\n", session);
|
|
|
|
}
|