int main(int argc, char **argv)
{
const char * rilLibPath = NULL;
char **rilArgv;
void *dlHandle;
const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
const RIL_RadioFunctions *(*rilInitSocket)(const struct RIL_EnvSocket *, int, char **);
const RIL_RadioFunctions *funcs;
const RIL_RadioFunctionsSocket *funcsSocket;
char libPath[PROPERTY_VALUE_MAX];
char socPath[PROPERTY_VALUE_MAX];
unsigned char hasLibArgs = 0;
int i;
const char *clientId = NULL;
RLOGD("**RIL Daemon Started**");
RLOGD("**RILd param count=%d**", argc);
#ifdef MTK_RIL_MD2
RLOGD("RILD started (MD2)");
#else
RLOGD("RILD started");
#endif
if (mtkInit() == -1) goto done;
umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH);
for (i = 1; i < argc ;) {
if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) {
rilLibPath = argv[i + 1];
i += 2;
} else if (0 == strcmp(argv[i], "--")) {
i++;
hasLibArgs = 1;
break;
} else if (0 == strcmp(argv[i], "-c") && (argc - i > 1)) {
clientId = argv[i+1];
i += 2;
} else {
usage(argv[0]);
}
}
if (clientId == NULL) {
clientId = "0";
} else if (atoi(clientId) >= MAX_RILDS) {
RLOGE("Max Number of rild's supported is: %d", MAX_RILDS);
exit(0);
}
if (strncmp(clientId, "0", MAX_CLIENT_ID_LENGTH)) {
RIL_setRilSocketName(strncat(rild, clientId, MAX_SOCKET_NAME_LENGTH));
}
if (rilLibPath == NULL) {
#ifdef MTK_RIL_MD2
if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, "/system/lib/mtk-rilmd2.so")) {
#else
if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, "/system/lib/mtk-ril.so")) {
#endif
// No lib sepcified on the command line, and nothing set in props.
// Assume "no-ril" case.
goto done;
} else {
rilLibPath = libPath;
}
}
/* special override when in the emulator */
#if 1
{
static char* arg_overrides[5];
static char arg_device[32];
int done = 0;
#ifdef MTK_RIL_MD2
#define REFERENCE_RIL_PATH "/system/lib/mtk-rilmd2.so"
#else
#define REFERENCE_RIL_PATH "/system/lib/mtk-ril.so"
#endif
/* first, read /proc/cmdline into memory */
char buffer[1024], *p, *q;
int len;
int fd = open("/proc/cmdline",O_RDONLY);
if (fd < 0) {
RLOGD("could not open /proc/cmdline:%s", strerror(errno));
goto OpenLib;
}
do {
len = read(fd,buffer,sizeof(buffer));
}
while (len == -1 && errno == EINTR);
if (len < 0) {
RLOGD("could not read /proc/cmdline:%s", strerror(errno));
close(fd);
goto OpenLib;
}
close(fd);
if (strstr(buffer, "android.qemud=") != NULL)
{
/* the qemud daemon is launched after rild, so
* give it some time to create its GSM socket
*/
int tries = 5;
#define QEMUD_SOCKET_NAME "qemud"
while (1) {
int fd;
sleep(1);
fd = qemu_pipe_open("qemud:gsm");
if (fd < 0) {
fd = socket_local_client(
QEMUD_SOCKET_NAME,
ANDROID_SOCKET_NAMESPACE_RESERVED,
SOCK_STREAM );
}
if (fd >= 0) {
close(fd);
snprintf( arg_device, sizeof(arg_device), "%s/%s",
ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME );
arg_overrides[1] = "-s";
arg_overrides[2] = arg_device;
done = 1;
break;
}
RLOGD("could not connect to %s socket: %s",
QEMUD_SOCKET_NAME, strerror(errno));
if (--tries == 0)
break;
}
if (!done) {
RLOGE("could not connect to %s socket (giving up): %s",
QEMUD_SOCKET_NAME, strerror(errno));
while(1)
sleep(0x00ffffff);
}
}
/* otherwise, try to see if we passed a device name from the kernel */
if (!done) do {
#define KERNEL_OPTION "android.ril="
#define DEV_PREFIX "/dev/"
p = strstr( buffer, KERNEL_OPTION );
if (p == NULL)
break;
p += sizeof(KERNEL_OPTION)-1;
q = strpbrk( p, " \t\n\r" );
if (q != NULL)
*q = 0;
snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p );
arg_device[sizeof(arg_device)-1] = 0;
arg_overrides[1] = "-d";
arg_overrides[2] = arg_device;
done = 1;
} while (0);
if (done) {
argv = arg_overrides;
argc = 3;
i = 1;
hasLibArgs = 1;
rilLibPath = REFERENCE_RIL_PATH;
RLOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]);
}
}
OpenLib:
#endif
switchUser();
#ifdef MTK_RIL_MD2
rilLibPath = "/system/lib/mtk-rilmd2.so";
#endif
RLOGD("Open ril lib path: %s", rilLibPath);
dlHandle = dlopen(rilLibPath, RTLD_NOW);
if (dlHandle == NULL) {
RLOGE("dlopen failed: %s", dlerror());
exit(EXIT_FAILURE);
}
RIL_startEventLoop();
rilInitSocket = (const int(*)(void))dlsym(dlHandle, "RIL_InitSocket");
if (rilInitSocket == NULL) {
RLOGD("Vendor RIL do not need socket id!");
rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init");
if (rilInit == NULL) {
RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath);
exit(EXIT_FAILURE);
}
} else {
RLOGD("vendor RIL need socket id");
}
if (hasLibArgs) {
rilArgv = argv + i - 1;
argc = argc -i + 1;
} else {
static char * newArgv[MAX_LIB_ARGS];
static char args[PROPERTY_VALUE_MAX];
rilArgv = newArgv;
#ifdef MTK_RIL_MD2
property_get(LIB_ARGS_PROPERTY, args, "-d /dev/ccci2_tty0");
#else
property_get(LIB_ARGS_PROPERTY, args, "-d /dev/ttyC0");
#endif
argc = make_argv(args, rilArgv);
}
rilArgv[argc++] = "-c";
rilArgv[argc++] = clientId;
RLOGD("RIL_Init argc = %d clientId = %s", argc, rilArgv[argc-1]);
// Make sure there's a reasonable argv[0]
rilArgv[0] = argv[0];
if (rilInitSocket == NULL) {
RLOGD("Old vendor ril! so RIL_register is called");
funcs = rilInit(&s_rilEnv, argc, rilArgv);
RIL_register(funcs);
} else {
RLOGD("New vendor ril! so RIL_registerSocket is called");
funcsSocket = rilInitSocket(&s_rilEnvSocket, argc, rilArgv);
RIL_registerSocket(funcsSocket);
}
done:
RLOGD("RIL_Init starting sleep loop");
while (true) {
sleep(UINT32_MAX);
}
}
status_t QemuClient::connectClient(const char* param)
{
LOGV("%s: '%s'", __FUNCTION__, param ? param : "");
/* Make sure that client is not connected already. */
if (mPipeFD >= 0) {
LOGE("%s: Qemu client is already connected", __FUNCTION__);
return EINVAL;
}
/* Select one of the two: 'factory', or 'emulated camera' service */
if (param == NULL || *param == '\0') {
/* No parameters: connect to the factory service. */
char pipe_name[512];
snprintf(pipe_name, sizeof(pipe_name), "qemud:%s", mCameraServiceName);
mPipeFD = qemu_pipe_open(pipe_name);
} else {
/* One extra char ':' that separates service name and parameters + six
* characters for 'qemud:'. This is required by qemu pipe protocol. */
char* connection_str = new char[strlen(mCameraServiceName) +
strlen(param) + 8];
sprintf(connection_str, "qemud:%s:%s", mCameraServiceName, param);
mPipeFD = qemu_pipe_open(connection_str);
delete[] connection_str;
}
if (mPipeFD < 0) {
LOGE("%s: Unable to connect to the camera service '%s': %s",
__FUNCTION__, param ? param : "Factory", strerror(errno));
return errno ? errno : EINVAL;
}
return NO_ERROR;
}
int
pipe_openQemuPipe( Pipe* pipe, const char* pipename )
{
pipe->socket = qemu_pipe_open(pipename);
if (pipe->socket < 0) {
fprintf(stderr, "%s: Could not open '%s' pipe: %s\n", __FUNCTION__, pipename, strerror(errno));
return -1;
}
return 0;
}
/* Initializes connection with the adb-debug qemud service in the emulator. */
static int adb_qemu_trace_init(void)
{
char con_name[32];
if (adb_debug_qemu >= 0) {
return 0;
}
/* adb debugging QEMUD service connection request. */
snprintf(con_name, sizeof(con_name), "qemud:adb-debug");
adb_debug_qemu = qemu_pipe_open(con_name);
return (adb_debug_qemu >= 0) ? 0 : -1;
}
void notifyHostBootComplete() {
if (s_QemuMiscPipe < 0) {
s_QemuMiscPipe = qemu_pipe_open(QEMU_MISC_PIPE);
if (s_QemuMiscPipe < 0) {
ALOGE("failed to open %s", QEMU_MISC_PIPE);
return;
}
}
char set[] = "bootcomplete";
int pipe_command_length = sizeof(set);
WriteFully(s_QemuMiscPipe, &pipe_command_length, sizeof(pipe_command_length));
WriteFully(s_QemuMiscPipe, set, pipe_command_length);
ReadFully(s_QemuMiscPipe, &pipe_command_length, sizeof(pipe_command_length));
if (pipe_command_length > sizeof(set) || pipe_command_length <= 0)
return;
ReadFully(s_QemuMiscPipe, set, pipe_command_length);
}
static int
qemu_channel_open_qemud_pipe( QemuChannel* channel,
const char* name )
{
int fd;
char pipe_name[512];
snprintf(pipe_name, sizeof(pipe_name), "qemud:%s", name);
fd = qemu_pipe_open(pipe_name);
if (fd < 0) {
D("no qemud pipe: %s", strerror(errno));
return -1;
}
channel->is_qemud = 1;
channel->fd = fd;
return 0;
}
/* A worker thread that monitors host connections, and registers a transport for
* every new host connection. This thread replaces server_socket_thread on
* condition that adbd daemon runs inside the emulator, and emulator uses QEMUD
* pipe to communicate with adbd daemon inside the guest. This is done in order
* to provide more robust communication channel between ADB host and guest. The
* main issue with server_socket_thread approach is that it runs on top of TCP,
* and thus is sensitive to network disruptions. For instance, the
* ConnectionManager may decide to reset all network connections, in which case
* the connection between ADB host and guest will be lost. To make ADB traffic
* independent from the network, we use here 'adb' QEMUD service to transfer data
* between the host, and the guest. See external/qemu/android/adb-*.* that
* implements the emulator's side of the protocol. Another advantage of using
* QEMUD approach is that ADB will be up much sooner, since it doesn't depend
* anymore on network being set up.
* The guest side of the protocol contains the following phases:
* - Connect with adb QEMUD service. In this phase a handle to 'adb' QEMUD service
* is opened, and it becomes clear whether or not emulator supports that
* protocol.
* - Wait for the ADB host to create connection with the guest. This is done by
* sending an 'accept' request to the adb QEMUD service, and waiting on
* response.
* - When new ADB host connection is accepted, the connection with adb QEMUD
* service is registered as the transport, and a 'start' request is sent to the
* adb QEMUD service, indicating that the guest is ready to receive messages.
* Note that the guest will ignore messages sent down from the emulator before
* the transport registration is completed. That's why we need to send the
* 'start' request after the transport is registered.
*/
static void *qemu_socket_thread(void * arg)
{
/* 'accept' request to the adb QEMUD service. */
static const char _accept_req[] = "accept";
/* 'start' request to the adb QEMUD service. */
static const char _start_req[] = "start";
/* 'ok' reply from the adb QEMUD service. */
static const char _ok_resp[] = "ok";
const int port = (int) (uintptr_t) arg;
int res, fd;
char tmp[256];
char con_name[32];
D("transport: qemu_socket_thread() starting\n");
/* adb QEMUD service connection request. */
snprintf(con_name, sizeof(con_name), "qemud:adb:%d", port);
/* Connect to the adb QEMUD service. */
fd = qemu_pipe_open(con_name);
if (fd < 0) {
/* This could be an older version of the emulator, that doesn't
* implement adb QEMUD service. Fall back to the old TCP way. */
D("adb service is not available. Falling back to TCP socket.\n");
adb_thread_create(server_socket_thread, arg);
return 0;
}
for(;;) {
/*
* Wait till the host creates a new connection.
*/
/* Send the 'accept' request. */
res = adb_write(fd, _accept_req, strlen(_accept_req));
if ((size_t)res == strlen(_accept_req)) {
/* Wait for the response. In the response we expect 'ok' on success,
* or 'ko' on failure. */
res = adb_read(fd, tmp, sizeof(tmp));
if (res != 2 || memcmp(tmp, _ok_resp, 2)) {
D("Accepting ADB host connection has failed.\n");
adb_close(fd);
} else {
/* Host is connected. Register the transport, and start the
* exchange. */
register_socket_transport(fd, "host", port, 1);
adb_write(fd, _start_req, strlen(_start_req));
}
/* Prepare for accepting of the next ADB host connection. */
fd = qemu_pipe_open(con_name);
if (fd < 0) {
D("adb service become unavailable.\n");
return 0;
}
} else {
D("Unable to send the '%s' request to ADB service.\n", _accept_req);
return 0;
}
}
D("transport: qemu_socket_thread() exiting\n");
return 0;
}
int main(int argc, char **argv)
{
const char * rilLibPath = NULL;
char **rilArgv;
void *dlHandle;
const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
const RIL_RadioFunctions *funcs;
char libPath[PROPERTY_VALUE_MAX];
unsigned char hasLibArgs = 0;
int modem_type = UNKNOWN_MODEM;
int i;
umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH);
for (i = 1; i < argc ;) {
if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) {
rilLibPath = argv[i + 1];
i += 2;
} else if (0 == strcmp(argv[i], "--")) {
i++;
hasLibArgs = 1;
break;
} else {
usage(argv[0]);
}
}
//Wait for device ready.
if (rilLibPath == NULL) {
while(UNKNOWN_MODEM == modem_type){
modem_type = runtime_3g_port_type();
ALOGD("Couldn't find proper modem, retrying...");
s_poll_device_cnt++;
if (s_poll_device_cnt > MAX_POLL_DEVICE_CNT){
/*
*Maybe no device right now, start to monitor
*hotplug event later.
*/
start_uevent_monitor();
goto done;
}
sleep(5);
}
}
start_uevent_monitor();
switch (modem_type){
case ZTE_MODEM:
rilLibPath = REFERENCE_RIL_ZTE_PATH;
break;
case HUAWEI_MODEM:
case AMAZON_MODEM:
default:
if (!rilLibPath)
rilLibPath = REFERENCE_RIL_DEF_PATH;
break;
}
RLOGE("ril lib path=%s\n", rilLibPath);
if (rilLibPath == NULL) {
if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, NULL)) {
// No lib sepcified on the command line, and nothing set in props.
// Assume "no-ril" case.
goto done;
} else {
rilLibPath = libPath;
}
}
/* special override when in the emulator */
#if 1
{
static char* arg_overrides[3];
static char arg_device[32];
int done = 0;
#define REFERENCE_RIL_PATH "/system/lib/libreference-ril.so"
/* first, read /proc/cmdline into memory */
char buffer[1024], *p, *q;
int len;
int fd = open("/proc/cmdline",O_RDONLY);
if (fd < 0) {
RLOGD("could not open /proc/cmdline:%s", strerror(errno));
goto OpenLib;
}
do {
len = read(fd,buffer,sizeof(buffer)); }
while (len == -1 && errno == EINTR);
if (len < 0) {
RLOGD("could not read /proc/cmdline:%s", strerror(errno));
close(fd);
goto OpenLib;
}
close(fd);
if (strstr(buffer, "android.qemud=") != NULL)
{
/* the qemud daemon is launched after rild, so
* give it some time to create its GSM socket
*/
int tries = 5;
#define QEMUD_SOCKET_NAME "qemud"
while (1) {
int fd;
sleep(1);
fd = qemu_pipe_open("qemud:gsm");
if (fd < 0) {
fd = socket_local_client(
QEMUD_SOCKET_NAME,
ANDROID_SOCKET_NAMESPACE_RESERVED,
SOCK_STREAM );
}
if (fd >= 0) {
close(fd);
snprintf( arg_device, sizeof(arg_device), "%s/%s",
ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME );
arg_overrides[1] = "-s";
arg_overrides[2] = arg_device;
done = 1;
break;
}
RLOGD("could not connect to %s socket: %s",
QEMUD_SOCKET_NAME, strerror(errno));
if (--tries == 0)
break;
}
if (!done) {
RLOGE("could not connect to %s socket (giving up): %s",
QEMUD_SOCKET_NAME, strerror(errno));
while(1)
sleep(0x00ffffff);
}
}
/* otherwise, try to see if we passed a device name from the kernel */
if (!done) do {
#define KERNEL_OPTION "android.ril="
#define DEV_PREFIX "/dev/"
p = strstr( buffer, KERNEL_OPTION );
if (p == NULL)
break;
p += sizeof(KERNEL_OPTION)-1;
q = strpbrk( p, " \t\n\r" );
if (q != NULL)
*q = 0;
snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p );
arg_device[sizeof(arg_device)-1] = 0;
arg_overrides[1] = "-d";
arg_overrides[2] = arg_device;
done = 1;
} while (0);
if (done) {
argv = arg_overrides;
argc = 3;
i = 1;
hasLibArgs = 1;
rilLibPath = REFERENCE_RIL_PATH;
RLOGD("overriding with %s %s", arg_overrides[1], arg_overrides[2]);
}
}
OpenLib:
#endif
switchUser();
dlHandle = dlopen(rilLibPath, RTLD_NOW);
if (dlHandle == NULL) {
RLOGE("dlopen failed: %s", dlerror());
exit(-1);
}
RIL_startEventLoop();
rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init");
if (rilInit == NULL) {
RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath);
exit(-1);
}
if (hasLibArgs) {
rilArgv = argv + i - 1;
argc = argc -i + 1;
} else {
static char * newArgv[MAX_LIB_ARGS];
static char args[PROPERTY_VALUE_MAX];
rilArgv = newArgv;
property_get(LIB_ARGS_PROPERTY, args, "");
argc = make_argv(args, rilArgv);
}
// Make sure there's a reasonable argv[0]
rilArgv[0] = argv[0];
funcs = rilInit(&s_rilEnv, argc, rilArgv);
RIL_register(funcs);
done:
while(1) {
// sleep(UINT32_MAX) seems to return immediately on bionic
sleep(0x00ffffff);
}
}
int QemuPipeStream::connect(void)
{
m_sock = qemu_pipe_open("opengles");
if (!valid()) return -1;
return 0;
}
int main(int argc, char **argv)
{
const char * rilLibPath = NULL;
char **rilArgv;
static char * s_argv[MAX_LIB_ARGS] = {NULL};
void *dlHandle;
const RIL_RadioFunctions *(*rilInit)(const struct RIL_Env *, int, char **);
const RIL_RadioFunctions *funcs;
char libPath[PROPERTY_VALUE_MAX];
unsigned char hasLibArgs = 0;
int j = 0;
int i;
static char clientId[3] = {'0'};
RLOGD("**RIL Daemon Started**");
RLOGD("**RILd param count=%d**", argc);
memset(s_argv, 0, sizeof(s_argv));
s_argv[0] = argv[0];
umask(S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IWOTH | S_IXOTH);
for (i = 1, j = 1; i < argc ;) {
if (0 == strcmp(argv[i], "-l") && (argc - i > 1)) {
rilLibPath = argv[i + 1];
i += 2;
} else if (0 == strcmp(argv[i], "-c") && (argc - i > 1)) {
strncpy(clientId, argv[i+1], strlen(clientId));
i += 2;
} else if (0 == strcmp(argv[i], "--")) {
i++;
hasLibArgs = 1;
memcpy(&s_argv[j], &argv[i], argc-i);
break;
} else {
usage(argv[0]);
}
}
#ifdef QCOM_HARDWARE
if (atoi(clientId) >= MAX_RILDS) {
RLOGE("Max Number of rild's supported is: %d", MAX_RILDS);
exit(0);
}
RLOGD ("RIL Client Id:=%s", clientId);
if (strncmp(clientId, "0", MAX_CLIENT_ID_LENGTH)) {
if (RIL_setRilSocketName) {
RIL_setRilSocketName(clientId);
} else {
RLOGE("Trying to instantiate multiple rild sockets without a compatible libril!");
}
}
#endif
if (rilLibPath == NULL) {
if ( 0 == property_get(LIB_PATH_PROPERTY, libPath, NULL)) {
// No lib sepcified on the command line, and nothing set in props.
// Assume "no-ril" case.
goto done;
} else {
rilLibPath = libPath;
}
}
/* special override when in the emulator */
#if 1
{
static char arg_device[32];
int done = 0;
//连接库地址：/system/lib/libreference-ril.so
#define REFERENCE_RIL_PATH "/system/lib/libreference-ril.so"
/* first, read /proc/cmdline into memory */
char buffer[1024], *p, *q;
int len;
int fd = open("/proc/cmdline",O_RDONLY);
if (fd < 0) {
RLOGD("could not open /proc/cmdline:%s", strerror(errno));
goto OpenLib;
}
do {
len = read(fd,buffer,sizeof(buffer)); }
while (len == -1 && errno == EINTR);
if (len < 0) {
RLOGD("could not read /proc/cmdline:%s", strerror(errno));
close(fd);
goto OpenLib;
}
close(fd);
if (strstr(buffer, "android.qemud=") != NULL)
{
/* the qemud daemon is launched after rild, so
* give it some time to create its GSM socket
*/
int tries = 5;
#define QEMUD_SOCKET_NAME "qemud"
while (1) {
int fd;
sleep(1);
fd = qemu_pipe_open("qemud:gsm");
if (fd < 0) {
fd = socket_local_client(
QEMUD_SOCKET_NAME,
ANDROID_SOCKET_NAMESPACE_RESERVED,
SOCK_STREAM );
}
if (fd >= 0) {
close(fd);
snprintf( arg_device, sizeof(arg_device), "%s/%s",
ANDROID_SOCKET_DIR, QEMUD_SOCKET_NAME );
memset(s_argv, 0, sizeof(s_argv));
s_argv[1] = "-s";
s_argv[2] = arg_device;
done = 1;
break;
}
RLOGD("could not connect to %s socket: %s",
QEMUD_SOCKET_NAME, strerror(errno));
if (--tries == 0)
break;
}
if (!done) {
RLOGE("could not connect to %s socket (giving up): %s",
QEMUD_SOCKET_NAME, strerror(errno));
while(1)
sleep(0x00ffffff);
}
}
/* otherwise, try to see if we passed a device name from the kernel */
if (!done) do {
#define KERNEL_OPTION "android.ril="
#define DEV_PREFIX "/dev/"
p = strstr( buffer, KERNEL_OPTION );
if (p == NULL)
break;
p += sizeof(KERNEL_OPTION)-1;
q = strpbrk( p, " \t\n\r" );
if (q != NULL)
*q = 0;
snprintf( arg_device, sizeof(arg_device), DEV_PREFIX "%s", p );
arg_device[sizeof(arg_device)-1] = 0;
memset(s_argv, 0, sizeof(s_argv));
s_argv[1] = "-d";
s_argv[2] = arg_device;
done = 1;
} while (0);
if (done) {
argc = 3;
i = 1;
hasLibArgs = 1;
rilLibPath = REFERENCE_RIL_PATH;
RLOGD("overriding with %s %s", s_argv[1], s_argv[2]);
}
}
OpenLib:
#endif
//切换UID为AID_RADIO
switchUser();
// 打开链接库
dlHandle = dlopen(rilLibPath, RTLD_NOW);
if (dlHandle == NULL) {
RLOGE("dlopen failed: %s", dlerror());
exit(-1);
}
// 开启EventLoop循环
RIL_startEventLoop();
// 从链接库中（也就是reference-ril.c）寻找RIL_Init函数地址
rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init");
if (rilInit == NULL) {
RLOGE("RIL_Init not defined or exported in %s\n", rilLibPath);
exit(-1);
}
if (hasLibArgs) {
argc = argc-i+1;
} else {
static char * newArgv[MAX_LIB_ARGS];
static char args[PROPERTY_VALUE_MAX];
property_get(LIB_ARGS_PROPERTY, args, "");
argc = make_argv(args, s_argv);
}
// Make sure there's a reasonable argv[0]
s_argv[0] = argv[0];
if (argc >= MAX_LIB_ARGS - 2) {
RLOGE("Max arguments are passed for rild, args count = %d", argc);
exit(0);
}
#ifdef QCOM_HARDWARE
/* Client-id is a qualcomm thing */
s_argv[argc++] = "-c";
s_argv[argc++] = clientId;
#endif
RLOGD("RIL_Init argc = %d clientId = %s", argc, s_argv[argc-1]);
// 初始化过程将s_rilEnv全局变量传递给了reference，然后在reference-ril.c内部将这个值传给了s_rilenv
// 而s_rilEnv的各个处理函数是在ril.cpp中实现的
// 调用reference-ril.c中的RIL_Init函数进行初始化INIT，同时得到reference-ril的回调函数
funcs = rilInit(&s_rilEnv, argc, s_argv);
#ifdef QCOM_HARDWARE
if (funcs == NULL) {
/* Pre-multi-client qualcomm vendor libraries won't support "-c" either, so
* try again without it. This should only happen on ancient qcoms, so raise
* a big fat warning
*/
argc -= 2;
RLOGE("============= Retrying RIL_Init without a client id. This is only required for very old versions,");
RLOGE("============= and you're likely to have more radio breakage elsewhere!");
funcs = rilInit(&s_rilEnv, argc, s_argv);
}
#endif
//注册得到的reference的回调函数
RIL_register(funcs);
done:
while(1) {
// sleep(UINT32_MAX) seems to return immediately on bionic
sleep(0x00ffffff);
}
}
