blob: d2ffa82701091b698b440203742933d9c34cd403 [file] [log] [blame]
Amit Mahajan4cb7b842016-08-12 15:25:10 -07001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.hardware.radio@1.0;
18
Sanket Padawe76372492016-10-27 13:20:49 -070019import IRadioResponse;
20import IRadioIndication;
Amit Mahajan4cb7b842016-08-12 15:25:10 -070021
Sanket Padawe76372492016-10-27 13:20:49 -070022/*
23 * This interface is used by telephony & telecom to talk to cellular radio.
Sanket Padawed52335c2016-11-03 16:46:32 -070024 * All the functions have minimum one parameter:
Sanket Padawe76372492016-10-27 13:20:49 -070025 * serial: which corresponds to serial no. of request. Serial numbers must only be memorized for the
26 * duration of a method call. If clients provide colliding serials (including passing the same
27 * serial to different methods), multiple responses (one for each method call) must still be served.
28 */
Amit Mahajan4cb7b842016-08-12 15:25:10 -070029interface IRadio {
Sanket Padawe76372492016-10-27 13:20:49 -070030 /*
31 * Set response functions for radio requests & radio indications.
Amit Mahajan4cb7b842016-08-12 15:25:10 -070032 *
Sanket Padawe76372492016-10-27 13:20:49 -070033 * @param radioResponse Object containing response functions
34 * @param radioIndication Object containing radio indications
Amit Mahajan4cb7b842016-08-12 15:25:10 -070035 */
Sanket Padawed52335c2016-11-03 16:46:32 -070036 setResponseFunctions(IRadioResponse radioResponse,
Sanket Padawe76372492016-10-27 13:20:49 -070037 IRadioIndication radioIndication);
Amit Mahajan4cb7b842016-08-12 15:25:10 -070038
Sanket Padawe76372492016-10-27 13:20:49 -070039 /*
Amit Mahajan4cb7b842016-08-12 15:25:10 -070040 * Requests status of the ICC card
41 *
Sanket Padawe76372492016-10-27 13:20:49 -070042 * @param serial Serial number of request.
Amit Mahajan4cb7b842016-08-12 15:25:10 -070043 *
Sanket Padawe76372492016-10-27 13:20:49 -070044 * Response function is IRadioResponse.getIccCardStatusResponse()
45 *
46 */
Sanket Padawed52335c2016-11-03 16:46:32 -070047 oneway getIccCardStatus(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -070048
49 /*
50 * Supplies ICC PIN. Only called if CardStatus has AppState.PIN state
Amit Mahajan4cb7b842016-08-12 15:25:10 -070051 *
Sanket Padawe76372492016-10-27 13:20:49 -070052 * @param serial Serial number of request.
53 * @param pin PIN value
54 * @param aid AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
55 *
56 * Response function is IRadioResponse.supplyIccPinForAppResponse()
57 *
Amit Mahajan4cb7b842016-08-12 15:25:10 -070058 */
Sanket Padawed52335c2016-11-03 16:46:32 -070059 oneway supplyIccPinForApp(int32_t serial, string pin, string aid);
Sanket Padawe76372492016-10-27 13:20:49 -070060
61 /*
62 * Supplies ICC PUK and new PIN.
63 *
Sanket Padawe76372492016-10-27 13:20:49 -070064 * @param serial Serial number of request.
65 * @param puk PUK value
66 * @param pin New PIN value
67 * @param aid AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
68 *
69 * Response function is IRadioResponse.supplyIccPukForAppResponse()
70 *
71 */
Sanket Padawed52335c2016-11-03 16:46:32 -070072 oneway supplyIccPukForApp(int32_t serial, string puk, string pin, string aid);
Sanket Padawe76372492016-10-27 13:20:49 -070073
74 /*
75 * Supplies ICC PIN2. Only called following operation where SIM_PIN2 was
76 * returned as a a failure from a previous operation.
77 *
Sanket Padawe76372492016-10-27 13:20:49 -070078 * @param serial Serial number of request.
79 * @param pin2 PIN2 value
80 * @param aid AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
81 *
82 * Response function is IRadioResponse.supplyIccPin2ForAppResponse()
83 *
84 */
Sanket Padawed52335c2016-11-03 16:46:32 -070085 oneway supplyIccPin2ForApp(int32_t serial, string pin2, string aid);
Sanket Padawe76372492016-10-27 13:20:49 -070086
87 /*
88 * Supplies ICC PUK2 and new PIN2.
89 *
Sanket Padawe76372492016-10-27 13:20:49 -070090 * @param serial Serial number of request.
91 * @param puk2 PUK2 value
92 * @param pin2 New PIN2 value
93 * @param aid AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
94 *
95 * Response function is IRadioResponse.supplyIccPuk2ForAppResponse()
96 *
97 */
Sanket Padawed52335c2016-11-03 16:46:32 -070098 oneway supplyIccPuk2ForApp(int32_t serial, string puk2, string pin2,
Sanket Padawe76372492016-10-27 13:20:49 -070099 string aid);
100
101 /*
102 * Supplies old ICC PIN and new PIN.
103 *
Sanket Padawe76372492016-10-27 13:20:49 -0700104 * @param serial Serial number of request.
105 * @param oldPin Old pin value
106 * @param newPin New pin value
107 * @param aid AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
108 *
109 * Response function is IRadioResponse.changeIccPinForAppResponse()
110 *
111 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700112 oneway changeIccPinForApp(int32_t serial, string oldPin, string newPin,
Sanket Padawe76372492016-10-27 13:20:49 -0700113 string aid);
114
115 /*
116 * Supplies old ICC PIN2 and new PIN2.
117 *
Sanket Padawe76372492016-10-27 13:20:49 -0700118 * @param serial Serial number of request.
119 * @param oldPin2 Old pin2 value
120 * @param newPin2 New pin2 value
121 * @param aid AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
122 *
123 * Response function is IRadioResponse.changeIccPin2ForAppResponse()
124 *
125 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700126 oneway changeIccPin2ForApp(int32_t serial, string oldPin2, string newPin2,
Sanket Padawe76372492016-10-27 13:20:49 -0700127 string aid);
128
129 /*
130 * Requests that network personalization be deactivated
131 *
Sanket Padawe76372492016-10-27 13:20:49 -0700132 * @param serial Serial number of request.
133 * @param netPin Network depersonlization code
134 *
135 * Response function is IRadioResponse.supplyNetworkDepersonalizationResponse()
136 *
137 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700138 oneway supplyNetworkDepersonalization(int32_t serial, string netPin);
Sanket Padawe76372492016-10-27 13:20:49 -0700139
140 /*
141 * Requests current call list
142 *
Sanket Padawe76372492016-10-27 13:20:49 -0700143 * @param serial Serial number of request.
144 *
145 * Response function is IRadioResponse.getCurrentCallsResponse()
146 *
147 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700148 oneway getCurrentCalls(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700149
150 /*
151 * Initiate voice call.
152 * This method is never used for supplementary service codes
153 *
Sanket Padawe76372492016-10-27 13:20:49 -0700154 * @param serial Serial number of request.
155 * @param dialInfo Dial struct
156 *
157 * Response function is IRadioResponse.dialResponse()
158 *
159 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700160 oneway dial(int32_t serial, Dial dialInfo);
Sanket Padawe76372492016-10-27 13:20:49 -0700161
162 /*
163 * Get the SIM IMSI
164 * Only valid when radio state is "RADIO_STATE_ON"
165 *
Sanket Padawe76372492016-10-27 13:20:49 -0700166 * @param serial Serial number of request.
167 * @param aid AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
168 *
169 * Response function is IRadioResponse.getImsiForAppResponse()
170 *
171 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700172 oneway getImsiForApp(int32_t serial, string aid);
Sanket Padawe76372492016-10-27 13:20:49 -0700173
174 /*
175 * Hang up a specific line (like AT+CHLD=1x)
176 * After this HANGUP request returns, Radio must show the connection is NOT
177 * active anymore in next requestGetCurrentCalls query.
178 *
Sanket Padawe76372492016-10-27 13:20:49 -0700179 * @param serial Serial number of request.
180 * @param gsmIndex Connection index (value of 'x' in CHLD above)
181 *
182 * Response function is IRadioResponse.hangupResponse()
183 *
184 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700185 oneway hangup(int32_t serial, int32_t gsmIndex);
Sanket Padawe76372492016-10-27 13:20:49 -0700186
187 /*
188 * Hang up waiting or held (like AT+CHLD=0)
189 * After this HANGUP request returns, Radio must show the connection is NOT
190 * active anymore in next getCurrentCalls() query.
191 *
Sanket Padawe76372492016-10-27 13:20:49 -0700192 * @param serial Serial number of request.
193 *
194 * Response function is IRadioResponse.hangupWaitingOrBackgroundResponse()
195 *
196 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700197 oneway hangupWaitingOrBackground(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700198
199 /*
200 * Hang up waiting or held (like AT+CHLD=1)
201 * After this HANGUP request returns, Radio must show the connection is NOT
202 * active anymore in next getCurrentCalls query.
203 *
Sanket Padawe76372492016-10-27 13:20:49 -0700204 * @param serial Serial number of request.
205 *
206 * Response function is IRadioResponse.hangupForegroundResumeBackgroundResponse()
207 *
208 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700209 oneway hangupForegroundResumeBackground(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700210
211 /*
212 * Switch waiting or holding call and active call (like AT+CHLD=2)
213 * State transitions must be as follows:
214 *
215 * Call transitions must happen as shown below.
216 *
217 * BEFORE AFTER
218 * Call 1 Call 2 Call 1 Call 2
219 * ACTIVE HOLDING HOLDING ACTIVE
220 * ACTIVE WAITING HOLDING ACTIVE
221 * HOLDING WAITING HOLDING ACTIVE
222 * ACTIVE IDLE HOLDING IDLE
223 * IDLE IDLE IDLE IDLE
224 *
Sanket Padawe76372492016-10-27 13:20:49 -0700225 * @param serial Serial number of request.
226 *
227 * Response function is IRadioResponse.switchWaitingOrHoldingAndActiveResponse()
228 *
229 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700230 oneway switchWaitingOrHoldingAndActive(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700231
232 /*
233 * Conference holding and active (like AT+CHLD=3)
234 *
Sanket Padawe76372492016-10-27 13:20:49 -0700235 * @param serial Serial number of request.
236 *
237 * Response function is IRadioResponse.conferenceResponse()
238 *
239 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700240 oneway conference(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700241
242 /*
243 * Send UDUB (user determined user busy) to ringing or
244 * waiting call answer)
245 *
Sanket Padawe76372492016-10-27 13:20:49 -0700246 * @param serial Serial number of request.
247 *
248 * Response function is IRadioResponse.rejectCallResponse()
249 *
250 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700251 oneway rejectCall(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700252
253 /*
254 * Requests the failure cause code for the most recently terminated call.
255 *
Sanket Padawe76372492016-10-27 13:20:49 -0700256 * @param serial Serial number of request.
257 *
258 * Response function is IRadioResponse.getLastCallFailCauseResponse()
259 *
260 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700261 oneway getLastCallFailCause(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700262
263 /*
264 * Requests current signal strength and associated information.
265 * Must succeed if radio is on.
266 *
Sanket Padawe76372492016-10-27 13:20:49 -0700267 * @param serial Serial number of request.
268 *
269 * Response function is IRadioResponse.getSignalStrengthResponse()
270 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700271 oneway getSignalStrength(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700272
273 /*
274 * Request current voice registration state
275 *
Sanket Padawe76372492016-10-27 13:20:49 -0700276 * @param serial Serial number of request.
277 *
278 * Response function is IRadioResponse.getVoiceRegistrationStateResponse()
279 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700280 oneway getVoiceRegistrationState(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700281
282 /*
283 * Request current data registration state
284 *
Sanket Padawe76372492016-10-27 13:20:49 -0700285 * @param serial Serial number of request.
286 *
287 * Response function is IRadioResponse.getDataRegistrationStateResponse()
288 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700289 oneway getDataRegistrationState(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700290
291 /*
292 * Request current operator ONS or EONS
293 *
Sanket Padawe76372492016-10-27 13:20:49 -0700294 * @param serial Serial number of request.
295 *
296 * Response function is IRadioResponse.getOperatorResponse()
297 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700298 oneway getOperator(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700299
300 /*
301 * Toggle radio on and off (for "airplane" mode)
302 * If the radio is turned off/on the radio modem subsystem
303 * is expected return to an initialized state. For instance,
304 * any voice and data calls must be terminated and all associated
305 * lists emptied.
306 *
Sanket Padawe76372492016-10-27 13:20:49 -0700307 * @param serial Serial number of request.
308 * @param on To turn on radio -> on = true, to turn off radio -> on = false.
309 *
310 * Response function is IRadioResponse.setRadioPowerResponse()
311 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700312 oneway setRadioPower(int32_t serial, bool on);
Sanket Padawe76372492016-10-27 13:20:49 -0700313
314 /*
315 * Send a DTMF tone
316 *
317 * If the implementation is currently playing a tone requested via
318 * startDtmf(), that tone must be cancelled and the new tone
319 * must be played instead
320 *
Sanket Padawe76372492016-10-27 13:20:49 -0700321 * @param serial Serial number of request.
322 * @param s string with single char having one of 12 values: 0-9, *, #
323 *
324 * Response function is IRadioResponse.sendDtmfResponse()
325 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700326 oneway sendDtmf(int32_t serial, string s);
Sanket Padawe76372492016-10-27 13:20:49 -0700327
328 /*
329 * Send an SMS message
330 *
Sanket Padawe76372492016-10-27 13:20:49 -0700331 * @param serial Serial number of request.
Sanket Padawed52335c2016-11-03 16:46:32 -0700332 * @param message GsmSmsMessage as defined in types.hal
Sanket Padawe76372492016-10-27 13:20:49 -0700333 *
334 * Response function is IRadioResponse.sendSmsResponse()
335 *
336 * Based on the return error, caller decides to resend if sending sms
337 * fails. RadioError:SMS_SEND_FAIL_RETRY means retry (i.e. error cause is 332)
338 * and RadioError:GENERIC_FAILURE means no retry (i.e. error cause is 500)
339 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700340 oneway sendSms(int32_t serial, GsmSmsMessage message);
Sanket Padawe76372492016-10-27 13:20:49 -0700341
342 /*
343 * Send an SMS message. Identical to sendSms,
344 * except that more messages are expected to be sent soon. If possible,
345 * keep SMS relay protocol link open (eg TS 27.005 AT+CMMS command)
346 *
Sanket Padawe76372492016-10-27 13:20:49 -0700347 * @param serial Serial number of request.
Sanket Padawed52335c2016-11-03 16:46:32 -0700348 * @param message GsmSmsMessage as defined in types.hal
Sanket Padawe76372492016-10-27 13:20:49 -0700349 *
350 * Response function is IRadioResponse.sendSMSExpectMoreResponse()
351 *
352 * Based on the return error, caller decides to resend if sending sms
353 * fails. RadioError:SMS_SEND_FAIL_RETRY means retry (i.e. error cause is 332)
354 * and RadioError:GENERIC_FAILURE means no retry (i.e. error cause is 500)
355 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700356 oneway sendSMSExpectMore(int32_t serial, GsmSmsMessage message);
Sanket Padawe76372492016-10-27 13:20:49 -0700357
358 /*
359 * Setup a packet data connection. If DataCallResponse.status
360 * return DataCallFailCause:NONE it is added to the list of data calls and a
361 * unsolDataCallListChanged() is sent. The call remains in the
362 * list until deactivateDataCall() is issued or the
363 * radio is powered off/on. This list is returned by getDataCallList()
364 * and dataCallListChanged().
365 *
Sanket Padawed52335c2016-11-03 16:46:32 -0700366 * The Radio is expected to:
Sanket Padawe76372492016-10-27 13:20:49 -0700367 * - Create one data call context.
368 * - Create and configure a dedicated interface for the context
369 * - The interface must be point to point.
370 * - The interface is configured with one or more addresses and
371 * is capable of sending and receiving packets. The prefix length
372 * of the addresses must be /32 for IPv4 and /128 for IPv6.
373 * - Must NOT change the linux routing table.
374 * - Support up to getDataRegistrationState response[5]
375 * number of simultaneous data call contexts.
376 *
Sanket Padawe76372492016-10-27 13:20:49 -0700377 * @param serial Serial number of request.
378 * @param radioTechnology Radio technology to use: 0-CDMA, 1-GSM/UMTS, 2...
379 * for values above 2 this is RadioTechnology + 2.
380 * @param profile is a RadioDataProfile (support is optional)
381 * @param apn is the APN to connect to if radio technology is GSM/UMTS. This APN must
382 * override the one in the profile. empty string indicates no APN overrride.
383 * @param user is the username for APN, or empty string
384 * @param password is the password for APN, or empty string
385 * @param authType is the PAP / CHAP auth type. Values:
Sanket Padawe76372492016-10-27 13:20:49 -0700386 * @param protocol is the connection type to request must be one of the
387 * PDP_type values in TS 27.007 section 10.1.1.
388 * For example, "IP", "IPV6", "IPV4V6", or "PPP".
389 *
390 * Response function is IRadioResponse.setupDataCallResponse()
391 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700392 oneway setupDataCall(int32_t serial, int32_t radioTechnology,
393 int32_t profile, string apn, string user, string password, ApnAuthType authType,
Sanket Padawe76372492016-10-27 13:20:49 -0700394 string protocol);
395
396 /*
397 * Request ICC I/O operation.
398 * This is similar to the TS 27.007 "restricted SIM" operation
399 * where it assumes all of the EF selection must be done by the
400 * callee
401 *
402 * Arguments and responses that are unused for certain
403 * values of "command" must be ignored or set to empty string
404 *
Sanket Padawe76372492016-10-27 13:20:49 -0700405 * @param serial Serial number of request.
406 * @param iccIo IccIo
407 *
408 * Please note that IccIo has a "PIN2" field which may be empty string,
409 * or may specify a PIN2 for operations that require a PIN2 (eg
410 * updating FDN records)
411 *
412 * Response function is IRadioResponse.iccIOForAppResponse()
413 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700414 oneway iccIOForApp(int32_t serial, IccIo iccIo);
Sanket Padawe76372492016-10-27 13:20:49 -0700415
416 /*
417 * Send a USSD message.
418 *
419 * If a USSD session already exists, the message must be sent in the
420 * context of that session. Otherwise, a new session must be created.
421 *
422 * The network reply must be reported via unsolOnUssd
423 *
424 * Only one USSD session must exist at a time, and the session is assumed
425 * to exist until:
426 * a) The android system invokes cancelUssd()
427 * b) The implementation sends a unsolOnUssd() with a type code
428 * of "0" (USSD-Notify/no further action) or "2" (session terminated)
429 *
Sanket Padawe76372492016-10-27 13:20:49 -0700430 * @param serial Serial number of request.
431 * @param ussd string containing the USSD request in UTF-8 format
432 *
433 * Response function is IRadioResponse.sendUssdResponse()
434 *
435 * See also requestCancelUssd, unsolOnUssd
436 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700437 oneway sendUssd(int32_t serial, string ussd);
Sanket Padawe76372492016-10-27 13:20:49 -0700438
439 /*
440 * Cancel the current USSD session if one exists.
441 *
Sanket Padawe76372492016-10-27 13:20:49 -0700442 * @param serial Serial number of request.
443 *
444 * Response function is IRadioResponse.cancelPendingUssdResponse()
445 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700446 oneway cancelPendingUssd(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700447
448 /*
449 * Gets current CLIR status
450 *
Sanket Padawe76372492016-10-27 13:20:49 -0700451 * @param serial Serial number of request.
452 *
453 * Response function is IRadioResponse.getClirResponse()
454 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700455 oneway getClir(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700456
457 /*
458 * Set current CLIR status
459 *
Sanket Padawe76372492016-10-27 13:20:49 -0700460 * @param serial Serial number of request.
461 * @param status "n" parameter from TS 27.007 7.7
462 *
463 * Response function is IRadioResponse.setClirResponse()
464 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700465 oneway setClir(int32_t serial, int32_t status);
Sanket Padawe76372492016-10-27 13:20:49 -0700466
467 /*
468 * Request call forward status.
469 *
Sanket Padawe76372492016-10-27 13:20:49 -0700470 * @param serial Serial number of request.
471 * @param callInfo CallForwardInfo
472 *
473 * Response function is IRadioResponse.getCallForwardStatusResponse()
474 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700475 oneway getCallForwardStatus(int32_t serial,
Sanket Padawe76372492016-10-27 13:20:49 -0700476 CallForwardInfo callInfo);
477
478 /*
479 * Configure call forward rule
480 *
Sanket Padawe76372492016-10-27 13:20:49 -0700481 * @param serial Serial number of request.
482 * @param callInfo CallForwardInfo
483 *
484 * Response function is IRadioResponse.setCallForwardResponse()
485 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700486 oneway setCallForward(int32_t serial, CallForwardInfo callInfo);
Sanket Padawe76372492016-10-27 13:20:49 -0700487
488 /*
489 * Query current call waiting state
490 *
Sanket Padawe76372492016-10-27 13:20:49 -0700491 * @param serial Serial number of request.
492 * @param serviceClass Service class is the TS 27.007 service class to query
493 *
494 * Response function is IRadioResponse.getCallWaitingResponse()
495 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700496 oneway getCallWaiting(int32_t serial, int32_t serviceClass);
Sanket Padawe76372492016-10-27 13:20:49 -0700497
498 /*
499 * Configure current call waiting state
500 *
Sanket Padawe76372492016-10-27 13:20:49 -0700501 * @param serial Serial number of request.
502 * @param enable is false for "disabled" and true for "enabled"
503 * @param serviceClass is the TS 27.007 service class bit vector of services to modify
504 *
505 * Response function is IRadioResponse.setCallWaitingResponse()
506 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700507 oneway setCallWaiting(int32_t serial, bool enable,
Sanket Padawe76372492016-10-27 13:20:49 -0700508 int32_t serviceClass);
509
510 /*
511 * Acknowledge successful or failed receipt of SMS previously indicated
512 * via unsolResponseNewSms
513 *
Sanket Padawe76372492016-10-27 13:20:49 -0700514 * @param serial Serial number of request.
515 * @param success is true on successful receipt
516 * (basically, AT+CNMA=1 from TS 27.005 is 0 on failed receipt
517 * (basically, AT+CNMA=2 from TS 27.005)
518 * @param cause: if success is false, this contains the failure cause as defined
519 * in TS 23.040, 9.2.3.22.
520 *
521 * Response function is IRadioResponse.acknowledgeLastIncomingGsmSmsResponse()
522 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700523 oneway acknowledgeLastIncomingGsmSms(int32_t serial, bool success,
Sanket Padawe76372492016-10-27 13:20:49 -0700524 SmsAcknowledgeFailCause cause);
525
526 /*
527 * Answer incoming call
528 * Must not be called for WAITING calls.
529 * switchWaitingOrHoldingAndActive() must be used in this case
530 * instead
531 *
Sanket Padawe76372492016-10-27 13:20:49 -0700532 * @param serial Serial number of request.
533 *
534 * Response function is IRadioResponse.acceptCallResponse()
535 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700536 oneway acceptCall(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700537
538 /*
539 * Deactivate packet data connection and remove from the
540 * data call list if RadioError:NONE is returned. Any other return
541 * values must also try to remove the call from the list. An
542 * unsolDataCallListChanged must be
543 * issued because of an deactivateDataCall.
544 *
Sanket Padawe76372492016-10-27 13:20:49 -0700545 * @param serial Serial number of request.
546 * @param cid Indicates CID
547 * @param reasonRadioShutDown Indicates Disconnect Reason
548 * false => No specific reason specified
549 * true => Radio shutdown requested
550 *
551 * Response function is IRadioResponse.deactivateDataCallResponse()
552 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700553 oneway deactivateDataCall(int32_t serial, int32_t cid,
Sanket Padawe76372492016-10-27 13:20:49 -0700554 bool reasonRadioShutDown);
555
556 /*
557 * Query the status of a facility lock state
558 *
Sanket Padawe76372492016-10-27 13:20:49 -0700559 * @param serial Serial number of request.
560 * @param facility is the facility string code from TS 27.007 7.4
561 * (eg "AO" for BAOC, "SC" for SIM lock)
562 * @param password is the password, or "" if not required
563 * @param serviceClass is the TS 27.007 service class bit vector of services to query
564 * @param appId is AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
565 * This is only applicable in the case of Fixed Dialing Numbers (FDN) requests.
566 *
567 * Response function is IRadioResponse.getFacilityLockForAppResponse()
568 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700569 oneway getFacilityLockForApp(int32_t serial, string facility,
Sanket Padawe76372492016-10-27 13:20:49 -0700570 string password, int32_t serviceClass, string appId);
571
572 /*
573 * Enable/disable one facility lock
574 *
Sanket Padawe76372492016-10-27 13:20:49 -0700575 * @param serial Serial number of request.
576 * @param facility is the facility string code from TS 27.007 7.4 (eg "AO" for BAOC)
577 * @param lockState false for "unlock" and true for "lock"
578 * @param password is the password
579 * @param serviceClass is string representation of decimal TS 27.007
580 * service class bit vector. Eg, the string
581 * "1" means "set this facility for voice services"
582 * @param appId is AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value.
583 * This is only applicable in the case of Fixed Dialing Numbers (FDN) requests.
584 *
585 * Response function is IRadioResponse.setFacilityLockForAppResponse()
586 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700587 oneway setFacilityLockForApp(int32_t serial, string facility, bool lockState,
Sanket Padawe76372492016-10-27 13:20:49 -0700588 string password, int32_t serviceClass, string appId);
589
590 /*
591 * Change call barring facility password
592 *
Sanket Padawe76372492016-10-27 13:20:49 -0700593 * @param serial Serial number of request.
594 * @param facility facility string code from TS 27.007 7.4 (eg "AO" for BAOC)
595 * @param oldPassword old password
596 * @param newPassword new password
597 *
598 * Response function is IRadioResponse.setBarringPasswordResponse()
599 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700600 oneway setBarringPassword(int32_t serial, string facility,
Sanket Padawe76372492016-10-27 13:20:49 -0700601 string oldPassword, string newPassword);
602
603 /*
604 * Query current network selection mode
605 *
Sanket Padawe76372492016-10-27 13:20:49 -0700606 * @param serial Serial number of request.
607 *
608 * Response function is IRadioResponse.getNetworkSelectionModeResponse()
609 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700610 oneway getNetworkSelectionMode(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700611
612 /*
613 * Specify that the network must be selected automatically.
614 * This request must not respond until the new operator is selected and registered.
615 *
Sanket Padawe76372492016-10-27 13:20:49 -0700616 * @param serial Serial number of request.
617 *
618 * Response function is IRadioResponse.setNetworkSelectionModeAutomaticResponse()
619 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700620 oneway setNetworkSelectionModeAutomatic(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700621
622 /*
623 * Manually select a specified network.
624 * This request must not respond until the new operator is selected and registered.
625 *
Sanket Padawe76372492016-10-27 13:20:49 -0700626 * @param serial Serial number of request.
627 * @param operatorNumeric string specifying MCCMNC of network to select (eg "310170")
628 *
629 * Response function is IRadioResponse.setNetworkSelectionModeManualResponse()
630 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700631 oneway setNetworkSelectionModeManual(int32_t serial, string operatorNumeric);
Sanket Padawe76372492016-10-27 13:20:49 -0700632
633 /*
634 * Scans for available networks
635 * This request must not respond until the new operator is selected and registered.
636 *
Sanket Padawe76372492016-10-27 13:20:49 -0700637 * @param serial Serial number of request.
638 *
639 * Response function is IRadioResponse.getAvailableNetworksResponse()
640 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700641 oneway getAvailableNetworks(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700642
643 /*
644 * Start playing a DTMF tone. Continue playing DTMF tone until
645 * stopDtmf is received.
646 * If a startDtmf() is received while a tone is currently playing,
647 * it must cancel the previous tone and play the new one.
648 *
Sanket Padawe76372492016-10-27 13:20:49 -0700649 * @param serial Serial number of request.
650 * @param s string having a single character with one of 12 values: 0-9,*,#
651 *
652 * Response function is IRadioResponse.startDtmfResponse()
653 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700654 oneway startDtmf(int32_t serial, string s);
Sanket Padawe76372492016-10-27 13:20:49 -0700655
656 /*
657 * Stop playing a currently playing DTMF tone.
658 *
Sanket Padawe76372492016-10-27 13:20:49 -0700659 * @param serial Serial number of request.
660 *
661 * Response function is IRadioResponse.stopDtmfResponse()
662 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700663 oneway stopDtmf(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700664
665 /*
666 * Return string value indicating baseband version, eg response from AT+CGMR
667 *
Sanket Padawe76372492016-10-27 13:20:49 -0700668 * @param serial Serial number of request.
669 *
670 * Response function is IRadioResponse.getBasebandVersionResponse()
671 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700672 oneway getBasebandVersion(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700673
674 /*
675 * Separate a party from a multiparty call placing the multiparty call
676 * (less the specified party) on hold and leaving the specified party
677 * as the only other member of the current (active) call
678 *
679 * Like AT+CHLD=2x
680 *
681 * See TS 22.084 1.3.8.2 (iii)
682 * TS 22.030 6.5.5 "Entering "2X followed by send"
683 * TS 27.007 "AT+CHLD=2x"
684 *
Sanket Padawe76372492016-10-27 13:20:49 -0700685 * @param serial Serial number of request.
686 * @param gsmIndex contains Connection index (value of 'x' in CHLD above)
687 *
688 * Response function is IRadioResponse.separateConnectionResponse()
689 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700690 oneway separateConnection(int32_t serial, int32_t gsmIndex);
Sanket Padawe76372492016-10-27 13:20:49 -0700691
692 /*
693 * Turn on or off uplink (microphone) mute.
694 * Must only be sent while voice call is active.
695 * Must always be reset to "disable mute" when a new voice call is initiated
696 *
Sanket Padawe76372492016-10-27 13:20:49 -0700697 * @param serial Serial number of request.
698 * @param enable true for "enable mute" and false for "disable mute"
699 *
700 * Response function is IRadioResponse.setMuteResponse()
701 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700702 oneway setMute(int32_t serial, bool enable);
Sanket Padawe76372492016-10-27 13:20:49 -0700703
704 /*
705 * Queries the current state of the uplink mute setting
706 *
Sanket Padawe76372492016-10-27 13:20:49 -0700707 * @param serial Serial number of request.
708 *
709 * Response function is IRadioResponse.getMuteResponse()
710 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700711 oneway getMute(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700712
713 /*
714 * Queries the status of the CLIP supplementary service
715 * (for MMI code "*#30#")
716 *
Sanket Padawe76372492016-10-27 13:20:49 -0700717 * @param serial Serial number of request.
718 *
719 * Response function is IRadioResponse.getClipResponse()
720 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700721 oneway getClip(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700722
723 /*
724 * Returns the data call list. An entry is added when a
725 * setupDataCall() is issued and removed on a
726 * deactivateDataCall(). The list is emptied when
727 * setRadioPower() off/on is issued.
728 *
Sanket Padawe76372492016-10-27 13:20:49 -0700729 * @param serial Serial number of request.
730 *
731 * Response function is IRadioResponse.getDataCallListResponse()
732 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700733 oneway getDataCallList(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700734
735 /*
736 * This request is reserved for OEM-specific uses. It passes raw byte arrays back and forth.
737 *
Sanket Padawe76372492016-10-27 13:20:49 -0700738 * @param serial Serial number of request.
739 * @param data data passed as raw bytes to oem
740 *
Sanket Padawed52335c2016-11-03 16:46:32 -0700741 * Response function is IRadioResponse.sendOemRadioRequestRawResponse()
Sanket Padawe76372492016-10-27 13:20:49 -0700742 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700743 oneway sendOemRadioRequestRaw(int32_t serial, vec<uint8_t> data);
Sanket Padawe76372492016-10-27 13:20:49 -0700744
745 /*
746 * This request is reserved for OEM-specific uses. It passes strings back and forth.
747 *
Sanket Padawe76372492016-10-27 13:20:49 -0700748 * @param serial Serial number of request.
749 * @param data data passed as strings to oem
750 *
Sanket Padawed52335c2016-11-03 16:46:32 -0700751 * Response function is IRadioResponse.sendOemRadioRequestStringsResponse()
Sanket Padawe76372492016-10-27 13:20:49 -0700752 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700753 oneway sendOemRadioRequestStrings(int32_t serial, vec<string> data);
Sanket Padawe76372492016-10-27 13:20:49 -0700754
755 /*
756 * Indicates the current state of the screen. When the screen is off, the
757 * Radio must notify the baseband to suppress certain notifications (eg,
758 * signal strength and changes in LAC/CID or BID/SID/NID/latitude/longitude)
759 * in an effort to conserve power. These notifications must resume when the
760 * screen is on.
761 *
Sanket Padawe76372492016-10-27 13:20:49 -0700762 * @param serial Serial number of request.
763 * @param enable true = screen on, false = screen off.
764 *
765 * Response function is IRadioResponse.sendScreenStateResponse()
766 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700767 oneway sendScreenState(int32_t serial, bool enable);
Sanket Padawe76372492016-10-27 13:20:49 -0700768
769 /*
770 * Enables/disables supplementary service related notifications from the network.
771 * Notifications are reported via unsolSuppSvcNotification().
772 *
Sanket Padawe76372492016-10-27 13:20:49 -0700773 * @param serial Serial number of request.
774 * @param enable true = notifications enabled, false = notifications disabled.
775 *
776 * Response function is IRadioResponse.setSuppServiceNotificationsResponse()
777 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700778 oneway setSuppServiceNotifications(int32_t serial, bool enable);
Sanket Padawe76372492016-10-27 13:20:49 -0700779
780 /*
781 * Stores a SMS message to SIM memory.
782 *
Sanket Padawe76372492016-10-27 13:20:49 -0700783 * @param serial Serial number of request.
784 * @param smsWriteArgs SmsWriteArgs defined in types.hal
785 *
786 * Response function is IRadioResponse.writeSmsToSimResponse()
787 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700788 oneway writeSmsToSim(int32_t serial, SmsWriteArgs smsWriteArgs);
Sanket Padawe76372492016-10-27 13:20:49 -0700789
790 /*
791 * Deletes a SMS message from SIM memory.
792 *
Sanket Padawe76372492016-10-27 13:20:49 -0700793 * @param serial Serial number of request.
794 * @param index Record index of the message to delete.
795 *
796 * Response function is IRadioResponse.deleteSmsOnSimResponse()
797 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700798 oneway deleteSmsOnSim(int32_t serial, int32_t index);
Sanket Padawe76372492016-10-27 13:20:49 -0700799
800 /*
801 * Assign a specified band for RF configuration.
802 *
Sanket Padawe76372492016-10-27 13:20:49 -0700803 * @param serial Serial number of request.
804 * @param mode RadioBandMode defined in types.hal
805 *
806 * Response function is IRadioResponse.setBandModeResponse()
807 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700808 oneway setBandMode(int32_t serial, RadioBandMode mode);
Sanket Padawe76372492016-10-27 13:20:49 -0700809
810 /*
811 * Get the list of band modes supported by RF.
812 *
Sanket Padawe76372492016-10-27 13:20:49 -0700813 * @param serial Serial number of request.
814 *
815 * Response function is IRadioResponse.getAvailableBandModesResponse()
816 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700817 oneway getAvailableBandModes(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -0700818
819 /*
820 * Requests to send a SAT/USAT envelope command to SIM.
821 * The SAT/USAT envelope command refers to 3GPP TS 11.14 and 3GPP TS 31.111
822 *
Sanket Padawe76372492016-10-27 13:20:49 -0700823 * @param serial Serial number of request.
824 * @param command SAT/USAT command in hexadecimal format string starting with command tag
825 *
826 * Response function is IRadioResponse.sendEnvelopeResponse()
827 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700828 oneway sendEnvelope(int32_t serial, string command);
Sanket Padawe76372492016-10-27 13:20:49 -0700829
830 /*
831 * Requests to send a terminal response to SIM for a received proactive command
832 *
Sanket Padawe76372492016-10-27 13:20:49 -0700833 * @param serial Serial number of request.
834 * @param commandResponse SAT/USAT response in hexadecimal format string starting with
835 * first byte of response data
836 *
837 * Response function is IRadioResponse.sendTerminalResponseResponseToSim()
838 */
Sanket Padawed52335c2016-11-03 16:46:32 -0700839 oneway sendTerminalResponseToSim(int32_t serial, string commandResponse);
840
841 /*
842 * When STK application gets stkCallSetup(), the call actually has
843 * been initialized by mobile device already. (We could see the call has been in the 'call
844 * list') So, STK application needs to accept/reject the call according to user
845 * operations.
846 *
847 * @param serial Serial number of request.
848 * @param accept true = accept the call setup, false = reject the call setup
849 *
850 * Response callback is IRadioCallback.handleStkCallSetupRequestFromSimResponse()
851 */
852 oneway handleStkCallSetupRequestFromSim(int32_t serial,
853 bool accept);
854
855 /*
856 * Connects the two calls and disconnects the subscriber from both calls.
857 *
858 * @param serial Serial number of request.
859 *
860 * Response callback is IRadioCallback.explicitCallTransferResponse()
861 */
862 oneway explicitCallTransfer(int32_t serial);
863
864 /*
865 * Requests to set the preferred network type for searching and registering
866 * (CS/PS domain, RAT, and operation mode)
867 *
868 * @param serial Serial number of request.
869 * @param nwType PreferredNetworkType defined in types.hal
870 *
871 * Response callback is IRadioCallback.setPreferredNetworkTypeResponse()
872 */
873 oneway setPreferredNetworkType(int32_t serial,
874 PreferredNetworkType nwType);
875
876 /*
877 * Query the preferred network type (CS/PS domain, RAT, and operation mode)
878 * for searching and registering
879 *
880 * @param serial Serial number of request.
881 *
882 * Response callback is IRadioCallback.getPreferredNetworkTypeResponse()
883 */
884 oneway getPreferredNetworkType(int32_t serial);
885
886 /*
887 * Request neighboring cell id in GSM network
888 *
889 * @param serial Serial number of request.
890 *
891 * Response callback is IRadioCallback.getNeighboringCidsResponse()
892 */
893 oneway getNeighboringCids(int32_t serial);
894
895 /*
896 * Enables/disables network state change notifications due to changes in
897 * LAC and/or CID (for GSM) or BID/SID/NID/latitude/longitude (for CDMA).
898 * Basically +CREG=2 vs. +CREG=1 (TS 27.007).
899 * Note: The Radio implementation must default to "updates enabled"
900 * when the screen is on and "updates disabled" when the screen is off.
901 *
902 * @param serial Serial number of request.
903 * @param enable true = updates enabled (+CREG=2), false = updates disabled (+CREG=1)
904 *
905 * Response callback is IRadioCallback.setLocationUpdatesResponse()
906 */
907 oneway setLocationUpdates(int32_t serial, bool enable);
908
909 /*
910 * Request to set the location where the CDMA subscription shall
911 * be retrieved
912 *
913 * @param serial Serial number of request.
914 * @param cdmaSub CdmaSubscriptionSource
915 *
916 * Response callback is IRadioCallback.setCdmaSubscriptionSourceResponse()
917 */
918 oneway setCdmaSubscriptionSource(int32_t serial,
919 CdmaSubscriptionSource cdmaSub);
920
921 /*
922 * Request to set the roaming preferences in CDMA
923 *
924 * @param serial Serial number of request.
925 * @param type CdmaRoamingType defined in types.hal
926 *
927 * Response callback is IRadioCallback.setCdmaRoamingPreferenceResponse()
928 */
929 oneway setCdmaRoamingPreference(int32_t serial,
930 CdmaRoamingType type);
931
932 /*
933 * Request the actual setting of the roaming preferences in CDMA in the modem
934 *
935 * @param serial Serial number of request.
936 *
937 * Response callback is IRadioCallback.getCdmaRoamingPreferenceResponse()
938 */
939 oneway getCdmaRoamingPreference(int32_t serial);
940
941 /*
942 * Request to set the TTY mode
943 *
944 * @param serial Serial number of request.
945 * @param mode TtyMode
946 *
947 * Response callback is IRadioCallback.setTTYModeResponse()
948 */
949 oneway setTTYMode(int32_t serial, TtyMode mode);
950
951 /*
952 * Request the setting of TTY mode
953 *
954 * @param serial Serial number of request.
955 *
956 * Response callback is IRadioCallback.getTTYModeResponse()
957 */
958 oneway getTTYMode(int32_t serial);
959
960 /*
961 * Request to set the preferred voice privacy mode used in voice scrambling.
962 *
963 * @param serial Serial number of request.
964 * @param enable false for Standard Privacy Mode (Public Long Code Mask)
965 * true for Enhanced Privacy Mode (Private Long Code Mask)
966 *
967 * Response callback is IRadioCallback.setPreferredVoicePrivacyResponse()
968 */
969 oneway setPreferredVoicePrivacy(int32_t serial, bool enable);
970
971 /*
972 * Request the setting of preferred voice privacy mode.
973 *
974 * @param serial Serial number of request.
975 *
976 * Response callback is IRadioCallback.getPreferredVoicePrivacyResponse()
977 */
978 oneway getPreferredVoicePrivacy(int32_t serial);
979
980 /*
981 * Send FLASH command
982 *
983 * @param serial Serial number of request.
984 * @param featureCode String associated with Flash command
985 *
986 * Response callback is IRadioCallback.sendCDMAFeatureCodeResponse()
987 */
988 oneway sendCDMAFeatureCode(int32_t serial, string featureCode);
989
990 /*
991 * Send DTMF string
992 *
993 * @param serial Serial number of request.
994 * @param dtmf DTMF string
995 * @param on DTMF ON length in milliseconds, or 0 to use default
996 * @param off is the DTMF OFF length in milliseconds, or 0 to use default
997 *
998 * Response callback is IRadioCallback.sendBurstDtmfResponse()
999 */
1000 oneway sendBurstDtmf(int32_t serial, string dtmf, int32_t on, int32_t off);
1001
1002 /*
1003 * Send a CDMA SMS message
1004 *
1005 * @param serial Serial number of request.
1006 * @param sms Cdma Sms to be sent described by CdmaSmsMessage in types.hal
1007 *
1008 * Response callback is IRadioCallback.sendCdmaSmsResponse()
1009 */
1010 oneway sendCdmaSms(int32_t serial, CdmaSmsMessage sms);
1011
1012 /*
1013 * Acknowledge the success or failure in the receipt of SMS
1014 * previously indicated via responseCdmaNewSms()
1015 *
1016 * @param serial Serial number of request.
1017 * @param smsAck Cdma Sms ack to be sent described by CdmaSmsAck in types.hal
1018 *
1019 * Response callback is IRadioCallback.acknowledgeLastIncomingCdmaSmsResponse()
1020 */
1021 oneway acknowledgeLastIncomingCdmaSms(int32_t serial, CdmaSmsAck smsAck);
1022
1023 /*
1024 * Request the setting of GSM/WCDMA Cell Broadcast SMS config.
1025 *
1026 * @param serial Serial number of request.
1027 *
1028 * Response callback is IRadioCallback.getGsmBroadcastConfigResponse()
1029 */
1030 oneway getGsmBroadcastConfig(int32_t serial);
1031
1032 /*
1033 * Set GSM/WCDMA Cell Broadcast SMS config
1034 *
1035 * @param serial Serial number of request.
1036 * @param configInfo Setting of GSM/WCDMA Cell broadcast config
1037 *
1038 * Response callback is IRadioCallback.setGsmBroadcastConfigResponse()
1039 */
1040 oneway setGsmBroadcastConfig(int32_t serial, GsmBroadcastSmsConfigInfo configInfo);
1041
1042 /*
1043 * Enable or disable the reception of GSM/WCDMA Cell Broadcast SMS
1044 *
1045 * @param serial Serial number of request.
1046 * @param activate indicates to activate or turn off the reception of GSM/WCDMA
1047 * Cell Broadcast SMS. true = activate, false = turn off
1048 *
1049 * Response callback is IRadioCallback.setGsmBroadcastActivationResponse()
1050 */
1051 oneway setGsmBroadcastActivation(int32_t serial, bool activate);
1052
1053 /*
1054 * Request the setting of CDMA Broadcast SMS config
1055 *
1056 * @param serial Serial number of request.
1057 *
1058 * Response callback is IRadioCallback.getCdmaBroadcastConfigResponse()
1059 */
1060 oneway getCdmaBroadcastConfig(int32_t serial);
1061
1062 /*
1063 * Set CDMA Broadcast SMS config
1064 *
1065 * @param serial Serial number of request.
1066 * @param configInfo CDMA Broadcast SMS config to be set.
1067 *
1068 * Response callback is IRadioCallback.setCdmaBroadcastConfigResponse()
1069 */
1070 oneway setCdmaBroadcastConfig(int32_t serial, CdmaBroadcastSmsConfigInfo configInfo);
1071
1072 /*
1073 * Enable or disable the reception of CDMA Cell Broadcast SMS
1074 *
1075 * @param serial Serial number of request.
1076 * @param activate indicates to activate or turn off the reception of CDMA
1077 * Cell Broadcast SMS. true = activate, false = turn off
1078 *
1079 * Response callback is IRadioCallback.setCdmaBroadcastActivationResponse()
1080 */
1081 oneway setCdmaBroadcastActivation(int32_t serial, bool activate);
1082
1083 /*
1084 * Request the device MDN / H_SID / H_NID.
1085 * The request is only allowed when CDMA subscription is available. When CDMA
1086 * subscription is changed, application layer must re-issue the request to
1087 * update the subscription information.
1088 *
1089 * @param serial Serial number of request.
1090 *
1091 * Response callback is IRadioCallback.getCDMASubscriptionResponse()
1092 */
1093 oneway getCDMASubscription(int32_t serial);
1094
1095 /*
1096 * Stores a CDMA SMS message to RUIM memory.
1097 *
1098 * @param serial Serial number of request.
1099 * @param cdmaSms CDMA message as defined by CdmaSmsWriteArgs in types.hal
1100 *
1101 * Response callback is IRadioCallback.writeSmsToRuimResponse()
1102 */
1103 oneway writeSmsToRuim(int32_t serial, CdmaSmsWriteArgs cdmaSms);
1104
1105 /*
1106 * Deletes a CDMA SMS message from RUIM memory.
1107 *
1108 * @param serial Serial number of request.
1109 * @param index record index of the message to delete
1110 *
1111 * Response callback is IRadioCallback.deleteSmsOnRuimResponse()
1112 */
1113 oneway deleteSmsOnRuim(int32_t serial, int32_t index);
1114
1115 /*
1116 * Request the device ESN / MEID / IMEI / IMEISV.
1117 * The request is always allowed and contains GSM and CDMA device identity.
1118 * When CDMA subscription is changed the ESN/MEID changes. The application
1119 * layer must re-issue the request to update the device identity in this case.
1120 *
1121 * @param serial Serial number of request.
1122 *
1123 * Response callback is IRadioCallback.getDeviceIdentityResponse()
1124 */
1125 oneway getDeviceIdentity(int32_t serial);
1126
1127 /*
1128 * Request the radio's system selection module to exit emergency
1129 * callback mode. Radio must not respond with SUCCESS until the modem has
1130 * completely exited from Emergency Callback Mode.
1131 *
1132 * @param serial Serial number of request.
1133 *
1134 * Response callback is IRadioCallback.exitEmergencyCallbackModeResponse()
1135 */
1136 oneway exitEmergencyCallbackMode(int32_t serial);
1137
1138 /*
1139 * Get the default Short Message Service Center address on the device.
1140 *
1141 * @param serial Serial number of request.
1142 *
1143 * Response callback is IRadioCallback.getSmscAddressResponse()
1144 */
1145 oneway getSmscAddress(int32_t serial);
1146
1147 /*
1148 * Set the default Short Message Service Center address on the device.
1149 *
1150 * @param serial Serial number of request.
1151 * @param smsc Short Message Service Center address to set
1152 *
1153 * Response callback is IRadioCallback.setSmscAddressResponse()
1154 */
1155 oneway setSmscAddress(int32_t serial, string smsc);
1156
1157 /*
1158 * Indicates whether there is storage available for new SMS messages.
1159 *
1160 * @param serial Serial number of request.
1161 * @param available true if memory is available for storing new messages,
1162 * false if memory capacity is exceeded
1163 *
1164 * Response callback is IRadioCallback.reportSmsMemoryStatusResponse()
1165 */
1166 oneway reportSmsMemoryStatus(int32_t serial, bool available);
1167
1168 /*
1169 * Indicates that the StkSerivce is running and is
1170 * ready to receive unsolicited stkXXXXX commands.
1171 *
1172 * @param serial Serial number of request.
1173 *
1174 * Response callback is IRadioCallback.reportStkServiceIsRunningResponse()
1175 */
1176 oneway reportStkServiceIsRunning(int32_t serial);
1177
1178 /*
1179 * Request to query the location where the CDMA subscription shall be retrieved.
1180 *
1181 * @param serial Serial number of request.
1182 *
1183 * Response callback is IRadioCallback.getCdmaSubscriptionSourceResponse()
1184 */
1185 oneway getCdmaSubscriptionSource(int32_t serial);
1186
1187 /*
1188 * Request the ISIM application on the UICC to perform AKA
1189 * challenge/response algorithm for IMS authentication
1190 *
1191 * @param serial Serial number of request.
1192 * @param challenge challenge string in Base64 format
1193 *
1194 * Response callback is IRadioCallback.requestIsimAuthenticationResponse()
1195 */
1196 oneway requestIsimAuthentication(int32_t serial, string challenge);
1197
1198 /*
1199 * Acknowledge successful or failed receipt of SMS previously indicated
1200 * via unsol responseNewSms(), including acknowledgement TPDU to send
1201 * as the RP-User-Data element of the RP-ACK or RP-ERROR PDU.
1202 *
1203 * @param serial Serial number of request.
1204 * @param success true on successful receipt (send RP-ACK)
1205 * false on failed receipt (send RP-ERROR)
1206 * @param ackPdu acknowledgement TPDU in hexadecimal format
1207 *
1208 * Response callback is IRadioCallback.acknowledgeIncomingGsmSmsWithPduResponse()
1209 */
1210 oneway acknowledgeIncomingGsmSmsWithPdu(int32_t serial, bool success, string ackPdu);
1211
1212 /*
1213 * Requests to send a SAT/USAT envelope command to SIM.
1214 * The SAT/USAT envelope command refers to 3GPP TS 11.14 and 3GPP TS 31.111.
1215 *
1216 * This request has one difference from sendEnvelope():
1217 * the SW1 and SW2 status bytes from the UICC response are returned along with
1218 * the response data, using the same structure as iccIOForApp().
1219 *
1220 * The implementation must perform normal processing of a '91XX'
1221 * response in SW1/SW2 to retrieve the pending proactive command and send it
1222 * as an unsolicited response, as sendEnvelope() does.
1223 *
1224 * @param serial Serial number of request.
1225 * @param contents SAT/USAT command in hexadecimal format starting with command tag
1226 *
1227 * Response callback is IRadioCallback.sendEnvelopeWithStatusResponse()
1228 */
1229 oneway sendEnvelopeWithStatus(int32_t serial, string contents);
1230
1231 /*
1232 * Query the radio technology type (3GPP/3GPP2) used for voice. Query is valid only
1233 * when radio state is not RADIO_STATE_UNAVAILABLE
1234 *
1235 * @param serial Serial number of request.
1236 *
1237 * Response callback is IRadioCallback.getVoiceRadioTechnologyResponse()
1238 */
1239 oneway getVoiceRadioTechnology(int32_t serial);
1240
1241 /*
1242 * Request all of the current cell information known to the radio. The radio
1243 * must return list of all current cells, including the neighboring cells. If for a particular
1244 * cell information isn't known then the appropriate unknown value will be returned.
1245 * This does not cause or change the rate of unsolicited cellInfoList().
1246 *
1247 * @param serial Serial number of request.
1248 *
1249 * Response callback is IRadioCallback.getCellInfoListResponse()
1250 */
1251 oneway getCellInfoList(int32_t serial);
1252
1253 /*
1254 * Sets the minimum time between when unsolicited cellInfoList() must be invoked.
1255 * A value of 0, means invoke cellInfoList() when any of the reported
1256 * information changes. Setting the value to INT_MAX(0x7fffffff) means never issue
1257 * a unsolicited cellInfoList().
1258 *
1259 * @param serial Serial number of request.
1260 * @param rate minimum time in milliseconds to indicate time between unsolicited cellInfoList()
1261 *
1262 * Response callback is IRadioCallback.setCellInfoListRateResponse()
1263 */
1264 oneway setCellInfoListRate(int32_t serial, int32_t rate);
1265
1266 /*
1267 * Set an apn to initial attach network
1268 *
1269 * @param serial Serial number of request.
1270 * @param apn is the APN to connect to if radio technology is GSM/UMTS. This APN must
1271 * override the one in the profile. empty string indicates no APN overrride.
1272 * @param protocol is the connection type to request must be one of the
1273 * PDP_type values in TS 27.007 section 10.1.1.
1274 * For example, "IP", "IPV6", "IPV4V6", or "PPP".
1275 * @param authType is the PAP / CHAP auth type. Values:
1276 * @param user is the username for APN, or empty string
1277 * @param password is the password for APN, or empty string
1278 *
1279 * Response callback is IRadioCallback.setInitialAttachApnResponse()
1280 */
1281 oneway setInitialAttachApn(int32_t serial, string apn, string protocol, ApnAuthType authType,
1282 string username, string password);
1283
1284 /*
1285 * Request current IMS registration state
1286 *
1287 * @param serial Serial number of request.
1288 *
1289 * Response callback is IRadioCallback.getImsRegistrationStateResponse()
1290 */
1291 oneway getImsRegistrationState(int32_t serial);
1292
1293 /*
1294 * Send a SMS message over IMS.
1295 * Based on the return error, caller decides to resend if sending sms
1296 * fails. SMS_SEND_FAIL_RETRY means retry, and other errors means no retry.
1297 * In case of retry, data is encoded based on Voice Technology available.
1298 *
1299 * @param serial Serial number of request.
1300 * @param message ImsSmsMessage as defined in types.hal to be sent
1301 *
1302 * Response callback is IRadioCallback.sendImsSmsResponse()
1303 */
1304 oneway sendImsSms(int32_t serial, ImsSmsMessage message);
1305
1306 /*
1307 * Request APDU exchange on the basic channel. This command reflects TS 27.007
1308 * "generic SIM access" operation (+CSIM). The modem must ensure proper function
1309 * of GSM/CDMA, and filter commands appropriately. It must filter
1310 * channel management and SELECT by DF name commands.
1311 * "sessionid" field must be ignored.
1312 *
1313 * @param serial Serial number of request.
1314 * @param message SimApdu as defined in types.hal to be sent
1315 *
1316 * Response callback is IRadioCallback.iccTransmitApduBasicChannelResponse()
1317 */
1318 oneway iccTransmitApduBasicChannel(int32_t serial, SimApdu message);
1319
1320 /*
1321 * Open a new logical channel and select the given application. This command
1322 * reflects TS 27.007 "open logical channel" operation (+CCHO).
1323 *
1324 * @param serial Serial number of request.
1325 * @param aid AID value, See ETSI 102.221 and 101.220.
1326 *
1327 * Response callback is IRadioCallback.iccOpenLogicalChannelResponse()
1328 */
1329 oneway iccOpenLogicalChannel(int32_t serial, string aid);
1330
1331 /*
1332 * Close a previously opened logical channel. This command reflects TS 27.007
1333 * "close logical channel" operation (+CCHC).
1334 *
1335 * @param serial Serial number of request.
1336 * @param channelId session id of the logical channel (+CCHC).
1337 *
1338 * Response callback is IRadioCallback.iccCloseLogicalChannelResponse()
1339 */
1340 oneway iccCloseLogicalChannel(int32_t serial, int32_t channelId);
1341
1342 /*
1343 * Exchange APDUs with a UICC over a previously opened logical channel. This
1344 * command reflects TS 27.007 "generic logical channel access" operation
1345 * (+CGLA). The modem must filter channel management and SELECT by DF name
1346 * commands.
1347 *
1348 * @param serial Serial number of request.
1349 * @param message SimApdu as defined in types.hal to be sent
1350 *
1351 * Response callback is IRadioCallback.iccTransmitApduLogicalChannelResponse()
1352 */
1353 oneway iccTransmitApduLogicalChannel(int32_t serial, SimApdu message);
1354
1355 /*
1356 * Read one of the radio NV items.
1357 * This is used for device configuration by some CDMA operators.
1358 *
1359 * @param serial Serial number of request.
1360 * @param itemId NvItem is radio NV item as defined in types.hal
1361 *
1362 * Response callback is IRadioCallback.nvReadItemResponse()
1363 */
1364 oneway nvReadItem(int32_t serial, NvItem itemId);
1365
1366 /*
1367 * Write one of the radio NV items.
1368 * This is used for device configuration by some CDMA operators.
1369 *
1370 * @param serial Serial number of request.
1371 * @param item NvWriteItem as defined in types.hal
1372 *
1373 * Response callback is IRadioCallback.nvWriteItemResponse()
1374 */
1375 oneway nvWriteItem(int32_t serial, NvWriteItem item);
1376
1377 /*
1378 * Update the CDMA Preferred Roaming List (PRL) in the radio NV storage.
1379 * This is used for device configuration by some CDMA operators.
1380 *
1381 * @param serial Serial number of request.
1382 * @param prl PRL as a byte array
1383 *
1384 * Response callback is IRadioCallback.nvWriteCdmaPrlResponse()
1385 */
1386 oneway nvWriteCdmaPrl(int32_t serial, vec<uint8_t> prl);
1387
1388 /*
1389 * Reset the radio NV configuration to the factory state.
1390 * This is used for device configuration by some CDMA operators.
1391 *
1392 * @param serial Serial number of request.
1393 * @param resetType ResetNvType as defined in types.hal
1394 *
1395 * Response callback is IRadioCallback.nvResetConfigResponse()
1396 */
1397 oneway nvResetConfig(int32_t serial, ResetNvType resetType);
1398
1399 /*
1400 * Selection/de-selection of a subscription from a SIM card
1401 *
1402 * @param serial Serial number of request.
1403 * @param uiccSub SelectUiccSub as defined in types.hal
1404 *
1405 * Response callback is IRadioCallback.setUiccSubscriptionResponse()
1406 */
1407 oneway setUiccSubscription(int32_t serial, SelectUiccSub uiccSub);
1408
1409 /*
1410 * Tells the modem whether data calls are allowed or not
1411 *
1412 * @param serial Serial number of request.
1413 * @param allow true to allow data calls, false to disallow data calls
1414 *
1415 * Response callback is IRadioCallback.setDataAllowedResponse()
1416 */
1417 oneway setDataAllowed(int32_t serial, bool allow);
1418
1419 /*
1420 * Request all of the current hardware (modem and sim) associated with Radio.
1421 *
1422 * @param serial Serial number of request.
1423 *
1424 * Response callback is IRadioCallback.getHardwareConfigResponse()
1425 */
1426 oneway getHardwareConfig(int32_t serial);
1427
1428 /*
1429 * Returns the response of SIM Authentication through Radio challenge request.
1430 *
1431 * @param serial Serial number of request.
1432 * @param authContext P2 value of authentication command, see P2 parameter in
1433 * 3GPP TS 31.102 7.1.2
1434 * @param authData the challenge string in Base64 format, see 3GPP TS 31.102 7.1.2
1435 * @param aid AID value, See ETSI 102.221 8.1 and 101.220 4, empty string if no value
1436 *
1437 * Response callback is IRadioCallback.requestIccSimAuthenticationResponse()
1438 */
1439 oneway requestIccSimAuthentication(int32_t serial, int32_t authContext, string authData,
1440 string aid);
1441
1442 /*
1443 * Set data profile in modem.
1444 * Modem must erase existed profiles from framework, and apply new profiles
1445 *
1446 * @param serial Serial number of request.
1447 * @param profiles Array of DataProfiles to set.
1448 *
1449 * Response callback is IRadioCallback.setDataProfileResponse()
1450 */
1451 oneway setDataProfile(int32_t serial, vec<DataProfileInfo> profiles);
1452
1453 /*
1454 * Device is shutting down. All further commands are ignored
1455 * and RADIO_NOT_AVAILABLE must be returned.
1456 *
1457 * @param serial Serial number of request.
1458 *
1459 * Response callback is IRadioCallback.requestShutdownResponse()
1460 */
1461 oneway requestShutdown(int32_t serial);
1462
1463 /*
1464 * Used to get phone radio capablility.
1465 *
1466 * @param serial Serial number of request.
1467 *
1468 * Response callback is IRadioCallback.getRadioCapabilityResponse()
1469 */
1470 oneway getRadioCapability(int32_t serial);
1471
1472 /*
1473 * Used to set the phones radio capability. Be VERY careful
1474 * using this request as it may cause some vendor modems to reset. Because
1475 * of the possible modem reset any radio commands after this one may not be
1476 * processed.
1477 *
1478 * @param serial Serial number of request.
1479 * @param rc RadioCapability structure to be set
1480 *
1481 * Response callback is IRadioCallback.setRadioCapabilityResponse()
1482 */
1483 oneway setRadioCapability(int32_t serial, RadioCapability rc);
1484
1485 /*
1486 * Start Link Capacity Estimate (LCE) service if supported by the radio.
1487 *
1488 * @param serial Serial number of request.
1489 * @param reportInterval desired reporting interval (ms).
1490 * @param pullMode LCE service mode. true: PULL; false: PUSH.
1491 *
1492 * Response callback is IRadioCallback.startLceServiceResponse()
1493 */
1494 oneway startLceService(int32_t serial, int32_t reportInterval, bool pullMode);
1495
1496 /*
1497 * Stop Link Capacity Estimate (LCE) service, the STOP operation must be
1498 * idempotent for the radio modem.
1499 *
1500 * @param serial Serial number of request.
1501 *
1502 * Response callback is IRadioCallback.stopLceServiceResponse()
1503 */
1504 oneway stopLceService(int32_t serial);
1505
1506 /*
1507 * Pull LCE service for capacity information.
1508 *
1509 * @param serial Serial number of request.
1510 *
1511 * Response callback is IRadioCallback.pullLceDataResponse()
1512 */
1513 oneway pullLceData(int32_t serial);
1514
1515 /*
1516 * Get modem activity information for power consumption estimation.
1517 * Request clear-on-read statistics information that is used for
1518 * estimating the per-millisecond power consumption of the cellular
1519 * modem.
1520 *
1521 * @param serial Serial number of request.
1522 *
1523 * Response callback is IRadioCallback.getModemActivityInfoResponse()
1524 */
1525 oneway getModemActivityInfo(int32_t serial);
1526
1527 /*
1528 * Set carrier restrictions. Expected modem behavior:
1529 * If never receives this command
1530 * - Must allow all carriers
1531 * Receives this command with allAllowed true
1532 * - Must allow all carriers. If a previously allowed SIM is present, modem must not reload
1533 * the SIM. If a previously disallowed SIM is present, reload the SIM and notify Android.
1534 * Receives this command with a list of carriers & allAllowed = false
1535 * - Only allow specified carriers, persist across power cycles and FDR. If a present SIM
1536 * is in the allowed list, modem must not reload the SIM. If a present SIM is *not* in
1537 * the allowed list, modem must detach from the registered network and only keep emergency
1538 * service, and notify Android SIM refresh reset with new SIM state being
1539 * CardState:RESTRICTED. Emergency service must be enabled.
1540 *
1541 * @param serial Serial number of request.
1542 * @param allAllowed true only when all carriers are allowed. Ignore "carriers" struct.
1543 * If false, consider "carriers" struct
1544 * @param carriers CarrierRestrictions consisting allowed and excluded carriers as defined
1545 * in types.hal
1546 *
1547 * Response callback is IRadioCallback.setAllowedCarriersResponse()
1548 */
1549 oneway setAllowedCarriers(int32_t serial, bool allAllowed, CarrierRestrictions carriers);
1550
1551 /*
1552 * Get carrier restrictions.
1553 *
1554 * @param serial Serial number of request.
1555 *
1556 * Response callback is IRadioCallback.getAllowedCarriersResponse()
1557 */
1558 oneway getAllowedCarriers(int32_t serial);
Sanket Padawe76372492016-10-27 13:20:49 -07001559};