609 lines
22 KiB
C++
609 lines
22 KiB
C++
/*
|
|
* Copyright (c) 2019 Amlogic, Inc. All rights reserved.
|
|
*
|
|
* This source code is subject to the terms and conditions defined in the
|
|
* file 'LICENSE' which is part of this source code package.
|
|
*
|
|
* Description:
|
|
*/
|
|
#define LOG_MODULE_TAG "TV"
|
|
#define LOG_CLASS_TAG "TvService"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <pthread.h>
|
|
|
|
#include "TvService.h"
|
|
#include "TvCommon.h"
|
|
#include "CTvLog.h"
|
|
#include "tvcmd.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
pthread_mutex_t tvservice_mutex = PTHREAD_MUTEX_INITIALIZER;
|
|
|
|
TvService *mInstance = NULL;
|
|
TvService *TvService::GetInstance() {
|
|
if (mInstance == NULL) {
|
|
mInstance = new TvService();
|
|
}
|
|
|
|
return mInstance;
|
|
}
|
|
|
|
TvService::TvService() {
|
|
init_tv_logging();
|
|
mpTv = new CTv();
|
|
mpTv->setTvObserver(this);
|
|
}
|
|
|
|
TvService::~TvService() {
|
|
|
|
}
|
|
|
|
void TvService::onTvEvent(CTvEvent &event) {
|
|
int eventType = event.getEventType();
|
|
LOGD("%s: eventType: %d\n", __FUNCTION__, eventType);
|
|
switch (eventType) {
|
|
case CTvEvent::TV_EVENT_SIGNAL_DETECT:
|
|
SendSignalForSignalDetectEvent(event);
|
|
break;
|
|
case CTvEvent::TV_EVENT_SOURCE_CONNECT:
|
|
SendSignalForSourceConnectEvent(event);
|
|
break;
|
|
case CTvEvent::TV_EVENT_SIG_DV_ALLM:
|
|
SendSignalForDvAllmEvent(event);
|
|
break;
|
|
case CTvEvent::TV_EVENT_SIG_CHG_VRR:
|
|
SendSignalForVrrEvent(event);
|
|
break;
|
|
case CTvEvent::TV_EVENT_QMS:
|
|
SendSignalForQmsEvent(event);
|
|
break;
|
|
case CTvEvent::TV_EVENT_PIP_SIGNAL_DETECT:
|
|
SendSignalForPipSignalDetectEvent(event);
|
|
break;
|
|
default :
|
|
LOGE("TvService: invalie event type!\n");
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
int TvService::SendSignalForSourceConnectEvent(CTvEvent &event)
|
|
{
|
|
LOGD("%s\n", __FUNCTION__);
|
|
Parcel send, reply;
|
|
|
|
TvEvent::SourceConnectEvent *sourceConnectEvent = (TvEvent::SourceConnectEvent *)(&event);
|
|
int clientSize = mTvServiceCallBack.size();
|
|
LOGD("%s: now has %d tvclient.\n", __FUNCTION__, clientSize);
|
|
int i = 0;
|
|
for (i = 0; i < clientSize; i++) {
|
|
if (mTvServiceCallBack[i] != NULL) {
|
|
send.writeInt32(sourceConnectEvent->mSourceInput);
|
|
send.writeInt32(sourceConnectEvent->connectionState);
|
|
LOGD("send source evt(%d,%d) to client.\n",
|
|
sourceConnectEvent->mSourceInput, sourceConnectEvent->connectionState);
|
|
mTvServiceCallBack[i]->transact(EVT_SRC_CT_CB, send, &reply);
|
|
} else {
|
|
LOGD("Event callback is null.\n");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int TvService::SendSignalForDvAllmEvent(CTvEvent &event)
|
|
{
|
|
LOGD("%s\n", __FUNCTION__);
|
|
Parcel send, reply;
|
|
|
|
TvEvent::SignalDvAllmEvent *signalDvAllmEvent = (TvEvent::SignalDvAllmEvent *)(&event);
|
|
int clientSize = mTvServiceCallBack.size();
|
|
LOGD("%s: now has %d tvclient.\n", __FUNCTION__, clientSize);
|
|
for (int i = 0; i < clientSize; i++) {
|
|
if (mTvServiceCallBack[i] != NULL) {
|
|
send.writeInt32(signalDvAllmEvent->allm_mode);
|
|
send.writeInt32(signalDvAllmEvent->it_content);
|
|
send.writeInt32(signalDvAllmEvent->cn_type);
|
|
LOGD("send dv_allm evt(%d,%d,%d) to client.\n",
|
|
signalDvAllmEvent->allm_mode, signalDvAllmEvent->it_content, signalDvAllmEvent->cn_type);
|
|
mTvServiceCallBack[i]->transact(EVT_SIG_DV_ALLM, send, &reply);
|
|
} else {
|
|
LOGD("Event callback is null.\n");
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int TvService::SendSignalForVrrEvent(CTvEvent &event)
|
|
{
|
|
LOGD("%s\n", __FUNCTION__);
|
|
Parcel send, reply;
|
|
|
|
TvEvent::SignalVrrEvent *signalVrrEvent = (TvEvent::SignalVrrEvent *)(&event);
|
|
int clientSize = mTvServiceCallBack.size();
|
|
LOGD("%s: now has %d tvclient.\n", __FUNCTION__, clientSize);
|
|
for (int i = 0; i < clientSize; i++) {
|
|
if (mTvServiceCallBack[i] != NULL) {
|
|
send.writeInt32(signalVrrEvent->cur_vrr_status);
|
|
LOGD("send vrr evt(%d) to client.\n",
|
|
signalVrrEvent->cur_vrr_status);
|
|
mTvServiceCallBack[i]->transact(EVT_SIG_VRR_CB, send, &reply);
|
|
} else {
|
|
LOGD("Event callback is null.\n");
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int TvService::SendSignalForSignalDetectEvent(CTvEvent &event)
|
|
{
|
|
LOGD("%s\n", __FUNCTION__);
|
|
Parcel send, reply;
|
|
|
|
TvEvent::SignalDetectEvent *signalDetectEvent = (TvEvent::SignalDetectEvent *)(&event);
|
|
int clientSize = mTvServiceCallBack.size();
|
|
LOGD("%s: now has %d tvclient.\n", __FUNCTION__, clientSize);
|
|
int i = 0;
|
|
for (i = 0; i < clientSize; i++) {
|
|
if (mTvServiceCallBack[i] != NULL) {
|
|
send.writeInt32(signalDetectEvent->mSourceInput);
|
|
send.writeInt32(signalDetectEvent->mFmt);
|
|
send.writeInt32(signalDetectEvent->mTrans_fmt);
|
|
send.writeInt32(signalDetectEvent->mStatus);
|
|
send.writeInt32(signalDetectEvent->mDviFlag);
|
|
send.writeUint32(signalDetectEvent->mhdr_info);
|
|
mTvServiceCallBack[i]->transact(EVT_SIG_DT_CB, send, &reply);
|
|
} else {
|
|
LOGD("Event callback is null.\n");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int TvService::SendSignalForQmsEvent(CTvEvent &event)
|
|
{
|
|
LOGD("%s\n", __FUNCTION__);
|
|
Parcel send, reply;
|
|
|
|
TvEvent::QMSEvent *signalQmsEvent = (TvEvent::QMSEvent *)(&event);
|
|
int clientSize = mTvServiceCallBack.size();
|
|
LOGD("%s: now has %d tvclient.\n", __FUNCTION__, clientSize);
|
|
for (int i = 0; i < clientSize; i++) {
|
|
if (mTvServiceCallBack[i] != NULL) {
|
|
send.writeInt32(signalQmsEvent->qms_en);
|
|
send.writeInt32(signalQmsEvent->qms_fps);
|
|
send.writeInt32(signalQmsEvent->qms_base_fps);
|
|
LOGD("send qms evt to client. qms_en(%d), qms_fps(%d), qms_base_fps(%d)\n",
|
|
signalQmsEvent->qms_en, signalQmsEvent->qms_fps, signalQmsEvent->qms_base_fps);
|
|
mTvServiceCallBack[i]->transact(EVT_SIG_QMS_CB, send, &reply);
|
|
} else {
|
|
LOGD("Event callback is null.\n");
|
|
return -ENODEV;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int TvService::SendSignalForPipSignalDetectEvent(CTvEvent &event) {
|
|
LOGD("%s\n", __FUNCTION__);
|
|
Parcel send, reply;
|
|
|
|
TvEvent::PipSignalDetectEvent *pipDetectEvent =
|
|
(TvEvent::PipSignalDetectEvent *)(&event);
|
|
int clientSize = mTvServiceCallBack.size();
|
|
LOGD("%s: now has %d tvclient.\n", __FUNCTION__, clientSize);
|
|
for (int i = 0; i < clientSize; i++) {
|
|
if (mTvServiceCallBack[i] != NULL) {
|
|
send.writeInt32(pipDetectEvent->mSourceInput);
|
|
send.writeInt32(pipDetectEvent->mFmt);
|
|
send.writeInt32(pipDetectEvent->mTrans_fmt);
|
|
send.writeInt32(pipDetectEvent->mStatus);
|
|
send.writeInt32(pipDetectEvent->mDviFlag);
|
|
send.writeUint32(pipDetectEvent->mhdr_info);
|
|
LOGD("send pip signal detect evt to client. source(%d), status(%d)\n",
|
|
pipDetectEvent->mSourceInput, pipDetectEvent->mStatus);
|
|
mTvServiceCallBack[i]->transact(EVT_PIP_SIG_DT_CB, send, &reply);
|
|
} else {
|
|
LOGD("Event callback is null.\n");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int TvService::ParserTvCommand(const char *commandData)
|
|
{
|
|
pthread_mutex_lock(&tvservice_mutex);
|
|
|
|
int ret = 0;
|
|
tvin_frontend_info_t frontendInfo;
|
|
memset(&frontendInfo, 0x0, sizeof(tvin_frontend_info_t));
|
|
tvin_info_t tvinSignalInfo;
|
|
memset(&tvinSignalInfo, 0x0, sizeof(tvin_info_t));
|
|
char cmdbuff[1024];
|
|
memset(cmdbuff, 0x0, sizeof(cmdbuff));
|
|
size_t len = strlen(commandData);
|
|
if (len >= sizeof(cmdbuff)) {
|
|
len = sizeof(cmdbuff)-1;
|
|
}
|
|
memcpy(cmdbuff, commandData, len);
|
|
const char *delimitation = ".";
|
|
char *temp = strtok(cmdbuff, delimitation);
|
|
LOGD("%s: cmdType = %s\n", __FUNCTION__, temp);
|
|
if (strcmp(temp, "control") == 0) {
|
|
LOGD("%s: control cmd!\n", __FUNCTION__);
|
|
temp = strtok(NULL, delimitation);
|
|
int moduleID = atoi(temp);
|
|
if (moduleID == TV_CONTROL_START_TV) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t startSource = (tv_source_input_t)atoi(temp);
|
|
ret = mpTv->StartTv(startSource);
|
|
} else if (moduleID == TV_CONTROL_STOP_TV) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t stopSource = (tv_source_input_t)atoi(temp);
|
|
ret = mpTv->StopTv(stopSource);
|
|
} else if (moduleID == TV_CONTROL_SWITCH_SOURCE) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t source = (tv_source_input_t)atoi(temp);
|
|
ret = mpTv->SwitchSource(source);
|
|
} else if (moduleID == TV_CONTROL_GET_CURRENT_SOURCE) {
|
|
ret = (int)mpTv->GetCurrentSource();
|
|
} else if (moduleID == TV_CONTROL_VDIN_WORK_MODE_SET) {
|
|
temp = strtok(NULL, delimitation);
|
|
vdin_work_mode_t setVdinWorkMode = (vdin_work_mode_t)atoi(temp);
|
|
ret = mpTv->SetVdinWorkMode(setVdinWorkMode);
|
|
} else if (moduleID == TV_CONTROL_GET_FRAME_HEIGHT) {
|
|
mpTv->GetFrontendInfo(&frontendInfo);
|
|
ret = frontendInfo.height;
|
|
} else if (moduleID == TV_CONTROL_GET_FRAME_WIDTH) {
|
|
mpTv->GetFrontendInfo(&frontendInfo);
|
|
ret = frontendInfo.width;
|
|
} else if (moduleID == TV_CONTROL_GET_FRAME_RATE) {
|
|
mpTv->GetFrontendInfo(&frontendInfo);
|
|
ret = frontendInfo.fps;
|
|
} else if (moduleID == TV_CONTROL_GET_COLOR_DEPTH) {
|
|
mpTv->GetFrontendInfo(&frontendInfo);
|
|
ret = frontendInfo.colordepth;
|
|
} else if (moduleID == TV_CONTROL_GET_LINE_SCAN_MODE) {
|
|
mpTv->GetFrontendInfo(&frontendInfo);
|
|
ret = frontendInfo.scan_mode;
|
|
} else if (moduleID == TV_CONTROL_GET_CONNECT_STATUS) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t source = (tv_source_input_t)atoi(temp);
|
|
ret = mpTv->GetSourceConnectStatus(source);
|
|
} else if (moduleID == TV_CONTROL_SET_BOOST_ON) {
|
|
temp = strtok(NULL, delimitation);
|
|
ret = mpTv->SetEdidBoostOn(atoi(temp));
|
|
} else if (moduleID == TV_CONTROL_SET_AUDIO_ID) {
|
|
temp = strtok(NULL, delimitation);
|
|
int channel = atoi(temp);
|
|
temp = strtok(NULL, delimitation);
|
|
int id = atoi(temp);
|
|
ret = mpTv->SetAudioDecoderId(channel,id);
|
|
} else if (moduleID == TV_CONTROL_SET_AVAUDIO_MODE) {
|
|
temp = strtok(NULL, delimitation);
|
|
int enable = atoi(temp);
|
|
ret = mpTv->SetAvAudioModeEnabled(enable);
|
|
} else if (moduleID == TV_CONTROL_START_TV_PIP) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t startSource = (tv_source_input_t)atoi(temp);
|
|
ret = mpTv->StartTvInPIP(startSource);
|
|
} else if (moduleID == TV_CONTROL_STOP_TV_PIP) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t stopSource = (tv_source_input_t)atoi(temp);
|
|
ret = mpTv->StopTvInPIP(stopSource);
|
|
} else {
|
|
LOGD("%s: invalid sourec cmd!\n", __FUNCTION__);
|
|
}
|
|
} else if (strcmp(temp, "edid") == 0) {
|
|
LOGD("%s: EDID cmd!\n", __FUNCTION__);
|
|
temp = strtok(NULL, delimitation);
|
|
if (strcmp(temp, "set") == 0) {
|
|
temp = strtok(NULL, delimitation);
|
|
int moduleID = atoi(temp);
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t setSource = (tv_source_input_t)atoi(temp);
|
|
if (moduleID == HDMI_EDID_VER_SET) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_hdmi_edid_version_t setVersion = (tv_hdmi_edid_version_t)atoi(temp);
|
|
ret = mpTv->SetEdidVersion(setSource, setVersion);
|
|
} else {
|
|
LOGD("%s: invalid EDID set cmd!\n", __FUNCTION__);
|
|
ret = 0;
|
|
}
|
|
} else if (strcmp(temp, "get") == 0) {
|
|
temp = strtok(NULL, delimitation);
|
|
int moduleID = atoi(temp);
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t getSource = (tv_source_input_t)atoi(temp);
|
|
if (moduleID == HDMI_EDID_VER_GET) {
|
|
ret = mpTv->GetEdidVersion(getSource);
|
|
} else {
|
|
LOGD("%s: invalid EDID get cmd!\n", __FUNCTION__);
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
LOGD("%s: invalid cmd!\n", __FUNCTION__);
|
|
ret = 0;
|
|
}
|
|
} else if (strcmp(temp, "hdmi") == 0) {
|
|
LOGD("%s: hdmi cmd!\n", __FUNCTION__);
|
|
temp = strtok(NULL, delimitation);
|
|
int moduleID = atoi(temp);
|
|
if (moduleID == HDMI_GET_COLOR_FORMAT) {
|
|
tvinSignalInfo = mpTv->GetCurrentSourceInfo();
|
|
ret = tvinSignalInfo.cfmt;
|
|
} else if (moduleID == HDMI_GET_COLOR_RANGE) {
|
|
ret = mpTv->GetCurrentSourceColorRange();
|
|
} else if (moduleID == HDMI_GET_COLOR_DEPTH) {
|
|
mpTv->GetFrontendInfo(&frontendInfo);
|
|
ret = frontendInfo.colordepth;
|
|
} else if (moduleID == HDMI_GET_ASPECT_RATIO) {
|
|
tvinSignalInfo = mpTv->GetCurrentSourceInfo();
|
|
ret = tvinSignalInfo.aspect_ratio;
|
|
} else if (moduleID == HDMI_SET_COLOR_RANGE) {
|
|
temp = strtok(NULL, delimitation);
|
|
int mode = atoi(temp);
|
|
ret = mpTv->SetCurrentSourceColorRange((tvin_color_range_t)mode);
|
|
} else if (moduleID == HDMI_SET_ALLM_ENABLED) {
|
|
temp = strtok(NULL, delimitation);
|
|
int enable = atoi(temp);
|
|
ret = mpTv->SetHdmiAllmEnabled(enable);
|
|
} else if (moduleID == HDMI_GET_ALLM_ENABLED) {
|
|
ret = mpTv->GetHdmiAllmEnabled();
|
|
} else if (moduleID == HDMI_SET_VRR_ENABLED) {
|
|
temp = strtok(NULL, delimitation);
|
|
int enable = atoi(temp);
|
|
ret = mpTv->SetHdmiVrrEnabled(enable);
|
|
} else if (moduleID == HDMI_GET_VRR_ENABLED) {
|
|
ret = mpTv->GetHdmiVrrEnabled();
|
|
} else if (moduleID == HDMI_GET_VRR_MODE) {
|
|
ret = mpTv->GetHdmiVrrMode();
|
|
} else if (moduleID == HDMI_GET_VRR_SUPPORT) {
|
|
ret = mpTv->GetHdmiVrrSupport();
|
|
} else if (moduleID == HDMI_GET_QMS_SUPPORT) {
|
|
ret = mpTv->GetHdmiQmsSupport();
|
|
} else if (moduleID == HDMI_SET_QMS_ENABLED) {
|
|
temp = strtok(NULL, delimitation);
|
|
int enable = atoi(temp);
|
|
ret = mpTv->SetHdmiQmsEnabled(enable);
|
|
} else if (moduleID == HDMI_GET_QMS_ENABLED) {
|
|
ret = mpTv->GetHdmiQmsEnabled();
|
|
} else if (moduleID == HDMI_GET_DLG_SUPPORT) {
|
|
ret = mpTv->GetHdmiDlgSupport();
|
|
} else if (moduleID == HDMI_SET_DLG_ENABLED) {
|
|
temp = strtok(NULL, delimitation);
|
|
int enable = atoi(temp);
|
|
ret = mpTv->SetHdmiDlgEnabled(enable);
|
|
} else if (moduleID == HDMI_GET_DLG_ENABLED) {
|
|
ret = mpTv->GetHdmiDlgEnabled();
|
|
} else {
|
|
LOGD("%s: invalid hdmi cmd!\n", __FUNCTION__);
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
LOGD("%s: invalie cmdType!\n", __FUNCTION__);
|
|
}
|
|
|
|
pthread_mutex_unlock(&tvservice_mutex);
|
|
return ret;
|
|
}
|
|
|
|
int TvService::ParserTvDataCommand(const char *commandBuf, unsigned char *dataBuf)
|
|
{
|
|
pthread_mutex_lock(&tvservice_mutex);
|
|
|
|
int ret = 0;
|
|
char cmdbuff[1024], tempData[1024];
|
|
memset(cmdbuff, 0x0, 1024);
|
|
memcpy(cmdbuff, commandBuf, 1024);
|
|
const char *delimitation = ".";
|
|
char *temp = strtok(cmdbuff, delimitation);
|
|
int cmdID = atoi(temp);
|
|
LOGD("%s: cmdID = %d\n", __FUNCTION__, cmdID);
|
|
if (cmdID == HDMI_EDID_DATA_SET) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t setSource = (tv_source_input_t)atoi(temp);
|
|
memcpy(tempData, dataBuf, 256);
|
|
/*LOGD("%s: edid data print start.\n", __FUNCTION__);
|
|
for (int i=0;i<256;i++) {
|
|
printf("0x%x",tempData[i]);
|
|
}
|
|
LOGD("%s: edid data print end.\n", __FUNCTION__);*/
|
|
ret = mpTv->SetEdidData(setSource, tempData);
|
|
} else if (cmdID == HDMI_EDID_DATA_GET) {
|
|
temp = strtok(NULL, delimitation);
|
|
tv_source_input_t getSource = (tv_source_input_t)atoi(temp);
|
|
ret = mpTv->GetEdidData(getSource, tempData);
|
|
memcpy(dataBuf, tempData, 256);
|
|
} else {
|
|
LOGD("%s: invalid data cmd.\n", __FUNCTION__);
|
|
}
|
|
|
|
pthread_mutex_unlock(&tvservice_mutex);
|
|
return ret;
|
|
}
|
|
|
|
int TvService::HandleDataRequest(const char* cmdtype, const char* cmd, tvcmd_e subcmd, tv_source_input_t source, char* data, size_t length)
|
|
{
|
|
int ret = 0;
|
|
LOGD("%s: cmdType = %s\n", __FUNCTION__, cmdtype);
|
|
if (strcmp(cmdtype, "pkttype") == 0) {
|
|
LOGD("%s: PKTTYPE cmd!\n", __FUNCTION__);
|
|
if (strcmp(cmd, "set") == 0) {
|
|
// Reserved
|
|
} else if (strcmp(cmd, "get") == 0) {
|
|
if (subcmd == HDMI_SPD_INFO_GET) {
|
|
ret = mpTv->GetHdmiSPDInfo(source, data, length);
|
|
} else if (subcmd == HDMI_EDID_DATA_GET) {
|
|
ret = mpTv->GetEdidData(source, data);
|
|
} else {
|
|
LOGD("%s: invalid PKTTYPE get cmd!\n", __FUNCTION__);
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
LOGD("%s: invalid cmd!\n", __FUNCTION__);
|
|
ret = 0;
|
|
}
|
|
} else {
|
|
LOGD("%s: invalie cmdtype!\n", __FUNCTION__);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int TvService::SetTvServiceCallBack(sp<IBinder> callBack)
|
|
{
|
|
LOGD("%s\n", __FUNCTION__);
|
|
int ret = -1;
|
|
if (callBack != nullptr) {
|
|
LOGD("%s: callBack is %p.\n", __FUNCTION__, callBack.get());
|
|
int cookie = -1;
|
|
int clientSize = mTvServiceCallBack.size();
|
|
for (int i = 0; i < clientSize; i++) {
|
|
if (mTvServiceCallBack[i] == NULL) {
|
|
cookie = i;
|
|
mTvServiceCallBack[i] = callBack;
|
|
break;
|
|
} else {
|
|
LOGD("%s: mTvServiceCallBack[%d] has been register.\n", __FUNCTION__, i);
|
|
}
|
|
}
|
|
|
|
if (cookie < 0) {
|
|
cookie = clientSize;
|
|
mTvServiceCallBack[clientSize] = callBack;
|
|
}
|
|
ret = cookie;
|
|
} else {
|
|
LOGD("%s: callBack is NULL.\n", __FUNCTION__);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int TvService::RemoveTvServiceCallBack(int callBackId)
|
|
{
|
|
LOGD("%s\n", __FUNCTION__);
|
|
|
|
int clientSize = mTvServiceCallBack.size();
|
|
if (callBackId < 0) {
|
|
LOGD("%s: invalid callBackId.\n", __FUNCTION__);
|
|
} else {
|
|
mTvServiceCallBack.erase(callBackId);
|
|
}
|
|
|
|
clientSize = mTvServiceCallBack.size();
|
|
LOGD("%s: now has %d tvclient after remove.\n", __FUNCTION__, clientSize);
|
|
return 0;
|
|
}
|
|
status_t TvService::onTransact(uint32_t code,
|
|
const Parcel& data, Parcel* reply,
|
|
uint32_t flags) {
|
|
LOGD("%s: cmd is %d.\n", __FUNCTION__, code);
|
|
unsigned char dataBuf[1024] = {0};
|
|
int count = 0;
|
|
switch (code) {
|
|
case CMD_TV_ACTION: {
|
|
const char* command = data.readCString();
|
|
int ret = ParserTvCommand(command);
|
|
reply->writeInt32(ret);
|
|
break;
|
|
}
|
|
case DATA_SET_ACTION: {
|
|
const char* command = data.readCString();
|
|
int setDataSize = data.readInt32();
|
|
LOGD("%s: data size is %d.\n", __FUNCTION__, setDataSize);
|
|
for (count=0;count<setDataSize;count++) {
|
|
dataBuf[count] = (char)data.readInt32();
|
|
}
|
|
int ret = ParserTvDataCommand(command, dataBuf);
|
|
reply->writeInt32(ret);
|
|
break;
|
|
}
|
|
case DATA_GET_ACTION: {
|
|
const char* command = data.readCString();
|
|
int ret = ParserTvDataCommand(command, dataBuf);
|
|
int getDataSize = sizeof(dataBuf);
|
|
reply->writeInt32(getDataSize);
|
|
for (count=0;count<getDataSize;count++) {
|
|
reply->writeInt32(dataBuf[count]);
|
|
}
|
|
reply->writeInt32(ret);
|
|
break;
|
|
}
|
|
case CMD_SET_TV_CB: {
|
|
int tvServiceCallBackID = SetTvServiceCallBack(data.readStrongBinder());
|
|
reply->writeInt32(tvServiceCallBackID);
|
|
break;
|
|
}
|
|
case CMD_CLR_TV_CB: {
|
|
RemoveTvServiceCallBack(data.readInt32());
|
|
break;
|
|
}
|
|
case CMD_DATA_REQ: {
|
|
const char* d = ".";
|
|
char databuf[1024];
|
|
char cmdstr[1024];
|
|
|
|
memset(cmdstr, 0, sizeof(cmdstr));
|
|
memcpy(cmdstr, data.readCString(), data.dataSize());
|
|
|
|
pthread_mutex_lock(&tvservice_mutex);
|
|
char* p = strtok(cmdstr, d);
|
|
const char* cmdtype = p;
|
|
|
|
p = strtok(NULL, d);
|
|
const char* cmd = p;
|
|
p = strtok(NULL, d);
|
|
tvcmd_e subcmd = (tvcmd_e) atoi(p);
|
|
|
|
p = strtok(NULL, d);
|
|
tv_source_input_t src = (tv_source_input_t) atoi(p);
|
|
|
|
p = strtok(NULL, d);
|
|
size_t datalen = atoi(p);
|
|
|
|
memset(databuf, 0, sizeof(databuf));
|
|
int ret = HandleDataRequest(cmdtype, cmd, subcmd, src, databuf, datalen);
|
|
pthread_mutex_unlock(&tvservice_mutex);
|
|
reply->writeInt32(ret);
|
|
reply->write(databuf, datalen);
|
|
break;
|
|
}
|
|
case CMT_GET_ALLM_INFO: {
|
|
tvin_latency_s info;
|
|
memset(&info, 0x0, sizeof(tvin_latency_s));
|
|
mpTv->GetCurrentSourceAllmInfo(&info);
|
|
reply->writeInt32((int)info.allm_mode);
|
|
reply->writeInt32((int)info.it_content);
|
|
reply->writeInt32((int)info.cn_type);
|
|
break;
|
|
}
|
|
case CMT_GET_STD_INFO: {
|
|
tvin_std_s info;
|
|
memset(&info, 0x0, sizeof(tvin_std_s));
|
|
mpTv->GetCurrentStdInfo(&info);
|
|
reply->writeInt32((int)info.source);
|
|
reply->writeInt32((int)info.edid_version);
|
|
reply->writeInt32((int)info.allm_enabled);
|
|
reply->writeInt32((int)info.vrr_enabled);
|
|
reply->writeInt32((int)info.qms_enabled);
|
|
break;
|
|
}
|
|
default:
|
|
return BBinder::onTransact(code, data, reply, flags);
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|