int at_send_command_to_data_channel(const char *command, ATResponse **pp_outResponse, RILChannelCtx *p_channel) { const char* line = NULL; int ret = writeline(command, p_channel); if (ret == 0) { p_channel->p_response = at_response_new(); do { line = readline(p_channel); if (line != NULL) RLOGI("readline: %s", line); else RLOGI("readline: EMPTY"); } while (line != NULL && !(strcmp(line, "OK") == 0 || strcmp(line, "NO CARRIER") == 0 || strStartsWith(line, "CONNECT") == 1 || strstr(line, "ERROR"))); if (line != NULL) { RLOGI("process line: %s", line); processLine(line, p_channel); if (pp_outResponse == NULL) { at_response_free(p_channel->p_response); } else { reverseIntermediates(p_channel->p_response); *pp_outResponse = p_channel->p_response; } return 0; } } return AT_ERROR_GENERIC; }
RILChannelCtx *openPPPDataChannel(int isBlocking) { RLOGI("openDataChannel"); RILChannelCtx* p_channel = &g_pppDataChannel; if (p_channel->fd > 0) closePPPDataChannel(); memset(p_channel, 0, sizeof(RILChannelCtx)); p_channel->fd = -1; /* fd of the AT channel */ int retryCounter = 0; int err = 0; while (p_channel->fd < 0 && retryCounter < 5) { do { RLOGI("set property for usb permission"); /* set this property than the permission of /dev/ttyACM0 will be set to 777 */ property_set("gsm.usb.ttyusb", "1"); if (isBlocking) p_channel->fd = open("/dev/ttyUSB0", O_RDWR); else p_channel->fd = open("/dev/ttyUSB0", O_RDWR | O_NONBLOCK); } while (p_channel->fd < 0 && errno == EINTR); if (p_channel->fd < 0) { perror ("opening AT interface. retrying..."); RLOGE("could not connect to %s: %s", "/dev/ttyUSB0", strerror(errno)); /* reduce polling time for usb connected */ sleep(1); /* never returns */ } else { struct termios ios; tcgetattr(p_channel->fd, &ios ); ios.c_lflag = 0; /* disable ECHO, ICANON, etc... */ ios.c_iflag = 0; tcsetattr(p_channel->fd, TCSANOW, &ios ); } ++retryCounter; } if (p_channel->fd < 0) { RLOGE("/dev/ttyUSB0 open failed"); return NULL; } else { RLOGI("/dev/ttyUSB0 open success"); p_channel->ATBufferCur = p_channel->ATBuffer; p_channel->myName = "PPP_CHANNEL"; p_channel->id = ++g_channelIndex; p_channel->unsolHandler = 0; p_channel->readerClosed = 0; p_channel->responsePrefix = NULL; p_channel->smsPDU = NULL; p_channel->p_response = NULL; } return &g_pppDataChannel; }
void purge_data_channel(RILChannelCtx *p_channel) { if (p_channel > 0 && p_channel->fd > 0) { const char* line = NULL; char buffer[64] = {0}; int count = 0; int readbyte = 0; while ((readbyte = read(p_channel->fd, buffer, 64)) > 0) { count += readbyte; } RLOGI("Total %d byte purged", count); } else { RLOGI("Channel not opened, not to purge"); } }
static void waitForClose() { RLOGI("[Emu]waitForClose in"); pthread_mutex_lock(&s_state_mutex); while (s_closed == 0) { RLOGI("[Emu]waitForClose while in"); pthread_cond_wait(&s_state_cond, &s_state_mutex); RLOGI("[Emu]waitForClose while out"); } pthread_mutex_unlock(&s_state_mutex); RLOGI("[Emu]waitForClose out"); }
int openDataChannel(char* deviceNote, int isBlocking, RILChannelCtx* p_channel, int channelId) { RLOGI("openDataChannel"); if (p_channel->fd > 0) closeDataChannel(p_channel); memset(p_channel, 0, sizeof(RILChannelCtx)); p_channel->fd = -1; /* fd of the AT channel */ int retryCounter = 0; int err = 0; while (p_channel->fd < 0 && retryCounter < 5) { do { RLOGI("set property for usb permission"); p_channel->fd = open(deviceNote, isBlocking? O_RDWR : (O_RDWR | O_NONBLOCK)); } while (p_channel->fd < 0 && errno == EINTR); if (p_channel->fd < 0) { perror ("opening AT interface. retrying..."); RLOGE("could not connect to %s: %s", "/dev/ttyUSB0", strerror(errno)); /* reduce polling time for usb connected */ sleep(1); /* never returns */ } else { struct termios ios; tcgetattr(p_channel->fd, &ios ); ios.c_lflag = 0; /* disable ECHO, ICANON, etc... */ ios.c_iflag = 0; tcsetattr(p_channel->fd, TCSANOW, &ios ); } ++retryCounter; } if (p_channel->fd < 0) { RLOGE("%s open failed", deviceNote); return -1; } else { RLOGI("%s open success", deviceNote); p_channel->ATBufferCur = p_channel->ATBuffer; p_channel->myName = deviceNote; p_channel->id = ++channelId; p_channel->unsolHandler = 0; p_channel->readerClosed = 0; p_channel->responsePrefix = NULL; p_channel->smsPDU = NULL; p_channel->p_response = NULL; } return 0; }
void asyncOperation(void* ptr, asyncHandler handler, asyncDestructor dtor, const char* operationID) //operationID for debug { //Run it right away to see if it finished instantly. auto res = handler(ptr); switch(res) { case ASYNC_OPERATION_COMPLETE: RLOGI("Async operation %s completed", operationID); break; case ASYNC_OPERATION_RUNNING: while(length == BUFFER_SIZE) { RLOGW("To many async operations in flight! %d", length); asyncOperationsProcess(); } asyncBuffer[length++] = (AsyncItem){ptr, handler, dtor, operationID}; break; case ASYNC_OPERATION_FAILURE: RLOGE("Async operation %s failed", operationID); break; default: RLOGE("Async operation %s returned invalid result %d", operationID, res); break; } }
void asyncOperationsProcess() { for(int i = 0; i < length; i++) { auto item = asyncBuffer[i]; auto res = item.handler(item.payload); switch(res) { case ASYNC_OPERATION_COMPLETE: asyncBuffer[i--] = asyncBuffer[--length]; item.dtor(item.payload); RLOGI("Async operation %s completed", item.operationID); break; case ASYNC_OPERATION_RUNNING: //Do nothing break; case ASYNC_OPERATION_FAILURE: RLOGE("Async operation %s failed", item.operationID); asyncBuffer[i--] = asyncBuffer[--length]; item.dtor(item.payload); break; default: RLOGE("Async operation %s returned invalid result %d", item.operationID, res); asyncBuffer[i--] = asyncBuffer[--length]; item.dtor(item.payload); break; } } }
void waitForTargetPPPStopped(RILChannelCtx *p_channel) { const char* line = NULL; int count = 0; p_channel->p_response = at_response_new(); while (count < 60) { line = readline(p_channel); if (line != NULL && strcmp(line, "NO CARRIER") == 0) { RLOGI("readline: %s [%d]", line, count); break; } else { RLOGI("Still wait for NO CARRIER [%d]", count); ++count; sleep(1); } } at_response_free(p_channel->p_response); }
/* Called on command or reader thread */ static void onATReaderClosed() { RLOGI("AT channel closed\n"); at_close(); s_closed = 1; setRadioState (RADIO_STATE_UNAVAILABLE); }
void closePPPDataChannel() { RILChannelCtx* p_channel = &g_pppDataChannel; RLOGI("closeDataChannel [%d, %d]", g_channelIndex, p_channel->fd); if (p_channel->fd >= 0) { close(p_channel->fd); } p_channel->fd = -1; }
/* Called on command or reader thread */ static void onATReaderClosed(RILChannelCtx *p_channel) { RLOGI("AT channel closed\n"); at_close(p_channel); assert(0); s_closed = 1; setRadioState (RADIO_STATE_UNAVAILABLE, getRILIdByChannelCtx(p_channel)); }
/*if(chmod(path, 0666) < 0 ) { RLOGD("chomod: system-error: '%s' (code: %d)", strerror(errno), errno); return NULL; }*/ if(symlink(path, s_mux_path[i]) < 0) { RLOGD("symlink: system-error: '%s' (code: %d)", strerror(errno), errno); return NULL; } ttys_index++; i++; } break; #endif default: usage(argv[0]); return NULL; } } RLOGI("while out %s\n", s_device_path); if (s_port < 0 && s_device_path == NULL && (s_device_range_begin < 0 || s_device_range_end < 0) ) { usage(argv[0]); return NULL; } pthread_attr_init (&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); // if (is_gemini_emulator){ // ret = pthread_create(&s_tid_mainloop, &attr, mainLoop_emulator, NULL); //}else{ ret = pthread_create(&s_tid_mainloop, &attr, mainLoop, NULL); // } return &s_callbacks; } #else /* RIL_SHLIB */ int main (int argc, char **argv) { int ret; int fd = -1; int opt; while ( -1 != (opt = getopt(argc, argv, "p:d:"))) { switch (opt) { case 'p': s_port = atoi(optarg); if (s_port == 0) { usage(argv[0]); } RLOGI("Opening loopback port %d\n", s_port); break; case 'd': s_device_path = optarg; RLOGI("Opening tty device %s\n", s_device_path); break; case 's': s_device_path = optarg; s_device_socket = 1; RLOGI("Opening socket %s\n", s_device_path); break; default: usage(argv[0]); } } if (s_port < 0 && s_device_path == NULL) { usage(argv[0]); } RIL_register(&s_callbacks); mainLoop(NULL); return 0; }
/* Called on command thread */ static void onATTimeout() { RLOGI("AT channel timeout; closing\n"); at_close(); s_closed = 1; /* FIXME cause a radio reset here */ setRadioState (RADIO_STATE_UNAVAILABLE); }
Resource platformLoadResource(const char* path) { RLOGI("Opening resource %s", path); auto externalPath = path::buildPath(gApp->activity->externalDataPath, path); auto file = fopen(externalPath.c_str(), "r+"); if(file == 0) { RLOGI("File is not external %s", path); return platformLoadInternalResource(path); } fseek( file, 0L, SEEK_END); auto length = ftell(file); rewind(file); auto buffer = new uint8_t[length]; fread(buffer, length, 1, file); fclose(file); return (Resource) { buffer, (uint32_t)length }; }
/* Called on command thread */ static void onATTimeout(RILChannelCtx *p_channel) { RLOGI("AT channel timeout; closing\n"); at_close(p_channel); assert(0); s_closed = 1; /* FIXME cause a radio reset here */ setRadioState (RADIO_STATE_UNAVAILABLE, getRILIdByChannelCtx(p_channel)); }
void closeDataChannel(RILChannelCtx* p_channel) { if (p_channel == NULL) { RLOGE("closeDataChannel invalid input argument"); return; } RLOGI("closeDataChannel [%d, %d]", p_channel->id, p_channel->fd); if (p_channel->fd >= 0) { close(p_channel->fd); } p_channel->fd = -1; }
Resource platformLoadAbsolutePath(const char* resourcePath) { auto file = fopen(resourcePath, "r+"); ASSERTF(file != 0, "Couldn't open file. %s", resourcePath); fseek( file, 0L, SEEK_END); auto length = ftell(file); rewind(file); auto buffer = new uint8_t[length]; fread(buffer, length, 1, file); fclose(file); RLOGI("%s", "Successfully loaded!"); return (Resource){ buffer, (uint32_t)length }; }
static void *readerLoop(void *arg) { RILChannelCtx *p_channel = (RILChannelCtx *)arg; const char *readerName = p_channel->myName; RLOGI("%s is up", readerName); for (;; ) { const char *line; line = readline(p_channel); RLOGD("%s:%s", readerName, line); if (line == NULL) break; if (isSMSUnsolicited(line)) { char *line1; const char *line2; RLOGD("SMS Urc Received!"); // The scope of string returned by 'readline()' is valid only // till next call to 'readline()' hence making a copy of line // before calling readline again. line1 = strdup(line); line2 = readline(p_channel); if (line2 == NULL) { RLOGE("NULL line found in %s", readerName); break; } if (p_channel->unsolHandler != NULL) { RLOGD("%s: line1:%s,line2:%s", readerName, line1, line2); p_channel->unsolHandler(line1, line2, p_channel); } free(line1); } else { pthread_mutex_lock(&p_channel->commandmutex); RLOGD("%s Enter processLine", readerName); processLine(line, p_channel); pthread_mutex_unlock(&p_channel->commandmutex); } } RLOGE("%s Closed", readerName); onReaderClosed(p_channel); return NULL; }
/** * Called by atchannel when an unsolicited line appears * This is called on atchannel's reader thread. AT commands may * not be issued here */ static void onUnsolicited (const char *s, const char *sms_pdu, void * pChannel) { RLOGI("[Emu]get in onUnsolicited"); RLOGI("[Emu]command %s",s); char *line = NULL; int err; RIL_RadioState radioState = sState; RILChannelCtx * p_channel = (RILChannelCtx *) pChannel; #ifdef MTK_GEMINI if (MTK_RIL_SOCKET_2 == getRILIdByChannelCtx(p_channel)) { radioState = sState2; RLOGI("[Emu]state2"); } #endif /* Ignore unsolicited responses until we're initialized. * This is OK because the RIL library will poll for initial state */ if (radioState == RADIO_STATE_UNAVAILABLE) { return; } if (!(rilNwUnsolicited(s,sms_pdu,p_channel) || rilCcUnsolicited(s,sms_pdu, p_channel) || rilSsUnsolicited(s,sms_pdu, p_channel) || rilSmsUnsolicited(s,sms_pdu, p_channel) || rilStkUnsolicited(s,sms_pdu, p_channel) || rilOemUnsolicited(s,sms_pdu, p_channel) || rilDataUnsolicited(s,sms_pdu, p_channel)|| rilSimUnsolicited(s,sms_pdu, p_channel)) ) { RLOGE("Unhandled unsolicited result code: %s\n", s); } }
Resource platformLoadInternalResource(const char* path) { RLOGI("Trying to internal load file %s", path); auto mgr = gApp->activity->assetManager; auto asset = AAssetManager_open(mgr, path, AASSET_MODE_RANDOM); ASSERTF(asset != 0, "The asset %s does not exist", path); auto length = AAsset_getLength(asset); auto buffer = new uint8_t[length]; auto err = AAsset_read(asset, buffer, length); ASSERTF(err >= 0, "Failed to load internal resource %s. Error was: %d", path, err); AAsset_close(asset); return (Resource){ buffer, (uint32_t)length }; }
/** * Sends string s to the radio with a \r appended. * Returns AT_ERROR_* on error, 0 on success * * This function exists because as of writing, android libc does not * have buffered stdio. */ static int writeline(const char *s, RILChannelCtx *p_channel) { size_t cur = 0; size_t len = strlen(s); ssize_t written; if (p_channel->fd < 0 || p_channel->readerClosed > 0) return AT_ERROR_CHANNEL_CLOSED; RLOGD("AT> %s\n", s); AT_DUMP(">> ", s, strlen(s)); /* the main string */ while (cur < len) { do{ RLOGI("AT write start\n"); written = write(p_channel->fd, s + cur, len - cur); }while (written < 0 && errno == EINTR); if (written < 0) return AT_ERROR_GENERIC; cur += written; } /* the \r */ do { written = write(p_channel->fd, "\r", 1); } while ((written < 0 && errno == EINTR) || (written == 0)); if (written < 0) return AT_ERROR_GENERIC; return 0; }
void gameInitialize(uint32_t screenWidth, uint32_t screenHeight) { if (gGame) return; Profile profile("Game initialize"); remoteDebugStart(platformDeviceName()); gGame = new Game(); gGame->clock = new Clock(); clockStart(gGame->clock); gGame->sensor = new SensorState(); gGame->screen = new Screen(); gGame->screen->width = screenWidth; gGame->screen->height = screenHeight; gGame->fps = 60; RLOGI("%s", "Initializing Game!"); gGame->L = luaCoreCreate(); if(hasStarted) gameRestart(); else gameStart(); }
static void * mainLoop(void *param) { int fd; int ret; char path[50]; int ttys_index; AT_DUMP("== ", "entering mainLoop()", -1 ); at_set_on_reader_closed(onATReaderClosed); at_set_on_timeout(onATTimeout); for (;;) { fd = -1; while (fd < 0) { if (s_port > 0) { fd = socket_loopback_client(s_port, SOCK_STREAM); } else if (s_device_socket) { if (!strcmp(s_device_path, "/dev/socket/qemud")) { /* Qemu-specific control socket */ fd = socket_local_client( "qemud", ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM ); if (fd >= 0 ) { char answer[2]; if ( write(fd, "gsm", 3) != 3 || read(fd, answer, 2) != 2 || memcmp(answer, "OK", 2) != 0) { close(fd); fd = -1; } } } else fd = socket_local_client( s_device_path, ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM ); } else if (s_device_path != NULL) { fd = open (s_device_path, O_RDWR); if ( fd >= 0 && !memcmp( s_device_path, "/dev/ttyS", 9 ) ) { /* disable echo on serial ports */ struct termios ios; tcgetattr( fd, &ios ); ios.c_lflag = 0; /* disable ECHO, ICANON, etc... */ ios.c_iflag = 0; tcsetattr( fd, TCSANOW, &ios ); } } if (fd < 0) { perror ("opening AT interface. retrying..."); sleep(10); /* never returns */ } } RLOGD("FD: %d", fd); s_closed = 0; ret = at_open(fd, onUnsolicited); if (ret < 0) { RLOGE ("AT error %d on at_open\n", ret); return 0; } RIL_requestTimedCallback(initializeCallback, NULL, &TIMEVAL_0); // Give initializeCallback a chance to dispatched, since // we don't presently have a cancellation mechanism sleep(1); waitForClose(); RLOGI("Re-opening after close"); } }
static void gameStart() { RLOGI("%s", "Starting game!"); hasStarted = true; luaStartCall(gGame->L); nice(1000000); }
static void gameRestart() { RLOGI("%s", "Restarting game!"); luaRestartCall(gGame->L); }
static void emulator_gemini_opensocket() { int fd; int ret; for (;;) { fd = -1; RLOGI("[Emu]emulator_gemini_opensocket_in\n"); RLOGI("[Emu]s_device_socket %d\n",s_device_socket); RLOGI("[Emu]s_port %d\n",s_port); while (fd < 0) { if (s_port > 0) { fd = socket_loopback_client(s_port, SOCK_STREAM); RLOGI("[Emu]fd1 %d\n",fd); } else if (s_device_socket) { if (!strcmp(s_device_path, "/dev/socket/qemud")) { /* Qemu-specific control socket */ fd = socket_local_client( "qemud", ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM ); RLOGI("[Emu]fd2 %d\n",fd); if (fd >= 0 ) { char answer[2]; if ( write(fd, "gsm", 3) != 3 || read(fd, answer, 2) != 2 || memcmp(answer, "OK", 2) != 0) { close(fd); fd = -1; } } } else { fd = socket_local_client( s_device_path, ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM ); } RLOGI("[Emu]fd3 %d\n",fd); } else if (s_device_path != NULL) { fd = open (s_device_path, O_RDWR); if ( fd >= 0 && !memcmp( s_device_path, "/dev/ttyS", 9 ) ) { /* disable echo on serial ports */ struct termios ios; tcgetattr( fd, &ios ); ios.c_lflag = 0; /* disable ECHO, ICANON, etc... */ ios.c_iflag = 0; tcsetattr( fd, TCSANOW, &ios ); } RLOGI("[Emu]fd4 %d\n",fd); } if (fd < 0) { RLOGI("[Emu]fd<0"); perror ("opening AT interface. retrying..."); sleep(10); /* never returns */ } } s_closed = 0; ret = at_open_emulator(fd, onUnsolicited,is_gemini_emulator); if (ret < 0) { RLOGE ("AT error %d on at_open\n", ret); return 0; } RLOGI("[Emu]RIL_requestTimedCallback"); RIL_requestTimedCallback(initializeCallback, &s_pollSimId, &TIMEVAL_0); #ifdef MTK_GEMINI RIL_requestTimedCallback(initializeCallback, &s_pollSimId2, &TIMEVAL_0); #endif RLOGI("[Emu]RIL_requestTimedCallback out"); // Give initializeCallback a chance to dispatched, since // we don't presently have a cancellation mechanism sleep(1); waitForClose(); RLOGI("Re-opening after close"); } }
static void initializeCallback(void *param) { RLOGE ("[Emu]get in initializeCallback"); ATResponse *p_response = NULL; int err; RILId rid = *((RILId *)param); char property_value[5] = { 0 }; int current_share_modem = 0; current_share_modem = MTK_SHARE_MODEM_CURRENT; setRadioState (RADIO_STATE_OFF,rid); err = at_handshake(getDefaultChannelCtx(rid)); RLOGI("AT handshake: %d",err); /* note: we don't check errors here. Everything important will be handled in onATTimeout and onATReaderClosed */ /* atchannel is tolerant of echo but it must */ /* have verbose result codes */ at_send_command("ATE0Q0V1", NULL, getDefaultChannelCtx(rid)); /* No auto-answer */ at_send_command("ATS0=0", NULL,getDefaultChannelCtx(rid)); /* Extended errors */ at_send_command("AT+CMEE=1", NULL, getDefaultChannelCtx(rid)); /* Network registration events */ err = at_send_command("AT+CREG=2", &p_response, getDefaultChannelCtx(rid)); /* some handsets -- in tethered mode -- don't support CREG=2 */ if (err < 0 || p_response->success == 0) { at_send_command("AT+CREG=1", NULL, getDefaultChannelCtx(rid)); } at_response_free(p_response); /* GPRS registration events */ at_send_command("AT+CGREG=1", NULL, getDefaultChannelCtx(rid)); /* Call Waiting notifications */ at_send_command("AT+CCWA=1", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* mtk00924: enable Call Progress notifications */ at_send_command("AT+ECPI=4294967295", NULL, getDefaultChannelCtx(rid)); /* Alternating voice/data off */ /* at_send_command("AT+CMOD=0", NULL, getDefaultChannelCtx(rid)); */ /* Not muted */ /* at_send_command("AT+CMUT=0", NULL, getDefaultChannelCtx(rid)); */ //[Emu]TODO diff /* +CSSU unsolicited supp service notifications */ at_send_command("AT+CSSN=1,1", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* connected line identification on */ at_send_command("AT+COLP=1", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* HEX character set */ at_send_command("AT+CSCS=\"UCS2\"", NULL, getDefaultChannelCtx(rid)); /* USSD unsolicited */ at_send_command("AT+CUSD=1", NULL, getDefaultChannelCtx(rid)); /* Enable +CGEV GPRS event notifications, but don't buffer */ at_send_command("AT+CGEREP=1,0", NULL, getDefaultChannelCtx(rid)); /* SMS PDU mode */ at_send_command("AT+CMGF=0", NULL, getDefaultChannelCtx(rid)); /* Initial CID table */ initialCidTable(); //[Emu]TODO diff /* Enable getting NITZ, include TZ and Operator Name*/ /* To Receive +CIEV: 9 and +CIEV: 10*/ //[Emu]TODO_1_ changed // at_send_command("AT+CTZR=1", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* Enable getting CFU info +ECFU and speech info +ESPEECH*/ // at_send_command("AT+EINFO=114", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* Enable get ECSQ URC */ //at_send_command("AT+ECSQ=2", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff /* Enable get +CIEV:7 URC to receive SMS SIM Storage Status*/ // at_send_command("AT+CMER=1,0,0,2,0", NULL, getDefaultChannelCtx(rid)); //[Emu]TODO diff #ifdef MTK_VT3G324M_SUPPORT at_send_command("AT+CRC=1", NULL, getDefaultChannelCtx(rid)); #endif #ifdef MTK_GEMINI requestSimReset(rid); RLOGD("start rild bootup flow [%d, %d, %d, %d]", isDualTalkMode(), rid, RIL_is3GSwitched(), current_share_modem); if (isDualTalkMode()) { if (rid == MTK_RIL_SOCKET_1) { flightModeBoot(); bootupGetIccid(rid); //query ICCID after AT+ESIMS bootupGetImei(rid); bootupGetImeisv(rid); bootupGetBasebandVersion(rid); bootupGetCalData(rid); RLOGD("get SIM inserted status (DT) [%d]", sim_inserted_status); RIL_onUnsolicitedResponse(RIL_UNSOL_SIM_INSERTED_STATUS, &sim_inserted_status, sizeof(int), rid); } } else { if (current_share_modem == 1) { if (rid == MTK_RIL_SOCKET_1) { flightModeBoot(); bootupGetIccid(rid); //query ICCID after AT+ESIMS bootupGetImei(rid); bootupGetImeisv(rid); bootupGetBasebandVersion(rid); bootupGetCalData(rid); RLOGD("get SIM inserted status (Single) [%d]", sim_inserted_status); RIL_onUnsolicitedResponse(RIL_UNSOL_SIM_INSERTED_STATUS, &sim_inserted_status, sizeof(int), rid); } } else if (rid == MTK_RIL_SOCKET_2) { flightModeBoot(); bootupGetIccid(MTK_RIL_SOCKET_1); bootupGetIccid(MTK_RIL_SOCKET_2); bootupGetImei(MTK_RIL_SOCKET_1); bootupGetImei(MTK_RIL_SOCKET_2); bootupGetImeisv(MTK_RIL_SOCKET_1); bootupGetImeisv(MTK_RIL_SOCKET_2); bootupGetBasebandVersion(MTK_RIL_SOCKET_1); bootupGetBasebandVersion(MTK_RIL_SOCKET_2); bootupGetCalData(MTK_RIL_SOCKET_1); RLOGD("get SIM inserted status [%d]", sim_inserted_status); RIL_onUnsolicitedResponse(RIL_UNSOL_SIM_INSERTED_STATUS, &sim_inserted_status, sizeof(int), rid); } } #else flightModeBoot(); bootupGetIccid(rid); bootupGetImei(rid); bootupGetImeisv(rid); bootupGetBasebandVersion(rid); bootupGetCalData(rid); #endif /* MTK_GEMINI */ //[Emu]TODO diff /* assume radio is off on error */ if (isRadioOn(rid) > 0) { setRadioState (RADIO_STATE_SIM_NOT_READY,rid); } }
Resource platformLoadExternalResource(const char* path) { RLOGI("Trying to external load file %s", path); auto resourcePath = path::buildPath(gApp->activity->externalDataPath, path); return platformLoadAbsolutePath(resourcePath.c_str()); }
/** * Reads a line from the AT channel, returns NULL on timeout. * Assumes it has exclusive read access to the FD * * This line is valid only until the next call to readline * * This function exists because as of writing, android libc does not * have buffered stdio. */ static const char *readline(RILChannelCtx *p_channel) { ssize_t count; char *p_read = NULL; char *p_eol = NULL; char *ret; /* this is a little odd. I use *s_ATBufferCur == 0 to * mean "buffer consumed completely". If it points to a character, than * the buffer continues until a \0 */ if (*p_channel->ATBufferCur == '\0') { /* empty buffer */ p_channel->ATBufferCur = p_channel->ATBuffer; *p_channel->ATBufferCur = '\0'; p_read = p_channel->ATBuffer; } else { /* *s_ATBufferCur != '\0' */ /* there's data in the buffer from the last read */ // skip over leading newlines while (*p_channel->ATBufferCur == '\r' || *p_channel->ATBufferCur == '\n') p_channel->ATBufferCur++; p_eol = findNextEOL(p_channel->ATBufferCur); if (p_eol == NULL) { /* a partial line. move it up and prepare to read more */ size_t len; len = strlen(p_channel->ATBufferCur); memmove(p_channel->ATBuffer, p_channel->ATBufferCur, len + 1); p_read = p_channel->ATBuffer + len; p_channel->ATBufferCur = p_channel->ATBuffer; } /* Otherwise, (p_eol !- NULL) there is a complete line */ /* that will be returned the while () loop below */ } while (p_eol == NULL) { if (0 == MAX_AT_RESPONSE - (p_read - p_channel->ATBuffer)) { RLOGE("ERROR: Input line exceeded buffer\n"); /* ditch buffer and start over again */ p_channel->ATBufferCur = p_channel->ATBuffer; *p_channel->ATBufferCur = '\0'; p_read = p_channel->ATBuffer; } do{ RLOGI("AT read start\n"); count = read(p_channel->fd, p_read, MAX_AT_RESPONSE - (p_read - p_channel->ATBuffer)); RLOGI("AT read end: %d:%s\n", count, strerror(errno)); }while (count < 0 && errno == EINTR); if (count > 0) { AT_DUMP("<< ", p_read, count); p_channel->readCount += count; p_read[count] = '\0'; // skip over leading newlines while (*p_channel->ATBufferCur == '\r' || *p_channel->ATBufferCur == '\n') p_channel->ATBufferCur++; p_eol = findNextEOL(p_channel->ATBufferCur); p_read += count; } else if (count <= 0) { /* read error encountered or EOF reached */ if (count == 0) RLOGD("atchannel: EOF reached"); else RLOGD("atchannel: read error %s", strerror(errno)); return NULL; } } /* a full line in the buffer. Place a \0 over the \r and return */ ret = p_channel->ATBufferCur; *p_eol = '\0'; if (p_channel->ATBufferCur[0] == '>' && p_channel->ATBufferCur[1] == ' ' && p_channel->ATBufferCur[2] == '\0') { RLOGD("atchannel: This is sms prompt!"); p_channel->ATBufferCur = p_eol + 1; /* this will always be <= p_read, */ p_channel->ATBufferCur[0] = '\0'; } else { p_channel->ATBufferCur = p_eol + 1; /* this will always be <= p_read, */ } /* and there will be a \0 at *p_read */ RLOGD("AT< %s\n", ret); return ret; }
static void * mainLoop(void *param) { AT_DUMP("== ", "entering mainLoop()", -1 ); at_set_on_reader_closed(onATReaderClosed); at_set_on_timeout(onATTimeout); initRILChannels(); RLOGI("[Emu]mainloop_in"); RLOGI("[Emu]mainloop_in %d\n",s_device_socket); if(s_device_socket) { emulator_gemini_opensocket(); return NULL; } else { int ret; int i; RILChannelCtx * p_channel; for (;;) { for (i=0; i < RIL_SUPPORT_CHANNELS; i ++) { p_channel = getChannelCtxbyId(i); while (p_channel->fd < 0) { do { p_channel->fd = open(s_mux_path[i], O_RDWR); } while (p_channel->fd < 0 && errno == EINTR); if (p_channel->fd < 0) { perror ("opening AT interface. retrying..."); RLOGE("could not connect to %s: %s", s_mux_path[i], strerror(errno)); sleep(10); /* never returns */ } else { struct termios ios; tcgetattr(p_channel->fd, &ios ); ios.c_lflag = 0; /* disable ECHO, ICANON, etc... */ ios.c_iflag = 0; tcsetattr(p_channel->fd, TCSANOW, &ios ); } } s_closed = 0; ret = at_open(p_channel->fd,onUnsolicited, p_channel); if (ret < 0) { RLOGE ("AT error %d on at_open\n", ret); return 0; } } RIL_requestTimedCallback(initializeCallback, &s_pollSimId, &TIMEVAL_0); #ifdef MTK_GEMINI RIL_requestTimedCallback(initializeCallback, &s_pollSimId2, &TIMEVAL_0); #endif // Give initializeCallback a chance to dispatched, since // we don't presently have a cancellation mechanism sleep(1); waitForClose(); RLOGI("Re-opening after close"); } } }