static void read_preferred_magnitude(int *pUpper, int *pLower)
{
char *pMagLower = NULL, *pMagUpper = NULL;
char uMagLower[64], uMagUpper[64];
*pUpper = 0;
*pLower = 0;
memset(uMagLower, 0, sizeof(uMagLower));
memset(uMagUpper, 0, sizeof(uMagUpper));
sprintf(uMagLower, "Lower.Magnitude.Headset");
sprintf(uMagUpper, "Upper.Magnitude.Headset");
pMagLower = ftm_get_prop(uMagLower);
pMagUpper = ftm_get_prop(uMagUpper);
if (pMagLower != NULL && pMagUpper != NULL)
{
*pLower = (int)atoi(pMagLower);
*pUpper = (int)atoi(pMagUpper);
ALOGD("Lower.Magnitude:%d,Upper.Magnitude:%d\n", *pLower, *pUpper);
}
else
{
ALOGD("Lower/Upper.Magnitude can not get\n");
}
}
static bool read_preferred_recorddump(void)
{
char *pDump = NULL;
char uName[64];
memset(uName, 0, sizeof(uName));
sprintf(uName, "Audio.Record.Dump");
pDump = ftm_get_prop(uName);
ALOGD("pDump:%s", pDump);
if (pDump != NULL)
{
if (!strcmp(pDump, "1"))
{
ALOGD("Dump record data");
return true;
}
else
{
ALOGD("No need to dump record data");
return false;
}
}
else
{
ALOGD("Dump record prop can't get");
return false;
}
}
int vibrator_entry(struct ftm_param *param, void *priv)
{
char *bPhone = NULL;
struct mVibrator *mc = (struct mVibrator *)priv;
bPhone = ftm_get_prop("Vibrator.PhoneAutoTest");
if ((bPhone != NULL) && (atoi(bPhone) == 1)) // Auto detect
{
vibrator_autotest_entry(param, priv);
item_testing = 0; // for Auto test, no need to send AT+VIBRATOR=STOP
}
else
{
vibrator_manual_entry(param, (void*)(mc->mod));
}
return 0;
}
int headset_entry(struct ftm_param *param, void *priv)
{
struct headset *mc = (struct headset *)priv;
char *outputType = NULL;
if (FTM_AUTO_ITEM == param->test_type)
{
outputType = ftm_get_prop("Audio.Auto.OutputType");
ALOGD("Audio.Auto.OutputType = %s\n", outputType);
if (outputType == NULL)
{
// @ default PCBA level, Headset receiver -> headset mic
mc->isPhoneTest = false;
mAudio_headset_auto_entry(param, priv);
}
else
{
if (atoi(outputType) == 0) // @ PCBA level, Headset receiver -> headset mic
{
mc->isPhoneTest = false;
mAudio_headset_auto_entry(param, priv);
}
else if (atoi(outputType) == 1) //@ Phone level, Headset receiver -> phone mic
{
mc->isPhoneTest = true;
headset_PhoneTest_entry(param, priv);
}
else if (atoi(outputType) == 2) // @ Phone level, THD, Headset receiver-->phone mic
{
mc->isPhoneTest = true;
headset_thd_entry(param, priv);
}
}
}
else if (FTM_MANUAL_ITEM == param->test_type)
{
mAudio_headset_manual_entry(param, priv);
}
return 0;
}
int read_preferred_para(const char *pstr,int default_value)
{
int value = default_value;
unsigned int i = 0;
char *pVal = NULL;
if(pstr== NULL)
{
LOGD(TAG "preferred_receiver_para error %s", pstr);
return 0;
}
pVal = ftm_get_prop(pstr);
if (pVal != NULL){
value = (int)atoi(pVal);
LOGD(TAG "preferred_receiver_para %s- %d \n",pstr,value);
}
else{
LOGD(TAG "preferred_receiver_para can't get %s , use default %d\n", pstr, value);
}
return value;
}
/********************
* Function Declaration
*********************/
int matv_read_preferred_para(const char *pstr)
{
int value = 0;
unsigned int i = 0;
char *pTime = NULL;
if(pstr== NULL)
{
ALOGD("matv_read_preferred_para error %s", pstr);
return 0;
}
pTime = ftm_get_prop(pstr);
if (pTime != NULL){
value = (int)atoi(pTime);
ALOGD("preferred_receiver_para %s- %d \n",pstr,value);
}
else{
ALOGD("preferred_receiver_para can't get %s\n", pstr);
}
return value;
}
static void read_preferred_freq()
{
uint16_t tmp_freq;
unsigned int i = 0;
char *pFreq = NULL;
char channel_no[64]; //max path
for(i = 0; i < sizeof(fmtx_freq_list)/sizeof(fmtx_freq_list[0]); i++)
{
memset(channel_no, 0, sizeof(channel_no));
sprintf(channel_no, "FMTX.CH%d", i+1);
pFreq = ftm_get_prop(channel_no);
if(pFreq != NULL){
fmtx_freq_list[i] = (uint16_t)atoi(pFreq);
LOGD("preferred_freq: %d, %d\n", i, fmtx_freq_list[i]);
}
else
{
LOGD("preferred_freq %d can't get\n", i);
}
}
}
//#else
int mAudio_headset_manual_entry(struct ftm_param *param, void *priv)
{
char *ptr;
int chosen;
bool exit = false;
char *inputType = NULL;
struct headset *hds = (struct headset *)priv;
struct textview *tv;
struct itemview *iv;
int privChosen = -1;
LOGD(TAG "%s\n", __FUNCTION__);
init_text(&hds->title, param->name, COLOR_YELLOW);
init_text(&hds->text, &hds->info[0], COLOR_YELLOW);
init_text(&hds->left_btn, "Fail", COLOR_YELLOW);
init_text(&hds->center_btn, "Pass", COLOR_YELLOW);
init_text(&hds->right_btn, "Back", COLOR_YELLOW);
headset_update_info(hds, hds->info);
hds->exit_thd = false;
if (!hds->iv)
{
iv = ui_new_itemview();
if (!iv)
{
LOGD(TAG "No memory");
return -1;
}
hds->iv = iv;
}
iv = hds->iv;
iv->set_title(iv, &hds->title);
if (get_is_ata() == 0)
{
iv->set_items(iv, headset_items, 0);
}
else
{
iv->set_items(iv, headset_items_ex, 0);
}
iv->set_text(iv, &hds->text);
Common_Audio_init();
pthread_create(&hds->headset_update_thd, NULL, headset_update_iv_thread, priv);
inputType = ftm_get_prop("Audio.Manual.InputType");
if (inputType != NULL && (atoi(inputType) == 0 || atoi(inputType) == 1 || atoi(inputType) == 2 || atoi(inputType) == 3))
{
// @ input != NULL, PC command control mode
ALOGD("Audio.Manual.InputType = %s", inputType);
iv->redraw(iv);
PhoneMic_EarphoneLR_Loopback(MIC1_OFF);
usleep(20000);
if (atoi(inputType) == 1)
{
ALOGD("Set Mic1 on");
PhoneMic_EarphoneLR_Loopback(MIC1_ON);
}
else if (atoi(inputType) == 2)
{
ALOGD("Set Mic2 on");
PhoneMic_EarphoneLR_Loopback(MIC2_ON);
}
else if (atoi(inputType) == 3)
{
ALOGD("Set headset Mic on");
HeadsetMic_EarphoneLR_Loopback(1, 1);
}
hds->exit_thd = true;
pthread_join(hds->headset_update_thd, NULL);
hds->mod->test_result = FTM_TEST_PASS;
if (atoi(inputType) == 0)
{
ALOGD("Audio Deinit");
Common_Audio_deinit();
}
}
else
{
// Original manual operating mode
do
{
chosen = iv->run(iv, &exit);
switch (chosen)
{
case ITEM_RINGTONE:
if (!hds->avail || privChosen == ITEM_RINGTONE)
{
break;
}
if (privChosen == ITEM_HEADSET_MIC && hds->Headset_mic)
{
HeadsetMic_EarphoneLR_Loopback(0, 1);
}
usleep(20000);
EarphoneTest(1);
privChosen = ITEM_RINGTONE;
break;
case ITEM_MIC1:
if (!hds->avail || privChosen == ITEM_MIC1)
{
break;
}
if (privChosen == ITEM_RINGTONE)
{
EarphoneTest(0);
}
else if (privChosen == ITEM_MIC2)
{
PhoneMic_EarphoneLR_Loopback(MIC2_OFF);
}
else if (privChosen == ITEM_HEADSET_MIC)
{
HeadsetMic_EarphoneLR_Loopback(0, 1);
}
usleep(20000);
PhoneMic_EarphoneLR_Loopback(MIC1_ON);
privChosen = ITEM_MIC1;
break;
case ITEM_MIC2:
if (!hds->avail || privChosen == ITEM_MIC2)
{
break;
}
if (privChosen == ITEM_RINGTONE)
{
EarphoneTest(0);
}
else if (privChosen == ITEM_MIC1)
{
PhoneMic_EarphoneLR_Loopback(MIC1_OFF);
}
else if (privChosen == ITEM_HEADSET_MIC)
{
HeadsetMic_EarphoneLR_Loopback(0, 1);
}
usleep(20000);
PhoneMic_EarphoneLR_Loopback(MIC2_ON);
privChosen = ITEM_MIC2;
break;
case ITEM_HEADSET_MIC:
if (!hds->avail || privChosen == ITEM_HEADSET_MIC || !hds->Headset_mic)
{
break;
}
if (privChosen == ITEM_RINGTONE)
{
EarphoneTest(0);
}
else if (privChosen == ITEM_MIC1)
{
PhoneMic_EarphoneLR_Loopback(MIC1_OFF);
}
else if (privChosen == ITEM_MIC2)
{
PhoneMic_EarphoneLR_Loopback(MIC2_OFF);
}
usleep(20000);
HeadsetMic_EarphoneLR_Loopback(1, 1);
privChosen = ITEM_HEADSET_MIC;
break;
case ITEM_PASS:
case ITEM_FAIL:
if (chosen == ITEM_PASS)
{
hds->mod->test_result = FTM_TEST_PASS;
}
else if (chosen == ITEM_FAIL)
{
hds->mod->test_result = FTM_TEST_FAIL;
}
exit = true;
break;
}
if (exit)
{
hds->exit_thd = true;
break;
}
}
while (1);
if (privChosen == ITEM_RINGTONE)
{
EarphoneTest(0);
}
if (privChosen == ITEM_MIC1)
{
PhoneMic_EarphoneLR_Loopback(MIC1_OFF);
}
if (privChosen == ITEM_MIC2)
{
PhoneMic_EarphoneLR_Loopback(MIC2_OFF);
}
if (privChosen == ITEM_HEADSET_MIC)
{
HeadsetMic_EarphoneLR_Loopback(0, 1);
}
pthread_join(hds->headset_update_thd, NULL);
Common_Audio_deinit();
}
return 0;
}
int gps_entry(struct ftm_param *param, void *priv)
{
char *ptr;
char *pTimeout=NULL;
int chosen;
bool exit = false;
struct gps_desc *gps = (struct gps_desc *)priv;
struct itemview *iv;
pTimeout = ftm_get_prop("GPS.TIMEOUT");
if(pTimeout != NULL )
{
timeout=atoi(pTimeout);
LOGD(TAG "timeout value is %d\n", timeout);
}
LOGD(TAG "%s\n", __FUNCTION__);
init_text(&gps->title, param->name, COLOR_YELLOW);
init_text(&gps->text, &gps->info[0], COLOR_YELLOW);
gps_update_info(gps, gps->info);
gps->exit_thd = false;
if (!gps->iv) {
iv = ui_new_itemview();
if (!iv) {
LOGD(TAG "No memory");
return -1;
}
gps->iv = iv;
}
iv = gps->iv;
iv->set_title(iv, &gps->title);
iv->set_items(iv, gps_items, 0);
iv->set_text(iv, &gps->text);
iv->start_menu(iv,0);
pthread_create(&gps->update_thd, NULL, gps_update_iv_thread, priv);
int wait_time = 10;
int init_try_time = 0;
while(!init_flag && wait_time)
{
LOGD(TAG" init_flag = %d, try time = %d\n", init_flag, ++init_try_time);
sleep(1);
--wait_time;
}
init_flag = 0;
wait_time = 10;
init_try_time = 0;
LOGD(TAG" init_flag = %d\n", init_flag);
iv->redraw(iv);
do{
//Auto test: only CTTFF
cttff = 1;
do{
usleep(1000000); //check status per sec
LOGD(TAG"after %d sec from test starting, we still can not see any SV\n", ttff);
}while(ttff <= timeout && !ttff_check_res);
if(ttff_check_res == 1){
LOGD(TAG"Test pass");
gps->mod->test_result = FTM_TEST_PASS;
}else{
LOGD(TAG"Test fail");
gps->mod->test_result = FTM_TEST_FAIL;
}
if(unlink("/data/misc/mtkgps.dat")!=0 )
LOGD(TAG "unlink mtkgps.dat error, error is %s\n", strerror(errno));
ttff_check_res = 0;
}while(0);
gps->exit_thd = true;
LOGD(TAG "%s, gps->exit_thd = true\n", __FUNCTION__);
#if 0
do {
chosen = iv->run(iv, &exit);
LOGD(TAG "%s, chosen = %d\n", __FUNCTION__, chosen);
switch (chosen) {
case ITEM_HTTFF:
httff = 1;
break;
case ITEM_CTTFF:
cttff = 1;
break;
case ITEM_PASS:
case ITEM_FAIL:
if (chosen == ITEM_PASS) {
gps->mod->test_result = FTM_TEST_PASS;
} else if (chosen == ITEM_FAIL) {
gps->mod->test_result = FTM_TEST_FAIL;
}
exit = true;
break;
}
if (exit) {
gps->exit_thd = true;
LOGD(TAG "%s, gps->exit_thd = true\n", __FUNCTION__);
break;
}
} while (1);
#endif
pthread_join(gps->update_thd, NULL);
return 0;
}
int vibrator_manual_entry(struct ftm_param *param, void *priv)
{
int chosen;
bool exit = false;
struct itemview *iv;
text_t title;
char* vibr_time = NULL;
struct ftm_module *mod = (struct ftm_module *)priv;
LOGD("%s\n", __FUNCTION__);
vibrator_test_exit = false;
iv = ui_new_itemview();
if (!iv) {
LOGD("No memory");
return -1;
}
init_text(&title, param->name, COLOR_YELLOW);
iv->set_title(iv, &title);
iv->set_items(iv, items, 0);
vibr_time = ftm_get_prop("Vibrator_Last_Time");
LOGD("%s: get vibrator last time=%s!\n", __FUNCTION__, vibr_time);
if(vibr_time != NULL)
{
vibrator_time = (uint32_t)atoi(vibr_time);
LOGD("%s: get vibrator last time=%d!\n", __FUNCTION__, vibrator_time);
}
else
{
LOGD("%s: get vibrator last time fail!\n", __FUNCTION__);
}
//#if defined(MTK_VIBSPK_SUPPORT)
if (IsFTMSupportVibSpk())
Common_Audio_init();
//#endif
pthread_create(&vibrator_thread, NULL, update_vibrator_thread, priv);
iv->start_menu(iv, 0);
iv->redraw(iv);
do {
if(param->test_type == FTM_MANUAL_ITEM){
chosen = iv->run(iv, &exit);
switch (chosen) {
case ITEM_PASS:
case ITEM_FAIL:
if (chosen == ITEM_PASS) {
mod->test_result = FTM_TEST_PASS;
} else if (chosen == ITEM_FAIL) {
mod->test_result = FTM_TEST_FAIL;
}
exit = true;
break;
}
if (exit) {
vibrator_test_exit = true;
break;
}
}
else{
if(vibrator_test_exit)
break;
}
} while (1);
//pthread_join(vibrator_thread, NULL);
// #if defined(MTK_VIBSPK_SUPPORT)
if (IsFTMSupportVibSpk())
Common_Audio_deinit();
// #endif
return 0;
}
