[Feature]add MT2731_MP2_MR2_SVN388 baseline version
Change-Id: Ief04314834b31e27effab435d3ca8ba33b499059
diff --git a/src/lynq/lib/liblynq-tele-ril/lynq-riltel/em/rfdesense/RfDesenseTxTest.cpp b/src/lynq/lib/liblynq-tele-ril/lynq-riltel/em/rfdesense/RfDesenseTxTest.cpp
new file mode 100644
index 0000000..26759a1
--- /dev/null
+++ b/src/lynq/lib/liblynq-tele-ril/lynq-riltel/em/rfdesense/RfDesenseTxTest.cpp
@@ -0,0 +1,1233 @@
+/* Copyright Statement:
+ *
+ * This software/firmware and related documentation ("MediaTek Software") are
+ * protected under relevant copyright laws. The information contained herein
+ * is confidential and proprietary to MediaTek Inc. and/or its licensors.
+ * Without the prior written permission of MediaTek inc. and/or its licensors,
+ * any reproduction, modification, use or disclosure of MediaTek Software,
+ * and information contained herein, in whole or in part, shall be strictly prohibited.
+ *
+ * MediaTek Inc. (C) 2016. All rights reserved.
+ *
+ * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+ * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
+ * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
+ * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
+ * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
+ * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
+ * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
+ * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
+ * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
+ * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
+ * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
+ * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
+ * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
+ * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
+ * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
+ * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+ *
+ * The following software/firmware and/or related documentation ("MediaTek Software")
+ * have been modified by MediaTek Inc. All revisions are subject to any receiver's
+ * applicable license agreements with MediaTek Inc.
+ */
+
+#include "rfdesense/RfDesenseTxTest.h"
+
+#include <memory>
+#include <list>
+#include <regex>
+#include <cmath>
+#include <string>
+#include <cstdarg>
+#include <cstring>
+
+#include <vendor-ril/telephony/ril.h>
+
+#include "common.h"
+#include "em.h"
+#include "rfdesense/RfDesenseTxTestCdma.h"
+#include "rfdesense/RfDesenseTxTestGsm.h"
+#include "rfdesense/RfDesenseTxTestLte.h"
+#include "rfdesense/RfDesenseTxTestTd.h"
+#include "util/log_extra.h"
+#include "util/utils.h"
+
+#undef LOG_TAG
+#define LOG_TAG "EM_RfDesenseTxTest"
+
+RfDesenseTxTest* RfDesenseTxTest::m_instance = NULL;
+std::mutex RfDesenseTxTest::mMutex;
+
+const int RfDesenseTxTest::STATE_NONE = 0;
+const int RfDesenseTxTest::STATE_STARTED = 1;
+const int RfDesenseTxTest::STATE_STOPPED = 2;
+
+const int RfDesenseTxTest::MSG_START_TX = 1;
+const int RfDesenseTxTest::MSG_NEXT_RAT = 4;
+const int RfDesenseTxTest::MSG_READ_POWER = 10;
+const int RfDesenseTxTest::MSG_EWMPOLICY_TDSCDMA = 12;
+const int RfDesenseTxTest::MSG_EWMPOLICY_WCDMA = 13;
+const int RfDesenseTxTest::MSG_ECSRA = 14;
+const int RfDesenseTxTest::MSG_SWITCH_RAT_DONE = 15;
+
+int RfDesenseTxTest::mState = STATE_NONE;
+
+long RfDesenseTxTest::mTestDuration = 10;
+long RfDesenseTxTest::mTestCount = 1;
+long RfDesenseTxTest::mTestDurationSended = 0;
+long RfDesenseTxTest::mTestCountSended = 0;
+long RfDesenseTxTest::mCheckLimit = 2;
+long RfDesenseTxTest::mReadbackInterval = 5;
+
+const std::string RfDesenseTxTest::KEY_GSM_ATCMD = "gsm_at_cmd";
+const std::string RfDesenseTxTest::KEY_TDSCDMA_ATCMD = "tdscdma_at_cmd";
+const std::string RfDesenseTxTest::KEY_WCDMA_ATCMD = "wcdma_at_cmd";
+const std::string RfDesenseTxTest::KEY_LTE_FDD_ATCMD = "lte_fdd_at_cmd";
+const std::string RfDesenseTxTest::KEY_LTE_TDD_ATCMD = "lte_tdd_at_cmd";
+const std::string RfDesenseTxTest::KEY_CDMA_1X_ATCMD = "cdma_at_cmd";
+const std::string RfDesenseTxTest::KEY_CDMA_EVDO_ATCMD = "cdma_evdo_at_cmd";
+const std::string RfDesenseTxTest::KEY_TEST_DURATION = "test_duration";
+const std::string RfDesenseTxTest::KEY_TEST_COUNT = "test_count";
+const std::string RfDesenseTxTest::KEY_CHECK_LIMIT = "check_limit";
+const std::string RfDesenseTxTest::KEY_READBACK_INTREVAL = "readback_interval";
+
+const std::string RfDesenseTxTest::DEFAULT_GSM_ATCMD =
+ "AT+ERFTX=2,1,190,4100,128,0,5,0";
+const std::string RfDesenseTxTest::DEFAULT_TDSCDMA_ATCMD = "AT+ERFTX=0,0,1,10087,24";
+const std::string RfDesenseTxTest::DEFAULT_WCDMA_ATCMD = "AT+ERFTX=0,0,1,9750,23";
+const std::string RfDesenseTxTest::DEFAULT_LTE_FDD_ATCMD =
+ "AT+ERFTX=6,0,1,3,3,17475,1,0,0,0,1,0,23";
+const std::string RfDesenseTxTest::DEFAULT_LTE_TDD_ATCMD =
+ "AT+ERFTX=6,0,1,38,3,25950,0,0,0,0,1,0,23";
+const std::string RfDesenseTxTest::DEFAULT_CDMA_EVDO_ATCMD = "AT+ERFTX=13,4,384,0,83";
+const std::string RfDesenseTxTest::DEFAULT_CDMA_1X_ATCMD = "AT+ECRFTX=1,384,0,83,0";
+
+const std::string RfDesenseTxTest::DEFAULT_CDMA_EVDO_ATCMD_93before =
+ "AT+ERFTX=1,384,0,83,1";
+
+const std::vector<std::string> RfDesenseTxTest::mRatName = { "GSM", "TDSCDMA", "WCDMA",
+ "LTE(FDD)", "LTE(TDD)", "CDMA(EVDO)", "CDMA(1X)" };
+std::vector<std::string> RfDesenseTxTest::mRatCmdStart = { DEFAULT_GSM_ATCMD,
+ DEFAULT_TDSCDMA_ATCMD, DEFAULT_WCDMA_ATCMD, DEFAULT_LTE_FDD_ATCMD,
+ DEFAULT_LTE_TDD_ATCMD, DEFAULT_CDMA_EVDO_ATCMD,
+ DEFAULT_CDMA_1X_ATCMD };
+
+std::vector<std::string> RfDesenseTxTest::mRatCmdStop = { "AT+ERFTX=2,0",
+ "AT+ERFTX=0,1", "AT+ERFTX=0,1", "AT+ERFTX=6,0,0", "AT+ERFTX=6,0,0",
+ "AT+ERFTX=13,5", "AT+ECRFTX=0" };
+
+ std::vector<std::string> RfDesenseTxTest::mRatCmdSwitch = { "AT+ERAT=0", "AT+ERAT=1",
+ "AT+ERAT=1", "AT+ERAT=6,4", "AT+ERAT=6,4", "AT+ERAT=7,64",
+ "AT+ERAT=7,32" };
+
+std::vector<std::string> RfDesenseTxTest::mRatCmdPowerRead = { "", "AT+ERFTX=0,3",
+ "AT+ERFTX=0,3", "AT+ERFTX=6,1", "AT+ERFTX=6,1", "AT+ERFTX=13,3",
+ "AT+ERFTX=13,3" };
+std::vector<std::string> RfDesenseTxTest::mRatBand = { "19", "1", "1", "3", "38", "0", "0" };
+std::vector<std::string> RfDesenseTxTest::mRatPowerSet = { "19", "10", "24", "23", "23", "23", "23" };
+std::vector<bool> RfDesenseTxTest::mRatCheck = {false, false,false,false,false,false,false};
+std::vector<bool> RfDesenseTxTest::mSendState = {false, false,false,false,false,false,false};
+std::string RfDesenseTxTest::str_msg = "";
+bool RfDesenseTxTest::trm_flag = false;
+int RfDesenseTxTest::phone_id = 0;
+
+void RfDesenseTxTest::rf_send_at_cmd(std::string cmd, int flag){
+ mCurrentFlag = flag;
+ emSendATCommand(cmd.c_str(),phone_id);
+}
+
+//create thread to send command
+void RfDesenseTxTest::emRfDesenseThread(int id) {
+ mState = STATE_STARTED;
+ int operatorid = id;
+ LOG_D(LOG_TAG, "emRfDesenseThread: operatorid(%d)", operatorid);
+ switch (operatorid) {
+ case 0:{
+ if (trm_flag) {
+ LOG_D(LOG_TAG, "wait modem reset done");
+ std::this_thread::sleep_for(std::chrono::milliseconds(1000*5));
+ trm_flag = false;
+ }
+ if(isRadioOn((RIL_SOCKET_ID)phone_id)) {
+ LOG_D(LOG_TAG, "radio already on");
+ mIsModemEnabled = false;
+ emRadioStateOn();
+ } else {
+ while(!isRadioOn((RIL_SOCKET_ID)phone_id)) {
+ LOG_D(LOG_TAG, "radio isn't on");
+ std::this_thread::sleep_for(std::chrono::milliseconds(200));
+ }
+ //turnOnRf();
+ LOG_D(LOG_TAG, "radio on again");
+ registerRadioOn(m_instance);
+ mIsModemEnabled = false;
+ }
+ break;
+ }
+ }
+}
+
+void RfDesenseTxTest::emRadioStateOn(){
+ if (mIsModemEnabled == true) {
+ LOG_D(LOG_TAG, "mIsModemEnabled is true, just return");
+ return;
+ }
+ mIsModemEnabled = true;
+ LOG_D(LOG_TAG, "turn on rf succeed");
+ if (mState == STATE_STARTED) {
+ mCurrectRatInfo = getCurrectRatInfo();
+ if (mCurrectRatInfo
+ && !mCurrectRatInfo->getRatCmdSwitch().empty()) {
+ LOG_D(LOG_TAG, "switch rat(%s)",mCurrectRatInfo->getRatCmdSwitch().c_str());
+ //unregisterRadioOn();
+ rf_send_at_cmd(mCurrectRatInfo->getRatCmdSwitch(), MSG_SWITCH_RAT_DONE);
+ } else {
+ LOG_D(LOG_TAG, "mCurrectRatInfo == null");
+ }
+ }
+}
+
+void RfDesenseTxTest::emRadioStateOfforNotAvailable() {
+ //unregisterRadioOffOrNotAvailable();
+ if (mIsModemNotEnabled == true) {
+ LOG_D(LOG_TAG, "mIsModemNotEnabled is true, just return");
+ return;
+ }
+ mIsModemNotEnabled = true;
+ LOG_D(LOG_TAG, "turn off rf succeed...");
+ if (mCurrectRatInfo) {
+ mCurrectRatInfo->setRatSendState(true);
+ rf_send_at_cmd(mCurrectRatInfo->getRatCmdStart(), MSG_START_TX);
+ LOG_D(LOG_TAG, "send: %s %s",mCurrectRatInfo->getRatName().c_str() ,mCurrectRatInfo->getRatCmdStart().c_str());
+ } else {
+ LOG_D(LOG_TAG, "mCurrectRatInfo == null");
+ }
+}
+
+void RfDesenseTxTest::emOemHookRaw(int value, int slot_id){
+ if(slot_id != phone_id) {
+ LOG_W(LOG_TAG, "slot_id = %d, main_slot: %d", slot_id, phone_id);
+ //return;
+ }
+ LOG_D(LOG_TAG, "Readback tx power = %d", value);
+ std::string result = "";
+ std::string rat = "";
+ std::lock_guard<std::mutex> guard(mMutex);
+ m_rawUrc = true;
+ m_condVar.notify_one();
+ float getPower = value / 8.0f;
+ if (std::abs(std::stoi(mCurrectRatInfo->getRatPowerSet()) -
+ getPower) > mCheckLimit) {
+ result = "failed\n";
+ } else {
+ result = "succeed\n";
+ }
+
+ std::string s = std::string("Start TX:\n")
+ + std::string("Rat(band) ") + std::string("Power_Set ")
+ + std::string("Power_Get ") + std::string("Result\n");
+ rat = utils::format("%-20s %-15s %-10s",
+ (mCurrectRatInfo->getRatName()+ "(b" + mCurrectRatInfo->getRatband() + ")").c_str(),
+ mCurrectRatInfo->getRatPowerSet().c_str(),
+ std::to_string(getPower).c_str()
+ );
+ std::string ret;
+ if (!result.compare("failed\n")) {
+ ret = utils::format("%10s", result.c_str());
+ } else {
+ ret = utils::format("%10s", result.c_str());
+ }
+ str_msg += s + rat + ret;
+
+}
+
+void RfDesenseTxTest::tx_stop() {
+ LOG_D(LOG_TAG,"tx_stop");
+ std::unique_lock<std::mutex> mlock(mMutex);
+ m_condVar.wait(mlock,[this]{return m_rawUrc;});
+ txTestStop(MSG_NEXT_RAT);
+}
+
+void RfDesenseTxTest::init() {
+ mRequestHandleThread = new RequestHandleThread(this);
+ mRequestHandleThread->run();
+}
+
+RfDesenseTxTest::RfDesenseTxTest() {
+ initRatList();
+}
+
+RfDesenseTxTest::~RfDesenseTxTest() {
+ LOG_D(LOG_TAG, "RfDesenseTxTest destroyed");
+}
+
+void RfDesenseTxTest::txTestStop(int what) {
+ if (mCurrectRatInfo) {
+ rf_send_at_cmd(mCurrectRatInfo->getRatCmdStop(), what);
+ LOG_D(LOG_TAG, "stop: %s %s", mCurrectRatInfo->getRatName().c_str(), mCurrectRatInfo->getRatCmdStop().c_str());
+ } else {
+ LOG_D(LOG_TAG, "mCurrectRatInfo is null");
+ mState = STATE_STOPPED;
+ for (int i = 0; i < mRatList.size(); i++) {
+ mRatList[i]->setRatSendState(false);
+ mRatList[i]->setRatCheckState(false);
+ }
+ }
+}
+
+void RfDesenseTxTest::deInit() {
+
+}
+
+RfDesenseTxTest* RfDesenseTxTest::getInstance() {
+ if(!m_instance) {
+ mMutex.lock();
+ if(!m_instance) {
+ m_instance = new RfDesenseTxTest();
+ m_instance->init();
+ }
+ mMutex.unlock();
+ }
+ return m_instance;
+}
+
+// Method implements of RequestHandleThread
+RfDesenseTxTest::RequestHandleThread::RequestHandleThread(RfDesenseTxTest* tx) : m_looper(NULL) {
+ mTx = tx;
+ LOG_D(LOG_TAG, "RequestHandleThread created");
+}
+
+RfDesenseTxTest::RequestHandleThread::~RequestHandleThread() {
+ mTx = NULL;
+ LOG_D(LOG_TAG, "RequestHandleThread destroyed");
+}
+
+bool RfDesenseTxTest::RequestHandleThread::threadLoop() {
+ LOG_D(LOG_TAG, "RequestHandleThread threadLoop");
+ // start message loop
+ m_looper = Looper::prepare(0);
+ int result;
+ do {
+ result = m_looper->pollAll(-1);
+ LOG_D(LOG_TAG, "RequestHandleThread threadLoop, pull message result = %d", result);
+ } while (result == Looper::POLL_WAKE || result == Looper::POLL_CALLBACK);
+ return true;
+}
+
+sp<Looper> RfDesenseTxTest::RequestHandleThread::getLooper() {
+ return m_looper;
+}
+
+RfDesenseTxTest::RfRequestMessage::RfRequestMessage(RfDesenseTxTest* tx) : mTx(tx),mMsgType(0),
+ response(""),responselen(0), slot(0), e(RIL_E_SUCCESS) {
+}
+
+RfDesenseTxTest::RfRequestMessage::~RfRequestMessage() {
+ LOG_D(LOG_TAG, "RequestHandleThread destroyed");
+}
+
+void RfDesenseTxTest::RfRequestMessage::sendMessage(int delayms) {
+ LOG_D(LOG_TAG, "RfDesenseTxTest::RfRequestMessage, sendMessage delayms=%d", delayms);
+ if(mTx != NULL) {
+ mTx->sendMessage(this, delayms);
+ } else {
+ LOG_D(LOG_TAG, "RfDesenseTxTest::RfRequestHandler mTx is null");
+ }
+}
+
+void RfDesenseTxTest::RfRequestHandler::sendMessage(sp<RfRequestMessage> msg, int delayms) {
+ LOG_D(LOG_TAG, "RfDesenseTxTest::RfRequestHandler, sendMessage msg what=%d delayms=%d", msg->mMsgType, delayms);
+ this->mMsg = msg;
+ if(mTx != NULL) {
+ mTx->sendMessage(mMsg, delayms);
+ } else {
+ LOG_D(LOG_TAG, "RfDesenseTxTest::RfRequestHandler mTx is null");
+ }
+}
+
+RfDesenseTxTest::RfRequestHandler:: ~RfRequestHandler() {
+ mTx = NULL;
+ LOG_D(LOG_TAG, "RfRequestHandler destroyed");
+}
+
+void RfDesenseTxTest::handle_request(string response,int responselen,int slot, RIL_Errno e) {
+ sp<RfRequestMessage> msg = new RfRequestMessage(this);
+ msg->mMsgType = mCurrentFlag;
+ msg->response = response;
+ msg->responselen = responselen;
+ msg->slot = slot;
+ msg->e = e;
+ if(mCurrentFlag == MSG_READ_POWER) {
+ sendMessage(msg, 2*1000);
+ } else {
+ sendMessage(msg, 1000);
+ }
+}
+
+sp<RfDesenseTxTest::RfRequestHandler> RfDesenseTxTest::sendMessage(sp<RfRequestMessage> msg, int delayms) {
+ LOG_D(LOG_TAG, "sendMessage msg token=%d delayms=%d", msg->mMsgType, delayms);
+ sp<RfRequestHandler> handler = new RfRequestHandler(this);
+ handler->mMsg = msg;
+ if(mRequestHandleThread.get()) {
+ sp<Looper> looper = mRequestHandleThread->getLooper();
+ if(looper.get()) {
+ if (delayms > 0) {
+ looper->sendMessageDelayed(ms2ns(delayms),handler, handler->m_dummyMsg);
+ } else {
+ looper->sendMessage(handler, handler->m_dummyMsg);
+ }
+ } else {
+ LOG_D(LOG_TAG, "looper fail");
+ }
+ } else {
+ LOG_D(LOG_TAG, "mRequestHandleThread fail");
+ }
+
+ return handler;
+}
+
+void RfDesenseTxTest::emRfDesenseAtCmdHandle(sp<RfRequestMessage> msg){
+ LOG_D(LOG_TAG, "emRfDesenseAtCmdHandle, type: %d", msg->mMsgType);
+ int responselen = msg->responselen;
+ std::string response = msg->response;
+ switch (msg->mMsgType) {
+ case MSG_SWITCH_RAT_DONE: {
+ if (msg->e == RIL_E_SUCCESS) {
+ LOG_D(LOG_TAG, "switch rat succeed");
+ if (mCurrectRatInfo->getRatName() == mRatName[1]) { // tdscdma
+ LOG_D(LOG_TAG, "end AT+EWMPOLICY=0");
+ rf_send_at_cmd("AT+EWMPOLICY=0", MSG_EWMPOLICY_TDSCDMA);
+ } else if (mCurrectRatInfo->getRatName() == mRatName[2]) { // wcdma
+ LOG_D(LOG_TAG, "send AT+EWMPOLICY=0");
+ rf_send_at_cmd("AT+EWMPOLICY=0", MSG_EWMPOLICY_WCDMA);
+ } else { // other rat
+ registerRadioOffOrNotAvailable(m_instance);
+ turnOffRf();
+ }
+ } else {
+ LOG_D(LOG_TAG, "switch rat failed");
+ emResultNotifyWithDone(mCurrectRatInfo->getRatName() + " switch rat failed\n");
+ }
+ break;
+ }
+ case MSG_EWMPOLICY_TDSCDMA: {
+ LOG_D(LOG_TAG, "AT+EWMPOLICY=0 send succeed");
+ LOG_D(LOG_TAG, "send AT+ECSRA=2,0,1,0,1,0 ...");
+ rf_send_at_cmd("AT+ECSRA=2,0,1,0,1,0", MSG_ECSRA);
+ break;
+ }
+ case MSG_EWMPOLICY_WCDMA: {
+ LOG_D(LOG_TAG, "AT+EWMPOLICY=0 send succeed");
+ LOG_D(LOG_TAG, "send AT+ECSRA=2,1,0,1,1,0 ...");
+ rf_send_at_cmd("AT+ECSRA=2,1,0,1,1,0", MSG_ECSRA);
+ break;
+ }
+ case MSG_ECSRA: {
+ LOG_D(LOG_TAG, "AT+ECSRA send succeed");
+ turnOffRf();
+ break;
+ }
+ case MSG_START_TX:{
+ if (msg->e == RIL_E_SUCCESS) {
+ LOG_D(LOG_TAG, "start cmd ok");
+ if (utils::is93Modem() && mCurrectRatInfo && !mCurrectRatInfo->getRatCmdPowerRead().empty()) {
+ LOG_D(LOG_TAG,"start read cmd: %s", mCurrectRatInfo->getRatCmdPowerRead().c_str());
+ rf_send_at_cmd(mCurrectRatInfo->getRatCmdPowerRead(), MSG_READ_POWER);
+ } else {
+ LOG_D(LOG_TAG, "don't read");
+ txTestStop(MSG_NEXT_RAT);
+ }
+ } else {
+ LOG_D(LOG_TAG, "start cmd failed");
+ emResultNotifyWithDone(mCurrectRatInfo->getRatName() + " start cmd failed\n");
+ }
+ break;
+ }
+ case MSG_READ_POWER:{
+ mTestDurationSended += mReadbackInterval;
+ if (mTestDurationSended >= mTestDuration) {
+ if (msg->e == RIL_E_SUCCESS) {
+ LOG_D(LOG_TAG, "read tx power succeed");
+ if(m_rawUrc){
+ txTestStop(MSG_NEXT_RAT);
+ m_rawUrc = false;
+ } else {
+ std::thread thread_stop(&RfDesenseTxTest::tx_stop, m_instance);
+ thread_stop.detach();
+ }
+ } else {
+ LOG_D(LOG_TAG, "read tx power failed");
+ emResultNotifyWithDone(mCurrectRatInfo->getRatName() + " read tx power failed\n");
+ }
+ mTestDurationSended = 0;
+ } else {
+ if (utils::is93Modem() && mCurrectRatInfo && !mCurrectRatInfo->getRatCmdPowerRead().empty()) {
+ LOG_D(LOG_TAG,"(sencond)start read cmd: %s", mCurrectRatInfo->getRatCmdPowerRead().c_str());
+ rf_send_at_cmd(mCurrectRatInfo->getRatCmdPowerRead(), MSG_READ_POWER);
+ } else {
+ LOG_D(LOG_TAG,"(sencond)start read cmd fail");
+ }
+ }
+ break;
+ }
+ case MSG_NEXT_RAT: {
+ if (msg->e == RIL_E_SUCCESS) {
+ std::string rat = mCurrectRatInfo->getRatName();
+ LOG_D(LOG_TAG, "stop(%s) cmd ok", rat.c_str());
+ mCurrectRatInfo = getCurrectRatInfo();
+ if (mCurrectRatInfo) {
+ LOG_D(LOG_TAG, "error, mCurrectRatInfo should null ");
+ }
+ emResultNotifyWithDone(str_msg + "send all rat done\n");
+ str_msg = "";
+ mState = STATE_STOPPED;
+ for (int i = 0; i < mRatList.size(); i++) {
+ mRatList[i]->setRatSendState(false);
+ mRatList[i]->setRatCheckState(false);
+ }
+// if(rat == mRatName[1] || rat == mRatName[2]) {
+// if(utils::is93Modem()){
+// utils::mtk_property_set("vendor.ril.mux.report.case", "2");
+// utils::mtk_property_set("vendor.ril.muxreport", "1");
+// }else {
+// emSendATCommand("AT+CFUN=1,1");
+// }
+// trm_flag = true;
+// } else {
+// turnOnRf();
+// }
+ turnOnRf();
+ trm_flag = true;
+ unregister_response_oem_hook_raw();
+ unregisterOnUnsolOemHookRaw();
+ } else {
+ LOG_D(LOG_TAG, "stop cmd failed");
+ emResultNotifyWithDone(mCurrectRatInfo->getRatName() + " stop cmd failed \n");
+ }
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+void RfDesenseTxTest::RfRequestHandler::handleMessage(const Message& message) {
+ LOG_D(LOG_TAG, "handleMessage msg->mMsgType: %d", mMsg->mMsgType);
+ if(mTx != NULL) {
+ mTx->emRfDesenseAtCmdHandle(mMsg);
+ } else {
+ LOG_D(LOG_TAG, "handleMessage mTx is null");
+ }
+}
+
+void RfDesenseTxTest::handle_gsm_para(const std::string& name, int last_pos,
+ const std::string& sub_name) {
+ bool flag = false;
+ std::shared_ptr<RfDesenseTxTestGsm> gsm =
+ RfDesenseTxTestGsm::get_instance();
+ if (name == rfdesense_gsm_sub[INDEX_GSM_SUB_BAND].name) {
+ flag = gsm->set_band(last_pos);
+ } else if (name == rfdesense_gsm_sub[INDEX_GSM_SUB_CHANNEL].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ gsm->show_channel();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = gsm->set_channel(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_gsm_sub[INDEX_GSM_SUB_POWER].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ gsm->show_power();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = gsm->set_power(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_gsm_sub[INDEX_GSM_SUB_AFC].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ gsm->show_afc();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = gsm->set_afc(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_gsm_sub[INDEX_GSM_SUB_TSC].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ gsm->show_tsc();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = gsm->set_tsc(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_gsm_sub[INDEX_GSM_SUB_PATTERN].name) {
+ flag = gsm->set_pattern(last_pos);
+ }
+
+ if (flag) {
+ mRatList[INDEX_GSM]->setRatCmdStart(gsm->get_command());
+ mRatList[INDEX_GSM]->setRatband(gsm->get_band());
+ mRatList[INDEX_GSM]->setRatPowerSet(gsm->get_power());
+ save(INDEX_GSM);
+ }
+}
+
+void RfDesenseTxTest::handle_tdscdma_para(const std::string& name, int last_pos,
+ const std::string& sub_name) {
+ //"TDSCDMA"
+ bool flag = false;
+ std::shared_ptr<RfDesenseTxTestTd> tdscdma = std::make_shared<
+ RfDesenseTxTestTd>(utils::MODEM_TDSCDMA);
+ if (name == rfdesense_tdscdma_sub[INDEX_3G_SUB_BAND].name) {
+ flag = tdscdma->set_band(last_pos);
+ } else if (name == rfdesense_tdscdma_sub[INDEX_3G_SUB_CHANNEL].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ tdscdma->show_channel();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = tdscdma->set_channel(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_tdscdma_sub[INDEX_3G_SUB_POWER].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ tdscdma->show_power();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = tdscdma->set_power(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else {
+ LOG_D(LOG_TAG, "logic error");
+ }
+
+ if (flag) {
+ mRatList[INDEX_TDSCDMA]->setRatCmdStart(tdscdma->get_command());
+ mRatList[INDEX_TDSCDMA]->setRatband(tdscdma->get_band());
+ mRatList[INDEX_TDSCDMA]->setRatPowerSet(tdscdma->get_power());
+ save(INDEX_TDSCDMA);
+ }
+}
+
+void RfDesenseTxTest::handle_wcdma_para(const std::string& name, int last_pos,
+ const std::string& sub_name) {
+ //"WCDMA"
+ bool flag = false;
+ std::shared_ptr<RfDesenseTxTestTd> wcdma = std::make_shared<
+ RfDesenseTxTestTd>(utils::MODEM_WCDMA);
+ if (name == rfdesense_wcdma_sub[INDEX_3G_SUB_BAND].name) {
+ flag = wcdma->set_band(last_pos);
+ } else if (name == rfdesense_wcdma_sub[INDEX_3G_SUB_CHANNEL].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ wcdma->show_channel();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = wcdma->set_channel(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_wcdma_sub[INDEX_3G_SUB_POWER].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ wcdma->show_power();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = wcdma->set_power(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else {
+ LOG_D(LOG_TAG, "logic error");
+ }
+
+ if (flag) {
+ mRatList[INDEX_WCDMA]->setRatCmdStart(wcdma->get_command());
+ mRatList[INDEX_WCDMA]->setRatband(wcdma->get_band());
+ mRatList[INDEX_WCDMA]->setRatPowerSet(wcdma->get_power());
+ save(INDEX_WCDMA);
+ }
+}
+
+void RfDesenseTxTest::handle_lte_fdd_para(const std::string& name, int last_pos,
+ const std::string& sub_name) {
+ //LTE(FDD)
+ bool flag = false;
+ std::shared_ptr<RfDesenseTxTestLte> fdd = std::make_shared<
+ RfDesenseTxTestLte>(utils::MODEM_LTE_FDD);
+ if (name == rfdesense_fdd_sub[INDEX_FDD_SUB_MODE].name) {
+ flag = fdd->set_mode(last_pos);
+ } else if (name == rfdesense_fdd_sub[INDEX_FDD_SUB_BAND].name) {
+ flag = fdd->set_band(last_pos);
+ } else if (name == rfdesense_fdd_sub[INDEX_FDD_SUB_BANDWITH].name) {
+ flag = fdd->set_bandwith(last_pos);
+ } else if (name == rfdesense_fdd_sub[INDEX_FDD_SUB_FREQ].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ fdd->show_freq();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = fdd->set_freq(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_fdd_sub[INDEX_FDD_SUB_START].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ fdd->show_start();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = fdd->set_start(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_fdd_sub[INDEX_FDD_SUB_LENGTH].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ fdd->show_length();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = fdd->set_length(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_fdd_sub[INDEX_FDD_SUB_MCS].name) {
+ flag = fdd->set_mcs(last_pos);
+ } else if (name == rfdesense_fdd_sub[INDEX_FDD_SUB_POWER].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ fdd->show_power();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = fdd->set_power(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+
+ if (flag) {
+ mRatList[INDEX_LTE_FDD]->setRatCmdStart(fdd->get_command());
+ mRatList[INDEX_LTE_FDD]->setRatband(fdd->get_band());
+ mRatList[INDEX_LTE_FDD]->setRatPowerSet(fdd->get_power());
+ save(INDEX_LTE_FDD);
+ }
+}
+
+void RfDesenseTxTest::handle_lte_tdd_para(const std::string& name, int last_pos,
+ const std::string& sub_name) {
+ //LTE(TDD)
+ bool flag = false;
+ std::shared_ptr<RfDesenseTxTestLte> tdd = std::make_shared<
+ RfDesenseTxTestLte>(utils::MODEM_LTE_TDD);
+ if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_MODE].name) {
+ flag = tdd->set_mode(last_pos);
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_BAND].name) {
+ flag = tdd->set_band(last_pos);
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_BANDWIDTH].name) {
+ flag = tdd->set_bandwith(last_pos);
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_FREQ].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ tdd->show_freq();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = tdd->set_freq(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_CONFIG].name) {
+ flag = tdd->set_tdd_config(last_pos);
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_SPECIAL].name) {
+ flag = tdd->set_tdd_special(last_pos);
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_START].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ tdd->show_start();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = tdd->set_start(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_LENGTH].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ tdd->show_length();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = tdd->set_length(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_MCS].name) {
+ flag = tdd->set_mcs(last_pos);
+ } else if (name == rfdesense_tdd_sub[INDEX_TDD_SUB_POWER].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ tdd->show_power();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = tdd->set_power(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+
+ if (flag) {
+ mRatList[INDEX_LTE_TDD]->setRatCmdStart(tdd->get_command());
+ mRatList[INDEX_LTE_TDD]->setRatband(tdd->get_band());
+ mRatList[INDEX_LTE_TDD]->setRatPowerSet(tdd->get_power());
+ save(INDEX_LTE_TDD);
+ }
+}
+
+void RfDesenseTxTest::handle_cdma_evdo_para(const std::string& name,
+ int last_pos, const std::string& sub_name) {
+ //CDMA(EVDO)
+ bool flag = false;
+ std::shared_ptr<RfDesenseTxTestCdma> evdo = std::make_shared<
+ RfDesenseTxTestCdma>(utils::MODEM_CDMA_EVDO);
+ if (name == rfdesense_cdma_sub[INDEX_CDMA_SUB_BAND].name) {
+ flag = evdo->set_band(last_pos);
+ } else if (name == rfdesense_cdma_sub[INDEX_CDMA_SUB_CHANNEL].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ evdo->show_channel();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = evdo->set_channel(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_cdma_sub[INDEX_CDMA_SUB_MODULATION].name) {
+ flag = evdo->set_modulation(last_pos);
+ } else if (name == rfdesense_cdma_sub[INDEX_CDMA_SUB_POWER].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ evdo->show_power();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = evdo->set_power(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ }
+
+ if (flag) {
+ mRatList[INDEX_CDMA_EVDO]->setRatCmdStart(evdo->get_command());
+ mRatList[INDEX_CDMA_EVDO]->setRatband(evdo->get_band());
+ mRatList[INDEX_CDMA_EVDO]->setRatPowerSet(evdo->get_power());
+ save(INDEX_CDMA_EVDO);
+ }
+}
+
+void RfDesenseTxTest::handle_cdma_1X_para(const std::string& name, int last_pos,
+ const std::string& sub_name) {
+ //CDMA(1X)
+ bool flag = false;
+ std::shared_ptr<RfDesenseTxTestCdma> cdma_1x = std::make_shared<
+ RfDesenseTxTestCdma>(utils::MODEM_CDMA_1X);
+ if (name == rfdesense_cdma_sub[INDEX_CDMA_SUB_BAND].name) {
+ flag = cdma_1x->set_band(last_pos);
+ } else if (name == rfdesense_cdma_sub[INDEX_CDMA_SUB_CHANNEL].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ cdma_1x->show_channel();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = cdma_1x->set_channel(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ } else if (name == rfdesense_cdma_sub[INDEX_CDMA_SUB_MODULATION].name) {
+ flag = cdma_1x->set_modulation(last_pos);
+ } else if (name == rfdesense_cdma_sub[INDEX_CDMA_SUB_POWER].name) {
+ if (sub_name == set_get[0].name) {
+ //get
+ cdma_1x->show_power();
+ } else if (sub_name == set_get[1].name) {
+ // set
+ if (mCurrentSettingsValues.size() > 0) {
+ flag = cdma_1x->set_power(mCurrentSettingsValues[0]);
+ } else {
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size is 0");
+ em_result_notify_error("please input set values, now, only select the set item. value is empty");
+ }
+ } else {
+ LOG_D(LOG_TAG, "error");
+ }
+ }
+
+ if (flag) {
+ mRatList[INDEX_CDMA_1X]->setRatCmdStart(cdma_1x->get_command());
+ mRatList[INDEX_CDMA_1X]->setRatband(cdma_1x->get_band());
+ mRatList[INDEX_CDMA_1X]->setRatPowerSet(cdma_1x->get_power());
+ save(INDEX_CDMA_1X);
+ }
+}
+
+bool RfDesenseTxTest::handle_show_default(const std::string& standard) {
+ //show default
+ if (standard == sub_tx_test[INDEX_GSM].name) {
+ //"GSM"
+ std::shared_ptr<RfDesenseTxTestGsm> gsm =
+ RfDesenseTxTestGsm::get_instance();
+ gsm->show_default();
+ } else if (standard == sub_tx_test[INDEX_TDSCDMA].name) {
+ //"TDSCDMA"
+ std::shared_ptr<RfDesenseTxTestTd> tdscdma = std::make_shared<
+ RfDesenseTxTestTd>(utils::MODEM_TDSCDMA);
+ tdscdma->show_default();
+ } else if (standard == sub_tx_test[INDEX_WCDMA].name) {
+ //"WCDMA"
+ std::shared_ptr<RfDesenseTxTestTd> wcdma = std::make_shared<
+ RfDesenseTxTestTd>(utils::MODEM_WCDMA);
+ wcdma->show_default();
+ } else if (standard == sub_tx_test[INDEX_LTE_FDD].name) {
+ //LTE(FDD)
+ std::shared_ptr<RfDesenseTxTestLte> fdd = std::make_shared<
+ RfDesenseTxTestLte>(utils::MODEM_LTE_FDD);
+ fdd->show_default();
+ } else if (standard == sub_tx_test[INDEX_LTE_TDD].name) {
+ //LTE(TDD)
+ std::shared_ptr<RfDesenseTxTestLte> tdd = std::make_shared<
+ RfDesenseTxTestLte>(utils::MODEM_LTE_TDD);
+ tdd->show_default();
+ } else if ((standard == sub_tx_test[INDEX_CDMA_EVDO].name)
+ && utils::isC2KSupport()) {
+ //CDMA(EVDO)
+ std::shared_ptr<RfDesenseTxTestCdma> evdo = std::make_shared<
+ RfDesenseTxTestCdma>(utils::MODEM_CDMA_EVDO);
+ evdo->show_default();
+ } else if ((standard == sub_tx_test[INDEX_CDMA_1X].name)
+ && utils::isC2KSupport()) {
+ //CDMA(1X)
+ std::shared_ptr<RfDesenseTxTestCdma> cdma_1x = std::make_shared<
+ RfDesenseTxTestCdma>(utils::MODEM_CDMA_1X);
+ cdma_1x->show_default();
+ } else {
+ LOG_D(LOG_TAG, "invaild INPUT");
+ return false;
+ }
+ return true;
+}
+
+bool RfDesenseTxTest::handle_para(int len, int classid, int propertyid,int operatorid, const std::string& standard, int* item) {
+ if (len < 5) {
+ LOG_D(LOG_TAG, "logic error");
+ return false;
+ }
+ LOG_D(LOG_TAG, "len: %d, classid: %d, propertyid: %d, operatorid: %d, standard: %s", len, classid,propertyid, operatorid, standard.c_str());
+ int name_pos = item[3];
+ int last_pos = item[4];
+ std::string name =
+ desense_test[classid].subarray[propertyid].subarray[operatorid].subarray[name_pos].name;
+ std::string sub_name =
+ desense_test[classid].subarray[propertyid].subarray[operatorid].subarray[name_pos].subarray[last_pos].name;
+ LOG_D(LOG_TAG, "name_pos: %d, last_pos: %d, name: %s, sub_name: %s", name_pos, last_pos,name.c_str(), sub_name.c_str());
+ if (standard == sub_tx_test[INDEX_GSM].name) {
+ //"GSM"
+ handle_gsm_para(name, last_pos, sub_name);
+ } else if (standard == sub_tx_test[INDEX_TDSCDMA].name) {
+ //"TDSCDMA"
+ handle_tdscdma_para(name, last_pos, sub_name);
+ } else if (standard == sub_tx_test[INDEX_WCDMA].name) {
+ //"WCDMA"
+ handle_wcdma_para(name, last_pos, sub_name);
+ } else if (standard == sub_tx_test[INDEX_LTE_FDD].name) {
+ //LTE(FDD)
+ handle_lte_fdd_para(name, last_pos, sub_name);
+ } else if (standard == sub_tx_test[INDEX_LTE_TDD].name) {
+ //LTE(TDD)
+ handle_lte_tdd_para(name, last_pos, sub_name);
+ } else if ((standard == sub_tx_test[INDEX_CDMA_EVDO].name)
+ && utils::isC2KSupport()) {
+ //CDMA(EVDO)
+ handle_cdma_evdo_para(name, last_pos, sub_name);
+ } else if ((standard == sub_tx_test[INDEX_CDMA_1X].name)
+ && utils::isC2KSupport()) {
+ //CDMA(1X)
+ handle_cdma_1X_para(name, last_pos, sub_name);
+ } else {
+ LOG_D(LOG_TAG, "invaild INPUT");
+ return false;
+ }
+ return true;
+}
+
+bool RfDesenseTxTest::handle_start(const std::string& standard) {
+ //start
+ mState = STATE_STARTED;
+ if (standard == sub_tx_test[INDEX_GSM].name) {
+ //"GSM"
+ mRatList[INDEX_GSM]->setRatCheckState(true);
+ } else if (standard == sub_tx_test[INDEX_TDSCDMA].name) {
+ //"TDSCDMA"
+ mRatList[INDEX_TDSCDMA]->setRatCheckState(true);
+ } else if (standard == sub_tx_test[INDEX_WCDMA].name) {
+ //"WCDMA"
+ mRatList[INDEX_WCDMA]->setRatCheckState(true);
+ } else if (standard == sub_tx_test[INDEX_LTE_FDD].name) {
+ //LTE(FDD)
+ mRatList[INDEX_LTE_FDD]->setRatCheckState(true);
+ } else if (standard == sub_tx_test[INDEX_LTE_TDD].name) {
+ //LTE(TDD)
+ mRatList[INDEX_LTE_TDD]->setRatCheckState(true);
+ } else if ((standard == sub_tx_test[INDEX_CDMA_EVDO].name)
+ && utils::isC2KSupport()) {
+ //CDMA(EVDO)
+ mRatList[INDEX_CDMA_EVDO]->setRatCheckState(true);
+ } else if ((standard == sub_tx_test[INDEX_CDMA_1X].name)
+ && utils::isC2KSupport()) {
+ //CDMA(1X)
+ mRatList[INDEX_CDMA_1X]->setRatCheckState(true);
+ } else {
+ LOG_D(LOG_TAG, "invaild INPUT");
+ return false;
+ }
+ return true;
+}
+
+int RfDesenseTxTest::emRfDesenseStart(int len,int *item,int multilen,char *value[]) {
+ LOG_D(LOG_TAG,"emRfDesenseStart called");
+ update_rat();
+ if (len < 3) {
+ LOG_D(LOG_TAG, "please select redesense get or set");
+ return -1;
+ }
+ int classid = item[0];
+ int propertyid = item[1];
+ int operatorid = item[2];
+ mCurrentSettingsValues.clear();
+ for(int i = 0; i < multilen; i++ ) {
+ mCurrentSettingsValues.push_back(value[i]);
+ LOG_D(LOG_TAG, "value[%d]: %s", i, value[i]);
+ }
+ LOG_D(LOG_TAG, "mCurrentSettingsValues size: " + mCurrentSettingsValues.size());
+ em_arry_t *subarry = &(desense_test[classid].subarray[propertyid]);
+ std::string standard = subarry->name;
+ LOG_D(LOG_TAG,"rfdesense property name: %s, operatorid: %d",subarry->name, operatorid);
+ switch (operatorid) {
+ case 0: { //start
+ str_msg = "";
+ if(!handle_start(standard)) return -1;
+ //emEnableRadio(false);
+ registerOnUnsolOemHookRaw(m_instance);
+ register_response_oem_hook_raw(m_instance);
+ std::thread thread_start(&RfDesenseTxTest::emRfDesenseThread, m_instance, operatorid);
+ thread_start.detach();
+ break;
+ }
+ case 1: {
+ if(!handle_para(len, classid, propertyid, operatorid, standard, item)) return -1;
+ break;
+ }
+ case 2: { //show default
+ if(!handle_show_default(standard)) return -1;
+ break;
+ }
+ default:
+ LOG_D(LOG_TAG, "logic eror ");
+ return -1;
+ }
+ return (0);
+}
+
+std::shared_ptr<RfDesenseRatInfo> RfDesenseTxTest::getCurrectRatInfo() {
+ int index;
+ for (index = 0; index < mRatList.size(); index++) {
+ if (mRatList[index]->getRatCheckState()) {
+ if (mRatList[index]->getRatSendState()) {
+ continue;
+ }
+ mCurrectRatInfo = mRatList[index];
+ break;
+ }
+ }
+ return mCurrectRatInfo;
+}
+
+void RfDesenseTxTest::turnOffRf(){
+ LOG_D(LOG_TAG, "turn off rf....");
+ mIsModemNotEnabled = false;
+ emEnableRadio(false, phone_id);
+ if(utils::is_support_dsds()){
+ emEnableRadio(false, phone_id == 0? 1:0);
+ }
+}
+
+void RfDesenseTxTest::turnOnRf() {
+ LOG_D(LOG_TAG, "turn on rf....");
+ mIsModemEnabled = false;
+ emEnableRadio(true, phone_id);
+ if(utils::is_support_dsds()){
+ emEnableRadio(true, phone_id == 0? 1:0);
+ }
+}
+
+void RfDesenseTxTest::initRatList() {
+ phone_id = Radio_capability_switch_util::get_main_capability_phone_id();
+ mState = STATE_NONE;
+ if(!utils::is93Modem()){
+ mRatCmdStart[5] = DEFAULT_CDMA_EVDO_ATCMD_93before;
+ mRatCmdStop[5] = "AT+ECRFTX=0";
+ }
+
+ if(utils::is90Modem()) {
+ mRatCmdSwitch[5] = "AT^PREFMODE=4";
+ mRatCmdSwitch[6] = "AT^EIRATMODE=2";
+ }
+ for (int i = 0; i < mRatName.size(); i++) {
+ std::shared_ptr<RfDesenseRatInfo> Info = std::make_shared<RfDesenseRatInfo>();
+ Info->setRatName(mRatName[i]);
+ Info->setRatCmdStart(mRatCmdStart[i]);
+ Info->setRatCmdStop(mRatCmdStop[i]);
+ Info->setRatCmdSwitch(mRatCmdSwitch[i]);
+ Info->setRatPowerRead(mRatCmdPowerRead[i]);
+ Info->setRatband(mRatBand[i]);
+ Info->setRatPowerSet(mRatPowerSet[i]);
+ Info->setRatCheckState(false);
+ Info->setRatSendState(false);
+ mRatList.push_back(Info);
+ if(!(utils::isC2KSupport())){
+ if (i == 4) {
+ break;
+ }
+ }
+ }
+}
+
+void RfDesenseTxTest::update_rat() {
+ for(int i=0; i < mRatList.size(); i++){
+ mRatList[i]->setRatName(mRatName[i]);
+ mRatList[i]->setRatCmdStart(mRatCmdStart[i]);
+ mRatList[i]->setRatCmdStop(mRatCmdStop[i]);
+ mRatList[i]->setRatCmdSwitch(mRatCmdSwitch[i]);
+ mRatList[i]->setRatPowerRead(mRatCmdPowerRead[i]);
+ mRatList[i]->setRatband(mRatBand[i]);
+ mRatList[i]->setRatPowerSet(mRatPowerSet[i]);
+ mRatList[i]->setRatCheckState(false);
+ mRatList[i]->setRatSendState(false);
+ if(!(utils::isC2KSupport())){
+ if (i == 4) {
+ break;
+ }
+ }
+ }
+}
+void RfDesenseTxTest::save(int index) {
+ mRatCmdStart[index] = mRatList[index]->getRatCmdStart();
+ mRatBand[index] = mRatList[index]->getRatband();
+ mRatPowerSet[index] = mRatList[index]->getRatPowerSet();
+}