From 8506e4eab86b62a662770a08081e599ab79bae02 Mon Sep 17 00:00:00 2001 From: bohu Date: Sat, 9 Jun 2018 08:20:14 -0700 Subject: goldfish: add ril Create goldfish's own ril so it is not coupled with reference-ril, and we can further customize it for goldfish's need BUG: 110047214 This initial version is taken from hardware/ril commit 982ba7ab0767df77b0cda7f592bfde7e8b6cb53d Author: Sooraj Sasindran Date: Mon May 7 21:20:43 2018 -0700 Add scan error to Network Scan result Change-Id: I07a938a8a6e9af368f51540f2c5f9627099017d7 --- ril/Android.mk | 44 + ril/MODULE_LICENSE_APACHE2 | 0 ril/NOTICE | 190 ++ ril/at_tok.c | 190 ++ ril/at_tok.h | 30 + ril/atchannel.c | 975 ++++++ ril/atchannel.h | 124 + ril/misc.c | 40 + ril/misc.h | 22 + ril/reference-ril.c | 3867 +++++++++++++++++++++++ ril/ril.h | 7363 ++++++++++++++++++++++++++++++++++++++++++++ 11 files changed, 12845 insertions(+) create mode 100644 ril/Android.mk create mode 100644 ril/MODULE_LICENSE_APACHE2 create mode 100644 ril/NOTICE create mode 100644 ril/at_tok.c create mode 100644 ril/at_tok.h create mode 100644 ril/atchannel.c create mode 100644 ril/atchannel.h create mode 100644 ril/misc.c create mode 100644 ril/misc.h create mode 100644 ril/reference-ril.c create mode 100644 ril/ril.h diff --git a/ril/Android.mk b/ril/Android.mk new file mode 100644 index 0000000..34bd227 --- /dev/null +++ b/ril/Android.mk @@ -0,0 +1,44 @@ +# Copyright 2006 The Android Open Source Project + +# XXX using libutils for simulator build only... +# +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES:= \ + reference-ril.c \ + atchannel.c \ + misc.c \ + at_tok.c + +LOCAL_SHARED_LIBRARIES := \ + liblog libcutils libutils libril librilutils + +LOCAL_STATIC_LIBRARIES := libqemu_pipe libbase + +# for asprinf +LOCAL_CFLAGS := -D_GNU_SOURCE +LOCAL_CFLAGS += -Wall -Wextra -Wno-unused-variable -Wno-unused-function -Werror + +LOCAL_C_INCLUDES := + +ifeq ($(TARGET_DEVICE),sooner) + LOCAL_CFLAGS += -DUSE_TI_COMMANDS +endif + +ifeq ($(TARGET_DEVICE),surf) + LOCAL_CFLAGS += -DPOLL_CALL_STATE -DUSE_QMI +endif + +ifeq ($(TARGET_DEVICE),dream) + LOCAL_CFLAGS += -DPOLL_CALL_STATE -DUSE_QMI +endif + +LOCAL_VENDOR_MODULE:= true + +#build shared library +LOCAL_SHARED_LIBRARIES += \ + libcutils libutils +LOCAL_CFLAGS += -DRIL_SHLIB +LOCAL_MODULE:= libgoldfish-ril +include $(BUILD_SHARED_LIBRARY) diff --git a/ril/MODULE_LICENSE_APACHE2 b/ril/MODULE_LICENSE_APACHE2 new file mode 100644 index 0000000..e69de29 diff --git a/ril/NOTICE b/ril/NOTICE new file mode 100644 index 0000000..c5b1efa --- /dev/null +++ b/ril/NOTICE @@ -0,0 +1,190 @@ + + Copyright (c) 2005-2008, The Android Open Source Project + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + diff --git a/ril/at_tok.c b/ril/at_tok.c new file mode 100644 index 0000000..204a69e --- /dev/null +++ b/ril/at_tok.c @@ -0,0 +1,190 @@ +/* //device/system/reference-ril/at_tok.c +** +** Copyright 2006, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +#include "at_tok.h" +#include +#include +#include + +/** + * Starts tokenizing an AT response string + * returns -1 if this is not a valid response string, 0 on success. + * updates *p_cur with current position + */ +int at_tok_start(char **p_cur) +{ + if (*p_cur == NULL) { + return -1; + } + + // skip prefix + // consume "^[^:]:" + + *p_cur = strchr(*p_cur, ':'); + + if (*p_cur == NULL) { + return -1; + } + + (*p_cur)++; + + return 0; +} + +static void skipWhiteSpace(char **p_cur) +{ + if (*p_cur == NULL) return; + + while (**p_cur != '\0' && isspace(**p_cur)) { + (*p_cur)++; + } +} + +static void skipNextComma(char **p_cur) +{ + if (*p_cur == NULL) return; + + while (**p_cur != '\0' && **p_cur != ',') { + (*p_cur)++; + } + + if (**p_cur == ',') { + (*p_cur)++; + } +} + +static char * nextTok(char **p_cur) +{ + char *ret = NULL; + + skipWhiteSpace(p_cur); + + if (*p_cur == NULL) { + ret = NULL; + } else if (**p_cur == '"') { + (*p_cur)++; + ret = strsep(p_cur, "\""); + skipNextComma(p_cur); + } else { + ret = strsep(p_cur, ","); + } + + return ret; +} + + +/** + * Parses the next integer in the AT response line and places it in *p_out + * returns 0 on success and -1 on fail + * updates *p_cur + * "base" is the same as the base param in strtol + */ + +static int at_tok_nextint_base(char **p_cur, int *p_out, int base, int uns) +{ + char *ret; + + if (*p_cur == NULL) { + return -1; + } + + ret = nextTok(p_cur); + + if (ret == NULL) { + return -1; + } else { + long l; + char *end; + + if (uns) + l = strtoul(ret, &end, base); + else + l = strtol(ret, &end, base); + + *p_out = (int)l; + + if (end == ret) { + return -1; + } + } + + return 0; +} + +/** + * Parses the next base 10 integer in the AT response line + * and places it in *p_out + * returns 0 on success and -1 on fail + * updates *p_cur + */ +int at_tok_nextint(char **p_cur, int *p_out) +{ + return at_tok_nextint_base(p_cur, p_out, 10, 0); +} + +/** + * Parses the next base 16 integer in the AT response line + * and places it in *p_out + * returns 0 on success and -1 on fail + * updates *p_cur + */ +int at_tok_nexthexint(char **p_cur, int *p_out) +{ + return at_tok_nextint_base(p_cur, p_out, 16, 1); +} + +int at_tok_nextbool(char **p_cur, char *p_out) +{ + int ret; + int result; + + ret = at_tok_nextint(p_cur, &result); + + if (ret < 0) { + return -1; + } + + // booleans should be 0 or 1 + if (!(result == 0 || result == 1)) { + return -1; + } + + if (p_out != NULL) { + *p_out = (char)result; + } + + return ret; +} + +int at_tok_nextstr(char **p_cur, char **p_out) +{ + if (*p_cur == NULL) { + return -1; + } + + *p_out = nextTok(p_cur); + + return 0; +} + +/** returns 1 on "has more tokens" and 0 if no */ +int at_tok_hasmore(char **p_cur) +{ + return ! (*p_cur == NULL || **p_cur == '\0'); +} + + diff --git a/ril/at_tok.h b/ril/at_tok.h new file mode 100644 index 0000000..a85ea63 --- /dev/null +++ b/ril/at_tok.h @@ -0,0 +1,30 @@ +/* //device/system/reference-ril/at_tok.h +** +** Copyright 2006, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +#ifndef AT_TOK_H +#define AT_TOK_H 1 + +int at_tok_start(char **p_cur); +int at_tok_nextint(char **p_cur, int *p_out); +int at_tok_nexthexint(char **p_cur, int *p_out); + +int at_tok_nextbool(char **p_cur, char *p_out); +int at_tok_nextstr(char **p_cur, char **out); + +int at_tok_hasmore(char **p_cur); + +#endif /*AT_TOK_H */ diff --git a/ril/atchannel.c b/ril/atchannel.c new file mode 100644 index 0000000..0041836 --- /dev/null +++ b/ril/atchannel.c @@ -0,0 +1,975 @@ +/* //device/system/reference-ril/atchannel.c +** +** Copyright 2006, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +#include "atchannel.h" +#include "at_tok.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define LOG_NDEBUG 0 +#define LOG_TAG "AT" +#include + +#include "misc.h" + + +#define NUM_ELEMS(x) (sizeof(x)/sizeof((x)[0])) + +#define MAX_AT_RESPONSE (8 * 1024) +#define HANDSHAKE_RETRY_COUNT 8 +#define HANDSHAKE_TIMEOUT_MSEC 250 + +static pthread_t s_tid_reader; +static int s_fd = -1; /* fd of the AT channel */ +static ATUnsolHandler s_unsolHandler; + +/* for input buffering */ + +static char s_ATBuffer[MAX_AT_RESPONSE+1]; +static char *s_ATBufferCur = s_ATBuffer; + +#if AT_DEBUG +void AT_DUMP(const char* prefix, const char* buff, int len) +{ + if (len < 0) + len = strlen(buff); + RLOGD("%.*s", len, buff); +} +#endif + +/* + * There is one reader thread |s_tid_reader| and potentially multiple writer + * threads. |s_commandmutex| and |s_commandcond| are used to maintain the + * condition that the writer thread will not read from |sp_response| until the + * reader thread has signaled itself is finished, etc. |s_writeMutex| is used to + * prevent multiple writer threads from calling at_send_command_full_nolock + * function at the same time. + */ + +static pthread_mutex_t s_commandmutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t s_commandcond = PTHREAD_COND_INITIALIZER; +static pthread_mutex_t s_writeMutex = PTHREAD_MUTEX_INITIALIZER; + +static ATCommandType s_type; +static const char *s_responsePrefix = NULL; +static const char *s_smsPDU = NULL; +static ATResponse *sp_response = NULL; + +static void (*s_onTimeout)(void) = NULL; +static void (*s_onReaderClosed)(void) = NULL; +static int s_readerClosed; + +static void onReaderClosed(); +static int writeCtrlZ (const char *s); +static int writeline (const char *s); + +#define NS_PER_S 1000000000 +static void setTimespecRelative(struct timespec *p_ts, long long msec) +{ + struct timeval tv; + + gettimeofday(&tv, (struct timezone *) NULL); + + p_ts->tv_sec = tv.tv_sec + (msec / 1000); + p_ts->tv_nsec = (tv.tv_usec + (msec % 1000) * 1000L ) * 1000L; + /* assuming tv.tv_usec < 10^6 */ + if (p_ts->tv_nsec >= NS_PER_S) { + p_ts->tv_sec++; + p_ts->tv_nsec -= NS_PER_S; + } +} + +static void sleepMsec(long long msec) +{ + struct timespec ts; + int err; + + ts.tv_sec = (msec / 1000); + ts.tv_nsec = (msec % 1000) * 1000 * 1000; + + do { + err = nanosleep (&ts, &ts); + } while (err < 0 && errno == EINTR); +} + + + +/** add an intermediate response to sp_response*/ +static void addIntermediate(const char *line) +{ + ATLine *p_new; + + p_new = (ATLine *) malloc(sizeof(ATLine)); + + p_new->line = strdup(line); + + /* note: this adds to the head of the list, so the list + will be in reverse order of lines received. the order is flipped + again before passing on to the command issuer */ + p_new->p_next = sp_response->p_intermediates; + sp_response->p_intermediates = p_new; +} + + +/** + * returns 1 if line is a final response indicating error + * See 27.007 annex B + * WARNING: NO CARRIER and others are sometimes unsolicited + */ +static const char * s_finalResponsesError[] = { + "ERROR", + "+CMS ERROR:", + "+CME ERROR:", + "NO CARRIER", /* sometimes! */ + "NO ANSWER", + "NO DIALTONE", +}; +static int isFinalResponseError(const char *line) +{ + size_t i; + + for (i = 0 ; i < NUM_ELEMS(s_finalResponsesError) ; i++) { + if (strStartsWith(line, s_finalResponsesError[i])) { + return 1; + } + } + + return 0; +} + +/** + * returns 1 if line is a final response indicating success + * See 27.007 annex B + * WARNING: NO CARRIER and others are sometimes unsolicited + */ +static const char * s_finalResponsesSuccess[] = { + "OK", + "CONNECT" /* some stacks start up data on another channel */ +}; +static int isFinalResponseSuccess(const char *line) +{ + size_t i; + + for (i = 0 ; i < NUM_ELEMS(s_finalResponsesSuccess) ; i++) { + if (strStartsWith(line, s_finalResponsesSuccess[i])) { + return 1; + } + } + + return 0; +} + +/** + * returns 1 if line is a final response, either error or success + * See 27.007 annex B + * WARNING: NO CARRIER and others are sometimes unsolicited + */ +static int isFinalResponse(const char *line) +{ + return isFinalResponseSuccess(line) || isFinalResponseError(line); +} + + +/** + * returns 1 if line is the first line in (what will be) a two-line + * SMS unsolicited response + */ +static const char * s_smsUnsoliciteds[] = { + "+CMT:", + "+CDS:", + "+CBM:" +}; +static int isSMSUnsolicited(const char *line) +{ + size_t i; + + for (i = 0 ; i < NUM_ELEMS(s_smsUnsoliciteds) ; i++) { + if (strStartsWith(line, s_smsUnsoliciteds[i])) { + return 1; + } + } + + return 0; +} + + +/** assumes s_commandmutex is held */ +static void handleFinalResponse(const char *line) +{ + sp_response->finalResponse = strdup(line); + + pthread_cond_signal(&s_commandcond); +} + +static void handleUnsolicited(const char *line) +{ + if (s_unsolHandler != NULL) { + s_unsolHandler(line, NULL); + } +} + +static void processLine(const char *line) +{ + pthread_mutex_lock(&s_commandmutex); + + if (sp_response == NULL) { + /* no command pending */ + handleUnsolicited(line); + } else if (isFinalResponseSuccess(line)) { + sp_response->success = 1; + handleFinalResponse(line); + } else if (isFinalResponseError(line)) { + sp_response->success = 0; + handleFinalResponse(line); + } else if (s_smsPDU != NULL && 0 == strcmp(line, "> ")) { + // See eg. TS 27.005 4.3 + // Commands like AT+CMGS have a "> " prompt + writeCtrlZ(s_smsPDU); + s_smsPDU = NULL; + } else switch (s_type) { + case NO_RESULT: + handleUnsolicited(line); + break; + case NUMERIC: + if (sp_response->p_intermediates == NULL + && isdigit(line[0]) + ) { + addIntermediate(line); + } else { + /* either we already have an intermediate response or + the line doesn't begin with a digit */ + handleUnsolicited(line); + } + break; + case SINGLELINE: + if (sp_response->p_intermediates == NULL + && strStartsWith (line, s_responsePrefix) + ) { + addIntermediate(line); + } else { + /* we already have an intermediate response */ + handleUnsolicited(line); + } + break; + case MULTILINE: + if (strStartsWith (line, s_responsePrefix)) { + addIntermediate(line); + } else { + handleUnsolicited(line); + } + break; + + default: /* this should never be reached */ + RLOGE("Unsupported AT command type %d\n", s_type); + handleUnsolicited(line); + break; + } + + pthread_mutex_unlock(&s_commandmutex); +} + + +/** + * Returns a pointer to the end of the next line + * special-cases the "> " SMS prompt + * + * returns NULL if there is no complete line + */ +static char * findNextEOL(char *cur) +{ + if (cur[0] == '>' && cur[1] == ' ' && cur[2] == '\0') { + /* SMS prompt character...not \r terminated */ + return cur+2; + } + + // Find next newline + while (*cur != '\0' && *cur != '\r' && *cur != '\n') cur++; + + return *cur == '\0' ? NULL : cur; +} + + +/** + * 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() +{ + 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 (*s_ATBufferCur == '\0') { + /* empty buffer */ + s_ATBufferCur = s_ATBuffer; + *s_ATBufferCur = '\0'; + p_read = s_ATBuffer; + } else { /* *s_ATBufferCur != '\0' */ + /* there's data in the buffer from the last read */ + + // skip over leading newlines + while (*s_ATBufferCur == '\r' || *s_ATBufferCur == '\n') + s_ATBufferCur++; + + p_eol = findNextEOL(s_ATBufferCur); + + if (p_eol == NULL) { + /* a partial line. move it up and prepare to read more */ + size_t len; + + len = strlen(s_ATBufferCur); + + memmove(s_ATBuffer, s_ATBufferCur, len + 1); + p_read = s_ATBuffer + len; + s_ATBufferCur = s_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 - s_ATBuffer)) { + RLOGE("ERROR: Input line exceeded buffer\n"); + /* ditch buffer and start over again */ + s_ATBufferCur = s_ATBuffer; + *s_ATBufferCur = '\0'; + p_read = s_ATBuffer; + } + + do { + count = read(s_fd, p_read, + MAX_AT_RESPONSE - (p_read - s_ATBuffer)); + } while (count < 0 && errno == EINTR); + + if (count > 0) { + AT_DUMP( "<< ", p_read, count ); + + p_read[count] = '\0'; + + // skip over leading newlines + while (*s_ATBufferCur == '\r' || *s_ATBufferCur == '\n') + s_ATBufferCur++; + + p_eol = findNextEOL(s_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 = s_ATBufferCur; + *p_eol = '\0'; + s_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 onReaderClosed() +{ + if (s_onReaderClosed != NULL && s_readerClosed == 0) { + + pthread_mutex_lock(&s_commandmutex); + + s_readerClosed = 1; + + pthread_cond_signal(&s_commandcond); + + pthread_mutex_unlock(&s_commandmutex); + + s_onReaderClosed(); + } +} + + +static void *readerLoop(void *arg __unused) +{ + for (;;) { + const char * line; + + line = readline(); + + if (line == NULL) { + break; + } + + if(isSMSUnsolicited(line)) { + char *line1; + const char *line2; + + // 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(); + + if (line2 == NULL) { + free(line1); + break; + } + + if (s_unsolHandler != NULL) { + s_unsolHandler (line1, line2); + } + free(line1); + } else { + processLine(line); + } + } + + onReaderClosed(); + + return NULL; +} + +/** + * 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) +{ + size_t cur = 0; + size_t len = strlen(s); + ssize_t written; + + if (s_fd < 0 || s_readerClosed > 0) { + return AT_ERROR_CHANNEL_CLOSED; + } + + RLOGD("AT> %s\n", s); + + AT_DUMP( ">> ", s, strlen(s) ); + + /* the main string */ + while (cur < len) { + do { + written = write (s_fd, s + cur, len - cur); + } while (written < 0 && errno == EINTR); + + if (written < 0) { + return AT_ERROR_GENERIC; + } + + cur += written; + } + + /* the \r */ + + do { + written = write (s_fd, "\r" , 1); + } while ((written < 0 && errno == EINTR) || (written == 0)); + + if (written < 0) { + return AT_ERROR_GENERIC; + } + + return 0; +} +static int writeCtrlZ (const char *s) +{ + size_t cur = 0; + size_t len = strlen(s); + ssize_t written; + + if (s_fd < 0 || s_readerClosed > 0) { + return AT_ERROR_CHANNEL_CLOSED; + } + + RLOGD("AT> %s^Z\n", s); + + AT_DUMP( ">* ", s, strlen(s) ); + + /* the main string */ + while (cur < len) { + do { + written = write (s_fd, s + cur, len - cur); + } while (written < 0 && errno == EINTR); + + if (written < 0) { + return AT_ERROR_GENERIC; + } + + cur += written; + } + + /* the ^Z */ + + do { + written = write (s_fd, "\032" , 1); + } while ((written < 0 && errno == EINTR) || (written == 0)); + + if (written < 0) { + return AT_ERROR_GENERIC; + } + + return 0; +} + +static void clearPendingCommand() +{ + if (sp_response != NULL) { + at_response_free(sp_response); + } + + sp_response = NULL; + s_responsePrefix = NULL; + s_smsPDU = NULL; +} + + +/** + * Starts AT handler on stream "fd' + * returns 0 on success, -1 on error + */ +int at_open(int fd, ATUnsolHandler h) +{ + int ret; + pthread_t tid; + pthread_attr_t attr; + + s_fd = fd; + s_unsolHandler = h; + s_readerClosed = 0; + + s_responsePrefix = NULL; + s_smsPDU = NULL; + sp_response = NULL; + + pthread_attr_init (&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + + ret = pthread_create(&s_tid_reader, &attr, readerLoop, &attr); + + if (ret < 0) { + perror ("pthread_create"); + return -1; + } + + + return 0; +} + +/* FIXME is it ok to call this from the reader and the command thread? */ +void at_close() +{ + if (s_fd >= 0) { + close(s_fd); + } + s_fd = -1; + + pthread_mutex_lock(&s_commandmutex); + + s_readerClosed = 1; + + pthread_cond_signal(&s_commandcond); + + pthread_mutex_unlock(&s_commandmutex); + + /* the reader thread should eventually die */ +} + +static ATResponse * at_response_new() +{ + return (ATResponse *) calloc(1, sizeof(ATResponse)); +} + +void at_response_free(ATResponse *p_response) +{ + ATLine *p_line; + + if (p_response == NULL) return; + + p_line = p_response->p_intermediates; + + while (p_line != NULL) { + ATLine *p_toFree; + + p_toFree = p_line; + p_line = p_line->p_next; + + free(p_toFree->line); + free(p_toFree); + } + + free (p_response->finalResponse); + free (p_response); +} + +/** + * The line reader places the intermediate responses in reverse order + * here we flip them back + */ +static void reverseIntermediates(ATResponse *p_response) +{ + ATLine *pcur,*pnext; + + pcur = p_response->p_intermediates; + p_response->p_intermediates = NULL; + + while (pcur != NULL) { + pnext = pcur->p_next; + pcur->p_next = p_response->p_intermediates; + p_response->p_intermediates = pcur; + pcur = pnext; + } +} + +/** + * Internal send_command implementation + * Doesn't lock or call the timeout callback + * + * timeoutMsec == 0 means infinite timeout + */ + +static int at_send_command_full_nolock (const char *command, ATCommandType type, + const char *responsePrefix, const char *smspdu, + long long timeoutMsec, ATResponse **pp_outResponse) +{ + int err = 0; + struct timespec ts; + + if(sp_response != NULL) { + err = AT_ERROR_COMMAND_PENDING; + goto error; + } + + err = writeline (command); + + if (err < 0) { + goto error; + } + + s_type = type; + s_responsePrefix = responsePrefix; + s_smsPDU = smspdu; + sp_response = at_response_new(); + + if (timeoutMsec != 0) { + setTimespecRelative(&ts, timeoutMsec); + } + + while (sp_response->finalResponse == NULL && s_readerClosed == 0) { + if (timeoutMsec != 0) { + err = pthread_cond_timedwait(&s_commandcond, &s_commandmutex, &ts); + } else { + err = pthread_cond_wait(&s_commandcond, &s_commandmutex); + } + + if (err == ETIMEDOUT) { + err = AT_ERROR_TIMEOUT; + goto error; + } + } + + if (pp_outResponse == NULL) { + at_response_free(sp_response); + } else { + /* line reader stores intermediate responses in reverse order */ + reverseIntermediates(sp_response); + *pp_outResponse = sp_response; + } + + sp_response = NULL; + + if(s_readerClosed > 0) { + err = AT_ERROR_CHANNEL_CLOSED; + goto error; + } + + err = 0; +error: + clearPendingCommand(); + + return err; +} + +/** + * Internal send_command implementation + * + * timeoutMsec == 0 means infinite timeout + */ +static int at_send_command_full (const char *command, ATCommandType type, + const char *responsePrefix, const char *smspdu, + long long timeoutMsec, ATResponse **pp_outResponse) +{ + int err; + bool inEmulator; + + if (0 != pthread_equal(s_tid_reader, pthread_self())) { + /* cannot be called from reader thread */ + return AT_ERROR_INVALID_THREAD; + } + inEmulator = isInEmulator(); + if (inEmulator) { + pthread_mutex_lock(&s_writeMutex); + } + pthread_mutex_lock(&s_commandmutex); + + err = at_send_command_full_nolock(command, type, + responsePrefix, smspdu, + timeoutMsec, pp_outResponse); + + pthread_mutex_unlock(&s_commandmutex); + if (inEmulator) { + pthread_mutex_unlock(&s_writeMutex); + } + + if (err == AT_ERROR_TIMEOUT && s_onTimeout != NULL) { + s_onTimeout(); + } + + return err; +} + + +/** + * Issue a single normal AT command with no intermediate response expected + * + * "command" should not include \r + * pp_outResponse can be NULL + * + * if non-NULL, the resulting ATResponse * must be eventually freed with + * at_response_free + */ +int at_send_command (const char *command, ATResponse **pp_outResponse) +{ + int err; + + err = at_send_command_full (command, NO_RESULT, NULL, + NULL, 0, pp_outResponse); + + return err; +} + + +int at_send_command_singleline (const char *command, + const char *responsePrefix, + ATResponse **pp_outResponse) +{ + int err; + + err = at_send_command_full (command, SINGLELINE, responsePrefix, + NULL, 0, pp_outResponse); + + if (err == 0 && pp_outResponse != NULL + && (*pp_outResponse)->success > 0 + && (*pp_outResponse)->p_intermediates == NULL + ) { + /* successful command must have an intermediate response */ + at_response_free(*pp_outResponse); + *pp_outResponse = NULL; + return AT_ERROR_INVALID_RESPONSE; + } + + return err; +} + + +int at_send_command_numeric (const char *command, + ATResponse **pp_outResponse) +{ + int err; + + err = at_send_command_full (command, NUMERIC, NULL, + NULL, 0, pp_outResponse); + + if (err == 0 && pp_outResponse != NULL + && (*pp_outResponse)->success > 0 + && (*pp_outResponse)->p_intermediates == NULL + ) { + /* successful command must have an intermediate response */ + at_response_free(*pp_outResponse); + *pp_outResponse = NULL; + return AT_ERROR_INVALID_RESPONSE; + } + + return err; +} + + +int at_send_command_sms (const char *command, + const char *pdu, + const char *responsePrefix, + ATResponse **pp_outResponse) +{ + int err; + + err = at_send_command_full (command, SINGLELINE, responsePrefix, + pdu, 0, pp_outResponse); + + if (err == 0 && pp_outResponse != NULL + && (*pp_outResponse)->success > 0 + && (*pp_outResponse)->p_intermediates == NULL + ) { + /* successful command must have an intermediate response */ + at_response_free(*pp_outResponse); + *pp_outResponse = NULL; + return AT_ERROR_INVALID_RESPONSE; + } + + return err; +} + + +int at_send_command_multiline (const char *command, + const char *responsePrefix, + ATResponse **pp_outResponse) +{ + int err; + + err = at_send_command_full (command, MULTILINE, responsePrefix, + NULL, 0, pp_outResponse); + + return err; +} + + +/** This callback is invoked on the command thread */ +void at_set_on_timeout(void (*onTimeout)(void)) +{ + s_onTimeout = onTimeout; +} + +/** + * This callback is invoked on the reader thread (like ATUnsolHandler) + * when the input stream closes before you call at_close + * (not when you call at_close()) + * You should still call at_close() + */ + +void at_set_on_reader_closed(void (*onClose)(void)) +{ + s_onReaderClosed = onClose; +} + + +/** + * Periodically issue an AT command and wait for a response. + * Used to ensure channel has start up and is active + */ + +int at_handshake() +{ + int i; + int err = 0; + bool inEmulator; + + if (0 != pthread_equal(s_tid_reader, pthread_self())) { + /* cannot be called from reader thread */ + return AT_ERROR_INVALID_THREAD; + } + inEmulator = isInEmulator(); + if (inEmulator) { + pthread_mutex_lock(&s_writeMutex); + } + pthread_mutex_lock(&s_commandmutex); + + for (i = 0 ; i < HANDSHAKE_RETRY_COUNT ; i++) { + /* some stacks start with verbose off */ + err = at_send_command_full_nolock ("ATE0Q0V1", NO_RESULT, + NULL, NULL, HANDSHAKE_TIMEOUT_MSEC, NULL); + + if (err == 0) { + break; + } + } + + if (err == 0) { + /* pause for a bit to let the input buffer drain any unmatched OK's + (they will appear as extraneous unsolicited responses) */ + + sleepMsec(HANDSHAKE_TIMEOUT_MSEC); + } + + pthread_mutex_unlock(&s_commandmutex); + if (inEmulator) { + pthread_mutex_unlock(&s_writeMutex); + } + + return err; +} + +/** + * Returns error code from response + * Assumes AT+CMEE=1 (numeric) mode + */ +AT_CME_Error at_get_cme_error(const ATResponse *p_response) +{ + int ret; + int err; + char *p_cur; + + if (p_response->success > 0) { + return CME_SUCCESS; + } + + if (p_response->finalResponse == NULL + || !strStartsWith(p_response->finalResponse, "+CME ERROR:") + ) { + return CME_ERROR_NON_CME; + } + + p_cur = p_response->finalResponse; + err = at_tok_start(&p_cur); + + if (err < 0) { + return CME_ERROR_NON_CME; + } + + err = at_tok_nextint(&p_cur, &ret); + + if (err < 0) { + return CME_ERROR_NON_CME; + } + + return (AT_CME_Error) ret; +} + diff --git a/ril/atchannel.h b/ril/atchannel.h new file mode 100644 index 0000000..9282915 --- /dev/null +++ b/ril/atchannel.h @@ -0,0 +1,124 @@ +/* //device/system/reference-ril/atchannel.h +** +** Copyright 2006, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +#ifndef ATCHANNEL_H +#define ATCHANNEL_H 1 + +#ifdef __cplusplus +extern "C" { +#endif + +/* define AT_DEBUG to send AT traffic to /tmp/radio-at.log" */ +#define AT_DEBUG 0 + +#if AT_DEBUG +extern void AT_DUMP(const char* prefix, const char* buff, int len); +#else +#define AT_DUMP(prefix,buff,len) do{}while(0) +#endif + +#define AT_ERROR_GENERIC (-1) +#define AT_ERROR_COMMAND_PENDING (-2) +#define AT_ERROR_CHANNEL_CLOSED (-3) +#define AT_ERROR_TIMEOUT (-4) +#define AT_ERROR_INVALID_THREAD (-5) /* AT commands may not be issued from + reader thread (or unsolicited response + callback */ +#define AT_ERROR_INVALID_RESPONSE (-6) /* eg an at_send_command_singleline that + did not get back an intermediate + response */ + + +typedef enum { + NO_RESULT, /* no intermediate response expected */ + NUMERIC, /* a single intermediate response starting with a 0-9 */ + SINGLELINE, /* a single intermediate response starting with a prefix */ + MULTILINE /* multiple line intermediate response + starting with a prefix */ +} ATCommandType; + +/** a singly-lined list of intermediate responses */ +typedef struct ATLine { + struct ATLine *p_next; + char *line; +} ATLine; + +/** Free this with at_response_free() */ +typedef struct { + int success; /* true if final response indicates + success (eg "OK") */ + char *finalResponse; /* eg OK, ERROR */ + ATLine *p_intermediates; /* any intermediate responses */ +} ATResponse; + +/** + * a user-provided unsolicited response handler function + * this will be called from the reader thread, so do not block + * "s" is the line, and "sms_pdu" is either NULL or the PDU response + * for multi-line TS 27.005 SMS PDU responses (eg +CMT:) + */ +typedef void (*ATUnsolHandler)(const char *s, const char *sms_pdu); + +int at_open(int fd, ATUnsolHandler h); +void at_close(); + +/* This callback is invoked on the command thread. + You should reset or handshake here to avoid getting out of sync */ +void at_set_on_timeout(void (*onTimeout)(void)); +/* This callback is invoked on the reader thread (like ATUnsolHandler) + when the input stream closes before you call at_close + (not when you call at_close()) + You should still call at_close() + It may also be invoked immediately from the current thread if the read + channel is already closed */ +void at_set_on_reader_closed(void (*onClose)(void)); + +int at_send_command_singleline (const char *command, + const char *responsePrefix, + ATResponse **pp_outResponse); + +int at_send_command_numeric (const char *command, + ATResponse **pp_outResponse); + +int at_send_command_multiline (const char *command, + const char *responsePrefix, + ATResponse **pp_outResponse); + + +int at_handshake(); + +int at_send_command (const char *command, ATResponse **pp_outResponse); + +int at_send_command_sms (const char *command, const char *pdu, + const char *responsePrefix, + ATResponse **pp_outResponse); + +void at_response_free(ATResponse *p_response); + +typedef enum { + CME_ERROR_NON_CME = -1, + CME_SUCCESS = 0, + CME_SIM_NOT_INSERTED = 10 +} AT_CME_Error; + +AT_CME_Error at_get_cme_error(const ATResponse *p_response); + +#ifdef __cplusplus +} +#endif + +#endif /*ATCHANNEL_H*/ diff --git a/ril/misc.c b/ril/misc.c new file mode 100644 index 0000000..c0e9b6e --- /dev/null +++ b/ril/misc.c @@ -0,0 +1,40 @@ +/* //device/system/reference-ril/misc.c +** +** Copyright 2006, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ +#include + +#include "misc.h" +/** returns 1 if line starts with prefix, 0 if it does not */ +int strStartsWith(const char *line, const char *prefix) +{ + for ( ; *line != '\0' && *prefix != '\0' ; line++, prefix++) { + if (*line != *prefix) { + return 0; + } + } + + return *prefix == '\0'; +} + +// Returns true iff running this process in an emulator VM +bool isInEmulator(void) { + static int inQemu = -1; + if (inQemu < 0) { + char propValue[PROP_VALUE_MAX]; + inQemu = (__system_property_get("ro.kernel.qemu", propValue) != 0); + } + return inQemu == 1; +} diff --git a/ril/misc.h b/ril/misc.h new file mode 100644 index 0000000..9e65ab3 --- /dev/null +++ b/ril/misc.h @@ -0,0 +1,22 @@ +/* //device/system/reference-ril/misc.h +** +** Copyright 2006, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ +#include + +/** returns 1 if line starts with prefix, 0 if it does not */ +int strStartsWith(const char *line, const char *prefix); +/** Returns true iff running this process in an emulator VM */ +bool isInEmulator(void); \ No newline at end of file diff --git a/ril/reference-ril.c b/ril/reference-ril.c new file mode 100644 index 0000000..084c4ad --- /dev/null +++ b/ril/reference-ril.c @@ -0,0 +1,3867 @@ +/* //device/system/reference-ril/reference-ril.c +** +** Copyright 2006, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "atchannel.h" +#include "at_tok.h" +#include "misc.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ril.h" + +#define LOG_TAG "RIL" +#include + +static void *noopRemoveWarning( void *a ) { return a; } +#define RIL_UNUSED_PARM(a) noopRemoveWarning((void *)&(a)); + +#define MAX_AT_RESPONSE 0x1000 + +/* pathname returned from RIL_REQUEST_SETUP_DATA_CALL / RIL_REQUEST_SETUP_DEFAULT_PDP */ +// This is used if Wifi is not supported, plain old eth0 +#define PPP_TTY_PATH_ETH0 "eth0" +// This is used if Wifi is supported to separate radio and wifi interface +#define PPP_TTY_PATH_RADIO0 "radio0" + +// Default MTU value +#define DEFAULT_MTU 1500 + +#ifdef USE_TI_COMMANDS + +// Enable a workaround +// 1) Make incoming call, do not answer +// 2) Hangup remote end +// Expected: call should disappear from CLCC line +// Actual: Call shows as "ACTIVE" before disappearing +#define WORKAROUND_ERRONEOUS_ANSWER 1 + +// Some varients of the TI stack do not support the +CGEV unsolicited +// response. However, they seem to send an unsolicited +CME ERROR: 150 +#define WORKAROUND_FAKE_CGEV 1 +#endif + +/* Modem Technology bits */ +#define MDM_GSM 0x01 +#define MDM_WCDMA 0x02 +#define MDM_CDMA 0x04 +#define MDM_EVDO 0x08 +#define MDM_LTE 0x10 + +typedef struct { + int supportedTechs; // Bitmask of supported Modem Technology bits + int currentTech; // Technology the modem is currently using (in the format used by modem) + int isMultimode; + + // Preferred mode bitmask. This is actually 4 byte-sized bitmasks with different priority values, + // in which the byte number from LSB to MSB give the priority. + // + // |MSB| | |LSB + // value: |00 |00 |00 |00 + // byte #: |3 |2 |1 |0 + // + // Higher byte order give higher priority. Thus, a value of 0x0000000f represents + // a preferred mode of GSM, WCDMA, CDMA, and EvDo in which all are equally preferrable, whereas + // 0x00000201 represents a mode with GSM and WCDMA, in which WCDMA is preferred over GSM + int32_t preferredNetworkMode; + int subscription_source; + +} ModemInfo; + +static ModemInfo *sMdmInfo; +// TECH returns the current technology in the format used by the modem. +// It can be used as an l-value +#define TECH(mdminfo) ((mdminfo)->currentTech) +// TECH_BIT returns the bitmask equivalent of the current tech +#define TECH_BIT(mdminfo) (1 << ((mdminfo)->currentTech)) +#define IS_MULTIMODE(mdminfo) ((mdminfo)->isMultimode) +#define TECH_SUPPORTED(mdminfo, tech) ((mdminfo)->supportedTechs & (tech)) +#define PREFERRED_NETWORK(mdminfo) ((mdminfo)->preferredNetworkMode) +// CDMA Subscription Source +#define SSOURCE(mdminfo) ((mdminfo)->subscription_source) + +static int net2modem[] = { + MDM_GSM | MDM_WCDMA, // 0 - GSM / WCDMA Pref + MDM_GSM, // 1 - GSM only + MDM_WCDMA, // 2 - WCDMA only + MDM_GSM | MDM_WCDMA, // 3 - GSM / WCDMA Auto + MDM_CDMA | MDM_EVDO, // 4 - CDMA / EvDo Auto + MDM_CDMA, // 5 - CDMA only + MDM_EVDO, // 6 - EvDo only + MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO, // 7 - GSM/WCDMA, CDMA, EvDo + MDM_LTE | MDM_CDMA | MDM_EVDO, // 8 - LTE, CDMA and EvDo + MDM_LTE | MDM_GSM | MDM_WCDMA, // 9 - LTE, GSM/WCDMA + MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA, // 10 - LTE, CDMA, EvDo, GSM/WCDMA + MDM_LTE, // 11 - LTE only +}; + +static int32_t net2pmask[] = { + MDM_GSM | (MDM_WCDMA << 8), // 0 - GSM / WCDMA Pref + MDM_GSM, // 1 - GSM only + MDM_WCDMA, // 2 - WCDMA only + MDM_GSM | MDM_WCDMA, // 3 - GSM / WCDMA Auto + MDM_CDMA | MDM_EVDO, // 4 - CDMA / EvDo Auto + MDM_CDMA, // 5 - CDMA only + MDM_EVDO, // 6 - EvDo only + MDM_GSM | MDM_WCDMA | MDM_CDMA | MDM_EVDO, // 7 - GSM/WCDMA, CDMA, EvDo + MDM_LTE | MDM_CDMA | MDM_EVDO, // 8 - LTE, CDMA and EvDo + MDM_LTE | MDM_GSM | MDM_WCDMA, // 9 - LTE, GSM/WCDMA + MDM_LTE | MDM_CDMA | MDM_EVDO | MDM_GSM | MDM_WCDMA, // 10 - LTE, CDMA, EvDo, GSM/WCDMA + MDM_LTE, // 11 - LTE only +}; + +static int is3gpp2(int radioTech) { + switch (radioTech) { + case RADIO_TECH_IS95A: + case RADIO_TECH_IS95B: + case RADIO_TECH_1xRTT: + case RADIO_TECH_EVDO_0: + case RADIO_TECH_EVDO_A: + case RADIO_TECH_EVDO_B: + case RADIO_TECH_EHRPD: + return 1; + default: + return 0; + } +} + +typedef enum { + SIM_ABSENT = 0, + SIM_NOT_READY = 1, + SIM_READY = 2, + SIM_PIN = 3, + SIM_PUK = 4, + SIM_NETWORK_PERSONALIZATION = 5, + RUIM_ABSENT = 6, + RUIM_NOT_READY = 7, + RUIM_READY = 8, + RUIM_PIN = 9, + RUIM_PUK = 10, + RUIM_NETWORK_PERSONALIZATION = 11, + ISIM_ABSENT = 12, + ISIM_NOT_READY = 13, + ISIM_READY = 14, + ISIM_PIN = 15, + ISIM_PUK = 16, + ISIM_NETWORK_PERSONALIZATION = 17, +} SIM_Status; + +static void onRequest (int request, void *data, size_t datalen, RIL_Token t); +static RIL_RadioState currentState(); +static int onSupports (int requestCode); +static void onCancel (RIL_Token t); +static const char *getVersion(); +static int isRadioOn(); +static SIM_Status getSIMStatus(); +static int getCardStatus(RIL_CardStatus_v6 **pp_card_status); +static void freeCardStatus(RIL_CardStatus_v6 *p_card_status); +static void onDataCallListChanged(void *param); + +extern const char * requestToString(int request); + +/*** Static Variables ***/ +static const RIL_RadioFunctions s_callbacks = { + RIL_VERSION, + onRequest, + currentState, + onSupports, + onCancel, + getVersion +}; + +#ifdef RIL_SHLIB +static const struct RIL_Env *s_rilenv; + +#define RIL_onRequestComplete(t, e, response, responselen) s_rilenv->OnRequestComplete(t,e, response, responselen) +#define RIL_onUnsolicitedResponse(a,b,c) s_rilenv->OnUnsolicitedResponse(a,b,c) +#define RIL_requestTimedCallback(a,b,c) s_rilenv->RequestTimedCallback(a,b,c) +#endif + +static RIL_RadioState sState = RADIO_STATE_UNAVAILABLE; + +static pthread_mutex_t s_state_mutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t s_state_cond = PTHREAD_COND_INITIALIZER; + +static int s_port = -1; +static const char * s_device_path = NULL; +static int s_device_socket = 0; + +/* trigger change to this with s_state_cond */ +static int s_closed = 0; + +static int sFD; /* file desc of AT channel */ +static char sATBuffer[MAX_AT_RESPONSE+1]; +static char *sATBufferCur = NULL; + +static const struct timeval TIMEVAL_SIMPOLL = {1,0}; +static const struct timeval TIMEVAL_CALLSTATEPOLL = {0,500000}; +static const struct timeval TIMEVAL_0 = {0,0}; + +static int s_ims_registered = 0; // 0==unregistered +static int s_ims_services = 1; // & 0x1 == sms over ims supported +static int s_ims_format = 1; // FORMAT_3GPP(1) vs FORMAT_3GPP2(2); +static int s_ims_cause_retry = 0; // 1==causes sms over ims to temp fail +static int s_ims_cause_perm_failure = 0; // 1==causes sms over ims to permanent fail +static int s_ims_gsm_retry = 0; // 1==causes sms over gsm to temp fail +static int s_ims_gsm_fail = 0; // 1==causes sms over gsm to permanent fail + +#ifdef WORKAROUND_ERRONEOUS_ANSWER +// Max number of times we'll try to repoll when we think +// we have a AT+CLCC race condition +#define REPOLL_CALLS_COUNT_MAX 4 + +// Line index that was incoming or waiting at last poll, or -1 for none +static int s_incomingOrWaitingLine = -1; +// Number of times we've asked for a repoll of AT+CLCC +static int s_repollCallsCount = 0; +// Should we expect a call to be answered in the next CLCC? +static int s_expectAnswer = 0; +#endif /* WORKAROUND_ERRONEOUS_ANSWER */ + + +static int s_cell_info_rate_ms = INT_MAX; +static int s_mcc = 0; +static int s_mnc = 0; +static int s_lac = 0; +static int s_cid = 0; + +static void pollSIMState (void *param); +static void setRadioState(RIL_RadioState newState); +static void setRadioTechnology(ModemInfo *mdm, int newtech); +static int query_ctec(ModemInfo *mdm, int *current, int32_t *preferred); +static int parse_technology_response(const char *response, int *current, int32_t *preferred); +static int techFromModemType(int mdmtype); + +static int clccStateToRILState(int state, RIL_CallState *p_state) + +{ + switch(state) { + case 0: *p_state = RIL_CALL_ACTIVE; return 0; + case 1: *p_state = RIL_CALL_HOLDING; return 0; + case 2: *p_state = RIL_CALL_DIALING; return 0; + case 3: *p_state = RIL_CALL_ALERTING; return 0; + case 4: *p_state = RIL_CALL_INCOMING; return 0; + case 5: *p_state = RIL_CALL_WAITING; return 0; + default: return -1; + } +} + +/** + * Note: directly modified line and has *p_call point directly into + * modified line + */ +static int callFromCLCCLine(char *line, RIL_Call *p_call) +{ + //+CLCC: 1,0,2,0,0,\"+18005551212\",145 + // index,isMT,state,mode,isMpty(,number,TOA)? + + int err; + int state; + int mode; + + err = at_tok_start(&line); + if (err < 0) goto error; + + err = at_tok_nextint(&line, &(p_call->index)); + if (err < 0) goto error; + + err = at_tok_nextbool(&line, &(p_call->isMT)); + if (err < 0) goto error; + + err = at_tok_nextint(&line, &state); + if (err < 0) goto error; + + err = clccStateToRILState(state, &(p_call->state)); + if (err < 0) goto error; + + err = at_tok_nextint(&line, &mode); + if (err < 0) goto error; + + p_call->isVoice = (mode == 0); + + err = at_tok_nextbool(&line, &(p_call->isMpty)); + if (err < 0) goto error; + + if (at_tok_hasmore(&line)) { + err = at_tok_nextstr(&line, &(p_call->number)); + + /* tolerate null here */ + if (err < 0) return 0; + + // Some lame implementations return strings + // like "NOT AVAILABLE" in the CLCC line + if (p_call->number != NULL + && 0 == strspn(p_call->number, "+0123456789") + ) { + p_call->number = NULL; + } + + err = at_tok_nextint(&line, &p_call->toa); + if (err < 0) goto error; + } + + p_call->uusInfo = NULL; + + return 0; + +error: + RLOGE("invalid CLCC line\n"); + return -1; +} + +static int parseSimResponseLine(char* line, RIL_SIM_IO_Response* response) { + int err; + + err = at_tok_start(&line); + if (err < 0) return err; + err = at_tok_nextint(&line, &response->sw1); + if (err < 0) return err; + err = at_tok_nextint(&line, &response->sw2); + if (err < 0) return err; + + if (at_tok_hasmore(&line)) { + err = at_tok_nextstr(&line, &response->simResponse); + if (err < 0) return err; + } + return 0; +} + +enum InterfaceState { + kInterfaceUp, + kInterfaceDown, +}; + +static RIL_Errno setInterfaceState(const char* interfaceName, + enum InterfaceState state) { + struct ifreq request; + int status = 0; + int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP); + if (sock == -1) { + RLOGE("Failed to open interface socket: %s (%d)", + strerror(errno), errno); + return RIL_E_GENERIC_FAILURE; + } + + memset(&request, 0, sizeof(request)); + strncpy(request.ifr_name, interfaceName, sizeof(request.ifr_name)); + request.ifr_name[sizeof(request.ifr_name) - 1] = '\0'; + status = ioctl(sock, SIOCGIFFLAGS, &request); + if (status != 0) { + RLOGE("Failed to get interface flags for %s: %s (%d)", + interfaceName, strerror(errno), errno); + close(sock); + return RIL_E_RADIO_NOT_AVAILABLE; + } + + bool isUp = (request.ifr_flags & IFF_UP); + if ((state == kInterfaceUp && isUp) || (state == kInterfaceDown && !isUp)) { + // Interface already in desired state + close(sock); + return RIL_E_SUCCESS; + } + + // Simply toggle the flag since we know it's the opposite of what we want + request.ifr_flags ^= IFF_UP; + + status = ioctl(sock, SIOCSIFFLAGS, &request); + if (status != 0) { + RLOGE("Failed to set interface flags for %s: %s (%d)", + interfaceName, strerror(errno), errno); + close(sock); + return RIL_E_GENERIC_FAILURE; + } + + close(sock); + return RIL_E_SUCCESS; +} + +/** do post-AT+CFUN=1 initialization */ +static void onRadioPowerOn() +{ +#ifdef USE_TI_COMMANDS + /* Must be after CFUN=1 */ + /* TI specific -- notifications for CPHS things such */ + /* as CPHS message waiting indicator */ + + at_send_command("AT%CPHS=1", NULL); + + /* TI specific -- enable NITZ unsol notifs */ + at_send_command("AT%CTZV=1", NULL); +#endif + + pollSIMState(NULL); +} + +/** do post- SIM ready initialization */ +static void onSIMReady() +{ + at_send_command_singleline("AT+CSMS=1", "+CSMS:", NULL); + /* + * Always send SMS messages directly to the TE + * + * mode = 1 // discard when link is reserved (link should never be + * reserved) + * mt = 2 // most messages routed to TE + * bm = 2 // new cell BM's routed to TE + * ds = 1 // Status reports routed to TE + * bfr = 1 // flush buffer + */ + at_send_command("AT+CNMI=1,2,2,1,1", NULL); +} + +static void requestRadioPower(void *data, size_t datalen __unused, RIL_Token t) +{ + int onOff; + + int err; + ATResponse *p_response = NULL; + + assert (datalen >= sizeof(int *)); + onOff = ((int *)data)[0]; + + if (onOff == 0 && sState != RADIO_STATE_OFF) { + err = at_send_command("AT+CFUN=0", &p_response); + if (err < 0 || p_response->success == 0) goto error; + setRadioState(RADIO_STATE_OFF); + } else if (onOff > 0 && sState == RADIO_STATE_OFF) { + err = at_send_command("AT+CFUN=1", &p_response); + if (err < 0|| p_response->success == 0) { + // Some stacks return an error when there is no SIM, + // but they really turn the RF portion on + // So, if we get an error, let's check to see if it + // turned on anyway + + if (isRadioOn() != 1) { + goto error; + } + } + setRadioState(RADIO_STATE_ON); + } + + at_response_free(p_response); + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + return; +error: + at_response_free(p_response); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); +} + +static void requestShutdown(RIL_Token t) +{ + int onOff; + + int err; + ATResponse *p_response = NULL; + + if (sState != RADIO_STATE_OFF) { + err = at_send_command("AT+CFUN=0", &p_response); + setRadioState(RADIO_STATE_UNAVAILABLE); + } + + at_response_free(p_response); + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + return; +} + +static void requestOrSendDataCallList(RIL_Token *t); + +static void onDataCallListChanged(void *param __unused) +{ + requestOrSendDataCallList(NULL); +} + +static void requestDataCallList(void *data __unused, size_t datalen __unused, RIL_Token t) +{ + requestOrSendDataCallList(&t); +} + +// Hang up, reject, conference, call waiting +static void requestCallSelection( + void *data __unused, size_t datalen __unused, RIL_Token t, int request) +{ + // 3GPP 22.030 6.5.5 + static char hangupWaiting[] = "AT+CHLD=0"; + static char hangupForeground[] = "AT+CHLD=1"; + static char switchWaiting[] = "AT+CHLD=2"; + static char conference[] = "AT+CHLD=3"; + static char reject[] = "ATH"; + + char* atCommand; + + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); + return; + } + + switch(request) { + case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: + // "Releases all held calls or sets User Determined User Busy + // (UDUB) for a waiting call." + atCommand = hangupWaiting; + break; + case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: + // "Releases all active calls (if any exist) and accepts + // the other (held or waiting) call." + atCommand = hangupForeground; + break; + case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: + // "Places all active calls (if any exist) on hold and accepts + // the other (held or waiting) call." + atCommand = switchWaiting; +#ifdef WORKAROUND_ERRONEOUS_ANSWER + s_expectAnswer = 1; +#endif /* WORKAROUND_ERRONEOUS_ANSWER */ + break; + case RIL_REQUEST_CONFERENCE: + // "Adds a held call to the conversation" + atCommand = conference; + break; + case RIL_REQUEST_UDUB: + // User determined user busy (reject) + atCommand = reject; + break; + default: + assert(0); + } + at_send_command(atCommand, NULL); + // Success or failure is ignored by the upper layer here. + // It will call GET_CURRENT_CALLS and determine success that way. + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); +} + +static bool hasWifiCapability() +{ + char propValue[PROP_VALUE_MAX]; + return property_get("ro.kernel.qemu.wifi", propValue, "") > 0 && + strcmp("1", propValue) == 0; +} + +static const char* getRadioInterfaceName(bool hasWifi) +{ + return hasWifi ? PPP_TTY_PATH_RADIO0 : PPP_TTY_PATH_ETH0; +} + +static void requestOrSendDataCallList(RIL_Token *t) +{ + ATResponse *p_response; + ATLine *p_cur; + int err; + int n = 0; + char *out; + char propValue[PROP_VALUE_MAX]; + bool hasWifi = hasWifiCapability(); + const char* radioInterfaceName = getRadioInterfaceName(hasWifi); + + err = at_send_command_multiline ("AT+CGACT?", "+CGACT:", &p_response); + if (err != 0 || p_response->success == 0) { + if (t != NULL) + RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); + else + RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, + NULL, 0); + return; + } + + for (p_cur = p_response->p_intermediates; p_cur != NULL; + p_cur = p_cur->p_next) + n++; + + RIL_Data_Call_Response_v11 *responses = + alloca(n * sizeof(RIL_Data_Call_Response_v11)); + + int i; + for (i = 0; i < n; i++) { + responses[i].status = -1; + responses[i].suggestedRetryTime = -1; + responses[i].cid = -1; + responses[i].active = -1; + responses[i].type = ""; + responses[i].ifname = ""; + responses[i].addresses = ""; + responses[i].dnses = ""; + responses[i].gateways = ""; + responses[i].pcscf = ""; + responses[i].mtu = 0; + } + + RIL_Data_Call_Response_v11 *response = responses; + for (p_cur = p_response->p_intermediates; p_cur != NULL; + p_cur = p_cur->p_next) { + char *line = p_cur->line; + + err = at_tok_start(&line); + if (err < 0) + goto error; + + err = at_tok_nextint(&line, &response->cid); + if (err < 0) + goto error; + + err = at_tok_nextint(&line, &response->active); + if (err < 0) + goto error; + + response++; + } + + at_response_free(p_response); + + err = at_send_command_multiline ("AT+CGDCONT?", "+CGDCONT:", &p_response); + if (err != 0 || p_response->success == 0) { + if (t != NULL) + RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); + else + RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, + NULL, 0); + return; + } + + for (p_cur = p_response->p_intermediates; p_cur != NULL; + p_cur = p_cur->p_next) { + char *line = p_cur->line; + int cid; + + err = at_tok_start(&line); + if (err < 0) + goto error; + + err = at_tok_nextint(&line, &cid); + if (err < 0) + goto error; + + for (i = 0; i < n; i++) { + if (responses[i].cid == cid) + break; + } + + if (i >= n) { + /* details for a context we didn't hear about in the last request */ + continue; + } + + // Assume no error + responses[i].status = 0; + + // type + err = at_tok_nextstr(&line, &out); + if (err < 0) + goto error; + + int type_size = strlen(out) + 1; + responses[i].type = alloca(type_size); + strlcpy(responses[i].type, out, type_size); + + // APN ignored for v5 + err = at_tok_nextstr(&line, &out); + if (err < 0) + goto error; + + int ifname_size = strlen(radioInterfaceName) + 1; + responses[i].ifname = alloca(ifname_size); + strlcpy(responses[i].ifname, radioInterfaceName, ifname_size); + + err = at_tok_nextstr(&line, &out); + if (err < 0) + goto error; + + int addresses_size = strlen(out) + 1; + responses[i].addresses = alloca(addresses_size); + strlcpy(responses[i].addresses, out, addresses_size); + + if (isInEmulator()) { + /* We are in the emulator - the dns servers are listed + * by the following system properties, setup in + * /system/etc/init.goldfish.sh: + * - net.eth0.dns1 + * - net.eth0.dns2 + * - net.eth0.dns3 + * - net.eth0.dns4 + */ + const int dnslist_sz = 128; + char* dnslist = alloca(dnslist_sz); + const char* separator = ""; + int nn; + + dnslist[0] = 0; + for (nn = 1; nn <= 4; nn++) { + /* Probe net.eth0.dns */ + char propName[PROP_NAME_MAX]; + char propValue[PROP_VALUE_MAX]; + + snprintf(propName, sizeof propName, "net.eth0.dns%d", nn); + + /* Ignore if undefined */ + if (property_get(propName, propValue, "") <= 0) { + continue; + } + + /* Append the DNS IP address */ + strlcat(dnslist, separator, dnslist_sz); + strlcat(dnslist, propValue, dnslist_sz); + separator = " "; + } + responses[i].dnses = dnslist; + + /* There is only one gateway in the emulator. If WiFi is + * configured the interface visible to RIL will be behind a NAT + * where the gateway is different. */ + if (hasWifi) { + responses[i].gateways = "192.168.200.1"; + } else if (property_get("net.eth0.gw", propValue, "") > 0) { + responses[i].gateways = propValue; + } else { + responses[i].gateways = ""; + } + responses[i].mtu = DEFAULT_MTU; + } + else { + /* I don't know where we are, so use the public Google DNS + * servers by default and no gateway. + */ + responses[i].dnses = "8.8.8.8 8.8.4.4"; + responses[i].gateways = ""; + } + } + + at_response_free(p_response); + + if (t != NULL) + RIL_onRequestComplete(*t, RIL_E_SUCCESS, responses, + n * sizeof(RIL_Data_Call_Response_v11)); + else + RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, + responses, + n * sizeof(RIL_Data_Call_Response_v11)); + + return; + +error: + if (t != NULL) + RIL_onRequestComplete(*t, RIL_E_GENERIC_FAILURE, NULL, 0); + else + RIL_onUnsolicitedResponse(RIL_UNSOL_DATA_CALL_LIST_CHANGED, + NULL, 0); + + at_response_free(p_response); +} + +static void requestQueryNetworkSelectionMode( + void *data __unused, size_t datalen __unused, RIL_Token t) +{ + int err; + ATResponse *p_response = NULL; + int response = 0; + char *line; + + err = at_send_command_singleline("AT+COPS?", "+COPS:", &p_response); + + if (err < 0 || p_response->success == 0) { + goto error; + } + + line = p_response->p_intermediates->line; + + err = at_tok_start(&line); + + if (err < 0) { + goto error; + } + + err = at_tok_nextint(&line, &response); + + if (err < 0) { + goto error; + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(int)); + at_response_free(p_response); + return; +error: + at_response_free(p_response); + RLOGE("requestQueryNetworkSelectionMode must never return error when radio is on"); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); +} + +static void sendCallStateChanged(void *param __unused) +{ + RIL_onUnsolicitedResponse ( + RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, + NULL, 0); +} + +static void requestGetCurrentCalls(void *data __unused, size_t datalen __unused, RIL_Token t) +{ + int err; + ATResponse *p_response; + ATLine *p_cur; + int countCalls; + int countValidCalls; + RIL_Call *p_calls; + RIL_Call **pp_calls; + int i; + int needRepoll = 0; + +#ifdef WORKAROUND_ERRONEOUS_ANSWER + int prevIncomingOrWaitingLine; + + prevIncomingOrWaitingLine = s_incomingOrWaitingLine; + s_incomingOrWaitingLine = -1; +#endif /*WORKAROUND_ERRONEOUS_ANSWER*/ + + err = at_send_command_multiline ("AT+CLCC", "+CLCC:", &p_response); + + if (err != 0 || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + + /* count the calls */ + for (countCalls = 0, p_cur = p_response->p_intermediates + ; p_cur != NULL + ; p_cur = p_cur->p_next + ) { + countCalls++; + } + + /* yes, there's an array of pointers and then an array of structures */ + + pp_calls = (RIL_Call **)alloca(countCalls * sizeof(RIL_Call *)); + p_calls = (RIL_Call *)alloca(countCalls * sizeof(RIL_Call)); + memset (p_calls, 0, countCalls * sizeof(RIL_Call)); + + /* init the pointer array */ + for(i = 0; i < countCalls ; i++) { + pp_calls[i] = &(p_calls[i]); + } + + for (countValidCalls = 0, p_cur = p_response->p_intermediates + ; p_cur != NULL + ; p_cur = p_cur->p_next + ) { + err = callFromCLCCLine(p_cur->line, p_calls + countValidCalls); + + if (err != 0) { + continue; + } + +#ifdef WORKAROUND_ERRONEOUS_ANSWER + if (p_calls[countValidCalls].state == RIL_CALL_INCOMING + || p_calls[countValidCalls].state == RIL_CALL_WAITING + ) { + s_incomingOrWaitingLine = p_calls[countValidCalls].index; + } +#endif /*WORKAROUND_ERRONEOUS_ANSWER*/ + + if (p_calls[countValidCalls].state != RIL_CALL_ACTIVE + && p_calls[countValidCalls].state != RIL_CALL_HOLDING + ) { + needRepoll = 1; + } + + countValidCalls++; + } + +#ifdef WORKAROUND_ERRONEOUS_ANSWER + // Basically: + // A call was incoming or waiting + // Now it's marked as active + // But we never answered it + // + // This is probably a bug, and the call will probably + // disappear from the call list in the next poll + if (prevIncomingOrWaitingLine >= 0 + && s_incomingOrWaitingLine < 0 + && s_expectAnswer == 0 + ) { + for (i = 0; i < countValidCalls ; i++) { + + if (p_calls[i].index == prevIncomingOrWaitingLine + && p_calls[i].state == RIL_CALL_ACTIVE + && s_repollCallsCount < REPOLL_CALLS_COUNT_MAX + ) { + RLOGI( + "Hit WORKAROUND_ERRONOUS_ANSWER case." + " Repoll count: %d\n", s_repollCallsCount); + s_repollCallsCount++; + goto error; + } + } + } + + s_expectAnswer = 0; + s_repollCallsCount = 0; +#endif /*WORKAROUND_ERRONEOUS_ANSWER*/ + + RIL_onRequestComplete(t, RIL_E_SUCCESS, pp_calls, + countValidCalls * sizeof (RIL_Call *)); + + at_response_free(p_response); + +#ifdef POLL_CALL_STATE + if (countValidCalls) { // We don't seem to get a "NO CARRIER" message from + // smd, so we're forced to poll until the call ends. +#else + if (needRepoll) { +#endif + RIL_requestTimedCallback (sendCallStateChanged, NULL, &TIMEVAL_CALLSTATEPOLL); + } + + return; +#ifdef WORKAROUND_ERRONEOUS_ANSWER +error: + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); +#endif +} + +static void requestDial(void *data, size_t datalen __unused, RIL_Token t) +{ + RIL_Dial *p_dial; + char *cmd; + const char *clir; + int ret; + + p_dial = (RIL_Dial *)data; + + switch (p_dial->clir) { + case 1: clir = "I"; break; /*invocation*/ + case 2: clir = "i"; break; /*suppression*/ + default: + case 0: clir = ""; break; /*subscription default*/ + } + + asprintf(&cmd, "ATD%s%s;", p_dial->address, clir); + + ret = at_send_command(cmd, NULL); + + free(cmd); + + /* success or failure is ignored by the upper layer here. + it will call GET_CURRENT_CALLS and determine success that way */ + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); +} + +static void requestWriteSmsToSim(void *data, size_t datalen __unused, RIL_Token t) +{ + RIL_SMS_WriteArgs *p_args; + char *cmd; + int length; + int err; + ATResponse *p_response = NULL; + + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0); + return; + } + + p_args = (RIL_SMS_WriteArgs *)data; + + length = strlen(p_args->pdu)/2; + asprintf(&cmd, "AT+CMGW=%d,%d", length, p_args->status); + + err = at_send_command_sms(cmd, p_args->pdu, "+CMGW:", &p_response); + + if (err != 0 || p_response->success == 0) goto error; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + at_response_free(p_response); + + return; +error: + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); +} + +static void requestHangup(void *data, size_t datalen __unused, RIL_Token t) +{ + int *p_line; + + int ret; + char *cmd; + + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_MODEM_ERR, NULL, 0); + return; + } + p_line = (int *)data; + + // 3GPP 22.030 6.5.5 + // "Releases a specific active call X" + asprintf(&cmd, "AT+CHLD=1%d", p_line[0]); + + ret = at_send_command(cmd, NULL); + + free(cmd); + + /* success or failure is ignored by the upper layer here. + it will call GET_CURRENT_CALLS and determine success that way */ + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); +} + +static void requestSignalStrength(void *data __unused, size_t datalen __unused, RIL_Token t) +{ + ATResponse *p_response = NULL; + int err; + char *line; + int count = 0; + // Accept a response that is at least v6, and up to v10 + int minNumOfElements=sizeof(RIL_SignalStrength_v6)/sizeof(int); + int maxNumOfElements=sizeof(RIL_SignalStrength_v10)/sizeof(int); + int response[maxNumOfElements]; + + memset(response, 0, sizeof(response)); + + err = at_send_command_singleline("AT+CSQ", "+CSQ:", &p_response); + + if (err < 0 || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + goto error; + } + + line = p_response->p_intermediates->line; + + err = at_tok_start(&line); + if (err < 0) goto error; + + for (count = 0; count < maxNumOfElements; count++) { + err = at_tok_nextint(&line, &(response[count])); + if (err < 0 && count < minNumOfElements) goto error; + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response)); + + at_response_free(p_response); + return; + +error: + RLOGE("requestSignalStrength must never return an error when radio is on"); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); +} + +/** + * networkModePossible. Decides whether the network mode is appropriate for the + * specified modem + */ +static int networkModePossible(ModemInfo *mdm, int nm) +{ + if ((net2modem[nm] & mdm->supportedTechs) == net2modem[nm]) { + return 1; + } + return 0; +} +static void requestSetPreferredNetworkType( int request __unused, void *data, + size_t datalen __unused, RIL_Token t ) +{ + ATResponse *p_response = NULL; + char *cmd = NULL; + int value = *(int *)data; + int current, old; + int err; + int32_t preferred = net2pmask[value]; + + RLOGD("requestSetPreferredNetworkType: current: %x. New: %x", PREFERRED_NETWORK(sMdmInfo), preferred); + if (!networkModePossible(sMdmInfo, value)) { + RIL_onRequestComplete(t, RIL_E_MODE_NOT_SUPPORTED, NULL, 0); + return; + } + if (query_ctec(sMdmInfo, ¤t, NULL) < 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + old = PREFERRED_NETWORK(sMdmInfo); + RLOGD("old != preferred: %d", old != preferred); + if (old != preferred) { + asprintf(&cmd, "AT+CTEC=%d,\"%x\"", current, preferred); + RLOGD("Sending command: <%s>", cmd); + err = at_send_command_singleline(cmd, "+CTEC:", &p_response); + free(cmd); + if (err || !p_response->success) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + PREFERRED_NETWORK(sMdmInfo) = value; + if (!strstr( p_response->p_intermediates->line, "DONE") ) { + int current; + int res = parse_technology_response(p_response->p_intermediates->line, ¤t, NULL); + switch (res) { + case -1: // Error or unable to parse + break; + case 1: // Only able to parse current + case 0: // Both current and preferred were parsed + setRadioTechnology(sMdmInfo, current); + break; + } + } + } + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); +} + +static void requestGetPreferredNetworkType(int request __unused, void *data __unused, + size_t datalen __unused, RIL_Token t) +{ + int preferred; + unsigned i; + + switch ( query_ctec(sMdmInfo, NULL, &preferred) ) { + case -1: // Error or unable to parse + case 1: // Only able to parse current + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + break; + case 0: // Both current and preferred were parsed + for ( i = 0 ; i < sizeof(net2pmask) / sizeof(int32_t) ; i++ ) { + if (preferred == net2pmask[i]) { + RIL_onRequestComplete(t, RIL_E_SUCCESS, &i, sizeof(int)); + return; + } + } + RLOGE("Unknown preferred mode received from modem: %d", preferred); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + break; + } + +} + +static void requestCdmaPrlVersion(int request __unused, void *data __unused, + size_t datalen __unused, RIL_Token t) +{ + int err; + char * responseStr; + ATResponse *p_response = NULL; + const char *cmd; + char *line; + + err = at_send_command_singleline("AT+WPRL?", "+WPRL:", &p_response); + if (err < 0 || !p_response->success) goto error; + line = p_response->p_intermediates->line; + err = at_tok_start(&line); + if (err < 0) goto error; + err = at_tok_nextstr(&line, &responseStr); + if (err < 0 || !responseStr) goto error; + RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, strlen(responseStr)); + at_response_free(p_response); + return; +error: + at_response_free(p_response); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); +} + +static void requestCdmaBaseBandVersion(int request __unused, void *data __unused, + size_t datalen __unused, RIL_Token t) +{ + int err; + char * responseStr; + ATResponse *p_response = NULL; + const char *cmd; + const char *prefix; + char *line, *p; + int commas; + int skip; + int count = 4; + + // Fixed values. TODO: query modem + responseStr = strdup("1.0.0.0"); + RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, sizeof(responseStr)); + free(responseStr); +} + +static void requestDeviceIdentity(int request __unused, void *data __unused, + size_t datalen __unused, RIL_Token t) +{ + int err; + int response[4]; + char * responseStr[4]; + ATResponse *p_response = NULL; + const char *cmd; + const char *prefix; + char *line, *p; + int commas; + int skip; + int count = 4; + + // Fixed values. TODO: Query modem + responseStr[0] = "----"; + responseStr[1] = "----"; + responseStr[2] = "77777777"; + responseStr[3] = ""; // default empty for non-CDMA + + err = at_send_command_numeric("AT+CGSN", &p_response); + if (err < 0 || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } else { + if (TECH_BIT(sMdmInfo) == MDM_CDMA) { + responseStr[3] = p_response->p_intermediates->line; + } else { + responseStr[0] = p_response->p_intermediates->line; + } + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*)); + at_response_free(p_response); +} + +static void requestCdmaGetSubscriptionSource(int request __unused, void *data, + size_t datalen __unused, RIL_Token t) +{ + int err; + int *ss = (int *)data; + ATResponse *p_response = NULL; + char *cmd = NULL; + char *line = NULL; + int response; + + asprintf(&cmd, "AT+CCSS?"); + if (!cmd) goto error; + + err = at_send_command_singleline(cmd, "+CCSS:", &p_response); + if (err < 0 || !p_response->success) + goto error; + + line = p_response->p_intermediates->line; + err = at_tok_start(&line); + if (err < 0) goto error; + + err = at_tok_nextint(&line, &response); + free(cmd); + cmd = NULL; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response)); + + return; +error: + free(cmd); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); +} + +static void requestCdmaSetSubscriptionSource(int request __unused, void *data, + size_t datalen, RIL_Token t) +{ + int err; + int *ss = (int *)data; + ATResponse *p_response = NULL; + char *cmd = NULL; + + if (!ss || !datalen) { + RLOGE("RIL_REQUEST_CDMA_SET_SUBSCRIPTION without data!"); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + asprintf(&cmd, "AT+CCSS=%d", ss[0]); + if (!cmd) goto error; + + err = at_send_command(cmd, &p_response); + if (err < 0 || !p_response->success) + goto error; + free(cmd); + cmd = NULL; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + + RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED, ss, sizeof(ss[0])); + + return; +error: + free(cmd); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); +} + +static void requestCdmaSubscription(int request __unused, void *data __unused, + size_t datalen __unused, RIL_Token t) +{ + int err; + int response[5]; + char * responseStr[5]; + ATResponse *p_response = NULL; + const char *cmd; + const char *prefix; + char *line, *p; + int commas; + int skip; + int count = 5; + + // Fixed values. TODO: Query modem + responseStr[0] = "8587777777"; // MDN + responseStr[1] = "1"; // SID + responseStr[2] = "1"; // NID + responseStr[3] = "8587777777"; // MIN + responseStr[4] = "1"; // PRL Version + RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, count*sizeof(char*)); +} + +static void requestCdmaGetRoamingPreference(int request __unused, void *data __unused, + size_t datalen __unused, RIL_Token t) +{ + int roaming_pref = -1; + ATResponse *p_response = NULL; + char *line; + int res; + + res = at_send_command_singleline("AT+WRMP?", "+WRMP:", &p_response); + if (res < 0 || !p_response->success) { + goto error; + } + line = p_response->p_intermediates->line; + + res = at_tok_start(&line); + if (res < 0) goto error; + + res = at_tok_nextint(&line, &roaming_pref); + if (res < 0) goto error; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &roaming_pref, sizeof(roaming_pref)); + return; +error: + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); +} + +static void requestCdmaSetRoamingPreference(int request __unused, void *data, + size_t datalen __unused, RIL_Token t) +{ + int *pref = (int *)data; + ATResponse *p_response = NULL; + char *line; + int res; + char *cmd = NULL; + + asprintf(&cmd, "AT+WRMP=%d", *pref); + if (cmd == NULL) goto error; + + res = at_send_command(cmd, &p_response); + if (res < 0 || !p_response->success) + goto error; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + free(cmd); + return; +error: + free(cmd); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); +} + +static int parseRegistrationState(char *str, int *type, int *items, int **response) +{ + int err; + char *line = str, *p; + int *resp = NULL; + int skip; + int count = 3; + int commas; + + RLOGD("parseRegistrationState. Parsing: %s",str); + err = at_tok_start(&line); + if (err < 0) goto error; + + /* Ok you have to be careful here + * The solicited version of the CREG response is + * +CREG: n, stat, [lac, cid] + * and the unsolicited version is + * +CREG: stat, [lac, cid] + * The parameter is basically "is unsolicited creg on?" + * which it should always be + * + * Now we should normally get the solicited version here, + * but the unsolicited version could have snuck in + * so we have to handle both + * + * Also since the LAC and CID are only reported when registered, + * we can have 1, 2, 3, or 4 arguments here + * + * finally, a +CGREG: answer may have a fifth value that corresponds + * to the network type, as in; + * + * +CGREG: n, stat [,lac, cid [,networkType]] + */ + + /* count number of commas */ + commas = 0; + for (p = line ; *p != '\0' ;p++) { + if (*p == ',') commas++; + } + + resp = (int *)calloc(commas + 1, sizeof(int)); + if (!resp) goto error; + switch (commas) { + case 0: /* +CREG: */ + err = at_tok_nextint(&line, &resp[0]); + if (err < 0) goto error; + resp[1] = -1; + resp[2] = -1; + break; + + case 1: /* +CREG: , */ + err = at_tok_nextint(&line, &skip); + if (err < 0) goto error; + err = at_tok_nextint(&line, &resp[0]); + if (err < 0) goto error; + resp[1] = -1; + resp[2] = -1; + if (err < 0) goto error; + break; + + case 2: /* +CREG: , , */ + err = at_tok_nextint(&line, &resp[0]); + if (err < 0) goto error; + err = at_tok_nexthexint(&line, &resp[1]); + if (err < 0) goto error; + err = at_tok_nexthexint(&line, &resp[2]); + if (err < 0) goto error; + break; + case 3: /* +CREG: , , , */ + err = at_tok_nextint(&line, &skip); + if (err < 0) goto error; + err = at_tok_nextint(&line, &resp[0]); + if (err < 0) goto error; + err = at_tok_nexthexint(&line, &resp[1]); + if (err < 0) goto error; + err = at_tok_nexthexint(&line, &resp[2]); + if (err < 0) goto error; + break; + /* special case for CGREG, there is a fourth parameter + * that is the network type (unknown/gprs/edge/umts) + */ + case 4: /* +CGREG: , , , , */ + err = at_tok_nextint(&line, &skip); + if (err < 0) goto error; + err = at_tok_nextint(&line, &resp[0]); + if (err < 0) goto error; + err = at_tok_nexthexint(&line, &resp[1]); + if (err < 0) goto error; + err = at_tok_nexthexint(&line, &resp[2]); + if (err < 0) goto error; + err = at_tok_nexthexint(&line, &resp[3]); + if (err < 0) goto error; + count = 4; + break; + default: + goto error; + } + s_lac = resp[1]; + s_cid = resp[2]; + if (response) + *response = resp; + if (items) + *items = commas + 1; + if (type) + *type = techFromModemType(TECH(sMdmInfo)); + return 0; +error: + free(resp); + return -1; +} + +#define REG_STATE_LEN 15 +#define REG_DATA_STATE_LEN 6 +static void requestRegistrationState(int request, void *data __unused, + size_t datalen __unused, RIL_Token t) +{ + int err; + int *registration; + char **responseStr = NULL; + ATResponse *p_response = NULL; + const char *cmd; + const char *prefix; + char *line; + int i = 0, j, numElements = 0; + int count = 3; + int type, startfrom; + + RLOGD("requestRegistrationState"); + if (request == RIL_REQUEST_VOICE_REGISTRATION_STATE) { + cmd = "AT+CREG?"; + prefix = "+CREG:"; + numElements = REG_STATE_LEN; + } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) { + cmd = "AT+CGREG?"; + prefix = "+CGREG:"; + numElements = REG_DATA_STATE_LEN; + } else { + assert(0); + goto error; + } + + err = at_send_command_singleline(cmd, prefix, &p_response); + + if (err != 0) goto error; + + line = p_response->p_intermediates->line; + + if (parseRegistrationState(line, &type, &count, ®istration)) goto error; + + responseStr = malloc(numElements * sizeof(char *)); + if (!responseStr) goto error; + memset(responseStr, 0, numElements * sizeof(char *)); + /** + * The first '4' bytes for both registration states remain the same. + * But if the request is 'DATA_REGISTRATION_STATE', + * the 5th and 6th byte(s) are optional. + */ + if (is3gpp2(type) == 1) { + RLOGD("registration state type: 3GPP2"); + // TODO: Query modem + startfrom = 3; + if(request == RIL_REQUEST_VOICE_REGISTRATION_STATE) { + asprintf(&responseStr[3], "8"); // EvDo revA + asprintf(&responseStr[4], "1"); // BSID + asprintf(&responseStr[5], "123"); // Latitude + asprintf(&responseStr[6], "222"); // Longitude + asprintf(&responseStr[7], "0"); // CSS Indicator + asprintf(&responseStr[8], "4"); // SID + asprintf(&responseStr[9], "65535"); // NID + asprintf(&responseStr[10], "0"); // Roaming indicator + asprintf(&responseStr[11], "1"); // System is in PRL + asprintf(&responseStr[12], "0"); // Default Roaming indicator + asprintf(&responseStr[13], "0"); // Reason for denial + asprintf(&responseStr[14], "0"); // Primary Scrambling Code of Current cell + } else if (request == RIL_REQUEST_DATA_REGISTRATION_STATE) { + asprintf(&responseStr[3], "8"); // Available data radio technology + } + } else { // type == RADIO_TECH_3GPP + RLOGD("registration state type: 3GPP"); + startfrom = 0; + asprintf(&responseStr[1], "%x", registration[1]); + asprintf(&responseStr[2], "%x", registration[2]); + if (count > 3) + asprintf(&responseStr[3], "%d", registration[3]); + } + asprintf(&responseStr[0], "%d", registration[0]); + + /** + * Optional bytes for DATA_REGISTRATION_STATE request + * 4th byte : Registration denial code + * 5th byte : The max. number of simultaneous Data Calls + */ + if(request == RIL_REQUEST_DATA_REGISTRATION_STATE) { + // asprintf(&responseStr[4], "3"); + // asprintf(&responseStr[5], "1"); + } + + for (j = startfrom; j < numElements; j++) { + if (!responseStr[i]) goto error; + } + free(registration); + registration = NULL; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, responseStr, numElements*sizeof(responseStr)); + for (j = 0; j < numElements; j++ ) { + free(responseStr[j]); + responseStr[j] = NULL; + } + free(responseStr); + responseStr = NULL; + at_response_free(p_response); + + return; +error: + if (responseStr) { + for (j = 0; j < numElements; j++) { + free(responseStr[j]); + responseStr[j] = NULL; + } + free(responseStr); + responseStr = NULL; + } + RLOGE("requestRegistrationState must never return an error when radio is on"); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); +} + +static void requestOperator(void *data __unused, size_t datalen __unused, RIL_Token t) +{ + int err; + int i; + int skip; + ATLine *p_cur; + char *response[3]; + + memset(response, 0, sizeof(response)); + + ATResponse *p_response = NULL; + + err = at_send_command_multiline( + "AT+COPS=3,0;+COPS?;+COPS=3,1;+COPS?;+COPS=3,2;+COPS?", + "+COPS:", &p_response); + + /* we expect 3 lines here: + * +COPS: 0,0,"T - Mobile" + * +COPS: 0,1,"TMO" + * +COPS: 0,2,"310170" + */ + + if (err != 0) goto error; + + for (i = 0, p_cur = p_response->p_intermediates + ; p_cur != NULL + ; p_cur = p_cur->p_next, i++ + ) { + char *line = p_cur->line; + + err = at_tok_start(&line); + if (err < 0) goto error; + + err = at_tok_nextint(&line, &skip); + if (err < 0) goto error; + + // If we're unregistered, we may just get + // a "+COPS: 0" response + if (!at_tok_hasmore(&line)) { + response[i] = NULL; + continue; + } + + err = at_tok_nextint(&line, &skip); + if (err < 0) goto error; + + // a "+COPS: 0, n" response is also possible + if (!at_tok_hasmore(&line)) { + response[i] = NULL; + continue; + } + + err = at_tok_nextstr(&line, &(response[i])); + if (err < 0) goto error; + // Simple assumption that mcc and mnc are 3 digits each + if (strlen(response[i]) == 6) { + if (sscanf(response[i], "%3d%3d", &s_mcc, &s_mnc) != 2) { + RLOGE("requestOperator expected mccmnc to be 6 decimal digits"); + } + } + } + + if (i != 3) { + /* expect 3 lines exactly */ + goto error; + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, response, sizeof(response)); + at_response_free(p_response); + + return; +error: + RLOGE("requestOperator must not return error when radio is on"); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); +} + +static void requestCdmaSendSMS(void *data, size_t datalen, RIL_Token t) +{ + int err = 1; // Set to go to error: + RIL_SMS_Response response; + RIL_CDMA_SMS_Message* rcsm; + + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0); + return; + } + + RLOGD("requestCdmaSendSMS datalen=%zu, sizeof(RIL_CDMA_SMS_Message)=%zu", + datalen, sizeof(RIL_CDMA_SMS_Message)); + + // verify data content to test marshalling/unmarshalling: + rcsm = (RIL_CDMA_SMS_Message*)data; + RLOGD("TeleserviceID=%d, bIsServicePresent=%d, \ + uServicecategory=%d, sAddress.digit_mode=%d, \ + sAddress.Number_mode=%d, sAddress.number_type=%d, ", + rcsm->uTeleserviceID, rcsm->bIsServicePresent, + rcsm->uServicecategory,rcsm->sAddress.digit_mode, + rcsm->sAddress.number_mode,rcsm->sAddress.number_type); + + if (err != 0) goto error; + + // Cdma Send SMS implementation will go here: + // But it is not implemented yet. + + memset(&response, 0, sizeof(response)); + response.messageRef = 1; + RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response)); + return; + +error: + // Cdma Send SMS will always cause send retry error. + response.messageRef = -1; + RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response)); +} + +static void requestSendSMS(void *data, size_t datalen, RIL_Token t) +{ + int err; + const char *smsc; + const char *pdu; + int tpLayerLength; + char *cmd1, *cmd2; + RIL_SMS_Response response; + ATResponse *p_response = NULL; + + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0); + return; + } + + memset(&response, 0, sizeof(response)); + RLOGD("requestSendSMS datalen =%zu", datalen); + + if (s_ims_gsm_fail != 0) goto error; + if (s_ims_gsm_retry != 0) goto error2; + + smsc = ((const char **)data)[0]; + pdu = ((const char **)data)[1]; + + tpLayerLength = strlen(pdu)/2; + + // "NULL for default SMSC" + if (smsc == NULL) { + smsc= "00"; + } + + asprintf(&cmd1, "AT+CMGS=%d", tpLayerLength); + asprintf(&cmd2, "%s%s", smsc, pdu); + + err = at_send_command_sms(cmd1, cmd2, "+CMGS:", &p_response); + + free(cmd1); + free(cmd2); + + if (err != 0 || p_response->success == 0) goto error; + + /* FIXME fill in messageRef and ackPDU */ + response.messageRef = 1; + RIL_onRequestComplete(t, RIL_E_SUCCESS, &response, sizeof(response)); + at_response_free(p_response); + + return; +error: + response.messageRef = -2; + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, &response, sizeof(response)); + at_response_free(p_response); + return; +error2: + // send retry error. + response.messageRef = -1; + RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response)); + at_response_free(p_response); + return; +} + +static void requestImsSendSMS(void *data, size_t datalen, RIL_Token t) +{ + RIL_IMS_SMS_Message *p_args; + RIL_SMS_Response response; + + memset(&response, 0, sizeof(response)); + + RLOGD("requestImsSendSMS: datalen=%zu, " + "registered=%d, service=%d, format=%d, ims_perm_fail=%d, " + "ims_retry=%d, gsm_fail=%d, gsm_retry=%d", + datalen, s_ims_registered, s_ims_services, s_ims_format, + s_ims_cause_perm_failure, s_ims_cause_retry, s_ims_gsm_fail, + s_ims_gsm_retry); + + // figure out if this is gsm/cdma format + // then route it to requestSendSMS vs requestCdmaSendSMS respectively + p_args = (RIL_IMS_SMS_Message *)data; + + if (0 != s_ims_cause_perm_failure ) goto error; + + // want to fail over ims and this is first request over ims + if (0 != s_ims_cause_retry && 0 == p_args->retry) goto error2; + + if (RADIO_TECH_3GPP == p_args->tech) { + return requestSendSMS(p_args->message.gsmMessage, + datalen - sizeof(RIL_RadioTechnologyFamily), + t); + } else if (RADIO_TECH_3GPP2 == p_args->tech) { + return requestCdmaSendSMS(p_args->message.cdmaMessage, + datalen - sizeof(RIL_RadioTechnologyFamily), + t); + } else { + RLOGE("requestImsSendSMS invalid format value =%d", p_args->tech); + } + +error: + response.messageRef = -2; + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, &response, sizeof(response)); + return; + +error2: + response.messageRef = -1; + RIL_onRequestComplete(t, RIL_E_SMS_SEND_FAIL_RETRY, &response, sizeof(response)); +} + +static void requestSimOpenChannel(void *data, size_t datalen, RIL_Token t) +{ + ATResponse *p_response = NULL; + int32_t session_id; + int err; + char cmd[32]; + char dummy; + char *line; + + // Max length is 16 bytes according to 3GPP spec 27.007 section 8.45 + if (data == NULL || datalen == 0 || datalen > 16) { + ALOGE("Invalid data passed to requestSimOpenChannel"); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + + snprintf(cmd, sizeof(cmd), "AT+CCHO=%s", data); + + err = at_send_command_numeric(cmd, &p_response); + if (err < 0 || p_response == NULL || p_response->success == 0) { + ALOGE("Error %d opening logical channel: %d", + err, p_response ? p_response->success : 0); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); + return; + } + + // Ensure integer only by scanning for an extra char but expect one result + line = p_response->p_intermediates->line; + if (sscanf(line, "%" SCNd32 "%c", &session_id, &dummy) != 1) { + ALOGE("Invalid AT response, expected integer, was '%s'", line); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &session_id, sizeof(&session_id)); + at_response_free(p_response); +} + +static void requestSimCloseChannel(void *data, size_t datalen, RIL_Token t) +{ + ATResponse *p_response = NULL; + int32_t session_id; + int err; + char cmd[32]; + + if (data == NULL || datalen != sizeof(session_id)) { + ALOGE("Invalid data passed to requestSimCloseChannel"); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + session_id = ((int32_t *)data)[0]; + snprintf(cmd, sizeof(cmd), "AT+CCHC=%" PRId32, session_id); + err = at_send_command_singleline(cmd, "+CCHC", &p_response); + + if (err < 0 || p_response == NULL || p_response->success == 0) { + ALOGE("Error %d closing logical channel %d: %d", + err, session_id, p_response ? p_response->success : 0); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); + return; + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + + at_response_free(p_response); +} + +static void requestSimTransmitApduChannel(void *data, + size_t datalen, + RIL_Token t) +{ + ATResponse *p_response = NULL; + int err; + char *cmd; + char *line; + size_t cmd_size; + RIL_SIM_IO_Response sim_response; + RIL_SIM_APDU *apdu = (RIL_SIM_APDU *)data; + + if (apdu == NULL || datalen != sizeof(RIL_SIM_APDU)) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + + cmd_size = 10 + (apdu->data ? strlen(apdu->data) : 0); + asprintf(&cmd, "AT+CGLA=%d,%zu,%02x%02x%02x%02x%02x%s", + apdu->sessionid, cmd_size, apdu->cla, apdu->instruction, + apdu->p1, apdu->p2, apdu->p3, apdu->data ? apdu->data : ""); + + err = at_send_command_singleline(cmd, "+CGLA", &p_response); + free(cmd); + if (err < 0 || p_response == NULL || p_response->success == 0) { + ALOGE("Error %d transmitting APDU: %d", + err, p_response ? p_response->success : 0); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); + return; + } + + line = p_response->p_intermediates->line; + err = parseSimResponseLine(line, &sim_response); + + if (err == 0) { + RIL_onRequestComplete(t, RIL_E_SUCCESS, + &sim_response, sizeof(sim_response)); + } else { + ALOGE("Error %d parsing SIM response line: %s", err, line); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } + at_response_free(p_response); +} + +static void requestSetupDataCall(void *data, size_t datalen, RIL_Token t) +{ + const char *apn; + char *cmd; + int err; + ATResponse *p_response = NULL; + + apn = ((const char **)data)[2]; + +#ifdef USE_TI_COMMANDS + // Config for multislot class 10 (probably default anyway eh?) + err = at_send_command("AT%CPRIM=\"GMM\",\"CONFIG MULTISLOT_CLASS=<10>\"", + NULL); + + err = at_send_command("AT%DATA=2,\"UART\",1,,\"SER\",\"UART\",0", NULL); +#endif /* USE_TI_COMMANDS */ + + int fd, qmistatus; + size_t cur = 0; + size_t len; + ssize_t written, rlen; + char status[32] = {0}; + int retry = 10; + const char *pdp_type; + + RLOGD("requesting data connection to APN '%s'", apn); + + fd = open ("/dev/qmi", O_RDWR); + if (fd >= 0) { /* the device doesn't exist on the emulator */ + + RLOGD("opened the qmi device\n"); + asprintf(&cmd, "up:%s", apn); + len = strlen(cmd); + + while (cur < len) { + do { + written = write (fd, cmd + cur, len - cur); + } while (written < 0 && errno == EINTR); + + if (written < 0) { + RLOGE("### ERROR writing to /dev/qmi"); + close(fd); + goto error; + } + + cur += written; + } + + // wait for interface to come online + + do { + sleep(1); + do { + rlen = read(fd, status, 31); + } while (rlen < 0 && errno == EINTR); + + if (rlen < 0) { + RLOGE("### ERROR reading from /dev/qmi"); + close(fd); + goto error; + } else { + status[rlen] = '\0'; + RLOGD("### status: %s", status); + } + } while (strncmp(status, "STATE=up", 8) && strcmp(status, "online") && --retry); + + close(fd); + + if (retry == 0) { + RLOGE("### Failed to get data connection up\n"); + goto error; + } + + qmistatus = system("netcfg rmnet0 dhcp"); + + RLOGD("netcfg rmnet0 dhcp: status %d\n", qmistatus); + + if (qmistatus < 0) goto error; + + } else { + bool hasWifi = hasWifiCapability(); + const char* radioInterfaceName = getRadioInterfaceName(hasWifi); + if (setInterfaceState(radioInterfaceName, kInterfaceUp) != RIL_E_SUCCESS) { + goto error; + } + + if (datalen > 6 * sizeof(char *)) { + pdp_type = ((const char **)data)[6]; + } else { + pdp_type = "IP"; + } + + asprintf(&cmd, "AT+CGDCONT=1,\"%s\",\"%s\",,0,0", pdp_type, apn); + //FIXME check for error here + err = at_send_command(cmd, NULL); + free(cmd); + + // Set required QoS params to default + err = at_send_command("AT+CGQREQ=1", NULL); + + // Set minimum QoS params to default + err = at_send_command("AT+CGQMIN=1", NULL); + + // packet-domain event reporting + err = at_send_command("AT+CGEREP=1,0", NULL); + + // Hangup anything that's happening there now + err = at_send_command("AT+CGACT=1,0", NULL); + + // Start data on PDP context 1 + err = at_send_command("ATD*99***1#", &p_response); + + if (err < 0 || p_response->success == 0) { + goto error; + } + } + + requestOrSendDataCallList(&t); + + at_response_free(p_response); + + return; +error: + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); + +} + +static void requestDeactivateDataCall(RIL_Token t) +{ + bool hasWifi = hasWifiCapability(); + const char* radioInterfaceName = getRadioInterfaceName(hasWifi); + RIL_Errno rilErrno = setInterfaceState(radioInterfaceName, kInterfaceDown); + RIL_onRequestComplete(t, rilErrno, NULL, 0); +} + +static void requestSMSAcknowledge(void *data, size_t datalen __unused, RIL_Token t) +{ + int ackSuccess; + int err; + + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); + return; + } + + ackSuccess = ((int *)data)[0]; + + if (ackSuccess == 1) { + err = at_send_command("AT+CNMA=1", NULL); + } else if (ackSuccess == 0) { + err = at_send_command("AT+CNMA=2", NULL); + } else { + RLOGE("unsupported arg to RIL_REQUEST_SMS_ACKNOWLEDGE\n"); + goto error; + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); +error: + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + +} + +static void requestSIM_IO(void *data, size_t datalen __unused, RIL_Token t) +{ + ATResponse *p_response = NULL; + RIL_SIM_IO_Response sr; + int err; + char *cmd = NULL; + RIL_SIM_IO_v6 *p_args; + char *line; + + memset(&sr, 0, sizeof(sr)); + + p_args = (RIL_SIM_IO_v6 *)data; + + /* FIXME handle pin2 */ + + if (p_args->data == NULL) { + asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d", + p_args->command, p_args->fileid, + p_args->p1, p_args->p2, p_args->p3); + } else { + asprintf(&cmd, "AT+CRSM=%d,%d,%d,%d,%d,%s", + p_args->command, p_args->fileid, + p_args->p1, p_args->p2, p_args->p3, p_args->data); + } + + err = at_send_command_singleline(cmd, "+CRSM:", &p_response); + + if (err < 0 || p_response->success == 0) { + goto error; + } + + line = p_response->p_intermediates->line; + + err = parseSimResponseLine(line, &sr); + if (err < 0) { + goto error; + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &sr, sizeof(sr)); + at_response_free(p_response); + free(cmd); + + return; +error: + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); + free(cmd); + +} + +static void requestEnterSimPin(void* data, size_t datalen, RIL_Token t) +{ + ATResponse *p_response = NULL; + int err; + char* cmd = NULL; + const char** strings = (const char**)data;; + + if ( datalen == sizeof(char*) ) { + asprintf(&cmd, "AT+CPIN=%s", strings[0]); + } else if ( datalen == 2*sizeof(char*) ) { + asprintf(&cmd, "AT+CPIN=%s,%s", strings[0], strings[1]); + } else + goto error; + + err = at_send_command_singleline(cmd, "+CPIN:", &p_response); + free(cmd); + + if (err < 0 || p_response->success == 0) { +error: + RIL_onRequestComplete(t, RIL_E_PASSWORD_INCORRECT, NULL, 0); + } else { + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } + at_response_free(p_response); +} + + +static void requestSendUSSD(void *data, size_t datalen __unused, RIL_Token t) +{ + const char *ussdRequest; + + ussdRequest = (char *)(data); + + + RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); + +// @@@ TODO + +} + +static void requestExitEmergencyMode(void *data __unused, size_t datalen __unused, RIL_Token t) +{ + int err; + ATResponse *p_response = NULL; + + err = at_send_command("AT+WSOS=0", &p_response); + + if (err < 0 || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + return; + } + + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); +} + +// TODO: Use all radio types +static int techFromModemType(int mdmtype) +{ + int ret = -1; + switch (1 << mdmtype) { + case MDM_CDMA: + ret = RADIO_TECH_1xRTT; + break; + case MDM_EVDO: + ret = RADIO_TECH_EVDO_A; + break; + case MDM_GSM: + ret = RADIO_TECH_GPRS; + break; + case MDM_WCDMA: + ret = RADIO_TECH_HSPA; + break; + case MDM_LTE: + ret = RADIO_TECH_LTE; + break; + } + return ret; +} + +static void requestGetCellInfoList(void *data __unused, size_t datalen __unused, RIL_Token t) +{ + uint64_t curTime = ril_nano_time(); + RIL_CellInfo_v12 ci[1] = + { + { // ci[0] + 1, // cellInfoType + 1, // registered + RIL_TIMESTAMP_TYPE_MODEM, + curTime - 1000, // Fake some time in the past + { // union CellInfo + { // RIL_CellInfoGsm gsm + { // gsm.cellIdneityGsm + s_mcc, // mcc + s_mnc, // mnc + s_lac, // lac + s_cid, // cid + 0, //arfcn unknown + 0xFF, // bsic unknown + }, + { // gsm.signalStrengthGsm + 10, // signalStrength + 0 // bitErrorRate + , INT_MAX // timingAdvance invalid value + } + } + } + } + }; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, ci, sizeof(ci)); +} + + +static void requestSetCellInfoListRate(void *data, size_t datalen __unused, RIL_Token t) +{ + // For now we'll save the rate but no RIL_UNSOL_CELL_INFO_LIST messages + // will be sent. + assert (datalen == sizeof(int)); + s_cell_info_rate_ms = ((int *)data)[0]; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); +} + +static void requestGetHardwareConfig(void *data, size_t datalen, RIL_Token t) +{ + // TODO - hook this up with real query/info from radio. + + RIL_HardwareConfig hwCfg; + + RIL_UNUSED_PARM(data); + RIL_UNUSED_PARM(datalen); + + hwCfg.type = -1; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &hwCfg, sizeof(hwCfg)); +} + +static void requestGetTtyMode(void *data, size_t datalen, RIL_Token t) +{ + int ttyModeResponse; + + RIL_UNUSED_PARM(data); + RIL_UNUSED_PARM(datalen); + + ttyModeResponse = (getSIMStatus() == SIM_READY) ? 1 // TTY Full + : 0; // TTY Off + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &ttyModeResponse, sizeof(ttyModeResponse)); +} + +static void requestGetRadioCapability(void *data, size_t datalen, RIL_Token t) +{ + RIL_RadioCapability radioCapability; + + RIL_UNUSED_PARM(data); + RIL_UNUSED_PARM(datalen); + + radioCapability.version = RIL_RADIO_CAPABILITY_VERSION; + radioCapability.session = 0; + radioCapability.phase = 0; + radioCapability.rat = 0; + radioCapability.logicalModemUuid[0] = '\0'; + radioCapability.status = RC_STATUS_SUCCESS; + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &radioCapability, sizeof(radioCapability)); +} + +static void requestGetMute(void *data, size_t datalen, RIL_Token t) +{ + int muteResponse; + + RIL_UNUSED_PARM(data); + RIL_UNUSED_PARM(datalen); + + muteResponse = 0; // Mute disabled + + RIL_onRequestComplete(t, RIL_E_SUCCESS, &muteResponse, sizeof(muteResponse)); +} + +/*** Callback methods from the RIL library to us ***/ + +/** + * Call from RIL to us to make a RIL_REQUEST + * + * Must be completed with a call to RIL_onRequestComplete() + * + * RIL_onRequestComplete() may be called from any thread, before or after + * this function returns. + * + * Because onRequest function could be called from multiple different thread, + * we must ensure that the underlying at_send_command_* function + * is atomic. + */ +static void +onRequest (int request, void *data, size_t datalen, RIL_Token t) +{ + ATResponse *p_response; + int err; + + RLOGD("onRequest: %s", requestToString(request)); + + /* Ignore all requests except RIL_REQUEST_GET_SIM_STATUS + * when RADIO_STATE_UNAVAILABLE. + */ + if (sState == RADIO_STATE_UNAVAILABLE + && request != RIL_REQUEST_GET_SIM_STATUS + ) { + RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); + return; + } + + /* Ignore all non-power requests when RADIO_STATE_OFF + * (except RIL_REQUEST_GET_SIM_STATUS) + */ + if (sState == RADIO_STATE_OFF) { + switch(request) { + case RIL_REQUEST_BASEBAND_VERSION: + case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: + case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE: + case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: + case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: + case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: + case RIL_REQUEST_CDMA_SUBSCRIPTION: + case RIL_REQUEST_DEVICE_IDENTITY: + case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: + case RIL_REQUEST_GET_ACTIVITY_INFO: + case RIL_REQUEST_GET_CARRIER_RESTRICTIONS: + case RIL_REQUEST_GET_CURRENT_CALLS: + case RIL_REQUEST_GET_IMEI: + case RIL_REQUEST_GET_MUTE: + case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: + case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: + case RIL_REQUEST_GET_RADIO_CAPABILITY: + case RIL_REQUEST_GET_SIM_STATUS: + case RIL_REQUEST_NV_RESET_CONFIG: + case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: + case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: + case RIL_REQUEST_QUERY_TTY_MODE: + case RIL_REQUEST_RADIO_POWER: + case RIL_REQUEST_SET_BAND_MODE: + case RIL_REQUEST_SET_CARRIER_RESTRICTIONS: + case RIL_REQUEST_SET_LOCATION_UPDATES: + case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: + case RIL_REQUEST_SET_TTY_MODE: + case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: + case RIL_REQUEST_STOP_LCE: + case RIL_REQUEST_VOICE_RADIO_TECH: + // Process all the above, even though the radio is off + break; + + default: + // For all others, say NOT_AVAILABLE because the radio is off + RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); + return; + } + } + + switch (request) { + case RIL_REQUEST_GET_SIM_STATUS: { + RIL_CardStatus_v6 *p_card_status; + char *p_buffer; + int buffer_size; + + int result = getCardStatus(&p_card_status); + if (result == RIL_E_SUCCESS) { + p_buffer = (char *)p_card_status; + buffer_size = sizeof(*p_card_status); + } else { + p_buffer = NULL; + buffer_size = 0; + } + RIL_onRequestComplete(t, result, p_buffer, buffer_size); + freeCardStatus(p_card_status); + break; + } + case RIL_REQUEST_GET_CURRENT_CALLS: + requestGetCurrentCalls(data, datalen, t); + break; + case RIL_REQUEST_DIAL: + requestDial(data, datalen, t); + break; + case RIL_REQUEST_HANGUP: + requestHangup(data, datalen, t); + break; + case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND: + case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND: + case RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE: + case RIL_REQUEST_CONFERENCE: + case RIL_REQUEST_UDUB: + requestCallSelection(data, datalen, t, request); + break; + case RIL_REQUEST_ANSWER: + at_send_command("ATA", NULL); + +#ifdef WORKAROUND_ERRONEOUS_ANSWER + s_expectAnswer = 1; +#endif /* WORKAROUND_ERRONEOUS_ANSWER */ + + if (getSIMStatus() != SIM_READY) { + RIL_onRequestComplete(t, RIL_E_MODEM_ERR, NULL, 0); + } else { + // Success or failure is ignored by the upper layer here. + // It will call GET_CURRENT_CALLS and determine success that way. + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } + break; + + case RIL_REQUEST_SEPARATE_CONNECTION: + { + char cmd[12]; + int party = ((int*)data)[0]; + + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); + return; + } + // Make sure that party is in a valid range. + // (Note: The Telephony middle layer imposes a range of 1 to 7. + // It's sufficient for us to just make sure it's single digit.) + if (party > 0 && party < 10) { + sprintf(cmd, "AT+CHLD=2%d", party); + at_send_command(cmd, NULL); + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } else { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } + } + break; + + case RIL_REQUEST_SIGNAL_STRENGTH: + requestSignalStrength(data, datalen, t); + break; + case RIL_REQUEST_VOICE_REGISTRATION_STATE: + case RIL_REQUEST_DATA_REGISTRATION_STATE: + requestRegistrationState(request, data, datalen, t); + break; + case RIL_REQUEST_OPERATOR: + requestOperator(data, datalen, t); + break; + case RIL_REQUEST_RADIO_POWER: + requestRadioPower(data, datalen, t); + break; + case RIL_REQUEST_DTMF: { + char c = ((char *)data)[0]; + char *cmd; + asprintf(&cmd, "AT+VTS=%c", (int)c); + at_send_command(cmd, NULL); + free(cmd); + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + break; + } + case RIL_REQUEST_SEND_SMS: + case RIL_REQUEST_SEND_SMS_EXPECT_MORE: + requestSendSMS(data, datalen, t); + break; + case RIL_REQUEST_CDMA_SEND_SMS: + requestCdmaSendSMS(data, datalen, t); + break; + case RIL_REQUEST_IMS_SEND_SMS: + requestImsSendSMS(data, datalen, t); + break; + case RIL_REQUEST_SIM_OPEN_CHANNEL: + requestSimOpenChannel(data, datalen, t); + break; + case RIL_REQUEST_SIM_CLOSE_CHANNEL: + requestSimCloseChannel(data, datalen, t); + break; + case RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL: + requestSimTransmitApduChannel(data, datalen, t); + break; + case RIL_REQUEST_SETUP_DATA_CALL: + requestSetupDataCall(data, datalen, t); + break; + case RIL_REQUEST_DEACTIVATE_DATA_CALL: + requestDeactivateDataCall(t); + break; + case RIL_REQUEST_SMS_ACKNOWLEDGE: + requestSMSAcknowledge(data, datalen, t); + break; + + case RIL_REQUEST_GET_IMSI: + p_response = NULL; + err = at_send_command_numeric("AT+CIMI", &p_response); + + if (err < 0 || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } else { + RIL_onRequestComplete(t, RIL_E_SUCCESS, + p_response->p_intermediates->line, sizeof(char *)); + } + at_response_free(p_response); + break; + + case RIL_REQUEST_GET_IMEI: + p_response = NULL; + err = at_send_command_numeric("AT+CGSN", &p_response); + + if (err < 0 || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } else { + RIL_onRequestComplete(t, RIL_E_SUCCESS, + p_response->p_intermediates->line, sizeof(char *)); + } + at_response_free(p_response); + break; + + case RIL_REQUEST_SIM_IO: + requestSIM_IO(data,datalen,t); + break; + + case RIL_REQUEST_SEND_USSD: + requestSendUSSD(data, datalen, t); + break; + + case RIL_REQUEST_CANCEL_USSD: + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); + return; + } + p_response = NULL; + err = at_send_command_numeric("AT+CUSD=2", &p_response); + + if (err < 0 || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } else { + RIL_onRequestComplete(t, RIL_E_SUCCESS, + p_response->p_intermediates->line, sizeof(char *)); + } + at_response_free(p_response); + break; + + case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); + } else { + at_send_command("AT+COPS=0", NULL); + } + break; + + case RIL_REQUEST_DATA_CALL_LIST: + requestDataCallList(data, datalen, t); + break; + + case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE: + requestQueryNetworkSelectionMode(data, datalen, t); + break; + + case RIL_REQUEST_OEM_HOOK_RAW: + // echo back data + RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen); + break; + + + case RIL_REQUEST_OEM_HOOK_STRINGS: { + int i; + const char ** cur; + + RLOGD("got OEM_HOOK_STRINGS: 0x%8p %lu", data, (long)datalen); + + + for (i = (datalen / sizeof (char *)), cur = (const char **)data ; + i > 0 ; cur++, i --) { + RLOGD("> '%s'", *cur); + } + + // echo back strings + RIL_onRequestComplete(t, RIL_E_SUCCESS, data, datalen); + break; + } + + case RIL_REQUEST_WRITE_SMS_TO_SIM: + requestWriteSmsToSim(data, datalen, t); + break; + + case RIL_REQUEST_DELETE_SMS_ON_SIM: { + char * cmd; + p_response = NULL; + asprintf(&cmd, "AT+CMGD=%d", ((int *)data)[0]); + err = at_send_command(cmd, &p_response); + free(cmd); + if (err < 0 || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } else { + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } + at_response_free(p_response); + break; + } + + case RIL_REQUEST_ENTER_SIM_PIN: + case RIL_REQUEST_ENTER_SIM_PUK: + case RIL_REQUEST_ENTER_SIM_PIN2: + case RIL_REQUEST_ENTER_SIM_PUK2: + case RIL_REQUEST_CHANGE_SIM_PIN: + case RIL_REQUEST_CHANGE_SIM_PIN2: + requestEnterSimPin(data, datalen, t); + break; + + case RIL_REQUEST_IMS_REGISTRATION_STATE: { + int reply[2]; + //0==unregistered, 1==registered + reply[0] = s_ims_registered; + + //to be used when changed to include service supporated info + //reply[1] = s_ims_services; + + // FORMAT_3GPP(1) vs FORMAT_3GPP2(2); + reply[1] = s_ims_format; + + RLOGD("IMS_REGISTRATION=%d, format=%d ", + reply[0], reply[1]); + if (reply[1] != -1) { + RIL_onRequestComplete(t, RIL_E_SUCCESS, reply, sizeof(reply)); + } else { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } + break; + } + + case RIL_REQUEST_VOICE_RADIO_TECH: + { + int tech = techFromModemType(TECH(sMdmInfo)); + if (tech < 0 ) + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + else + RIL_onRequestComplete(t, RIL_E_SUCCESS, &tech, sizeof(tech)); + } + break; + case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE: + requestSetPreferredNetworkType(request, data, datalen, t); + break; + + case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE: + requestGetPreferredNetworkType(request, data, datalen, t); + break; + + case RIL_REQUEST_GET_CELL_INFO_LIST: + requestGetCellInfoList(data, datalen, t); + break; + + case RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE: + requestSetCellInfoListRate(data, datalen, t); + break; + + case RIL_REQUEST_GET_HARDWARE_CONFIG: + requestGetHardwareConfig(data, datalen, t); + break; + + case RIL_REQUEST_SHUTDOWN: + requestShutdown(t); + break; + + case RIL_REQUEST_QUERY_TTY_MODE: + requestGetTtyMode(data, datalen, t); + break; + + case RIL_REQUEST_GET_RADIO_CAPABILITY: + requestGetRadioCapability(data, datalen, t); + break; + + case RIL_REQUEST_GET_MUTE: + requestGetMute(data, datalen, t); + break; + + case RIL_REQUEST_SET_INITIAL_ATTACH_APN: + case RIL_REQUEST_ALLOW_DATA: + case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION: + case RIL_REQUEST_SET_CLIR: + case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION: + case RIL_REQUEST_SET_BAND_MODE: + case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE: + case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS: + case RIL_REQUEST_SET_LOCATION_UPDATES: + case RIL_REQUEST_SET_TTY_MODE: + case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE: + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + break; + + case RIL_REQUEST_BASEBAND_VERSION: + requestCdmaBaseBandVersion(request, data, datalen, t); + break; + + case RIL_REQUEST_DEVICE_IDENTITY: + requestDeviceIdentity(request, data, datalen, t); + break; + + case RIL_REQUEST_CDMA_SUBSCRIPTION: + requestCdmaSubscription(request, data, datalen, t); + break; + + case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE: + requestCdmaGetSubscriptionSource(request, data, datalen, t); + break; + + case RIL_REQUEST_START_LCE: + case RIL_REQUEST_STOP_LCE: + case RIL_REQUEST_PULL_LCEDATA: + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_SIM_ABSENT, NULL, 0); + } else { + RIL_onRequestComplete(t, RIL_E_LCE_NOT_SUPPORTED, NULL, 0); + } + break; + + case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE: + if (TECH_BIT(sMdmInfo) == MDM_CDMA) { + requestCdmaGetRoamingPreference(request, data, datalen, t); + } else { + RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); + } + break; + + case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE: + if (TECH_BIT(sMdmInfo) == MDM_CDMA) { + requestCdmaSetSubscriptionSource(request, data, datalen, t); + } else { + // VTS tests expect us to silently do nothing + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } + break; + + case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE: + if (TECH_BIT(sMdmInfo) == MDM_CDMA) { + requestCdmaSetRoamingPreference(request, data, datalen, t); + } else { + // VTS tests expect us to silently do nothing + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } + break; + + case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE: + if (TECH_BIT(sMdmInfo) == MDM_CDMA) { + requestExitEmergencyMode(data, datalen, t); + } else { + // VTS tests expect us to silently do nothing + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } + break; + + default: + RLOGD("Request not supported. Tech: %d",TECH(sMdmInfo)); + RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); + break; + } +} + +/** + * Synchronous call from the RIL to us to return current radio state. + * RADIO_STATE_UNAVAILABLE should be the initial state. + */ +static RIL_RadioState +currentState() +{ + return sState; +} +/** + * Call from RIL to us to find out whether a specific request code + * is supported by this implementation. + * + * Return 1 for "supported" and 0 for "unsupported" + */ + +static int +onSupports (int requestCode __unused) +{ + //@@@ todo + + return 1; +} + +static void onCancel (RIL_Token t __unused) +{ + //@@@todo + +} + +static const char * getVersion(void) +{ + return "android reference-ril 1.0"; +} + +static void +setRadioTechnology(ModemInfo *mdm, int newtech) +{ + RLOGD("setRadioTechnology(%d)", newtech); + + int oldtech = TECH(mdm); + + if (newtech != oldtech) { + RLOGD("Tech change (%d => %d)", oldtech, newtech); + TECH(mdm) = newtech; + if (techFromModemType(newtech) != techFromModemType(oldtech)) { + int tech = techFromModemType(TECH(sMdmInfo)); + if (tech > 0 ) { + RIL_onUnsolicitedResponse(RIL_UNSOL_VOICE_RADIO_TECH_CHANGED, + &tech, sizeof(tech)); + } + } + } +} + +static void +setRadioState(RIL_RadioState newState) +{ + RLOGD("setRadioState(%d)", newState); + RIL_RadioState oldState; + + pthread_mutex_lock(&s_state_mutex); + + oldState = sState; + + if (s_closed > 0) { + // If we're closed, the only reasonable state is + // RADIO_STATE_UNAVAILABLE + // This is here because things on the main thread + // may attempt to change the radio state after the closed + // event happened in another thread + newState = RADIO_STATE_UNAVAILABLE; + } + + if (sState != newState || s_closed > 0) { + sState = newState; + + pthread_cond_broadcast (&s_state_cond); + } + + pthread_mutex_unlock(&s_state_mutex); + + + /* do these outside of the mutex */ + if (sState != oldState) { + RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED, + NULL, 0); + // Sim state can change as result of radio state change + RIL_onUnsolicitedResponse (RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, + NULL, 0); + + /* FIXME onSimReady() and onRadioPowerOn() cannot be called + * from the AT reader thread + * Currently, this doesn't happen, but if that changes then these + * will need to be dispatched on the request thread + */ + if (sState == RADIO_STATE_ON) { + onRadioPowerOn(); + } + } +} + +/** Returns RUIM_NOT_READY on error */ +static SIM_Status +getRUIMStatus() +{ + ATResponse *p_response = NULL; + int err; + int ret; + char *cpinLine; + char *cpinResult; + + if (sState == RADIO_STATE_OFF || sState == RADIO_STATE_UNAVAILABLE) { + ret = SIM_NOT_READY; + goto done; + } + + err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response); + + if (err != 0) { + ret = SIM_NOT_READY; + goto done; + } + + switch (at_get_cme_error(p_response)) { + case CME_SUCCESS: + break; + + case CME_SIM_NOT_INSERTED: + ret = SIM_ABSENT; + goto done; + + default: + ret = SIM_NOT_READY; + goto done; + } + + /* CPIN? has succeeded, now look at the result */ + + cpinLine = p_response->p_intermediates->line; + err = at_tok_start (&cpinLine); + + if (err < 0) { + ret = SIM_NOT_READY; + goto done; + } + + err = at_tok_nextstr(&cpinLine, &cpinResult); + + if (err < 0) { + ret = SIM_NOT_READY; + goto done; + } + + if (0 == strcmp (cpinResult, "SIM PIN")) { + ret = SIM_PIN; + goto done; + } else if (0 == strcmp (cpinResult, "SIM PUK")) { + ret = SIM_PUK; + goto done; + } else if (0 == strcmp (cpinResult, "PH-NET PIN")) { + return SIM_NETWORK_PERSONALIZATION; + } else if (0 != strcmp (cpinResult, "READY")) { + /* we're treating unsupported lock types as "sim absent" */ + ret = SIM_ABSENT; + goto done; + } + + at_response_free(p_response); + p_response = NULL; + cpinResult = NULL; + + ret = SIM_READY; + +done: + at_response_free(p_response); + return ret; +} + +/** Returns SIM_NOT_READY on error */ +static SIM_Status +getSIMStatus() +{ + ATResponse *p_response = NULL; + int err; + int ret; + char *cpinLine; + char *cpinResult; + + RLOGD("getSIMStatus(). sState: %d",sState); + err = at_send_command_singleline("AT+CPIN?", "+CPIN:", &p_response); + + if (err != 0) { + ret = SIM_NOT_READY; + goto done; + } + + switch (at_get_cme_error(p_response)) { + case CME_SUCCESS: + break; + + case CME_SIM_NOT_INSERTED: + ret = SIM_ABSENT; + goto done; + + default: + ret = SIM_NOT_READY; + goto done; + } + + /* CPIN? has succeeded, now look at the result */ + + cpinLine = p_response->p_intermediates->line; + err = at_tok_start (&cpinLine); + + if (err < 0) { + ret = SIM_NOT_READY; + goto done; + } + + err = at_tok_nextstr(&cpinLine, &cpinResult); + + if (err < 0) { + ret = SIM_NOT_READY; + goto done; + } + + if (0 == strcmp (cpinResult, "SIM PIN")) { + ret = SIM_PIN; + goto done; + } else if (0 == strcmp (cpinResult, "SIM PUK")) { + ret = SIM_PUK; + goto done; + } else if (0 == strcmp (cpinResult, "PH-NET PIN")) { + return SIM_NETWORK_PERSONALIZATION; + } else if (0 != strcmp (cpinResult, "READY")) { + /* we're treating unsupported lock types as "sim absent" */ + ret = SIM_ABSENT; + goto done; + } + + at_response_free(p_response); + p_response = NULL; + cpinResult = NULL; + + ret = (sState == RADIO_STATE_ON) ? SIM_READY : SIM_NOT_READY; + +done: + at_response_free(p_response); + return ret; +} + + +/** + * Get the current card status. + * + * This must be freed using freeCardStatus. + * @return: On success returns RIL_E_SUCCESS + */ +static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) { + static RIL_AppStatus app_status_array[] = { + // SIM_ABSENT = 0 + { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // SIM_NOT_READY = 1 + { RIL_APPTYPE_USIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // SIM_READY = 2 + { RIL_APPTYPE_USIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // SIM_PIN = 3 + { RIL_APPTYPE_USIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, + // SIM_PUK = 4 + { RIL_APPTYPE_USIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, + // SIM_NETWORK_PERSONALIZATION = 5 + { RIL_APPTYPE_USIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, + // RUIM_ABSENT = 6 + { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // RUIM_NOT_READY = 7 + { RIL_APPTYPE_RUIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // RUIM_READY = 8 + { RIL_APPTYPE_RUIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // RUIM_PIN = 9 + { RIL_APPTYPE_RUIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, + // RUIM_PUK = 10 + { RIL_APPTYPE_RUIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, + // RUIM_NETWORK_PERSONALIZATION = 11 + { RIL_APPTYPE_RUIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, + // ISIM_ABSENT = 12 + { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // ISIM_NOT_READY = 13 + { RIL_APPTYPE_ISIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // ISIM_READY = 14 + { RIL_APPTYPE_ISIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // ISIM_PIN = 15 + { RIL_APPTYPE_ISIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, + // ISIM_PUK = 16 + { RIL_APPTYPE_ISIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, + // ISIM_NETWORK_PERSONALIZATION = 17 + { RIL_APPTYPE_ISIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, + NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, + + }; + RIL_CardState card_state; + int num_apps; + + int sim_status = getSIMStatus(); + if (sim_status == SIM_ABSENT) { + card_state = RIL_CARDSTATE_ABSENT; + num_apps = 0; + } else { + card_state = RIL_CARDSTATE_PRESENT; + num_apps = 3; + } + + // Allocate and initialize base card status. + RIL_CardStatus_v6 *p_card_status = malloc(sizeof(RIL_CardStatus_v6)); + p_card_status->card_state = card_state; + p_card_status->universal_pin_state = RIL_PINSTATE_UNKNOWN; + p_card_status->gsm_umts_subscription_app_index = -1; + p_card_status->cdma_subscription_app_index = -1; + p_card_status->ims_subscription_app_index = -1; + p_card_status->num_applications = num_apps; + + // Initialize application status + int i; + for (i = 0; i < RIL_CARD_MAX_APPS; i++) { + p_card_status->applications[i] = app_status_array[SIM_ABSENT]; + } + + // Pickup the appropriate application status + // that reflects sim_status for gsm. + if (num_apps != 0) { + p_card_status->num_applications = 3; + p_card_status->gsm_umts_subscription_app_index = 0; + p_card_status->cdma_subscription_app_index = 1; + p_card_status->ims_subscription_app_index = 2; + + // Get the correct app status + p_card_status->applications[0] = app_status_array[sim_status]; + p_card_status->applications[1] = app_status_array[sim_status + RUIM_ABSENT]; + p_card_status->applications[2] = app_status_array[sim_status + ISIM_ABSENT]; + } + + *pp_card_status = p_card_status; + return RIL_E_SUCCESS; +} + +/** + * Free the card status returned by getCardStatus + */ +static void freeCardStatus(RIL_CardStatus_v6 *p_card_status) { + free(p_card_status); +} + +/** + * SIM ready means any commands that access the SIM will work, including: + * AT+CPIN, AT+CSMS, AT+CNMI, AT+CRSM + * (all SMS-related commands) + */ + +static void pollSIMState (void *param __unused) +{ + ATResponse *p_response; + int ret; + + if (sState != RADIO_STATE_UNAVAILABLE) { + // no longer valid to poll + return; + } + + switch(getSIMStatus()) { + case SIM_ABSENT: + case SIM_PIN: + case SIM_PUK: + case SIM_NETWORK_PERSONALIZATION: + default: + RLOGI("SIM ABSENT or LOCKED"); + RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0); + return; + + case SIM_NOT_READY: + RIL_requestTimedCallback (pollSIMState, NULL, &TIMEVAL_SIMPOLL); + return; + + case SIM_READY: + RLOGI("SIM_READY"); + onSIMReady(); + RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED, NULL, 0); + return; + } +} + +/** returns 1 if on, 0 if off, and -1 on error */ +static int isRadioOn() +{ + ATResponse *p_response = NULL; + int err; + char *line; + char ret; + + err = at_send_command_singleline("AT+CFUN?", "+CFUN:", &p_response); + + if (err < 0 || p_response->success == 0) { + // assume radio is off + goto error; + } + + line = p_response->p_intermediates->line; + + err = at_tok_start(&line); + if (err < 0) goto error; + + err = at_tok_nextbool(&line, &ret); + if (err < 0) goto error; + + at_response_free(p_response); + + return (int)ret; + +error: + + at_response_free(p_response); + return -1; +} + +/** + * Parse the response generated by a +CTEC AT command + * The values read from the response are stored in current and preferred. + * Both current and preferred may be null. The corresponding value is ignored in that case. + * + * @return: -1 if some error occurs (or if the modem doesn't understand the +CTEC command) + * 1 if the response includes the current technology only + * 0 if the response includes both current technology and preferred mode + */ +int parse_technology_response( const char *response, int *current, int32_t *preferred ) +{ + int err; + char *line, *p; + int ct; + int32_t pt = 0; + char *str_pt; + + line = p = strdup(response); + RLOGD("Response: %s", line); + err = at_tok_start(&p); + if (err || !at_tok_hasmore(&p)) { + RLOGD("err: %d. p: %s", err, p); + free(line); + return -1; + } + + err = at_tok_nextint(&p, &ct); + if (err) { + free(line); + return -1; + } + if (current) *current = ct; + + RLOGD("line remaining after int: %s", p); + + err = at_tok_nexthexint(&p, &pt); + if (err) { + free(line); + return 1; + } + if (preferred) { + *preferred = pt; + } + free(line); + + return 0; +} + +int query_supported_techs( ModemInfo *mdm __unused, int *supported ) +{ + ATResponse *p_response; + int err, val, techs = 0; + char *tok; + char *line; + + RLOGD("query_supported_techs"); + err = at_send_command_singleline("AT+CTEC=?", "+CTEC:", &p_response); + if (err || !p_response->success) + goto error; + line = p_response->p_intermediates->line; + err = at_tok_start(&line); + if (err || !at_tok_hasmore(&line)) + goto error; + while (!at_tok_nextint(&line, &val)) { + techs |= ( 1 << val ); + } + if (supported) *supported = techs; + return 0; +error: + at_response_free(p_response); + return -1; +} + +/** + * query_ctec. Send the +CTEC AT command to the modem to query the current + * and preferred modes. It leaves values in the addresses pointed to by + * current and preferred. If any of those pointers are NULL, the corresponding value + * is ignored, but the return value will still reflect if retreiving and parsing of the + * values suceeded. + * + * @mdm Currently unused + * @current A pointer to store the current mode returned by the modem. May be null. + * @preferred A pointer to store the preferred mode returned by the modem. May be null. + * @return -1 on error (or failure to parse) + * 1 if only the current mode was returned by modem (or failed to parse preferred) + * 0 if both current and preferred were returned correctly + */ +int query_ctec(ModemInfo *mdm __unused, int *current, int32_t *preferred) +{ + ATResponse *response = NULL; + int err; + int res; + + RLOGD("query_ctec. current: %p, preferred: %p", current, preferred); + err = at_send_command_singleline("AT+CTEC?", "+CTEC:", &response); + if (!err && response->success) { + res = parse_technology_response(response->p_intermediates->line, current, preferred); + at_response_free(response); + return res; + } + RLOGE("Error executing command: %d. response: %p. status: %d", err, response, response? response->success : -1); + at_response_free(response); + return -1; +} + +int is_multimode_modem(ModemInfo *mdm) +{ + ATResponse *response; + int err; + char *line; + int tech; + int32_t preferred; + + if (query_ctec(mdm, &tech, &preferred) == 0) { + mdm->currentTech = tech; + mdm->preferredNetworkMode = preferred; + if (query_supported_techs(mdm, &mdm->supportedTechs)) { + return 0; + } + return 1; + } + return 0; +} + +/** + * Find out if our modem is GSM, CDMA or both (Multimode) + */ +static void probeForModemMode(ModemInfo *info) +{ + ATResponse *response; + int err; + assert (info); + // Currently, our only known multimode modem is qemu's android modem, + // which implements the AT+CTEC command to query and set mode. + // Try that first + + if (is_multimode_modem(info)) { + RLOGI("Found Multimode Modem. Supported techs mask: %8.8x. Current tech: %d", + info->supportedTechs, info->currentTech); + return; + } + + /* Being here means that our modem is not multimode */ + info->isMultimode = 0; + + /* CDMA Modems implement the AT+WNAM command */ + err = at_send_command_singleline("AT+WNAM","+WNAM:", &response); + if (!err && response->success) { + at_response_free(response); + // TODO: find out if we really support EvDo + info->supportedTechs = MDM_CDMA | MDM_EVDO; + info->currentTech = MDM_CDMA; + RLOGI("Found CDMA Modem"); + return; + } + if (!err) at_response_free(response); + // TODO: find out if modem really supports WCDMA/LTE + info->supportedTechs = MDM_GSM | MDM_WCDMA | MDM_LTE; + info->currentTech = MDM_GSM; + RLOGI("Found GSM Modem"); +} + +/** + * Initialize everything that can be configured while we're still in + * AT+CFUN=0 + */ +static void initializeCallback(void *param __unused) +{ + ATResponse *p_response = NULL; + int err; + + setRadioState (RADIO_STATE_OFF); + + at_handshake(); + + probeForModemMode(sMdmInfo); + /* 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); + + /* No auto-answer */ + at_send_command("ATS0=0", NULL); + + /* Extended errors */ + at_send_command("AT+CMEE=1", NULL); + + /* Network registration events */ + err = at_send_command("AT+CREG=2", &p_response); + + /* some handsets -- in tethered mode -- don't support CREG=2 */ + if (err < 0 || p_response->success == 0) { + at_send_command("AT+CREG=1", NULL); + } + + at_response_free(p_response); + + /* GPRS registration events */ + at_send_command("AT+CGREG=1", NULL); + + /* Call Waiting notifications */ + at_send_command("AT+CCWA=1", NULL); + + /* Alternating voice/data off */ + at_send_command("AT+CMOD=0", NULL); + + /* Not muted */ + at_send_command("AT+CMUT=0", NULL); + + /* +CSSU unsolicited supp service notifications */ + at_send_command("AT+CSSN=0,1", NULL); + + /* no connected line identification */ + at_send_command("AT+COLP=0", NULL); + + /* HEX character set */ + at_send_command("AT+CSCS=\"HEX\"", NULL); + + /* USSD unsolicited */ + at_send_command("AT+CUSD=1", NULL); + + /* Enable +CGEV GPRS event notifications, but don't buffer */ + at_send_command("AT+CGEREP=1,0", NULL); + + /* SMS PDU mode */ + at_send_command("AT+CMGF=0", NULL); + +#ifdef USE_TI_COMMANDS + + at_send_command("AT%CPI=3", NULL); + + /* TI specific -- notifications when SMS is ready (currently ignored) */ + at_send_command("AT%CSTAT=1", NULL); + +#endif /* USE_TI_COMMANDS */ + + + /* assume radio is off on error */ + if (isRadioOn() > 0) { + setRadioState (RADIO_STATE_ON); + } +} + +static void waitForClose() +{ + pthread_mutex_lock(&s_state_mutex); + + while (s_closed == 0) { + pthread_cond_wait(&s_state_cond, &s_state_mutex); + } + + pthread_mutex_unlock(&s_state_mutex); +} + +static void sendUnsolImsNetworkStateChanged() +{ +#if 0 // to be used when unsol is changed to return data. + int reply[2]; + reply[0] = s_ims_registered; + reply[1] = s_ims_services; + reply[1] = s_ims_format; +#endif + RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED, + NULL, 0); +} + +/** + * 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) +{ + char *line = NULL, *p; + int err; + + /* Ignore unsolicited responses until we're initialized. + * This is OK because the RIL library will poll for initial state + */ + if (sState == RADIO_STATE_UNAVAILABLE) { + return; + } + + if (strStartsWith(s, "%CTZV:")) { + /* TI specific -- NITZ time */ + char *response; + + line = p = strdup(s); + at_tok_start(&p); + + err = at_tok_nextstr(&p, &response); + + if (err != 0) { + RLOGE("invalid NITZ line %s\n", s); + } else { + RIL_onUnsolicitedResponse ( + RIL_UNSOL_NITZ_TIME_RECEIVED, + response, strlen(response) + 1); + } + free(line); + } else if (strStartsWith(s,"+CRING:") + || strStartsWith(s,"RING") + || strStartsWith(s,"NO CARRIER") + || strStartsWith(s,"+CCWA") + ) { + RIL_onUnsolicitedResponse ( + RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, + NULL, 0); +#ifdef WORKAROUND_FAKE_CGEV + RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); //TODO use new function +#endif /* WORKAROUND_FAKE_CGEV */ + } else if (strStartsWith(s,"+CREG:") + || strStartsWith(s,"+CGREG:") + ) { + RIL_onUnsolicitedResponse ( + RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED, + NULL, 0); +#ifdef WORKAROUND_FAKE_CGEV + RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); +#endif /* WORKAROUND_FAKE_CGEV */ + } else if (strStartsWith(s, "+CMT:")) { + RIL_onUnsolicitedResponse ( + RIL_UNSOL_RESPONSE_NEW_SMS, + sms_pdu, strlen(sms_pdu)); + } else if (strStartsWith(s, "+CDS:")) { + RIL_onUnsolicitedResponse ( + RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT, + sms_pdu, strlen(sms_pdu)); + } else if (strStartsWith(s, "+CGEV:")) { + /* Really, we can ignore NW CLASS and ME CLASS events here, + * but right now we don't since extranous + * RIL_UNSOL_DATA_CALL_LIST_CHANGED calls are tolerated + */ + /* can't issue AT commands here -- call on main thread */ + RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); +#ifdef WORKAROUND_FAKE_CGEV + } else if (strStartsWith(s, "+CME ERROR: 150")) { + RIL_requestTimedCallback (onDataCallListChanged, NULL, NULL); +#endif /* WORKAROUND_FAKE_CGEV */ + } else if (strStartsWith(s, "+CTEC: ")) { + int tech, mask; + switch (parse_technology_response(s, &tech, NULL)) + { + case -1: // no argument could be parsed. + RLOGE("invalid CTEC line %s\n", s); + break; + case 1: // current mode correctly parsed + case 0: // preferred mode correctly parsed + mask = 1 << tech; + if (mask != MDM_GSM && mask != MDM_CDMA && + mask != MDM_WCDMA && mask != MDM_LTE) { + RLOGE("Unknown technology %d\n", tech); + } else { + setRadioTechnology(sMdmInfo, tech); + } + break; + } + } else if (strStartsWith(s, "+CCSS: ")) { + int source = 0; + line = p = strdup(s); + if (!line) { + RLOGE("+CCSS: Unable to allocate memory"); + return; + } + if (at_tok_start(&p) < 0) { + free(line); + return; + } + if (at_tok_nextint(&p, &source) < 0) { + RLOGE("invalid +CCSS response: %s", line); + free(line); + return; + } + SSOURCE(sMdmInfo) = source; + RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED, + &source, sizeof(source)); + } else if (strStartsWith(s, "+WSOS: ")) { + char state = 0; + int unsol; + line = p = strdup(s); + if (!line) { + RLOGE("+WSOS: Unable to allocate memory"); + return; + } + if (at_tok_start(&p) < 0) { + free(line); + return; + } + if (at_tok_nextbool(&p, &state) < 0) { + RLOGE("invalid +WSOS response: %s", line); + free(line); + return; + } + free(line); + + unsol = state ? + RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE : RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE; + + RIL_onUnsolicitedResponse(unsol, NULL, 0); + + } else if (strStartsWith(s, "+WPRL: ")) { + int version = -1; + line = p = strdup(s); + if (!line) { + RLOGE("+WPRL: Unable to allocate memory"); + return; + } + if (at_tok_start(&p) < 0) { + RLOGE("invalid +WPRL response: %s", s); + free(line); + return; + } + if (at_tok_nextint(&p, &version) < 0) { + RLOGE("invalid +WPRL response: %s", s); + free(line); + return; + } + free(line); + RIL_onUnsolicitedResponse(RIL_UNSOL_CDMA_PRL_CHANGED, &version, sizeof(version)); + } else if (strStartsWith(s, "+CFUN: 0")) { + setRadioState(RADIO_STATE_OFF); + } +} + +/* Called on command or reader thread */ +static void onATReaderClosed() +{ + RLOGI("AT channel closed\n"); + at_close(); + s_closed = 1; + + setRadioState (RADIO_STATE_UNAVAILABLE); +} + +/* 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); +} + +/* Called to pass hardware configuration information to telephony + * framework. + */ +static void setHardwareConfiguration(int num, RIL_HardwareConfig *cfg) +{ + RIL_onUnsolicitedResponse(RIL_UNSOL_HARDWARE_CONFIG_CHANGED, cfg, num*sizeof(*cfg)); +} + +static void usage(char *s __unused) +{ +#ifdef RIL_SHLIB + fprintf(stderr, "reference-ril requires: -p or -d /dev/tty_device\n"); +#else + fprintf(stderr, "usage: %s [-p ] [-d /dev/tty_device]\n", s); + exit(-1); +#endif +} + +static void * +mainLoop(void *param __unused) +{ + int fd; + int ret; + + AT_DUMP("== ", "entering mainLoop()", -1 ); + at_set_on_reader_closed(onATReaderClosed); + at_set_on_timeout(onATTimeout); + + for (;;) { + fd = -1; + while (fd < 0) { + if (isInEmulator()) { + fd = qemu_pipe_open("pipe:qemud:gsm"); + } else if (s_port > 0) { + fd = socket_network_client("localhost", s_port, SOCK_STREAM); + } else if (s_device_socket) { + 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... */ + tcsetattr( fd, TCSANOW, &ios ); + } + } + + if (fd < 0) { + perror ("opening AT interface. retrying..."); + sleep(10); + /* never returns */ + } + } + + 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"); + } +} + +#ifdef RIL_SHLIB + +pthread_t s_tid_mainloop; + +const RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv) +{ + int ret; + int fd = -1; + int opt; + pthread_attr_t attr; + + s_rilenv = env; + + while ( -1 != (opt = getopt(argc, argv, "p:d:s:c:"))) { + switch (opt) { + case 'p': + s_port = atoi(optarg); + if (s_port == 0) { + usage(argv[0]); + return NULL; + } + 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; + + case 'c': + RLOGI("Client id received %s\n", optarg); + break; + + default: + usage(argv[0]); + return NULL; + } + } + + if (s_port < 0 && s_device_path == NULL && !isInEmulator()) { + usage(argv[0]); + return NULL; + } + + sMdmInfo = calloc(1, sizeof(ModemInfo)); + if (!sMdmInfo) { + RLOGE("Unable to alloc memory for ModemInfo"); + return NULL; + } + pthread_attr_init (&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + 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 && !isInEmulator()) { + usage(argv[0]); + } + + RIL_register(&s_callbacks); + + mainLoop(NULL); + + return 0; +} + +#endif /* RIL_SHLIB */ diff --git a/ril/ril.h b/ril/ril.h new file mode 100644 index 0000000..c4add62 --- /dev/null +++ b/ril/ril.h @@ -0,0 +1,7363 @@ +/* + * Copyright (C) 2006 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_RIL_H +#define ANDROID_RIL_H 1 + +#include +#include +#include +#include +#include + +#ifndef FEATURE_UNIT_TEST +#include +#endif /* !FEATURE_UNIT_TEST */ + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef SIM_COUNT +#if defined(ANDROID_SIM_COUNT_2) +#define SIM_COUNT 2 +#elif defined(ANDROID_SIM_COUNT_3) +#define SIM_COUNT 3 +#elif defined(ANDROID_SIM_COUNT_4) +#define SIM_COUNT 4 +#else +#define SIM_COUNT 1 +#endif + +#ifndef ANDROID_MULTI_SIM +#define SIM_COUNT 1 +#endif +#endif + +/* + * RIL version. + * Value of RIL_VERSION should not be changed in future. Here onwards, + * when a new change is supposed to be introduced which could involve new + * schemes added like Wakelocks, data structures added/updated, etc, we would + * just document RIL version associated with that change below. When OEM updates its + * RIL with those changes, they would return that new RIL version during RIL_REGISTER. + * We should make use of the returned version by vendor to identify appropriate scheme + * or data structure version to use. + * + * Documentation of RIL version and associated changes + * RIL_VERSION = 12 : This version corresponds to updated data structures namely + * RIL_Data_Call_Response_v11, RIL_SIM_IO_v6, RIL_CardStatus_v6, + * RIL_SimRefreshResponse_v7, RIL_CDMA_CallWaiting_v6, + * RIL_LTE_SignalStrength_v8, RIL_SignalStrength_v10, RIL_CellIdentityGsm_v12 + * RIL_CellIdentityWcdma_v12, RIL_CellIdentityLte_v12,RIL_CellInfoGsm_v12, + * RIL_CellInfoWcdma_v12, RIL_CellInfoLte_v12, RIL_CellInfo_v12. + * + * RIL_VERSION = 13 : This version includes new wakelock semantics and as the first + * strongly versioned version it enforces structure use. + * + * RIL_VERSION = 14 : New data structures are added, namely RIL_CarrierMatchType, + * RIL_Carrier, RIL_CarrierRestrictions and RIL_PCO_Data. + * New commands added: RIL_REQUEST_SET_CARRIER_RESTRICTIONS, + * RIL_REQUEST_SET_CARRIER_RESTRICTIONS and RIL_UNSOL_PCO_DATA. + * + * RIL_VERSION = 15 : New commands added: + * RIL_UNSOL_MODEM_RESTART, + * RIL_REQUEST_SEND_DEVICE_STATE, + * RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER, + * RIL_REQUEST_SET_SIM_CARD_POWER, + * RIL_REQUEST_SET_CARRIER_INFO_IMSI_ENCRYPTION, + * RIL_UNSOL_CARRIER_INFO_IMSI_ENCRYPTION + * The new parameters for RIL_REQUEST_SETUP_DATA_CALL, + * Updated data structures: RIL_DataProfileInfo_v15, RIL_InitialAttachApn_v15 + * New data structure RIL_DataRegistrationStateResponse, + * RIL_VoiceRegistrationStateResponse same is + * used in RIL_REQUEST_DATA_REGISTRATION_STATE and + * RIL_REQUEST_VOICE_REGISTRATION_STATE respectively. + * New data structure RIL_OpenChannelParams. + * RIL_REQUEST_START_NETWORK_SCAN + * RIL_REQUEST_STOP_NETWORK_SCAN + * RIL_UNSOL_NETWORK_SCAN_RESULT + */ +#define RIL_VERSION 12 +#define LAST_IMPRECISE_RIL_VERSION 12 // Better self-documented name +#define RIL_VERSION_MIN 6 /* Minimum RIL_VERSION supported */ + +#define CDMA_ALPHA_INFO_BUFFER_LENGTH 64 +#define CDMA_NUMBER_INFO_BUFFER_LENGTH 81 + +#define MAX_RILDS 3 +#define MAX_SERVICE_NAME_LENGTH 6 +#define MAX_CLIENT_ID_LENGTH 2 +#define MAX_DEBUG_SOCKET_NAME_LENGTH 12 +#define MAX_QEMU_PIPE_NAME_LENGTH 11 +#define MAX_UUID_LENGTH 64 +#define MAX_BANDS 8 +#define MAX_CHANNELS 32 +#define MAX_RADIO_ACCESS_NETWORKS 8 + + +typedef void * RIL_Token; + +typedef enum { + RIL_SOCKET_1, +#if (SIM_COUNT >= 2) + RIL_SOCKET_2, +#if (SIM_COUNT >= 3) + RIL_SOCKET_3, +#endif +#if (SIM_COUNT >= 4) + RIL_SOCKET_4, +#endif +#endif + RIL_SOCKET_NUM +} RIL_SOCKET_ID; + + +typedef enum { + RIL_E_SUCCESS = 0, + RIL_E_RADIO_NOT_AVAILABLE = 1, /* If radio did not start or is resetting */ + RIL_E_GENERIC_FAILURE = 2, + RIL_E_PASSWORD_INCORRECT = 3, /* for PIN/PIN2 methods only! */ + RIL_E_SIM_PIN2 = 4, /* Operation requires SIM PIN2 to be entered */ + RIL_E_SIM_PUK2 = 5, /* Operation requires SIM PIN2 to be entered */ + RIL_E_REQUEST_NOT_SUPPORTED = 6, + RIL_E_CANCELLED = 7, + RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL = 8, /* data ops are not allowed during voice + call on a Class C GPRS device */ + RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW = 9, /* data ops are not allowed before device + registers in network */ + RIL_E_SMS_SEND_FAIL_RETRY = 10, /* fail to send sms and need retry */ + RIL_E_SIM_ABSENT = 11, /* fail to set the location where CDMA subscription + shall be retrieved because of SIM or RUIM + card absent */ + RIL_E_SUBSCRIPTION_NOT_AVAILABLE = 12, /* fail to find CDMA subscription from specified + location */ + RIL_E_MODE_NOT_SUPPORTED = 13, /* HW does not support preferred network type */ + RIL_E_FDN_CHECK_FAILURE = 14, /* command failed because recipient is not on FDN list */ + RIL_E_ILLEGAL_SIM_OR_ME = 15, /* network selection failed due to + illegal SIM or ME */ + RIL_E_MISSING_RESOURCE = 16, /* no logical channel available */ + RIL_E_NO_SUCH_ELEMENT = 17, /* application not found on SIM */ + RIL_E_DIAL_MODIFIED_TO_USSD = 18, /* DIAL request modified to USSD */ + RIL_E_DIAL_MODIFIED_TO_SS = 19, /* DIAL request modified to SS */ + RIL_E_DIAL_MODIFIED_TO_DIAL = 20, /* DIAL request modified to DIAL with different + data */ + RIL_E_USSD_MODIFIED_TO_DIAL = 21, /* USSD request modified to DIAL */ + RIL_E_USSD_MODIFIED_TO_SS = 22, /* USSD request modified to SS */ + RIL_E_USSD_MODIFIED_TO_USSD = 23, /* USSD request modified to different USSD + request */ + RIL_E_SS_MODIFIED_TO_DIAL = 24, /* SS request modified to DIAL */ + RIL_E_SS_MODIFIED_TO_USSD = 25, /* SS request modified to USSD */ + RIL_E_SUBSCRIPTION_NOT_SUPPORTED = 26, /* Subscription not supported by RIL */ + RIL_E_SS_MODIFIED_TO_SS = 27, /* SS request modified to different SS request */ + RIL_E_LCE_NOT_SUPPORTED = 36, /* LCE service not supported(36 in RILConstants.java) */ + RIL_E_NO_MEMORY = 37, /* Not sufficient memory to process the request */ + RIL_E_INTERNAL_ERR = 38, /* Modem hit unexpected error scenario while handling + this request */ + RIL_E_SYSTEM_ERR = 39, /* Hit platform or system error */ + RIL_E_MODEM_ERR = 40, /* Vendor RIL got unexpected or incorrect response + from modem for this request */ + RIL_E_INVALID_STATE = 41, /* Unexpected request for the current state */ + RIL_E_NO_RESOURCES = 42, /* Not sufficient resource to process the request */ + RIL_E_SIM_ERR = 43, /* Received error from SIM card */ + RIL_E_INVALID_ARGUMENTS = 44, /* Received invalid arguments in request */ + RIL_E_INVALID_SIM_STATE = 45, /* Can not process the request in current SIM state */ + RIL_E_INVALID_MODEM_STATE = 46, /* Can not process the request in current Modem state */ + RIL_E_INVALID_CALL_ID = 47, /* Received invalid call id in request */ + RIL_E_NO_SMS_TO_ACK = 48, /* ACK received when there is no SMS to ack */ + RIL_E_NETWORK_ERR = 49, /* Received error from network */ + RIL_E_REQUEST_RATE_LIMITED = 50, /* Operation denied due to overly-frequent requests */ + RIL_E_SIM_BUSY = 51, /* SIM is busy */ + RIL_E_SIM_FULL = 52, /* The target EF is full */ + RIL_E_NETWORK_REJECT = 53, /* Request is rejected by network */ + RIL_E_OPERATION_NOT_ALLOWED = 54, /* Not allowed the request now */ + RIL_E_EMPTY_RECORD = 55, /* The request record is empty */ + RIL_E_INVALID_SMS_FORMAT = 56, /* Invalid sms format */ + RIL_E_ENCODING_ERR = 57, /* Message not encoded properly */ + RIL_E_INVALID_SMSC_ADDRESS = 58, /* SMSC address specified is invalid */ + RIL_E_NO_SUCH_ENTRY = 59, /* No such entry present to perform the request */ + RIL_E_NETWORK_NOT_READY = 60, /* Network is not ready to perform the request */ + RIL_E_NOT_PROVISIONED = 61, /* Device doesnot have this value provisioned */ + RIL_E_NO_SUBSCRIPTION = 62, /* Device doesnot have subscription */ + RIL_E_NO_NETWORK_FOUND = 63, /* Network cannot be found */ + RIL_E_DEVICE_IN_USE = 64, /* Operation cannot be performed because the device + is currently in use */ + RIL_E_ABORTED = 65, /* Operation aborted */ + RIL_E_INVALID_RESPONSE = 66, /* Invalid response sent by vendor code */ + // OEM specific error codes. To be used by OEM when they don't want to reveal + // specific error codes which would be replaced by Generic failure. + RIL_E_OEM_ERROR_1 = 501, + RIL_E_OEM_ERROR_2 = 502, + RIL_E_OEM_ERROR_3 = 503, + RIL_E_OEM_ERROR_4 = 504, + RIL_E_OEM_ERROR_5 = 505, + RIL_E_OEM_ERROR_6 = 506, + RIL_E_OEM_ERROR_7 = 507, + RIL_E_OEM_ERROR_8 = 508, + RIL_E_OEM_ERROR_9 = 509, + RIL_E_OEM_ERROR_10 = 510, + RIL_E_OEM_ERROR_11 = 511, + RIL_E_OEM_ERROR_12 = 512, + RIL_E_OEM_ERROR_13 = 513, + RIL_E_OEM_ERROR_14 = 514, + RIL_E_OEM_ERROR_15 = 515, + RIL_E_OEM_ERROR_16 = 516, + RIL_E_OEM_ERROR_17 = 517, + RIL_E_OEM_ERROR_18 = 518, + RIL_E_OEM_ERROR_19 = 519, + RIL_E_OEM_ERROR_20 = 520, + RIL_E_OEM_ERROR_21 = 521, + RIL_E_OEM_ERROR_22 = 522, + RIL_E_OEM_ERROR_23 = 523, + RIL_E_OEM_ERROR_24 = 524, + RIL_E_OEM_ERROR_25 = 525 +} RIL_Errno; + +typedef enum { + RIL_CALL_ACTIVE = 0, + RIL_CALL_HOLDING = 1, + RIL_CALL_DIALING = 2, /* MO call only */ + RIL_CALL_ALERTING = 3, /* MO call only */ + RIL_CALL_INCOMING = 4, /* MT call only */ + RIL_CALL_WAITING = 5 /* MT call only */ +} RIL_CallState; + +typedef enum { + RADIO_STATE_OFF = 0, /* Radio explictly powered off (eg CFUN=0) */ + RADIO_STATE_UNAVAILABLE = 1, /* Radio unavailable (eg, resetting or not booted) */ + RADIO_STATE_ON = 10 /* Radio is on */ +} RIL_RadioState; + +typedef enum { + RADIO_TECH_UNKNOWN = 0, + RADIO_TECH_GPRS = 1, + RADIO_TECH_EDGE = 2, + RADIO_TECH_UMTS = 3, + RADIO_TECH_IS95A = 4, + RADIO_TECH_IS95B = 5, + RADIO_TECH_1xRTT = 6, + RADIO_TECH_EVDO_0 = 7, + RADIO_TECH_EVDO_A = 8, + RADIO_TECH_HSDPA = 9, + RADIO_TECH_HSUPA = 10, + RADIO_TECH_HSPA = 11, + RADIO_TECH_EVDO_B = 12, + RADIO_TECH_EHRPD = 13, + RADIO_TECH_LTE = 14, + RADIO_TECH_HSPAP = 15, // HSPA+ + RADIO_TECH_GSM = 16, // Only supports voice + RADIO_TECH_TD_SCDMA = 17, + RADIO_TECH_IWLAN = 18, + RADIO_TECH_LTE_CA = 19 +} RIL_RadioTechnology; + +typedef enum { + RAF_UNKNOWN = (1 << RADIO_TECH_UNKNOWN), + RAF_GPRS = (1 << RADIO_TECH_GPRS), + RAF_EDGE = (1 << RADIO_TECH_EDGE), + RAF_UMTS = (1 << RADIO_TECH_UMTS), + RAF_IS95A = (1 << RADIO_TECH_IS95A), + RAF_IS95B = (1 << RADIO_TECH_IS95B), + RAF_1xRTT = (1 << RADIO_TECH_1xRTT), + RAF_EVDO_0 = (1 << RADIO_TECH_EVDO_0), + RAF_EVDO_A = (1 << RADIO_TECH_EVDO_A), + RAF_HSDPA = (1 << RADIO_TECH_HSDPA), + RAF_HSUPA = (1 << RADIO_TECH_HSUPA), + RAF_HSPA = (1 << RADIO_TECH_HSPA), + RAF_EVDO_B = (1 << RADIO_TECH_EVDO_B), + RAF_EHRPD = (1 << RADIO_TECH_EHRPD), + RAF_LTE = (1 << RADIO_TECH_LTE), + RAF_HSPAP = (1 << RADIO_TECH_HSPAP), + RAF_GSM = (1 << RADIO_TECH_GSM), + RAF_TD_SCDMA = (1 << RADIO_TECH_TD_SCDMA), + RAF_LTE_CA = (1 << RADIO_TECH_LTE_CA) +} RIL_RadioAccessFamily; + +typedef enum { + BAND_MODE_UNSPECIFIED = 0, //"unspecified" (selected by baseband automatically) + BAND_MODE_EURO = 1, //"EURO band" (GSM-900 / DCS-1800 / WCDMA-IMT-2000) + BAND_MODE_USA = 2, //"US band" (GSM-850 / PCS-1900 / WCDMA-850 / WCDMA-PCS-1900) + BAND_MODE_JPN = 3, //"JPN band" (WCDMA-800 / WCDMA-IMT-2000) + BAND_MODE_AUS = 4, //"AUS band" (GSM-900 / DCS-1800 / WCDMA-850 / WCDMA-IMT-2000) + BAND_MODE_AUS_2 = 5, //"AUS band 2" (GSM-900 / DCS-1800 / WCDMA-850) + BAND_MODE_CELL_800 = 6, //"Cellular" (800-MHz Band) + BAND_MODE_PCS = 7, //"PCS" (1900-MHz Band) + BAND_MODE_JTACS = 8, //"Band Class 3" (JTACS Band) + BAND_MODE_KOREA_PCS = 9, //"Band Class 4" (Korean PCS Band) + BAND_MODE_5_450M = 10, //"Band Class 5" (450-MHz Band) + BAND_MODE_IMT2000 = 11, //"Band Class 6" (2-GMHz IMT2000 Band) + BAND_MODE_7_700M_2 = 12, //"Band Class 7" (Upper 700-MHz Band) + BAND_MODE_8_1800M = 13, //"Band Class 8" (1800-MHz Band) + BAND_MODE_9_900M = 14, //"Band Class 9" (900-MHz Band) + BAND_MODE_10_800M_2 = 15, //"Band Class 10" (Secondary 800-MHz Band) + BAND_MODE_EURO_PAMR_400M = 16, //"Band Class 11" (400-MHz European PAMR Band) + BAND_MODE_AWS = 17, //"Band Class 15" (AWS Band) + BAND_MODE_USA_2500M = 18 //"Band Class 16" (US 2.5-GHz Band) +} RIL_RadioBandMode; + +typedef enum { + RC_PHASE_CONFIGURED = 0, // LM is configured is initial value and value after FINISH completes + RC_PHASE_START = 1, // START is sent before Apply and indicates that an APPLY will be + // forthcoming with these same parameters + RC_PHASE_APPLY = 2, // APPLY is sent after all LM's receive START and returned + // RIL_RadioCapability.status = 0, if any START's fail no + // APPLY will be sent + RC_PHASE_UNSOL_RSP = 3, // UNSOL_RSP is sent with RIL_UNSOL_RADIO_CAPABILITY + RC_PHASE_FINISH = 4 // FINISH is sent after all commands have completed. If an error + // occurs in any previous command the RIL_RadioAccessesFamily and + // logicalModemUuid fields will be the prior configuration thus + // restoring the configuration to the previous value. An error + // returned by this command will generally be ignored or may + // cause that logical modem to be removed from service. +} RadioCapabilityPhase; + +typedef enum { + RC_STATUS_NONE = 0, // This parameter has no meaning with RC_PHASE_START, + // RC_PHASE_APPLY + RC_STATUS_SUCCESS = 1, // Tell modem the action transaction of set radio + // capability was success with RC_PHASE_FINISH + RC_STATUS_FAIL = 2, // Tell modem the action transaction of set radio + // capability is fail with RC_PHASE_FINISH. +} RadioCapabilityStatus; + +#define RIL_RADIO_CAPABILITY_VERSION 1 +typedef struct { + int version; // Version of structure, RIL_RADIO_CAPABILITY_VERSION + int session; // Unique session value defined by framework returned in all "responses/unsol" + int phase; // CONFIGURED, START, APPLY, FINISH + int rat; // RIL_RadioAccessFamily for the radio + char logicalModemUuid[MAX_UUID_LENGTH]; // A UUID typically "com.xxxx.lmX where X is the logical modem. + int status; // Return status and an input parameter for RC_PHASE_FINISH +} RIL_RadioCapability; + +// Do we want to split Data from Voice and the use +// RIL_RadioTechnology for get/setPreferredVoice/Data ? +typedef enum { + PREF_NET_TYPE_GSM_WCDMA = 0, /* GSM/WCDMA (WCDMA preferred) */ + PREF_NET_TYPE_GSM_ONLY = 1, /* GSM only */ + PREF_NET_TYPE_WCDMA = 2, /* WCDMA */ + PREF_NET_TYPE_GSM_WCDMA_AUTO = 3, /* GSM/WCDMA (auto mode, according to PRL) */ + PREF_NET_TYPE_CDMA_EVDO_AUTO = 4, /* CDMA and EvDo (auto mode, according to PRL) */ + PREF_NET_TYPE_CDMA_ONLY = 5, /* CDMA only */ + PREF_NET_TYPE_EVDO_ONLY = 6, /* EvDo only */ + PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO = 7, /* GSM/WCDMA, CDMA, and EvDo (auto mode, according to PRL) */ + PREF_NET_TYPE_LTE_CDMA_EVDO = 8, /* LTE, CDMA and EvDo */ + PREF_NET_TYPE_LTE_GSM_WCDMA = 9, /* LTE, GSM/WCDMA */ + PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA = 10, /* LTE, CDMA, EvDo, GSM/WCDMA */ + PREF_NET_TYPE_LTE_ONLY = 11, /* LTE only */ + PREF_NET_TYPE_LTE_WCDMA = 12, /* LTE/WCDMA */ + PREF_NET_TYPE_TD_SCDMA_ONLY = 13, /* TD-SCDMA only */ + PREF_NET_TYPE_TD_SCDMA_WCDMA = 14, /* TD-SCDMA and WCDMA */ + PREF_NET_TYPE_TD_SCDMA_LTE = 15, /* TD-SCDMA and LTE */ + PREF_NET_TYPE_TD_SCDMA_GSM = 16, /* TD-SCDMA and GSM */ + PREF_NET_TYPE_TD_SCDMA_GSM_LTE = 17, /* TD-SCDMA,GSM and LTE */ + PREF_NET_TYPE_TD_SCDMA_GSM_WCDMA = 18, /* TD-SCDMA, GSM/WCDMA */ + PREF_NET_TYPE_TD_SCDMA_WCDMA_LTE = 19, /* TD-SCDMA, WCDMA and LTE */ + PREF_NET_TYPE_TD_SCDMA_GSM_WCDMA_LTE = 20, /* TD-SCDMA, GSM/WCDMA and LTE */ + PREF_NET_TYPE_TD_SCDMA_GSM_WCDMA_CDMA_EVDO_AUTO = 21, /* TD-SCDMA, GSM/WCDMA, CDMA and EvDo */ + PREF_NET_TYPE_TD_SCDMA_LTE_CDMA_EVDO_GSM_WCDMA = 22 /* TD-SCDMA, LTE, CDMA, EvDo GSM/WCDMA */ +} RIL_PreferredNetworkType; + +/* Source for cdma subscription */ +typedef enum { + CDMA_SUBSCRIPTION_SOURCE_RUIM_SIM = 0, + CDMA_SUBSCRIPTION_SOURCE_NV = 1 +} RIL_CdmaSubscriptionSource; + +/* User-to-User signaling Info activation types derived from 3GPP 23.087 v8.0 */ +typedef enum { + RIL_UUS_TYPE1_IMPLICIT = 0, + RIL_UUS_TYPE1_REQUIRED = 1, + RIL_UUS_TYPE1_NOT_REQUIRED = 2, + RIL_UUS_TYPE2_REQUIRED = 3, + RIL_UUS_TYPE2_NOT_REQUIRED = 4, + RIL_UUS_TYPE3_REQUIRED = 5, + RIL_UUS_TYPE3_NOT_REQUIRED = 6 +} RIL_UUS_Type; + +/* User-to-User Signaling Information data coding schemes. Possible values for + * Octet 3 (Protocol Discriminator field) in the UUIE. The values have been + * specified in section 10.5.4.25 of 3GPP TS 24.008 */ +typedef enum { + RIL_UUS_DCS_USP = 0, /* User specified protocol */ + RIL_UUS_DCS_OSIHLP = 1, /* OSI higher layer protocol */ + RIL_UUS_DCS_X244 = 2, /* X.244 */ + RIL_UUS_DCS_RMCF = 3, /* Reserved for system mangement + convergence function */ + RIL_UUS_DCS_IA5c = 4 /* IA5 characters */ +} RIL_UUS_DCS; + +/* User-to-User Signaling Information defined in 3GPP 23.087 v8.0 + * This data is passed in RIL_ExtensionRecord and rec contains this + * structure when type is RIL_UUS_INFO_EXT_REC */ +typedef struct { + RIL_UUS_Type uusType; /* UUS Type */ + RIL_UUS_DCS uusDcs; /* UUS Data Coding Scheme */ + int uusLength; /* Length of UUS Data */ + char * uusData; /* UUS Data */ +} RIL_UUS_Info; + +/* CDMA Signal Information Record as defined in C.S0005 section 3.7.5.5 */ +typedef struct { + char isPresent; /* non-zero if signal information record is present */ + char signalType; /* as defined 3.7.5.5-1 */ + char alertPitch; /* as defined 3.7.5.5-2 */ + char signal; /* as defined 3.7.5.5-3, 3.7.5.5-4 or 3.7.5.5-5 */ +} RIL_CDMA_SignalInfoRecord; + +typedef struct { + RIL_CallState state; + int index; /* Connection Index for use with, eg, AT+CHLD */ + int toa; /* type of address, eg 145 = intl */ + char isMpty; /* nonzero if is mpty call */ + char isMT; /* nonzero if call is mobile terminated */ + char als; /* ALS line indicator if available + (0 = line 1) */ + char isVoice; /* nonzero if this is is a voice call */ + char isVoicePrivacy; /* nonzero if CDMA voice privacy mode is active */ + char * number; /* Remote party number */ + int numberPresentation; /* 0=Allowed, 1=Restricted, 2=Not Specified/Unknown 3=Payphone */ + char * name; /* Remote party name */ + int namePresentation; /* 0=Allowed, 1=Restricted, 2=Not Specified/Unknown 3=Payphone */ + RIL_UUS_Info * uusInfo; /* NULL or Pointer to User-User Signaling Information */ +} RIL_Call; + +/* Deprecated, use RIL_Data_Call_Response_v6 */ +typedef struct { + int cid; /* Context ID, uniquely identifies this call */ + int active; /* 0=inactive, 1=active/physical link down, 2=active/physical link up */ + char * type; /* One of the PDP_type values in TS 27.007 section 10.1.1. + For example, "IP", "IPV6", "IPV4V6", or "PPP". */ + char * apn; /* ignored */ + char * address; /* An address, e.g., "192.0.1.3" or "2001:db8::1". */ +} RIL_Data_Call_Response_v4; + +/* + * Returned by RIL_REQUEST_SETUP_DATA_CALL, RIL_REQUEST_DATA_CALL_LIST + * and RIL_UNSOL_DATA_CALL_LIST_CHANGED, on error status != 0. + */ +typedef struct { + int status; /* A RIL_DataCallFailCause, 0 which is PDP_FAIL_NONE if no error */ + int suggestedRetryTime; /* If status != 0, this fields indicates the suggested retry + back-off timer value RIL wants to override the one + pre-configured in FW. + The unit is miliseconds. + The value < 0 means no value is suggested. + The value 0 means retry should be done ASAP. + The value of INT_MAX(0x7fffffff) means no retry. */ + int cid; /* Context ID, uniquely identifies this call */ + int active; /* 0=inactive, 1=active/physical link down, 2=active/physical link up */ + char * type; /* One of the PDP_type values in TS 27.007 section 10.1.1. + For example, "IP", "IPV6", "IPV4V6", or "PPP". If status is + PDP_FAIL_ONLY_SINGLE_BEARER_ALLOWED this is the type supported + such as "IP" or "IPV6" */ + char * ifname; /* The network interface name */ + char * addresses; /* A space-delimited list of addresses with optional "/" prefix length, + e.g., "192.0.1.3" or "192.0.1.11/16 2001:db8::1/64". + May not be empty, typically 1 IPv4 or 1 IPv6 or + one of each. If the prefix length is absent the addresses + are assumed to be point to point with IPv4 having a prefix + length of 32 and IPv6 128. */ + char * dnses; /* A space-delimited list of DNS server addresses, + e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1". + May be empty. */ + char * gateways; /* A space-delimited list of default gateway addresses, + e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1". + May be empty in which case the addresses represent point + to point connections. */ +} RIL_Data_Call_Response_v6; + +typedef struct { + int status; /* A RIL_DataCallFailCause, 0 which is PDP_FAIL_NONE if no error */ + int suggestedRetryTime; /* If status != 0, this fields indicates the suggested retry + back-off timer value RIL wants to override the one + pre-configured in FW. + The unit is miliseconds. + The value < 0 means no value is suggested. + The value 0 means retry should be done ASAP. + The value of INT_MAX(0x7fffffff) means no retry. */ + int cid; /* Context ID, uniquely identifies this call */ + int active; /* 0=inactive, 1=active/physical link down, 2=active/physical link up */ + char * type; /* One of the PDP_type values in TS 27.007 section 10.1.1. + For example, "IP", "IPV6", "IPV4V6", or "PPP". If status is + PDP_FAIL_ONLY_SINGLE_BEARER_ALLOWED this is the type supported + such as "IP" or "IPV6" */ + char * ifname; /* The network interface name */ + char * addresses; /* A space-delimited list of addresses with optional "/" prefix length, + e.g., "192.0.1.3" or "192.0.1.11/16 2001:db8::1/64". + May not be empty, typically 1 IPv4 or 1 IPv6 or + one of each. If the prefix length is absent the addresses + are assumed to be point to point with IPv4 having a prefix + length of 32 and IPv6 128. */ + char * dnses; /* A space-delimited list of DNS server addresses, + e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1". + May be empty. */ + char * gateways; /* A space-delimited list of default gateway addresses, + e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1". + May be empty in which case the addresses represent point + to point connections. */ + char * pcscf; /* the Proxy Call State Control Function address + via PCO(Protocol Configuration Option) for IMS client. */ +} RIL_Data_Call_Response_v9; + +typedef struct { + int status; /* A RIL_DataCallFailCause, 0 which is PDP_FAIL_NONE if no error */ + int suggestedRetryTime; /* If status != 0, this fields indicates the suggested retry + back-off timer value RIL wants to override the one + pre-configured in FW. + The unit is miliseconds. + The value < 0 means no value is suggested. + The value 0 means retry should be done ASAP. + The value of INT_MAX(0x7fffffff) means no retry. */ + int cid; /* Context ID, uniquely identifies this call */ + int active; /* 0=inactive, 1=active/physical link down, 2=active/physical link up */ + char * type; /* One of the PDP_type values in TS 27.007 section 10.1.1. + For example, "IP", "IPV6", "IPV4V6", or "PPP". If status is + PDP_FAIL_ONLY_SINGLE_BEARER_ALLOWED this is the type supported + such as "IP" or "IPV6" */ + char * ifname; /* The network interface name */ + char * addresses; /* A space-delimited list of addresses with optional "/" prefix length, + e.g., "192.0.1.3" or "192.0.1.11/16 2001:db8::1/64". + May not be empty, typically 1 IPv4 or 1 IPv6 or + one of each. If the prefix length is absent the addresses + are assumed to be point to point with IPv4 having a prefix + length of 32 and IPv6 128. */ + char * dnses; /* A space-delimited list of DNS server addresses, + e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1". + May be empty. */ + char * gateways; /* A space-delimited list of default gateway addresses, + e.g., "192.0.1.3" or "192.0.1.11 2001:db8::1". + May be empty in which case the addresses represent point + to point connections. */ + char * pcscf; /* the Proxy Call State Control Function address + via PCO(Protocol Configuration Option) for IMS client. */ + int mtu; /* MTU received from network + Value <= 0 means network has either not sent a value or + sent an invalid value */ +} RIL_Data_Call_Response_v11; + +typedef enum { + RADIO_TECH_3GPP = 1, /* 3GPP Technologies - GSM, WCDMA */ + RADIO_TECH_3GPP2 = 2 /* 3GPP2 Technologies - CDMA */ +} RIL_RadioTechnologyFamily; + +typedef struct { + RIL_RadioTechnologyFamily tech; + unsigned char retry; /* 0 == not retry, nonzero == retry */ + int messageRef; /* Valid field if retry is set to nonzero. + Contains messageRef from RIL_SMS_Response + corresponding to failed MO SMS. + */ + + union { + /* Valid field if tech is RADIO_TECH_3GPP2. See RIL_REQUEST_CDMA_SEND_SMS */ + RIL_CDMA_SMS_Message* cdmaMessage; + + /* Valid field if tech is RADIO_TECH_3GPP. See RIL_REQUEST_SEND_SMS */ + char** gsmMessage; /* This is an array of pointers where pointers + are contiguous but elements pointed by those pointers + are not contiguous + */ + } message; +} RIL_IMS_SMS_Message; + +typedef struct { + int messageRef; /* TP-Message-Reference for GSM, + and BearerData MessageId for CDMA + (See 3GPP2 C.S0015-B, v2.0, table 4.5-1). */ + char *ackPDU; /* or NULL if n/a */ + int errorCode; /* See 3GPP 27.005, 3.2.5 for GSM/UMTS, + 3GPP2 N.S0005 (IS-41C) Table 171 for CDMA, + -1 if unknown or not applicable*/ +} RIL_SMS_Response; + +/** Used by RIL_REQUEST_WRITE_SMS_TO_SIM */ +typedef struct { + int status; /* Status of message. See TS 27.005 3.1, "": */ + /* 0 = "REC UNREAD" */ + /* 1 = "REC READ" */ + /* 2 = "STO UNSENT" */ + /* 3 = "STO SENT" */ + char * pdu; /* PDU of message to write, as an ASCII hex string less the SMSC address, + the TP-layer length is "strlen(pdu)/2". */ + char * smsc; /* SMSC address in GSM BCD format prefixed by a length byte + (as expected by TS 27.005) or NULL for default SMSC */ +} RIL_SMS_WriteArgs; + +/** Used by RIL_REQUEST_DIAL */ +typedef struct { + char * address; + int clir; + /* (same as 'n' paremeter in TS 27.007 7.7 "+CLIR" + * clir == 0 on "use subscription default value" + * clir == 1 on "CLIR invocation" (restrict CLI presentation) + * clir == 2 on "CLIR suppression" (allow CLI presentation) + */ + RIL_UUS_Info * uusInfo; /* NULL or Pointer to User-User Signaling Information */ +} RIL_Dial; + +typedef struct { + int command; /* one of the commands listed for TS 27.007 +CRSM*/ + int fileid; /* EF id */ + char *path; /* "pathid" from TS 27.007 +CRSM command. + Path is in hex asciii format eg "7f205f70" + Path must always be provided. + */ + int p1; + int p2; + int p3; + char *data; /* May be NULL*/ + char *pin2; /* May be NULL*/ +} RIL_SIM_IO_v5; + +typedef struct { + int command; /* one of the commands listed for TS 27.007 +CRSM*/ + int fileid; /* EF id */ + char *path; /* "pathid" from TS 27.007 +CRSM command. + Path is in hex asciii format eg "7f205f70" + Path must always be provided. + */ + int p1; + int p2; + int p3; + char *data; /* May be NULL*/ + char *pin2; /* May be NULL*/ + char *aidPtr; /* AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. */ +} RIL_SIM_IO_v6; + +/* Used by RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL and + * RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC. */ +typedef struct { + int sessionid; /* "sessionid" from TS 27.007 +CGLA command. Should be + ignored for +CSIM command. */ + + /* Following fields are used to derive the APDU ("command" and "length" + values in TS 27.007 +CSIM and +CGLA commands). */ + int cla; + int instruction; + int p1; + int p2; + int p3; /* A negative P3 implies a 4 byte APDU. */ + char *data; /* May be NULL. In hex string format. */ +} RIL_SIM_APDU; + +typedef struct { + int sw1; + int sw2; + char *simResponse; /* In hex string format ([a-fA-F0-9]*), except for SIM_AUTHENTICATION + response for which it is in Base64 format, see 3GPP TS 31.102 7.1.2 */ +} RIL_SIM_IO_Response; + +/* See also com.android.internal.telephony.gsm.CallForwardInfo */ + +typedef struct { + int status; /* + * For RIL_REQUEST_QUERY_CALL_FORWARD_STATUS + * status 1 = active, 0 = not active + * + * For RIL_REQUEST_SET_CALL_FORWARD: + * status is: + * 0 = disable + * 1 = enable + * 2 = interrogate + * 3 = registeration + * 4 = erasure + */ + + int reason; /* from TS 27.007 7.11 "reason" */ + int serviceClass;/* From 27.007 +CCFC/+CLCK "class" + See table for Android mapping from + MMI service code + 0 means user doesn't input class */ + int toa; /* "type" from TS 27.007 7.11 */ + char * number; /* "number" from TS 27.007 7.11. May be NULL */ + int timeSeconds; /* for CF no reply only */ +}RIL_CallForwardInfo; + +typedef struct { + char * cid; /* Combination of LAC and Cell Id in 32 bits in GSM. + * Upper 16 bits is LAC and lower 16 bits + * is CID (as described in TS 27.005) + * Primary Scrambling Code (as described in TS 25.331) + * in 9 bits in UMTS + * Valid values are hexadecimal 0x0000 - 0xffffffff. + */ + int rssi; /* Received RSSI in GSM, + * Level index of CPICH Received Signal Code Power in UMTS + */ +} RIL_NeighboringCell; + +typedef struct { + char lce_status; /* LCE service status: + * -1 = not supported; + * 0 = stopped; + * 1 = active. + */ + unsigned int actual_interval_ms; /* actual LCE reporting interval, + * meaningful only if LCEStatus = 1. + */ +} RIL_LceStatusInfo; + +typedef struct { + unsigned int last_hop_capacity_kbps; /* last-hop cellular capacity: kilobits/second. */ + unsigned char confidence_level; /* capacity estimate confidence: 0-100 */ + unsigned char lce_suspended; /* LCE report going to be suspended? (e.g., radio + * moves to inactive state or network type change) + * 1 = suspended; + * 0 = not suspended. + */ +} RIL_LceDataInfo; + +typedef enum { + RIL_MATCH_ALL = 0, /* Apply to all carriers with the same mcc/mnc */ + RIL_MATCH_SPN = 1, /* Use SPN and mcc/mnc to identify the carrier */ + RIL_MATCH_IMSI_PREFIX = 2, /* Use IMSI prefix and mcc/mnc to identify the carrier */ + RIL_MATCH_GID1 = 3, /* Use GID1 and mcc/mnc to identify the carrier */ + RIL_MATCH_GID2 = 4, /* Use GID2 and mcc/mnc to identify the carrier */ +} RIL_CarrierMatchType; + +typedef struct { + const char * mcc; + const char * mnc; + RIL_CarrierMatchType match_type; /* Specify match type for the carrier. + * If it’s RIL_MATCH_ALL, match_data is null; + * otherwise, match_data is the value for the match type. + */ + const char * match_data; +} RIL_Carrier; + +typedef struct { + int32_t len_allowed_carriers; /* length of array allowed_carriers */ + int32_t len_excluded_carriers; /* length of array excluded_carriers */ + RIL_Carrier * allowed_carriers; /* whitelist for allowed carriers */ + RIL_Carrier * excluded_carriers; /* blacklist for explicitly excluded carriers + * which match allowed_carriers. Eg. allowed_carriers match + * mcc/mnc, excluded_carriers has same mcc/mnc and gid1 + * is ABCD. It means except the carrier whose gid1 is ABCD, + * all carriers with the same mcc/mnc are allowed. + */ +} RIL_CarrierRestrictions; + +typedef struct { + char * mcc; /* MCC of the Carrier. */ + char * mnc ; /* MNC of the Carrier. */ + uint8_t * carrierKey; /* Public Key from the Carrier used to encrypt the + * IMSI/IMPI. + */ + int32_t carrierKeyLength; /* Length of the Public Key. */ + char * keyIdentifier; /* The keyIdentifier Attribute value pair that helps + * a server locate the private key to decrypt the + * permanent identity. + */ + int64_t expirationTime; /* Date-Time (in UTC) when the key will expire. */ + +} RIL_CarrierInfoForImsiEncryption; + +/* See RIL_REQUEST_LAST_CALL_FAIL_CAUSE */ +typedef enum { + CALL_FAIL_UNOBTAINABLE_NUMBER = 1, + CALL_FAIL_NO_ROUTE_TO_DESTINATION = 3, + CALL_FAIL_CHANNEL_UNACCEPTABLE = 6, + CALL_FAIL_OPERATOR_DETERMINED_BARRING = 8, + CALL_FAIL_NORMAL = 16, + CALL_FAIL_BUSY = 17, + CALL_FAIL_NO_USER_RESPONDING = 18, + CALL_FAIL_NO_ANSWER_FROM_USER = 19, + CALL_FAIL_CALL_REJECTED = 21, + CALL_FAIL_NUMBER_CHANGED = 22, + CALL_FAIL_PREEMPTION = 25, + CALL_FAIL_DESTINATION_OUT_OF_ORDER = 27, + CALL_FAIL_INVALID_NUMBER_FORMAT = 28, + CALL_FAIL_FACILITY_REJECTED = 29, + CALL_FAIL_RESP_TO_STATUS_ENQUIRY = 30, + CALL_FAIL_NORMAL_UNSPECIFIED = 31, + CALL_FAIL_CONGESTION = 34, + CALL_FAIL_NETWORK_OUT_OF_ORDER = 38, + CALL_FAIL_TEMPORARY_FAILURE = 41, + CALL_FAIL_SWITCHING_EQUIPMENT_CONGESTION = 42, + CALL_FAIL_ACCESS_INFORMATION_DISCARDED = 43, + CALL_FAIL_REQUESTED_CIRCUIT_OR_CHANNEL_NOT_AVAILABLE = 44, + CALL_FAIL_RESOURCES_UNAVAILABLE_OR_UNSPECIFIED = 47, + CALL_FAIL_QOS_UNAVAILABLE = 49, + CALL_FAIL_REQUESTED_FACILITY_NOT_SUBSCRIBED = 50, + CALL_FAIL_INCOMING_CALLS_BARRED_WITHIN_CUG = 55, + CALL_FAIL_BEARER_CAPABILITY_NOT_AUTHORIZED = 57, + CALL_FAIL_BEARER_CAPABILITY_UNAVAILABLE = 58, + CALL_FAIL_SERVICE_OPTION_NOT_AVAILABLE = 63, + CALL_FAIL_BEARER_SERVICE_NOT_IMPLEMENTED = 65, + CALL_FAIL_ACM_LIMIT_EXCEEDED = 68, + CALL_FAIL_REQUESTED_FACILITY_NOT_IMPLEMENTED = 69, + CALL_FAIL_ONLY_DIGITAL_INFORMATION_BEARER_AVAILABLE = 70, + CALL_FAIL_SERVICE_OR_OPTION_NOT_IMPLEMENTED = 79, + CALL_FAIL_INVALID_TRANSACTION_IDENTIFIER = 81, + CALL_FAIL_USER_NOT_MEMBER_OF_CUG = 87, + CALL_FAIL_INCOMPATIBLE_DESTINATION = 88, + CALL_FAIL_INVALID_TRANSIT_NW_SELECTION = 91, + CALL_FAIL_SEMANTICALLY_INCORRECT_MESSAGE = 95, + CALL_FAIL_INVALID_MANDATORY_INFORMATION = 96, + CALL_FAIL_MESSAGE_TYPE_NON_IMPLEMENTED = 97, + CALL_FAIL_MESSAGE_TYPE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE = 98, + CALL_FAIL_INFORMATION_ELEMENT_NON_EXISTENT = 99, + CALL_FAIL_CONDITIONAL_IE_ERROR = 100, + CALL_FAIL_MESSAGE_NOT_COMPATIBLE_WITH_PROTOCOL_STATE = 101, + CALL_FAIL_RECOVERY_ON_TIMER_EXPIRED = 102, + CALL_FAIL_PROTOCOL_ERROR_UNSPECIFIED = 111, + CALL_FAIL_INTERWORKING_UNSPECIFIED = 127, + CALL_FAIL_CALL_BARRED = 240, + CALL_FAIL_FDN_BLOCKED = 241, + CALL_FAIL_IMSI_UNKNOWN_IN_VLR = 242, + CALL_FAIL_IMEI_NOT_ACCEPTED = 243, + CALL_FAIL_DIAL_MODIFIED_TO_USSD = 244, /* STK Call Control */ + CALL_FAIL_DIAL_MODIFIED_TO_SS = 245, + CALL_FAIL_DIAL_MODIFIED_TO_DIAL = 246, + CALL_FAIL_RADIO_OFF = 247, /* Radio is OFF */ + CALL_FAIL_OUT_OF_SERVICE = 248, /* No cellular coverage */ + CALL_FAIL_NO_VALID_SIM = 249, /* No valid SIM is present */ + CALL_FAIL_RADIO_INTERNAL_ERROR = 250, /* Internal error at Modem */ + CALL_FAIL_NETWORK_RESP_TIMEOUT = 251, /* No response from network */ + CALL_FAIL_NETWORK_REJECT = 252, /* Explicit network reject */ + CALL_FAIL_RADIO_ACCESS_FAILURE = 253, /* RRC connection failure. Eg.RACH */ + CALL_FAIL_RADIO_LINK_FAILURE = 254, /* Radio Link Failure */ + CALL_FAIL_RADIO_LINK_LOST = 255, /* Radio link lost due to poor coverage */ + CALL_FAIL_RADIO_UPLINK_FAILURE = 256, /* Radio uplink failure */ + CALL_FAIL_RADIO_SETUP_FAILURE = 257, /* RRC connection setup failure */ + CALL_FAIL_RADIO_RELEASE_NORMAL = 258, /* RRC connection release, normal */ + CALL_FAIL_RADIO_RELEASE_ABNORMAL = 259, /* RRC connection release, abnormal */ + CALL_FAIL_ACCESS_CLASS_BLOCKED = 260, /* Access class barring */ + CALL_FAIL_NETWORK_DETACH = 261, /* Explicit network detach */ + CALL_FAIL_CDMA_LOCKED_UNTIL_POWER_CYCLE = 1000, + CALL_FAIL_CDMA_DROP = 1001, + CALL_FAIL_CDMA_INTERCEPT = 1002, + CALL_FAIL_CDMA_REORDER = 1003, + CALL_FAIL_CDMA_SO_REJECT = 1004, + CALL_FAIL_CDMA_RETRY_ORDER = 1005, + CALL_FAIL_CDMA_ACCESS_FAILURE = 1006, + CALL_FAIL_CDMA_PREEMPTED = 1007, + CALL_FAIL_CDMA_NOT_EMERGENCY = 1008, /* For non-emergency number dialed + during emergency callback mode */ + CALL_FAIL_CDMA_ACCESS_BLOCKED = 1009, /* CDMA network access probes blocked */ + + /* OEM specific error codes. Used to distinguish error from + * CALL_FAIL_ERROR_UNSPECIFIED and help assist debugging */ + CALL_FAIL_OEM_CAUSE_1 = 0xf001, + CALL_FAIL_OEM_CAUSE_2 = 0xf002, + CALL_FAIL_OEM_CAUSE_3 = 0xf003, + CALL_FAIL_OEM_CAUSE_4 = 0xf004, + CALL_FAIL_OEM_CAUSE_5 = 0xf005, + CALL_FAIL_OEM_CAUSE_6 = 0xf006, + CALL_FAIL_OEM_CAUSE_7 = 0xf007, + CALL_FAIL_OEM_CAUSE_8 = 0xf008, + CALL_FAIL_OEM_CAUSE_9 = 0xf009, + CALL_FAIL_OEM_CAUSE_10 = 0xf00a, + CALL_FAIL_OEM_CAUSE_11 = 0xf00b, + CALL_FAIL_OEM_CAUSE_12 = 0xf00c, + CALL_FAIL_OEM_CAUSE_13 = 0xf00d, + CALL_FAIL_OEM_CAUSE_14 = 0xf00e, + CALL_FAIL_OEM_CAUSE_15 = 0xf00f, + + CALL_FAIL_ERROR_UNSPECIFIED = 0xffff /* This error will be deprecated soon, + vendor code should make sure to map error + code to specific error */ +} RIL_LastCallFailCause; + +typedef struct { + RIL_LastCallFailCause cause_code; + char * vendor_cause; +} RIL_LastCallFailCauseInfo; + +/* See RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE */ +typedef enum { + PDP_FAIL_NONE = 0, /* No error, connection ok */ + + /* an integer cause code defined in TS 24.008 + section 6.1.3.1.3 or TS 24.301 Release 8+ Annex B. + If the implementation does not have access to the exact cause codes, + then it should return one of the following values, + as the UI layer needs to distinguish these + cases for error notification and potential retries. */ + PDP_FAIL_OPERATOR_BARRED = 0x08, /* no retry */ + PDP_FAIL_NAS_SIGNALLING = 0x0E, + PDP_FAIL_LLC_SNDCP = 0x19, + PDP_FAIL_INSUFFICIENT_RESOURCES = 0x1A, + PDP_FAIL_MISSING_UKNOWN_APN = 0x1B, /* no retry */ + PDP_FAIL_UNKNOWN_PDP_ADDRESS_TYPE = 0x1C, /* no retry */ + PDP_FAIL_USER_AUTHENTICATION = 0x1D, /* no retry */ + PDP_FAIL_ACTIVATION_REJECT_GGSN = 0x1E, /* no retry */ + PDP_FAIL_ACTIVATION_REJECT_UNSPECIFIED = 0x1F, + PDP_FAIL_SERVICE_OPTION_NOT_SUPPORTED = 0x20, /* no retry */ + PDP_FAIL_SERVICE_OPTION_NOT_SUBSCRIBED = 0x21, /* no retry */ + PDP_FAIL_SERVICE_OPTION_OUT_OF_ORDER = 0x22, + PDP_FAIL_NSAPI_IN_USE = 0x23, /* no retry */ + PDP_FAIL_REGULAR_DEACTIVATION = 0x24, /* possibly restart radio, + based on framework config */ + PDP_FAIL_QOS_NOT_ACCEPTED = 0x25, + PDP_FAIL_NETWORK_FAILURE = 0x26, + PDP_FAIL_UMTS_REACTIVATION_REQ = 0x27, + PDP_FAIL_FEATURE_NOT_SUPP = 0x28, + PDP_FAIL_TFT_SEMANTIC_ERROR = 0x29, + PDP_FAIL_TFT_SYTAX_ERROR = 0x2A, + PDP_FAIL_UNKNOWN_PDP_CONTEXT = 0x2B, + PDP_FAIL_FILTER_SEMANTIC_ERROR = 0x2C, + PDP_FAIL_FILTER_SYTAX_ERROR = 0x2D, + PDP_FAIL_PDP_WITHOUT_ACTIVE_TFT = 0x2E, + PDP_FAIL_ONLY_IPV4_ALLOWED = 0x32, /* no retry */ + PDP_FAIL_ONLY_IPV6_ALLOWED = 0x33, /* no retry */ + PDP_FAIL_ONLY_SINGLE_BEARER_ALLOWED = 0x34, + PDP_FAIL_ESM_INFO_NOT_RECEIVED = 0x35, + PDP_FAIL_PDN_CONN_DOES_NOT_EXIST = 0x36, + PDP_FAIL_MULTI_CONN_TO_SAME_PDN_NOT_ALLOWED = 0x37, + PDP_FAIL_MAX_ACTIVE_PDP_CONTEXT_REACHED = 0x41, + PDP_FAIL_UNSUPPORTED_APN_IN_CURRENT_PLMN = 0x42, + PDP_FAIL_INVALID_TRANSACTION_ID = 0x51, + PDP_FAIL_MESSAGE_INCORRECT_SEMANTIC = 0x5F, + PDP_FAIL_INVALID_MANDATORY_INFO = 0x60, + PDP_FAIL_MESSAGE_TYPE_UNSUPPORTED = 0x61, + PDP_FAIL_MSG_TYPE_NONCOMPATIBLE_STATE = 0x62, + PDP_FAIL_UNKNOWN_INFO_ELEMENT = 0x63, + PDP_FAIL_CONDITIONAL_IE_ERROR = 0x64, + PDP_FAIL_MSG_AND_PROTOCOL_STATE_UNCOMPATIBLE = 0x65, + PDP_FAIL_PROTOCOL_ERRORS = 0x6F, /* no retry */ + PDP_FAIL_APN_TYPE_CONFLICT = 0x70, + PDP_FAIL_INVALID_PCSCF_ADDR = 0x71, + PDP_FAIL_INTERNAL_CALL_PREEMPT_BY_HIGH_PRIO_APN = 0x72, + PDP_FAIL_EMM_ACCESS_BARRED = 0x73, + PDP_FAIL_EMERGENCY_IFACE_ONLY = 0x74, + PDP_FAIL_IFACE_MISMATCH = 0x75, + PDP_FAIL_COMPANION_IFACE_IN_USE = 0x76, + PDP_FAIL_IP_ADDRESS_MISMATCH = 0x77, + PDP_FAIL_IFACE_AND_POL_FAMILY_MISMATCH = 0x78, + PDP_FAIL_EMM_ACCESS_BARRED_INFINITE_RETRY = 0x79, + PDP_FAIL_AUTH_FAILURE_ON_EMERGENCY_CALL = 0x7A, + + // OEM specific error codes. To be used by OEMs when they don't want to + // reveal error code which would be replaced by PDP_FAIL_ERROR_UNSPECIFIED + PDP_FAIL_OEM_DCFAILCAUSE_1 = 0x1001, + PDP_FAIL_OEM_DCFAILCAUSE_2 = 0x1002, + PDP_FAIL_OEM_DCFAILCAUSE_3 = 0x1003, + PDP_FAIL_OEM_DCFAILCAUSE_4 = 0x1004, + PDP_FAIL_OEM_DCFAILCAUSE_5 = 0x1005, + PDP_FAIL_OEM_DCFAILCAUSE_6 = 0x1006, + PDP_FAIL_OEM_DCFAILCAUSE_7 = 0x1007, + PDP_FAIL_OEM_DCFAILCAUSE_8 = 0x1008, + PDP_FAIL_OEM_DCFAILCAUSE_9 = 0x1009, + PDP_FAIL_OEM_DCFAILCAUSE_10 = 0x100A, + PDP_FAIL_OEM_DCFAILCAUSE_11 = 0x100B, + PDP_FAIL_OEM_DCFAILCAUSE_12 = 0x100C, + PDP_FAIL_OEM_DCFAILCAUSE_13 = 0x100D, + PDP_FAIL_OEM_DCFAILCAUSE_14 = 0x100E, + PDP_FAIL_OEM_DCFAILCAUSE_15 = 0x100F, + + /* Not mentioned in the specification */ + PDP_FAIL_VOICE_REGISTRATION_FAIL = -1, + PDP_FAIL_DATA_REGISTRATION_FAIL = -2, + + /* reasons for data call drop - network/modem disconnect */ + PDP_FAIL_SIGNAL_LOST = -3, + PDP_FAIL_PREF_RADIO_TECH_CHANGED = -4,/* preferred technology has changed, should retry + with parameters appropriate for new technology */ + PDP_FAIL_RADIO_POWER_OFF = -5, /* data call was disconnected because radio was resetting, + powered off - no retry */ + PDP_FAIL_TETHERED_CALL_ACTIVE = -6, /* data call was disconnected by modem because tethered + mode was up on same APN/data profile - no retry until + tethered call is off */ + + PDP_FAIL_ERROR_UNSPECIFIED = 0xffff, /* retry silently. Will be deprecated soon as + new error codes are added making this unnecessary */ +} RIL_DataCallFailCause; + +/* See RIL_REQUEST_SETUP_DATA_CALL */ +typedef enum { + RIL_DATA_PROFILE_DEFAULT = 0, + RIL_DATA_PROFILE_TETHERED = 1, + RIL_DATA_PROFILE_IMS = 2, + RIL_DATA_PROFILE_FOTA = 3, + RIL_DATA_PROFILE_CBS = 4, + RIL_DATA_PROFILE_OEM_BASE = 1000, /* Start of OEM-specific profiles */ + RIL_DATA_PROFILE_INVALID = 0xFFFFFFFF +} RIL_DataProfile; + +/* Used by RIL_UNSOL_SUPP_SVC_NOTIFICATION */ +typedef struct { + int notificationType; /* + * 0 = MO intermediate result code + * 1 = MT unsolicited result code + */ + int code; /* See 27.007 7.17 + "code1" for MO + "code2" for MT. */ + int index; /* CUG index. See 27.007 7.17. */ + int type; /* "type" from 27.007 7.17 (MT only). */ + char * number; /* "number" from 27.007 7.17 + (MT only, may be NULL). */ +} RIL_SuppSvcNotification; + +#define RIL_CARD_MAX_APPS 8 + +typedef enum { + RIL_CARDSTATE_ABSENT = 0, + RIL_CARDSTATE_PRESENT = 1, + RIL_CARDSTATE_ERROR = 2, + RIL_CARDSTATE_RESTRICTED = 3 /* card is present but not usable due to carrier restrictions.*/ +} RIL_CardState; + +typedef enum { + RIL_PERSOSUBSTATE_UNKNOWN = 0, /* initial state */ + RIL_PERSOSUBSTATE_IN_PROGRESS = 1, /* in between each lock transition */ + RIL_PERSOSUBSTATE_READY = 2, /* when either SIM or RUIM Perso is finished + since each app can only have 1 active perso + involved */ + RIL_PERSOSUBSTATE_SIM_NETWORK = 3, + RIL_PERSOSUBSTATE_SIM_NETWORK_SUBSET = 4, + RIL_PERSOSUBSTATE_SIM_CORPORATE = 5, + RIL_PERSOSUBSTATE_SIM_SERVICE_PROVIDER = 6, + RIL_PERSOSUBSTATE_SIM_SIM = 7, + RIL_PERSOSUBSTATE_SIM_NETWORK_PUK = 8, /* The corresponding perso lock is blocked */ + RIL_PERSOSUBSTATE_SIM_NETWORK_SUBSET_PUK = 9, + RIL_PERSOSUBSTATE_SIM_CORPORATE_PUK = 10, + RIL_PERSOSUBSTATE_SIM_SERVICE_PROVIDER_PUK = 11, + RIL_PERSOSUBSTATE_SIM_SIM_PUK = 12, + RIL_PERSOSUBSTATE_RUIM_NETWORK1 = 13, + RIL_PERSOSUBSTATE_RUIM_NETWORK2 = 14, + RIL_PERSOSUBSTATE_RUIM_HRPD = 15, + RIL_PERSOSUBSTATE_RUIM_CORPORATE = 16, + RIL_PERSOSUBSTATE_RUIM_SERVICE_PROVIDER = 17, + RIL_PERSOSUBSTATE_RUIM_RUIM = 18, + RIL_PERSOSUBSTATE_RUIM_NETWORK1_PUK = 19, /* The corresponding perso lock is blocked */ + RIL_PERSOSUBSTATE_RUIM_NETWORK2_PUK = 20, + RIL_PERSOSUBSTATE_RUIM_HRPD_PUK = 21, + RIL_PERSOSUBSTATE_RUIM_CORPORATE_PUK = 22, + RIL_PERSOSUBSTATE_RUIM_SERVICE_PROVIDER_PUK = 23, + RIL_PERSOSUBSTATE_RUIM_RUIM_PUK = 24 +} RIL_PersoSubstate; + +typedef enum { + RIL_APPSTATE_UNKNOWN = 0, + RIL_APPSTATE_DETECTED = 1, + RIL_APPSTATE_PIN = 2, /* If PIN1 or UPin is required */ + RIL_APPSTATE_PUK = 3, /* If PUK1 or Puk for UPin is required */ + RIL_APPSTATE_SUBSCRIPTION_PERSO = 4, /* perso_substate should be look at + when app_state is assigned to this value */ + RIL_APPSTATE_READY = 5 +} RIL_AppState; + +typedef enum { + RIL_PINSTATE_UNKNOWN = 0, + RIL_PINSTATE_ENABLED_NOT_VERIFIED = 1, + RIL_PINSTATE_ENABLED_VERIFIED = 2, + RIL_PINSTATE_DISABLED = 3, + RIL_PINSTATE_ENABLED_BLOCKED = 4, + RIL_PINSTATE_ENABLED_PERM_BLOCKED = 5 +} RIL_PinState; + +typedef enum { + RIL_APPTYPE_UNKNOWN = 0, + RIL_APPTYPE_SIM = 1, + RIL_APPTYPE_USIM = 2, + RIL_APPTYPE_RUIM = 3, + RIL_APPTYPE_CSIM = 4, + RIL_APPTYPE_ISIM = 5 +} RIL_AppType; + +/* + * Please note that registration state UNKNOWN is + * treated as "out of service" in the Android telephony. + * Registration state REG_DENIED must be returned if Location Update + * Reject (with cause 17 - Network Failure) is received + * repeatedly from the network, to facilitate + * "managed roaming" + */ +typedef enum { + RIL_NOT_REG_AND_NOT_SEARCHING = 0, // Not registered, MT is not currently searching + // a new operator to register + RIL_REG_HOME = 1, // Registered, home network + RIL_NOT_REG_AND_SEARCHING = 2, // Not registered, but MT is currently searching + // a new operator to register + RIL_REG_DENIED = 3, // Registration denied + RIL_UNKNOWN = 4, // Unknown + RIL_REG_ROAMING = 5, // Registered, roaming + RIL_NOT_REG_AND_EMERGENCY_AVAILABLE_AND_NOT_SEARCHING = 10, // Same as + // RIL_NOT_REG_AND_NOT_SEARCHING but indicates that + // emergency calls are enabled. + RIL_NOT_REG_AND_EMERGENCY_AVAILABLE_AND_SEARCHING = 12, // Same as RIL_NOT_REG_AND_SEARCHING + // but indicates that + // emergency calls are enabled. + RIL_REG_DENIED_AND_EMERGENCY_AVAILABLE = 13, // Same as REG_DENIED but indicates that + // emergency calls are enabled. + RIL_UNKNOWN_AND_EMERGENCY_AVAILABLE = 14, // Same as UNKNOWN but indicates that + // emergency calls are enabled. +} RIL_RegState; + +typedef struct +{ + RIL_AppType app_type; + RIL_AppState app_state; + RIL_PersoSubstate perso_substate; /* applicable only if app_state == + RIL_APPSTATE_SUBSCRIPTION_PERSO */ + char *aid_ptr; /* null terminated string, e.g., from 0xA0, 0x00 -> 0x41, + 0x30, 0x30, 0x30 */ + char *app_label_ptr; /* null terminated string */ + int pin1_replaced; /* applicable to USIM, CSIM & ISIM */ + RIL_PinState pin1; + RIL_PinState pin2; +} RIL_AppStatus; + +/* Deprecated, use RIL_CardStatus_v6 */ +typedef struct +{ + RIL_CardState card_state; + RIL_PinState universal_pin_state; /* applicable to USIM and CSIM: RIL_PINSTATE_xxx */ + int gsm_umts_subscription_app_index; /* value < RIL_CARD_MAX_APPS, -1 if none */ + int cdma_subscription_app_index; /* value < RIL_CARD_MAX_APPS, -1 if none */ + int num_applications; /* value <= RIL_CARD_MAX_APPS */ + RIL_AppStatus applications[RIL_CARD_MAX_APPS]; +} RIL_CardStatus_v5; + +typedef struct +{ + RIL_CardState card_state; + RIL_PinState universal_pin_state; /* applicable to USIM and CSIM: RIL_PINSTATE_xxx */ + int gsm_umts_subscription_app_index; /* value < RIL_CARD_MAX_APPS, -1 if none */ + int cdma_subscription_app_index; /* value < RIL_CARD_MAX_APPS, -1 if none */ + int ims_subscription_app_index; /* value < RIL_CARD_MAX_APPS, -1 if none */ + int num_applications; /* value <= RIL_CARD_MAX_APPS */ + RIL_AppStatus applications[RIL_CARD_MAX_APPS]; +} RIL_CardStatus_v6; + +/** The result of a SIM refresh, returned in data[0] of RIL_UNSOL_SIM_REFRESH + * or as part of RIL_SimRefreshResponse_v7 + */ +typedef enum { + /* A file on SIM has been updated. data[1] contains the EFID. */ + SIM_FILE_UPDATE = 0, + /* SIM initialized. All files should be re-read. */ + SIM_INIT = 1, + /* SIM reset. SIM power required, SIM may be locked and all files should be re-read. */ + SIM_RESET = 2 +} RIL_SimRefreshResult; + +typedef struct { + RIL_SimRefreshResult result; + int ef_id; /* is the EFID of the updated file if the result is */ + /* SIM_FILE_UPDATE or 0 for any other result. */ + char * aid; /* is AID(application ID) of the card application */ + /* See ETSI 102.221 8.1 and 101.220 4 */ + /* For SIM_FILE_UPDATE result it can be set to AID of */ + /* application in which updated EF resides or it can be */ + /* NULL if EF is outside of an application. */ + /* For SIM_INIT result this field is set to AID of */ + /* application that caused REFRESH */ + /* For SIM_RESET result it is NULL. */ +} RIL_SimRefreshResponse_v7; + +/* Deprecated, use RIL_CDMA_CallWaiting_v6 */ +typedef struct { + char * number; /* Remote party number */ + int numberPresentation; /* 0=Allowed, 1=Restricted, 2=Not Specified/Unknown */ + char * name; /* Remote party name */ + RIL_CDMA_SignalInfoRecord signalInfoRecord; +} RIL_CDMA_CallWaiting_v5; + +typedef struct { + char * number; /* Remote party number */ + int numberPresentation; /* 0=Allowed, 1=Restricted, 2=Not Specified/Unknown */ + char * name; /* Remote party name */ + RIL_CDMA_SignalInfoRecord signalInfoRecord; + /* Number type/Number plan required to support International Call Waiting */ + int number_type; /* 0=Unknown, 1=International, 2=National, + 3=Network specific, 4=subscriber */ + int number_plan; /* 0=Unknown, 1=ISDN, 3=Data, 4=Telex, 8=Nat'l, 9=Private */ +} RIL_CDMA_CallWaiting_v6; + +/** + * Which types of Cell Broadcast Message (CBM) are to be received by the ME + * + * uFromServiceID - uToServiceID defines a range of CBM message identifiers + * whose value is 0x0000 - 0xFFFF as defined in TS 23.041 9.4.1.2.2 for GMS + * and 9.4.4.2.2 for UMTS. All other values can be treated as empty + * CBM message ID. + * + * uFromCodeScheme - uToCodeScheme defines a range of CBM data coding schemes + * whose value is 0x00 - 0xFF as defined in TS 23.041 9.4.1.2.3 for GMS + * and 9.4.4.2.3 for UMTS. + * All other values can be treated as empty CBM data coding scheme. + * + * selected 0 means message types specified in + * and are not accepted, while 1 means accepted. + * + * Used by RIL_REQUEST_GSM_GET_BROADCAST_CONFIG and + * RIL_REQUEST_GSM_SET_BROADCAST_CONFIG. + */ +typedef struct { + int fromServiceId; + int toServiceId; + int fromCodeScheme; + int toCodeScheme; + unsigned char selected; +} RIL_GSM_BroadcastSmsConfigInfo; + +/* No restriction at all including voice/SMS/USSD/SS/AV64 and packet data. */ +#define RIL_RESTRICTED_STATE_NONE 0x00 +/* Block emergency call due to restriction. But allow all normal voice/SMS/USSD/SS/AV64. */ +#define RIL_RESTRICTED_STATE_CS_EMERGENCY 0x01 +/* Block all normal voice/SMS/USSD/SS/AV64 due to restriction. Only Emergency call allowed. */ +#define RIL_RESTRICTED_STATE_CS_NORMAL 0x02 +/* Block all voice/SMS/USSD/SS/AV64 including emergency call due to restriction.*/ +#define RIL_RESTRICTED_STATE_CS_ALL 0x04 +/* Block packet data access due to restriction. */ +#define RIL_RESTRICTED_STATE_PS_ALL 0x10 + +/* The status for an OTASP/OTAPA session */ +typedef enum { + CDMA_OTA_PROVISION_STATUS_SPL_UNLOCKED, + CDMA_OTA_PROVISION_STATUS_SPC_RETRIES_EXCEEDED, + CDMA_OTA_PROVISION_STATUS_A_KEY_EXCHANGED, + CDMA_OTA_PROVISION_STATUS_SSD_UPDATED, + CDMA_OTA_PROVISION_STATUS_NAM_DOWNLOADED, + CDMA_OTA_PROVISION_STATUS_MDN_DOWNLOADED, + CDMA_OTA_PROVISION_STATUS_IMSI_DOWNLOADED, + CDMA_OTA_PROVISION_STATUS_PRL_DOWNLOADED, + CDMA_OTA_PROVISION_STATUS_COMMITTED, + CDMA_OTA_PROVISION_STATUS_OTAPA_STARTED, + CDMA_OTA_PROVISION_STATUS_OTAPA_STOPPED, + CDMA_OTA_PROVISION_STATUS_OTAPA_ABORTED +} RIL_CDMA_OTA_ProvisionStatus; + +typedef struct { + int signalStrength; /* Valid values are (0-31, 99) as defined in TS 27.007 8.5 */ + int bitErrorRate; /* bit error rate (0-7, 99) as defined in TS 27.007 8.5 */ +} RIL_GW_SignalStrength; + +typedef struct { + int signalStrength; /* Valid values are (0-31, 99) as defined in TS 27.007 8.5 */ + int bitErrorRate; /* bit error rate (0-7, 99) as defined in TS 27.007 8.5 */ + int timingAdvance; /* Timing Advance in bit periods. 1 bit period = 48/13 us. + * INT_MAX denotes invalid value */ +} RIL_GSM_SignalStrength_v12; + +typedef struct { + int signalStrength; /* Valid values are (0-31, 99) as defined in TS 27.007 8.5 */ + int bitErrorRate; /* bit error rate (0-7, 99) as defined in TS 27.007 8.5 */ +} RIL_SignalStrengthWcdma; + +typedef struct { + int dbm; /* Valid values are positive integers. This value is the actual RSSI value + * multiplied by -1. Example: If the actual RSSI is -75, then this response + * value will be 75. + */ + int ecio; /* Valid values are positive integers. This value is the actual Ec/Io multiplied + * by -10. Example: If the actual Ec/Io is -12.5 dB, then this response value + * will be 125. + */ +} RIL_CDMA_SignalStrength; + + +typedef struct { + int dbm; /* Valid values are positive integers. This value is the actual RSSI value + * multiplied by -1. Example: If the actual RSSI is -75, then this response + * value will be 75. + */ + int ecio; /* Valid values are positive integers. This value is the actual Ec/Io multiplied + * by -10. Example: If the actual Ec/Io is -12.5 dB, then this response value + * will be 125. + */ + int signalNoiseRatio; /* Valid values are 0-8. 8 is the highest signal to noise ratio. */ +} RIL_EVDO_SignalStrength; + +typedef struct { + int signalStrength; /* Valid values are (0-31, 99) as defined in TS 27.007 8.5 */ + int rsrp; /* The current Reference Signal Receive Power in dBm multipled by -1. + * Range: 44 to 140 dBm + * INT_MAX: 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 36.133 9.1.4 */ + int rsrq; /* The current Reference Signal Receive Quality in dB multiplied by -1. + * Range: 20 to 3 dB. + * INT_MAX: 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 36.133 9.1.7 */ + int rssnr; /* The current reference signal signal-to-noise ratio in 0.1 dB units. + * Range: -200 to +300 (-200 = -20.0 dB, +300 = 30dB). + * INT_MAX : 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 36.101 8.1.1 */ + int cqi; /* The current Channel Quality Indicator. + * Range: 0 to 15. + * INT_MAX : 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 36.101 9.2, 9.3, A.4 */ +} RIL_LTE_SignalStrength; + +typedef struct { + int signalStrength; /* Valid values are (0-31, 99) as defined in TS 27.007 8.5 */ + int rsrp; /* The current Reference Signal Receive Power in dBm multipled by -1. + * Range: 44 to 140 dBm + * INT_MAX: 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 36.133 9.1.4 */ + int rsrq; /* The current Reference Signal Receive Quality in dB multiplied by -1. + * Range: 20 to 3 dB. + * INT_MAX: 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 36.133 9.1.7 */ + int rssnr; /* The current reference signal signal-to-noise ratio in 0.1 dB units. + * Range: -200 to +300 (-200 = -20.0 dB, +300 = 30dB). + * INT_MAX : 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 36.101 8.1.1 */ + int cqi; /* The current Channel Quality Indicator. + * Range: 0 to 15. + * INT_MAX : 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 36.101 9.2, 9.3, A.4 */ + int timingAdvance; /* timing advance in micro seconds for a one way trip from cell to device. + * Approximate distance can be calculated using 300m/us * timingAdvance. + * Range: 0 to 0x7FFFFFFE + * INT_MAX : 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP 36.321 section 6.1.3.5 + * also: http://www.cellular-planningoptimization.com/2010/02/timing-advance-with-calculation.html */ +} RIL_LTE_SignalStrength_v8; + +typedef struct { + int rscp; /* The Received Signal Code Power in dBm multipled by -1. + * Range : 25 to 120 + * INT_MAX: 0x7FFFFFFF denotes invalid value. + * Reference: 3GPP TS 25.123, section 9.1.1.1 */ +} RIL_TD_SCDMA_SignalStrength; + +/* Deprecated, use RIL_SignalStrength_v6 */ +typedef struct { + RIL_GW_SignalStrength GW_SignalStrength; + RIL_CDMA_SignalStrength CDMA_SignalStrength; + RIL_EVDO_SignalStrength EVDO_SignalStrength; +} RIL_SignalStrength_v5; + +typedef struct { + RIL_GW_SignalStrength GW_SignalStrength; + RIL_CDMA_SignalStrength CDMA_SignalStrength; + RIL_EVDO_SignalStrength EVDO_SignalStrength; + RIL_LTE_SignalStrength LTE_SignalStrength; +} RIL_SignalStrength_v6; + +typedef struct { + RIL_GW_SignalStrength GW_SignalStrength; + RIL_CDMA_SignalStrength CDMA_SignalStrength; + RIL_EVDO_SignalStrength EVDO_SignalStrength; + RIL_LTE_SignalStrength_v8 LTE_SignalStrength; +} RIL_SignalStrength_v8; + +typedef struct { + RIL_GW_SignalStrength GW_SignalStrength; + RIL_CDMA_SignalStrength CDMA_SignalStrength; + RIL_EVDO_SignalStrength EVDO_SignalStrength; + RIL_LTE_SignalStrength_v8 LTE_SignalStrength; + RIL_TD_SCDMA_SignalStrength TD_SCDMA_SignalStrength; +} RIL_SignalStrength_v10; + +typedef struct { + int mcc; /* 3-digit Mobile Country Code, 0..999, INT_MAX if unknown */ + int mnc; /* 2 or 3-digit Mobile Network Code, 0..999, INT_MAX if unknown */ + int lac; /* 16-bit Location Area Code, 0..65535, INT_MAX if unknown */ + int cid; /* 16-bit GSM Cell Identity described in TS 27.007, 0..65535, INT_MAX if unknown */ +} RIL_CellIdentityGsm; + +typedef struct { + int mcc; /* 3-digit Mobile Country Code, 0..999, INT_MAX if unknown */ + int mnc; /* 2 or 3-digit Mobile Network Code, 0..999, INT_MAX if unknown */ + int lac; /* 16-bit Location Area Code, 0..65535, INT_MAX if unknown */ + int cid; /* 16-bit GSM Cell Identity described in TS 27.007, 0..65535, INT_MAX if unknown */ + int arfcn; /* 16-bit GSM Absolute RF channel number; this value must be reported */ + uint8_t bsic; /* 6-bit Base Station Identity Code; 0xFF if unknown */ +} RIL_CellIdentityGsm_v12; + +typedef struct { + int mcc; /* 3-digit Mobile Country Code, 0..999, INT_MAX if unknown */ + int mnc; /* 2 or 3-digit Mobile Network Code, 0..999, INT_MAX if unknown */ + int lac; /* 16-bit Location Area Code, 0..65535, INT_MAX if unknown */ + int cid; /* 28-bit UMTS Cell Identity described in TS 25.331, 0..268435455, INT_MAX if unknown */ + int psc; /* 9-bit UMTS Primary Scrambling Code described in TS 25.331, 0..511, INT_MAX if unknown */ +} RIL_CellIdentityWcdma; + +typedef struct { + int mcc; /* 3-digit Mobile Country Code, 0..999, INT_MAX if unknown */ + int mnc; /* 2 or 3-digit Mobile Network Code, 0..999, INT_MAX if unknown */ + int lac; /* 16-bit Location Area Code, 0..65535, INT_MAX if unknown */ + int cid; /* 28-bit UMTS Cell Identity described in TS 25.331, 0..268435455, INT_MAX if unknown */ + int psc; /* 9-bit UMTS Primary Scrambling Code described in TS 25.331, 0..511; this value must be reported */ + int uarfcn; /* 16-bit UMTS Absolute RF Channel Number; this value must be reported */ +} RIL_CellIdentityWcdma_v12; + +typedef struct { + int networkId; /* Network Id 0..65535, INT_MAX if unknown */ + int systemId; /* CDMA System Id 0..32767, INT_MAX if unknown */ + int basestationId; /* Base Station Id 0..65535, INT_MAX if unknown */ + int longitude; /* Longitude is a decimal number as specified in 3GPP2 C.S0005-A v6.0. + * It is represented in units of 0.25 seconds and ranges from -2592000 + * to 2592000, both values inclusive (corresponding to a range of -180 + * to +180 degrees). INT_MAX if unknown */ + + int latitude; /* Latitude is a decimal number as specified in 3GPP2 C.S0005-A v6.0. + * It is represented in units of 0.25 seconds and ranges from -1296000 + * to 1296000, both values inclusive (corresponding to a range of -90 + * to +90 degrees). INT_MAX if unknown */ +} RIL_CellIdentityCdma; + +typedef struct { + int mcc; /* 3-digit Mobile Country Code, 0..999, INT_MAX if unknown */ + int mnc; /* 2 or 3-digit Mobile Network Code, 0..999, INT_MAX if unknown */ + int ci; /* 28-bit Cell Identity described in TS ???, INT_MAX if unknown */ + int pci; /* physical cell id 0..503, INT_MAX if unknown */ + int tac; /* 16-bit tracking area code, INT_MAX if unknown */ +} RIL_CellIdentityLte; + +typedef struct { + int mcc; /* 3-digit Mobile Country Code, 0..999, INT_MAX if unknown */ + int mnc; /* 2 or 3-digit Mobile Network Code, 0..999, INT_MAX if unknown */ + int ci; /* 28-bit Cell Identity described in TS ???, INT_MAX if unknown */ + int pci; /* physical cell id 0..503; this value must be reported */ + int tac; /* 16-bit tracking area code, INT_MAX if unknown */ + int earfcn; /* 18-bit LTE Absolute RF Channel Number; this value must be reported */ +} RIL_CellIdentityLte_v12; + +typedef struct { + int mcc; /* 3-digit Mobile Country Code, 0..999, INT_MAX if unknown */ + int mnc; /* 2 or 3-digit Mobile Network Code, 0..999, INT_MAX if unknown */ + int lac; /* 16-bit Location Area Code, 0..65535, INT_MAX if unknown */ + int cid; /* 28-bit UMTS Cell Identity described in TS 25.331, 0..268435455, INT_MAX if unknown */ + int cpid; /* 8-bit Cell Parameters ID described in TS 25.331, 0..127, INT_MAX if unknown */ +} RIL_CellIdentityTdscdma; + +typedef struct { + RIL_CellIdentityGsm cellIdentityGsm; + RIL_GW_SignalStrength signalStrengthGsm; +} RIL_CellInfoGsm; + +typedef struct { + RIL_CellIdentityGsm_v12 cellIdentityGsm; + RIL_GSM_SignalStrength_v12 signalStrengthGsm; +} RIL_CellInfoGsm_v12; + +typedef struct { + RIL_CellIdentityWcdma cellIdentityWcdma; + RIL_SignalStrengthWcdma signalStrengthWcdma; +} RIL_CellInfoWcdma; + +typedef struct { + RIL_CellIdentityWcdma_v12 cellIdentityWcdma; + RIL_SignalStrengthWcdma signalStrengthWcdma; +} RIL_CellInfoWcdma_v12; + +typedef struct { + RIL_CellIdentityCdma cellIdentityCdma; + RIL_CDMA_SignalStrength signalStrengthCdma; + RIL_EVDO_SignalStrength signalStrengthEvdo; +} RIL_CellInfoCdma; + +typedef struct { + RIL_CellIdentityLte cellIdentityLte; + RIL_LTE_SignalStrength_v8 signalStrengthLte; +} RIL_CellInfoLte; + +typedef struct { + RIL_CellIdentityLte_v12 cellIdentityLte; + RIL_LTE_SignalStrength_v8 signalStrengthLte; +} RIL_CellInfoLte_v12; + +typedef struct { + RIL_CellIdentityTdscdma cellIdentityTdscdma; + RIL_TD_SCDMA_SignalStrength signalStrengthTdscdma; +} RIL_CellInfoTdscdma; + +// Must be the same as CellInfo.TYPE_XXX +typedef enum { + RIL_CELL_INFO_TYPE_NONE = 0, /* indicates no cell information */ + RIL_CELL_INFO_TYPE_GSM = 1, + RIL_CELL_INFO_TYPE_CDMA = 2, + RIL_CELL_INFO_TYPE_LTE = 3, + RIL_CELL_INFO_TYPE_WCDMA = 4, + RIL_CELL_INFO_TYPE_TD_SCDMA = 5 +} RIL_CellInfoType; + +// Must be the same as CellInfo.TIMESTAMP_TYPE_XXX +typedef enum { + RIL_TIMESTAMP_TYPE_UNKNOWN = 0, + RIL_TIMESTAMP_TYPE_ANTENNA = 1, + RIL_TIMESTAMP_TYPE_MODEM = 2, + RIL_TIMESTAMP_TYPE_OEM_RIL = 3, + RIL_TIMESTAMP_TYPE_JAVA_RIL = 4, +} RIL_TimeStampType; + +typedef struct { + RIL_CellInfoType cellInfoType; /* cell type for selecting from union CellInfo */ + int registered; /* !0 if this cell is registered 0 if not registered */ + RIL_TimeStampType timeStampType; /* type of time stamp represented by timeStamp */ + uint64_t timeStamp; /* Time in nanos as returned by ril_nano_time */ + union { + RIL_CellInfoGsm gsm; + RIL_CellInfoCdma cdma; + RIL_CellInfoLte lte; + RIL_CellInfoWcdma wcdma; + RIL_CellInfoTdscdma tdscdma; + } CellInfo; +} RIL_CellInfo; + +typedef struct { + RIL_CellInfoType cellInfoType; /* cell type for selecting from union CellInfo */ + int registered; /* !0 if this cell is registered 0 if not registered */ + RIL_TimeStampType timeStampType; /* type of time stamp represented by timeStamp */ + uint64_t timeStamp; /* Time in nanos as returned by ril_nano_time */ + union { + RIL_CellInfoGsm_v12 gsm; + RIL_CellInfoCdma cdma; + RIL_CellInfoLte_v12 lte; + RIL_CellInfoWcdma_v12 wcdma; + RIL_CellInfoTdscdma tdscdma; + } CellInfo; +} RIL_CellInfo_v12; + +typedef struct { + RIL_CellInfoType cellInfoType; /* cell type for selecting from union CellInfo */ + union { + RIL_CellIdentityGsm_v12 cellIdentityGsm; + RIL_CellIdentityWcdma_v12 cellIdentityWcdma; + RIL_CellIdentityLte_v12 cellIdentityLte; + RIL_CellIdentityTdscdma cellIdentityTdscdma; + RIL_CellIdentityCdma cellIdentityCdma; + }; +}RIL_CellIdentity_v16; + +typedef struct { + RIL_RegState regState; // Valid reg states are RIL_NOT_REG_AND_NOT_SEARCHING, + // REG_HOME, RIL_NOT_REG_AND_SEARCHING, REG_DENIED, + // UNKNOWN, REG_ROAMING defined in RegState + RIL_RadioTechnology rat; // indicates the available voice radio technology, + // valid values as defined by RadioTechnology. + int32_t cssSupported; // concurrent services support indicator. if + // registered on a CDMA system. + // 0 - Concurrent services not supported, + // 1 - Concurrent services supported + int32_t roamingIndicator; // TSB-58 Roaming Indicator if registered + // on a CDMA or EVDO system or -1 if not. + // Valid values are 0-255. + int32_t systemIsInPrl; // indicates whether the current system is in the + // PRL if registered on a CDMA or EVDO system or -1 if + // not. 0=not in the PRL, 1=in the PRL + int32_t defaultRoamingIndicator; // default Roaming Indicator from the PRL, + // if registered on a CDMA or EVDO system or -1 if not. + // Valid values are 0-255. + int32_t reasonForDenial; // reasonForDenial if registration state is 3 + // (Registration denied) this is an enumerated reason why + // registration was denied. See 3GPP TS 24.008, + // 10.5.3.6 and Annex G. + // 0 - General + // 1 - Authentication Failure + // 2 - IMSI unknown in HLR + // 3 - Illegal MS + // 4 - Illegal ME + // 5 - PLMN not allowed + // 6 - Location area not allowed + // 7 - Roaming not allowed + // 8 - No Suitable Cells in this Location Area + // 9 - Network failure + // 10 - Persistent location update reject + // 11 - PLMN not allowed + // 12 - Location area not allowed + // 13 - Roaming not allowed in this Location Area + // 15 - No Suitable Cells in this Location Area + // 17 - Network Failure + // 20 - MAC Failure + // 21 - Sync Failure + // 22 - Congestion + // 23 - GSM Authentication unacceptable + // 25 - Not Authorized for this CSG + // 32 - Service option not supported + // 33 - Requested service option not subscribed + // 34 - Service option temporarily out of order + // 38 - Call cannot be identified + // 48-63 - Retry upon entry into a new cell + // 95 - Semantically incorrect message + // 96 - Invalid mandatory information + // 97 - Message type non-existent or not implemented + // 98 - Message type not compatible with protocol state + // 99 - Information element non-existent or + // not implemented + // 100 - Conditional IE error + // 101 - Message not compatible with protocol state; + RIL_CellIdentity_v16 cellIdentity; // current cell information +}RIL_VoiceRegistrationStateResponse; + + +typedef struct { + RIL_RegState regState; // Valid reg states are RIL_NOT_REG_AND_NOT_SEARCHING, + // REG_HOME, RIL_NOT_REG_AND_SEARCHING, REG_DENIED, + // UNKNOWN, REG_ROAMING defined in RegState + RIL_RadioTechnology rat; // indicates the available data radio technology, + // valid values as defined by RadioTechnology. + int32_t reasonDataDenied; // if registration state is 3 (Registration + // denied) this is an enumerated reason why + // registration was denied. See 3GPP TS 24.008, + // Annex G.6 "Additional cause codes for GMM". + // 7 == GPRS services not allowed + // 8 == GPRS services and non-GPRS services not allowed + // 9 == MS identity cannot be derived by the network + // 10 == Implicitly detached + // 14 == GPRS services not allowed in this PLMN + // 16 == MSC temporarily not reachable + // 40 == No PDP context activated + int32_t maxDataCalls; // The maximum number of simultaneous Data Calls that + // must be established using setupDataCall(). + RIL_CellIdentity_v16 cellIdentity; // Current cell information +}RIL_DataRegistrationStateResponse; + +/* Names of the CDMA info records (C.S0005 section 3.7.5) */ +typedef enum { + RIL_CDMA_DISPLAY_INFO_REC, + RIL_CDMA_CALLED_PARTY_NUMBER_INFO_REC, + RIL_CDMA_CALLING_PARTY_NUMBER_INFO_REC, + RIL_CDMA_CONNECTED_NUMBER_INFO_REC, + RIL_CDMA_SIGNAL_INFO_REC, + RIL_CDMA_REDIRECTING_NUMBER_INFO_REC, + RIL_CDMA_LINE_CONTROL_INFO_REC, + RIL_CDMA_EXTENDED_DISPLAY_INFO_REC, + RIL_CDMA_T53_CLIR_INFO_REC, + RIL_CDMA_T53_RELEASE_INFO_REC, + RIL_CDMA_T53_AUDIO_CONTROL_INFO_REC +} RIL_CDMA_InfoRecName; + +/* Display Info Rec as defined in C.S0005 section 3.7.5.1 + Extended Display Info Rec as defined in C.S0005 section 3.7.5.16 + Note: the Extended Display info rec contains multiple records of the + form: display_tag, display_len, and display_len occurrences of the + chari field if the display_tag is not 10000000 or 10000001. + To save space, the records are stored consecutively in a byte buffer. + The display_tag, display_len and chari fields are all 1 byte. +*/ + +typedef struct { + char alpha_len; + char alpha_buf[CDMA_ALPHA_INFO_BUFFER_LENGTH]; +} RIL_CDMA_DisplayInfoRecord; + +/* Called Party Number Info Rec as defined in C.S0005 section 3.7.5.2 + Calling Party Number Info Rec as defined in C.S0005 section 3.7.5.3 + Connected Number Info Rec as defined in C.S0005 section 3.7.5.4 +*/ + +typedef struct { + char len; + char buf[CDMA_NUMBER_INFO_BUFFER_LENGTH]; + char number_type; + char number_plan; + char pi; + char si; +} RIL_CDMA_NumberInfoRecord; + +/* Redirecting Number Information Record as defined in C.S0005 section 3.7.5.11 */ +typedef enum { + RIL_REDIRECTING_REASON_UNKNOWN = 0, + RIL_REDIRECTING_REASON_CALL_FORWARDING_BUSY = 1, + RIL_REDIRECTING_REASON_CALL_FORWARDING_NO_REPLY = 2, + RIL_REDIRECTING_REASON_CALLED_DTE_OUT_OF_ORDER = 9, + RIL_REDIRECTING_REASON_CALL_FORWARDING_BY_THE_CALLED_DTE = 10, + RIL_REDIRECTING_REASON_CALL_FORWARDING_UNCONDITIONAL = 15, + RIL_REDIRECTING_REASON_RESERVED +} RIL_CDMA_RedirectingReason; + +typedef struct { + RIL_CDMA_NumberInfoRecord redirectingNumber; + /* redirectingReason is set to RIL_REDIRECTING_REASON_UNKNOWN if not included */ + RIL_CDMA_RedirectingReason redirectingReason; +} RIL_CDMA_RedirectingNumberInfoRecord; + +/* Line Control Information Record as defined in C.S0005 section 3.7.5.15 */ +typedef struct { + char lineCtrlPolarityIncluded; + char lineCtrlToggle; + char lineCtrlReverse; + char lineCtrlPowerDenial; +} RIL_CDMA_LineControlInfoRecord; + +/* T53 CLIR Information Record */ +typedef struct { + char cause; +} RIL_CDMA_T53_CLIRInfoRecord; + +/* T53 Audio Control Information Record */ +typedef struct { + char upLink; + char downLink; +} RIL_CDMA_T53_AudioControlInfoRecord; + +typedef struct { + + RIL_CDMA_InfoRecName name; + + union { + /* Display and Extended Display Info Rec */ + RIL_CDMA_DisplayInfoRecord display; + + /* Called Party Number, Calling Party Number, Connected Number Info Rec */ + RIL_CDMA_NumberInfoRecord number; + + /* Signal Info Rec */ + RIL_CDMA_SignalInfoRecord signal; + + /* Redirecting Number Info Rec */ + RIL_CDMA_RedirectingNumberInfoRecord redir; + + /* Line Control Info Rec */ + RIL_CDMA_LineControlInfoRecord lineCtrl; + + /* T53 CLIR Info Rec */ + RIL_CDMA_T53_CLIRInfoRecord clir; + + /* T53 Audio Control Info Rec */ + RIL_CDMA_T53_AudioControlInfoRecord audioCtrl; + } rec; +} RIL_CDMA_InformationRecord; + +#define RIL_CDMA_MAX_NUMBER_OF_INFO_RECS 10 + +typedef struct { + char numberOfInfoRecs; + RIL_CDMA_InformationRecord infoRec[RIL_CDMA_MAX_NUMBER_OF_INFO_RECS]; +} RIL_CDMA_InformationRecords; + +/* See RIL_REQUEST_NV_READ_ITEM */ +typedef struct { + RIL_NV_Item itemID; +} RIL_NV_ReadItem; + +/* See RIL_REQUEST_NV_WRITE_ITEM */ +typedef struct { + RIL_NV_Item itemID; + char * value; +} RIL_NV_WriteItem; + +typedef enum { + HANDOVER_STARTED = 0, + HANDOVER_COMPLETED = 1, + HANDOVER_FAILED = 2, + HANDOVER_CANCELED = 3 +} RIL_SrvccState; + +/* hardware configuration reported to RILJ. */ +typedef enum { + RIL_HARDWARE_CONFIG_MODEM = 0, + RIL_HARDWARE_CONFIG_SIM = 1, +} RIL_HardwareConfig_Type; + +typedef enum { + RIL_HARDWARE_CONFIG_STATE_ENABLED = 0, + RIL_HARDWARE_CONFIG_STATE_STANDBY = 1, + RIL_HARDWARE_CONFIG_STATE_DISABLED = 2, +} RIL_HardwareConfig_State; + +typedef struct { + int rilModel; + uint32_t rat; /* bitset - ref. RIL_RadioTechnology. */ + int maxVoice; + int maxData; + int maxStandby; +} RIL_HardwareConfig_Modem; + +typedef struct { + char modemUuid[MAX_UUID_LENGTH]; +} RIL_HardwareConfig_Sim; + +typedef struct { + RIL_HardwareConfig_Type type; + char uuid[MAX_UUID_LENGTH]; + RIL_HardwareConfig_State state; + union { + RIL_HardwareConfig_Modem modem; + RIL_HardwareConfig_Sim sim; + } cfg; +} RIL_HardwareConfig; + +typedef enum { + SS_CFU, + SS_CF_BUSY, + SS_CF_NO_REPLY, + SS_CF_NOT_REACHABLE, + SS_CF_ALL, + SS_CF_ALL_CONDITIONAL, + SS_CLIP, + SS_CLIR, + SS_COLP, + SS_COLR, + SS_WAIT, + SS_BAOC, + SS_BAOIC, + SS_BAOIC_EXC_HOME, + SS_BAIC, + SS_BAIC_ROAMING, + SS_ALL_BARRING, + SS_OUTGOING_BARRING, + SS_INCOMING_BARRING +} RIL_SsServiceType; + +typedef enum { + SS_ACTIVATION, + SS_DEACTIVATION, + SS_INTERROGATION, + SS_REGISTRATION, + SS_ERASURE +} RIL_SsRequestType; + +typedef enum { + SS_ALL_TELE_AND_BEARER_SERVICES, + SS_ALL_TELESEVICES, + SS_TELEPHONY, + SS_ALL_DATA_TELESERVICES, + SS_SMS_SERVICES, + SS_ALL_TELESERVICES_EXCEPT_SMS +} RIL_SsTeleserviceType; + +#define SS_INFO_MAX 4 +#define NUM_SERVICE_CLASSES 7 + +typedef struct { + int numValidIndexes; /* This gives the number of valid values in cfInfo. + For example if voice is forwarded to one number and data + is forwarded to a different one then numValidIndexes will be + 2 indicating total number of valid values in cfInfo. + Similarly if all the services are forwarded to the same + number then the value of numValidIndexes will be 1. */ + + RIL_CallForwardInfo cfInfo[NUM_SERVICE_CLASSES]; /* This is the response data + for SS request to query call + forward status. see + RIL_REQUEST_QUERY_CALL_FORWARD_STATUS */ +} RIL_CfData; + +typedef struct { + RIL_SsServiceType serviceType; + RIL_SsRequestType requestType; + RIL_SsTeleserviceType teleserviceType; + int serviceClass; + RIL_Errno result; + + union { + int ssInfo[SS_INFO_MAX]; /* This is the response data for most of the SS GET/SET + RIL requests. E.g. RIL_REQUSET_GET_CLIR returns + two ints, so first two values of ssInfo[] will be + used for response if serviceType is SS_CLIR and + requestType is SS_INTERROGATION */ + + RIL_CfData cfData; + }; +} RIL_StkCcUnsolSsResponse; + +/** + * Data connection power state + */ +typedef enum { + RIL_DC_POWER_STATE_LOW = 1, // Low power state + RIL_DC_POWER_STATE_MEDIUM = 2, // Medium power state + RIL_DC_POWER_STATE_HIGH = 3, // High power state + RIL_DC_POWER_STATE_UNKNOWN = INT32_MAX // Unknown state +} RIL_DcPowerStates; + +/** + * Data connection real time info + */ +typedef struct { + uint64_t time; // Time in nanos as returned by ril_nano_time + RIL_DcPowerStates powerState; // Current power state +} RIL_DcRtInfo; + +/** + * Data profile to modem + */ +typedef struct { + /* id of the data profile */ + int profileId; + /* the APN to connect to */ + char* apn; + /** one of the PDP_type values in TS 27.007 section 10.1.1. + * For example, "IP", "IPV6", "IPV4V6", or "PPP". + */ + char* protocol; + /** authentication protocol used for this PDP context + * (None: 0, PAP: 1, CHAP: 2, PAP&CHAP: 3) + */ + int authType; + /* the username for APN, or NULL */ + char* user; + /* the password for APN, or NULL */ + char* password; + /* the profile type, TYPE_COMMON-0, TYPE_3GPP-1, TYPE_3GPP2-2 */ + int type; + /* the period in seconds to limit the maximum connections */ + int maxConnsTime; + /* the maximum connections during maxConnsTime */ + int maxConns; + /** the required wait time in seconds after a successful UE initiated + * disconnect of a given PDN connection before the device can send + * a new PDN connection request for that given PDN + */ + int waitTime; + /* true to enable the profile, 0 to disable, 1 to enable */ + int enabled; +} RIL_DataProfileInfo; + +typedef struct { + /* id of the data profile */ + int profileId; + /* the APN to connect to */ + char* apn; + /** one of the PDP_type values in TS 27.007 section 10.1.1. + * For example, "IP", "IPV6", "IPV4V6", or "PPP". + */ + char* protocol; + /** one of the PDP_type values in TS 27.007 section 10.1.1 used on roaming network. + * For example, "IP", "IPV6", "IPV4V6", or "PPP". + */ + char *roamingProtocol; + /** authentication protocol used for this PDP context + * (None: 0, PAP: 1, CHAP: 2, PAP&CHAP: 3) + */ + int authType; + /* the username for APN, or NULL */ + char* user; + /* the password for APN, or NULL */ + char* password; + /* the profile type, TYPE_COMMON-0, TYPE_3GPP-1, TYPE_3GPP2-2 */ + int type; + /* the period in seconds to limit the maximum connections */ + int maxConnsTime; + /* the maximum connections during maxConnsTime */ + int maxConns; + /** the required wait time in seconds after a successful UE initiated + * disconnect of a given PDN connection before the device can send + * a new PDN connection request for that given PDN + */ + int waitTime; + /* true to enable the profile, 0 to disable, 1 to enable */ + int enabled; + /* supported APN types bitmask. See RIL_ApnTypes for the value of each bit. */ + int supportedTypesBitmask; + /** the bearer bitmask. See RIL_RadioAccessFamily for the value of each bit. */ + int bearerBitmask; + /** maximum transmission unit (MTU) size in bytes */ + int mtu; + /** the MVNO type: possible values are "imsi", "gid", "spn" */ + char *mvnoType; + /** MVNO match data. Can be anything defined by the carrier. For example, + * SPN like: "A MOBILE", "BEN NL", etc... + * IMSI like: "302720x94", "2060188", etc... + * GID like: "4E", "33", etc... + */ + char *mvnoMatchData; +} RIL_DataProfileInfo_v15; + +/* Tx Power Levels */ +#define RIL_NUM_TX_POWER_LEVELS 5 + +/** + * Aggregate modem activity information + */ +typedef struct { + + /* total time (in ms) when modem is in a low power or + * sleep state + */ + uint32_t sleep_mode_time_ms; + + /* total time (in ms) when modem is awake but neither + * the transmitter nor receiver are active/awake */ + uint32_t idle_mode_time_ms; + + /* total time (in ms) during which the transmitter is active/awake, + * subdivided by manufacturer-defined device-specific + * contiguous increasing ranges of transmit power between + * 0 and the transmitter's maximum transmit power. + */ + uint32_t tx_mode_time_ms[RIL_NUM_TX_POWER_LEVELS]; + + /* total time (in ms) for which receiver is active/awake and + * the transmitter is inactive */ + uint32_t rx_mode_time_ms; +} RIL_ActivityStatsInfo; + +typedef enum { + RIL_APN_TYPE_UNKNOWN = 0x0, // Unknown + RIL_APN_TYPE_DEFAULT = 0x1, // APN type for default data traffic + RIL_APN_TYPE_MMS = 0x2, // APN type for MMS traffic + RIL_APN_TYPE_SUPL = 0x4, // APN type for SUPL assisted GPS + RIL_APN_TYPE_DUN = 0x8, // APN type for DUN traffic + RIL_APN_TYPE_HIPRI = 0x10, // APN type for HiPri traffic + RIL_APN_TYPE_FOTA = 0x20, // APN type for FOTA + RIL_APN_TYPE_IMS = 0x40, // APN type for IMS + RIL_APN_TYPE_CBS = 0x80, // APN type for CBS + RIL_APN_TYPE_IA = 0x100, // APN type for IA Initial Attach APN + RIL_APN_TYPE_EMERGENCY = 0x200, // APN type for Emergency PDN. This is not an IA apn, + // but is used for access to carrier services in an + // emergency call situation. + RIL_APN_TYPE_ALL = 0xFFFFFFFF // All APN types +} RIL_ApnTypes; + +typedef enum { + RIL_DST_POWER_SAVE_MODE, // Device power save mode (provided by PowerManager) + // True indicates the device is in power save mode. + RIL_DST_CHARGING_STATE, // Device charging state (provided by BatteryManager) + // True indicates the device is charging. + RIL_DST_LOW_DATA_EXPECTED // Low data expected mode. True indicates low data traffic + // is expected, for example, when the device is idle + // (e.g. not doing tethering in the background). Note + // this doesn't mean no data is expected. +} RIL_DeviceStateType; + +typedef enum { + RIL_UR_SIGNAL_STRENGTH = 0x01, // When this bit is set, modem should always send the + // signal strength update through + // RIL_UNSOL_SIGNAL_STRENGTH, otherwise suppress it. + RIL_UR_FULL_NETWORK_STATE = 0x02, // When this bit is set, modem should always send + // RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED + // when any field in + // RIL_REQUEST_VOICE_REGISTRATION_STATE or + // RIL_REQUEST_DATA_REGISTRATION_STATE changes. When + // this bit is not set, modem should suppress + // RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED + // only when insignificant fields change + // (e.g. cell info). + // Modem should continue sending + // RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED + // when significant fields are updated even when this + // bit is not set. The following fields are + // considered significant, registration state and + // radio technology. + RIL_UR_DATA_CALL_DORMANCY_CHANGED = 0x04 // When this bit is set, modem should send the data + // call list changed unsolicited response + // RIL_UNSOL_DATA_CALL_LIST_CHANGED whenever any + // field in RIL_Data_Call_Response changes. + // Otherwise modem should suppress the unsolicited + // response when the only changed field is 'active' + // (for data dormancy). For all other fields change, + // modem should continue sending + // RIL_UNSOL_DATA_CALL_LIST_CHANGED regardless this + // bit is set or not. +} RIL_UnsolicitedResponseFilter; + +typedef struct { + char * aidPtr; /* AID value, See ETSI 102.221 and 101.220*/ + int p2; /* P2 parameter (described in ISO 7816-4) + P2Constants:NO_P2 if to be ignored */ +} RIL_OpenChannelParams; + +typedef enum { + RIL_ONE_SHOT = 0x01, // Performs the scan only once + RIL_PERIODIC = 0x02 // Performs the scan periodically until cancelled +} RIL_ScanType; + +typedef enum { + GERAN = 0x01, // GSM EDGE Radio Access Network + UTRAN = 0x02, // Universal Terrestrial Radio Access Network + EUTRAN = 0x03, // Evolved Universal Terrestrial Radio Access Network +} RIL_RadioAccessNetworks; + +typedef enum { + GERAN_BAND_T380 = 1, + GERAN_BAND_T410 = 2, + GERAN_BAND_450 = 3, + GERAN_BAND_480 = 4, + GERAN_BAND_710 = 5, + GERAN_BAND_750 = 6, + GERAN_BAND_T810 = 7, + GERAN_BAND_850 = 8, + GERAN_BAND_P900 = 9, + GERAN_BAND_E900 = 10, + GERAN_BAND_R900 = 11, + GERAN_BAND_DCS1800 = 12, + GERAN_BAND_PCS1900 = 13, + GERAN_BAND_ER900 = 14, +} RIL_GeranBands; + +typedef enum { + UTRAN_BAND_1 = 1, + UTRAN_BAND_2 = 2, + UTRAN_BAND_3 = 3, + UTRAN_BAND_4 = 4, + UTRAN_BAND_5 = 5, + UTRAN_BAND_6 = 6, + UTRAN_BAND_7 = 7, + UTRAN_BAND_8 = 8, + UTRAN_BAND_9 = 9, + UTRAN_BAND_10 = 10, + UTRAN_BAND_11 = 11, + UTRAN_BAND_12 = 12, + UTRAN_BAND_13 = 13, + UTRAN_BAND_14 = 14, + UTRAN_BAND_19 = 19, + UTRAN_BAND_20 = 20, + UTRAN_BAND_21 = 21, + UTRAN_BAND_22 = 22, + UTRAN_BAND_25 = 25, + UTRAN_BAND_26 = 26, +} RIL_UtranBands; + +typedef enum { + EUTRAN_BAND_1 = 1, + EUTRAN_BAND_2 = 2, + EUTRAN_BAND_3 = 3, + EUTRAN_BAND_4 = 4, + EUTRAN_BAND_5 = 5, + EUTRAN_BAND_6 = 6, + EUTRAN_BAND_7 = 7, + EUTRAN_BAND_8 = 8, + EUTRAN_BAND_9 = 9, + EUTRAN_BAND_10 = 10, + EUTRAN_BAND_11 = 11, + EUTRAN_BAND_12 = 12, + EUTRAN_BAND_13 = 13, + EUTRAN_BAND_14 = 14, + EUTRAN_BAND_17 = 17, + EUTRAN_BAND_18 = 18, + EUTRAN_BAND_19 = 19, + EUTRAN_BAND_20 = 20, + EUTRAN_BAND_21 = 21, + EUTRAN_BAND_22 = 22, + EUTRAN_BAND_23 = 23, + EUTRAN_BAND_24 = 24, + EUTRAN_BAND_25 = 25, + EUTRAN_BAND_26 = 26, + EUTRAN_BAND_27 = 27, + EUTRAN_BAND_28 = 28, + EUTRAN_BAND_30 = 30, + EUTRAN_BAND_31 = 31, + EUTRAN_BAND_33 = 33, + EUTRAN_BAND_34 = 34, + EUTRAN_BAND_35 = 35, + EUTRAN_BAND_36 = 36, + EUTRAN_BAND_37 = 37, + EUTRAN_BAND_38 = 38, + EUTRAN_BAND_39 = 39, + EUTRAN_BAND_40 = 40, + EUTRAN_BAND_41 = 41, + EUTRAN_BAND_42 = 42, + EUTRAN_BAND_43 = 43, + EUTRAN_BAND_44 = 44, + EUTRAN_BAND_45 = 45, + EUTRAN_BAND_46 = 46, + EUTRAN_BAND_47 = 47, + EUTRAN_BAND_48 = 48, + EUTRAN_BAND_65 = 65, + EUTRAN_BAND_66 = 66, + EUTRAN_BAND_68 = 68, + EUTRAN_BAND_70 = 70, +} RIL_EutranBands; + +typedef struct { + RIL_RadioAccessNetworks radio_access_network; // The type of network to scan. + uint32_t bands_length; // Length of bands + union { + RIL_GeranBands geran_bands[MAX_BANDS]; + RIL_UtranBands utran_bands[MAX_BANDS]; + RIL_EutranBands eutran_bands[MAX_BANDS]; + } bands; + uint32_t channels_length; // Length of channels + uint32_t channels[MAX_CHANNELS]; // Frequency channels to scan +} RIL_RadioAccessSpecifier; + +typedef struct { + RIL_ScanType type; // Type of the scan + int32_t interval; // Time interval in seconds + // between periodic scans, only + // valid when type=RIL_PERIODIC + uint32_t specifiers_length; // Length of specifiers + RIL_RadioAccessSpecifier specifiers[MAX_RADIO_ACCESS_NETWORKS]; // Radio access networks + // with bands/channels. +} RIL_NetworkScanRequest; + +typedef enum { + PARTIAL = 0x01, // The result contains a part of the scan results + COMPLETE = 0x02, // The result contains the last part of the scan results +} RIL_ScanStatus; + +typedef struct { + RIL_ScanStatus status; // The status of the scan + uint32_t network_infos_length; // Total length of RIL_CellInfo + RIL_CellInfo_v12* network_infos; // List of network information + RIL_Errno error; +} RIL_NetworkScanResult; + +/** + * RIL_REQUEST_GET_SIM_STATUS + * + * Requests status of the SIM interface and the SIM card + * + * "data" is NULL + * + * "response" is const RIL_CardStatus_v6 * + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_GET_SIM_STATUS 1 + +/** + * RIL_REQUEST_ENTER_SIM_PIN + * + * Supplies SIM PIN. Only called if RIL_CardStatus has RIL_APPSTATE_PIN state + * + * "data" is const char ** + * ((const char **)data)[0] is PIN value + * ((const char **)data)[1] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * + * "response" is int * + * ((int *)response)[0] is the number of retries remaining, or -1 if unknown + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * PASSWORD_INCORRECT + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_ARGUMENTS + * INVALID_SIM_STATE + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_ENTER_SIM_PIN 2 + +/** + * RIL_REQUEST_ENTER_SIM_PUK + * + * Supplies SIM PUK and new PIN. + * + * "data" is const char ** + * ((const char **)data)[0] is PUK value + * ((const char **)data)[1] is new PIN value + * ((const char **)data)[2] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * + * "response" is int * + * ((int *)response)[0] is the number of retries remaining, or -1 if unknown + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * PASSWORD_INCORRECT + * (PUK is invalid) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_ARGUMENTS + * INVALID_SIM_STATE + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_ENTER_SIM_PUK 3 + +/** + * RIL_REQUEST_ENTER_SIM_PIN2 + * + * Supplies SIM PIN2. Only called following operation where SIM_PIN2 was + * returned as a a failure from a previous operation. + * + * "data" is const char ** + * ((const char **)data)[0] is PIN2 value + * ((const char **)data)[1] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * + * "response" is int * + * ((int *)response)[0] is the number of retries remaining, or -1 if unknown + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * PASSWORD_INCORRECT + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_ARGUMENTS + * INVALID_SIM_STATE + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_ENTER_SIM_PIN2 4 + +/** + * RIL_REQUEST_ENTER_SIM_PUK2 + * + * Supplies SIM PUK2 and new PIN2. + * + * "data" is const char ** + * ((const char **)data)[0] is PUK2 value + * ((const char **)data)[1] is new PIN2 value + * ((const char **)data)[2] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * + * "response" is int * + * ((int *)response)[0] is the number of retries remaining, or -1 if unknown + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * PASSWORD_INCORRECT + * (PUK2 is invalid) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_ARGUMENTS + * INVALID_SIM_STATE + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_ENTER_SIM_PUK2 5 + +/** + * RIL_REQUEST_CHANGE_SIM_PIN + * + * Supplies old SIM PIN and new PIN. + * + * "data" is const char ** + * ((const char **)data)[0] is old PIN value + * ((const char **)data)[1] is new PIN value + * ((const char **)data)[2] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * + * "response" is int * + * ((int *)response)[0] is the number of retries remaining, or -1 if unknown + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * PASSWORD_INCORRECT + * (old PIN is invalid) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_ARGUMENTS + * INVALID_SIM_STATE + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_CHANGE_SIM_PIN 6 + + +/** + * RIL_REQUEST_CHANGE_SIM_PIN2 + * + * Supplies old SIM PIN2 and new PIN2. + * + * "data" is const char ** + * ((const char **)data)[0] is old PIN2 value + * ((const char **)data)[1] is new PIN2 value + * ((const char **)data)[2] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * + * "response" is int * + * ((int *)response)[0] is the number of retries remaining, or -1 if unknown + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * PASSWORD_INCORRECT + * (old PIN2 is invalid) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_ARGUMENTS + * INVALID_SIM_STATE + * REQUEST_NOT_SUPPORTED + * + */ + +#define RIL_REQUEST_CHANGE_SIM_PIN2 7 + +/** + * RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION + * + * Requests that network personlization be deactivated + * + * "data" is const char ** + * ((const char **)(data))[0]] is network depersonlization code + * + * "response" is int * + * ((int *)response)[0] is the number of retries remaining, or -1 if unknown + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * PASSWORD_INCORRECT + * SIM_ABSENT + * (code is invalid) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION 8 + +/** + * RIL_REQUEST_GET_CURRENT_CALLS + * + * Requests current call list + * + * "data" is NULL + * + * "response" must be a "const RIL_Call **" + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * (request will be made again in a few hundred msec) + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_GET_CURRENT_CALLS 9 + + +/** + * RIL_REQUEST_DIAL + * + * Initiate voice call + * + * "data" is const RIL_Dial * + * "response" is NULL + * + * This method is never used for supplementary service codes + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * DIAL_MODIFIED_TO_USSD + * DIAL_MODIFIED_TO_SS + * DIAL_MODIFIED_TO_DIAL + * INVALID_ARGUMENTS + * NO_MEMORY + * INVALID_STATE + * NO_RESOURCES + * INTERNAL_ERR + * FDN_CHECK_FAILURE + * MODEM_ERR + * NO_SUBSCRIPTION + * NO_NETWORK_FOUND + * INVALID_CALL_ID + * DEVICE_IN_USE + * OPERATION_NOT_ALLOWED + * ABORTED + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_DIAL 10 + +/** + * RIL_REQUEST_GET_IMSI + * + * Get the SIM IMSI + * + * Only valid when radio state is "RADIO_STATE_ON" + * + * "data" is const char ** + * ((const char **)data)[0] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * "response" is a const char * containing the IMSI + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_SIM_STATE + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_GET_IMSI 11 + +/** + * RIL_REQUEST_HANGUP + * + * Hang up a specific line (like AT+CHLD=1x) + * + * After this HANGUP request returns, RIL should show the connection is NOT + * active anymore in next RIL_REQUEST_GET_CURRENT_CALLS query. + * + * "data" is an int * + * (int *)data)[0] contains Connection index (value of 'x' in CHLD above) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_ARGUMENTS + * NO_MEMORY + * INVALID_STATE + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * INVALID_CALL_ID + * INVALID_ARGUMENTS + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_HANGUP 12 + +/** + * RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND + * + * Hang up waiting or held (like AT+CHLD=0) + * + * After this HANGUP request returns, RIL should show the connection is NOT + * active anymore in next RIL_REQUEST_GET_CURRENT_CALLS query. + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_STATE + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * INVALID_CALL_ID + * NO_RESOURCES + * OPERATION_NOT_ALLOWED + * INVALID_ARGUMENTS + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND 13 + +/** + * RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND + * + * Hang up waiting or held (like AT+CHLD=1) + * + * After this HANGUP request returns, RIL should show the connection is NOT + * active anymore in next RIL_REQUEST_GET_CURRENT_CALLS query. + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_STATE + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * OPERATION_NOT_ALLOWED + * INVALID_ARGUMENTS + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND 14 + +/** + * RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE + * + * Switch waiting or holding call and active call (like AT+CHLD=2) + * + * State transitions should be is follows: + * + * If call 1 is waiting and call 2 is active, then if this re + * + * BEFORE AFTER + * Call 1 Call 2 Call 1 Call 2 + * ACTIVE HOLDING HOLDING ACTIVE + * ACTIVE WAITING HOLDING ACTIVE + * HOLDING WAITING HOLDING ACTIVE + * ACTIVE IDLE HOLDING IDLE + * IDLE IDLE IDLE IDLE + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_STATE + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * INVALID_STATE + * INVALID_ARGUMENTS + * INVALID_CALL_ID + * OPERATION_NOT_ALLOWED + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE 15 +#define RIL_REQUEST_SWITCH_HOLDING_AND_ACTIVE 15 + +/** + * RIL_REQUEST_CONFERENCE + * + * Conference holding and active (like AT+CHLD=3) + + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * INVALID_STATE + * INVALID_CALL_ID + * INVALID_ARGUMENTS + * OPERATION_NOT_ALLOWED + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_CONFERENCE 16 + +/** + * RIL_REQUEST_UDUB + * + * Send UDUB (user determined used busy) to ringing or + * waiting call answer)(RIL_BasicRequest r); + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_STATE + * NO_RESOURCES + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * OPERATION_NOT_ALLOWED + * INVALID_ARGUMENTS + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_UDUB 17 + +/** + * RIL_REQUEST_LAST_CALL_FAIL_CAUSE + * + * Requests the failure cause code for the most recently terminated call + * + * "data" is NULL + * "response" is a const RIL_LastCallFailCauseInfo * + * RIL_LastCallFailCauseInfo contains LastCallFailCause and vendor cause. + * The vendor cause code must be used for debugging purpose only. + * The implementation must return one of the values of LastCallFailCause + * as mentioned below. + * + * GSM failure reasons codes for the cause codes defined in TS 24.008 Annex H + * where possible. + * CDMA failure reasons codes for the possible call failure scenarios + * described in the "CDMA IS-2000 Release A (C.S0005-A v6.0)" standard. + * Any of the following reason codes if the call is failed or dropped due to reason + * mentioned with in the braces. + * + * CALL_FAIL_RADIO_OFF (Radio is OFF) + * CALL_FAIL_OUT_OF_SERVICE (No cell coverage) + * CALL_FAIL_NO_VALID_SIM (No valid SIM) + * CALL_FAIL_RADIO_INTERNAL_ERROR (Modem hit unexpected error scenario) + * CALL_FAIL_NETWORK_RESP_TIMEOUT (No response from network) + * CALL_FAIL_NETWORK_REJECT (Explicit network reject) + * CALL_FAIL_RADIO_ACCESS_FAILURE (RRC connection failure. Eg.RACH) + * CALL_FAIL_RADIO_LINK_FAILURE (Radio Link Failure) + * CALL_FAIL_RADIO_LINK_LOST (Radio link lost due to poor coverage) + * CALL_FAIL_RADIO_UPLINK_FAILURE (Radio uplink failure) + * CALL_FAIL_RADIO_SETUP_FAILURE (RRC connection setup failure) + * CALL_FAIL_RADIO_RELEASE_NORMAL (RRC connection release, normal) + * CALL_FAIL_RADIO_RELEASE_ABNORMAL (RRC connection release, abnormal) + * CALL_FAIL_ACCESS_CLASS_BLOCKED (Access class barring) + * CALL_FAIL_NETWORK_DETACH (Explicit network detach) + * + * OEM causes (CALL_FAIL_OEM_CAUSE_XX) must be used for debug purpose only + * + * If the implementation does not have access to the exact cause codes, + * then it should return one of the values listed in RIL_LastCallFailCause, + * as the UI layer needs to distinguish these cases for tone generation or + * error notification. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE + */ +#define RIL_REQUEST_LAST_CALL_FAIL_CAUSE 18 + +/** + * RIL_REQUEST_SIGNAL_STRENGTH + * + * Requests current signal strength and associated information + * + * Must succeed if radio is on. + * + * "data" is NULL + * + * "response" is a const RIL_SignalStrength * + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SIGNAL_STRENGTH 19 + +/** + * RIL_REQUEST_VOICE_REGISTRATION_STATE + * + * Request current registration state + * + * "data" is NULL + * "response" is a const RIL_VoiceRegistrationStateResponse * + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_VOICE_REGISTRATION_STATE 20 + +/** + * RIL_REQUEST_DATA_REGISTRATION_STATE + * + * Request current DATA registration state + * + * "data" is NULL + * "response" is a const RIL_DataRegistrationStateResponse * + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_DATA_REGISTRATION_STATE 21 + +/** + * RIL_REQUEST_OPERATOR + * + * Request current operator ONS or EONS + * + * "data" is NULL + * "response" is a "const char **" + * ((const char **)response)[0] is long alpha ONS or EONS + * or NULL if unregistered + * + * ((const char **)response)[1] is short alpha ONS or EONS + * or NULL if unregistered + * ((const char **)response)[2] is 5 or 6 digit numeric code (MCC + MNC) + * or NULL if unregistered + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_OPERATOR 22 + +/** + * RIL_REQUEST_RADIO_POWER + * + * Toggle radio on and off (for "airplane" mode) + * If the radio is is turned off/on the radio modem subsystem + * is expected return to an initialized state. For instance, + * any voice and data calls will be terminated and all associated + * lists emptied. + * + * "data" is int * + * ((int *)data)[0] is > 0 for "Radio On" + * ((int *)data)[0] is == 0 for "Radio Off" + * + * "response" is NULL + * + * Turn radio on if "on" > 0 + * Turn radio off if "on" == 0 + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * INVALID_STATE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * DEVICE_IN_USE + * OPERATION_NOT_ALLOWED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_RADIO_POWER 23 + +/** + * RIL_REQUEST_DTMF + * + * Send a DTMF tone + * + * If the implementation is currently playing a tone requested via + * RIL_REQUEST_DTMF_START, that tone should be cancelled and the new tone + * should be played instead + * + * "data" is a char * containing a single character with one of 12 values: 0-9,*,# + * "response" is NULL + * + * FIXME should this block/mute microphone? + * How does this interact with local DTMF feedback? + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * NO_RESOURCES + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_REQUEST_DTMF_STOP, RIL_REQUEST_DTMF_START + * + */ +#define RIL_REQUEST_DTMF 24 + +/** + * RIL_REQUEST_SEND_SMS + * + * Send an SMS message + * + * "data" is const char ** + * ((const char **)data)[0] is SMSC address in GSM BCD format prefixed + * by a length byte (as expected by TS 27.005) or NULL for default SMSC + * ((const char **)data)[1] is SMS in PDU format as an ASCII hex string + * less the SMSC address + * TP-Layer-Length is be "strlen(((const char **)data)[1])/2" + * + * "response" is a const RIL_SMS_Response * + * + * Based on the return error, caller decides to resend if sending sms + * fails. SMS_SEND_FAIL_RETRY means retry (i.e. error cause is 332) + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SMS_SEND_FAIL_RETRY + * FDN_CHECK_FAILURE + * NETWORK_REJECT + * INVALID_STATE + * INVALID_ARGUMENTS + * NO_MEMORY + * REQUEST_RATE_LIMITED + * INVALID_SMS_FORMAT + * SYSTEM_ERR + * ENCODING_ERR + * INVALID_SMSC_ADDRESS + * MODEM_ERR + * NETWORK_ERR + * OPERATION_NOT_ALLOWED + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * MODE_NOT_SUPPORTED + * SIM_ABSENT + * + * FIXME how do we specify TP-Message-Reference if we need to resend? + */ +#define RIL_REQUEST_SEND_SMS 25 + + +/** + * RIL_REQUEST_SEND_SMS_EXPECT_MORE + * + * Send an SMS message. Identical to RIL_REQUEST_SEND_SMS, + * except that more messages are expected to be sent soon. If possible, + * keep SMS relay protocol link open (eg TS 27.005 AT+CMMS command) + * + * "data" is const char ** + * ((const char **)data)[0] is SMSC address in GSM BCD format prefixed + * by a length byte (as expected by TS 27.005) or NULL for default SMSC + * ((const char **)data)[1] is SMS in PDU format as an ASCII hex string + * less the SMSC address + * TP-Layer-Length is be "strlen(((const char **)data)[1])/2" + * + * "response" is a const RIL_SMS_Response * + * + * Based on the return error, caller decides to resend if sending sms + * fails. SMS_SEND_FAIL_RETRY means retry (i.e. error cause is 332) + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SMS_SEND_FAIL_RETRY + * NETWORK_REJECT + * INVALID_STATE + * INVALID_ARGUMENTS + * NO_MEMORY + * INVALID_SMS_FORMAT + * SYSTEM_ERR + * REQUEST_RATE_LIMITED + * FDN_CHECK_FAILURE + * MODEM_ERR + * NETWORK_ERR + * ENCODING_ERR + * INVALID_SMSC_ADDRESS + * OPERATION_NOT_ALLOWED + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * MODE_NOT_SUPPORTED + * SIM_ABSENT + * + */ +#define RIL_REQUEST_SEND_SMS_EXPECT_MORE 26 + + +/** + * RIL_REQUEST_SETUP_DATA_CALL + * + * Setup a packet data connection. If RIL_Data_Call_Response_v6.status + * return success it is added to the list of data calls and a + * RIL_UNSOL_DATA_CALL_LIST_CHANGED is sent. The call remains in the + * list until RIL_REQUEST_DEACTIVATE_DATA_CALL is issued or the + * radio is powered off/on. This list is returned by RIL_REQUEST_DATA_CALL_LIST + * and RIL_UNSOL_DATA_CALL_LIST_CHANGED. + * + * The RIL is expected to: + * - Create one data call context. + * - Create and configure a dedicated interface for the context + * - The interface must be point to point. + * - The interface is configured with one or more addresses and + * is capable of sending and receiving packets. The prefix length + * of the addresses must be /32 for IPv4 and /128 for IPv6. + * - Must NOT change the linux routing table. + * - Support up to RIL_REQUEST_DATA_REGISTRATION_STATE response[5] + * number of simultaneous data call contexts. + * + * "data" is a const char ** + * ((const char **)data)[0] Radio technology to use: 0-CDMA, 1-GSM/UMTS, 2... + * for values above 2 this is RIL_RadioTechnology + 2. + * ((const char **)data)[1] is a RIL_DataProfile (support is optional) + * ((const char **)data)[2] is the APN to connect to if radio technology is GSM/UMTS. This APN will + * override the one in the profile. NULL indicates no APN overrride. + * ((const char **)data)[3] is the username for APN, or NULL + * ((const char **)data)[4] is the password for APN, or NULL + * ((const char **)data)[5] is the PAP / CHAP auth type. Values: + * 0 => PAP and CHAP is never performed. + * 1 => PAP may be performed; CHAP is never performed. + * 2 => CHAP may be performed; PAP is never performed. + * 3 => PAP / CHAP may be performed - baseband dependent. + * ((const char **)data)[6] is the non-roaming/home connection type to request. Must be one of the + * PDP_type values in TS 27.007 section 10.1.1. + * For example, "IP", "IPV6", "IPV4V6", or "PPP". + * ((const char **)data)[7] is the roaming connection type to request. Must be one of the + * PDP_type values in TS 27.007 section 10.1.1. + * For example, "IP", "IPV6", "IPV4V6", or "PPP". + * ((const char **)data)[8] is the bitmask of APN type in decimal string format. The + * bitmask will encapsulate the following values: + * ia,mms,agps,supl,hipri,fota,dun,ims,default. + * ((const char **)data)[9] is the bearer bitmask in decimal string format. Each bit is a + * RIL_RadioAccessFamily. "0" or NULL indicates all RATs. + * ((const char **)data)[10] is the boolean in string format indicating the APN setting was + * sent to the modem through RIL_REQUEST_SET_DATA_PROFILE earlier. + * ((const char **)data)[11] is the mtu size in bytes of the mobile interface to which + * the apn is connected. + * ((const char **)data)[12] is the MVNO type: + * possible values are "imsi", "gid", "spn". + * ((const char **)data)[13] is MVNO match data in string. Can be anything defined by the carrier. + * For example, + * SPN like: "A MOBILE", "BEN NL", etc... + * IMSI like: "302720x94", "2060188", etc... + * GID like: "4E", "33", etc... + * ((const char **)data)[14] is the boolean string indicating data roaming is allowed or not. "1" + * indicates data roaming is enabled by the user, "0" indicates disabled. + * + * "response" is a RIL_Data_Call_Response_v11 + * + * FIXME may need way to configure QoS settings + * + * Valid errors: + * SUCCESS should be returned on both success and failure of setup with + * the RIL_Data_Call_Response_v6.status containing the actual status. + * For all other errors the RIL_Data_Call_Resonse_v6 is ignored. + * + * Other errors could include: + * RADIO_NOT_AVAILABLE, OP_NOT_ALLOWED_BEFORE_REG_TO_NW, + * OP_NOT_ALLOWED_DURING_VOICE_CALL, REQUEST_NOT_SUPPORTED, + * INVALID_ARGUMENTS, INTERNAL_ERR, NO_MEMORY, NO_RESOURCES, + * CANCELLED and SIM_ABSENT + * + * See also: RIL_REQUEST_DEACTIVATE_DATA_CALL + */ +#define RIL_REQUEST_SETUP_DATA_CALL 27 + + +/** + * RIL_REQUEST_SIM_IO + * + * Request SIM I/O operation. + * This is similar to the TS 27.007 "restricted SIM" operation + * where it assumes all of the EF selection will be done by the + * callee. + * + * "data" is a const RIL_SIM_IO_v6 * + * Please note that RIL_SIM_IO has a "PIN2" field which may be NULL, + * or may specify a PIN2 for operations that require a PIN2 (eg + * updating FDN records) + * + * "response" is a const RIL_SIM_IO_Response * + * + * Arguments and responses that are unused for certain + * values of "command" should be ignored or set to NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SIM_PIN2 + * SIM_PUK2 + * INVALID_SIM_STATE + * SIM_ERR + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SIM_IO 28 + +/** + * RIL_REQUEST_SEND_USSD + * + * Send a USSD message + * + * If a USSD session already exists, the message should be sent in the + * context of that session. Otherwise, a new session should be created. + * + * The network reply should be reported via RIL_UNSOL_ON_USSD + * + * Only one USSD session may exist at a time, and the session is assumed + * to exist until: + * a) The android system invokes RIL_REQUEST_CANCEL_USSD + * b) The implementation sends a RIL_UNSOL_ON_USSD with a type code + * of "0" (USSD-Notify/no further action) or "2" (session terminated) + * + * "data" is a const char * containing the USSD request in UTF-8 format + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * FDN_CHECK_FAILURE + * USSD_MODIFIED_TO_DIAL + * USSD_MODIFIED_TO_SS + * USSD_MODIFIED_TO_USSD + * SIM_BUSY + * OPERATION_NOT_ALLOWED + * INVALID_ARGUMENTS + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * ABORTED + * SYSTEM_ERR + * INVALID_STATE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_REQUEST_CANCEL_USSD, RIL_UNSOL_ON_USSD + */ + +#define RIL_REQUEST_SEND_USSD 29 + +/** + * RIL_REQUEST_CANCEL_USSD + * + * Cancel the current USSD session if one exists + * + * "data" is null + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SIM_BUSY + * OPERATION_NOT_ALLOWED + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * INVALID_STATE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_CANCEL_USSD 30 + +/** + * RIL_REQUEST_GET_CLIR + * + * Gets current CLIR status + * "data" is NULL + * "response" is int * + * ((int *)data)[0] is "n" parameter from TS 27.007 7.7 + * ((int *)data)[1] is "m" parameter from TS 27.007 7.7 + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * FDN_CHECK_FAILURE + * SYSTEM_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_GET_CLIR 31 + +/** + * RIL_REQUEST_SET_CLIR + * + * "data" is int * + * ((int *)data)[0] is "n" parameter from TS 27.007 7.7 + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * INVALID_ARGUMENTS + * SYSTEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SET_CLIR 32 + +/** + * RIL_REQUEST_QUERY_CALL_FORWARD_STATUS + * + * "data" is const RIL_CallForwardInfo * + * + * "response" is const RIL_CallForwardInfo ** + * "response" points to an array of RIL_CallForwardInfo *'s, one for + * each distinct registered phone number. + * + * For example, if data is forwarded to +18005551212 and voice is forwarded + * to +18005559999, then two separate RIL_CallForwardInfo's should be returned + * + * If, however, both data and voice are forwarded to +18005551212, then + * a single RIL_CallForwardInfo can be returned with the service class + * set to "data + voice = 3") + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * FDN_CHECK_FAILURE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_QUERY_CALL_FORWARD_STATUS 33 + + +/** + * RIL_REQUEST_SET_CALL_FORWARD + * + * Configure call forward rule + * + * "data" is const RIL_CallForwardInfo * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * INVALID_STATE + * FDN_CHECK_FAILURE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SET_CALL_FORWARD 34 + + +/** + * RIL_REQUEST_QUERY_CALL_WAITING + * + * Query current call waiting state + * + * "data" is const int * + * ((const int *)data)[0] is the TS 27.007 service class to query. + * "response" is a const int * + * ((const int *)response)[0] is 0 for "disabled" and 1 for "enabled" + * + * If ((const int *)response)[0] is = 1, then ((const int *)response)[1] + * must follow, with the TS 27.007 service class bit vector of services + * for which call waiting is enabled. + * + * For example, if ((const int *)response)[0] is 1 and + * ((const int *)response)[1] is 3, then call waiting is enabled for data + * and voice and disabled for everything else + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * FDN_CHECK_FAILURE + * INVALID_ARGUMENTS + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_QUERY_CALL_WAITING 35 + + +/** + * RIL_REQUEST_SET_CALL_WAITING + * + * Configure current call waiting state + * + * "data" is const int * + * ((const int *)data)[0] is 0 for "disabled" and 1 for "enabled" + * ((const int *)data)[1] is the TS 27.007 service class bit vector of + * services to modify + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * INVALID_ARGUMENTS + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * INVALID_STATE + * FDN_CHECK_FAILURE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SET_CALL_WAITING 36 + +/** + * RIL_REQUEST_SMS_ACKNOWLEDGE + * + * Acknowledge successful or failed receipt of SMS previously indicated + * via RIL_UNSOL_RESPONSE_NEW_SMS + * + * "data" is int * + * ((int *)data)[0] is 1 on successful receipt + * (basically, AT+CNMA=1 from TS 27.005 + * is 0 on failed receipt + * (basically, AT+CNMA=2 from TS 27.005) + * ((int *)data)[1] if data[0] is 0, this contains the failure cause as defined + * in TS 23.040, 9.2.3.22. Currently only 0xD3 (memory + * capacity exceeded) and 0xFF (unspecified error) are + * reported. + * + * "response" is NULL + * + * FIXME would like request that specified RP-ACK/RP-ERROR PDU + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SMS_ACKNOWLEDGE 37 + +/** + * RIL_REQUEST_GET_IMEI - DEPRECATED + * + * Get the device IMEI, including check digit + * + * The request is DEPRECATED, use RIL_REQUEST_DEVICE_IDENTITY + * Valid when RadioState is not RADIO_STATE_UNAVAILABLE + * + * "data" is NULL + * "response" is a const char * containing the IMEI + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ + +#define RIL_REQUEST_GET_IMEI 38 + +/** + * RIL_REQUEST_GET_IMEISV - DEPRECATED + * + * Get the device IMEISV, which should be two decimal digits + * + * The request is DEPRECATED, use RIL_REQUEST_DEVICE_IDENTITY + * Valid when RadioState is not RADIO_STATE_UNAVAILABLE + * + * "data" is NULL + * "response" is a const char * containing the IMEISV + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ + +#define RIL_REQUEST_GET_IMEISV 39 + + +/** + * RIL_REQUEST_ANSWER + * + * Answer incoming call + * + * Will not be called for WAITING calls. + * RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE will be used in this case + * instead + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_STATE + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_ANSWER 40 + +/** + * RIL_REQUEST_DEACTIVATE_DATA_CALL + * + * Deactivate packet data connection and remove from the + * data call list if SUCCESS is returned. Any other return + * values should also try to remove the call from the list, + * but that may not be possible. In any event a + * RIL_REQUEST_RADIO_POWER off/on must clear the list. An + * RIL_UNSOL_DATA_CALL_LIST_CHANGED is not expected to be + * issued because of an RIL_REQUEST_DEACTIVATE_DATA_CALL. + * + * "data" is const char ** + * ((char**)data)[0] indicating CID + * ((char**)data)[1] indicating Disconnect Reason + * 0 => No specific reason specified + * 1 => Radio shutdown requested + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_CALL_ID + * INVALID_STATE + * INVALID_ARGUMENTS + * REQUEST_NOT_SUPPORTED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * SIM_ABSENT + * + * See also: RIL_REQUEST_SETUP_DATA_CALL + */ +#define RIL_REQUEST_DEACTIVATE_DATA_CALL 41 + +/** + * RIL_REQUEST_QUERY_FACILITY_LOCK + * + * Query the status of a facility lock state + * + * "data" is const char ** + * ((const char **)data)[0] is the facility string code from TS 27.007 7.4 + * (eg "AO" for BAOC, "SC" for SIM lock) + * ((const char **)data)[1] is the password, or "" if not required + * ((const char **)data)[2] is the TS 27.007 service class bit vector of + * services to query + * ((const char **)data)[3] is AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * This is only applicable in the case of Fixed Dialing Numbers + * (FDN) requests. + * + * "response" is an int * + * ((const int *)response) 0 is the TS 27.007 service class bit vector of + * services for which the specified barring facility + * is active. "0" means "disabled for all" + * + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * INVALID_ARGUMENTS + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * FDN_CHECK_FAILURE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_QUERY_FACILITY_LOCK 42 + +/** + * RIL_REQUEST_SET_FACILITY_LOCK + * + * Enable/disable one facility lock + * + * "data" is const char ** + * + * ((const char **)data)[0] = facility string code from TS 27.007 7.4 + * (eg "AO" for BAOC) + * ((const char **)data)[1] = "0" for "unlock" and "1" for "lock" + * ((const char **)data)[2] = password + * ((const char **)data)[3] = string representation of decimal TS 27.007 + * service class bit vector. Eg, the string + * "1" means "set this facility for voice services" + * ((const char **)data)[4] = AID value, See ETSI 102.221 8.1 and 101.220 4, NULL if no value. + * This is only applicable in the case of Fixed Dialing Numbers + * (FDN) requests. + * + * "response" is int * + * ((int *)response)[0] is the number of retries remaining, or -1 if unknown + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * INVALID_ARGUMENTS + * INTERNAL_ERR + * NO_MEMORY + * MODEM_ERR + * INVALID_STATE + * FDN_CHECK_FAILURE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_SET_FACILITY_LOCK 43 + +/** + * RIL_REQUEST_CHANGE_BARRING_PASSWORD + * + * Change call barring facility password + * + * "data" is const char ** + * + * ((const char **)data)[0] = facility string code from TS 27.007 7.4 + * (eg "AO" for BAOC) + * ((const char **)data)[1] = old password + * ((const char **)data)[2] = new password + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * INVALID_ARGUMENTS + * NO_MEMORY + * MODEM_ERR + * INTERNAL_ERR + * SYSTEM_ERR + * FDN_CHECK_FAILURE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_CHANGE_BARRING_PASSWORD 44 + +/** + * RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE + * + * Query current network selectin mode + * + * "data" is NULL + * + * "response" is int * + * ((const int *)response)[0] is + * 0 for automatic selection + * 1 for manual selection + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE 45 + +/** + * RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC + * + * Specify that the network should be selected automatically + * + * "data" is NULL + * "response" is NULL + * + * This request must not respond until the new operator is selected + * and registered + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * ILLEGAL_SIM_OR_ME + * OPERATION_NOT_ALLOWED + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + * Note: Returns ILLEGAL_SIM_OR_ME when the failure is permanent and + * no retries needed, such as illegal SIM or ME. + * + */ +#define RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC 46 + +/** + * RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL + * + * Manually select a specified network. + * + * "data" is const char * specifying MCCMNC of network to select (eg "310170") + * "response" is NULL + * + * This request must not respond until the new operator is selected + * and registered + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * ILLEGAL_SIM_OR_ME + * OPERATION_NOT_ALLOWED + * INVALID_STATE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + * Note: Returns ILLEGAL_SIM_OR_ME when the failure is permanent and + * no retries needed, such as illegal SIM or ME. + * + */ +#define RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL 47 + +/** + * RIL_REQUEST_QUERY_AVAILABLE_NETWORKS + * + * Scans for available networks + * + * "data" is NULL + * "response" is const char ** that should be an array of n*4 strings, where + * n is the number of available networks + * For each available network: + * + * ((const char **)response)[n+0] is long alpha ONS or EONS + * ((const char **)response)[n+1] is short alpha ONS or EONS + * ((const char **)response)[n+2] is 5 or 6 digit numeric code (MCC + MNC) + * ((const char **)response)[n+3] is a string value of the status: + * "unknown" + * "available" + * "current" + * "forbidden" + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * ABORTED + * DEVICE_IN_USE + * INTERNAL_ERR + * NO_MEMORY + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * CANCELLED + * OPERATION_NOT_ALLOWED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_QUERY_AVAILABLE_NETWORKS 48 + +/** + * RIL_REQUEST_DTMF_START + * + * Start playing a DTMF tone. Continue playing DTMF tone until + * RIL_REQUEST_DTMF_STOP is received + * + * If a RIL_REQUEST_DTMF_START is received while a tone is currently playing, + * it should cancel the previous tone and play the new one. + * + * "data" is a char * + * ((char *)data)[0] is a single character with one of 12 values: 0-9,*,# + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * NO_RESOURCES + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_REQUEST_DTMF, RIL_REQUEST_DTMF_STOP + */ +#define RIL_REQUEST_DTMF_START 49 + +/** + * RIL_REQUEST_DTMF_STOP + * + * Stop playing a currently playing DTMF tone. + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * NO_RESOURCES + * NO_MEMORY + * INVALID_ARGUMENTS + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_REQUEST_DTMF, RIL_REQUEST_DTMF_START + */ +#define RIL_REQUEST_DTMF_STOP 50 + +/** + * RIL_REQUEST_BASEBAND_VERSION + * + * Return string value indicating baseband version, eg + * response from AT+CGMR + * + * "data" is NULL + * "response" is const char * containing version string for log reporting + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * EMPTY_RECORD + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_BASEBAND_VERSION 51 + +/** + * RIL_REQUEST_SEPARATE_CONNECTION + * + * Separate a party from a multiparty call placing the multiparty call + * (less the specified party) on hold and leaving the specified party + * as the only other member of the current (active) call + * + * Like AT+CHLD=2x + * + * See TS 22.084 1.3.8.2 (iii) + * TS 22.030 6.5.5 "Entering "2X followed by send" + * TS 27.007 "AT+CHLD=2x" + * + * "data" is an int * + * (int *)data)[0] contains Connection index (value of 'x' in CHLD above) "response" is NULL + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_ARGUMENTS + * INVALID_STATE + * NO_RESOURCES + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * INVALID_STATE + * OPERATION_NOT_ALLOWED + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SEPARATE_CONNECTION 52 + + +/** + * RIL_REQUEST_SET_MUTE + * + * Turn on or off uplink (microphone) mute. + * + * Will only be sent while voice call is active. + * Will always be reset to "disable mute" when a new voice call is initiated + * + * "data" is an int * + * (int *)data)[0] is 1 for "enable mute" and 0 for "disable mute" + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_ARGUMENTS + * NO_MEMORY + * REQUEST_RATE_LIMITED + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_SET_MUTE 53 + +/** + * RIL_REQUEST_GET_MUTE + * + * Queries the current state of the uplink mute setting + * + * "data" is NULL + * "response" is an int * + * (int *)response)[0] is 1 for "mute enabled" and 0 for "mute disabled" + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * SS_MODIFIED_TO_DIAL + * SS_MODIFIED_TO_USSD + * SS_MODIFIED_TO_SS + * NO_MEMORY + * REQUEST_RATE_LIMITED + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_GET_MUTE 54 + +/** + * RIL_REQUEST_QUERY_CLIP + * + * Queries the status of the CLIP supplementary service + * + * (for MMI code "*#30#") + * + * "data" is NULL + * "response" is an int * + * (int *)response)[0] is 1 for "CLIP provisioned" + * and 0 for "CLIP not provisioned" + * and 2 for "unknown, e.g. no network etc" + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * FDN_CHECK_FAILURE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_QUERY_CLIP 55 + +/** + * RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE - Deprecated use the status + * field in RIL_Data_Call_Response_v6. + * + * Requests the failure cause code for the most recently failed PDP + * context or CDMA data connection active + * replaces RIL_REQUEST_LAST_PDP_FAIL_CAUSE + * + * "data" is NULL + * + * "response" is a "int *" + * ((int *)response)[0] is an integer cause code defined in TS 24.008 + * section 6.1.3.1.3 or close approximation + * + * If the implementation does not have access to the exact cause codes, + * then it should return one of the values listed in + * RIL_DataCallFailCause, as the UI layer needs to distinguish these + * cases for error notification + * and potential retries. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_REQUEST_LAST_CALL_FAIL_CAUSE + * + * Deprecated use the status field in RIL_Data_Call_Response_v6. + */ + +#define RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE 56 + +/** + * RIL_REQUEST_DATA_CALL_LIST + * + * Returns the data call list. An entry is added when a + * RIL_REQUEST_SETUP_DATA_CALL is issued and removed on a + * RIL_REQUEST_DEACTIVATE_DATA_CALL. The list is emptied + * when RIL_REQUEST_RADIO_POWER off/on is issued. + * + * "data" is NULL + * "response" is an array of RIL_Data_Call_Response_v6 + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + * + * See also: RIL_UNSOL_DATA_CALL_LIST_CHANGED + */ + +#define RIL_REQUEST_DATA_CALL_LIST 57 + +/** + * RIL_REQUEST_RESET_RADIO - DEPRECATED + * + * Request a radio reset. The RIL implementation may postpone + * the reset until after this request is responded to if the baseband + * is presently busy. + * + * The request is DEPRECATED, use RIL_REQUEST_RADIO_POWER + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * REQUEST_NOT_SUPPORTED + */ + +#define RIL_REQUEST_RESET_RADIO 58 + +/** + * RIL_REQUEST_OEM_HOOK_RAW + * + * This request reserved for OEM-specific uses. It passes raw byte arrays + * back and forth. + * + * It can be invoked on the Java side from + * com.android.internal.telephony.Phone.invokeOemRilRequestRaw() + * + * "data" is a char * of bytes copied from the byte[] data argument in java + * "response" is a char * of bytes that will returned via the + * caller's "response" Message here: + * (byte[])(((AsyncResult)response.obj).result) + * + * An error response here will result in + * (((AsyncResult)response.obj).result) == null and + * (((AsyncResult)response.obj).exception) being an instance of + * com.android.internal.telephony.gsm.CommandException + * + * Valid errors: + * All + */ + +#define RIL_REQUEST_OEM_HOOK_RAW 59 + +/** + * RIL_REQUEST_OEM_HOOK_STRINGS + * + * This request reserved for OEM-specific uses. It passes strings + * back and forth. + * + * It can be invoked on the Java side from + * com.android.internal.telephony.Phone.invokeOemRilRequestStrings() + * + * "data" is a const char **, representing an array of null-terminated UTF-8 + * strings copied from the "String[] strings" argument to + * invokeOemRilRequestStrings() + * + * "response" is a const char **, representing an array of null-terminated UTF-8 + * stings that will be returned via the caller's response message here: + * + * (String[])(((AsyncResult)response.obj).result) + * + * An error response here will result in + * (((AsyncResult)response.obj).result) == null and + * (((AsyncResult)response.obj).exception) being an instance of + * com.android.internal.telephony.gsm.CommandException + * + * Valid errors: + * All + */ + +#define RIL_REQUEST_OEM_HOOK_STRINGS 60 + +/** + * RIL_REQUEST_SCREEN_STATE - DEPRECATED + * + * Indicates the current state of the screen. When the screen is off, the + * RIL should notify the baseband to suppress certain notifications (eg, + * signal strength and changes in LAC/CID or BID/SID/NID/latitude/longitude) + * in an effort to conserve power. These notifications should resume when the + * screen is on. + * + * Note this request is deprecated. Use RIL_REQUEST_SEND_DEVICE_STATE to report the device state + * to the modem and use RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER to turn on/off unsolicited + * response from the modem in different scenarios. + * + * "data" is int * + * ((int *)data)[0] is == 1 for "Screen On" + * ((int *)data)[0] is == 0 for "Screen Off" + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SCREEN_STATE 61 + + +/** + * RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION + * + * Enables/disables supplementary service related notifications + * from the network. + * + * Notifications are reported via RIL_UNSOL_SUPP_SVC_NOTIFICATION. + * + * "data" is int * + * ((int *)data)[0] is == 1 for notifications enabled + * ((int *)data)[0] is == 0 for notifications disabled + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SIM_BUSY + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_UNSOL_SUPP_SVC_NOTIFICATION. + */ +#define RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION 62 + +/** + * RIL_REQUEST_WRITE_SMS_TO_SIM + * + * Stores a SMS message to SIM memory. + * + * "data" is RIL_SMS_WriteArgs * + * + * "response" is int * + * ((const int *)response)[0] is the record index where the message is stored. + * + * Valid errors: + * SUCCESS + * SIM_FULL + * INVALID_ARGUMENTS + * INVALID_SMS_FORMAT + * INTERNAL_ERR + * MODEM_ERR + * ENCODING_ERR + * NO_MEMORY + * NO_RESOURCES + * INVALID_MODEM_STATE + * OPERATION_NOT_ALLOWED + * INVALID_SMSC_ADDRESS + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + * + */ +#define RIL_REQUEST_WRITE_SMS_TO_SIM 63 + +/** + * RIL_REQUEST_DELETE_SMS_ON_SIM + * + * Deletes a SMS message from SIM memory. + * + * "data" is int * + * ((int *)data)[0] is the record index of the message to delete. + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * SIM_FULL + * INVALID_ARGUMENTS + * NO_MEMORY + * REQUEST_RATE_LIMITED + * SYSTEM_ERR + * MODEM_ERR + * NO_SUCH_ENTRY + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + * + */ +#define RIL_REQUEST_DELETE_SMS_ON_SIM 64 + +/** + * RIL_REQUEST_SET_BAND_MODE + * + * Assign a specified band for RF configuration. + * + * "data" is int * + * ((int *)data)[0] is a RIL_RadioBandMode + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + * See also: RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE + */ +#define RIL_REQUEST_SET_BAND_MODE 65 + +/** + * RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE + * + * Query the list of band mode supported by RF. + * + * "data" is NULL + * + * "response" is int * + * "response" points to an array of int's, the int[0] is the size of array; + * subsequent values are a list of RIL_RadioBandMode listing supported modes. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + * See also: RIL_REQUEST_SET_BAND_MODE + */ +#define RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE 66 + +/** + * RIL_REQUEST_STK_GET_PROFILE + * + * Requests the profile of SIM tool kit. + * The profile indicates the SAT/USAT features supported by ME. + * The SAT/USAT features refer to 3GPP TS 11.14 and 3GPP TS 31.111 + * + * "data" is NULL + * + * "response" is a const char * containing SAT/USAT profile + * in hexadecimal format string starting with first byte of terminal profile + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_RADIO_NOT_AVAILABLE (radio resetting) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_STK_GET_PROFILE 67 + +/** + * RIL_REQUEST_STK_SET_PROFILE + * + * Download the STK terminal profile as part of SIM initialization + * procedure + * + * "data" is a const char * containing SAT/USAT profile + * in hexadecimal format string starting with first byte of terminal profile + * + * "response" is NULL + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_RADIO_NOT_AVAILABLE (radio resetting) + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_STK_SET_PROFILE 68 + +/** + * RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND + * + * Requests to send a SAT/USAT envelope command to SIM. + * The SAT/USAT envelope command refers to 3GPP TS 11.14 and 3GPP TS 31.111 + * + * "data" is a const char * containing SAT/USAT command + * in hexadecimal format string starting with command tag + * + * "response" is a const char * containing SAT/USAT response + * in hexadecimal format string starting with first byte of response + * (May be NULL) + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_RADIO_NOT_AVAILABLE (radio resetting) + * SIM_BUSY + * OPERATION_NOT_ALLOWED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND 69 + +/** + * RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE + * + * Requests to send a terminal response to SIM for a received + * proactive command + * + * "data" is a const char * containing SAT/USAT response + * in hexadecimal format string starting with first byte of response data + * + * "response" is NULL + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_RADIO_NOT_AVAILABLE (radio resetting) + * RIL_E_OPERATION_NOT_ALLOWED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE 70 + +/** + * RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM + * + * When STK application gets RIL_UNSOL_STK_CALL_SETUP, the call actually has + * been initialized by ME already. (We could see the call has been in the 'call + * list') So, STK application needs to accept/reject the call according as user + * operations. + * + * "data" is int * + * ((int *)data)[0] is > 0 for "accept" the call setup + * ((int *)data)[0] is == 0 for "reject" the call setup + * + * "response" is NULL + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_RADIO_NOT_AVAILABLE (radio resetting) + * RIL_E_OPERATION_NOT_ALLOWED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM 71 + +/** + * RIL_REQUEST_EXPLICIT_CALL_TRANSFER + * + * Connects the two calls and disconnects the subscriber from both calls. + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * INVALID_STATE + * NO_RESOURCES + * NO_MEMORY + * INVALID_ARGUMENTS + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * INVALID_STATE + * OPERATION_NOT_ALLOWED + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_EXPLICIT_CALL_TRANSFER 72 + +/** + * RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE + * + * Requests to set the preferred network type for searching and registering + * (CS/PS domain, RAT, and operation mode) + * + * "data" is int * which is RIL_PreferredNetworkType + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * OPERATION_NOT_ALLOWED + * MODE_NOT_SUPPORTED + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE 73 + +/** + * RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE + * + * Query the preferred network type (CS/PS domain, RAT, and operation mode) + * for searching and registering + * + * "data" is NULL + * + * "response" is int * + * ((int *)reponse)[0] is == RIL_PreferredNetworkType + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + * See also: RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE + */ +#define RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE 74 + +/** + * RIL_REQUEST_NEIGHBORING_CELL_IDS + * + * Request neighboring cell id in GSM network + * + * "data" is NULL + * "response" must be a " const RIL_NeighboringCell** " + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * NO_NETWORK_FOUND + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_GET_NEIGHBORING_CELL_IDS 75 + +/** + * RIL_REQUEST_SET_LOCATION_UPDATES + * + * Enables/disables network state change notifications due to changes in + * LAC and/or CID (for GSM) or BID/SID/NID/latitude/longitude (for CDMA). + * Basically +CREG=2 vs. +CREG=1 (TS 27.007). + * + * Note: The RIL implementation should default to "updates enabled" + * when the screen is on and "updates disabled" when the screen is off. + * + * "data" is int * + * ((int *)data)[0] is == 1 for updates enabled (+CREG=2) + * ((int *)data)[0] is == 0 for updates disabled (+CREG=1) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + * See also: RIL_REQUEST_SCREEN_STATE, RIL_UNSOL_RESPONSE_NETWORK_STATE_CHANGED + */ +#define RIL_REQUEST_SET_LOCATION_UPDATES 76 + +/** + * RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE + * + * Request to set the location where the CDMA subscription shall + * be retrieved + * + * "data" is int * + * ((int *)data)[0] is == RIL_CdmaSubscriptionSource + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SIM_ABSENT + * SUBSCRIPTION_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE + */ +#define RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE 77 + +/** + * RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE + * + * Request to set the roaming preferences in CDMA + * + * "data" is int * + * ((int *)data)[0] is == 0 for Home Networks only, as defined in PRL + * ((int *)data)[0] is == 1 for Roaming on Affiliated networks, as defined in PRL + * ((int *)data)[0] is == 2 for Roaming on Any Network, as defined in the PRL + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * OPERATION_NOT_ALLOWED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE 78 + +/** + * RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE + * + * Request the actual setting of the roaming preferences in CDMA in the modem + * + * "data" is NULL + * + * "response" is int * + * ((int *)response)[0] is == 0 for Home Networks only, as defined in PRL + * ((int *)response)[0] is == 1 for Roaming on Affiliated networks, as defined in PRL + * ((int *)response)[0] is == 2 for Roaming on Any Network, as defined in the PRL + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE 79 + +/** + * RIL_REQUEST_SET_TTY_MODE + * + * Request to set the TTY mode + * + * "data" is int * + * ((int *)data)[0] is == 0 for TTY off + * ((int *)data)[0] is == 1 for TTY Full + * ((int *)data)[0] is == 2 for TTY HCO (hearing carryover) + * ((int *)data)[0] is == 3 for TTY VCO (voice carryover) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * INVALID_ARGUMENTS + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SET_TTY_MODE 80 + +/** + * RIL_REQUEST_QUERY_TTY_MODE + * + * Request the setting of TTY mode + * + * "data" is NULL + * + * "response" is int * + * ((int *)response)[0] is == 0 for TTY off + * ((int *)response)[0] is == 1 for TTY Full + * ((int *)response)[0] is == 2 for TTY HCO (hearing carryover) + * ((int *)response)[0] is == 3 for TTY VCO (voice carryover) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * INVALID_ARGUMENTS + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_QUERY_TTY_MODE 81 + +/** + * RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE + * + * Request to set the preferred voice privacy mode used in voice + * scrambling + * + * "data" is int * + * ((int *)data)[0] is == 0 for Standard Privacy Mode (Public Long Code Mask) + * ((int *)data)[0] is == 1 for Enhanced Privacy Mode (Private Long Code Mask) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * INVALID_CALL_ID + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE 82 + +/** + * RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE + * + * Request the setting of preferred voice privacy mode + * + * "data" is NULL + * + * "response" is int * + * ((int *)response)[0] is == 0 for Standard Privacy Mode (Public Long Code Mask) + * ((int *)response)[0] is == 1 for Enhanced Privacy Mode (Private Long Code Mask) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * MODEM_ERR + * INTERNAL_ERR + * NO_MEMORY + * INVALID_ARGUMENTS + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE 83 + +/** + * RIL_REQUEST_CDMA_FLASH + * + * Send FLASH + * + * "data" is const char * + * ((const char *)data)[0] is a FLASH string + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * INVALID_STATE + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_CDMA_FLASH 84 + +/** + * RIL_REQUEST_CDMA_BURST_DTMF + * + * Send DTMF string + * + * "data" is const char ** + * ((const char **)data)[0] is a DTMF string + * ((const char **)data)[1] is the DTMF ON length in milliseconds, or 0 to use + * default + * ((const char **)data)[2] is the DTMF OFF length in milliseconds, or 0 to use + * default + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * MODEM_ERR + * INTERNAL_ERR + * INVALID_CALL_ID + * NO_RESOURCES + * CANCELLED + * OPERATION_NOT_ALLOWED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_CDMA_BURST_DTMF 85 + +/** + * RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY + * + * Takes a 26 digit string (20 digit AKEY + 6 digit checksum). + * If the checksum is valid the 20 digit AKEY is written to NV, + * replacing the existing AKEY no matter what it was before. + * + * "data" is const char * + * ((const char *)data)[0] is a 26 digit string (ASCII digits '0'-'9') + * where the last 6 digits are a checksum of the + * first 20, as specified in TR45.AHAG + * "Common Cryptographic Algorithms, Revision D.1 + * Section 2.2" + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY 86 + +/** + * RIL_REQUEST_CDMA_SEND_SMS + * + * Send a CDMA SMS message + * + * "data" is const RIL_CDMA_SMS_Message * + * + * "response" is a const RIL_SMS_Response * + * + * Based on the return error, caller decides to resend if sending sms + * fails. The CDMA error class is derived as follows, + * SUCCESS is error class 0 (no error) + * SMS_SEND_FAIL_RETRY is error class 2 (temporary failure) + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SMS_SEND_FAIL_RETRY + * NETWORK_REJECT + * INVALID_STATE + * INVALID_ARGUMENTS + * NO_MEMORY + * REQUEST_RATE_LIMITED + * INVALID_SMS_FORMAT + * SYSTEM_ERR + * FDN_CHECK_FAILURE + * MODEM_ERR + * NETWORK_ERR + * ENCODING_ERR + * INVALID_SMSC_ADDRESS + * OPERATION_NOT_ALLOWED + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * MODE_NOT_SUPPORTED + * SIM_ABSENT + * + */ +#define RIL_REQUEST_CDMA_SEND_SMS 87 + +/** + * RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE + * + * Acknowledge the success or failure in the receipt of SMS + * previously indicated via RIL_UNSOL_RESPONSE_CDMA_NEW_SMS + * + * "data" is const RIL_CDMA_SMS_Ack * + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * NO_SMS_TO_ACK + * INVALID_STATE + * NO_MEMORY + * REQUEST_RATE_LIMITED + * SYSTEM_ERR + * MODEM_ERR + * INVALID_STATE + * OPERATION_NOT_ALLOWED + * NETWORK_NOT_READY + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE 88 + +/** + * RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG + * + * Request the setting of GSM/WCDMA Cell Broadcast SMS config. + * + * "data" is NULL + * + * "response" is a const RIL_GSM_BroadcastSmsConfigInfo ** + * "responselen" is count * sizeof (RIL_GSM_BroadcastSmsConfigInfo *) + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_STATE + * NO_MEMORY + * REQUEST_RATE_LIMITED + * SYSTEM_ERR + * NO_RESOURCES + * MODEM_ERR + * SYSTEM_ERR + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG 89 + +/** + * RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG + * + * Set GSM/WCDMA Cell Broadcast SMS config + * + * "data" is a const RIL_GSM_BroadcastSmsConfigInfo ** + * "datalen" is count * sizeof(RIL_GSM_BroadcastSmsConfigInfo *) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_STATE + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * REQUEST_RATE_LIMITED + * MODEM_ERR + * SYSTEM_ERR + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG 90 + +/** + * RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION + * +* Enable or disable the reception of GSM/WCDMA Cell Broadcast SMS + * + * "data" is const int * + * (const int *)data[0] indicates to activate or turn off the + * reception of GSM/WCDMA Cell Broadcast SMS, 0-1, + * 0 - Activate, 1 - Turn off + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_STATE + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * REQUEST_RATE_LIMITED +* MODEM_ERR +* INTERNAL_ERR +* NO_RESOURCES +* CANCELLED +* INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION 91 + +/** + * RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG + * + * Request the setting of CDMA Broadcast SMS config + * + * "data" is NULL + * + * "response" is a const RIL_CDMA_BroadcastSmsConfigInfo ** + * "responselen" is count * sizeof (RIL_CDMA_BroadcastSmsConfigInfo *) + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_STATE + * NO_MEMORY + * REQUEST_RATE_LIMITED + * SYSTEM_ERR + * NO_RESOURCES + * MODEM_ERR + * SYSTEM_ERR + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG 92 + +/** + * RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG + * + * Set CDMA Broadcast SMS config + * + * "data" is a const RIL_CDMA_BroadcastSmsConfigInfo ** + * "datalen" is count * sizeof(const RIL_CDMA_BroadcastSmsConfigInfo *) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_STATE + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * REQUEST_RATE_LIMITED + * MODEM_ERR + * SYSTEM_ERR + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG 93 + +/** + * RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION + * + * Enable or disable the reception of CDMA Broadcast SMS + * + * "data" is const int * + * (const int *)data[0] indicates to activate or turn off the + * reception of CDMA Broadcast SMS, 0-1, + * 0 - Activate, 1 - Turn off + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_STATE + * INVALID_ARGUMENTS + * NO_MEMORY + * SYSTEM_ERR + * REQUEST_RATE_LIMITED + * MODEM_ERR + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION 94 + +/** + * RIL_REQUEST_CDMA_SUBSCRIPTION + * + * Request the device MDN / H_SID / H_NID. + * + * The request is only allowed when CDMA subscription is available. When CDMA + * subscription is changed, application layer should re-issue the request to + * update the subscription information. + * + * If a NULL value is returned for any of the device id, it means that error + * accessing the device. + * + * "response" is const char ** + * ((const char **)response)[0] is MDN if CDMA subscription is available + * ((const char **)response)[1] is a comma separated list of H_SID (Home SID) if + * CDMA subscription is available, in decimal format + * ((const char **)response)[2] is a comma separated list of H_NID (Home NID) if + * CDMA subscription is available, in decimal format + * ((const char **)response)[3] is MIN (10 digits, MIN2+MIN1) if CDMA subscription is available + * ((const char **)response)[4] is PRL version if CDMA subscription is available + * + * Valid errors: + * SUCCESS + * RIL_E_SUBSCRIPTION_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * + */ + +#define RIL_REQUEST_CDMA_SUBSCRIPTION 95 + +/** + * RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM + * + * Stores a CDMA SMS message to RUIM memory. + * + * "data" is RIL_CDMA_SMS_WriteArgs * + * + * "response" is int * + * ((const int *)response)[0] is the record index where the message is stored. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SIM_FULL + * INVALID_ARGUMENTS + * INVALID_SMS_FORMAT + * INTERNAL_ERR + * MODEM_ERR + * ENCODING_ERR + * NO_MEMORY + * NO_RESOURCES + * INVALID_MODEM_STATE + * OPERATION_NOT_ALLOWED + * INVALID_SMSC_ADDRESS + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + * + */ +#define RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM 96 + +/** + * RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM + * + * Deletes a CDMA SMS message from RUIM memory. + * + * "data" is int * + * ((int *)data)[0] is the record index of the message to delete. + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * NO_MEMORY + * REQUEST_RATE_LIMITED + * SYSTEM_ERR + * MODEM_ERR + * NO_SUCH_ENTRY + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + */ +#define RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM 97 + +/** + * RIL_REQUEST_DEVICE_IDENTITY + * + * Request the device ESN / MEID / IMEI / IMEISV. + * + * The request is always allowed and contains GSM and CDMA device identity; + * it substitutes the deprecated requests RIL_REQUEST_GET_IMEI and + * RIL_REQUEST_GET_IMEISV. + * + * If a NULL value is returned for any of the device id, it means that error + * accessing the device. + * + * When CDMA subscription is changed the ESN/MEID may change. The application + * layer should re-issue the request to update the device identity in this case. + * + * "response" is const char ** + * ((const char **)response)[0] is IMEI if GSM subscription is available + * ((const char **)response)[1] is IMEISV if GSM subscription is available + * ((const char **)response)[2] is ESN if CDMA subscription is available + * ((const char **)response)[3] is MEID if CDMA subscription is available + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_DEVICE_IDENTITY 98 + +/** + * RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE + * + * Request the radio's system selection module to exit emergency + * callback mode. RIL will not respond with SUCCESS until the modem has + * completely exited from Emergency Callback Mode. + * + * "data" is NULL + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE 99 + +/** + * RIL_REQUEST_GET_SMSC_ADDRESS + * + * Queries the default Short Message Service Center address on the device. + * + * "data" is NULL + * + * "response" is const char * containing the SMSC address. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * REQUEST_RATE_LIMITED + * SYSTEM_ERR + * INTERNAL_ERR + * MODEM_ERR + * INVALID_ARGUMENTS + * INVALID_MODEM_STATE + * NOT_PROVISIONED + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + * + */ +#define RIL_REQUEST_GET_SMSC_ADDRESS 100 + +/** + * RIL_REQUEST_SET_SMSC_ADDRESS + * + * Sets the default Short Message Service Center address on the device. + * + * "data" is const char * containing the SMSC address. + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * INVALID_SMS_FORMAT + * NO_MEMORY + * SYSTEM_ERR + * REQUEST_RATE_LIMITED + * MODEM_ERR + * NO_RESOURCES + * INTERNAL_ERR + * CANCELLED + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + */ +#define RIL_REQUEST_SET_SMSC_ADDRESS 101 + +/** + * RIL_REQUEST_REPORT_SMS_MEMORY_STATUS + * + * Indicates whether there is storage available for new SMS messages. + * + * "data" is int * + * ((int *)data)[0] is 1 if memory is available for storing new messages + * is 0 if memory capacity is exceeded + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INVALID_ARGUMENTS + * NO_MEMORY + * INVALID_STATE + * SYSTEM_ERR + * REQUEST_RATE_LIMITED + * MODEM_ERR + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_REPORT_SMS_MEMORY_STATUS 102 + +/** + * RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING + * + * Indicates that the StkSerivce is running and is + * ready to receive RIL_UNSOL_STK_XXXXX commands. + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING 103 + +/** + * RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE + * + * Request to query the location where the CDMA subscription shall + * be retrieved + * + * "data" is NULL + * + * "response" is int * + * ((int *)data)[0] is == RIL_CdmaSubscriptionSource + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SUBSCRIPTION_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + * See also: RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE + */ +#define RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE 104 + +/** + * RIL_REQUEST_ISIM_AUTHENTICATION + * + * Request the ISIM application on the UICC to perform AKA + * challenge/response algorithm for IMS authentication + * + * "data" is a const char * containing the challenge string in Base64 format + * "response" is a const char * containing the response in Base64 format + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_ISIM_AUTHENTICATION 105 + +/** + * RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU + * + * Acknowledge successful or failed receipt of SMS previously indicated + * via RIL_UNSOL_RESPONSE_NEW_SMS, including acknowledgement TPDU to send + * as the RP-User-Data element of the RP-ACK or RP-ERROR PDU. + * + * "data" is const char ** + * ((const char **)data)[0] is "1" on successful receipt (send RP-ACK) + * is "0" on failed receipt (send RP-ERROR) + * ((const char **)data)[1] is the acknowledgement TPDU in hexadecimal format + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU 106 + +/** + * RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS + * + * Requests to send a SAT/USAT envelope command to SIM. + * The SAT/USAT envelope command refers to 3GPP TS 11.14 and 3GPP TS 31.111. + * + * This request has one difference from RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND: + * the SW1 and SW2 status bytes from the UICC response are returned along with + * the response data, using the same structure as RIL_REQUEST_SIM_IO. + * + * The RIL implementation shall perform the normal processing of a '91XX' + * response in SW1/SW2 to retrieve the pending proactive command and send it + * as an unsolicited response, as RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND does. + * + * "data" is a const char * containing the SAT/USAT command + * in hexadecimal format starting with command tag + * + * "response" is a const RIL_SIM_IO_Response * + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_RADIO_NOT_AVAILABLE (radio resetting) + * SIM_BUSY + * OPERATION_NOT_ALLOWED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + */ +#define RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS 107 + +/** + * RIL_REQUEST_VOICE_RADIO_TECH + * + * Query the radio technology type (3GPP/3GPP2) used for voice. Query is valid only + * when radio state is not RADIO_STATE_UNAVAILABLE + * + * "data" is NULL + * "response" is int * + * ((int *) response)[0] is of type const RIL_RadioTechnology + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_VOICE_RADIO_TECH 108 + +/** + * RIL_REQUEST_GET_CELL_INFO_LIST + * + * Request all of the current cell information known to the radio. The radio + * must a list of all current cells, including the neighboring cells. If for a particular + * cell information isn't known then the appropriate unknown value will be returned. + * This does not cause or change the rate of RIL_UNSOL_CELL_INFO_LIST. + * + * "data" is NULL + * + * "response" is an array of RIL_CellInfo_v12. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * NO_NETWORK_FOUND + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_GET_CELL_INFO_LIST 109 + +/** + * RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE + * + * Sets the minimum time between when RIL_UNSOL_CELL_INFO_LIST should be invoked. + * A value of 0, means invoke RIL_UNSOL_CELL_INFO_LIST when any of the reported + * information changes. Setting the value to INT_MAX(0x7fffffff) means never issue + * a RIL_UNSOL_CELL_INFO_LIST. + * + * "data" is int * + * ((int *)data)[0] is minimum time in milliseconds + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SET_UNSOL_CELL_INFO_LIST_RATE 110 + +/** + * RIL_REQUEST_SET_INITIAL_ATTACH_APN + * + * Set an apn to initial attach network + * + * "data" is a const char ** + * ((const char **)data)[0] is the APN to connect if radio technology is LTE + * ((const char **)data)[1] is the connection type to request must be one of the + * PDP_type values in TS 27.007 section 10.1.1. + * For example, "IP", "IPV6", "IPV4V6", or "PPP". + * ((const char **)data)[2] is the PAP / CHAP auth type. Values: + * 0 => PAP and CHAP is never performed. + * 1 => PAP may be performed; CHAP is never performed. + * 2 => CHAP may be performed; PAP is never performed. + * 3 => PAP / CHAP may be performed - baseband dependent. + * ((const char **)data)[3] is the username for APN, or NULL + * ((const char **)data)[4] is the password for APN, or NULL + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * SUBSCRIPTION_NOT_AVAILABLE + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_SET_INITIAL_ATTACH_APN 111 + +/** + * RIL_REQUEST_IMS_REGISTRATION_STATE + * + * This message is DEPRECATED and shall be removed in a future release (target: 2018); + * instead, provide IMS registration status via an IMS Service. + * + * Request current IMS registration state + * + * "data" is NULL + * + * "response" is int * + * ((int *)response)[0] is registration state: + * 0 - Not registered + * 1 - Registered + * + * If ((int*)response)[0] is = 1, then ((int *) response)[1] + * must follow with IMS SMS format: + * + * ((int *) response)[1] is of type RIL_RadioTechnologyFamily + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_IMS_REGISTRATION_STATE 112 + +/** + * RIL_REQUEST_IMS_SEND_SMS + * + * Send a SMS message over IMS + * + * "data" is const RIL_IMS_SMS_Message * + * + * "response" is a const RIL_SMS_Response * + * + * Based on the return error, caller decides to resend if sending sms + * fails. SMS_SEND_FAIL_RETRY means retry, and other errors means no retry. + * In case of retry, data is encoded based on Voice Technology available. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * SMS_SEND_FAIL_RETRY + * FDN_CHECK_FAILURE + * NETWORK_REJECT + * INVALID_ARGUMENTS + * INVALID_STATE + * NO_MEMORY + * INVALID_SMS_FORMAT + * SYSTEM_ERR + * REQUEST_RATE_LIMITED + * MODEM_ERR + * NETWORK_ERR + * ENCODING_ERR + * INVALID_SMSC_ADDRESS + * OPERATION_NOT_ALLOWED + * INTERNAL_ERR + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_IMS_SEND_SMS 113 + +/** + * RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC + * + * Request APDU exchange on the basic channel. This command reflects TS 27.007 + * "generic SIM access" operation (+CSIM). The modem must ensure proper function + * of GSM/CDMA, and filter commands appropriately. It should filter + * channel management and SELECT by DF name commands. + * + * "data" is a const RIL_SIM_APDU * + * "sessionid" field should be ignored. + * + * "response" is a const RIL_SIM_IO_Response * + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SIM_TRANSMIT_APDU_BASIC 114 + +/** + * RIL_REQUEST_SIM_OPEN_CHANNEL + * + * Open a new logical channel and select the given application. This command + * reflects TS 27.007 "open logical channel" operation (+CCHO). This request + * also specifies the P2 parameter (described in ISO 7816-4). + * + * "data" is a const RIL_OpenChannelParam * + * + * "response" is int * + * ((int *)data)[0] contains the session id of the logical channel. + * ((int *)data)[1] onwards may optionally contain the select response for the + * open channel command with one byte per integer. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * MISSING_RESOURCE + * NO_SUCH_ELEMENT + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * SIM_ERR + * INVALID_SIM_STATE + * MISSING_RESOURCE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SIM_OPEN_CHANNEL 115 + +/** + * RIL_REQUEST_SIM_CLOSE_CHANNEL + * + * Close a previously opened logical channel. This command reflects TS 27.007 + * "close logical channel" operation (+CCHC). + * + * "data" is int * + * ((int *)data)[0] is the session id of logical the channel to close. + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SIM_CLOSE_CHANNEL 116 + +/** + * RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL + * + * Exchange APDUs with a UICC over a previously opened logical channel. This + * command reflects TS 27.007 "generic logical channel access" operation + * (+CGLA). The modem should filter channel management and SELECT by DF name + * commands. + * + * "data" is a const RIL_SIM_APDU* + * + * "response" is a const RIL_SIM_IO_Response * + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SIM_TRANSMIT_APDU_CHANNEL 117 + +/** + * RIL_REQUEST_NV_READ_ITEM + * + * Read one of the radio NV items defined in RadioNVItems.java / ril_nv_items.h. + * This is used for device configuration by some CDMA operators. + * + * "data" is a const RIL_NV_ReadItem * + * + * "response" is const char * containing the contents of the NV item + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_NV_READ_ITEM 118 + +/** + * RIL_REQUEST_NV_WRITE_ITEM + * + * Write one of the radio NV items defined in RadioNVItems.java / ril_nv_items.h. + * This is used for device configuration by some CDMA operators. + * + * "data" is a const RIL_NV_WriteItem * + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_NV_WRITE_ITEM 119 + +/** + * RIL_REQUEST_NV_WRITE_CDMA_PRL + * + * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage. + * This is used for device configuration by some CDMA operators. + * + * "data" is a const char * containing the PRL as a byte array + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_NV_WRITE_CDMA_PRL 120 + +/** + * RIL_REQUEST_NV_RESET_CONFIG + * + * Reset the radio NV configuration to the factory state. + * This is used for device configuration by some CDMA operators. + * + * "data" is int * + * ((int *)data)[0] is 1 to reload all NV items + * ((int *)data)[0] is 2 for erase NV reset (SCRTN) + * ((int *)data)[0] is 3 for factory reset (RTN) + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_NV_RESET_CONFIG 121 + + /** RIL_REQUEST_SET_UICC_SUBSCRIPTION + * FIXME This API needs to have more documentation. + * + * Selection/de-selection of a subscription from a SIM card + * "data" is const RIL_SelectUiccSub* + + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * SUBSCRIPTION_NOT_SUPPORTED + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_SET_UICC_SUBSCRIPTION 122 + +/** + * RIL_REQUEST_ALLOW_DATA + * + * Tells the modem whether data calls are allowed or not + * + * "data" is int * + * FIXME slotId and aid will be added. + * ((int *)data)[0] is == 0 to allow data calls + * ((int *)data)[0] is == 1 to disallow data calls + * + * "response" is NULL + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * INVALID_ARGUMENTS + * DEVICE_IN_USE + * INVALID_MODEM_STATE + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_ALLOW_DATA 123 + +/** + * RIL_REQUEST_GET_HARDWARE_CONFIG + * + * Request all of the current hardware (modem and sim) associated + * with the RIL. + * + * "data" is NULL + * + * "response" is an array of RIL_HardwareConfig. + * + * Valid errors: + * RADIO_NOT_AVAILABLE + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_GET_HARDWARE_CONFIG 124 + +/** + * RIL_REQUEST_SIM_AUTHENTICATION + * + * Returns the response of SIM Authentication through RIL to a + * challenge request. + * + * "data" Base64 encoded string containing challenge: + * int authContext; P2 value of authentication command, see P2 parameter in + * 3GPP TS 31.102 7.1.2 + * char *authData; the challenge string in Base64 format, see 3GPP + * TS 31.102 7.1.2 + * char *aid; AID value, See ETSI 102.221 8.1 and 101.220 4, + * NULL if no value + * + * "response" Base64 encoded strings containing response: + * int sw1; Status bytes per 3GPP TS 31.102 section 7.3 + * int sw2; + * char *simResponse; Response in Base64 format, see 3GPP TS 31.102 7.1.2 + * + * Valid errors: + * RADIO_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * INVALID_MODEM_STATE + * INVALID_ARGUMENTS + * SIM_ERR + * REQUEST_NOT_SUPPORTED + */ +#define RIL_REQUEST_SIM_AUTHENTICATION 125 + +/** + * RIL_REQUEST_GET_DC_RT_INFO + * + * The request is DEPRECATED, use RIL_REQUEST_GET_ACTIVITY_INFO + * Requests the Data Connection Real Time Info + * + * "data" is NULL + * + * "response" is the most recent RIL_DcRtInfo + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * REQUEST_NOT_SUPPORTED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * + * See also: RIL_UNSOL_DC_RT_INFO_CHANGED + */ +#define RIL_REQUEST_GET_DC_RT_INFO 126 + +/** + * RIL_REQUEST_SET_DC_RT_INFO_RATE + * + * The request is DEPRECATED + * This is the minimum number of milliseconds between successive + * RIL_UNSOL_DC_RT_INFO_CHANGED messages and defines the highest rate + * at which RIL_UNSOL_DC_RT_INFO_CHANGED's will be sent. A value of + * 0 means send as fast as possible. + * + * "data" The number of milliseconds as an int + * + * "response" is null + * + * Valid errors: + * SUCCESS must not fail + */ +#define RIL_REQUEST_SET_DC_RT_INFO_RATE 127 + +/** + * RIL_REQUEST_SET_DATA_PROFILE + * + * Set data profile in modem + * Modem should erase existed profiles from framework, and apply new profiles + * "data" is a const RIL_DataProfileInfo ** + * "datalen" is count * sizeof(const RIL_DataProfileInfo *) + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * SUBSCRIPTION_NOT_AVAILABLE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + */ +#define RIL_REQUEST_SET_DATA_PROFILE 128 + +/** + * RIL_REQUEST_SHUTDOWN + * + * Device is shutting down. All further commands are ignored + * and RADIO_NOT_AVAILABLE must be returned. + * + * "data" is null + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SHUTDOWN 129 + +/** + * RIL_REQUEST_GET_RADIO_CAPABILITY + * + * Used to get phone radio capablility. + * + * "data" is the RIL_RadioCapability structure + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * INVALID_STATE + * REQUEST_NOT_SUPPORTED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_GET_RADIO_CAPABILITY 130 + +/** + * RIL_REQUEST_SET_RADIO_CAPABILITY + * + * Used to set the phones radio capability. Be VERY careful + * using this request as it may cause some vendor modems to reset. Because + * of the possible modem reset any RIL commands after this one may not be + * processed. + * + * "data" is the RIL_RadioCapability structure + * + * "response" is the RIL_RadioCapability structure, used to feedback return status + * + * Valid errors: + * SUCCESS means a RIL_UNSOL_RADIO_CAPABILITY will be sent within 30 seconds. + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * MODEM_ERR + * INVALID_STATE + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SET_RADIO_CAPABILITY 131 + +/** + * RIL_REQUEST_START_LCE + * + * Start Link Capacity Estimate (LCE) service if supported by the radio. + * + * "data" is const int * + * ((const int*)data)[0] specifies the desired reporting interval (ms). + * ((const int*)data)[1] specifies the LCE service mode. 1: PULL; 0: PUSH. + * + * "response" is the RIL_LceStatusInfo. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * LCE_NOT_SUPPORTED + * INTERNAL_ERR + * REQUEST_NOT_SUPPORTED + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * SIM_ABSENT + */ +#define RIL_REQUEST_START_LCE 132 + +/** + * RIL_REQUEST_STOP_LCE + * + * Stop Link Capacity Estimate (LCE) service, the STOP operation should be + * idempotent for the radio modem. + * + * "response" is the RIL_LceStatusInfo. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * LCE_NOT_SUPPORTED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + */ +#define RIL_REQUEST_STOP_LCE 133 + +/** + * RIL_REQUEST_PULL_LCEDATA + * + * Pull LCE service for capacity information. + * + * "response" is the RIL_LceDataInfo. + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * LCE_NOT_SUPPORTED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + */ +#define RIL_REQUEST_PULL_LCEDATA 134 + +/** + * RIL_REQUEST_GET_ACTIVITY_INFO + * + * Get modem activity information for power consumption estimation. + * + * Request clear-on-read statistics information that is used for + * estimating the per-millisecond power consumption of the cellular + * modem. + * + * "data" is null + * "response" is const RIL_ActivityStatsInfo * + * + * Valid errors: + * + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * MODEM_ERR + * NOT_PROVISIONED + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES CANCELLED + */ +#define RIL_REQUEST_GET_ACTIVITY_INFO 135 + +/** + * RIL_REQUEST_SET_CARRIER_RESTRICTIONS + * + * Set carrier restrictions for this sim slot. Expected modem behavior: + * If never receives this command + * - Must allow all carriers + * Receives this command with data being NULL + * - Must allow all carriers. If a previously allowed SIM is present, modem must not reload + * the SIM. If a previously disallowed SIM is present, reload the SIM and notify Android. + * Receives this command with a list of carriers + * - Only allow specified carriers, persist across power cycles and FDR. If a present SIM + * is in the allowed list, modem must not reload the SIM. If a present SIM is *not* in + * the allowed list, modem must detach from the registered network and only keep emergency + * service, and notify Android SIM refresh reset with new SIM state being + * RIL_CARDSTATE_RESTRICTED. Emergency service must be enabled. + * + * "data" is const RIL_CarrierRestrictions * + * A list of allowed carriers and possibly a list of excluded carriers. + * If data is NULL, means to clear previous carrier restrictions and allow all carriers + * + * "response" is int * + * ((int *)data)[0] contains the number of allowed carriers which have been set correctly. + * On success, it should match the length of list data->allowed_carriers. + * If data is NULL, the value must be 0. + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_INVALID_ARGUMENTS + * RIL_E_RADIO_NOT_AVAILABLE + * RIL_E_REQUEST_NOT_SUPPORTED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SET_CARRIER_RESTRICTIONS 136 + +/** + * RIL_REQUEST_GET_CARRIER_RESTRICTIONS + * + * Get carrier restrictions for this sim slot. Expected modem behavior: + * Return list of allowed carriers, or null if all carriers are allowed. + * + * "data" is NULL + * + * "response" is const RIL_CarrierRestrictions *. + * If response is NULL, it means all carriers are allowed. + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_RADIO_NOT_AVAILABLE + * RIL_E_REQUEST_NOT_SUPPORTED + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_GET_CARRIER_RESTRICTIONS 137 + +/** + * RIL_REQUEST_SEND_DEVICE_STATE + * + * Send the updated device state. + * Modem can perform power saving based on the provided device state. + * "data" is const int * + * ((const int*)data)[0] A RIL_DeviceStateType that specifies the device state type. + * ((const int*)data)[1] Specifies the state. See RIL_DeviceStateType for the definition of each + * type. + * + * "datalen" is count * sizeof(const RIL_DeviceState *) + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * INVALID_ARGUMENTS + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SEND_DEVICE_STATE 138 + +/** + * RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER + * + * Set the unsolicited response filter + * This is used to prevent unnecessary application processor + * wake up for power saving purposes by suppressing the + * unsolicited responses in certain scenarios. + * + * "data" is an int * + * + * ((int *)data)[0] is a 32-bit bitmask of RIL_UnsolicitedResponseFilter + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * INVALID_ARGUMENTS (e.g. the requested filter doesn't exist) + * RADIO_NOT_AVAILABLE (radio resetting) + * NO_MEMORY + * INTERNAL_ERR + * SYSTEM_ERR + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SET_UNSOLICITED_RESPONSE_FILTER 139 + + /** + * RIL_REQUEST_SET_SIM_CARD_POWER + * + * Set SIM card power up or down + * + * Request is equivalent to inserting and removing the card, with + * an additional effect where the ability to detect card removal/insertion + * is disabled when the SIM card is powered down. + * + * This will generate RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED + * as if the SIM had been inserted or removed. + * + * "data" is int * + * ((int *)data)[0] is 1 for "SIM POWER UP" + * ((int *)data)[0] is 0 for "SIM POWER DOWN" + * + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * REQUEST_NOT_SUPPORTED + * SIM_ABSENT + * INVALID_ARGUMENTS + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SET_SIM_CARD_POWER 140 + +/** + * RIL_REQUEST_SET_CARRIER_INFO_IMSI_ENCRYPTION + * + * Provide Carrier specific information to the modem that will be used to + * encrypt the IMSI and IMPI. Sent by the framework during boot, carrier + * switch and everytime we receive a new certificate. + * + * "data" is the RIL_CarrierInfoForImsiEncryption * structure. + * + * "response" is NULL + * + * Valid errors: + * RIL_E_SUCCESS + * RIL_E_RADIO_NOT_AVAILABLE + * SIM_ABSENT + * RIL_E_REQUEST_NOT_SUPPORTED + * INVALID_ARGUMENTS + * MODEM_INTERNAL_FAILURE + * INTERNAL_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + */ +#define RIL_REQUEST_SET_CARRIER_INFO_IMSI_ENCRYPTION 141 + +/** + * RIL_REQUEST_START_NETWORK_SCAN + * + * Starts a new network scan + * + * Request to start a network scan with specified radio access networks with frequency bands and/or + * channels. + * + * "data" is a const RIL_NetworkScanRequest *. + * "response" is NULL + * + * Valid errors: + * SUCCESS + * RADIO_NOT_AVAILABLE + * OPERATION_NOT_ALLOWED + * DEVICE_IN_USE + * INTERNAL_ERR + * NO_MEMORY + * MODEM_ERR + * INVALID_ARGUMENTS + * REQUEST_NOT_SUPPORTED + * NO_RESOURCES + * CANCELLED + * + */ +#define RIL_REQUEST_START_NETWORK_SCAN 142 + +/** + * RIL_REQUEST_STOP_NETWORK_SCAN + * + * Stops an ongoing network scan + * + * Request to stop the ongoing network scan. Since the modem can only perform one scan at a time, + * there is no parameter for this request. + * + * "data" is NULL + * "response" is NULL + * + * Valid errors: + * SUCCESS + * INTERNAL_ERR + * MODEM_ERR + * NO_MEMORY + * NO_RESOURCES + * CANCELLED + * REQUEST_NOT_SUPPORTED + * + */ +#define RIL_REQUEST_STOP_NETWORK_SCAN 143 + +/** + * RIL_REQUEST_START_KEEPALIVE + * + * Start a keepalive session + * + * Request that the modem begin sending keepalive packets on a particular + * data call, with a specified source, destination, and format. + * + * "data" is a const RIL_RequestKeepalive + * "response" is RIL_KeepaliveStatus with a valid "handle" + * + * Valid errors: + * SUCCESS + * NO_RESOURCES + * INVALID_ARGUMENTS + * + */ +#define RIL_REQUEST_START_KEEPALIVE 144 + +/** + * RIL_REQUEST_STOP_KEEPALIVE + * + * Stops an ongoing keepalive session + * + * Requests that a keepalive session with the given handle be stopped. + * there is no parameter for this request. + * + * "data" is an integer handle + * "response" is NULL + * + * Valid errors: + * SUCCESS + * INVALID_ARGUMENTS + * + */ +#define RIL_REQUEST_STOP_KEEPALIVE 145 + +/***********************************************************************/ + +/** + * RIL_RESPONSE_ACKNOWLEDGEMENT + * + * This is used by Asynchronous solicited messages and Unsolicited messages + * to acknowledge the receipt of those messages in RIL.java so that the ack + * can be used to let ril.cpp to release wakelock. + * + * Valid errors + * SUCCESS + * RADIO_NOT_AVAILABLE + */ + +#define RIL_RESPONSE_ACKNOWLEDGEMENT 800 + +/***********************************************************************/ + + +#define RIL_UNSOL_RESPONSE_BASE 1000 + +/** + * RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED + * + * Indicate when value of RIL_RadioState has changed. + * + * Callee will invoke RIL_RadioStateRequest method on main thread + * + * "data" is NULL + */ + +#define RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED 1000 + + +/** + * RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED + * + * Indicate when call state has changed + * + * Callee will invoke RIL_REQUEST_GET_CURRENT_CALLS on main thread + * + * "data" is NULL + * + * Response should be invoked on, for example, + * "RING", "BUSY", "NO CARRIER", and also call state + * transitions (DIALING->ALERTING ALERTING->ACTIVE) + * + * Redundent or extraneous invocations are tolerated + */ +#define RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED 1001 + + +/** + * RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED + * + * Called when the voice network state changed + * + * Callee will invoke the following requests on main thread: + * + * RIL_REQUEST_VOICE_REGISTRATION_STATE + * RIL_REQUEST_OPERATOR + * + * "data" is NULL + * + * FIXME should this happen when SIM records are loaded? (eg, for + * EONS) + */ +#define RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED 1002 + +/** + * RIL_UNSOL_RESPONSE_NEW_SMS + * + * Called when new SMS is received. + * + * "data" is const char * + * This is a pointer to a string containing the PDU of an SMS-DELIVER + * as an ascii string of hex digits. The PDU starts with the SMSC address + * per TS 27.005 (+CMT:) + * + * Callee will subsequently confirm the receipt of thei SMS with a + * RIL_REQUEST_SMS_ACKNOWLEDGE + * + * No new RIL_UNSOL_RESPONSE_NEW_SMS + * or RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT messages should be sent until a + * RIL_REQUEST_SMS_ACKNOWLEDGE has been received + */ + +#define RIL_UNSOL_RESPONSE_NEW_SMS 1003 + +/** + * RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT + * + * Called when new SMS Status Report is received. + * + * "data" is const char * + * This is a pointer to a string containing the PDU of an SMS-STATUS-REPORT + * as an ascii string of hex digits. The PDU starts with the SMSC address + * per TS 27.005 (+CDS:). + * + * Callee will subsequently confirm the receipt of the SMS with a + * RIL_REQUEST_SMS_ACKNOWLEDGE + * + * No new RIL_UNSOL_RESPONSE_NEW_SMS + * or RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT messages should be sent until a + * RIL_REQUEST_SMS_ACKNOWLEDGE has been received + */ + +#define RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT 1004 + +/** + * RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM + * + * Called when new SMS has been stored on SIM card + * + * "data" is const int * + * ((const int *)data)[0] contains the slot index on the SIM that contains + * the new message + */ + +#define RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM 1005 + +/** + * RIL_UNSOL_ON_USSD + * + * Called when a new USSD message is received. + * + * "data" is const char ** + * ((const char **)data)[0] points to a type code, which is + * one of these string values: + * "0" USSD-Notify -- text in ((const char **)data)[1] + * "1" USSD-Request -- text in ((const char **)data)[1] + * "2" Session terminated by network + * "3" other local client (eg, SIM Toolkit) has responded + * "4" Operation not supported + * "5" Network timeout + * + * The USSD session is assumed to persist if the type code is "1", otherwise + * the current session (if any) is assumed to have terminated. + * + * ((const char **)data)[1] points to a message string if applicable, which + * should always be in UTF-8. + */ +#define RIL_UNSOL_ON_USSD 1006 +/* Previously #define RIL_UNSOL_ON_USSD_NOTIFY 1006 */ + +/** + * RIL_UNSOL_ON_USSD_REQUEST + * + * Obsolete. Send via RIL_UNSOL_ON_USSD + */ +#define RIL_UNSOL_ON_USSD_REQUEST 1007 + +/** + * RIL_UNSOL_NITZ_TIME_RECEIVED + * + * Called when radio has received a NITZ time message + * + * "data" is const char * pointing to NITZ time string + * in the form "yy/mm/dd,hh:mm:ss(+/-)tz,dt" + */ +#define RIL_UNSOL_NITZ_TIME_RECEIVED 1008 + +/** + * RIL_UNSOL_SIGNAL_STRENGTH + * + * Radio may report signal strength rather han have it polled. + * + * "data" is a const RIL_SignalStrength * + */ +#define RIL_UNSOL_SIGNAL_STRENGTH 1009 + + +/** + * RIL_UNSOL_DATA_CALL_LIST_CHANGED + * + * "data" is an array of RIL_Data_Call_Response_v6 identical to that + * returned by RIL_REQUEST_DATA_CALL_LIST. It is the complete list + * of current data contexts including new contexts that have been + * activated. A data call is only removed from this list when the + * framework sends a RIL_REQUEST_DEACTIVATE_DATA_CALL or the radio + * is powered off/on. + * + * See also: RIL_REQUEST_DATA_CALL_LIST + */ + +#define RIL_UNSOL_DATA_CALL_LIST_CHANGED 1010 + +/** + * RIL_UNSOL_SUPP_SVC_NOTIFICATION + * + * Reports supplementary service related notification from the network. + * + * "data" is a const RIL_SuppSvcNotification * + * + */ + +#define RIL_UNSOL_SUPP_SVC_NOTIFICATION 1011 + +/** + * RIL_UNSOL_STK_SESSION_END + * + * Indicate when STK session is terminated by SIM. + * + * "data" is NULL + */ +#define RIL_UNSOL_STK_SESSION_END 1012 + +/** + * RIL_UNSOL_STK_PROACTIVE_COMMAND + * + * Indicate when SIM issue a STK proactive command to applications + * + * "data" is a const char * containing SAT/USAT proactive command + * in hexadecimal format string starting with command tag + * + */ +#define RIL_UNSOL_STK_PROACTIVE_COMMAND 1013 + +/** + * RIL_UNSOL_STK_EVENT_NOTIFY + * + * Indicate when SIM notifies applcations some event happens. + * Generally, application does not need to have any feedback to + * SIM but shall be able to indicate appropriate messages to users. + * + * "data" is a const char * containing SAT/USAT commands or responses + * sent by ME to SIM or commands handled by ME, in hexadecimal format string + * starting with first byte of response data or command tag + * + */ +#define RIL_UNSOL_STK_EVENT_NOTIFY 1014 + +/** + * RIL_UNSOL_STK_CALL_SETUP + * + * Indicate when SIM wants application to setup a voice call. + * + * "data" is const int * + * ((const int *)data)[0] contains timeout value (in milliseconds) + */ +#define RIL_UNSOL_STK_CALL_SETUP 1015 + +/** + * RIL_UNSOL_SIM_SMS_STORAGE_FULL + * + * Indicates that SMS storage on the SIM is full. Sent when the network + * attempts to deliver a new SMS message. Messages cannot be saved on the + * SIM until space is freed. In particular, incoming Class 2 messages + * cannot be stored. + * + * "data" is null + * + */ +#define RIL_UNSOL_SIM_SMS_STORAGE_FULL 1016 + +/** + * RIL_UNSOL_SIM_REFRESH + * + * Indicates that file(s) on the SIM have been updated, or the SIM + * has been reinitialized. + * + * In the case where RIL is version 6 or older: + * "data" is an int * + * ((int *)data)[0] is a RIL_SimRefreshResult. + * ((int *)data)[1] is the EFID of the updated file if the result is + * SIM_FILE_UPDATE or NULL for any other result. + * + * In the case where RIL is version 7: + * "data" is a RIL_SimRefreshResponse_v7 * + * + * Note: If the SIM state changes as a result of the SIM refresh (eg, + * SIM_READY -> SIM_LOCKED_OR_ABSENT), RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED + * should be sent. + */ +#define RIL_UNSOL_SIM_REFRESH 1017 + +/** + * RIL_UNSOL_CALL_RING + * + * Ring indication for an incoming call (eg, RING or CRING event). + * There must be at least one RIL_UNSOL_CALL_RING at the beginning + * of a call and sending multiple is optional. If the system property + * ro.telephony.call_ring.multiple is false then the upper layers + * will generate the multiple events internally. Otherwise the vendor + * ril must generate multiple RIL_UNSOL_CALL_RING if + * ro.telephony.call_ring.multiple is true or if it is absent. + * + * The rate of these events is controlled by ro.telephony.call_ring.delay + * and has a default value of 3000 (3 seconds) if absent. + * + * "data" is null for GSM + * "data" is const RIL_CDMA_SignalInfoRecord * if CDMA + */ +#define RIL_UNSOL_CALL_RING 1018 + +/** + * RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED + * + * Indicates that SIM state changes. + * + * Callee will invoke RIL_REQUEST_GET_SIM_STATUS on main thread + + * "data" is null + */ +#define RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED 1019 + +/** + * RIL_UNSOL_RESPONSE_CDMA_NEW_SMS + * + * Called when new CDMA SMS is received + * + * "data" is const RIL_CDMA_SMS_Message * + * + * Callee will subsequently confirm the receipt of the SMS with + * a RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE + * + * No new RIL_UNSOL_RESPONSE_CDMA_NEW_SMS should be sent until + * RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE has been received + * + */ +#define RIL_UNSOL_RESPONSE_CDMA_NEW_SMS 1020 + +/** + * RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS + * + * Called when new Broadcast SMS is received + * + * "data" can be one of the following: + * If received from GSM network, "data" is const char of 88 bytes + * which indicates each page of a CBS Message sent to the MS by the + * BTS as coded in 3GPP 23.041 Section 9.4.1.2. + * If received from UMTS network, "data" is const char of 90 up to 1252 + * bytes which contain between 1 and 15 CBS Message pages sent as one + * packet to the MS by the BTS as coded in 3GPP 23.041 Section 9.4.2.2. + * + */ +#define RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS 1021 + +/** + * RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL + * + * Indicates that SMS storage on the RUIM is full. Messages + * cannot be saved on the RUIM until space is freed. + * + * "data" is null + * + */ +#define RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL 1022 + +/** + * RIL_UNSOL_RESTRICTED_STATE_CHANGED + * + * Indicates a restricted state change (eg, for Domain Specific Access Control). + * + * Radio need send this msg after radio off/on cycle no matter it is changed or not. + * + * "data" is an int * + * ((int *)data)[0] contains a bitmask of RIL_RESTRICTED_STATE_* values. + */ +#define RIL_UNSOL_RESTRICTED_STATE_CHANGED 1023 + +/** + * RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE + * + * Indicates that the radio system selection module has + * autonomously entered emergency callback mode. + * + * "data" is null + * + */ +#define RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE 1024 + +/** + * RIL_UNSOL_CDMA_CALL_WAITING + * + * Called when CDMA radio receives a call waiting indication. + * + * "data" is const RIL_CDMA_CallWaiting * + * + */ +#define RIL_UNSOL_CDMA_CALL_WAITING 1025 + +/** + * RIL_UNSOL_CDMA_OTA_PROVISION_STATUS + * + * Called when CDMA radio receives an update of the progress of an + * OTASP/OTAPA call. + * + * "data" is const int * + * For CDMA this is an integer OTASP/OTAPA status listed in + * RIL_CDMA_OTA_ProvisionStatus. + * + */ +#define RIL_UNSOL_CDMA_OTA_PROVISION_STATUS 1026 + +/** + * RIL_UNSOL_CDMA_INFO_REC + * + * Called when CDMA radio receives one or more info recs. + * + * "data" is const RIL_CDMA_InformationRecords * + * + */ +#define RIL_UNSOL_CDMA_INFO_REC 1027 + +/** + * RIL_UNSOL_OEM_HOOK_RAW + * + * This is for OEM specific use. + * + * "data" is a byte[] + */ +#define RIL_UNSOL_OEM_HOOK_RAW 1028 + +/** + * RIL_UNSOL_RINGBACK_TONE + * + * Indicates that nework doesn't have in-band information, need to + * play out-band tone. + * + * "data" is an int * + * ((int *)data)[0] == 0 for stop play ringback tone. + * ((int *)data)[0] == 1 for start play ringback tone. + */ +#define RIL_UNSOL_RINGBACK_TONE 1029 + +/** + * RIL_UNSOL_RESEND_INCALL_MUTE + * + * Indicates that framework/application need reset the uplink mute state. + * + * There may be situations where the mute state becomes out of sync + * between the application and device in some GSM infrastructures. + * + * "data" is null + */ +#define RIL_UNSOL_RESEND_INCALL_MUTE 1030 + +/** + * RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED + * + * Called when CDMA subscription source changed. + * + * "data" is int * + * ((int *)data)[0] is == RIL_CdmaSubscriptionSource + */ +#define RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED 1031 + +/** + * RIL_UNSOL_CDMA_PRL_CHANGED + * + * Called when PRL (preferred roaming list) changes. + * + * "data" is int * + * ((int *)data)[0] is PRL_VERSION as would be returned by RIL_REQUEST_CDMA_SUBSCRIPTION + */ +#define RIL_UNSOL_CDMA_PRL_CHANGED 1032 + +/** + * RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE + * + * Called when Emergency Callback Mode Ends + * + * Indicates that the radio system selection module has + * proactively exited emergency callback mode. + * + * "data" is NULL + * + */ +#define RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE 1033 + +/** + * RIL_UNSOL_RIL_CONNECTED + * + * Called the ril connects and returns the version + * + * "data" is int * + * ((int *)data)[0] is RIL_VERSION + */ +#define RIL_UNSOL_RIL_CONNECTED 1034 + +/** + * RIL_UNSOL_VOICE_RADIO_TECH_CHANGED + * + * Indicates that voice technology has changed. Contains new radio technology + * as a data in the message. + * + * "data" is int * + * ((int *)data)[0] is of type const RIL_RadioTechnology + * + */ +#define RIL_UNSOL_VOICE_RADIO_TECH_CHANGED 1035 + +/** + * RIL_UNSOL_CELL_INFO_LIST + * + * Same information as returned by RIL_REQUEST_GET_CELL_INFO_LIST, but returned + * at the rate no greater than specified by RIL_REQUEST_SET_UNSOL_CELL_INFO_RATE. + * + * "data" is NULL + * + * "response" is an array of RIL_CellInfo_v12. + */ +#define RIL_UNSOL_CELL_INFO_LIST 1036 + +/** + * RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED + * + * This message is DEPRECATED and shall be removed in a future release (target: 2018); + * instead, provide IMS registration status via an IMS Service. + * + * Called when IMS registration state has changed + * + * To get IMS registration state and IMS SMS format, callee needs to invoke the + * following request on main thread: + * + * RIL_REQUEST_IMS_REGISTRATION_STATE + * + * "data" is NULL + * + */ +#define RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED 1037 + +/** + * RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED + * + * Indicated when there is a change in subscription status. + * This event will be sent in the following scenarios + * - subscription readiness at modem, which was selected by telephony layer + * - when subscription is deactivated by modem due to UICC card removal + * - When network invalidates the subscription i.e. attach reject due to authentication reject + * + * "data" is const int * + * ((const int *)data)[0] == 0 for Subscription Deactivated + * ((const int *)data)[0] == 1 for Subscription Activated + * + */ +#define RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED 1038 + +/** + * RIL_UNSOL_SRVCC_STATE_NOTIFY + * + * Called when Single Radio Voice Call Continuity(SRVCC) + * progress state has changed + * + * "data" is int * + * ((int *)data)[0] is of type const RIL_SrvccState + * + */ + +#define RIL_UNSOL_SRVCC_STATE_NOTIFY 1039 + +/** + * RIL_UNSOL_HARDWARE_CONFIG_CHANGED + * + * Called when the hardware configuration associated with the RILd changes + * + * "data" is an array of RIL_HardwareConfig + * + */ +#define RIL_UNSOL_HARDWARE_CONFIG_CHANGED 1040 + +/** + * RIL_UNSOL_DC_RT_INFO_CHANGED + * + * The message is DEPRECATED, use RIL_REQUEST_GET_ACTIVITY_INFO + * Sent when the DC_RT_STATE changes but the time + * between these messages must not be less than the + * value set by RIL_REQUEST_SET_DC_RT_RATE. + * + * "data" is the most recent RIL_DcRtInfo + * + */ +#define RIL_UNSOL_DC_RT_INFO_CHANGED 1041 + +/** + * RIL_UNSOL_RADIO_CAPABILITY + * + * Sent when RIL_REQUEST_SET_RADIO_CAPABILITY completes. + * Returns the phone radio capability exactly as + * RIL_REQUEST_GET_RADIO_CAPABILITY and should be the + * same set as sent by RIL_REQUEST_SET_RADIO_CAPABILITY. + * + * "data" is the RIL_RadioCapability structure + */ +#define RIL_UNSOL_RADIO_CAPABILITY 1042 + +/* + * RIL_UNSOL_ON_SS + * + * Called when SS response is received when DIAL/USSD/SS is changed to SS by + * call control. + * + * "data" is const RIL_StkCcUnsolSsResponse * + * + */ +#define RIL_UNSOL_ON_SS 1043 + +/** + * RIL_UNSOL_STK_CC_ALPHA_NOTIFY + * + * Called when there is an ALPHA from UICC during Call Control. + * + * "data" is const char * containing ALPHA string from UICC in UTF-8 format. + * + */ +#define RIL_UNSOL_STK_CC_ALPHA_NOTIFY 1044 + +/** + * RIL_UNSOL_LCEDATA_RECV + * + * Called when there is an incoming Link Capacity Estimate (LCE) info report. + * + * "data" is the RIL_LceDataInfo structure. + * + */ +#define RIL_UNSOL_LCEDATA_RECV 1045 + + /** + * RIL_UNSOL_PCO_DATA + * + * Called when there is new Carrier PCO data received for a data call. Ideally + * only new data will be forwarded, though this is not required. Multiple + * boxes of carrier PCO data for a given call should result in a series of + * RIL_UNSOL_PCO_DATA calls. + * + * "data" is the RIL_PCO_Data structure. + * + */ +#define RIL_UNSOL_PCO_DATA 1046 + + /** + * RIL_UNSOL_MODEM_RESTART + * + * Called when there is a modem reset. + * + * "reason" is "const char *" containing the reason for the reset. It + * could be a crash signature if the restart was due to a crash or some + * string such as "user-initiated restart" or "AT command initiated + * restart" that explains the cause of the modem restart. + * + * When modem restarts, one of the following radio state transitions will happen + * 1) RADIO_STATE_ON->RADIO_STATE_UNAVAILABLE->RADIO_STATE_ON or + * 2) RADIO_STATE_OFF->RADIO_STATE_UNAVAILABLE->RADIO_STATE_OFF + * This message can be sent either just before the RADIO_STATE changes to RADIO_STATE_UNAVAILABLE + * or just after but should never be sent after the RADIO_STATE changes from UNAVAILABLE to + * AVAILABLE(RADIO_STATE_ON/RADIO_STATE_OFF) again. + * + * It should NOT be sent after the RADIO_STATE changes to AVAILABLE after the + * modem restart as that could be interpreted as a second modem reset by the + * framework. + */ +#define RIL_UNSOL_MODEM_RESTART 1047 + +/** + * RIL_UNSOL_CARRIER_INFO_IMSI_ENCRYPTION + * + * Called when the modem needs Carrier specific information that will + * be used to encrypt IMSI and IMPI. + * + * "data" is NULL + * + */ +#define RIL_UNSOL_CARRIER_INFO_IMSI_ENCRYPTION 1048 + +/** + * RIL_UNSOL_NETWORK_SCAN_RESULT + * + * Returns incremental result for the network scan which is started by + * RIL_REQUEST_START_NETWORK_SCAN, sent to report results, status, or errors. + * + * "data" is NULL + * "response" is a const RIL_NetworkScanResult * + */ +#define RIL_UNSOL_NETWORK_SCAN_RESULT 1049 + +/** + * RIL_UNSOL_KEEPALIVE_STATUS + * + * "data" is NULL + * "response" is a const RIL_KeepaliveStatus * + */ +#define RIL_UNSOL_KEEPALIVE_STATUS 1050 + +/***********************************************************************/ + + +#if defined(ANDROID_MULTI_SIM) +/** + * RIL_Request Function pointer + * + * @param request is one of RIL_REQUEST_* + * @param data is pointer to data defined for that RIL_REQUEST_* + * data is owned by caller, and should not be modified or freed by callee + * structures passed as data may contain pointers to non-contiguous memory + * @param t should be used in subsequent call to RIL_onResponse + * @param datalen is the length of "data" which is defined as other argument. It may or may + * not be equal to sizeof(data). Refer to the documentation of individual structures + * to find if pointers listed in the structure are contiguous and counted in the datalen + * length or not. + * (Eg: RIL_IMS_SMS_Message where we don't have datalen equal to sizeof(data)) + * + */ +typedef void (*RIL_RequestFunc) (int request, void *data, + size_t datalen, RIL_Token t, RIL_SOCKET_ID socket_id); + +/** + * This function should return the current radio state synchronously + */ +typedef RIL_RadioState (*RIL_RadioStateRequest)(RIL_SOCKET_ID socket_id); + +#else +/* Backward compatible */ + +/** + * RIL_Request Function pointer + * + * @param request is one of RIL_REQUEST_* + * @param data is pointer to data defined for that RIL_REQUEST_* + * data is owned by caller, and should not be modified or freed by callee + * structures passed as data may contain pointers to non-contiguous memory + * @param t should be used in subsequent call to RIL_onResponse + * @param datalen is the length of "data" which is defined as other argument. It may or may + * not be equal to sizeof(data). Refer to the documentation of individual structures + * to find if pointers listed in the structure are contiguous and counted in the datalen + * length or not. + * (Eg: RIL_IMS_SMS_Message where we don't have datalen equal to sizeof(data)) + * + */ +typedef void (*RIL_RequestFunc) (int request, void *data, + size_t datalen, RIL_Token t); + +/** + * This function should return the current radio state synchronously + */ +typedef RIL_RadioState (*RIL_RadioStateRequest)(); + +#endif + + +/** + * This function returns "1" if the specified RIL_REQUEST code is + * supported and 0 if it is not + * + * @param requestCode is one of RIL_REQUEST codes + */ + +typedef int (*RIL_Supports)(int requestCode); + +/** + * This function is called from a separate thread--not the + * thread that calls RIL_RequestFunc--and indicates that a pending + * request should be cancelled. + * + * On cancel, the callee should do its best to abandon the request and + * call RIL_onRequestComplete with RIL_Errno CANCELLED at some later point. + * + * Subsequent calls to RIL_onRequestComplete for this request with + * other results will be tolerated but ignored. (That is, it is valid + * to ignore the cancellation request) + * + * RIL_Cancel calls should return immediately, and not wait for cancellation + * + * Please see ITU v.250 5.6.1 for how one might implement this on a TS 27.007 + * interface + * + * @param t token wants to be canceled + */ + +typedef void (*RIL_Cancel)(RIL_Token t); + +typedef void (*RIL_TimedCallback) (void *param); + +/** + * Return a version string for your RIL implementation + */ +typedef const char * (*RIL_GetVersion) (void); + +typedef struct { + int version; /* set to RIL_VERSION */ + RIL_RequestFunc onRequest; + RIL_RadioStateRequest onStateRequest; + RIL_Supports supports; + RIL_Cancel onCancel; + RIL_GetVersion getVersion; +} RIL_RadioFunctions; + +typedef struct { + char *apn; /* the APN to connect to */ + char *protocol; /* one of the PDP_type values in TS 27.007 section 10.1.1 used on + roaming network. For example, "IP", "IPV6", "IPV4V6", or "PPP".*/ + int authtype; /* authentication protocol used for this PDP context + (None: 0, PAP: 1, CHAP: 2, PAP&CHAP: 3) */ + char *username; /* the username for APN, or NULL */ + char *password; /* the password for APN, or NULL */ +} RIL_InitialAttachApn; + +typedef struct { + char *apn; /* the APN to connect to */ + char *protocol; /* one of the PDP_type values in TS 27.007 section 10.1.1 used on + home network. For example, "IP", "IPV6", "IPV4V6", or "PPP". */ + char *roamingProtocol; /* one of the PDP_type values in TS 27.007 section 10.1.1 used on + roaming network. For example, "IP", "IPV6", "IPV4V6", or "PPP".*/ + int authtype; /* authentication protocol used for this PDP context + (None: 0, PAP: 1, CHAP: 2, PAP&CHAP: 3) */ + char *username; /* the username for APN, or NULL */ + char *password; /* the password for APN, or NULL */ + int supportedTypesBitmask; /* supported APN types bitmask. See RIL_ApnTypes for the value of + each bit. */ + int bearerBitmask; /* the bearer bitmask. See RIL_RadioAccessFamily for the value of + each bit. */ + int modemCognitive; /* indicating the APN setting was sent to the modem through + setDataProfile earlier. */ + int mtu; /* maximum transmission unit (MTU) size in bytes */ + char *mvnoType; /* the MVNO type: possible values are "imsi", "gid", "spn" */ + char *mvnoMatchData; /* MVNO match data. Can be anything defined by the carrier. + For example, + SPN like: "A MOBILE", "BEN NL", etc... + IMSI like: "302720x94", "2060188", etc... + GID like: "4E", "33", etc... */ +} RIL_InitialAttachApn_v15; + +typedef struct { + int authContext; /* P2 value of authentication command, see P2 parameter in + 3GPP TS 31.102 7.1.2 */ + char *authData; /* the challenge string in Base64 format, see 3GPP + TS 31.102 7.1.2 */ + char *aid; /* AID value, See ETSI 102.221 8.1 and 101.220 4, + NULL if no value. */ +} RIL_SimAuthentication; + +typedef struct { + int cid; /* Context ID, uniquely identifies this call */ + char *bearer_proto; /* One of the PDP_type values in TS 27.007 section 10.1.1. + For example, "IP", "IPV6", "IPV4V6". */ + int pco_id; /* The protocol ID for this box. Note that only IDs from + FF00H - FFFFH are accepted. If more than one is included + from the network, multiple calls should be made to send all + of them. */ + int contents_length; /* The number of octets in the contents. */ + char *contents; /* Carrier-defined content. It is binary, opaque and + loosely defined in LTE Layer 3 spec 24.008 */ +} RIL_PCO_Data; + +typedef enum { + NATT_IPV4 = 0, /* Keepalive specified by RFC 3948 Sec. 2.3 using IPv4 */ + NATT_IPV6 = 1 /* Keepalive specified by RFC 3948 Sec. 2.3 using IPv6 */ +} RIL_KeepaliveType; + +#define MAX_INADDR_LEN 16 +typedef struct { + RIL_KeepaliveType type; /* Type of keepalive packet */ + char sourceAddress[MAX_INADDR_LEN]; /* Source address in network-byte order */ + int sourcePort; /* Source port if applicable, or 0x7FFFFFFF; + the maximum value is 65535 */ + char destinationAddress[MAX_INADDR_LEN]; /* Destination address in network-byte order */ + int destinationPort; /* Destination port if applicable or 0x7FFFFFFF; + the maximum value is 65535 */ + int maxKeepaliveIntervalMillis; /* Maximum milliseconds between two packets */ + int cid; /* Context ID, uniquely identifies this call */ +} RIL_KeepaliveRequest; + +typedef enum { + KEEPALIVE_ACTIVE, /* Keepalive session is active */ + KEEPALIVE_INACTIVE, /* Keepalive session is inactive */ + KEEPALIVE_PENDING /* Keepalive session status not available */ +} RIL_KeepaliveStatusCode; + +typedef struct { + uint32_t sessionHandle; + RIL_KeepaliveStatusCode code; +} RIL_KeepaliveStatus; + +#ifdef RIL_SHLIB +struct RIL_Env { + /** + * "t" is parameter passed in on previous call to RIL_Notification + * routine. + * + * If "e" != SUCCESS, then response can be null/is ignored + * + * "response" is owned by caller, and should not be modified or + * freed by callee + * + * RIL_onRequestComplete will return as soon as possible + */ + void (*OnRequestComplete)(RIL_Token t, RIL_Errno e, + void *response, size_t responselen); + +#if defined(ANDROID_MULTI_SIM) + /** + * "unsolResponse" is one of RIL_UNSOL_RESPONSE_* + * "data" is pointer to data defined for that RIL_UNSOL_RESPONSE_* + * + * "data" is owned by caller, and should not be modified or freed by callee + */ + void (*OnUnsolicitedResponse)(int unsolResponse, const void *data, size_t datalen, RIL_SOCKET_ID socket_id); +#else + /** + * "unsolResponse" is one of RIL_UNSOL_RESPONSE_* + * "data" is pointer to data defined for that RIL_UNSOL_RESPONSE_* + * + * "data" is owned by caller, and should not be modified or freed by callee + */ + void (*OnUnsolicitedResponse)(int unsolResponse, const void *data, size_t datalen); +#endif + /** + * Call user-specifed "callback" function on on the same thread that + * RIL_RequestFunc is called. If "relativeTime" is specified, then it specifies + * a relative time value at which the callback is invoked. If relativeTime is + * NULL or points to a 0-filled structure, the callback will be invoked as + * soon as possible + */ + + void (*RequestTimedCallback) (RIL_TimedCallback callback, + void *param, const struct timeval *relativeTime); + /** + * "t" is parameter passed in on previous call RIL_Notification routine + * + * RIL_onRequestAck will be called by vendor when an Async RIL request was received + * by them and an ack needs to be sent back to java ril. + */ + void (*OnRequestAck) (RIL_Token t); +}; + + +/** + * RIL implementations must defined RIL_Init + * argc and argv will be command line arguments intended for the RIL implementation + * Return NULL on error + * + * @param env is environment point defined as RIL_Env + * @param argc number of arguments + * @param argv list fo arguments + * + */ +const RIL_RadioFunctions *RIL_Init(const struct RIL_Env *env, int argc, char **argv); + +/** + * If BT SAP(SIM Access Profile) is supported, then RIL implementations must define RIL_SAP_Init + * for initializing RIL_RadioFunctions used for BT SAP communcations. It is called whenever RILD + * starts or modem restarts. Returns handlers for SAP related request that are made on SAP + * sepecific socket, analogous to the RIL_RadioFunctions returned by the call to RIL_Init + * and used on the general RIL socket. + * argc and argv will be command line arguments intended for the RIL implementation + * Return NULL on error. + * + * @param env is environment point defined as RIL_Env + * @param argc number of arguments + * @param argv list fo arguments + * + */ +const RIL_RadioFunctions *RIL_SAP_Init(const struct RIL_Env *env, int argc, char **argv); + +#else /* RIL_SHLIB */ + +/** + * Call this once at startup to register notification routine + * + * @param callbacks user-specifed callback function + */ +void RIL_register (const RIL_RadioFunctions *callbacks); + +void rilc_thread_pool(); + + +/** + * + * RIL_onRequestComplete will return as soon as possible + * + * @param t is parameter passed in on previous call to RIL_Notification + * routine. + * @param e error code + * if "e" != SUCCESS, then response can be null/is ignored + * @param response is owned by caller, and should not be modified or + * freed by callee + * @param responselen the length of response in byte + */ +void RIL_onRequestComplete(RIL_Token t, RIL_Errno e, + void *response, size_t responselen); + +/** + * RIL_onRequestAck will be called by vendor when an Async RIL request was received by them and + * an ack needs to be sent back to java ril. This doesn't mark the end of the command or it's + * results, just that the command was received and will take a while. After sending this Ack + * its vendor's responsibility to make sure that AP is up whenever needed while command is + * being processed. + * + * @param t is parameter passed in on previous call to RIL_Notification + * routine. + */ +void RIL_onRequestAck(RIL_Token t); + +#if defined(ANDROID_MULTI_SIM) +/** + * @param unsolResponse is one of RIL_UNSOL_RESPONSE_* + * @param data is pointer to data defined for that RIL_UNSOL_RESPONSE_* + * "data" is owned by caller, and should not be modified or freed by callee + * @param datalen the length of data in byte + */ + +void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, + size_t datalen, RIL_SOCKET_ID socket_id); +#else +/** + * @param unsolResponse is one of RIL_UNSOL_RESPONSE_* + * @param data is pointer to data defined for that RIL_UNSOL_RESPONSE_* + * "data" is owned by caller, and should not be modified or freed by callee + * @param datalen the length of data in byte + */ + +void RIL_onUnsolicitedResponse(int unsolResponse, const void *data, + size_t datalen); +#endif + +/** + * Call user-specifed "callback" function on on the same thread that + * RIL_RequestFunc is called. If "relativeTime" is specified, then it specifies + * a relative time value at which the callback is invoked. If relativeTime is + * NULL or points to a 0-filled structure, the callback will be invoked as + * soon as possible + * + * @param callback user-specifed callback function + * @param param parameter list + * @param relativeTime a relative time value at which the callback is invoked + */ + +void RIL_requestTimedCallback (RIL_TimedCallback callback, + void *param, const struct timeval *relativeTime); + +#endif /* RIL_SHLIB */ + +#ifdef __cplusplus +} +#endif + +#endif /*ANDROID_RIL_H*/ -- cgit v1.2.3 From 268c72fe011fdaeac8fb68bcb6abf938e3175088 Mon Sep 17 00:00:00 2001 From: bohu Date: Sat, 9 Jun 2018 08:19:08 -0700 Subject: goldfish: add vendor.mk This vendor.mk contains emulator specific vendor/data partition configurations and packages. BUG: 110030159 Nothing here should impact system partition. Change-Id: I41aa0659159e977bfeae9eeac438701090fb5756 --- arm32-vendor.mk | 12 +++++ arm64-vendor.mk | 12 +++++ vendor.mk | 147 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ x86-vendor.mk | 13 +++++ x86_64-vendor.mk | 13 +++++ 5 files changed, 197 insertions(+) create mode 100644 arm32-vendor.mk create mode 100644 arm64-vendor.mk create mode 100644 vendor.mk create mode 100644 x86-vendor.mk create mode 100644 x86_64-vendor.mk diff --git a/arm32-vendor.mk b/arm32-vendor.mk new file mode 100644 index 0000000..3209c4a --- /dev/null +++ b/arm32-vendor.mk @@ -0,0 +1,12 @@ + +PRODUCT_PROPERTY_OVERRIDES += \ + vendor.rild.libpath=/vendor/lib/libreference-ril.so + +# Note: the following lines need to stay at the beginning so that it can +# take priority and override the rules it inherit from other mk files +# see copy file rules in core/Makefile +PRODUCT_COPY_FILES += \ + development/sys-img/advancedFeatures.ini.arm:advancedFeatures.ini \ + prebuilts/qemu-kernel/arm64/3.18/kernel-qemu2:kernel-ranchu-64 \ + device/generic/goldfish/fstab.ranchu.arm:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.ranchu + diff --git a/arm64-vendor.mk b/arm64-vendor.mk new file mode 100644 index 0000000..7696a8e --- /dev/null +++ b/arm64-vendor.mk @@ -0,0 +1,12 @@ + +PRODUCT_PROPERTY_OVERRIDES += \ + vendor.rild.libpath=/vendor/lib64/libreference-ril.so + +# Note: the following lines need to stay at the beginning so that it can +# take priority and override the rules it inherit from other mk files +# see copy file rules in core/Makefile +PRODUCT_COPY_FILES += \ + development/sys-img/advancedFeatures.ini.arm:advancedFeatures.ini \ + prebuilts/qemu-kernel/arm64/3.18/kernel-qemu2:kernel-ranchu \ + device/generic/goldfish/fstab.ranchu.arm:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.ranchu + diff --git a/vendor.mk b/vendor.mk new file mode 100644 index 0000000..52002b5 --- /dev/null +++ b/vendor.mk @@ -0,0 +1,147 @@ +# +# Copyright (C) 2018 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# +# This file is to configure vendor/data partitions of emulator-related products +# + +# Device modules +PRODUCT_PACKAGES += \ + gralloc.goldfish \ + gralloc.goldfish.default \ + gralloc.ranchu \ + libGLESv1_CM_emulation \ + lib_renderControl_enc \ + libEGL_emulation \ + libGLESv2_enc \ + libOpenglSystemCommon \ + libGLESv2_emulation \ + libGLESv1_enc \ + libEGL_swiftshader \ + libGLESv1_CM_swiftshader \ + libGLESv2_swiftshader \ + qemu-props \ + camera.goldfish \ + camera.goldfish.jpeg \ + camera.ranchu \ + camera.ranchu.jpeg \ + gatekeeper.ranchu \ + lights.goldfish \ + gps.goldfish \ + gps.ranchu \ + fingerprint.goldfish \ + sensors.goldfish \ + audio.primary.goldfish \ + audio.primary.goldfish_legacy \ + vibrator.goldfish \ + power.goldfish \ + power.ranchu \ + fingerprint.ranchu \ + sensors.ranchu \ + android.hardware.graphics.composer@2.1-impl \ + android.hardware.graphics.composer@2.1-service \ + android.hardware.graphics.allocator@2.0-service \ + android.hardware.graphics.allocator@2.0-impl \ + android.hardware.graphics.mapper@2.0-impl \ + hwcomposer.goldfish \ + hwcomposer.ranchu \ + toybox_vendor \ + android.hardware.audio@2.0-service \ + android.hardware.wifi@1.0-service \ + android.hardware.biometrics.fingerprint@2.1-service \ + sh_vendor \ + audio.r_submix.default \ + local_time.default \ + SdkSetup + +PRODUCT_PACKAGES += \ + android.hardware.audio@2.0-impl \ + android.hardware.audio.effect@2.0-impl \ + android.hardware.broadcastradio@1.1-service \ + android.hardware.broadcastradio@1.0-impl \ + android.hardware.soundtrigger@2.0-impl + +PRODUCT_PACKAGES += \ + android.hardware.keymaster@3.0-impl \ + android.hardware.keymaster@3.0-service + +PRODUCT_PACKAGES += \ + android.hardware.keymaster@4.0-strongbox-service + +PRODUCT_PACKAGES += \ + android.hardware.gnss@1.0-service \ + android.hardware.gnss@1.0-impl + +PRODUCT_PACKAGES += \ + android.hardware.sensors@1.0-impl \ + android.hardware.sensors@1.0-service + +PRODUCT_PACKAGES += \ + android.hardware.drm@1.0-service \ + android.hardware.drm@1.0-impl + +PRODUCT_PACKAGES += \ + android.hardware.power@1.0-service \ + android.hardware.power@1.0-impl + +PRODUCT_PACKAGES += \ + camera.device@1.0-impl \ + android.hardware.camera.provider@2.4-service \ + android.hardware.camera.provider@2.4-impl \ + +PRODUCT_PACKAGES += \ + android.hardware.gatekeeper@1.0-impl \ + android.hardware.gatekeeper@1.0-service + +# WiFi: vendor side +PRODUCT_PACKAGES += \ + createns \ + dhcpclient \ + dhcpserver \ + execns \ + hostapd \ + ipv6proxy \ + wpa_supplicant \ + +PRODUCT_COPY_FILES += \ + device/generic/goldfish/data/etc/apns-conf.xml:data/misc/apns/apns-conf.xml \ + device/generic/goldfish/init.ranchu-core.sh:$(TARGET_COPY_OUT_VENDOR)/bin/init.ranchu-core.sh \ + device/generic/goldfish/init.ranchu-net.sh:$(TARGET_COPY_OUT_VENDOR)/bin/init.ranchu-net.sh \ + device/generic/goldfish/wifi/init.wifi.sh:$(TARGET_COPY_OUT_VENDOR)/bin/init.wifi.sh \ + device/generic/goldfish/init.ranchu.rc:$(TARGET_COPY_OUT_VENDOR)/etc/init/hw/init.ranchu.rc \ + device/generic/goldfish/fstab.ranchu:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.ranchu \ + device/generic/goldfish/ueventd.ranchu.rc:$(TARGET_COPY_OUT_VENDOR)/ueventd.rc \ + device/generic/goldfish/input/goldfish_rotary.idc:$(TARGET_COPY_OUT_VENDOR)/usr/idc/goldfish_rotary.idc \ + device/generic/goldfish/manifest.xml:$(TARGET_COPY_OUT_VENDOR)/manifest.xml \ + device/generic/goldfish/data/etc/permissions/privapp-permissions-goldfish.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/privapp-permissions-goldfish.xml \ + device/generic/goldfish/data/etc/config.ini:config.ini \ + device/generic/goldfish/wifi/simulated_hostapd.conf:$(TARGET_COPY_OUT_VENDOR)/etc/simulated_hostapd.conf \ + device/generic/goldfish/wifi/wpa_supplicant.conf:$(TARGET_COPY_OUT_VENDOR)/etc/wifi/wpa_supplicant.conf \ + device/generic/goldfish/wifi/WifiConfigStore.xml:data/misc/wifi/WifiConfigStore.xml \ + frameworks/native/data/etc/android.hardware.wifi.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.wifi.xml \ + device/generic/goldfish/data/etc/handheld_core_hardware.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/handheld_core_hardware.xml \ + device/generic/goldfish/camera/media_profiles.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_profiles_V1_0.xml \ + frameworks/av/media/libstagefright/data/media_codecs_google_audio.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_codecs_google_audio.xml \ + frameworks/av/media/libstagefright/data/media_codecs_google_telephony.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_codecs_google_telephony.xml \ + device/generic/goldfish/camera/media_codecs_google_video.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_codecs_google_video.xml \ + device/generic/goldfish/camera/media_codecs.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_codecs.xml \ + device/generic/goldfish/camera/media_codecs_performance.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_codecs_performance.xml \ + frameworks/native/data/etc/android.hardware.touchscreen.multitouch.jazzhand.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.touchscreen.multitouch.jazzhand.xml \ + frameworks/native/data/etc/android.hardware.camera.autofocus.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.camera.autofocus.xml \ + frameworks/native/data/etc/android.hardware.camera.full.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.camera.full.xml \ + frameworks/native/data/etc/android.hardware.fingerprint.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.fingerprint.xml \ + frameworks/native/data/etc/android.software.autofill.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.software.autofill.xml \ + frameworks/av/media/libeffects/data/audio_effects.conf:$(TARGET_COPY_OUT_VENDOR)/etc/audio_effects.conf \ + device/generic/goldfish/audio_policy.conf:$(TARGET_COPY_OUT_VENDOR)/etc/audio_policy.conf diff --git a/x86-vendor.mk b/x86-vendor.mk new file mode 100644 index 0000000..6b34eaf --- /dev/null +++ b/x86-vendor.mk @@ -0,0 +1,13 @@ + +PRODUCT_PROPERTY_OVERRIDES += \ + vendor.rild.libpath=/vendor/lib/libreference-ril.so + +# This is a build configuration for a full-featured build of the +# Open-Source part of the tree. It's geared toward a US-centric +# build quite specifically for the emulator, and might not be +# entirely appropriate to inherit from for on-device configurations. +PRODUCT_COPY_FILES += \ + development/sys-img/advancedFeatures.ini:advancedFeatures.ini \ + device/generic/goldfish/data/etc/encryptionkey.img:encryptionkey.img \ + prebuilts/qemu-kernel/x86_64/4.9/kernel-qemu2:kernel-ranchu-64 + diff --git a/x86_64-vendor.mk b/x86_64-vendor.mk new file mode 100644 index 0000000..f585573 --- /dev/null +++ b/x86_64-vendor.mk @@ -0,0 +1,13 @@ + +PRODUCT_PROPERTY_OVERRIDES += \ + vendor.rild.libpath=/vendor/lib64/libreference-ril.so + +# This is a build configuration for a full-featured build of the +# Open-Source part of the tree. It's geared toward a US-centric +# build quite specifically for the emulator, and might not be +# entirely appropriate to inherit from for on-device configurations. +PRODUCT_COPY_FILES += \ + development/sys-img/advancedFeatures.ini:advancedFeatures.ini \ + device/generic/goldfish/data/etc/encryptionkey.img:encryptionkey.img \ + prebuilts/qemu-kernel/x86_64/4.9/kernel-qemu2:kernel-ranchu + -- cgit v1.2.3 From 880e708e2162c2b45383e77cae475f541d5cc51e Mon Sep 17 00:00:00 2001 From: Bjoern Johansson Date: Tue, 15 May 2018 15:04:53 -0700 Subject: Use hostapd without HIDL for virtual access points Change the init file to use the new hostapd binary that does not have HIDL control interface support. This way we can have both HIDL and non-HIDL hostapd binaries at the same time. The non-HIDL hostapd is used to provide a virtual acccesss point and the HIDL enabled hostapd is used to provide WiFi hotspot functionality. Modify the manifest to make sure that the hostapd HIDL for hotspots is included. BUG: 74401469 Test: run cts -m CtsNetTestCases Change-Id: I6ad2af0415c53e50050d7b91c1beb7dd45f4bbdc --- init.ranchu.rc | 4 +-- manifest.xml | 9 ++++++ vendor.mk | 1 + wifi/execns/execns.cpp | 82 +++++++++++++++++++++++++++++++++++++++++++++++--- 4 files changed, 90 insertions(+), 6 deletions(-) diff --git a/init.ranchu.rc b/init.ranchu.rc index 2193c58..9c23a81 100644 --- a/init.ranchu.rc +++ b/init.ranchu.rc @@ -56,9 +56,9 @@ service ipv6proxy /vendor/bin/execns router /vendor/bin/ipv6proxy -o eth0 -i wla group root disabled -service emu_hostapd /vendor/bin/execns router /vendor/bin/hw/hostapd /vendor/etc/simulated_hostapd.conf +service emu_hostapd /vendor/bin/execns -u wifi -g wifi router /vendor/bin/hostapd_nohidl /vendor/etc/simulated_hostapd.conf user root - group root wifi + group root wifi net_raw net_admin disabled service dhcpserver /vendor/bin/execns router /vendor/bin/dhcpserver --range 192.168.232.2,192.168.239.254 --gateway 192.168.232.1 --netmask 255.255.248.0 --exclude-interface eth0 diff --git a/manifest.xml b/manifest.xml index f534912..7e723c4 100644 --- a/manifest.xml +++ b/manifest.xml @@ -191,6 +191,15 @@ default + + android.hardware.wifi.hostapd + hwbinder + 1.0 + + IHostapd + default + + android.hardware.wifi.supplicant hwbinder diff --git a/vendor.mk b/vendor.mk index 52002b5..411b51e 100644 --- a/vendor.mk +++ b/vendor.mk @@ -112,6 +112,7 @@ PRODUCT_PACKAGES += \ dhcpserver \ execns \ hostapd \ + hostapd_nohidl \ ipv6proxy \ wpa_supplicant \ diff --git a/wifi/execns/execns.cpp b/wifi/execns/execns.cpp index e5506da..770d249 100644 --- a/wifi/execns/execns.cpp +++ b/wifi/execns/execns.cpp @@ -19,6 +19,8 @@ #include #include +#include +#include #include #include #include @@ -77,7 +79,7 @@ private: }; static void printUsage(const char* program) { - LOGE("%s [options...]", program); + LOGE("%s [-u user] [-g group] [options...]", program); } static bool isNumericString(const char* str) { @@ -147,6 +149,34 @@ static bool setNetworkNamespace(const char* ns) { return true; } +static bool changeUser(const char* user) { + struct passwd* pwd = ::getpwnam(user); + if (pwd == nullptr) { + LOGE("Could not find user '%s'", user); + return false; + } + + if (::setuid(pwd->pw_uid) != 0) { + LOGE("Cannot switch to user '%s': %s", user, strerror(errno)); + return false; + } + return true; +} + +static bool changeGroup(const char* group) { + struct group* grp = ::getgrnam(group); + if (grp == nullptr) { + LOGE("Could not find group '%s'", group); + return false; + } + + if (::setgid(grp->gr_gid) != 0) { + LOGE("Cannot switch to group '%s': %s", group, strerror(errno)); + return false; + } + return true; +} + // Append a formatted string to the end of |buffer|. The total size in |buffer| // is |size|, including any existing string data. The string to append is // specified by |fmt| and any additional arguments required by the format @@ -220,17 +250,61 @@ static int execCommand( int argc, char** argv) { */ int main(int argc, char* argv[]) { isTerminal = isatty(STDOUT_FILENO) != 0; - if (argc < 3) { + + // Parse parameters + const char* user = nullptr; + const char* group = nullptr; + int nsArg = -1; + int execArg = -1; + for (int i = 1; i < argc; ++i) { + if (::strcmp(argv[i], "-u") == 0) { + if (user || i + 1 >= argc) { + LOGE("Missing argument to option -u"); + return 1; + } + user = argv[++i]; + } else if (::strcmp(argv[i], "-g") == 0) { + if (group || i + 1 >= argc) { + LOGE("Missing argument to option -g"); + return 1; + } + group = argv[++i]; + } else { + // Break on the first non-option and treat it as the namespace name + nsArg = i; + if (i + 1 < argc) { + execArg = i + 1; + } + break; + } + } + + if (nsArg < 0 || execArg < 0) { + // Missing namespace and/or exec arguments printUsage(argv[0]); return 1; } // First set the new network namespace for this process - if (!setNetworkNamespace(argv[1])) { + if (!setNetworkNamespace(argv[nsArg])) { + return 1; + } + + // Changing namespace is the privileged operation, so now we can drop + // privileges by changing user and/or group if the user requested it. Note + // that it's important to change group first because it must be done as a + // privileged user. Otherwise an attacker might be able to restore group + // privileges by using the group ID that is saved by setgid when running + // as a non-privileged user. + if (group && !changeGroup(group)) { + return 1; + } + + if (user && !changeUser(user)) { return 1; } // Now run the command with all the remaining parameters - return execCommand(argc - 2, &argv[2]); + return execCommand(argc - execArg, &argv[execArg]); } -- cgit v1.2.3 From 3853eb01a2a6de7f3cb5ff605d94824fc4328aec Mon Sep 17 00:00:00 2001 From: bohu Date: Wed, 13 Jun 2018 09:26:50 -0700 Subject: goldfish: uses 4.4 kernel for arm/arm64 In build environment, uses 4.4 kernels as well BUG: 109735735 Change-Id: I37ef10c30395f2dab4e76ea07cab0add40b7f9b2 --- arm32-vendor.mk | 2 +- arm64-vendor.mk | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/arm32-vendor.mk b/arm32-vendor.mk index 3209c4a..a91a4b8 100644 --- a/arm32-vendor.mk +++ b/arm32-vendor.mk @@ -7,6 +7,6 @@ PRODUCT_PROPERTY_OVERRIDES += \ # see copy file rules in core/Makefile PRODUCT_COPY_FILES += \ development/sys-img/advancedFeatures.ini.arm:advancedFeatures.ini \ - prebuilts/qemu-kernel/arm64/3.18/kernel-qemu2:kernel-ranchu-64 \ + prebuilts/qemu-kernel/arm64/4.4/kernel-qemu2:kernel-ranchu-64 \ device/generic/goldfish/fstab.ranchu.arm:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.ranchu diff --git a/arm64-vendor.mk b/arm64-vendor.mk index 7696a8e..a7a79b1 100644 --- a/arm64-vendor.mk +++ b/arm64-vendor.mk @@ -7,6 +7,6 @@ PRODUCT_PROPERTY_OVERRIDES += \ # see copy file rules in core/Makefile PRODUCT_COPY_FILES += \ development/sys-img/advancedFeatures.ini.arm:advancedFeatures.ini \ - prebuilts/qemu-kernel/arm64/3.18/kernel-qemu2:kernel-ranchu \ + prebuilts/qemu-kernel/arm64/4.4/kernel-qemu2:kernel-ranchu \ device/generic/goldfish/fstab.ranchu.arm:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.ranchu -- cgit v1.2.3 From 836f41dcec3d4b489c4a2ded7af65bdc182fd223 Mon Sep 17 00:00:00 2001 From: Bjoern Johansson Date: Wed, 13 Jun 2018 10:57:09 -0700 Subject: Add support for Wifi-Direct CTS and VTS now require support for Wifi-Direct (also known as p2p wifi). Add the required xml file to indicate support, fix the wpa_supplicant configuration to deal with p2p correectly, and make sure the proper directories are created for the p2p configuration. BUG: 79749857 Test: run vts -m VtsHalWifiSupplicantV1_0Target Change-Id: I0e658a6020c1fc4a7cf7547cbfc6e2b0151f2a03 --- init.ranchu.rc | 7 +++++++ vendor.mk | 1 + wifi/wpa_supplicant.conf | 2 +- 3 files changed, 9 insertions(+), 1 deletion(-) diff --git a/init.ranchu.rc b/init.ranchu.rc index 9c23a81..12f5a68 100644 --- a/init.ranchu.rc +++ b/init.ranchu.rc @@ -15,6 +15,12 @@ on post-fs-data mkdir /data/vendor/var/run 0755 root root mkdir /data/vendor/var/run/netns 0755 root root +on zygote-start + # Create the directories used by the Wireless subsystem + mkdir /data/vendor/wifi 0771 wifi wifi + mkdir /data/vendor/wifi/wpa 0770 wifi wifi + mkdir /data/vendor/wifi/wpa/sockets 0770 wifi wifi + on boot setprop debug.hwui.renderer opengl setprop debug.hwui.renderer ${ro.kernel.qemu.uirenderer} @@ -26,6 +32,7 @@ on boot setprop ro.hardware.audio.primary goldfish setprop wifi.interface wlan0 + setprop wifi.direct.interface p2p-dev-wlan0 start goldfish-logcat diff --git a/vendor.mk b/vendor.mk index 411b51e..09870f0 100644 --- a/vendor.mk +++ b/vendor.mk @@ -132,6 +132,7 @@ PRODUCT_COPY_FILES += \ device/generic/goldfish/wifi/wpa_supplicant.conf:$(TARGET_COPY_OUT_VENDOR)/etc/wifi/wpa_supplicant.conf \ device/generic/goldfish/wifi/WifiConfigStore.xml:data/misc/wifi/WifiConfigStore.xml \ frameworks/native/data/etc/android.hardware.wifi.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.wifi.xml \ + frameworks/native/data/etc/android.hardware.wifi.direct.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.wifi.direct.xml \ device/generic/goldfish/data/etc/handheld_core_hardware.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/handheld_core_hardware.xml \ device/generic/goldfish/camera/media_profiles.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_profiles_V1_0.xml \ frameworks/av/media/libstagefright/data/media_codecs_google_audio.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_codecs_google_audio.xml \ diff --git a/wifi/wpa_supplicant.conf b/wifi/wpa_supplicant.conf index 20b58be..391c970 100644 --- a/wifi/wpa_supplicant.conf +++ b/wifi/wpa_supplicant.conf @@ -1,4 +1,4 @@ -ctrl_interface=wlan0 disable_scan_offload=1 wowlan_triggers=any ap_scan=1 +p2p_no_group_iface=1 -- cgit v1.2.3 From ff1eb24e460722639676c8390c3b8d37b5198f35 Mon Sep 17 00:00:00 2001 From: bohu Date: Wed, 13 Jun 2018 10:05:24 -0700 Subject: goldfish: add sepolicies This is copied from build/make/target/generic/sepolicy and build/make/target/generic_x86/sepolicy at the following cl: commit cfbe8cf3bb1a302c8e41caed528c2d8ea6c70d4b Merge: 0f494a025 0047dbed1 Author: Yi Kong Date: Wed Jun 13 02:10:12 2018 +0000 Merge "Fix CLANG_EXTERNAL_CFLAGS logic" BUG: 110030159 Change-Id: I121a20c2e24f020921045463d5043b634ffbe7c2 Merged-In: I121a20c2e24f020921045463d5043b634ffbe7c2 --- sepolicy/common/OWNERS | 8 ++++ sepolicy/common/adbd.te | 1 + sepolicy/common/audioserver.te | 1 + sepolicy/common/bootanim.te | 9 +++++ sepolicy/common/cameraserver.te | 2 + sepolicy/common/createns.te | 14 +++++++ sepolicy/common/device.te | 1 + sepolicy/common/dhcpclient.te | 20 ++++++++++ sepolicy/common/dhcpserver.te | 12 ++++++ sepolicy/common/domain.te | 3 ++ sepolicy/common/execns.te | 27 +++++++++++++ sepolicy/common/file.te | 4 ++ sepolicy/common/file_contexts | 47 +++++++++++++++++++++++ sepolicy/common/genfs_contexts | 20 ++++++++++ sepolicy/common/goldfish_setup.te | 47 +++++++++++++++++++++++ sepolicy/common/hal_camera_default.te | 3 ++ sepolicy/common/hal_cas_default.te | 1 + sepolicy/common/hal_drm_default.te | 2 + sepolicy/common/hal_drm_widevine.te | 14 +++++++ sepolicy/common/hal_fingerprint_default.te | 5 +++ sepolicy/common/hal_gnss_default.te | 3 ++ sepolicy/common/hal_graphics_allocator_default.te | 2 + sepolicy/common/hal_graphics_composer_default.te | 3 ++ sepolicy/common/hal_wifi_default.te | 1 + sepolicy/common/healthd.te | 2 + sepolicy/common/hostapd_nohidl.te | 16 ++++++++ sepolicy/common/init.te | 2 + sepolicy/common/ipv6proxy.te | 16 ++++++++ sepolicy/common/logpersist.te | 13 +++++++ sepolicy/common/mediacodec.te | 1 + sepolicy/common/netd.te | 3 ++ sepolicy/common/priv_app.te | 5 +++ sepolicy/common/property.te | 5 +++ sepolicy/common/property_contexts | 8 ++++ sepolicy/common/qemu_props.te | 10 +++++ sepolicy/common/radio.te | 3 ++ sepolicy/common/rild.te | 3 ++ sepolicy/common/shell.te | 1 + sepolicy/common/surfaceflinger.te | 5 +++ sepolicy/common/system_server.te | 1 + sepolicy/common/vendor_init.te | 1 + sepolicy/common/vold.te | 1 + sepolicy/common/zygote.te | 5 +++ sepolicy/x86/OWNERS | 8 ++++ sepolicy/x86/domain.te | 1 + sepolicy/x86/healthd.te | 1 + sepolicy/x86/init.te | 1 + sepolicy/x86/installd.te | 1 + sepolicy/x86/zygote.te | 2 + 49 files changed, 365 insertions(+) create mode 100644 sepolicy/common/OWNERS create mode 100644 sepolicy/common/adbd.te create mode 100644 sepolicy/common/audioserver.te create mode 100644 sepolicy/common/bootanim.te create mode 100644 sepolicy/common/cameraserver.te create mode 100644 sepolicy/common/createns.te create mode 100644 sepolicy/common/device.te create mode 100644 sepolicy/common/dhcpclient.te create mode 100644 sepolicy/common/dhcpserver.te create mode 100644 sepolicy/common/domain.te create mode 100644 sepolicy/common/execns.te create mode 100644 sepolicy/common/file.te create mode 100644 sepolicy/common/file_contexts create mode 100644 sepolicy/common/genfs_contexts create mode 100644 sepolicy/common/goldfish_setup.te create mode 100644 sepolicy/common/hal_camera_default.te create mode 100644 sepolicy/common/hal_cas_default.te create mode 100644 sepolicy/common/hal_drm_default.te create mode 100644 sepolicy/common/hal_drm_widevine.te create mode 100644 sepolicy/common/hal_fingerprint_default.te create mode 100644 sepolicy/common/hal_gnss_default.te create mode 100644 sepolicy/common/hal_graphics_allocator_default.te create mode 100644 sepolicy/common/hal_graphics_composer_default.te create mode 100644 sepolicy/common/hal_wifi_default.te create mode 100644 sepolicy/common/healthd.te create mode 100644 sepolicy/common/hostapd_nohidl.te create mode 100644 sepolicy/common/init.te create mode 100644 sepolicy/common/ipv6proxy.te create mode 100644 sepolicy/common/logpersist.te create mode 100644 sepolicy/common/mediacodec.te create mode 100644 sepolicy/common/netd.te create mode 100644 sepolicy/common/priv_app.te create mode 100644 sepolicy/common/property.te create mode 100644 sepolicy/common/property_contexts create mode 100644 sepolicy/common/qemu_props.te create mode 100644 sepolicy/common/radio.te create mode 100644 sepolicy/common/rild.te create mode 100644 sepolicy/common/shell.te create mode 100644 sepolicy/common/surfaceflinger.te create mode 100644 sepolicy/common/system_server.te create mode 100644 sepolicy/common/vendor_init.te create mode 100644 sepolicy/common/vold.te create mode 100644 sepolicy/common/zygote.te create mode 100644 sepolicy/x86/OWNERS create mode 100644 sepolicy/x86/domain.te create mode 100644 sepolicy/x86/healthd.te create mode 100644 sepolicy/x86/init.te create mode 100644 sepolicy/x86/installd.te create mode 100644 sepolicy/x86/zygote.te diff --git a/sepolicy/common/OWNERS b/sepolicy/common/OWNERS new file mode 100644 index 0000000..ff29677 --- /dev/null +++ b/sepolicy/common/OWNERS @@ -0,0 +1,8 @@ +alanstokes@google.com +bowgotsai@google.com +jbires@google.com +jeffv@google.com +jgalenson@google.com +sspatil@google.com +tomcherry@google.com +trong@google.com diff --git a/sepolicy/common/adbd.te b/sepolicy/common/adbd.te new file mode 100644 index 0000000..9546c1a --- /dev/null +++ b/sepolicy/common/adbd.te @@ -0,0 +1 @@ +set_prop(adbd, ctl_mdnsd_prop); diff --git a/sepolicy/common/audioserver.te b/sepolicy/common/audioserver.te new file mode 100644 index 0000000..c3c4a3a --- /dev/null +++ b/sepolicy/common/audioserver.te @@ -0,0 +1 @@ +allow audioserver bootanim:binder call; diff --git a/sepolicy/common/bootanim.te b/sepolicy/common/bootanim.te new file mode 100644 index 0000000..bc84ee7 --- /dev/null +++ b/sepolicy/common/bootanim.te @@ -0,0 +1,9 @@ +allow bootanim self:process execmem; +allow bootanim ashmem_device:chr_file execute; +#TODO: This can safely be ignored until b/62954877 is fixed +dontaudit bootanim system_data_file:dir read; + +allow bootanim graphics_device:chr_file { read ioctl open }; + +typeattribute bootanim system_writes_vendor_properties_violators; +set_prop(bootanim, qemu_prop) diff --git a/sepolicy/common/cameraserver.te b/sepolicy/common/cameraserver.te new file mode 100644 index 0000000..6cf5d6a --- /dev/null +++ b/sepolicy/common/cameraserver.te @@ -0,0 +1,2 @@ +allow cameraserver system_file:dir { open read }; +allow cameraserver hal_allocator:fd use; diff --git a/sepolicy/common/createns.te b/sepolicy/common/createns.te new file mode 100644 index 0000000..1eaf9ef --- /dev/null +++ b/sepolicy/common/createns.te @@ -0,0 +1,14 @@ +# Network namespace creation +type createns, domain; +type createns_exec, exec_type, vendor_file_type, file_type; + +init_daemon_domain(createns) + +allow createns self:capability { sys_admin net_raw setuid setgid }; +allow createns varrun_file:dir { add_name search write }; +allow createns varrun_file:file { create mounton open read write }; + +#Allow createns itself to be run by init in its own domain +domain_auto_trans(goldfish_setup, createns_exec, createns); +allow createns goldfish_setup:fd use; + diff --git a/sepolicy/common/device.te b/sepolicy/common/device.te new file mode 100644 index 0000000..d129441 --- /dev/null +++ b/sepolicy/common/device.te @@ -0,0 +1 @@ +type qemu_device, dev_type, mlstrustedobject; diff --git a/sepolicy/common/dhcpclient.te b/sepolicy/common/dhcpclient.te new file mode 100644 index 0000000..df71fca --- /dev/null +++ b/sepolicy/common/dhcpclient.te @@ -0,0 +1,20 @@ +# DHCP client +type dhcpclient, domain; +type dhcpclient_exec, exec_type, vendor_file_type, file_type; + +init_daemon_domain(dhcpclient) +net_domain(dhcpclient) + +allow dhcpclient execns:fd use; + +set_prop(dhcpclient, net_eth0_prop); +allow dhcpclient self:capability { net_admin net_raw }; +allow dhcpclient self:udp_socket create; +allow dhcpclient self:netlink_route_socket { write nlmsg_write }; +allow dhcpclient varrun_file:dir search; +allow dhcpclient self:packet_socket { create bind write read }; +allowxperm dhcpclient self:udp_socket ioctl { SIOCSIFFLAGS + SIOCSIFADDR + SIOCSIFNETMASK + SIOCSIFMTU + SIOCGIFHWADDR }; diff --git a/sepolicy/common/dhcpserver.te b/sepolicy/common/dhcpserver.te new file mode 100644 index 0000000..7e8ba26 --- /dev/null +++ b/sepolicy/common/dhcpserver.te @@ -0,0 +1,12 @@ +# DHCP server +type dhcpserver, domain; +type dhcpserver_exec, exec_type, vendor_file_type, file_type; + +init_daemon_domain(dhcpserver) +net_domain(dhcpserver) + +allow dhcpserver execns:fd use; + +get_prop(dhcpserver, net_eth0_prop); +allow dhcpserver self:udp_socket { ioctl create setopt bind }; +allow dhcpserver self:capability { net_raw net_bind_service }; diff --git a/sepolicy/common/domain.te b/sepolicy/common/domain.te new file mode 100644 index 0000000..3706dba --- /dev/null +++ b/sepolicy/common/domain.te @@ -0,0 +1,3 @@ +allow domain qemu_device:chr_file rw_file_perms; + +get_prop(domain, qemu_prop) diff --git a/sepolicy/common/execns.te b/sepolicy/common/execns.te new file mode 100644 index 0000000..dc6c424 --- /dev/null +++ b/sepolicy/common/execns.te @@ -0,0 +1,27 @@ +# Network namespace transitions +type execns, domain; +type execns_exec, exec_type, vendor_file_type, file_type; + +init_daemon_domain(execns) + +allow execns varrun_file:dir search; +allow execns varrun_file:file r_file_perms; +allow execns self:capability { sys_admin setuid setgid }; +allow execns nsfs:file { open read }; + +#Allow execns itself to be run by init in its own domain +domain_auto_trans(init, execns_exec, execns); + +# Allow dhcpclient to be run by execns in its own domain +domain_auto_trans(execns, dhcpclient_exec, dhcpclient); + +# Allow dhcpserver to be run by execns in its own domain +domain_auto_trans(execns, dhcpserver_exec, dhcpserver); + +# Allow hostapd_nohidl to be run by execns in its own domain +domain_auto_trans(execns, hostapd_nohidl_exec, hostapd_nohidl); + +# Allow execns to read createns proc file to get the namespace file +allow execns createns:file read; +allow execns createns:dir search; +allow execns createns:lnk_file read; diff --git a/sepolicy/common/file.te b/sepolicy/common/file.te new file mode 100644 index 0000000..b0aa217 --- /dev/null +++ b/sepolicy/common/file.te @@ -0,0 +1,4 @@ +type sysfs_writable, fs_type, sysfs_type, mlstrustedobject; +type varrun_file, file_type, data_file_type, mlstrustedobject; +type mediadrm_vendor_data_file, file_type, data_file_type; +type nsfs, fs_type; diff --git a/sepolicy/common/file_contexts b/sepolicy/common/file_contexts new file mode 100644 index 0000000..7cd79fe --- /dev/null +++ b/sepolicy/common/file_contexts @@ -0,0 +1,47 @@ +# goldfish +/dev/block/mtdblock0 u:object_r:system_block_device:s0 +/dev/block/mtdblock1 u:object_r:userdata_block_device:s0 +/dev/block/mtdblock2 u:object_r:cache_block_device:s0 + +# ranchu +/dev/block/vda u:object_r:system_block_device:s0 +/dev/block/vdb u:object_r:cache_block_device:s0 +/dev/block/vdc u:object_r:userdata_block_device:s0 +/dev/block/vdd u:object_r:metadata_block_device:s0 +/dev/block/vde u:object_r:system_block_device:s0 + +/dev/goldfish_pipe u:object_r:qemu_device:s0 +/dev/goldfish_sync u:object_r:qemu_device:s0 +/dev/qemu_.* u:object_r:qemu_device:s0 +/dev/ttyGF[0-9]* u:object_r:serial_device:s0 +/dev/ttyS2 u:object_r:console_device:s0 +/vendor/bin/init\.ranchu-core\.sh u:object_r:goldfish_setup_exec:s0 +/vendor/bin/init\.ranchu-net\.sh u:object_r:goldfish_setup_exec:s0 +/vendor/bin/init\.wifi\.sh u:object_r:goldfish_setup_exec:s0 +/vendor/bin/qemu-props u:object_r:qemu_props_exec:s0 +/vendor/bin/createns u:object_r:createns_exec:s0 +/vendor/bin/execns u:object_r:execns_exec:s0 +/vendor/bin/ipv6proxy u:object_r:ipv6proxy_exec:s0 +/vendor/bin/dhcpclient u:object_r:dhcpclient_exec:s0 +/vendor/bin/dhcpserver u:object_r:dhcpserver_exec:s0 +/vendor/bin/hostapd_nohidl u:object_r:hostapd_nohidl_exec:s0 + +/vendor/bin/hw/android\.hardware\.drm@1\.0-service\.widevine u:object_r:hal_drm_widevine_exec:s0 + +/vendor/lib(64)?/hw/gralloc\.ranchu\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/hw/gralloc\.goldfish\.default\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libEGL_emulation\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libGLESv1_CM_emulation\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libGLESv2_emulation\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libEGL_swiftshader\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libGLESv1_CM_swiftshader\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libGLESv2_swiftshader\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libOpenglSystemCommon\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/lib_renderControl_enc\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libGLESv1_enc\.so u:object_r:same_process_hal_file:s0 +/vendor/lib(64)?/libGLESv2_enc\.so u:object_r:same_process_hal_file:s0 + +# data +/data/vendor/mediadrm(/.*)? u:object_r:mediadrm_vendor_data_file:s0 +/data/vendor/var/run(/.*)? u:object_r:varrun_file:s0 + diff --git a/sepolicy/common/genfs_contexts b/sepolicy/common/genfs_contexts new file mode 100644 index 0000000..1b81626 --- /dev/null +++ b/sepolicy/common/genfs_contexts @@ -0,0 +1,20 @@ +# On the emulator, device tree dir is configured to be +# /sys/bus/platform/devices/ANDR0001:00/properties/android/ which is a symlink to +# /sys/devices/platform/ANDR0001:00/properties/android/ +genfscon sysfs /devices/platform/ANDR0001:00/properties/android u:object_r:sysfs_dt_firmware_android:s0 + +# We expect /sys/class/power_supply/* and everything it links to to be labeled +# as sysfs_batteryinfo. +genfscon sysfs /devices/platform/GFSH0001:00/power_supply u:object_r:sysfs_batteryinfo:s0 + +# /sys/class/rtc +genfscon sysfs /devices/pnp0/00:00/rtc u:object_r:sysfs_rtc:s0 +genfscon sysfs /devices/platform/GFSH0007:00/rtc u:object_r:sysfs_rtc:s0 + +# /sys/class/net +genfscon sysfs /devices/pci0000:00/0000:00:08.0/virtio5/net u:object_r:sysfs_net:s0 +genfscon sysfs /devices/virtual/mac80211_hwsim/hwsim0/net u:object_r:sysfs_net:s0 +genfscon sysfs /devices/virtual/mac80211_hwsim/hwsim1/net u:object_r:sysfs_net:s0 + +# /proc//ns +genfscon nsfs / u:object_r:nsfs:s0 diff --git a/sepolicy/common/goldfish_setup.te b/sepolicy/common/goldfish_setup.te new file mode 100644 index 0000000..3041436 --- /dev/null +++ b/sepolicy/common/goldfish_setup.te @@ -0,0 +1,47 @@ +# goldfish-setup service: runs init.goldfish.sh script +type goldfish_setup, domain; +type goldfish_setup_exec, vendor_file_type, exec_type, file_type; + +init_daemon_domain(goldfish_setup) + +# TODO(b/79502552): Invalid property access from emulator vendor +#set_prop(goldfish_setup, debug_prop); +allow goldfish_setup self:capability { net_admin net_raw }; +allow goldfish_setup self:udp_socket { create ioctl }; +allow goldfish_setup vendor_toolbox_exec:file execute_no_trans; +allowxperm goldfish_setup self:udp_socket ioctl priv_sock_ioctls; +wakelock_use(goldfish_setup); +allow goldfish_setup vendor_shell_exec:file { rx_file_perms }; + +# Set system properties to start services +set_prop(goldfish_setup, ctl_default_prop); + +# Set up WiFi +allow goldfish_setup self:netlink_route_socket { create nlmsg_write setopt bind getattr read write nlmsg_read }; +allow goldfish_setup self:netlink_generic_socket create_socket_perms_no_ioctl; +allow goldfish_setup self:capability { sys_module sys_admin }; +allow goldfish_setup varrun_file:dir { mounton open read write add_name search remove_name }; +allow goldfish_setup varrun_file:file { mounton getattr create read write open unlink }; +allow goldfish_setup execns_exec:file rx_file_perms; +allow goldfish_setup proc_net:file rw_file_perms; +allow goldfish_setup proc:file r_file_perms; +allow goldfish_setup nsfs:file r_file_perms; +allow goldfish_setup system_data_file:dir getattr; +allow goldfish_setup kernel:system module_request; +set_prop(goldfish_setup, qemu_prop); +get_prop(goldfish_setup, net_share_prop); +# Allow goldfish_setup to run /system/bin/ip and /system/bin/iw +allow goldfish_setup system_file:file execute_no_trans; +# Allow goldfish_setup to run init.wifi.sh +allow goldfish_setup goldfish_setup_exec:file execute_no_trans; +#Allow goldfish_setup to run createns in its own domain +domain_auto_trans(goldfish_setup, createns_exec, createns); +# iw +allow goldfish_setup sysfs:file { read open }; +# iptables +allow goldfish_setup system_file:file lock; +allow goldfish_setup self:rawip_socket { create getopt setopt }; +# Allow goldfish_setup to read createns proc file to get the namespace file +allow goldfish_setup createns:file { read }; +allow goldfish_setup createns:dir { search }; +allow goldfish_setup createns:lnk_file { read }; diff --git a/sepolicy/common/hal_camera_default.te b/sepolicy/common/hal_camera_default.te new file mode 100644 index 0000000..eb88c36 --- /dev/null +++ b/sepolicy/common/hal_camera_default.te @@ -0,0 +1,3 @@ +vndbinder_use(hal_camera_default); +allow hal_camera_default hal_graphics_mapper_hwservice:hwservice_manager find; +hal_client_domain(hal_camera_default, hal_graphics_composer) diff --git a/sepolicy/common/hal_cas_default.te b/sepolicy/common/hal_cas_default.te new file mode 100644 index 0000000..3ed3bee --- /dev/null +++ b/sepolicy/common/hal_cas_default.te @@ -0,0 +1 @@ +vndbinder_use(hal_cas_default); diff --git a/sepolicy/common/hal_drm_default.te b/sepolicy/common/hal_drm_default.te new file mode 100644 index 0000000..5a07433 --- /dev/null +++ b/sepolicy/common/hal_drm_default.te @@ -0,0 +1,2 @@ +vndbinder_use(hal_drm_default); +hal_client_domain(hal_drm_default, hal_graphics_composer) diff --git a/sepolicy/common/hal_drm_widevine.te b/sepolicy/common/hal_drm_widevine.te new file mode 100644 index 0000000..d49000d --- /dev/null +++ b/sepolicy/common/hal_drm_widevine.te @@ -0,0 +1,14 @@ +# define SELinux domain +type hal_drm_widevine, domain; +hal_server_domain(hal_drm_widevine, hal_drm) + +type hal_drm_widevine_exec, exec_type, vendor_file_type, file_type; +init_daemon_domain(hal_drm_widevine) + +allow hal_drm mediacodec:fd use; +allow hal_drm { appdomain -isolated_app }:fd use; + +vndbinder_use(hal_drm_widevine); +hal_client_domain(hal_drm_widevine, hal_graphics_composer); +allow hal_drm_widevine mediadrm_vendor_data_file:dir create_dir_perms; +allow hal_drm_widevine mediadrm_vendor_data_file:file create_file_perms; diff --git a/sepolicy/common/hal_fingerprint_default.te b/sepolicy/common/hal_fingerprint_default.te new file mode 100644 index 0000000..e5b06f1 --- /dev/null +++ b/sepolicy/common/hal_fingerprint_default.te @@ -0,0 +1,5 @@ +# TODO(b/36644492): Remove data_between_core_and_vendor_violators once +# hal_fingerprint no longer directly accesses fingerprintd_data_file. +typeattribute hal_fingerprint_default data_between_core_and_vendor_violators; +allow hal_fingerprint_default fingerprintd_data_file:file create_file_perms; +allow hal_fingerprint_default fingerprintd_data_file:dir rw_dir_perms; diff --git a/sepolicy/common/hal_gnss_default.te b/sepolicy/common/hal_gnss_default.te new file mode 100644 index 0000000..0dd3d03 --- /dev/null +++ b/sepolicy/common/hal_gnss_default.te @@ -0,0 +1,3 @@ +#============= hal_gnss_default ============== +allow hal_gnss_default vndbinder_device:chr_file { ioctl open read write }; + diff --git a/sepolicy/common/hal_graphics_allocator_default.te b/sepolicy/common/hal_graphics_allocator_default.te new file mode 100644 index 0000000..0c8e27d --- /dev/null +++ b/sepolicy/common/hal_graphics_allocator_default.te @@ -0,0 +1,2 @@ +allow hal_graphics_allocator_default graphics_device:dir search; +allow hal_graphics_allocator_default graphics_device:chr_file { ioctl open read write }; diff --git a/sepolicy/common/hal_graphics_composer_default.te b/sepolicy/common/hal_graphics_composer_default.te new file mode 100644 index 0000000..034bdef --- /dev/null +++ b/sepolicy/common/hal_graphics_composer_default.te @@ -0,0 +1,3 @@ +#============= hal_graphics_composer_default ============== +allow hal_graphics_composer_default vndbinder_device:chr_file { ioctl open read write }; + diff --git a/sepolicy/common/hal_wifi_default.te b/sepolicy/common/hal_wifi_default.te new file mode 100644 index 0000000..de4b996 --- /dev/null +++ b/sepolicy/common/hal_wifi_default.te @@ -0,0 +1 @@ +allow hal_wifi_default hal_wifi_default:netlink_route_socket { create bind write read nlmsg_read }; diff --git a/sepolicy/common/healthd.te b/sepolicy/common/healthd.te new file mode 100644 index 0000000..ced6704 --- /dev/null +++ b/sepolicy/common/healthd.te @@ -0,0 +1,2 @@ +# Allow to read /sys/class/power_supply directory +allow healthd sysfs:dir r_dir_perms; diff --git a/sepolicy/common/hostapd_nohidl.te b/sepolicy/common/hostapd_nohidl.te new file mode 100644 index 0000000..add648a --- /dev/null +++ b/sepolicy/common/hostapd_nohidl.te @@ -0,0 +1,16 @@ +type hostapd_nohidl, domain; +type hostapd_nohidl_exec, exec_type, vendor_file_type, file_type; + +init_daemon_domain(hostapd_nohidl) +net_domain(hostapd_nohidl) + +allow hostapd_nohidl execns:fd use; + +allow hostapd_nohidl self:capability { net_admin net_raw }; +allow hostapd_nohidl self:netlink_generic_socket { bind create getattr read setopt write }; +allow hostapd_nohidl self:netlink_route_socket nlmsg_write; +allow hostapd_nohidl self:packet_socket { create setopt }; +allowxperm hostapd_nohidl self:udp_socket ioctl priv_sock_ioctls; + +# hostapd will attempt to search sysfs but it's not needed and will spam the log +dontaudit hostapd_nohidl sysfs_net:dir search; diff --git a/sepolicy/common/init.te b/sepolicy/common/init.te new file mode 100644 index 0000000..84a4e8d --- /dev/null +++ b/sepolicy/common/init.te @@ -0,0 +1,2 @@ +allow init tmpfs:lnk_file create_file_perms; +dontaudit init kernel:system module_request; diff --git a/sepolicy/common/ipv6proxy.te b/sepolicy/common/ipv6proxy.te new file mode 100644 index 0000000..22976fe --- /dev/null +++ b/sepolicy/common/ipv6proxy.te @@ -0,0 +1,16 @@ +# IPv6 proxying +type ipv6proxy, domain; +type ipv6proxy_exec, exec_type, vendor_file_type, file_type; + +init_daemon_domain(ipv6proxy) +net_domain(ipv6proxy) + +# Allow ipv6proxy to be run by execns in its own domain +domain_auto_trans(execns, ipv6proxy_exec, ipv6proxy); +allow ipv6proxy execns:fd use; + +allow ipv6proxy self:capability { sys_admin sys_module net_admin net_raw }; +allow ipv6proxy self:packet_socket { bind create read }; +allow ipv6proxy self:netlink_route_socket nlmsg_write; +allow ipv6proxy varrun_file:dir search; +allowxperm ipv6proxy self:udp_socket ioctl { SIOCSIFFLAGS SIOCGIFHWADDR }; diff --git a/sepolicy/common/logpersist.te b/sepolicy/common/logpersist.te new file mode 100644 index 0000000..3fc0250 --- /dev/null +++ b/sepolicy/common/logpersist.te @@ -0,0 +1,13 @@ +# goldfish logcat service: runs logcat -Q in logpersist domain + +# See global logcat.te/logpersist.te, only set for eng & userdebug, +# allow for all builds in a non-conflicting manner. + +domain_auto_trans(init, logcat_exec, logpersist) + +# Read from logd. +unix_socket_connect(logpersist, logdr, logd) + +# Write to /dev/ttyS2 and /dev/ttyGF2. +allow logpersist serial_device:chr_file { write open }; +get_prop(logpersist, qemu_cmdline) diff --git a/sepolicy/common/mediacodec.te b/sepolicy/common/mediacodec.te new file mode 100644 index 0000000..acf4e59 --- /dev/null +++ b/sepolicy/common/mediacodec.te @@ -0,0 +1 @@ +allow mediacodec system_file:dir { open read }; diff --git a/sepolicy/common/netd.te b/sepolicy/common/netd.te new file mode 100644 index 0000000..09a28b9 --- /dev/null +++ b/sepolicy/common/netd.te @@ -0,0 +1,3 @@ +dontaudit netd self:capability sys_module; +#TODO: This can safely be ignored until b/62954877 is fixed +dontaudit netd kernel:system module_request; diff --git a/sepolicy/common/priv_app.te b/sepolicy/common/priv_app.te new file mode 100644 index 0000000..3d16f32 --- /dev/null +++ b/sepolicy/common/priv_app.te @@ -0,0 +1,5 @@ +#TODO: b/62908025 +dontaudit priv_app firstboot_prop:file { getattr open }; +dontaudit priv_app device:dir { open read }; +dontaudit priv_app proc_interrupts:file { getattr open read }; +dontaudit priv_app proc_modules:file { getattr open read }; diff --git a/sepolicy/common/property.te b/sepolicy/common/property.te new file mode 100644 index 0000000..3593a39 --- /dev/null +++ b/sepolicy/common/property.te @@ -0,0 +1,5 @@ +type qemu_prop, property_type; +type qemu_cmdline, property_type; +type radio_noril_prop, property_type; +type net_eth0_prop, property_type; +type net_share_prop, property_type; diff --git a/sepolicy/common/property_contexts b/sepolicy/common/property_contexts new file mode 100644 index 0000000..f7a241c --- /dev/null +++ b/sepolicy/common/property_contexts @@ -0,0 +1,8 @@ +qemu. u:object_r:qemu_prop:s0 +qemu.cmdline u:object_r:qemu_cmdline:s0 +vendor.qemu u:object_r:qemu_prop:s0 +ro.emu. u:object_r:qemu_prop:s0 +ro.emulator. u:object_r:qemu_prop:s0 +ro.radio.noril u:object_r:radio_noril_prop:s0 +net.eth0. u:object_r:net_eth0_prop:s0 +net.shared_net_ip u:object_r:net_share_prop:s0 diff --git a/sepolicy/common/qemu_props.te b/sepolicy/common/qemu_props.te new file mode 100644 index 0000000..b3e2d95 --- /dev/null +++ b/sepolicy/common/qemu_props.te @@ -0,0 +1,10 @@ +# qemu-props service: Sets system properties on boot. +type qemu_props, domain; +type qemu_props_exec, vendor_file_type, exec_type, file_type; + +init_daemon_domain(qemu_props) + +set_prop(qemu_props, qemu_prop) +# TODO(b/79502552): Invalid property access from emulator vendor +#set_prop(qemu_props, qemu_cmdline) +set_prop(qemu_props, qemu_cmdline) diff --git a/sepolicy/common/radio.te b/sepolicy/common/radio.te new file mode 100644 index 0000000..742d3b2 --- /dev/null +++ b/sepolicy/common/radio.te @@ -0,0 +1,3 @@ +# Allow the radio to read these properties, they only have an SELinux label in +# the emulator. +get_prop(radio, net_eth0_prop); diff --git a/sepolicy/common/rild.te b/sepolicy/common/rild.te new file mode 100644 index 0000000..ea18373 --- /dev/null +++ b/sepolicy/common/rild.te @@ -0,0 +1,3 @@ +# Allow rild to read these properties, they only have an SELinux label in the +# emulator. +get_prop(rild, net_eth0_prop); diff --git a/sepolicy/common/shell.te b/sepolicy/common/shell.te new file mode 100644 index 0000000..b246d7e --- /dev/null +++ b/sepolicy/common/shell.te @@ -0,0 +1 @@ +allow shell serial_device:chr_file rw_file_perms; diff --git a/sepolicy/common/surfaceflinger.te b/sepolicy/common/surfaceflinger.te new file mode 100644 index 0000000..2bba8a7 --- /dev/null +++ b/sepolicy/common/surfaceflinger.te @@ -0,0 +1,5 @@ +allow surfaceflinger self:process execmem; +allow surfaceflinger ashmem_device:chr_file execute; + +typeattribute surfaceflinger system_writes_vendor_properties_violators; +set_prop(surfaceflinger, qemu_prop) diff --git a/sepolicy/common/system_server.te b/sepolicy/common/system_server.te new file mode 100644 index 0000000..dd70b12 --- /dev/null +++ b/sepolicy/common/system_server.te @@ -0,0 +1 @@ +get_prop(system_server, radio_noril_prop) diff --git a/sepolicy/common/vendor_init.te b/sepolicy/common/vendor_init.te new file mode 100644 index 0000000..b18d391 --- /dev/null +++ b/sepolicy/common/vendor_init.te @@ -0,0 +1 @@ +set_prop(vendor_init, qemu_prop) diff --git a/sepolicy/common/vold.te b/sepolicy/common/vold.te new file mode 100644 index 0000000..5f3bdd4 --- /dev/null +++ b/sepolicy/common/vold.te @@ -0,0 +1 @@ +dontaudit vold kernel:system module_request; diff --git a/sepolicy/common/zygote.te b/sepolicy/common/zygote.te new file mode 100644 index 0000000..da403b5 --- /dev/null +++ b/sepolicy/common/zygote.te @@ -0,0 +1,5 @@ +typeattribute zygote system_writes_vendor_properties_violators; +set_prop(zygote, qemu_prop) +# TODO (b/63631799) fix this access +# Suppress denials to storage. Webview zygote should not be accessing. +dontaudit webview_zygote mnt_expand_file:dir getattr; diff --git a/sepolicy/x86/OWNERS b/sepolicy/x86/OWNERS new file mode 100644 index 0000000..ff29677 --- /dev/null +++ b/sepolicy/x86/OWNERS @@ -0,0 +1,8 @@ +alanstokes@google.com +bowgotsai@google.com +jbires@google.com +jeffv@google.com +jgalenson@google.com +sspatil@google.com +tomcherry@google.com +trong@google.com diff --git a/sepolicy/x86/domain.te b/sepolicy/x86/domain.te new file mode 100644 index 0000000..0bc8d87 --- /dev/null +++ b/sepolicy/x86/domain.te @@ -0,0 +1 @@ +allow domain cpuctl_device:dir search; diff --git a/sepolicy/x86/healthd.te b/sepolicy/x86/healthd.te new file mode 100644 index 0000000..95fa807 --- /dev/null +++ b/sepolicy/x86/healthd.te @@ -0,0 +1 @@ +allow healthd self:capability sys_nice; diff --git a/sepolicy/x86/init.te b/sepolicy/x86/init.te new file mode 100644 index 0000000..3aa81d1 --- /dev/null +++ b/sepolicy/x86/init.te @@ -0,0 +1 @@ +allow init tmpfs:lnk_file create_file_perms; diff --git a/sepolicy/x86/installd.te b/sepolicy/x86/installd.te new file mode 100644 index 0000000..7a558b1 --- /dev/null +++ b/sepolicy/x86/installd.te @@ -0,0 +1 @@ +allow installd self:process execmem; diff --git a/sepolicy/x86/zygote.te b/sepolicy/x86/zygote.te new file mode 100644 index 0000000..93993a4 --- /dev/null +++ b/sepolicy/x86/zygote.te @@ -0,0 +1,2 @@ +allow zygote self:process execmem; +allow zygote self:capability sys_nice; -- cgit v1.2.3 From 7241bf7522b091e398ca1b87c0160341e646e054 Mon Sep 17 00:00:00 2001 From: Weilun Du Date: Wed, 13 Jun 2018 14:56:53 -0700 Subject: Add android.software.cant_save_state to handheld_core_hardware.xml Fixed CTS tests android.app.cts.ActivityManagerProcessStateTest#testCantSaveStateLaunchAndBackground android.app.cts.ActivityManagerProcessStateTest#testCantSaveStateLaunchAndSwitch BUG: 110165999 Change-Id: I4141be5e8d136b00e9e097917ad1b542c79affab Signed-off-by: Weilun Du --- data/etc/handheld_core_hardware.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/data/etc/handheld_core_hardware.xml b/data/etc/handheld_core_hardware.xml index 728e5ba..37be092 100644 --- a/data/etc/handheld_core_hardware.xml +++ b/data/etc/handheld_core_hardware.xml @@ -67,6 +67,7 @@ + -- cgit v1.2.3 From e60e0437a64549ef251290bbae87830369b91f0e Mon Sep 17 00:00:00 2001 From: huans Date: Wed, 13 Jun 2018 16:07:27 -0700 Subject: Add selinux label for strongbox km4 Bug: 91777626 Test: manually started emulator with enforcement, checked lshal and dmesg Change-Id: Iee71b5971f4a8239580b7207e0149e452613d49d --- sepolicy/common/file_contexts | 1 + 1 file changed, 1 insertion(+) diff --git a/sepolicy/common/file_contexts b/sepolicy/common/file_contexts index 7cd79fe..301784a 100644 --- a/sepolicy/common/file_contexts +++ b/sepolicy/common/file_contexts @@ -27,6 +27,7 @@ /vendor/bin/hostapd_nohidl u:object_r:hostapd_nohidl_exec:s0 /vendor/bin/hw/android\.hardware\.drm@1\.0-service\.widevine u:object_r:hal_drm_widevine_exec:s0 +/vendor/bin/hw/android\.hardware\.keymaster@4\.0-strongbox-service u:object_r:hal_keymaster_default_exec:s0 /vendor/lib(64)?/hw/gralloc\.ranchu\.so u:object_r:same_process_hal_file:s0 /vendor/lib(64)?/hw/gralloc\.goldfish\.default\.so u:object_r:same_process_hal_file:s0 -- cgit v1.2.3 From 85d26b87e1b955c639f4f771c480e0b4c0ce5502 Mon Sep 17 00:00:00 2001 From: huans Date: Wed, 13 Jun 2018 16:14:28 -0700 Subject: Add drm clearkey and drm widevine sepolicy and binary Bug: 91718542 Test: run vts -m VtsHalDrmV1_0Target run cts --m CtsMediaTestCases -t android.media.cts.MediaDrmClearkeyTest Change-Id: I8e0886edab5c66b072b03c85fe9259916eefad0e --- sepolicy/common/file_contexts | 2 ++ sepolicy/common/hal_drm_clearkey.te | 11 +++++++++++ vendor.mk | 4 +++- 3 files changed, 16 insertions(+), 1 deletion(-) create mode 100644 sepolicy/common/hal_drm_clearkey.te diff --git a/sepolicy/common/file_contexts b/sepolicy/common/file_contexts index 301784a..c9712a2 100644 --- a/sepolicy/common/file_contexts +++ b/sepolicy/common/file_contexts @@ -27,6 +27,8 @@ /vendor/bin/hostapd_nohidl u:object_r:hostapd_nohidl_exec:s0 /vendor/bin/hw/android\.hardware\.drm@1\.0-service\.widevine u:object_r:hal_drm_widevine_exec:s0 +/vendor/bin/hw/android\.hardware\.drm@1\.1-service\.widevine u:object_r:hal_drm_widevine_exec:s0 +/vendor/bin/hw/android\.hardware\.drm@1\.1-service\.clearkey u:object_r:hal_drm_clearkey_exec:s0 /vendor/bin/hw/android\.hardware\.keymaster@4\.0-strongbox-service u:object_r:hal_keymaster_default_exec:s0 /vendor/lib(64)?/hw/gralloc\.ranchu\.so u:object_r:same_process_hal_file:s0 diff --git a/sepolicy/common/hal_drm_clearkey.te b/sepolicy/common/hal_drm_clearkey.te new file mode 100644 index 0000000..976b9fa --- /dev/null +++ b/sepolicy/common/hal_drm_clearkey.te @@ -0,0 +1,11 @@ +# policy for /vendor/bin/hw/android.hardware.drm@1.1-service.clearkey +type hal_drm_clearkey, domain; +type hal_drm_clearkey_exec, exec_type, vendor_file_type, file_type; + +init_daemon_domain(hal_drm_clearkey) + +hal_server_domain(hal_drm_clearkey, hal_drm) + +vndbinder_use(hal_drm_clearkey); + +allow hal_drm_clearkey { appdomain -isolated_app }:fd use; diff --git a/vendor.mk b/vendor.mk index 09870f0..025e17d 100644 --- a/vendor.mk +++ b/vendor.mk @@ -90,7 +90,9 @@ PRODUCT_PACKAGES += \ PRODUCT_PACKAGES += \ android.hardware.drm@1.0-service \ - android.hardware.drm@1.0-impl + android.hardware.drm@1.0-impl \ + android.hardware.drm@1.1-service.clearkey \ + android.hardware.drm@1.1-service.widevine PRODUCT_PACKAGES += \ android.hardware.power@1.0-service \ -- cgit v1.2.3 From 916ec9591e0f4951032e8f294b2f607dd14e33bd Mon Sep 17 00:00:00 2001 From: huans Date: Wed, 13 Jun 2018 16:42:51 -0700 Subject: Add instance 'default' for keymaster4.0 Impact emulator only Bug: 91777626 Test: Build aosp_x86_64-userdebug, lshal check services Change-Id: Ic275702273c6bb188e2fa0c45632a6ad549012c5 --- manifest.xml | 1 + 1 file changed, 1 insertion(+) diff --git a/manifest.xml b/manifest.xml index 7e723c4..8b7e695 100644 --- a/manifest.xml +++ b/manifest.xml @@ -67,6 +67,7 @@ 4.0 IKeymasterDevice + default strongbox -- cgit v1.2.3 From 0749822563a6a5fd914dd34f0180edf77beb2854 Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Wed, 13 Jun 2018 17:46:19 -0700 Subject: emulator: add a SELinux entry for goldfish battery. This change labels /sys/class/power_supply sysfs_batteryinfo to allow reading the battery status. Bug: 109735735 Test: emulator -show-kernel -verbose -kernel /tmp/arm64/4.4/kernel-qemu2 -no-boot-anim Change-Id: I9851ccdb6ae38a876318d87917a3b5f35545c57e Signed-off-by: Roman Kiryanov --- sepolicy/common/genfs_contexts | 3 +++ 1 file changed, 3 insertions(+) diff --git a/sepolicy/common/genfs_contexts b/sepolicy/common/genfs_contexts index 1b81626..02f08f0 100644 --- a/sepolicy/common/genfs_contexts +++ b/sepolicy/common/genfs_contexts @@ -16,5 +16,8 @@ genfscon sysfs /devices/pci0000:00/0000:00:08.0/virtio5/net u:object_r:sysfs_net genfscon sysfs /devices/virtual/mac80211_hwsim/hwsim0/net u:object_r:sysfs_net:s0 genfscon sysfs /devices/virtual/mac80211_hwsim/hwsim1/net u:object_r:sysfs_net:s0 +# /sys/class/power_supply +genfscon sysfs /devices/platform/9020000.goldfish_battery/power_supply u:object_r:sysfs_batteryinfo:s0 + # /proc//ns genfscon nsfs / u:object_r:nsfs:s0 -- cgit v1.2.3 From fda217c9ecaebc9bc867b9e3922ddc45cea0d863 Mon Sep 17 00:00:00 2001 From: Bjoern Johansson Date: Thu, 14 Jun 2018 16:02:30 -0700 Subject: Switch to using the goldfish RIL A previous commit created a goldfish RIL so that the emulator can use its own RIL instead of the reference RIL. However that commit did not have any changes to make the emulator images actually use the goldfish RIL. Make the necessary makefile changes to switch to the goldfish RIL and set the vendor.rild.libpath property to use the correct RIL. BUG: 110230182 Test: Compile and note that goldfish RIL changes take effect Change-Id: Ibd912e7a21421a7f0c08ce28089bf6787cf4f5ea --- arm32-vendor.mk | 2 +- arm64-vendor.mk | 2 +- vendor.mk | 1 + x86-vendor.mk | 2 +- x86_64-vendor.mk | 2 +- 5 files changed, 5 insertions(+), 4 deletions(-) diff --git a/arm32-vendor.mk b/arm32-vendor.mk index a91a4b8..ba00642 100644 --- a/arm32-vendor.mk +++ b/arm32-vendor.mk @@ -1,6 +1,6 @@ PRODUCT_PROPERTY_OVERRIDES += \ - vendor.rild.libpath=/vendor/lib/libreference-ril.so + vendor.rild.libpath=/vendor/lib/libgoldfish-ril.so # Note: the following lines need to stay at the beginning so that it can # take priority and override the rules it inherit from other mk files diff --git a/arm64-vendor.mk b/arm64-vendor.mk index a7a79b1..94717c0 100644 --- a/arm64-vendor.mk +++ b/arm64-vendor.mk @@ -1,6 +1,6 @@ PRODUCT_PROPERTY_OVERRIDES += \ - vendor.rild.libpath=/vendor/lib64/libreference-ril.so + vendor.rild.libpath=/vendor/lib64/libgoldfish-ril.so # Note: the following lines need to stay at the beginning so that it can # take priority and override the rules it inherit from other mk files diff --git a/vendor.mk b/vendor.mk index 025e17d..416313e 100644 --- a/vendor.mk +++ b/vendor.mk @@ -32,6 +32,7 @@ PRODUCT_PACKAGES += \ libEGL_swiftshader \ libGLESv1_CM_swiftshader \ libGLESv2_swiftshader \ + libgoldfish-ril \ qemu-props \ camera.goldfish \ camera.goldfish.jpeg \ diff --git a/x86-vendor.mk b/x86-vendor.mk index 6b34eaf..22e6ec7 100644 --- a/x86-vendor.mk +++ b/x86-vendor.mk @@ -1,6 +1,6 @@ PRODUCT_PROPERTY_OVERRIDES += \ - vendor.rild.libpath=/vendor/lib/libreference-ril.so + vendor.rild.libpath=/vendor/lib/libgoldfish-ril.so # This is a build configuration for a full-featured build of the # Open-Source part of the tree. It's geared toward a US-centric diff --git a/x86_64-vendor.mk b/x86_64-vendor.mk index f585573..2aa61c9 100644 --- a/x86_64-vendor.mk +++ b/x86_64-vendor.mk @@ -1,6 +1,6 @@ PRODUCT_PROPERTY_OVERRIDES += \ - vendor.rild.libpath=/vendor/lib64/libreference-ril.so + vendor.rild.libpath=/vendor/lib64/libgoldfish-ril.so # This is a build configuration for a full-featured build of the # Open-Source part of the tree. It's geared toward a US-centric -- cgit v1.2.3 From fdde7ebf0e6f1c53f0fb13da8680281d85a6cb76 Mon Sep 17 00:00:00 2001 From: Bjoern Johansson Date: Fri, 15 Jun 2018 11:24:09 -0700 Subject: Fix error code returned from sim close channel When a SIM_CLOSE_CHANNEL request fails because the channel number is invalid the emulator returns CME Error: 21 which indicates that the channel index is invalid. The reference RIL treats any error as a generic failure so this information is lost. There is a VTS test that expects the RIL error code (which is different from the CME error code) to indicate that the channel provided is an invalid argument. Inspect the return code from the modem and if it's invalid index translate it to an invalid arguments error. Otherwise return generic failure. BUG: 110212792 Test: run vts -m VtsHalRadioV1_0Target -t VtsHalRadioV1_0Target#RadioHidlTest.iccCloseLogicalChannel Change-Id: I2617458c67f7470fab12efa6068347cac01e2564 --- ril/atchannel.h | 3 ++- ril/reference-ril.c | 7 ++++++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/ril/atchannel.h b/ril/atchannel.h index 9282915..9401141 100644 --- a/ril/atchannel.h +++ b/ril/atchannel.h @@ -112,7 +112,8 @@ void at_response_free(ATResponse *p_response); typedef enum { CME_ERROR_NON_CME = -1, CME_SUCCESS = 0, - CME_SIM_NOT_INSERTED = 10 + CME_SIM_NOT_INSERTED = 10, + CME_INVALID_INDEX = 21, } AT_CME_Error; AT_CME_Error at_get_cme_error(const ATResponse *p_response); diff --git a/ril/reference-ril.c b/ril/reference-ril.c index 084c4ad..3bca581 100644 --- a/ril/reference-ril.c +++ b/ril/reference-ril.c @@ -1878,9 +1878,14 @@ static void requestSimCloseChannel(void *data, size_t datalen, RIL_Token t) err = at_send_command_singleline(cmd, "+CCHC", &p_response); if (err < 0 || p_response == NULL || p_response->success == 0) { + AT_CME_Error cme = p_response ? at_get_cme_error(p_response) : + CME_ERROR_NON_CME; + RIL_Errno ril_e = (cme == CME_INVALID_INDEX) ? RIL_E_INVALID_ARGUMENTS : + RIL_E_GENERIC_FAILURE; + ALOGE("Error %d closing logical channel %d: %d", err, session_id, p_response ? p_response->success : 0); - RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + RIL_onRequestComplete(t, ril_e, NULL, 0); at_response_free(p_response); return; } -- cgit v1.2.3 From 4772b3d4eb604875d70ac693704a29ea6da8f27f Mon Sep 17 00:00:00 2001 From: huans Date: Fri, 15 Jun 2018 10:56:16 -0700 Subject: Add health service 2.0 goldfish Bug: 110263143 Test: Build and run emulator. lshal shows android.hardware.health@2.0::IHealth/backup served by process health service 2.0 goldfish Change-Id: I1055d73cf001c5219c841a25e28eaa4d30f1af52 --- health/Android.bp | 30 ++++++++++++++++++++++ health/HealthService.cpp | 12 +++++++++ ...android.hardware.health@2.0-service.goldfish.rc | 5 ++++ manifest.xml | 9 +++++++ sepolicy/common/file_contexts | 1 + vendor.mk | 3 +++ 6 files changed, 60 insertions(+) create mode 100644 health/Android.bp create mode 100644 health/HealthService.cpp create mode 100644 health/android.hardware.health@2.0-service.goldfish.rc diff --git a/health/Android.bp b/health/Android.bp new file mode 100644 index 0000000..aab4fa9 --- /dev/null +++ b/health/Android.bp @@ -0,0 +1,30 @@ +cc_binary { + name: "android.hardware.health@2.0-service.goldfish", + init_rc: ["android.hardware.health@2.0-service.goldfish.rc"], + proprietary: true, + relative_install_path: "hw", + srcs: [ + "HealthService.cpp", + ], + cflags: [ + "-Wall", + "-Werror", + ], + static_libs: [ + "android.hardware.health@2.0-impl", + "android.hardware.health@1.0-convert", + "libhealthservice", + "libbatterymonitor", + "libhealthstoragedefault", + ], + shared_libs: [ + "libbase", + "libcutils", + "libhidlbase", + "libhidltransport", + "libhwbinder", + "libutils", + "android.hardware.health@2.0", + ], + header_libs: ["libhealthd_headers"], +} diff --git a/health/HealthService.cpp b/health/HealthService.cpp new file mode 100644 index 0000000..2498a5c --- /dev/null +++ b/health/HealthService.cpp @@ -0,0 +1,12 @@ +#include +#include + +int main() { + return health_service_main(); +} + +void healthd_board_init(struct healthd_config*) {} + +int healthd_board_battery_update(struct android::BatteryProperties*) { + return 0; +} diff --git a/health/android.hardware.health@2.0-service.goldfish.rc b/health/android.hardware.health@2.0-service.goldfish.rc new file mode 100644 index 0000000..ecd42e4 --- /dev/null +++ b/health/android.hardware.health@2.0-service.goldfish.rc @@ -0,0 +1,5 @@ +service vendor.health-hal-2-0 /vendor/bin/hw/android.hardware.health@2.0-service.goldfish + class hal + user system + group system + file /dev/kmsg w diff --git a/manifest.xml b/manifest.xml index 8b7e695..413042d 100644 --- a/manifest.xml +++ b/manifest.xml @@ -219,6 +219,15 @@ default + + android.hardware.health + hwbinder + 2.0 + + IHealth + default + + 27.0 diff --git a/sepolicy/common/file_contexts b/sepolicy/common/file_contexts index c9712a2..c0c7e5e 100644 --- a/sepolicy/common/file_contexts +++ b/sepolicy/common/file_contexts @@ -30,6 +30,7 @@ /vendor/bin/hw/android\.hardware\.drm@1\.1-service\.widevine u:object_r:hal_drm_widevine_exec:s0 /vendor/bin/hw/android\.hardware\.drm@1\.1-service\.clearkey u:object_r:hal_drm_clearkey_exec:s0 /vendor/bin/hw/android\.hardware\.keymaster@4\.0-strongbox-service u:object_r:hal_keymaster_default_exec:s0 +/vendor/bin/hw/android\.hardware\.health@2\.0-service.goldfish u:object_r:hal_health_default_exec:s0 /vendor/lib(64)?/hw/gralloc\.ranchu\.so u:object_r:same_process_hal_file:s0 /vendor/lib(64)?/hw/gralloc\.goldfish\.default\.so u:object_r:same_process_hal_file:s0 diff --git a/vendor.mk b/vendor.mk index 416313e..5d702d9 100644 --- a/vendor.mk +++ b/vendor.mk @@ -74,6 +74,9 @@ PRODUCT_PACKAGES += \ android.hardware.broadcastradio@1.0-impl \ android.hardware.soundtrigger@2.0-impl +PRODUCT_PACKAGES += \ + android.hardware.health@2.0-service.goldfish + PRODUCT_PACKAGES += \ android.hardware.keymaster@3.0-impl \ android.hardware.keymaster@3.0-service -- cgit v1.2.3 From 950c5dc4d947c70c151bc92fb597c41902b36dc4 Mon Sep 17 00:00:00 2001 From: Bjoern Johansson Date: Fri, 15 Jun 2018 14:36:40 -0700 Subject: Return result after RIL set auto network selection Our RIL was only returning the result of set network selection automatic if the SIM card is absent. On other types of failure or success nothing was returned. This results in a timeout in the upper RIL layers because they never get to know if the request was successful or not. Return results for successful or failed requests based on the modem's response. This fixes tests that rely on the return code to know whether the operation succeeded or not. BUG: 110212792 Test: run vts -m VtsHalRadioV1_0Target -t VtsHalRadioV1_0Target#RadioHidlTest.setNetworkSelectionModeAutomatic Change-Id: I82569285fb4f5274d4be72802aad00cffd5a91ec --- ril/reference-ril.c | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/ril/reference-ril.c b/ril/reference-ril.c index 3bca581..03c9897 100644 --- a/ril/reference-ril.c +++ b/ril/reference-ril.c @@ -780,6 +780,27 @@ error: at_response_free(p_response); } +static void setNetworkSelectionAutomatic(RIL_Token t) +{ + int err; + ATResponse *p_response = NULL; + + if (getSIMStatus() == SIM_ABSENT) { + RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); + return; + } + + err = at_send_command("AT+COPS=0", &p_response); + + if (err < 0 || p_response == NULL || p_response->success == 0) { + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } else { + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } + + at_response_free(p_response); +} + static void requestQueryNetworkSelectionMode( void *data __unused, size_t datalen __unused, RIL_Token t) { @@ -2585,11 +2606,7 @@ onRequest (int request, void *data, size_t datalen, RIL_Token t) break; case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC: - if (getSIMStatus() == SIM_ABSENT) { - RIL_onRequestComplete(t, RIL_E_RADIO_NOT_AVAILABLE, NULL, 0); - } else { - at_send_command("AT+COPS=0", NULL); - } + setNetworkSelectionAutomatic(t); break; case RIL_REQUEST_DATA_CALL_LIST: -- cgit v1.2.3 From 3b8c3e0c54b159d95aea0d212f3d2c3d9909aefc Mon Sep 17 00:00:00 2001 From: Bjoern Johansson Date: Wed, 23 May 2018 10:23:50 -0700 Subject: Add SELinux rule to allow vold to access nsfs An earlier change to support WiFi in the emulator created a context for nsfs, the namespace filesystem. This change caused vold to no longer have access to that part of /proc which is causing problems. Allow vold to access nsfs to make it happy. BUG: 79699591 Test: Run app that requires storage permissions, verify that it works Change-Id: Ia840d45b6d3d92f652ea46e51fd4ec19d3c4b809 --- sepolicy/common/vold.te | 2 ++ 1 file changed, 2 insertions(+) diff --git a/sepolicy/common/vold.te b/sepolicy/common/vold.te index 5f3bdd4..bea4501 100644 --- a/sepolicy/common/vold.te +++ b/sepolicy/common/vold.te @@ -1 +1,3 @@ dontaudit vold kernel:system module_request; + +allow vold nsfs:file r_file_perms; -- cgit v1.2.3 From 5168292543096b59117f3a923a2c0e2a17485722 Mon Sep 17 00:00:00 2001 From: Weilun Du Date: Wed, 13 Jun 2018 11:49:44 -0700 Subject: Emulator: add CSIM authentication support Test: run cts -m CtsCarrierApiTestCases -t android.carrierapi.cts.CarrierApiTest#testGetIccAuthentication BUG: 74389924 BUG: 75284151 Exempt-From-Owner-Approval: Change-Id: I71c96f2c2fbefba838c356690c79e0deec35d423 Signed-off-by: Weilun Du --- ril/reference-ril.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) diff --git a/ril/reference-ril.c b/ril/reference-ril.c index 084c4ad..a549d85 100644 --- a/ril/reference-ril.c +++ b/ril/reference-ril.c @@ -410,6 +410,21 @@ static RIL_Errno setInterfaceState(const char* interfaceName, return RIL_E_SUCCESS; } +static void parseAuthResponse(char* line, RIL_SIM_IO_Response* response) { + // example string +CSIM=number, "9000" + // get the status first + int len = strlen(line); + char* first_double_quote = strchr(line, '"'); + if (first_double_quote == NULL) { + RLOGE("%s bad response %s", __func__, line); + return; + } + char* data_ptr = first_double_quote + 1; + sscanf(line + (len -5), "%2x%2x", &(response->sw1), &(response->sw2)); + line[len-5] = '\0'; + response->simResponse = strdup(data_ptr); +} + /** do post-AT+CFUN=1 initialization */ static void onRadioPowerOn() { @@ -2327,6 +2342,52 @@ static void requestGetMute(void *data, size_t datalen, RIL_Token t) RIL_onRequestComplete(t, RIL_E_SUCCESS, &muteResponse, sizeof(muteResponse)); } +static void requestGetSimAuthentication(void *data, size_t datalen __unused, RIL_Token t) +{ + // TODO - hook this up with real query/info from radio. + RIL_SimAuthentication* auth = (RIL_SimAuthentication*)data; + + RIL_SIM_IO_Response auth_response = { + 0x90, + 0x00, + "" + }; + + // special case: empty authData, should return empty response + if (auth->authData == NULL || strlen(auth->authData) == 0) { + char reply[] = ""; + RIL_onRequestComplete(t, RIL_E_SUCCESS, &auth_response, sizeof(auth_response)); + RLOGD("%s empty data in", __func__); + return; + } + + //talk to modem + ATResponse *p_response = NULL; + memset(&auth_response, 0, sizeof(auth_response)); + int err; + char *cmd = NULL; + int auth_len = strlen(auth->authData); + int total_len = auth_len + 12; + asprintf(&cmd, "AT+CSIM=%d, \"008800%02x%02x%s00\"", total_len, auth->authContext, + auth_len, auth->authData); + + err = at_send_command_singleline(cmd, "+CSIM:", &p_response); + if (err < 0 || p_response == NULL || p_response->success == 0) { + ALOGE("%s Error %d transmitting CSIM: %d", __func__, + err, p_response ? p_response->success : 0); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + at_response_free(p_response); + return; + } + + char* line = p_response->p_intermediates->line; + + parseAuthResponse(line, &auth_response); + RIL_onRequestComplete(t, RIL_E_SUCCESS, &auth_response, sizeof(auth_response)); + free(auth_response.simResponse); + free(p_response); +} + /*** Callback methods from the RIL library to us ***/ /** @@ -2726,6 +2787,10 @@ onRequest (int request, void *data, size_t datalen, RIL_Token t) RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); break; + case RIL_REQUEST_SIM_AUTHENTICATION: + requestGetSimAuthentication(data, datalen, t); + break; + case RIL_REQUEST_BASEBAND_VERSION: requestCdmaBaseBandVersion(request, data, datalen, t); break; -- cgit v1.2.3 From 271cd94c86c0067476e2e49b882e66329b1ab907 Mon Sep 17 00:00:00 2001 From: Yahan Zhou Date: Mon, 18 Jun 2018 17:41:39 -0700 Subject: Sepolicy for DRM Exempt-From-Owner-Approval: Test: atest VtsHalDrmV1_0Target BUG: 91718542 Change-Id: Iaf800cb7157911f503826a8204472085d1ab84af --- sepolicy/common/hal_drm_widevine.te | 1 + 1 file changed, 1 insertion(+) diff --git a/sepolicy/common/hal_drm_widevine.te b/sepolicy/common/hal_drm_widevine.te index d49000d..8198410 100644 --- a/sepolicy/common/hal_drm_widevine.te +++ b/sepolicy/common/hal_drm_widevine.te @@ -10,5 +10,6 @@ allow hal_drm { appdomain -isolated_app }:fd use; vndbinder_use(hal_drm_widevine); hal_client_domain(hal_drm_widevine, hal_graphics_composer); +allow hal_drm_widevine hal_allocator_server:fd use; allow hal_drm_widevine mediadrm_vendor_data_file:dir create_dir_perms; allow hal_drm_widevine mediadrm_vendor_data_file:file create_file_perms; -- cgit v1.2.3 From d69c26bfeccb6d612a6eb231ca5b94a5ea1d3446 Mon Sep 17 00:00:00 2001 From: bohu Date: Wed, 20 Jun 2018 08:45:13 -0700 Subject: Exclude non essenstial services from arm images. We found arm images boot better without gnss. This change removes gnss, arm by creating a separate manifest.xml Bug: 109735735 Exempt-From-Owner-Approval: Change-Id: Iabc01cc256967466b7d3c12de115b0270a71d13c Signed-off-by: Roman Kiryanov --- arm32-vendor.mk | 2 + arm64-vendor.mk | 3 + manifest-arm.xml | 225 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ vendor.mk | 2 + 4 files changed, 232 insertions(+) create mode 100644 manifest-arm.xml diff --git a/arm32-vendor.mk b/arm32-vendor.mk index ba00642..2d10d89 100644 --- a/arm32-vendor.mk +++ b/arm32-vendor.mk @@ -6,7 +6,9 @@ PRODUCT_PROPERTY_OVERRIDES += \ # take priority and override the rules it inherit from other mk files # see copy file rules in core/Makefile PRODUCT_COPY_FILES += \ + device/generic/goldfish/manifest-arm.xml:$(TARGET_COPY_OUT_VENDOR)/manifest.xml \ development/sys-img/advancedFeatures.ini.arm:advancedFeatures.ini \ prebuilts/qemu-kernel/arm64/4.4/kernel-qemu2:kernel-ranchu-64 \ device/generic/goldfish/fstab.ranchu.arm:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.ranchu +EMULATOR_VENDOR_NO_GNSS := true diff --git a/arm64-vendor.mk b/arm64-vendor.mk index 94717c0..1dd977e 100644 --- a/arm64-vendor.mk +++ b/arm64-vendor.mk @@ -6,7 +6,10 @@ PRODUCT_PROPERTY_OVERRIDES += \ # take priority and override the rules it inherit from other mk files # see copy file rules in core/Makefile PRODUCT_COPY_FILES += \ + device/generic/goldfish/manifest-arm.xml:$(TARGET_COPY_OUT_VENDOR)/manifest.xml \ development/sys-img/advancedFeatures.ini.arm:advancedFeatures.ini \ prebuilts/qemu-kernel/arm64/4.4/kernel-qemu2:kernel-ranchu \ device/generic/goldfish/fstab.ranchu.arm:$(TARGET_COPY_OUT_VENDOR)/etc/fstab.ranchu +EMULATOR_VENDOR_NO_GNSS := true + diff --git a/manifest-arm.xml b/manifest-arm.xml new file mode 100644 index 0000000..aab5137 --- /dev/null +++ b/manifest-arm.xml @@ -0,0 +1,225 @@ + + + android.hardware.drm + hwbinder + 1.0 + + ICryptoFactory + default + + + IDrmFactory + default + + @1.1::ICryptoFactory/clearkey + @1.1::IDrmFactory/clearkey + @1.1::ICryptoFactory/widevine + @1.1::IDrmFactory/widevine + + + android.hardware.audio.effect + hwbinder + 2.0 + + IEffectsFactory + default + + + + android.hardware.biometrics.fingerprint + hwbinder + 2.1 + + IBiometricsFingerprint + default + + + + android.hardware.configstore + hwbinder + 1.0 + + ISurfaceFlingerConfigs + default + + + + android.hardware.audio + hwbinder + 2.0 + + IDevicesFactory + default + + + + android.hardware.keymaster + hwbinder + 3.0 + + IKeymasterDevice + default + + + + android.hardware.keymaster + hwbinder + 4.0 + + IKeymasterDevice + default + strongbox + + + + android.hardware.graphics.allocator + hwbinder + 2.0 + + IAllocator + default + + + + android.hardware.graphics.mapper + passthrough + 2.0 + + IMapper + default + + + + android.hardware.graphics.composer + hwbinder + 2.1 + + IComposer + default + + + + android.hardware.power + hwbinder + 1.0 + + IPower + default + + + + android.hardware.broadcastradio + hwbinder + 1.0 + + IBroadcastRadioFactory + default + + + + android.hardware.camera.provider + hwbinder + 2.4 + + ICameraProvider + legacy/0 + + + + android.hardware.sensors + hwbinder + 1.0 + + ISensors + default + + + + android.hardware.gatekeeper + hwbinder + 1.0 + + IGatekeeper + default + + + + android.hardware.media.omx + hwbinder + 1.0 + + IOmx + default + + + IOmxStore + default + + + + android.hardware.radio.deprecated + hwbinder + 1.0 + + IOemHook + slot1 + + + + android.hardware.radio + hwbinder + 1.0 + + IRadio + slot1 + + + + android.hardware.wifi + hwbinder + 1.0 + + IWifi + default + + + + android.hardware.wifi.hostapd + hwbinder + 1.0 + + IHostapd + default + + + + android.hardware.wifi.supplicant + hwbinder + 1.0 + + ISupplicant + default + + + + android.hardware.cas + hwbinder + 1.0 + + IMediaCasService + default + + + + android.hardware.health + hwbinder + 2.0 + + IHealth + default + + + + 27.0 + + diff --git a/vendor.mk b/vendor.mk index 5d702d9..51be81f 100644 --- a/vendor.mk +++ b/vendor.mk @@ -84,9 +84,11 @@ PRODUCT_PACKAGES += \ PRODUCT_PACKAGES += \ android.hardware.keymaster@4.0-strongbox-service +ifneq ($(EMULATOR_VENDOR_NO_GNSS),true) PRODUCT_PACKAGES += \ android.hardware.gnss@1.0-service \ android.hardware.gnss@1.0-impl +endif PRODUCT_PACKAGES += \ android.hardware.sensors@1.0-impl \ -- cgit v1.2.3 From 6a7cea4791cdd2eba2625c018e7d978f4bedbc9e Mon Sep 17 00:00:00 2001 From: Weilun Du Date: Thu, 21 Jun 2018 11:13:55 -0700 Subject: [Workaround] Add dummy userdata.img to pass avd manager check Avd manager in Android Studio requires userdata.img in the downloaded system image. As we no longer inlcude the real userdata.img, we created this dummy userdata.img to pass the check. This cl does not impact real devices. BUG: 110492064 Change-Id: I401a5d9bbcb7c95b86039dab968e774970a5a21c Signed-off-by: Weilun Du --- data/etc/userdata.img | Bin 0 -> 1048576 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 data/etc/userdata.img diff --git a/data/etc/userdata.img b/data/etc/userdata.img new file mode 100644 index 0000000..9e0f96a Binary files /dev/null and b/data/etc/userdata.img differ -- cgit v1.2.3 From 9cd132b0458e0615d100cf0e1316870567155125 Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Thu, 21 Jun 2018 18:17:50 -0700 Subject: Add support to query modem activity info in ril Implement RIL_REQUEST_GET_ACTIVITY_INFO to pass testModemActivityInfo. Bug: 78235709 Test: ./android-cts/tools/cts-tradefed run cts -m CtsStatsdHostTestCases \ -t android.cts.statsd.atom.HostAtomTests#testModemActivityInfo Signed-off-by: Roman Kiryanov Change-Id: I4df288f270d896027a19a495874e125ac5def359 --- ril/reference-ril.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) diff --git a/ril/reference-ril.c b/ril/reference-ril.c index 4503e1b..0f56a19 100644 --- a/ril/reference-ril.c +++ b/ril/reference-ril.c @@ -2414,6 +2414,44 @@ static void requestGetSimAuthentication(void *data, size_t datalen __unused, RIL free(p_response); } +static void requestModemActivityInfo(RIL_Token t) +{ + int err; + char *line; + ATResponse *p_response = NULL; + RIL_ActivityStatsInfo info; + + err = at_send_command_singleline("AT+MAI", "+MAI:", &p_response); + if (err < 0 || p_response == NULL || p_response->success == 0) { + ALOGE("Error transmitting AT+MAI, err=%d, success=%d", + err, (p_response ? p_response->success : 0)); + goto error; + } + + memset(&info, 0, sizeof(info)); + if (sscanf(p_response->p_intermediates->line, + "+MAI: sleep=%u idle=%u rx=%u tx0=%u tx1=%u tx2=%u tx3=%u tx4=%u", + &info.sleep_mode_time_ms, + &info.idle_mode_time_ms, + &info.rx_mode_time_ms, + &info.tx_mode_time_ms[0], + &info.tx_mode_time_ms[1], + &info.tx_mode_time_ms[2], + &info.tx_mode_time_ms[3], + &info.tx_mode_time_ms[4]) == 8) { + RIL_onRequestComplete(t, RIL_E_SUCCESS, &info, sizeof(info)); + at_response_free(p_response); + return; + } else { + ALOGE("Unexpected response for AT+MAI: '%s'", + p_response->p_intermediates->line); + } + +error: + at_response_free(p_response); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); +} + /*** Callback methods from the RIL library to us ***/ /** @@ -2874,6 +2912,10 @@ onRequest (int request, void *data, size_t datalen, RIL_Token t) } break; + case RIL_REQUEST_GET_ACTIVITY_INFO: + requestModemActivityInfo(t); + break; + default: RLOGD("Request not supported. Tech: %d",TECH(sMdmInfo)); RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); -- cgit v1.2.3 From 64eca14642a5a75a966239b4d6ff7ad387dad51a Mon Sep 17 00:00:00 2001 From: huans Date: Mon, 18 Jun 2018 14:45:46 -0700 Subject: Update to audio 4.0 hal interface Bug: 110368387 Test: run vts -m VtsHalAudioEffectV4_0Target Change-Id: I3ea3293f17b671184b2d10e182d38a318cf9be32 --- manifest.xml | 4 ++-- vendor.mk | 13 +++++++++---- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/manifest.xml b/manifest.xml index 413042d..6594133 100644 --- a/manifest.xml +++ b/manifest.xml @@ -19,7 +19,7 @@ android.hardware.audio.effect hwbinder - 2.0 + 4.0 IEffectsFactory default @@ -46,7 +46,7 @@ android.hardware.audio hwbinder - 2.0 + 4.0 IDevicesFactory default diff --git a/vendor.mk b/vendor.mk index 51be81f..c68aaa7 100644 --- a/vendor.mk +++ b/vendor.mk @@ -68,8 +68,8 @@ PRODUCT_PACKAGES += \ SdkSetup PRODUCT_PACKAGES += \ - android.hardware.audio@2.0-impl \ - android.hardware.audio.effect@2.0-impl \ + android.hardware.audio@4.0-impl:32 \ + android.hardware.audio.effect@4.0-impl:32 \ android.hardware.broadcastradio@1.1-service \ android.hardware.broadcastradio@1.0-impl \ android.hardware.soundtrigger@2.0-impl @@ -153,5 +153,10 @@ PRODUCT_COPY_FILES += \ frameworks/native/data/etc/android.hardware.camera.full.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.camera.full.xml \ frameworks/native/data/etc/android.hardware.fingerprint.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.fingerprint.xml \ frameworks/native/data/etc/android.software.autofill.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.software.autofill.xml \ - frameworks/av/media/libeffects/data/audio_effects.conf:$(TARGET_COPY_OUT_VENDOR)/etc/audio_effects.conf \ - device/generic/goldfish/audio_policy.conf:$(TARGET_COPY_OUT_VENDOR)/etc/audio_policy.conf + frameworks/av/media/libeffects/data/audio_effects.xml:$(TARGET_COPY_OUT_VENDOR)/etc/audio_effects.xml \ + device/generic/goldfish/audio_policy.conf:$(TARGET_COPY_OUT_VENDOR)/etc/audio_policy.conf \ + frameworks/av/services/audiopolicy/config/audio_policy_configuration_generic.xml:$(TARGET_COPY_OUT_VENDOR)/etc/audio_policy_configuration.xml \ + frameworks/av/services/audiopolicy/config/primary_audio_policy_configuration.xml:$(TARGET_COPY_OUT_VENDOR)/etc/primary_audio_policy_configuration.xml \ + frameworks/av/services/audiopolicy/config/r_submix_audio_policy_configuration.xml:$(TARGET_COPY_OUT_VENDOR)/etc/r_submix_audio_policy_configuration.xml \ + frameworks/av/services/audiopolicy/config/audio_policy_volumes.xml:$(TARGET_COPY_OUT_VENDOR)/etc/audio_policy_volumes.xml \ + frameworks/av/services/audiopolicy/config/default_volume_tables.xml:$(TARGET_COPY_OUT_VENDOR)/etc/default_volume_tables.xml \ -- cgit v1.2.3 From 4b884531b94ef96337e2fa57efd847f111292d5d Mon Sep 17 00:00:00 2001 From: huans Date: Wed, 20 Jun 2018 12:42:47 -0700 Subject: Goldfish Audio HAL update Add function for microphone; Add handling for parameters SUP_FORMATs and FORMAT Misc. fix Bug: 110367728 Test: run vts -m VtsHalAudioV4_0Target run cts -m CtsNativeMediaAAudioTestCases run cts -m CtsSpeechTestCases Change-Id: Ibd4d4a96c6280b8f6014a05b18f7ab043fed2f18 --- audio/audio_hw.c | 120 +++++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 107 insertions(+), 13 deletions(-) diff --git a/audio/audio_hw.c b/audio/audio_hw.c index 10cf730..071b47f 100644 --- a/audio/audio_hw.c +++ b/audio/audio_hw.c @@ -60,6 +60,10 @@ static struct audio_module* sFallback; static pthread_once_t sFallbackOnce = PTHREAD_ONCE_INIT; static void fallback_init(void); static int adev_get_mic_mute(const struct audio_hw_device *dev, bool *state); +static int adev_get_microphones(const audio_hw_device_t *dev, + struct audio_microphone_characteristic_t *mic_array, + size_t *mic_count); + typedef struct audio_vbuffer { pthread_mutex_t lock; @@ -265,6 +269,7 @@ static audio_channel_mask_t out_get_channels(const struct audio_stream *stream) static audio_format_t out_get_format(const struct audio_stream *stream) { struct generic_stream_out *out = (struct generic_stream_out *)stream; + return out->req_config.format; } @@ -299,7 +304,7 @@ static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) struct generic_stream_out *out = (struct generic_stream_out *)stream; struct str_parms *parms; char value[32]; - int ret; + int ret = -ENOSYS; int success; long val; char *end; @@ -308,11 +313,7 @@ static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) return 0; } pthread_mutex_lock(&out->lock); - if (!out->standby) { - //Do not support changing params while stream running - ret = -ENOSYS; - } else { - ret = -EINVAL; + if (out->standby) { parms = str_parms_create_str(kvpairs); success = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); @@ -338,7 +339,7 @@ static int out_set_parameters(struct audio_stream *stream, const char *kvpairs) } if (ret != 0) { - ALOGD("Unsupported parameter %s", kvpairs); + ALOGD("%s Unsupported parameter %s", __FUNCTION__, kvpairs); } str_parms_destroy(parms); @@ -355,14 +356,36 @@ static char * out_get_parameters(const struct audio_stream *stream, const char * char value[256]; struct str_parms *reply = str_parms_create(); int ret; + bool get = false; ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); if (ret >= 0) { pthread_mutex_lock(&out->lock); str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, out->device); pthread_mutex_unlock(&out->lock); + get = true; + } + + if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS)) { + value[0] = 0; + strcat(value, "AUDIO_FORMAT_PCM_16_BIT"); + str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_FORMATS, value); + get = true; + } + + if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_FORMAT)) { + value[0] = 0; + strcat(value, "AUDIO_FORMAT_PCM_16_BIT"); + str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_FORMAT, value); + get = true; + } + + if (get) { str = strdup(str_parms_to_str(reply)); } + else { + ALOGD("%s Unsupported paramter: %s", __FUNCTION__, keys); + } str_parms_destroy(query); str_parms_destroy(reply); @@ -818,7 +841,7 @@ static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) struct generic_stream_in *in = (struct generic_stream_in *)stream; struct str_parms *parms; char value[32]; - int ret; + int ret = -ENOSYS; int success; long val; char *end; @@ -827,10 +850,7 @@ static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) return 0; } pthread_mutex_lock(&in->lock); - if (!in->standby) { - ret = -ENOSYS; - } else { - ret = -EINVAL; + if (in->standby) { parms = str_parms_create_str(kvpairs); success = str_parms_get_str(parms, AUDIO_PARAMETER_STREAM_ROUTING, @@ -856,7 +876,7 @@ static int in_set_parameters(struct audio_stream *stream, const char *kvpairs) } if (ret != 0) { - ALOGD("Unsupported parameter %s", kvpairs); + ALOGD("%s: Unsupported parameter %s", __FUNCTION__, kvpairs); } str_parms_destroy(parms); @@ -874,12 +894,34 @@ static char * in_get_parameters(const struct audio_stream *stream, char value[256]; struct str_parms *reply = str_parms_create(); int ret; + bool get = false; ret = str_parms_get_str(query, AUDIO_PARAMETER_STREAM_ROUTING, value, sizeof(value)); if (ret >= 0) { str_parms_add_int(reply, AUDIO_PARAMETER_STREAM_ROUTING, in->device); + get = true; + } + + if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_SUP_FORMATS)) { + value[0] = 0; + strcat(value, "AUDIO_FORMAT_PCM_16_BIT"); + str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_SUP_FORMATS, value); + get = true; + } + + if (str_parms_has_key(query, AUDIO_PARAMETER_STREAM_FORMAT)) { + value[0] = 0; + strcat(value, "AUDIO_FORMAT_PCM_16_BIT"); + str_parms_add_str(reply, AUDIO_PARAMETER_STREAM_FORMAT, value); + get = true; + } + + if (get) { str = strdup(str_parms_to_str(reply)); } + else { + ALOGD("%s Unsupported paramter: %s", __FUNCTION__, keys); + } str_parms_destroy(query); str_parms_destroy(reply); @@ -1001,6 +1043,7 @@ static void *in_read_worker(void * args) if (ret != 0) { ALOGW("pcm_read failed %s", pcm_get_error(pcm)); restart = true; + continue; } pthread_mutex_lock(&in->lock); @@ -1128,6 +1171,13 @@ static int in_get_capture_position(const struct audio_stream_in *stream, return 0; } +static int in_get_active_microphones(const struct audio_stream_in *stream, + struct audio_microphone_characteristic_t *mic_array, + size_t *mic_count) +{ + return adev_get_microphones(NULL, mic_array, mic_count); +} + static int in_add_audio_effect(const struct audio_stream *stream, effect_handle_t effect) { // in_add_audio_effect is a no op @@ -1374,6 +1424,7 @@ static int adev_open_input_stream(struct audio_hw_device *dev, in->stream.read = in_read; in->stream.get_input_frames_lost = in_get_input_frames_lost; // no op in->stream.get_capture_position = in_get_capture_position; + in->stream.get_active_microphones = in_get_active_microphones; pthread_mutex_init(&in->lock, (const pthread_mutexattr_t *) NULL); in->dev = adev; @@ -1415,6 +1466,48 @@ static int adev_dump(const audio_hw_device_t *dev, int fd) return 0; } +static int adev_get_microphones(const audio_hw_device_t *dev, + struct audio_microphone_characteristic_t *mic_array, + size_t *mic_count) +{ + if (mic_count == NULL) { + return -ENOSYS; + } + + if (*mic_count == 0) { + *mic_count = 1; + return 0; + } + + if (mic_array == NULL) { + return -ENOSYS; + } + + strncpy(mic_array->device_id, "mic_goldfish", AUDIO_MICROPHONE_ID_MAX_LEN - 1); + mic_array->device = AUDIO_DEVICE_IN_BUILTIN_MIC; + strncpy(mic_array->address, AUDIO_BOTTOM_MICROPHONE_ADDRESS, + AUDIO_DEVICE_MAX_ADDRESS_LEN - 1); + memset(mic_array->channel_mapping, AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED, + sizeof(mic_array->channel_mapping)); + mic_array->location = AUDIO_MICROPHONE_LOCATION_UNKNOWN; + mic_array->group = 0; + mic_array->index_in_the_group = 0; + mic_array->sensitivity = AUDIO_MICROPHONE_SENSITIVITY_UNKNOWN; + mic_array->max_spl = AUDIO_MICROPHONE_SPL_UNKNOWN; + mic_array->min_spl = AUDIO_MICROPHONE_SPL_UNKNOWN; + mic_array->directionality = AUDIO_MICROPHONE_DIRECTIONALITY_UNKNOWN; + mic_array->num_frequency_responses = 0; + mic_array->geometric_location.x = AUDIO_MICROPHONE_COORDINATE_UNKNOWN; + mic_array->geometric_location.y = AUDIO_MICROPHONE_COORDINATE_UNKNOWN; + mic_array->geometric_location.z = AUDIO_MICROPHONE_COORDINATE_UNKNOWN; + mic_array->orientation.x = AUDIO_MICROPHONE_COORDINATE_UNKNOWN; + mic_array->orientation.y = AUDIO_MICROPHONE_COORDINATE_UNKNOWN; + mic_array->orientation.z = AUDIO_MICROPHONE_COORDINATE_UNKNOWN; + + *mic_count = 1; + return 0; +} + static int adev_close(hw_device_t *dev) { struct generic_audio_device *adev = (struct generic_audio_device *)dev; @@ -1489,6 +1582,7 @@ static int adev_open(const hw_module_t* module, const char* name, adev->device.open_input_stream = adev_open_input_stream; adev->device.close_input_stream = adev_close_input_stream; adev->device.dump = adev_dump; + adev->device.get_microphones = adev_get_microphones; *device = &adev->device.common; -- cgit v1.2.3 From 207a57241e02e0c13d152b754ce998997bbe4442 Mon Sep 17 00:00:00 2001 From: huans Date: Mon, 25 Jun 2018 10:23:28 -0700 Subject: Update to target-level 3. Remove deprecated radio hal Bug: 110113210 Test: verify wifi, radio working. Run vts, no regression. Change-Id: Idc548734cae710ecf86144110cfb9cefda72b2d7 --- manifest-arm.xml | 11 +---------- manifest.xml | 11 +---------- 2 files changed, 2 insertions(+), 20 deletions(-) diff --git a/manifest-arm.xml b/manifest-arm.xml index aab5137..c4d10dd 100644 --- a/manifest-arm.xml +++ b/manifest-arm.xml @@ -1,4 +1,4 @@ - + android.hardware.drm hwbinder @@ -156,15 +156,6 @@ default - - android.hardware.radio.deprecated - hwbinder - 1.0 - - IOemHook - slot1 - - android.hardware.radio hwbinder diff --git a/manifest.xml b/manifest.xml index 6594133..bd40ed3 100644 --- a/manifest.xml +++ b/manifest.xml @@ -1,4 +1,4 @@ - + android.hardware.drm hwbinder @@ -165,15 +165,6 @@ default - - android.hardware.radio.deprecated - hwbinder - 1.0 - - IOemHook - slot1 - - android.hardware.radio hwbinder -- cgit v1.2.3 From 1460ce34e98074a5b0f8c96b5bb98a4bd9d2ea45 Mon Sep 17 00:00:00 2001 From: Akash Agrawal Date: Wed, 20 Jun 2018 16:08:19 -0700 Subject: Generating new artifact called emulator-info.txt For a given build of sys-image, a stable emulator build is added to the emulator-info.txt which will end up in generated emulator-info.txt artifact. This information will be used by the testing infrastructure while using GCE instances. Bug: b/110053895 Test: A local build will generate "emulator-info.txt" with the following "require version-emulator=" line. Exempt-From-Owner-Approval: Change-Id: Ib0807d7da3d49bc8635515b369c231fc2c6d5d9a --- Android.mk | 9 +++++++++ emulator-info.txt | 2 ++ 2 files changed, 11 insertions(+) create mode 100644 emulator-info.txt diff --git a/Android.mk b/Android.mk index fef7f95..6350f27 100644 --- a/Android.mk +++ b/Android.mk @@ -17,6 +17,15 @@ LOCAL_PATH := $(call my-dir) ifeq ($(BUILD_QEMU_IMAGES),true) + INSTALLED_EMULATOR_INFO_TXT_TARGET := $(PRODUCT_OUT)/emulator-info.txt + emulator_info_txt := $(wildcard ${LOCAL_PATH}/emulator-info.txt) + + $(INSTALLED_EMULATOR_INFO_TXT_TARGET): $(emulator_info_txt) + $(call pretty,"Generated: ($@)") + $(hide) grep -v '#' $< > $@ + + $(call dist-for-goals, dist_files, $(INSTALLED_EMULATOR_INFO_TXT_TARGET)) + subdir_makefiles=$(call first-makefiles-under,$(LOCAL_PATH)) $(foreach mk,$(subdir_makefiles),$(info including $(mk) ...)$(eval include $(mk))) endif diff --git a/emulator-info.txt b/emulator-info.txt new file mode 100644 index 0000000..6fed42f --- /dev/null +++ b/emulator-info.txt @@ -0,0 +1,2 @@ +# Emulator (stable) version +require version-emulator=4833465 -- cgit v1.2.3 From 398554a4aae676e556fbc787eff2a302aafc66f1 Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Mon, 25 Jun 2018 16:10:51 -0700 Subject: Add support for carrier restrictions to ril This change introduces support to notify the modem about carrier restrictions. So far only the number of carrier restrictions supportted to pass the VTS test. Bug: 110212792 Test: ./android-cts/tools/cts-tradefed run cts -m CtsTelephonyTestCases Test: ./tools/vts-tradefed run vts -m VtsHalRadioV1_0Target \ -t VtsHalRadioV1_0Target#RadioHidlTest.setAllowedCarriers Change-Id: Ibbf239cde82d0430b084c88f28dbd8d7d8d95300 Signed-off-by: Roman Kiryanov --- ril/reference-ril.c | 143 +++++++++++++++++++++++++++++++++++----------------- 1 file changed, 98 insertions(+), 45 deletions(-) diff --git a/ril/reference-ril.c b/ril/reference-ril.c index 0f56a19..b1f6b37 100644 --- a/ril/reference-ril.c +++ b/ril/reference-ril.c @@ -167,18 +167,24 @@ typedef enum { SIM_PIN = 3, SIM_PUK = 4, SIM_NETWORK_PERSONALIZATION = 5, - RUIM_ABSENT = 6, - RUIM_NOT_READY = 7, - RUIM_READY = 8, - RUIM_PIN = 9, - RUIM_PUK = 10, - RUIM_NETWORK_PERSONALIZATION = 11, - ISIM_ABSENT = 12, - ISIM_NOT_READY = 13, - ISIM_READY = 14, - ISIM_PIN = 15, - ISIM_PUK = 16, - ISIM_NETWORK_PERSONALIZATION = 17, + SIM_RESTRICTED = 6, + + RUIM_ABSENT = 7, + RUIM_NOT_READY = 8, + RUIM_READY = 9, + RUIM_PIN = 10, + RUIM_PUK = 11, + RUIM_NETWORK_PERSONALIZATION = 12, + RUIM_RESTRICTED = 13, + + ISIM_ABSENT = 14, + ISIM_NOT_READY = 15, + ISIM_READY = 16, + ISIM_PIN = 17, + ISIM_PUK = 18, + ISIM_NETWORK_PERSONALIZATION = 19, + ISIM_RESTRICTED = 20 + } SIM_Status; static void onRequest (int request, void *data, size_t datalen, RIL_Token t); @@ -2452,6 +2458,29 @@ error: RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); } +static void requestSetCarrierRestrictions(const RIL_CarrierRestrictions *restrictions __unused, RIL_Token t) +{ + ATResponse *p_response = NULL; + int success; + int err; + char cmd[32]; + + snprintf(cmd, sizeof(cmd), "AT+CRRSTR=%d,%d", + restrictions->len_allowed_carriers, + restrictions->len_excluded_carriers); + + err = at_send_command_singleline(cmd, "+CRRSTR:", &p_response); + success = p_response ? p_response->success : 0; + at_response_free(p_response); + + if (err == 0 && success) { + RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0); + } else { + ALOGE("'%s' failed with err=%d success=%d", cmd, err, success); + RIL_onRequestComplete(t, RIL_E_GENERIC_FAILURE, NULL, 0); + } +} + /*** Callback methods from the RIL library to us ***/ /** @@ -2916,6 +2945,15 @@ onRequest (int request, void *data, size_t datalen, RIL_Token t) requestModemActivityInfo(t); break; + case RIL_REQUEST_SET_CARRIER_RESTRICTIONS: + if (datalen == sizeof(RIL_CarrierRestrictions)) { + requestSetCarrierRestrictions((const RIL_CarrierRestrictions *)data, t); + } else { + /* unexpected sizeof */ + RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); + } + break; + default: RLOGD("Request not supported. Tech: %d",TECH(sMdmInfo)); RIL_onRequestComplete(t, RIL_E_REQUEST_NOT_SUPPORTED, NULL, 0); @@ -3108,7 +3146,7 @@ getSIMStatus() { ATResponse *p_response = NULL; int err; - int ret; + SIM_Status ret; char *cpinLine; char *cpinResult; @@ -3152,24 +3190,19 @@ getSIMStatus() if (0 == strcmp (cpinResult, "SIM PIN")) { ret = SIM_PIN; - goto done; } else if (0 == strcmp (cpinResult, "SIM PUK")) { ret = SIM_PUK; - goto done; } else if (0 == strcmp (cpinResult, "PH-NET PIN")) { - return SIM_NETWORK_PERSONALIZATION; - } else if (0 != strcmp (cpinResult, "READY")) { + ret = SIM_NETWORK_PERSONALIZATION; + } else if (0 == strcmp (cpinResult, "RESTRICTED")) { + ret = SIM_RESTRICTED; + } else if (0 == strcmp (cpinResult, "READY")) { + ret = (sState == RADIO_STATE_ON) ? SIM_READY : SIM_NOT_READY; + } else { /* we're treating unsupported lock types as "sim absent" */ ret = SIM_ABSENT; - goto done; } - at_response_free(p_response); - p_response = NULL; - cpinResult = NULL; - - ret = (sState == RADIO_STATE_ON) ? SIM_READY : SIM_NOT_READY; - done: at_response_free(p_response); return ret; @@ -3183,7 +3216,7 @@ done: * @return: On success returns RIL_E_SUCCESS */ static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) { - static RIL_AppStatus app_status_array[] = { + static const RIL_AppStatus app_status_array[] = { // SIM_ABSENT = 0 { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, @@ -3202,54 +3235,74 @@ static int getCardStatus(RIL_CardStatus_v6 **pp_card_status) { // SIM_NETWORK_PERSONALIZATION = 5 { RIL_APPTYPE_USIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, - // RUIM_ABSENT = 6 + // SIM_RESTRICTED = 6 { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, - // RUIM_NOT_READY = 7 + + // RUIM_ABSENT = 7 + { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + // RUIM_NOT_READY = 8 { RIL_APPTYPE_RUIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, - // RUIM_READY = 8 + // RUIM_READY = 9 { RIL_APPTYPE_RUIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, - // RUIM_PIN = 9 + // RUIM_PIN = 10 { RIL_APPTYPE_RUIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, - // RUIM_PUK = 10 + // RUIM_PUK = 11 { RIL_APPTYPE_RUIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, - // RUIM_NETWORK_PERSONALIZATION = 11 + // RUIM_NETWORK_PERSONALIZATION = 12 { RIL_APPTYPE_RUIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, - // ISIM_ABSENT = 12 + // RUIM_RESTRICTED = 13 + { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, + + // ISIM_ABSENT = 14 { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, - // ISIM_NOT_READY = 13 + // ISIM_NOT_READY = 15 { RIL_APPTYPE_ISIM, RIL_APPSTATE_DETECTED, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, - // ISIM_READY = 14 + // ISIM_READY = 16 { RIL_APPTYPE_ISIM, RIL_APPSTATE_READY, RIL_PERSOSUBSTATE_READY, NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, - // ISIM_PIN = 15 + // ISIM_PIN = 17 { RIL_APPTYPE_ISIM, RIL_APPSTATE_PIN, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, - // ISIM_PUK = 16 + // ISIM_PUK = 18 { RIL_APPTYPE_ISIM, RIL_APPSTATE_PUK, RIL_PERSOSUBSTATE_UNKNOWN, NULL, NULL, 0, RIL_PINSTATE_ENABLED_BLOCKED, RIL_PINSTATE_UNKNOWN }, - // ISIM_NETWORK_PERSONALIZATION = 17 + // ISIM_NETWORK_PERSONALIZATION = 19 { RIL_APPTYPE_ISIM, RIL_APPSTATE_SUBSCRIPTION_PERSO, RIL_PERSOSUBSTATE_SIM_NETWORK, NULL, NULL, 0, RIL_PINSTATE_ENABLED_NOT_VERIFIED, RIL_PINSTATE_UNKNOWN }, - + // ISIM_RESTRICTED = 20 + { RIL_APPTYPE_UNKNOWN, RIL_APPSTATE_UNKNOWN, RIL_PERSOSUBSTATE_UNKNOWN, + NULL, NULL, 0, RIL_PINSTATE_UNKNOWN, RIL_PINSTATE_UNKNOWN }, }; + RIL_CardState card_state; int num_apps; - int sim_status = getSIMStatus(); - if (sim_status == SIM_ABSENT) { - card_state = RIL_CARDSTATE_ABSENT; - num_apps = 0; - } else { - card_state = RIL_CARDSTATE_PRESENT; - num_apps = 3; + SIM_Status sim_status = getSIMStatus(); + switch (sim_status) { + case SIM_ABSENT: + card_state = RIL_CARDSTATE_ABSENT; + num_apps = 0; + break; + + case SIM_RESTRICTED: + card_state = RIL_CARDSTATE_RESTRICTED; + num_apps = 0; + break; + + default: + card_state = RIL_CARDSTATE_PRESENT; + num_apps = 3; + break; } // Allocate and initialize base card status. -- cgit v1.2.3 From b8f47813fc0a05f00fe8492030c2645e9549ac20 Mon Sep 17 00:00:00 2001 From: Jim Kaye Date: Mon, 18 Jun 2018 16:24:10 -0700 Subject: Add an emulated cutout definition for use by the Emulator This cutout definition is intended to adjust the placement of notification icons relative to a display cutout overlay that the Emulator will apply. This cutout definition is not intended for use on physical devices. Bug: 79882444 Test: Verified with the Emulator Change-Id: I6104a9d4a996e01a13a010255ce74f259e60f73b --- .../DisplayCutoutEmulationEmu01/Android.mk | 14 ++++++ .../AndroidManifest.xml | 26 +++++++++++ .../res/values/config.xml | 52 ++++++++++++++++++++++ .../res/values/strings.xml | 22 +++++++++ vendor.mk | 3 ++ 5 files changed, 117 insertions(+) create mode 100644 overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/Android.mk create mode 100644 overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml create mode 100644 overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/res/values/config.xml create mode 100644 overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/res/values/strings.xml diff --git a/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/Android.mk b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/Android.mk new file mode 100644 index 0000000..18c0138 --- /dev/null +++ b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/Android.mk @@ -0,0 +1,14 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_RRO_THEME := DisplayCutoutEmulationEmu01 +LOCAL_CERTIFICATE := platform + +LOCAL_SRC_FILES := $(call all-subdir-java-files) + +LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/res + +LOCAL_PACKAGE_NAME := DisplayCutoutEmulationEmu01Overlay +LOCAL_SDK_VERSION := current + +include $(BUILD_RRO_PACKAGE) diff --git a/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml new file mode 100644 index 0000000..8c98d2f --- /dev/null +++ b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml @@ -0,0 +1,26 @@ + + + + + + + diff --git a/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/res/values/config.xml b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/res/values/config.xml new file mode 100644 index 0000000..ce41ccb --- /dev/null +++ b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/res/values/config.xml @@ -0,0 +1,52 @@ + + + + + + + + M -278,0 l 171,171 h 214 l 171,-171 z + + + false + + + 49dp + 28dp + + 49dp + + 177dp + + diff --git a/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/res/values/strings.xml b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/res/values/strings.xml new file mode 100644 index 0000000..8860fc4 --- /dev/null +++ b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/res/values/strings.xml @@ -0,0 +1,22 @@ + + + + + + Emu01 display cutout + + diff --git a/vendor.mk b/vendor.mk index c68aaa7..6ddf8db 100644 --- a/vendor.mk +++ b/vendor.mk @@ -84,6 +84,9 @@ PRODUCT_PACKAGES += \ PRODUCT_PACKAGES += \ android.hardware.keymaster@4.0-strongbox-service +PRODUCT_PACKAGES += \ + DisplayCutoutEmulationEmu01Overlay + ifneq ($(EMULATOR_VENDOR_NO_GNSS),true) PRODUCT_PACKAGES += \ android.hardware.gnss@1.0-service \ -- cgit v1.2.3 From 26d7b84686efa846b254a27611740daf68634c20 Mon Sep 17 00:00:00 2001 From: huans Date: Mon, 2 Jul 2018 13:52:52 -0700 Subject: Disable software Keymaster4.0 for goldfish KM4.0 is not required for Android P. It causes several VTS/CTS failures. Bug: 91777626 110489833 Test: run VTS CTS Change-Id: Ia8ec9d5b313a3ef6d4b18b498b3ae50d408a1606 --- manifest-arm.xml | 10 ---------- manifest.xml | 10 ---------- vendor.mk | 3 --- 3 files changed, 23 deletions(-) diff --git a/manifest-arm.xml b/manifest-arm.xml index c4d10dd..adef88b 100644 --- a/manifest-arm.xml +++ b/manifest-arm.xml @@ -61,16 +61,6 @@ default - - android.hardware.keymaster - hwbinder - 4.0 - - IKeymasterDevice - default - strongbox - - android.hardware.graphics.allocator hwbinder diff --git a/manifest.xml b/manifest.xml index bd40ed3..0000149 100644 --- a/manifest.xml +++ b/manifest.xml @@ -61,16 +61,6 @@ default - - android.hardware.keymaster - hwbinder - 4.0 - - IKeymasterDevice - default - strongbox - - android.hardware.graphics.allocator hwbinder diff --git a/vendor.mk b/vendor.mk index 6ddf8db..ff5a1e1 100644 --- a/vendor.mk +++ b/vendor.mk @@ -81,9 +81,6 @@ PRODUCT_PACKAGES += \ android.hardware.keymaster@3.0-impl \ android.hardware.keymaster@3.0-service -PRODUCT_PACKAGES += \ - android.hardware.keymaster@4.0-strongbox-service - PRODUCT_PACKAGES += \ DisplayCutoutEmulationEmu01Overlay -- cgit v1.2.3 From 31eb958813c6d026e9f9a6dafed1e2b23bba164f Mon Sep 17 00:00:00 2001 From: huans Date: Fri, 6 Jul 2018 11:39:20 -0700 Subject: Goldfish CameraHAL3 fixes: 1, Static variablies only for attributes unique across HAL objects 2, Bug when parsing resolutions for multiple cameras 3, Front camera always report INACTIVE for AF_MODE requests Bug: 110795223, 110853354, 110778954 Test: All combinations of cameras, Front Back Switch Picture Recording E E Y Y Y W E Y Y Y E W Y Y Y W W Y Y Y E V Y Y Y W V Y Y Y E: Emulated W: Webcam V: AR Change-Id: I1fbaea5ec33945876c4f0466e9bd951bd5d01f0f --- camera/EmulatedCameraFactory.cpp | 3 +- camera/EmulatedFakeCamera3.cpp | 76 ++++++++++++++++++------------------ camera/EmulatedQemuCamera3.cpp | 69 ++++++++++++++++++++------------ camera/qemu-pipeline3/QemuSensor.cpp | 2 +- 4 files changed, 82 insertions(+), 68 deletions(-) diff --git a/camera/EmulatedCameraFactory.cpp b/camera/EmulatedCameraFactory.cpp index 3f40aab..cf26a9e 100755 --- a/camera/EmulatedCameraFactory.cpp +++ b/camera/EmulatedCameraFactory.cpp @@ -312,8 +312,7 @@ void EmulatedCameraFactory::findQemuCameras( size_t lineBegin = 0; size_t lineEnd = cameraListStr.find('\n'); while (lineEnd != std::string::npos) { - std::string cameraStr = cameraListStr.substr(lineBegin, lineEnd); - + std::string cameraStr = cameraListStr.substr(lineBegin, lineEnd - lineBegin); // Parse the 'name', 'framedims', and 'dir' tokens. char *name, *frameDims, *dir; if (getTokenValue(kListNameToken, cameraStr, &name) && diff --git a/camera/EmulatedFakeCamera3.cpp b/camera/EmulatedFakeCamera3.cpp index 9a86f4f..296d06e 100644 --- a/camera/EmulatedFakeCamera3.cpp +++ b/camera/EmulatedFakeCamera3.cpp @@ -441,8 +441,8 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings( static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_FULL; settings.update(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1); - static const int32_t id = 0; - settings.update(ANDROID_REQUEST_ID, &id, 1); + static const int32_t requestId = 0; + settings.update(ANDROID_REQUEST_ID, &requestId, 1); static const int32_t frameCount = 0; settings.update(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1); @@ -473,13 +473,13 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings( /** android.sensor */ if (hasCapability(MANUAL_SENSOR)) { - static const int64_t exposureTime = 10 * MSEC; + const int64_t exposureTime = 10 * MSEC; settings.update(ANDROID_SENSOR_EXPOSURE_TIME, &exposureTime, 1); - static const int64_t frameDuration = 33333333L; // 1/30 s + const int64_t frameDuration = 33333333L; // 1/30 s settings.update(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1); - static const int32_t sensitivity = 100; + const int32_t sensitivity = 100; settings.update(ANDROID_SENSOR_SENSITIVITY, &sensitivity, 1); } @@ -574,7 +574,7 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings( /** android.scaler */ if (hasCapability(BACKWARD_COMPATIBLE)) { - static const int32_t cropRegion[4] = { + const int32_t cropRegion[4] = { 0, 0, mSensorWidth, mSensorHeight }; settings.update(ANDROID_SCALER_CROP_REGION, cropRegion, 4); @@ -669,7 +669,7 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings( static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); - static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; + const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); const uint8_t aeMode = (type == CAMERA3_TEMPLATE_MANUAL) ? @@ -737,7 +737,7 @@ const camera_metadata_t* EmulatedFakeCamera3::constructDefaultRequestSettings( settings.update(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5); - static const uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; + const uint8_t afTrigger = ANDROID_CONTROL_AF_TRIGGER_IDLE; settings.update(ANDROID_CONTROL_AF_TRIGGER, &afTrigger, 1); static const uint8_t vstabMode = @@ -1244,10 +1244,9 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { } // android.lens - - static const float focalLength = 5.0f; // mm + static const float focalLengths = 5.0f; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, - &focalLength, 1); + &focalLengths, 1); if (hasCapability(BACKWARD_COMPATIBLE)) { // 5 cm min focus distance for back camera, infinity (fixed focus) for front @@ -1258,14 +1257,14 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front const float hyperFocalDistance = mFacingBack ? 1.0/5.0 : 0.0; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, - &minFocusDistance, 1); + &hyperFocalDistance, 1); - static const float aperture = 2.8f; + static const float apertures = 2.8f; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_APERTURES, - &aperture, 1); - static const float filterDensity = 0; + &apertures, 1); + static const float filterDensities = 0; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, - &filterDensity, 1); + &filterDensities, 1); static const uint8_t availableOpticalStabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, @@ -1307,8 +1306,8 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { sizeof(lensPoseTranslation)/sizeof(float)); // Intrinsics are 'ideal' (f_x, f_y, c_x, c_y, s) match focal length and active array size - float f_x = focalLength * mSensorWidth / sensorPhysicalSize[0]; - float f_y = focalLength * mSensorHeight / sensorPhysicalSize[1]; + float f_x = focalLengths * mSensorWidth / sensorPhysicalSize[0]; + float f_y = focalLengths * mSensorHeight / sensorPhysicalSize[1]; float c_x = mSensorWidth / 2.f; float c_y = mSensorHeight / 2.f; float s = 0.f; @@ -1327,7 +1326,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { } - static const uint8_t lensFacing = mFacingBack ? + const uint8_t lensFacing = mFacingBack ? ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; ADD_STATIC_ENTRY(ANDROID_LENS_FACING, &lensFacing, 1); @@ -1597,20 +1596,20 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { // android.control if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableControlModes[] = { + const uint8_t availableControlModes[] = { ANDROID_CONTROL_MODE_OFF, ANDROID_CONTROL_MODE_AUTO, ANDROID_CONTROL_MODE_USE_SCENE_MODE }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES, availableControlModes, sizeof(availableControlModes)); } else { - static const uint8_t availableControlModes[] = { + const uint8_t availableControlModes[] = { ANDROID_CONTROL_MODE_AUTO }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES, availableControlModes, sizeof(availableControlModes)); } - static const uint8_t availableSceneModes[] = { + const uint8_t availableSceneModes[] = { hasCapability(BACKWARD_COMPATIBLE) ? ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : ANDROID_CONTROL_SCENE_MODE_DISABLED @@ -1644,7 +1643,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_STEP, &exposureCompensationStep, 1); - int32_t exposureCompensationRange[] = {0, 0}; + static const int32_t exposureCompensationRange[] = {0, 0}; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_RANGE, exposureCompensationRange, sizeof(exposureCompensationRange)/sizeof(int32_t)); @@ -1666,7 +1665,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { availableAntibandingModes, sizeof(availableAntibandingModes)); } - static const uint8_t aeLockAvailable = hasCapability(BACKWARD_COMPATIBLE) ? + const uint8_t aeLockAvailable = hasCapability(BACKWARD_COMPATIBLE) ? ANDROID_CONTROL_AE_LOCK_AVAILABLE_TRUE : ANDROID_CONTROL_AE_LOCK_AVAILABLE_FALSE; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_LOCK_AVAILABLE, @@ -1685,7 +1684,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { availableAwbModes, sizeof(availableAwbModes)); } - static const uint8_t awbLockAvailable = hasCapability(BACKWARD_COMPATIBLE) ? + const uint8_t awbLockAvailable = hasCapability(BACKWARD_COMPATIBLE) ? ANDROID_CONTROL_AWB_LOCK_AVAILABLE_TRUE : ANDROID_CONTROL_AWB_LOCK_AVAILABLE_FALSE; ADD_STATIC_ENTRY(ANDROID_CONTROL_AWB_LOCK_AVAILABLE, @@ -1720,7 +1719,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { // android.colorCorrection if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableAberrationModes[] = { + const uint8_t availableAberrationModes[] = { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF, ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST, ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY @@ -1728,7 +1727,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, availableAberrationModes, sizeof(availableAberrationModes)); } else { - static const uint8_t availableAberrationModes[] = { + const uint8_t availableAberrationModes[] = { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF, }; ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, @@ -1737,13 +1736,13 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { // android.edge if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableEdgeModes[] = { + const uint8_t availableEdgeModes[] = { ANDROID_EDGE_MODE_OFF, ANDROID_EDGE_MODE_FAST, ANDROID_EDGE_MODE_HIGH_QUALITY }; ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES, availableEdgeModes, sizeof(availableEdgeModes)); } else { - static const uint8_t availableEdgeModes[] = { + const uint8_t availableEdgeModes[] = { ANDROID_EDGE_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES, @@ -1752,7 +1751,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { // android.info - static const uint8_t supportedHardwareLevel = + const uint8_t supportedHardwareLevel = hasCapability(FULL_LEVEL) ? ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_FULL : ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED; ADD_STATIC_ENTRY(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL, @@ -1762,7 +1761,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { // android.noiseReduction if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableNoiseReductionModes[] = { + const uint8_t availableNoiseReductionModes[] = { ANDROID_NOISE_REDUCTION_MODE_OFF, ANDROID_NOISE_REDUCTION_MODE_FAST, ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY @@ -1770,7 +1769,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, availableNoiseReductionModes, sizeof(availableNoiseReductionModes)); } else { - static const uint8_t availableNoiseReductionModes[] = { + const uint8_t availableNoiseReductionModes[] = { ANDROID_NOISE_REDUCTION_MODE_OFF, }; ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, @@ -1809,7 +1808,7 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { availableDepthStallDurations, sizeof(availableDepthStallDurations)/sizeof(int64_t)); - uint8_t depthIsExclusive = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE; + static const uint8_t depthIsExclusive = ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE_FALSE; ADD_STATIC_ENTRY(ANDROID_DEPTH_DEPTH_IS_EXCLUSIVE, &depthIsExclusive, 1); } @@ -1817,13 +1816,13 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { // android.shading if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableShadingModes[] = { + const uint8_t availableShadingModes[] = { ANDROID_SHADING_MODE_OFF, ANDROID_SHADING_MODE_FAST, ANDROID_SHADING_MODE_HIGH_QUALITY }; ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes, sizeof(availableShadingModes)); } else { - static const uint8_t availableShadingModes[] = { + const uint8_t availableShadingModes[] = { ANDROID_SHADING_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes, @@ -2154,11 +2153,10 @@ status_t EmulatedFakeCamera3::doFakeAF(CameraMetadata &settings) { case ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO: case ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE: if (!mFacingBack) { - ALOGE("%s: Front camera doesn't support AF mode %d", - __FUNCTION__, afMode); - return BAD_VALUE; + // Always report INACTIVE for front Emulated Camera + mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; + return OK; } - // OK, handle transitions lower on break; default: ALOGE("%s: Emulator doesn't support AF mode %d", diff --git a/camera/EmulatedQemuCamera3.cpp b/camera/EmulatedQemuCamera3.cpp index 33939f9..123ab1c 100644 --- a/camera/EmulatedQemuCamera3.cpp +++ b/camera/EmulatedQemuCamera3.cpp @@ -136,7 +136,10 @@ void EmulatedQemuCamera3::parseResolutions(const char *frameDims) { */ if (sscanf(input.c_str(), "%dx%d%c", &width, &height, &none) == 2) { mResolutions.push_back(std::pair(width, height)); - ALOGE("%s: %dx%d", __FUNCTION__, width, height); + ALOGI("%s: %dx%d", __FUNCTION__, width, height); + } + else { + ALOGE("wrong resolution input %s", input.c_str()); } } @@ -239,6 +242,20 @@ status_t EmulatedQemuCamera3::connectCamera(hw_device_t** device) { res = mReadoutThread->run("EmuCam3::readoutThread"); if (res != NO_ERROR) return res; + // Initialize fake 3A + + mFacePriority = false; + mAeMode = ANDROID_CONTROL_AE_MODE_ON; + mAfMode = ANDROID_CONTROL_AF_MODE_AUTO; + mAwbMode = ANDROID_CONTROL_AWB_MODE_AUTO; + mAeState = ANDROID_CONTROL_AE_STATE_INACTIVE; + mAfState = ANDROID_CONTROL_AF_STATE_INACTIVE; + mAwbState = ANDROID_CONTROL_AWB_STATE_INACTIVE; + mAeCounter = 0; + mAeTargetExposureTime = kNormalExposureTime; + mAeCurrentExposureTime = kNormalExposureTime; + mAeCurrentSensitivity = kNormalSensitivity; + return EmulatedCamera3::connectCamera(device); } @@ -516,7 +533,7 @@ const camera_metadata_t* EmulatedQemuCamera3::constructDefaultRequestSettings( /* android.scaler */ if (hasCapability(BACKWARD_COMPATIBLE)) { - static const int32_t cropRegion[4] = { + const int32_t cropRegion[4] = { 0, 0, mSensorWidth, mSensorHeight }; settings.update(ANDROID_SCALER_CROP_REGION, cropRegion, 4); @@ -607,7 +624,7 @@ const camera_metadata_t* EmulatedQemuCamera3::constructDefaultRequestSettings( static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); - static const uint8_t sceneMode = + const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); @@ -1132,27 +1149,27 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { /* android.lens */ - static const float focalLength = 3.30f; // mm + static const float focalLengths = 5.0f; // mm ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, - &focalLength, 1); + &focalLengths, 1); if (hasCapability(BACKWARD_COMPATIBLE)) { // infinity (fixed focus) - const float minFocusDistance = 0.0; + static const float minFocusDistance = 0.0; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, &minFocusDistance, 1); // (fixed focus) - const float hyperFocalDistance = 0.0; + static const float hyperFocalDistance = 0.0; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, - &minFocusDistance, 1); + &hyperFocalDistance, 1); - static const float aperture = 2.8f; + static const float apertures = 2.8f; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_APERTURES, - &aperture, 1); - static const float filterDensity = 0; + &apertures, 1); + static const float filterDensities = 0; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, - &filterDensity, 1); + &filterDensities, 1); static const uint8_t availableOpticalStabilization = ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; ADD_STATIC_ENTRY(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, @@ -1168,7 +1185,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { &lensFocusCalibration, 1); } - static const uint8_t lensFacing = mFacingBack ? + const uint8_t lensFacing = mFacingBack ? ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; ADD_STATIC_ENTRY(ANDROID_LENS_FACING, &lensFacing, 1); @@ -1309,7 +1326,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { /* android.sync */ - static const int32_t maxLatency = + const int32_t maxLatency = hasCapability(FULL_LEVEL) ? ANDROID_SYNC_MAX_LATENCY_PER_FRAME_CONTROL : 3; ADD_STATIC_ENTRY(ANDROID_SYNC_MAX_LATENCY, &maxLatency, 1); @@ -1317,7 +1334,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { /* android.control */ if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableControlModes[] = { + const uint8_t availableControlModes[] = { ANDROID_CONTROL_MODE_OFF, ANDROID_CONTROL_MODE_AUTO, ANDROID_CONTROL_MODE_USE_SCENE_MODE @@ -1325,14 +1342,14 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES, availableControlModes, sizeof(availableControlModes)); } else { - static const uint8_t availableControlModes[] = { + const uint8_t availableControlModes[] = { ANDROID_CONTROL_MODE_AUTO }; ADD_STATIC_ENTRY(ANDROID_CONTROL_AVAILABLE_MODES, availableControlModes, sizeof(availableControlModes)); } - static const uint8_t availableSceneModes[] = { + const uint8_t availableSceneModes[] = { hasCapability(BACKWARD_COMPATIBLE) ? ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY : ANDROID_CONTROL_SCENE_MODE_DISABLED @@ -1369,7 +1386,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_STEP, &exposureCompensationStep, 1); - int32_t exposureCompensationRange[] = {-9, 9}; + static int32_t exposureCompensationRange[] = {-9, 9}; ADD_STATIC_ENTRY(ANDROID_CONTROL_AE_COMPENSATION_RANGE, exposureCompensationRange, sizeof(exposureCompensationRange) / sizeof(int32_t)); @@ -1439,7 +1456,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { /* android.colorCorrection */ if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableAberrationModes[] = { + const uint8_t availableAberrationModes[] = { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF, ANDROID_COLOR_CORRECTION_ABERRATION_MODE_FAST, ANDROID_COLOR_CORRECTION_ABERRATION_MODE_HIGH_QUALITY @@ -1447,7 +1464,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, availableAberrationModes, sizeof(availableAberrationModes)); } else { - static const uint8_t availableAberrationModes[] = { + const uint8_t availableAberrationModes[] = { ANDROID_COLOR_CORRECTION_ABERRATION_MODE_OFF, }; ADD_STATIC_ENTRY(ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES, @@ -1457,7 +1474,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { /* android.edge */ if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableEdgeModes[] = { + const uint8_t availableEdgeModes[] = { ANDROID_EDGE_MODE_OFF, ANDROID_EDGE_MODE_FAST, ANDROID_EDGE_MODE_HIGH_QUALITY, @@ -1465,7 +1482,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES, availableEdgeModes, sizeof(availableEdgeModes)); } else { - static const uint8_t availableEdgeModes[] = { + const uint8_t availableEdgeModes[] = { ANDROID_EDGE_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_EDGE_AVAILABLE_EDGE_MODES, @@ -1482,7 +1499,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { /* android.noiseReduction */ if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableNoiseReductionModes[] = { + const uint8_t availableNoiseReductionModes[] = { ANDROID_NOISE_REDUCTION_MODE_OFF, ANDROID_NOISE_REDUCTION_MODE_FAST, ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY @@ -1491,7 +1508,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { availableNoiseReductionModes, sizeof(availableNoiseReductionModes)); } else { - static const uint8_t availableNoiseReductionModes[] = { + const uint8_t availableNoiseReductionModes[] = { ANDROID_NOISE_REDUCTION_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES, @@ -1502,7 +1519,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { /* android.shading */ if (hasCapability(BACKWARD_COMPATIBLE)) { - static const uint8_t availableShadingModes[] = { + const uint8_t availableShadingModes[] = { ANDROID_SHADING_MODE_OFF, ANDROID_SHADING_MODE_FAST, ANDROID_SHADING_MODE_HIGH_QUALITY @@ -1510,7 +1527,7 @@ status_t EmulatedQemuCamera3::constructStaticInfo() { ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes, sizeof(availableShadingModes)); } else { - static const uint8_t availableShadingModes[] = { + const uint8_t availableShadingModes[] = { ANDROID_SHADING_MODE_OFF }; ADD_STATIC_ENTRY(ANDROID_SHADING_AVAILABLE_MODES, availableShadingModes, diff --git a/camera/qemu-pipeline3/QemuSensor.cpp b/camera/qemu-pipeline3/QemuSensor.cpp index bf662ab..d52bffd 100644 --- a/camera/qemu-pipeline3/QemuSensor.cpp +++ b/camera/qemu-pipeline3/QemuSensor.cpp @@ -341,7 +341,7 @@ bool QemuSensor::threadLoop() { (int) ((endRealTime - startRealTime) / 1000000), (int) (frameDuration / 1000000)); return true; -}; +} void QemuSensor::captureRGBA(uint8_t *img, uint32_t width, uint32_t height, uint32_t stride, int64_t *timestamp) { -- cgit v1.2.3 From 005c10e381d8c5d87ee17204b4cd6ac5023ee337 Mon Sep 17 00:00:00 2001 From: huans Date: Fri, 6 Jul 2018 16:12:30 -0700 Subject: Fix compile warnings for goldfish camera and hwcomposer Bug: 80194417 Test: check warnings are gone when compile Change-Id: Iaba227444accfb552fae1c333d29dc26e3cdd736 --- camera/CallbackNotifier.cpp | 2 +- camera/Converters.cpp | 2 +- camera/EmulatedBaseCamera.cpp | 2 +- camera/EmulatedBaseCamera.h | 2 +- camera/EmulatedCamera.cpp | 35 ++--------------------------- camera/EmulatedCamera2.cpp | 2 +- camera/EmulatedCamera3.cpp | 2 +- camera/EmulatedCameraDevice.cpp | 2 +- camera/EmulatedCameraFactory.cpp | 4 ++-- camera/EmulatedCameraFactory.h | 2 +- camera/EmulatedCameraHal.cpp | 30 ++++++++++++------------- camera/EmulatedCameraHotplugThread.cpp | 2 +- camera/EmulatedFakeCamera.cpp | 2 +- camera/EmulatedFakeCamera2.cpp | 12 ++++------ camera/EmulatedFakeCamera3.cpp | 15 ++++++------- camera/EmulatedFakeCameraDevice.cpp | 2 +- camera/EmulatedFakeRotatingCameraDevice.cpp | 6 +---- camera/EmulatedQemuCamera.cpp | 2 +- camera/EmulatedQemuCamera2.cpp | 2 +- camera/EmulatedQemuCamera3.cpp | 8 +++---- camera/EmulatedQemuCameraDevice.cpp | 2 +- camera/Exif.cpp | 14 ++++++------ camera/GrallocModule.h | 2 +- camera/JpegCompressor.cpp | 2 +- camera/PreviewWindow.cpp | 2 +- camera/QemuClient.cpp | 2 +- camera/Thumbnail.cpp | 2 +- camera/WorkerThread.cpp | 2 +- camera/fake-pipeline2/JpegCompressor.cpp | 5 ++--- camera/fake-pipeline2/Scene.cpp | 6 ++--- camera/fake-pipeline2/Scene.h | 2 +- camera/fake-pipeline2/Sensor.cpp | 8 ++----- camera/jpeg-stub/Compressor.cpp | 2 +- camera/jpeg-stub/JpegStub.cpp | 2 +- camera/qemu-pipeline3/QemuSensor.cpp | 14 ++++++------ hwcomposer/hwcomposer.cpp | 21 ++++++++--------- 36 files changed, 89 insertions(+), 135 deletions(-) diff --git a/camera/CallbackNotifier.cpp b/camera/CallbackNotifier.cpp index e7fea45..fca2a80 100755 --- a/camera/CallbackNotifier.cpp +++ b/camera/CallbackNotifier.cpp @@ -21,7 +21,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_CallbackNotifier" -#include +#include #include #include "EmulatedCameraDevice.h" #undef min diff --git a/camera/Converters.cpp b/camera/Converters.cpp index 4765bf2..cb09946 100755 --- a/camera/Converters.cpp +++ b/camera/Converters.cpp @@ -20,7 +20,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Converter" -#include +#include #include "Converters.h" #include "Alignment.h" diff --git a/camera/EmulatedBaseCamera.cpp b/camera/EmulatedBaseCamera.cpp index 5fe7d73..0b85dcf 100644 --- a/camera/EmulatedBaseCamera.cpp +++ b/camera/EmulatedBaseCamera.cpp @@ -26,7 +26,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_BaseCamera" -#include +#include #include "EmulatedBaseCamera.h" diff --git a/camera/EmulatedBaseCamera.h b/camera/EmulatedBaseCamera.h index 3b8a6a0..abaed98 100644 --- a/camera/EmulatedBaseCamera.h +++ b/camera/EmulatedBaseCamera.h @@ -52,7 +52,7 @@ class EmulatedBaseCamera { */ virtual status_t Initialize() = 0; - /**************************************************************************** + /**************************************************************************** * Camera API implementation ***************************************************************************/ diff --git a/camera/EmulatedCamera.cpp b/camera/EmulatedCamera.cpp index fe4fcae..b13a5c3 100755 --- a/camera/EmulatedCamera.cpp +++ b/camera/EmulatedCamera.cpp @@ -25,8 +25,8 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Camera" -#include - #include +#include +#include #include "EmulatedCamera.h" //#include "EmulatedFakeCameraDevice.h" #include "Converters.h" @@ -57,17 +57,6 @@ static void PrintParamDiff(const CameraParameters& current, const char* new_par) #define PrintParamDiff(current, new_par) (void(0)) #endif /* DEBUG_PARAM */ -/* A helper routine that adds a value to the camera parameter. - * Param: - * param - Camera parameter to add a value to. - * val - Value to add. - * Return: - * A new string containing parameter with the added value on success, or NULL on - * a failure. If non-NULL string is returned, the caller is responsible for - * freeing it with 'free'. - */ -static char* AddValue(const char* param, const char* val); - /* * Check if a given string |value| equals at least one of the strings in |list| */ @@ -495,7 +484,6 @@ status_t EmulatedCamera::takePicture() { ALOGV("%s", __FUNCTION__); - status_t res; int width, height; uint32_t org_fmt; @@ -1235,25 +1223,6 @@ const char EmulatedCamera::RECORDING_HINT_KEY[] = "recording-hint"; const char EmulatedCamera::FACING_BACK[] = "back"; const char EmulatedCamera::FACING_FRONT[] = "front"; -/**************************************************************************** - * Helper routines - ***************************************************************************/ - -static char* AddValue(const char* param, const char* val) -{ - const size_t len1 = strlen(param); - const size_t len2 = strlen(val); - char* ret = reinterpret_cast(malloc(len1 + len2 + 2)); - ALOGE_IF(ret == NULL, "%s: Memory failure", __FUNCTION__); - if (ret != NULL) { - memcpy(ret, param, len1); - ret[len1] = ','; - memcpy(ret + len1 + 1, val, len2); - ret[len1 + len2 + 1] = '\0'; - } - return ret; -} - /**************************************************************************** * Parameter debugging helpers ***************************************************************************/ diff --git a/camera/EmulatedCamera2.cpp b/camera/EmulatedCamera2.cpp index ea7424b..72e1c07 100644 --- a/camera/EmulatedCamera2.cpp +++ b/camera/EmulatedCamera2.cpp @@ -24,7 +24,7 @@ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera2_Camera" -#include +#include #include "EmulatedCamera2.h" #include "system/camera_metadata.h" diff --git a/camera/EmulatedCamera3.cpp b/camera/EmulatedCamera3.cpp index e9110cc..0cc373a 100644 --- a/camera/EmulatedCamera3.cpp +++ b/camera/EmulatedCamera3.cpp @@ -24,7 +24,7 @@ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera3_Camera" -#include +#include #include "EmulatedCamera3.h" #include "system/camera_metadata.h" diff --git a/camera/EmulatedCameraDevice.cpp b/camera/EmulatedCameraDevice.cpp index 31e2aff..f1aced4 100755 --- a/camera/EmulatedCameraDevice.cpp +++ b/camera/EmulatedCameraDevice.cpp @@ -25,7 +25,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Device" -#include +#include #include #include #include "Alignment.h" diff --git a/camera/EmulatedCameraFactory.cpp b/camera/EmulatedCameraFactory.cpp index cf26a9e..414289a 100755 --- a/camera/EmulatedCameraFactory.cpp +++ b/camera/EmulatedCameraFactory.cpp @@ -30,7 +30,7 @@ #include "EmulatedQemuCamera.h" #include "EmulatedQemuCamera3.h" -#include +#include #include extern camera_module_t HAL_MODULE_INFO_SYM; @@ -580,7 +580,7 @@ void EmulatedCameraFactory::onStatusChanged(int cameraId, int newStatus) { // Entry point for camera HAL API. struct hw_module_methods_t EmulatedCameraFactory::mCameraModuleMethods = { - open: EmulatedCameraFactory::device_open + .open = EmulatedCameraFactory::device_open }; }; // end of namespace android diff --git a/camera/EmulatedCameraFactory.h b/camera/EmulatedCameraFactory.h index fe70401..4091bfc 100755 --- a/camera/EmulatedCameraFactory.h +++ b/camera/EmulatedCameraFactory.h @@ -27,7 +27,7 @@ namespace android { -struct EmulatedCameraHotplugThread; +class EmulatedCameraHotplugThread; /* * Contains declaration of a class EmulatedCameraFactory that manages cameras diff --git a/camera/EmulatedCameraHal.cpp b/camera/EmulatedCameraHal.cpp index b1f8b3a..f60b0d2 100755 --- a/camera/EmulatedCameraHal.cpp +++ b/camera/EmulatedCameraHal.cpp @@ -29,20 +29,20 @@ * Required HAL header. */ camera_module_t HAL_MODULE_INFO_SYM = { - common: { - tag: HARDWARE_MODULE_TAG, - module_api_version: CAMERA_MODULE_API_VERSION_2_3, - hal_api_version: HARDWARE_HAL_API_VERSION, - id: CAMERA_HARDWARE_MODULE_ID, - name: "Emulated Camera Module", - author: "The Android Open Source Project", - methods: &android::EmulatedCameraFactory::mCameraModuleMethods, - dso: NULL, - reserved: {0}, + .common = { + .tag = HARDWARE_MODULE_TAG, + .module_api_version = CAMERA_MODULE_API_VERSION_2_3, + .hal_api_version = HARDWARE_HAL_API_VERSION, + .id = CAMERA_HARDWARE_MODULE_ID, + .name = "Emulated Camera Module", + .author = "The Android Open Source Project", + .methods = &android::EmulatedCameraFactory::mCameraModuleMethods, + .dso = NULL, + .reserved = {0}, }, - get_number_of_cameras: android::EmulatedCameraFactory::get_number_of_cameras, - get_camera_info: android::EmulatedCameraFactory::get_camera_info, - set_callbacks: android::EmulatedCameraFactory::set_callbacks, - get_vendor_tag_ops: android::EmulatedCameraFactory::get_vendor_tag_ops, - open_legacy: android::EmulatedCameraFactory::open_legacy + .get_number_of_cameras = android::EmulatedCameraFactory::get_number_of_cameras, + .get_camera_info = android::EmulatedCameraFactory::get_camera_info, + .set_callbacks = android::EmulatedCameraFactory::set_callbacks, + .get_vendor_tag_ops = android::EmulatedCameraFactory::get_vendor_tag_ops, + .open_legacy = android::EmulatedCameraFactory::open_legacy }; diff --git a/camera/EmulatedCameraHotplugThread.cpp b/camera/EmulatedCameraHotplugThread.cpp index de94429..f7782be 100644 --- a/camera/EmulatedCameraHotplugThread.cpp +++ b/camera/EmulatedCameraHotplugThread.cpp @@ -15,7 +15,7 @@ */ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_HotplugThread" -#include +#include #include #include diff --git a/camera/EmulatedFakeCamera.cpp b/camera/EmulatedFakeCamera.cpp index ff19fd0..bf41fb6 100755 --- a/camera/EmulatedFakeCamera.cpp +++ b/camera/EmulatedFakeCamera.cpp @@ -21,7 +21,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeCamera" -#include +#include #include #include "EmulatedFakeCamera.h" #include "EmulatedCameraFactory.h" diff --git a/camera/EmulatedFakeCamera2.cpp b/camera/EmulatedFakeCamera2.cpp index dad384c..6bff5eb 100644 --- a/camera/EmulatedFakeCamera2.cpp +++ b/camera/EmulatedFakeCamera2.cpp @@ -23,7 +23,7 @@ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeCamera2" -#include +#include #include "EmulatedFakeCamera2.h" #include "EmulatedCameraFactory.h" @@ -114,8 +114,8 @@ status_t EmulatedFakeCamera2::Initialize() { int32_t width = 0, height = 0; size_t rawSizeCount = sizeof(kAvailableRawSizes)/sizeof(kAvailableRawSizes[0]); for (size_t index = 0; index + 1 < rawSizeCount; index += 2) { - if (width <= kAvailableRawSizes[index] && - height <= kAvailableRawSizes[index+1]) { + if (width <= (int32_t)kAvailableRawSizes[index] && + height <= (int32_t)kAvailableRawSizes[index+1]) { width = kAvailableRawSizes[index]; height = kAvailableRawSizes[index+1]; } @@ -377,7 +377,6 @@ int EmulatedFakeCamera2::allocateStream( if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { unsigned int numFormats = sizeof(kAvailableFormats) / sizeof(uint32_t); unsigned int formatIdx = 0; - unsigned int sizeOffsetIdx = 0; for (; formatIdx < numFormats; formatIdx++) { if (format == (int)kAvailableFormats[formatIdx]) break; } @@ -1789,8 +1788,6 @@ bool EmulatedFakeCamera2::ControlThread::threadLoop() { mLockAfterPassiveScan = false; } - uint8_t oldAfState = afState; - if (afTriggered) { afState = processAfTrigger(afMode, afState); } @@ -2090,7 +2087,7 @@ status_t EmulatedFakeCamera2::constructStaticInfo( // 5 m hyperfocal distance for back camera, infinity (fixed focus) for front const float hyperFocalDistance = mFacingBack ? 1.0/5.0 : 0.0; ADD_OR_SIZE(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, - &minFocusDistance, 1); + &hyperFocalDistance, 1); static const float focalLength = 3.30f; // mm ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, @@ -2679,7 +2676,6 @@ status_t EmulatedFakeCamera2::addOrSize(camera_metadata_t *request, uint32_t tag, const void *entryData, size_t entryDataCount) { - status_t res; if (!sizeRequest) { return add_camera_metadata_entry(request, tag, entryData, entryDataCount); diff --git a/camera/EmulatedFakeCamera3.cpp b/camera/EmulatedFakeCamera3.cpp index 296d06e..4330c02 100644 --- a/camera/EmulatedFakeCamera3.cpp +++ b/camera/EmulatedFakeCamera3.cpp @@ -25,7 +25,7 @@ //#define LOG_NNDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeCamera3" #include -#include +#include #include "EmulatedFakeCamera3.h" #include "EmulatedCameraFactory.h" @@ -53,7 +53,6 @@ namespace android { const int64_t USEC = 1000LL; const int64_t MSEC = USEC * 1000LL; -const int64_t SEC = MSEC * 1000LL; const int32_t EmulatedFakeCamera3::kAvailableFormats[] = { HAL_PIXEL_FORMAT_RAW16, @@ -292,8 +291,10 @@ status_t EmulatedFakeCamera3::configureStreams( } } - if (newStream->width <= 0 || newStream->width > mSensorWidth || - newStream->height <= 0 || newStream->height > mSensorHeight) { + if (newStream->width <= 0 || + (int32_t)newStream->width > mSensorWidth || + newStream->height <= 0 || + (int32_t)newStream->height > mSensorHeight) { ALOGE("%s: Unsupported stream width 0x%x height 0x%x", __FUNCTION__, newStream->width, newStream->height); return BAD_VALUE; @@ -1158,8 +1159,8 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { int32_t width = 0, height = 0; size_t rawSizeCount = sizeof(kAvailableRawSizes)/sizeof(kAvailableRawSizes[0]); for (size_t index = 0; index + 1 < rawSizeCount; index += 2) { - if (width <= kAvailableRawSizes[index] && - height <= kAvailableRawSizes[index+1]) { + if (width <= (int32_t)kAvailableRawSizes[index] && + height <= (int32_t)kAvailableRawSizes[index+1]) { width = kAvailableRawSizes[index]; height = kAvailableRawSizes[index+1]; } @@ -1940,8 +1941,6 @@ status_t EmulatedFakeCamera3::process3A(CameraMetadata &settings) { */ status_t res; - bool facePriority = false; - camera_metadata_entry e; e = settings.find(ANDROID_CONTROL_MODE); diff --git a/camera/EmulatedFakeCameraDevice.cpp b/camera/EmulatedFakeCameraDevice.cpp index 747c55a..85f0e79 100755 --- a/camera/EmulatedFakeCameraDevice.cpp +++ b/camera/EmulatedFakeCameraDevice.cpp @@ -21,7 +21,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeDevice" -#include +#include #include "EmulatedFakeCamera.h" #include "EmulatedFakeCameraDevice.h" diff --git a/camera/EmulatedFakeRotatingCameraDevice.cpp b/camera/EmulatedFakeRotatingCameraDevice.cpp index 0e54b6c..fc1951e 100755 --- a/camera/EmulatedFakeRotatingCameraDevice.cpp +++ b/camera/EmulatedFakeRotatingCameraDevice.cpp @@ -23,7 +23,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_FakeDevice" #define FAKE_CAMERA_SENSOR "FakeRotatingCameraSensor" -#include +#include #include "EmulatedFakeCamera.h" #include "EmulatedFakeRotatingCameraDevice.h" #include "qemud.h" @@ -94,7 +94,6 @@ static void rgba8888_to_nv21(uint8_t* input, uint8_t* output, int width, int hei static void nv21_to_rgba8888(uint8_t* input, uint32_t * output, int width, int height) { int align = 16; - uint32_t* output0 = output; int yStride = (width + (align -1)) & ~(align-1); uint8_t* inputVU = input + height*yStride; uint8_t Y, U, V; @@ -117,8 +116,6 @@ void EmulatedFakeRotatingCameraDevice::render(int width, int height) { update_scene((float)width, (float)height); create_texture_dotx(1280, 720); - int i, j; - int quads = 1; int w= 992/2; int h = 1280/2; @@ -402,7 +399,6 @@ int EmulatedFakeRotatingCameraDevice::init_gl_surface(int width, int height) checkEglError("eglQuerySurface"); eglQuerySurface(mEglDisplay, mEglSurface, EGL_HEIGHT, &h); checkEglError("eglQuerySurface"); - GLint dim = w < h ? w : h; ALOGD("Window dimensions: %d x %d\n", w, h); diff --git a/camera/EmulatedQemuCamera.cpp b/camera/EmulatedQemuCamera.cpp index 496954b..d08baad 100755 --- a/camera/EmulatedQemuCamera.cpp +++ b/camera/EmulatedQemuCamera.cpp @@ -21,7 +21,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_QemuCamera" -#include +#include #include "EmulatedQemuCamera.h" #include "EmulatedCameraFactory.h" diff --git a/camera/EmulatedQemuCamera2.cpp b/camera/EmulatedQemuCamera2.cpp index 2c94f0e..77d8ff8 100644 --- a/camera/EmulatedQemuCamera2.cpp +++ b/camera/EmulatedQemuCamera2.cpp @@ -22,7 +22,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_QemuCamera2" -#include +#include #include #include "EmulatedQemuCamera2.h" #include "EmulatedCameraFactory.h" diff --git a/camera/EmulatedQemuCamera3.cpp b/camera/EmulatedQemuCamera3.cpp index 123ab1c..7cc3d86 100644 --- a/camera/EmulatedQemuCamera3.cpp +++ b/camera/EmulatedQemuCamera3.cpp @@ -42,7 +42,7 @@ #include #include #include -#include +#include #include namespace android { @@ -53,7 +53,6 @@ namespace android { const int64_t USEC = 1000LL; const int64_t MSEC = USEC * 1000LL; -const int64_t SEC = MSEC * 1000LL; const int32_t EmulatedQemuCamera3::kAvailableFormats[] = { HAL_PIXEL_FORMAT_BLOB, @@ -165,7 +164,8 @@ void EmulatedQemuCamera3::parseResolutions(const char *frameDims) { // Remove any resolution with a dimension exceeding the sensor size. for (auto res = mResolutions.begin(); res != mResolutions.end(); ) { - if (res->first > mSensorWidth || res->second > mSensorHeight) { + if (res->first > (int32_t)mSensorWidth || + res->second > (int32_t)mSensorHeight) { // Width and/or height larger than sensor. Remove it. res = mResolutions.erase(res); } else { @@ -1630,8 +1630,6 @@ status_t EmulatedQemuCamera3::process3A(CameraMetadata &settings) { */ status_t res; - bool facePriority = false; - camera_metadata_entry e; e = settings.find(ANDROID_CONTROL_MODE); diff --git a/camera/EmulatedQemuCameraDevice.cpp b/camera/EmulatedQemuCameraDevice.cpp index 0ff6df2..c416454 100755 --- a/camera/EmulatedQemuCameraDevice.cpp +++ b/camera/EmulatedQemuCameraDevice.cpp @@ -21,7 +21,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_QemuDevice" -#include +#include #include "EmulatedQemuCamera.h" #include "EmulatedQemuCameraDevice.h" diff --git a/camera/Exif.cpp b/camera/Exif.cpp index f7f85f5..0f451ff 100644 --- a/camera/Exif.cpp +++ b/camera/Exif.cpp @@ -16,7 +16,7 @@ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Exif" -#include +#include #include #include @@ -151,12 +151,12 @@ static bool createEntry(ExifData* exifData, // Create an entry and place it in |exifData|, the entry is initialized with a // single byte in |value| -static bool createEntry(ExifData* exifData, - ExifIfd ifd, - int tag, - uint8_t value) { - return createEntry(exifData, ifd, tag, &value, 1, EXIF_FORMAT_BYTE); -} +//static bool createEntry(ExifData* exifData, +// ExifIfd ifd, +// int tag, +// uint8_t value) { +// return createEntry(exifData, ifd, tag, &value, 1, EXIF_FORMAT_BYTE); +//} // Create an entry and place it in |exifData|, the entry is default initialized // by the exif library based on |tag| diff --git a/camera/GrallocModule.h b/camera/GrallocModule.h index 72b6322..c6d4840 100644 --- a/camera/GrallocModule.h +++ b/camera/GrallocModule.h @@ -2,7 +2,7 @@ #define EMU_CAMERA_GRALLOC_MODULE_H #include -#include +#include class GrallocModule { diff --git a/camera/JpegCompressor.cpp b/camera/JpegCompressor.cpp index d757a3d..3a5b15e 100644 --- a/camera/JpegCompressor.cpp +++ b/camera/JpegCompressor.cpp @@ -21,7 +21,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_JPEG" -#include +#include #include #include #include "JpegCompressor.h" diff --git a/camera/PreviewWindow.cpp b/camera/PreviewWindow.cpp index 4c7ee24..aad54e2 100755 --- a/camera/PreviewWindow.cpp +++ b/camera/PreviewWindow.cpp @@ -21,7 +21,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Preview" -#include +#include #include "EmulatedCameraDevice.h" #include "PreviewWindow.h" #include "GrallocModule.h" diff --git a/camera/QemuClient.cpp b/camera/QemuClient.cpp index f5cfe6b..18beb69 100755 --- a/camera/QemuClient.cpp +++ b/camera/QemuClient.cpp @@ -21,7 +21,7 @@ #define LOG_NDEBUG 1 #define LOG_TAG "EmulatedCamera_QemuClient" -#include +#include #include "EmulatedCamera.h" #include "QemuClient.h" diff --git a/camera/Thumbnail.cpp b/camera/Thumbnail.cpp index 4d66f10..8f901a3 100644 --- a/camera/Thumbnail.cpp +++ b/camera/Thumbnail.cpp @@ -18,7 +18,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Thumbnail" -#include +#include #include #include diff --git a/camera/WorkerThread.cpp b/camera/WorkerThread.cpp index 2b5fe92..42505a3 100644 --- a/camera/WorkerThread.cpp +++ b/camera/WorkerThread.cpp @@ -18,7 +18,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_WorkerThread" -#include +#include #include diff --git a/camera/fake-pipeline2/JpegCompressor.cpp b/camera/fake-pipeline2/JpegCompressor.cpp index f4952b2..51de0c0 100644 --- a/camera/fake-pipeline2/JpegCompressor.cpp +++ b/camera/fake-pipeline2/JpegCompressor.cpp @@ -17,7 +17,7 @@ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera2_JpegCompressor" -#include +#include #include "gralloc_cb.h" #include "JpegCompressor.h" @@ -131,7 +131,7 @@ bool JpegCompressor::threadLoop() { status_t JpegCompressor::compress() { // Find source and target buffers. Assumes only one buffer matches // each condition! - bool foundJpeg = false, mFoundAux = false; + bool mFoundAux = false; int thumbWidth = 0, thumbHeight = 0; unsigned char thumbJpegQuality = 90; unsigned char jpegQuality = 90; @@ -223,7 +223,6 @@ bool JpegCompressor::waitForDone(nsecs_t timeout) { } void JpegCompressor::cleanUp() { - status_t res; Mutex::Autolock lock(mBusyMutex); if (mFoundAux) { diff --git a/camera/fake-pipeline2/Scene.cpp b/camera/fake-pipeline2/Scene.cpp index 81dcd31..0fea38e 100644 --- a/camera/fake-pipeline2/Scene.cpp +++ b/camera/fake-pipeline2/Scene.cpp @@ -16,7 +16,7 @@ //#define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_Scene" -#include +#include #include #include #include "Scene.h" @@ -87,8 +87,8 @@ Scene::Scene( mSensorWidth(sensorWidthPx), mSensorHeight(sensorHeightPx), mHour(12), - mExposureDuration(0.033f), - mSensorSensitivity(sensorSensitivity) + mExposureDuration(0.033f) + //mSensorSensitivity(sensorSensitivity) { // Map scene to sensor pixels if (mSensorWidth > mSensorHeight) { diff --git a/camera/fake-pipeline2/Scene.h b/camera/fake-pipeline2/Scene.h index 66d1a69..3a7a001 100644 --- a/camera/fake-pipeline2/Scene.h +++ b/camera/fake-pipeline2/Scene.h @@ -108,7 +108,7 @@ class Scene { int mHour; float mExposureDuration; - float mSensorSensitivity; + //float mSensorSensitivity; enum Materials { GRASS = 0, diff --git a/camera/fake-pipeline2/Sensor.cpp b/camera/fake-pipeline2/Sensor.cpp index b480022..c555275 100644 --- a/camera/fake-pipeline2/Sensor.cpp +++ b/camera/fake-pipeline2/Sensor.cpp @@ -24,7 +24,7 @@ #define ALOGVV(...) ((void)0) #endif -#include +#include #include "../EmulatedFakeCamera2.h" #include "Sensor.h" @@ -190,7 +190,6 @@ bool Sensor::waitForVSync(nsecs_t reltime) { bool Sensor::waitForNewFrame(nsecs_t reltime, nsecs_t *captureTime) { Mutex::Autolock lock(mReadoutMutex); - uint8_t *ret; if (mCapturedBuffers == NULL) { int res; res = mReadoutAvailable.waitRelative(mReadoutMutex, reltime); @@ -270,8 +269,6 @@ bool Sensor::threadLoop() { // time on that. nsecs_t simulatedTime = startRealTime; nsecs_t frameEndRealTime = startRealTime + frameDuration; - nsecs_t frameReadoutEndRealTime = startRealTime + - mRowReadoutTime * mResolution[1]; if (mNextCapturedBuffers != NULL) { ALOGVV("Sensor starting readout"); @@ -380,9 +377,8 @@ bool Sensor::threadLoop() { ret = nanosleep(&t, &t); } while (ret != 0); } - nsecs_t endRealTime = systemTime(); ALOGVV("Frame cycle took %d ms, target %d ms", - (int)((endRealTime - startRealTime)/1000000), + (int)((systemTime() - startRealTime)/1000000), (int)(frameDuration / 1000000)); return true; }; diff --git a/camera/jpeg-stub/Compressor.cpp b/camera/jpeg-stub/Compressor.cpp index 76c4a24..3fe0bd6 100644 --- a/camera/jpeg-stub/Compressor.cpp +++ b/camera/jpeg-stub/Compressor.cpp @@ -18,7 +18,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_JPEGStub_Compressor" -#include +#include #include Compressor::Compressor() { diff --git a/camera/jpeg-stub/JpegStub.cpp b/camera/jpeg-stub/JpegStub.cpp index 1eef9e2..3e02de0 100644 --- a/camera/jpeg-stub/JpegStub.cpp +++ b/camera/jpeg-stub/JpegStub.cpp @@ -19,7 +19,7 @@ #define LOG_NDEBUG 0 #define LOG_TAG "EmulatedCamera_JPEGStub" #include -#include +#include #include #include "Compressor.h" diff --git a/camera/qemu-pipeline3/QemuSensor.cpp b/camera/qemu-pipeline3/QemuSensor.cpp index d52bffd..529bf96 100644 --- a/camera/qemu-pipeline3/QemuSensor.cpp +++ b/camera/qemu-pipeline3/QemuSensor.cpp @@ -34,7 +34,7 @@ #include #include #include -#include +#include namespace android { @@ -55,8 +55,8 @@ QemuSensor::QemuSensor(const char *deviceName, uint32_t width, uint32_t height): mLastRequestWidth(-1), mLastRequestHeight(-1), mCameraQemuClient(), - mGotVSync(false), mDeviceName(deviceName), + mGotVSync(false), mFrameDuration(kFrameDurationRange[0]), mNextBuffers(nullptr), mFrameNumber(0), @@ -153,7 +153,6 @@ bool QemuSensor::waitForVSync(nsecs_t reltime) { bool QemuSensor::waitForNewFrame(nsecs_t reltime, nsecs_t *captureTime) { Mutex::Autolock lock(mReadoutMutex); - uint8_t *ret; if (mCapturedBuffers == nullptr) { int res; res = mReadoutAvailable.waitRelative(mReadoutMutex, reltime); @@ -336,9 +335,8 @@ bool QemuSensor::threadLoop() { ret = nanosleep(&t, &t); } while (ret != 0); } - nsecs_t endRealTime = systemTime(); ALOGVV("Frame cycle took %d ms, target %d ms", - (int) ((endRealTime - startRealTime) / 1000000), + (int) ((systemTime() - startRealTime) / 1000000), (int) (frameDuration / 1000000)); return true; } @@ -346,7 +344,8 @@ bool QemuSensor::threadLoop() { void QemuSensor::captureRGBA(uint8_t *img, uint32_t width, uint32_t height, uint32_t stride, int64_t *timestamp) { status_t res; - if (width != mLastRequestWidth || height != mLastRequestHeight) { + if (width != (uint32_t)mLastRequestWidth || + height != (uint32_t)mLastRequestHeight) { ALOGI("%s: Dimensions for the current request (%dx%d) differ " "from the previous request (%dx%d). Restarting camera", __FUNCTION__, width, height, mLastRequestWidth, @@ -414,7 +413,8 @@ void QemuSensor::captureRGB(uint8_t *img, uint32_t width, uint32_t height, uint3 void QemuSensor::captureNV21(uint8_t *img, uint32_t width, uint32_t height, uint32_t stride, int64_t *timestamp) { status_t res; - if (width != mLastRequestWidth || height != mLastRequestHeight) { + if (width != (uint32_t)mLastRequestWidth || + height != (uint32_t)mLastRequestHeight) { ALOGI("%s: Dimensions for the current request (%dx%d) differ " "from the previous request (%dx%d). Restarting camera", __FUNCTION__, width, height, mLastRequestWidth, diff --git a/hwcomposer/hwcomposer.cpp b/hwcomposer/hwcomposer.cpp index 702527f..cc0dc66 100644 --- a/hwcomposer/hwcomposer.cpp +++ b/hwcomposer/hwcomposer.cpp @@ -271,7 +271,8 @@ static void* hwc_vsync_thread(void* data) { int64_t timestamp = int64_t(rt.tv_sec) * 1e9 + rt.tv_nsec; pdev->procs->vsync(pdev->procs, 0, timestamp); if (rt.tv_sec - last_logged >= log_interval) { - ALOGD("hw_composer sent %d syncs in %ds", sent - last_sent, rt.tv_sec - last_logged); + ALOGD("hw_composer sent %d syncs in %ds", (uint32_t)(sent - last_sent), + (uint32_t)(rt.tv_sec - last_logged)); last_logged = rt.tv_sec; last_sent = sent; } @@ -345,17 +346,17 @@ static int hwc_open(const struct hw_module_t* module, const char* name, static struct hw_module_methods_t hwc_module_methods = { - open: hwc_open, + .open = hwc_open, }; hwc_module_t HAL_MODULE_INFO_SYM = { - common: { - tag: HARDWARE_MODULE_TAG, - module_api_version: HWC_MODULE_API_VERSION_0_1, - hal_api_version: HARDWARE_HAL_API_VERSION, - id: HWC_HARDWARE_MODULE_ID, - name: "Android Emulator hwcomposer module", - author: "The Android Open Source Project", - methods: &hwc_module_methods, + .common = { + .tag = HARDWARE_MODULE_TAG, + .module_api_version = HWC_MODULE_API_VERSION_0_1, + .hal_api_version = HARDWARE_HAL_API_VERSION, + .id = HWC_HARDWARE_MODULE_ID, + .name = "Android Emulator hwcomposer module", + .author = "The Android Open Source Project", + .methods = &hwc_module_methods, } }; -- cgit v1.2.3 From 52d256325b7f0d9607fcfcf883d939f89693a8a3 Mon Sep 17 00:00:00 2001 From: Jeff McGlynn Date: Tue, 10 Jul 2018 15:45:24 -0700 Subject: Add arcore supported property to emulator images To download ARCore from the play store, the image must support the android.hardware.camera.ar property. Add this to images so that we don't need to manually whitelist each emulator image on the play store. Bug: 78242579 Test: Validated that "adb shell pm list features" included the property. Change-Id: Ia00ec4d04e076e9860c5735f477a05ccac38d7cc --- vendor.mk | 1 + 1 file changed, 1 insertion(+) diff --git a/vendor.mk b/vendor.mk index ff5a1e1..958b309 100644 --- a/vendor.mk +++ b/vendor.mk @@ -149,6 +149,7 @@ PRODUCT_COPY_FILES += \ device/generic/goldfish/camera/media_codecs.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_codecs.xml \ device/generic/goldfish/camera/media_codecs_performance.xml:$(TARGET_COPY_OUT_VENDOR)/etc/media_codecs_performance.xml \ frameworks/native/data/etc/android.hardware.touchscreen.multitouch.jazzhand.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.touchscreen.multitouch.jazzhand.xml \ + frameworks/native/data/etc/android.hardware.camera.ar.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.camera.ar.xml \ frameworks/native/data/etc/android.hardware.camera.autofocus.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.camera.autofocus.xml \ frameworks/native/data/etc/android.hardware.camera.full.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.camera.full.xml \ frameworks/native/data/etc/android.hardware.fingerprint.xml:$(TARGET_COPY_OUT_VENDOR)/etc/permissions/android.hardware.fingerprint.xml \ -- cgit v1.2.3 From 96e05ac4dbd53f669025dee8cb88b7e0d02f3a30 Mon Sep 17 00:00:00 2001 From: Akash Agrawal Date: Tue, 17 Jul 2018 16:12:41 -0700 Subject: Update emulator build id for the system image Update stable emulator build id in "emulator-info.txt" for the system image. Exempt-From-Owner-Approval: Need to update the emulator build id as the old version does not exist in GS bucket. Bug: b/111567131 Test: Local Change-Id: I54a560692845f52101a86c1352dd1cc2b848ff69 --- emulator-info.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/emulator-info.txt b/emulator-info.txt index 6fed42f..0d6e6cf 100644 --- a/emulator-info.txt +++ b/emulator-info.txt @@ -1,2 +1,2 @@ # Emulator (stable) version -require version-emulator=4833465 +require version-emulator=4898683 -- cgit v1.2.3 From f03fd390cd3cba082c22ec3d544a23a54ab32310 Mon Sep 17 00:00:00 2001 From: bohu Date: Mon, 23 Jul 2018 15:30:14 -0700 Subject: goldfish: set first shipping api to 24 It is the first api where playstore appears on emulator image. BUG: 111761826 Test: cts-tradefed run cts -m CtsOsTestCases -t android.os.ctst#testSdkInt Change-Id: I563ea23d9fc7540b28f61545b96265dc4b241c3f --- vendor.mk | 2 ++ 1 file changed, 2 insertions(+) diff --git a/vendor.mk b/vendor.mk index 958b309..328b847 100644 --- a/vendor.mk +++ b/vendor.mk @@ -17,6 +17,8 @@ # This file is to configure vendor/data partitions of emulator-related products # +PRODUCT_SHIPPING_API_LEVEL := 24 + # Device modules PRODUCT_PACKAGES += \ gralloc.goldfish \ -- cgit v1.2.3 From 5c5d5fcf829d2bbb255d22a3ba706ea923a0050b Mon Sep 17 00:00:00 2001 From: bohu Date: Tue, 24 Jul 2018 14:53:45 -0700 Subject: goldfish: remove hal_fingerprint_default.te It is causing security violation BUG: 111803009 Test: fingerprint still works Test: fixes above bug Change-Id: Id7f37b4a540e3b69032fa197873fb46cf8380126 --- sepolicy/common/hal_fingerprint_default.te | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 sepolicy/common/hal_fingerprint_default.te diff --git a/sepolicy/common/hal_fingerprint_default.te b/sepolicy/common/hal_fingerprint_default.te deleted file mode 100644 index e5b06f1..0000000 --- a/sepolicy/common/hal_fingerprint_default.te +++ /dev/null @@ -1,5 +0,0 @@ -# TODO(b/36644492): Remove data_between_core_and_vendor_violators once -# hal_fingerprint no longer directly accesses fingerprintd_data_file. -typeattribute hal_fingerprint_default data_between_core_and_vendor_violators; -allow hal_fingerprint_default fingerprintd_data_file:file create_file_perms; -allow hal_fingerprint_default fingerprintd_data_file:dir rw_dir_perms; -- cgit v1.2.3 From 4a57dd62c87f3a3510d08e660bfcd63ec45997c1 Mon Sep 17 00:00:00 2001 From: huans Date: Mon, 23 Jul 2018 11:39:14 -0700 Subject: Add capability MOTION TRACKING to EmulatedFakeCamera3 Motion Tracking is a feature to track fast moving objects, which limits max exposure time to 20 ms. Bug: 111746823 Test: run cts -m CtsAppTestCases -t android.app.cts.SystemFeaturesTest#testCameraFeatures Change-Id: I4a49c940d15be9e13129788dc65d09223c19b6db --- camera/EmulatedCamera3.h | 1 + camera/EmulatedFakeCamera3.cpp | 4 ++++ 2 files changed, 5 insertions(+) diff --git a/camera/EmulatedCamera3.h b/camera/EmulatedCamera3.h index 9d2d7b2..02057e5 100644 --- a/camera/EmulatedCamera3.h +++ b/camera/EmulatedCamera3.h @@ -66,6 +66,7 @@ public: YUV_REPROCESSING, DEPTH_OUTPUT, CONSTRAINED_HIGH_SPEED_VIDEO, + MOTION_TRACKING, // Levels FULL_LEVEL, diff --git a/camera/EmulatedFakeCamera3.cpp b/camera/EmulatedFakeCamera3.cpp index 4330c02..96c2350 100644 --- a/camera/EmulatedFakeCamera3.cpp +++ b/camera/EmulatedFakeCamera3.cpp @@ -1113,6 +1113,7 @@ status_t EmulatedFakeCamera3::getCameraCapabilities() { // "RAW" causes several CTS failures: b/68723953, disable it so far. // TODO: add "RAW" back when all failures are resolved. //mCapabilities.add(RAW); + mCapabilities.add(MOTION_TRACKING); } // Add level-based caps @@ -1877,6 +1878,9 @@ status_t EmulatedFakeCamera3::constructStaticInfo() { case CONSTRAINED_HIGH_SPEED_VIDEO: caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO); break; + case MOTION_TRACKING: + caps.add(ANDROID_REQUEST_AVAILABLE_CAPABILITIES_MOTION_TRACKING); + break; default: // Ignore LEVELs break; -- cgit v1.2.3 From 5cd78d29de9390720948f96d6822ee47ad455c37 Mon Sep 17 00:00:00 2001 From: bohu Date: Mon, 30 Jul 2018 22:54:04 -0700 Subject: set first shipping api to 28 To fix fingerprint selinux errors BUG: 111989951 Change-Id: Iffc8265577bdc636ab8e00ee8603afad44a5e452 --- vendor.mk | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/vendor.mk b/vendor.mk index 328b847..8625069 100644 --- a/vendor.mk +++ b/vendor.mk @@ -17,7 +17,8 @@ # This file is to configure vendor/data partitions of emulator-related products # -PRODUCT_SHIPPING_API_LEVEL := 24 +PRODUCT_SHIPPING_API_LEVEL := 28 +TARGET_USES_MKE2FS := true # Device modules PRODUCT_PACKAGES += \ -- cgit v1.2.3 From 8c1d0ac2680b3e5dc1637907dd45a27c33062f40 Mon Sep 17 00:00:00 2001 From: Jim Kaye Date: Mon, 30 Jul 2018 15:36:58 -0700 Subject: Change category name for Emulator cutout emulation The system image has some "cutout emulation" options. The Emulator added an option of its own. Give the Emulator's a different package category so the system image doesn't mention the Emulator's option under Developer Options : Drawing : Simulate a display with cutout. Fixes: 111807173 Test: Verified with Pi AVD Change-Id: Iea0b87e5fdb4373a09614dc0455bc3f49a5e386c --- .../packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml index 8c98d2f..22ebe32 100644 --- a/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml +++ b/overlay/frameworks/base/packages/overlays/DisplayCutoutEmulationEmu01/AndroidManifest.xml @@ -19,7 +19,7 @@ android:versionCode="1" android:versionName="1.0"> -- cgit v1.2.3 From 341ae7a194fcf39f40279325866e9c383be24ab4 Mon Sep 17 00:00:00 2001 From: Bo Hu Date: Tue, 31 Jul 2018 18:37:08 +0000 Subject: Revert "set first shipping api to 28" This reverts commit 5cd78d29de9390720948f96d6822ee47ad455c37. BUG: 111989951 Reason for revert: broke wear build Change-Id: I9a902202dc98b5d0c1e72729ca16885fb2f9b400 --- vendor.mk | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/vendor.mk b/vendor.mk index 8625069..328b847 100644 --- a/vendor.mk +++ b/vendor.mk @@ -17,8 +17,7 @@ # This file is to configure vendor/data partitions of emulator-related products # -PRODUCT_SHIPPING_API_LEVEL := 28 -TARGET_USES_MKE2FS := true +PRODUCT_SHIPPING_API_LEVEL := 24 # Device modules PRODUCT_PACKAGES += \ -- cgit v1.2.3 From 8a76923254de3313a40711b6d1733e3db5ce529b Mon Sep 17 00:00:00 2001 From: bohu Date: Mon, 18 Sep 2017 15:14:56 -0700 Subject: sensor: use CLOCK_BOOTTIME in clock_gettime As required by cts verifier. BUG: 65366251 Change-Id: I3375501fb188442af12f0544db0e0be325356595 (cherry picked from commit 3561313901558b9508f2dc7af4a0ba97798c2971) (cherry picked from commit 28e4bcaa88853a8fb0620f2787e2ae7eb0f5527e) --- sensors/sensors_qemu.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sensors/sensors_qemu.c b/sensors/sensors_qemu.c index 998d1c1..dfa6273 100644 --- a/sensors/sensors_qemu.c +++ b/sensors/sensors_qemu.c @@ -128,7 +128,7 @@ _sensorIdFromName( const char* name ) /* return the current time in nanoseconds */ static int64_t now_ns(void) { struct timespec ts; - clock_gettime(CLOCK_MONOTONIC, &ts); + clock_gettime(CLOCK_BOOTTIME, &ts); return (int64_t)ts.tv_sec * 1000000000 + ts.tv_nsec; } -- cgit v1.2.3 From 0d147bd9fba79b9e00047cc16550903e8b57b745 Mon Sep 17 00:00:00 2001 From: huans Date: Wed, 1 Aug 2018 15:06:44 -0700 Subject: Fix sanity check for configureStream. bug: 111658209 Test: run vts -m VtsHalCameraProviderV2_4Target Change-Id: I0ca633510a525368d5a2b0277b265ec141505d2f --- camera/EmulatedFakeCamera3.cpp | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/camera/EmulatedFakeCamera3.cpp b/camera/EmulatedFakeCamera3.cpp index 96c2350..625a0f1 100644 --- a/camera/EmulatedFakeCamera3.cpp +++ b/camera/EmulatedFakeCamera3.cpp @@ -265,7 +265,7 @@ status_t EmulatedFakeCamera3::configureStreams( } ALOGV("%s: Stream %p (id %zu), type %d, usage 0x%x, format 0x%x " - "width %d, height %d", + "width 0x%x, height 0x%x", __FUNCTION__, newStream, i, newStream->stream_type, newStream->usage, newStream->format, @@ -291,10 +291,9 @@ status_t EmulatedFakeCamera3::configureStreams( } } - if (newStream->width <= 0 || - (int32_t)newStream->width > mSensorWidth || - newStream->height <= 0 || - (int32_t)newStream->height > mSensorHeight) { + if (newStream->width == 0 || newStream->height == 0 || + newStream->width > (uint32_t)mSensorWidth || + newStream->height > (uint32_t)mSensorHeight) { ALOGE("%s: Unsupported stream width 0x%x height 0x%x", __FUNCTION__, newStream->width, newStream->height); return BAD_VALUE; -- cgit v1.2.3 From 543816812430b72b898371c2e345438d0a08a7a7 Mon Sep 17 00:00:00 2001 From: bohu Date: Wed, 1 Aug 2018 15:38:47 -0700 Subject: goldfish: allow emulator to suspend Previously we install an emulator_wake_lock to prevent it from being suspended, and that is the right behavior for most cases. However, sometime we do want the emualtor to suspend (such as doing sensor verifier tests). This cl will skip installing the emualtor_wake_lock if -qemu -append qemu.allowsuspend=1 is given. The default behavior is unchanged. BUG: 112074471 Change-Id: I5bcdd4d4394f6c15fd15c78603c0a52c0d46c777 --- init.ranchu-core.sh | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/init.ranchu-core.sh b/init.ranchu-core.sh index 0b2e6fd..e6c9de4 100755 --- a/init.ranchu-core.sh +++ b/init.ranchu-core.sh @@ -11,4 +11,12 @@ case "$bootanim" in esac # take the wake lock -echo "emulator_wake_lock" > /sys/power/wake_lock +allowsuspend=`getprop ro.kernel.qemu.allowsuspend` +case "$allowsuspend" in + "") echo "emulator_wake_lock" > /sys/power/wake_lock + ;; + 1) echo "emulator_wake_lock" > /sys/power/wake_unlock + ;; + *) echo "emulator_wake_lock" > /sys/power/wake_lock + ;; +esac -- cgit v1.2.3 From ee28af438c5a4a1e50c4f97a283edaac1665f02c Mon Sep 17 00:00:00 2001 From: bohu Date: Thu, 2 Aug 2018 12:55:41 -0700 Subject: goldfish: re-enable shipping api level For x86 and x86_64 aosp/sdk images only This wont impact wear and other products that only include emulator.mk BUG: 111989951 Change-Id: Ie68a4f3683aa1c152aa058a48392038aaf7b09d8 Merged-In: Ie68a4f3683aa1c152aa058a48392038aaf7b09d8 --- vendor.mk | 2 -- x86-vendor.mk | 2 ++ x86_64-vendor.mk | 2 ++ 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/vendor.mk b/vendor.mk index 328b847..958b309 100644 --- a/vendor.mk +++ b/vendor.mk @@ -17,8 +17,6 @@ # This file is to configure vendor/data partitions of emulator-related products # -PRODUCT_SHIPPING_API_LEVEL := 24 - # Device modules PRODUCT_PACKAGES += \ gralloc.goldfish \ diff --git a/x86-vendor.mk b/x86-vendor.mk index 22e6ec7..2ee7f1b 100644 --- a/x86-vendor.mk +++ b/x86-vendor.mk @@ -11,3 +11,5 @@ PRODUCT_COPY_FILES += \ device/generic/goldfish/data/etc/encryptionkey.img:encryptionkey.img \ prebuilts/qemu-kernel/x86_64/4.9/kernel-qemu2:kernel-ranchu-64 +PRODUCT_SHIPPING_API_LEVEL := 28 +TARGET_USES_MKE2FS := true diff --git a/x86_64-vendor.mk b/x86_64-vendor.mk index 2aa61c9..66d46f9 100644 --- a/x86_64-vendor.mk +++ b/x86_64-vendor.mk @@ -11,3 +11,5 @@ PRODUCT_COPY_FILES += \ device/generic/goldfish/data/etc/encryptionkey.img:encryptionkey.img \ prebuilts/qemu-kernel/x86_64/4.9/kernel-qemu2:kernel-ranchu +PRODUCT_SHIPPING_API_LEVEL := 28 +TARGET_USES_MKE2FS := true -- cgit v1.2.3 From 6e604f70bc56b328f0c4af2fc5a1578938f4d1e5 Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Fri, 3 Aug 2018 13:07:19 -0700 Subject: Pass the size of the vatiable instead of a pointer to it RIL_onRequestComplete(t, RIL_E_SUCCESS, &session_id, sizeof(&session_id)) passes size of a pointer to session_id instead of size of session_id. Bug: 112142343 Test: make -j50 Change-Id: I36db293b793ac569631e2407483326a5a004ebe0 Signed-off-by: Roman Kiryanov --- ril/reference-ril.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ril/reference-ril.c b/ril/reference-ril.c index b1f6b37..c0db44d 100644 --- a/ril/reference-ril.c +++ b/ril/reference-ril.c @@ -1899,7 +1899,7 @@ static void requestSimOpenChannel(void *data, size_t datalen, RIL_Token t) return; } - RIL_onRequestComplete(t, RIL_E_SUCCESS, &session_id, sizeof(&session_id)); + RIL_onRequestComplete(t, RIL_E_SUCCESS, &session_id, sizeof(session_id)); at_response_free(p_response); } -- cgit v1.2.3 From 6c9d41e14bd16e4495cee2bbc774f5cdb06f7e34 Mon Sep 17 00:00:00 2001 From: Weilun Du Date: Mon, 6 Aug 2018 10:04:43 -0700 Subject: Reserve 128MB for critical system components. We recently created a new GID that can be granted to critical system processes, so that the system is usable enough for the user to free up disk space used by abusive apps. 128MB ought to be enough for anybody. Test: run cts -m CtsAppSecurityHostTestCases -t android.appsecurity.cts.StorageHostTest#testVerify BUG: 112239816 Change-Id: I061cb365cfbdcdbc833106d81db60e5e36d613e5 Signed-off-by: Weilun Du --- fstab.ranchu | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fstab.ranchu b/fstab.ranchu index 0c83d59..12988ab 100644 --- a/fstab.ranchu +++ b/fstab.ranchu @@ -2,5 +2,5 @@ # # The filesystem that contains the filesystem checker binary (typically /system) cannot # specify MF_CHECK, and must come before any filesystems that do specify MF_CHECK -/dev/block/vdc /data ext4 noatime,nosuid,nodev,nomblk_io_submit,errors=panic wait,check,quota,forceencrypt=/dev/block/vdd +/dev/block/vdc /data ext4 noatime,nosuid,nodev,nomblk_io_submit,errors=panic wait,check,quota,forceencrypt=/dev/block/vdd,reservedsize=128M /devices/*/block/vdf auto auto defaults voldmanaged=sdcard:auto,encryptable=userdata -- cgit v1.2.3 From 9bd45e6a94c8d8b84d834ffd6029fef5ddec4f5a Mon Sep 17 00:00:00 2001 From: Kenneth Magic Date: Wed, 8 Aug 2018 12:31:32 -0700 Subject: Create a dummy USB gadget for sysfs tests. VTS has test cases for the sysfs interface around USB gadgets. As the emulator does not function as a USB gadget, creating a dummy one is the simplest mechanism to enable the sysfs testing. Bug: 110558638 Test: run vts -m VtsKernelApiSysfsTest Change-Id: I87e0d0174bb49b0694ae2704134635d3c3c5ec6c` --- init.ranchu.rc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/init.ranchu.rc b/init.ranchu.rc index 12f5a68..bf77184 100644 --- a/init.ranchu.rc +++ b/init.ranchu.rc @@ -36,6 +36,8 @@ on boot start goldfish-logcat + # Create a dummy USB gadget to allow sysfs testing + mkdir /config/usb_gadget/g1 0770 root root service ranchu-setup /vendor/bin/init.ranchu-core.sh class core -- cgit v1.2.3 From dabd8de3d3192aedb6c30832938631c3e653f1d2 Mon Sep 17 00:00:00 2001 From: Roman Kiryanov Date: Wed, 8 Aug 2018 16:51:50 -0700 Subject: Return the auth status as the error code for +CSIM ril_service.cpp expects the error to be received as the error code instead of the auth status. Bug: 110212792 Test: ./android-vts/tools/vts-tradefed run vts -m VtsHalRadioV1_0Target \ -t VtsHalRadioV1_0Target#RadioHidlTest.requestIccSimAuthentication_64bit Signed-off-by: Roman Kiryanov Change-Id: I4301979c929d54b091851326769f422974555cff --- ril/reference-ril.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ril/reference-ril.c b/ril/reference-ril.c index c0db44d..51f63ea 100644 --- a/ril/reference-ril.c +++ b/ril/reference-ril.c @@ -2415,7 +2415,7 @@ static void requestGetSimAuthentication(void *data, size_t datalen __unused, RIL char* line = p_response->p_intermediates->line; parseAuthResponse(line, &auth_response); - RIL_onRequestComplete(t, RIL_E_SUCCESS, &auth_response, sizeof(auth_response)); + RIL_onRequestComplete(t, auth_response.sw2, &auth_response, sizeof(auth_response)); free(auth_response.simResponse); free(p_response); } -- cgit v1.2.3 From 27583a2c7c1b1fcadb8421ea807df0715465b650 Mon Sep 17 00:00:00 2001 From: Matt Wachowski Date: Thu, 9 Aug 2018 09:17:17 -0700 Subject: Cleanup some compiler warnings in driver_cmd_nl80211.c. Bug: b/80194417 Test: Recompile to assert warnings are gone. Change-Id: I80141b3105765b226211f78c6b748b0ac894a682 --- wifi/wpa_supplicant_8_lib/driver_cmd_nl80211.c | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/wifi/wpa_supplicant_8_lib/driver_cmd_nl80211.c b/wifi/wpa_supplicant_8_lib/driver_cmd_nl80211.c index 7cf4468..9589e85 100644 --- a/wifi/wpa_supplicant_8_lib/driver_cmd_nl80211.c +++ b/wifi/wpa_supplicant_8_lib/driver_cmd_nl80211.c @@ -43,8 +43,6 @@ int wpa_driver_nl80211_driver_cmd( void* priv, char* cmd, char* buf, size_t buf_len) { struct i802_bss* bss = priv; struct wpa_driver_nl80211_data* drv = bss->drv; - struct ifreq ifr; - android_wifi_priv_cmd priv_cmd; int ret = 0; D("%s: called", __FUNCTION__); @@ -70,27 +68,40 @@ int wpa_driver_nl80211_driver_cmd( } -int wpa_driver_set_p2p_noa(void* priv, u8 count, int start, int duration) { +int wpa_driver_set_p2p_noa( + __attribute__((__unused__)) void* priv, + __attribute__((__unused__)) u8 count, + __attribute__((__unused__)) int start, + __attribute__((__unused__)) int duration) { D("%s: called", __FUNCTION__); return 0; } -int wpa_driver_get_p2p_noa(void* priv, u8* buf, size_t len) { +int wpa_driver_get_p2p_noa( + __attribute__((__unused__)) void* priv, + __attribute__((__unused__)) u8* buf, + __attribute__((__unused__)) size_t len) { D("%s: called", __FUNCTION__); return 0; } -int wpa_driver_set_p2p_ps(void* priv, int legacy_ps, int opp_ps, int ctwindow) { +int wpa_driver_set_p2p_ps( + __attribute__((__unused__)) void* priv, + __attribute__((__unused__)) int legacy_ps, + __attribute__((__unused__)) int opp_ps, + __attribute__((__unused__)) int ctwindow) { D("%s: called", __FUNCTION__); return -1; } int wpa_driver_set_ap_wps_p2p_ie( - void* priv, const struct wpabuf* beacon, - const struct wpabuf* proberesp, const struct wpabuf* assocresp) { + __attribute__((__unused__)) void* priv, + __attribute__((__unused__)) const struct wpabuf* beacon, + __attribute__((__unused__)) const struct wpabuf* proberesp, + __attribute__((__unused__)) const struct wpabuf* assocresp) { D("%s: called", __FUNCTION__); return 0; } -- cgit v1.2.3 From 7ef398360d6e71b45c5d72021713a352253f40b5 Mon Sep 17 00:00:00 2001 From: Jim Kaye Date: Fri, 10 Aug 2018 10:54:31 -0700 Subject: Retain GPS flags across multiple messages This code sets flags to indicate what GPS values are present. The current code sets the flags only according to the most recent message. This change aggregates the flags, so if different message types are received, the flags indicate all the values that were received in the multiple messages. This is needed because the Emulator now sends both altitude and speed, which requires two types of messages. This CL also removes some dead code. Bug: 112259283 Test: The VtsHalGnssV1_0Target group now passes 6/6 Change-Id: Iecf710f02a2bac6740f5beff729d6da9224868bc --- gps/gps_qemu.c | 36 +++++++++++++++++++----------------- 1 file changed, 19 insertions(+), 17 deletions(-) diff --git a/gps/gps_qemu.c b/gps/gps_qemu.c index dc7351f..7985869 100644 --- a/gps/gps_qemu.c +++ b/gps/gps_qemu.c @@ -41,6 +41,7 @@ #define GPS_DEBUG 0 +#undef D #if GPS_DEBUG # define D(...) ALOGD(__VA_ARGS__) #else @@ -71,7 +72,6 @@ static int nmea_tokenizer_init( NmeaTokenizer* t, const char* p, const char* end ) { int count = 0; - char* q; // the initial '$' is optional if (p < end && p[0] == '$') @@ -154,7 +154,6 @@ Fail: static double str2float( const char* p, const char* end ) { - int result = 0; int len = end - p; char temp[16]; @@ -336,6 +335,8 @@ nmea_reader_update_latlong( NmeaReader* r, double lat, lon; Token tok; + r->fix.flags &= ~GPS_LOCATION_HAS_LAT_LONG; + tok = latitude; if (tok.p + 6 > tok.end) { D("latitude is too short: '%.*s'", tok.end-tok.p, tok.p); @@ -366,9 +367,10 @@ nmea_reader_update_altitude( NmeaReader* r, Token altitude, Token __unused units ) { - double alt; Token tok = altitude; + r->fix.flags &= ~GPS_LOCATION_HAS_ALTITUDE; + if (tok.p >= tok.end) return -1; @@ -382,9 +384,10 @@ static int nmea_reader_update_bearing( NmeaReader* r, Token bearing ) { - double alt; Token tok = bearing; + r->fix.flags &= ~GPS_LOCATION_HAS_BEARING; + if (tok.p >= tok.end) return -1; @@ -398,9 +401,10 @@ static int nmea_reader_update_speed( NmeaReader* r, Token speed ) { - double alt; Token tok = speed; + r->fix.flags &= ~GPS_LOCATION_HAS_SPEED; + if (tok.p >= tok.end) return -1; @@ -465,7 +469,6 @@ nmea_reader_parse( NmeaReader* r ) Token tok_altitude = nmea_tokenizer_get(tzer,9); Token tok_altitudeUnits = nmea_tokenizer_get(tzer,10); - r->fix.flags = 0; nmea_reader_update_time(r, tok_time); nmea_reader_update_latlong(r, tok_latitude, tok_latitudeHemi.p[0], @@ -489,7 +492,6 @@ nmea_reader_parse( NmeaReader* r ) D("in RMC, fixStatus=%c", tok_fixStatus.p[0]); if (tok_fixStatus.p[0] == 'A') { - r->fix.flags = 0; nmea_reader_update_date( r, tok_date, tok_time ); nmea_reader_update_latlong( r, tok_latitude, @@ -665,15 +667,15 @@ epoll_register( int epoll_fd, int fd ) } -static int -epoll_deregister( int epoll_fd, int fd ) -{ - int ret; - do { - ret = epoll_ctl( epoll_fd, EPOLL_CTL_DEL, fd, NULL ); - } while (ret < 0 && errno == EINTR); - return ret; -} +// static int +// epoll_deregister( int epoll_fd, int fd ) +// { +// int ret; +// do { +// ret = epoll_ctl( epoll_fd, EPOLL_CTL_DEL, fd, NULL ); +// } while (ret < 0 && errno == EINTR); +// return ret; +// } /* this is the main thread, it waits for commands from gps_state_start/stop and, * when started, messages from the QEMU GPS daemon. these are simple NMEA sentences @@ -738,7 +740,7 @@ gps_state_thread( void* arg ) if (fd == control_fd) { - char cmd = 255; + char cmd = 0xFF; int ret; D("gps control fd event"); do { -- cgit v1.2.3 From f891132c58fa7fc12e2c211bacc7099feafa1a9e Mon Sep 17 00:00:00 2001 From: bohu Date: Thu, 16 Aug 2018 14:41:11 -0700 Subject: goldfish: disable WIFI_FEATURE_LINK_LAYER_STATS We are missing a few fields for this feature, disable it until we have the full support. BUG: 112202626 Test: vts still pass for wifi related modules Change-Id: Icfaf19bd993d2b367aaa1d2e1816393e6d0f8d52 --- wifi/wifi_hal/interface.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wifi/wifi_hal/interface.cpp b/wifi/wifi_hal/interface.cpp index f3d1f13..af96884 100644 --- a/wifi/wifi_hal/interface.cpp +++ b/wifi/wifi_hal/interface.cpp @@ -74,7 +74,7 @@ wifi_error Interface::getSupportedFeatureSet(feature_set* set) { if (set == nullptr) { return WIFI_ERROR_INVALID_ARGS; } - *set = WIFI_FEATURE_LINK_LAYER_STATS; + *set = 0; return WIFI_SUCCESS; } -- cgit v1.2.3 From d9689ef63954619b589c32752a790e5336ade746 Mon Sep 17 00:00:00 2001 From: Haitao Shan Date: Fri, 17 Aug 2018 11:58:33 -0700 Subject: Add power service 1.1 ranchu. Bug: 79491800 Test: cts android.cts.statsd.atom.HostAtomTests#testSubsystemSleepState Change-Id: Ic15f70ef05233da051ddeb08338e31dafa55a0df --- manifest.xml | 2 +- power/Android.mk | 39 +++--- power/Power.cpp | 146 +++++++++++++++++++++ power/Power.h | 61 +++++++++ power/android.hardware.power@1.1-service.ranchu.rc | 4 + power/power_qemu.c | 64 --------- power/service.cpp | 67 ++++++++++ sepolicy/common/file_contexts | 1 + vendor.mk | 5 +- 9 files changed, 299 insertions(+), 90 deletions(-) create mode 100644 power/Power.cpp create mode 100644 power/Power.h create mode 100644 power/android.hardware.power@1.1-service.ranchu.rc delete mode 100644 power/power_qemu.c create mode 100644 power/service.cpp diff --git a/manifest.xml b/manifest.xml index 0000149..38a22d6 100644 --- a/manifest.xml +++ b/manifest.xml @@ -91,7 +91,7 @@ android.hardware.power hwbinder - 1.0 + 1.1 IPower default diff --git a/power/Android.mk b/power/Android.mk index e3d07a5..3466c54 100644 --- a/power/Android.mk +++ b/power/Android.mk @@ -1,4 +1,4 @@ -# Copyright (C) 2012 The Android Open Source Project +# Copyright (C) 2017 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -12,33 +12,26 @@ # See the License for the specific language governing permissions and # limitations under the License. - LOCAL_PATH := $(call my-dir) -# HAL module implemenation stored in -# hw/..so include $(CLEAR_VARS) LOCAL_VENDOR_MODULE := true LOCAL_MODULE_RELATIVE_PATH := hw -LOCAL_CFLAGS += -DQEMU_HARDWARE -LOCAL_SHARED_LIBRARIES := liblog libcutils -LOCAL_HEADER_LIBRARIES := libutils_headers libhardware_headers -LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include -LOCAL_SRC_FILES := power_qemu.c -LOCAL_MODULE := power.goldfish -LOCAL_MODULE_TAGS := optional -include $(BUILD_SHARED_LIBRARY) -include $(CLEAR_VARS) +LOCAL_MODULE := android.hardware.power@1.1-service.ranchu +LOCAL_INIT_RC := android.hardware.power@1.1-service.ranchu.rc +LOCAL_SRC_FILES := service.cpp Power.cpp -LOCAL_VENDOR_MODULE := true -LOCAL_MODULE_RELATIVE_PATH := hw -LOCAL_CFLAGS += -DQEMU_HARDWARE -LOCAL_SHARED_LIBRARIES := liblog libcutils -LOCAL_HEADER_LIBRARIES := libutils_headers libhardware_headers -LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include -LOCAL_SRC_FILES := power_qemu.c -LOCAL_MODULE := power.ranchu -LOCAL_MODULE_TAGS := optional -include $(BUILD_SHARED_LIBRARY) +LOCAL_HEADER_LIBRARIES := libhardware_headers + +LOCAL_SHARED_LIBRARIES := \ + libbase \ + libcutils \ + libhidlbase \ + libhidltransport \ + liblog \ + libutils \ + android.hardware.power@1.1 \ + +include $(BUILD_EXECUTABLE) diff --git a/power/Power.cpp b/power/Power.cpp new file mode 100644 index 0000000..5ba33c8 --- /dev/null +++ b/power/Power.cpp @@ -0,0 +1,146 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "android.hardware.power@1.1-service.marlin" + +#include +#include + +#include + +#include "Power.h" + +enum subsystem_type { + SUBSYSTEM_WLAN, + + //Don't add any lines after that line + SUBSYSTEM_COUNT +}; + +enum wlan_param_id { + CUMULATIVE_SLEEP_TIME_MS, + CUMULATIVE_TOTAL_ON_TIME_MS, + DEEP_SLEEP_ENTER_COUNTER, + LAST_DEEP_SLEEP_ENTER_TSTAMP_MS, + + //Don't add any lines after that line + WLAN_PARAM_COUNT +}; + +enum wlan_state_id { + WLAN_STATE_ACTIVE = 0, + WLAN_STATE_DEEP_SLEEP, + + //Don't add any lines after that line + WLAN_STATE_COUNT +}; + +namespace android { +namespace hardware { +namespace power { +namespace V1_1 { +namespace implementation { + +using ::android::hardware::power::V1_0::Feature; +using ::android::hardware::power::V1_0::PowerHint; +using ::android::hardware::power::V1_0::PowerStatePlatformSleepState; +using ::android::hardware::power::V1_0::Status; +using ::android::hardware::power::V1_1::PowerStateSubsystem; +using ::android::hardware::hidl_vec; +using ::android::hardware::Return; +using ::android::hardware::Void; + +Power::Power() { +} + +// Methods from ::android::hardware::power::V1_0::IPower follow. +Return Power::setInteractive(bool __attribute__((__unused__)) interactive) { + return Void(); +} + +Return Power::powerHint(PowerHint __attribute__((__unused__)) hint, int32_t __attribute__((__unused__)) data) { + return Void(); +} + +Return Power::setFeature(Feature /*feature*/, bool /*activate*/) { + return Void(); +} + +Return Power::getPlatformLowPowerStats(getPlatformLowPowerStats_cb _hidl_cb) { + + hidl_vec states; + + states.resize(0); + _hidl_cb(states, Status::SUCCESS); + return Void(); +} + +static int get_wlan_low_power_stats(struct PowerStateSubsystem &subsystem) { + + struct PowerStateSubsystemSleepState *state; + + subsystem.name = "wlan"; + subsystem.states.resize(WLAN_STATE_COUNT); + + /* Update statistics for Active State */ + state = &subsystem.states[WLAN_STATE_ACTIVE]; + state->name = "Active"; + state->residencyInMsecSinceBoot = 1000; + state->totalTransitions = 1; + state->lastEntryTimestampMs = 0; + state->supportedOnlyInSuspend = false; + + /* Update statistics for Deep-Sleep state */ + state = &subsystem.states[WLAN_STATE_DEEP_SLEEP]; + state->name = "Deep-Sleep"; + state->residencyInMsecSinceBoot = 0; + state->totalTransitions = 0; + state->lastEntryTimestampMs = 0; + state->supportedOnlyInSuspend = false; + + return 0; +} + +Return Power::getSubsystemLowPowerStats(getSubsystemLowPowerStats_cb _hidl_cb) { + + hidl_vec subsystems; + int ret; + + subsystems.resize(subsystem_type::SUBSYSTEM_COUNT); + + //We currently have only one Subsystem for WLAN + ret = get_wlan_low_power_stats(subsystems[subsystem_type::SUBSYSTEM_WLAN]); + if (ret != 0) { + goto done; + } + + //Add query for other subsystems here + +done: + _hidl_cb(subsystems, Status::SUCCESS); + return Void(); +} + +Return Power::powerHintAsync(PowerHint hint, int32_t data) { + // just call the normal power hint in this oneway function + return powerHint(hint, data); +} + +} // namespace implementation +} // namespace V1_1 +} // namespace power +} // namespace hardware +} // namespace android diff --git a/power/Power.h b/power/Power.h new file mode 100644 index 0000000..2676b7d --- /dev/null +++ b/power/Power.h @@ -0,0 +1,61 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ANDROID_HARDWARE_POWER_V1_1_POWER_H +#define ANDROID_HARDWARE_POWER_V1_1_POWER_H + +#include +#include +#include +#include + +namespace android { +namespace hardware { +namespace power { +namespace V1_1 { +namespace implementation { + +using ::android::hardware::power::V1_0::Feature; +using ::android::hardware::power::V1_0::PowerHint; +using ::android::hardware::power::V1_1::IPower; +using ::android::hardware::Return; +using ::android::hardware::Void; + +struct Power : public IPower { + // Methods from ::android::hardware::power::V1_0::IPower follow. + + Power(); + + Return setInteractive(bool interactive) override; + Return powerHint(PowerHint hint, int32_t data) override; + Return setFeature(Feature feature, bool activate) override; + Return getPlatformLowPowerStats(getPlatformLowPowerStats_cb _hidl_cb) override; + + // Methods from ::android::hardware::power::V1_1::IPower follow. + Return getSubsystemLowPowerStats(getSubsystemLowPowerStats_cb _hidl_cb) override; + Return powerHintAsync(PowerHint hint, int32_t data) override; + + // Methods from ::android::hidl::base::V1_0::IBase follow. + +}; + +} // namespace implementation +} // namespace V1_1 +} // namespace power +} // namespace hardware +} // namespace android + +#endif // ANDROID_HARDWARE_POWER_V1_1_POWER_H diff --git a/power/android.hardware.power@1.1-service.ranchu.rc b/power/android.hardware.power@1.1-service.ranchu.rc new file mode 100644 index 0000000..f5a05d6 --- /dev/null +++ b/power/android.hardware.power@1.1-service.ranchu.rc @@ -0,0 +1,4 @@ +service vendor.power-hal-1-1 /vendor/bin/hw/android.hardware.power@1.1-service.ranchu + class hal + user system + group system diff --git a/power/power_qemu.c b/power/power_qemu.c deleted file mode 100644 index 808589a..0000000 --- a/power/power_qemu.c +++ /dev/null @@ -1,64 +0,0 @@ -/* - * Copyright (C) 2012 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#define LOG_TAG "emulator PowerHAL" -#include - -#include -#include -#include "qemud.h" -#include -#include - -static int qemud_fd; - -static void power_qemu_init(struct power_module *module) -{ - qemud_fd = qemud_channel_open("hw-control"); - - if (qemud_fd < 0) - ALOGE("Error connecting to qemud hw-control service\n"); -} - -static void power_qemu_set_interactive(struct power_module *module, int on) -{ - int r; - - r = qemud_channel_send(qemud_fd, on ? "power:screen_state:wake" - : "power:screen_state:standby", -1); - - if (r < 0) - ALOGE("Error sending power command to qemud hw-control service\n"); -} - -static struct hw_module_methods_t power_qemu_module_methods = { - .open = NULL, -}; - -struct power_module HAL_MODULE_INFO_SYM = { - .common = { - .tag = HARDWARE_MODULE_TAG, - .version_major = 1, - .version_minor = 0, - .id = POWER_HARDWARE_MODULE_ID, - .name = "Emulator Power HAL", - .author = "The Android Open Source Project", - .methods = &power_qemu_module_methods, - }, - - .init = power_qemu_init, - .setInteractive = power_qemu_set_interactive, -}; diff --git a/power/service.cpp b/power/service.cpp new file mode 100644 index 0000000..b0fb829 --- /dev/null +++ b/power/service.cpp @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2017 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#define LOG_TAG "android.hardware.power@1.1-service.ranchu" + +#include +#include +#include +#include "Power.h" + +using android::sp; +using android::status_t; +using android::OK; + +// libhwbinder: +using android::hardware::configureRpcThreadpool; +using android::hardware::joinRpcThreadpool; + +// Generated HIDL files +using android::hardware::power::V1_1::IPower; +using android::hardware::power::V1_1::implementation::Power; + +int main() { + + status_t status; + android::sp service = nullptr; + + ALOGI("Power HAL Service 1.1 for Ranchu is starting."); + + service = new Power(); + if (service == nullptr) { + ALOGE("Can not create an instance of Power HAL Iface, exiting."); + + goto shutdown; + } + + configureRpcThreadpool(1, true /*callerWillJoin*/); + + status = service->registerAsService(); + if (status != OK) { + ALOGE("Could not register service for Power HAL Iface (%d).", status); + goto shutdown; + } + + ALOGI("Power Service is ready"); + joinRpcThreadpool(); + //Should not pass this line + +shutdown: + // In normal operation, we don't expect the thread pool to exit + + ALOGE("Power Service is shutting down"); + return 1; +} diff --git a/sepolicy/common/file_contexts b/sepolicy/common/file_contexts index c0c7e5e..3c9df34 100644 --- a/sepolicy/common/file_contexts +++ b/sepolicy/common/file_contexts @@ -31,6 +31,7 @@ /vendor/bin/hw/android\.hardware\.drm@1\.1-service\.clearkey u:object_r:hal_drm_clearkey_exec:s0 /vendor/bin/hw/android\.hardware\.keymaster@4\.0-strongbox-service u:object_r:hal_keymaster_default_exec:s0 /vendor/bin/hw/android\.hardware\.health@2\.0-service.goldfish u:object_r:hal_health_default_exec:s0 +/vendor/bin/hw/android\.hardware\.power@1\.1-service.ranchu u:object_r:hal_power_default_exec:s0 /vendor/lib(64)?/hw/gralloc\.ranchu\.so u:object_r:same_process_hal_file:s0 /vendor/lib(64)?/hw/gralloc\.goldfish\.default\.so u:object_r:same_process_hal_file:s0 diff --git a/vendor.mk b/vendor.mk index 958b309..37b170a 100644 --- a/vendor.mk +++ b/vendor.mk @@ -101,8 +101,9 @@ PRODUCT_PACKAGES += \ android.hardware.drm@1.1-service.widevine PRODUCT_PACKAGES += \ - android.hardware.power@1.0-service \ - android.hardware.power@1.0-impl + android.hardware.power@1.1-service.ranchu \ + +PRODUCT_PROPERTY_OVERRIDES += ro.hardware.power=ranchu PRODUCT_PACKAGES += \ camera.device@1.0-impl \ -- cgit v1.2.3