rilReqConversionMap[RIL_REQUEST_OPERATOR] = ReqWithNoData; // 22
rilReqConversionMap[RIL_REQUEST_GET_IMEI] = ReqWithNoData; // 38
rilReqConversionMap[RIL_REQUEST_GET_IMEISV] = ReqWithNoData; // 39
+ rilReqConversionMap[RIL_REQUEST_ANSWER] = ReqWithNoData; // 40
rilReqConversionMap[RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE] = ReqWithNoData; // 45
rilReqConversionMap[RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC] = ReqWithNoData; // 46
rilReqConversionMap[RIL_REQUEST_BASEBAND_VERSION] = ReqWithNoData; // 51
rilRspConversionMap[RIL_REQUEST_OPERATOR] = RspOperator; // 22
rilRspConversionMap[RIL_REQUEST_GET_IMEI] = RspString; // 38
rilRspConversionMap[RIL_REQUEST_GET_IMEISV] = RspString; // 39
+ rilRspConversionMap[RIL_REQUEST_ANSWER] = RspWithNoData; // 39
rilRspConversionMap[RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE] = RspIntegers; // 45
rilRspConversionMap[RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC] = RspWithNoData; // 46
rilRspConversionMap[RIL_REQUEST_BASEBAND_VERSION] = RspString; // 51
#include <time.h>
-#define WORKER_DEBUG
+//#define WORKER_DEBUG
#ifdef WORKER_DEBUG
#define DBG(...) LOGD(__VA_ARGS__)
"rlReqRadioState\022$\n\005state\030\001 \002(\0162\025.ril_pro"
"to.RadioState\"9\n\021CtrlRspRadioState\022$\n\005st"
"ate\030\001 \002(\0162\025.ril_proto.RadioState\"(\n\020Ctrl"
- "ReqSetMTCall\022\024\n\014phone_number\030\001 \002(\t*r\n\007Ct"
+ "ReqSetMTCall\022\024\n\014phone_number\030\001 \002(\t*s\n\007Ct"
"rlCmd\022\021\n\rCTRL_CMD_ECHO\020\000\022\034\n\030CTRL_CMD_GET"
"_RADIO_STATE\020\001\022\034\n\030CTRL_CMD_SET_RADIO_STA"
- "TE\020\002\022\030\n\024CTRL_CMD_SET_MT_CALL\020\003*5\n\nCtrlSt"
- "atus\022\022\n\016CTRL_STATUS_OK\020\000\022\023\n\017CTRL_STATUS_"
- "ERR\020\001B7\n(com.android.internal.telephony."
- "ril_protoB\013RilCtrlCmds", 422);
+ "TE\020\002\022\031\n\024CTRL_CMD_SET_MT_CALL\020\351\007*5\n\nCtrlS"
+ "tatus\022\022\n\016CTRL_STATUS_OK\020\000\022\023\n\017CTRL_STATUS"
+ "_ERR\020\001B7\n(com.android.internal.telephony"
+ ".ril_protoB\013RilCtrlCmds", 423);
::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
"ctrl.proto", &protobuf_RegisterTypes);
CtrlReqRadioState::default_instance_ = new CtrlReqRadioState();
case 0:
case 1:
case 2:
- case 3:
+ case 1001:
return true;
default:
return false;
CTRL_CMD_ECHO = 0,
CTRL_CMD_GET_RADIO_STATE = 1,
CTRL_CMD_SET_RADIO_STATE = 2,
- CTRL_CMD_SET_MT_CALL = 3
+ CTRL_CMD_SET_MT_CALL = 1001
};
bool CtrlCmd_IsValid(int value);
const CtrlCmd CtrlCmd_MIN = CTRL_CMD_ECHO;
public static final int CTRL_CMD_ECHO = 0;
public static final int CTRL_CMD_GET_RADIO_STATE = 1;
public static final int CTRL_CMD_SET_RADIO_STATE = 2;
- public static final int CTRL_CMD_SET_MT_CALL = 3;
+ public static final int CTRL_CMD_SET_MT_CALL = 1001;
// enum CtrlStatus
public static final int CTRL_STATUS_OK = 0;
DESCRIPTOR = descriptor.FileDescriptor(
name='ctrl.proto',
package='ril_proto',
- serialized_pb='\n\nctrl.proto\x12\tril_proto\x1a\tril.proto\"9\n\x11\x43trlReqRadioState\x12$\n\x05state\x18\x01 \x02(\x0e\x32\x15.ril_proto.RadioState\"9\n\x11\x43trlRspRadioState\x12$\n\x05state\x18\x01 \x02(\x0e\x32\x15.ril_proto.RadioState\"(\n\x10\x43trlReqSetMTCall\x12\x14\n\x0cphone_number\x18\x01 \x02(\t*r\n\x07\x43trlCmd\x12\x11\n\rCTRL_CMD_ECHO\x10\x00\x12\x1c\n\x18\x43TRL_CMD_GET_RADIO_STATE\x10\x01\x12\x1c\n\x18\x43TRL_CMD_SET_RADIO_STATE\x10\x02\x12\x18\n\x14\x43TRL_CMD_SET_MT_CALL\x10\x03*5\n\nCtrlStatus\x12\x12\n\x0e\x43TRL_STATUS_OK\x10\x00\x12\x13\n\x0f\x43TRL_STATUS_ERR\x10\x01\x42\x37\n(com.android.internal.telephony.ril_protoB\x0bRilCtrlCmds')
+ serialized_pb='\n\nctrl.proto\x12\tril_proto\x1a\tril.proto\"9\n\x11\x43trlReqRadioState\x12$\n\x05state\x18\x01 \x02(\x0e\x32\x15.ril_proto.RadioState\"9\n\x11\x43trlRspRadioState\x12$\n\x05state\x18\x01 \x02(\x0e\x32\x15.ril_proto.RadioState\"(\n\x10\x43trlReqSetMTCall\x12\x14\n\x0cphone_number\x18\x01 \x02(\t*s\n\x07\x43trlCmd\x12\x11\n\rCTRL_CMD_ECHO\x10\x00\x12\x1c\n\x18\x43TRL_CMD_GET_RADIO_STATE\x10\x01\x12\x1c\n\x18\x43TRL_CMD_SET_RADIO_STATE\x10\x02\x12\x19\n\x14\x43TRL_CMD_SET_MT_CALL\x10\xe9\x07*5\n\nCtrlStatus\x12\x12\n\x0e\x43TRL_STATUS_OK\x10\x00\x12\x13\n\x0f\x43TRL_STATUS_ERR\x10\x01\x42\x37\n(com.android.internal.telephony.ril_protoB\x0bRilCtrlCmds')
_CTRLCMD = descriptor.EnumDescriptor(
name='CtrlCmd',
options=None,
type=None),
descriptor.EnumValueDescriptor(
- name='CTRL_CMD_SET_MT_CALL', index=3, number=3,
+ name='CTRL_CMD_SET_MT_CALL', index=3, number=1001,
options=None,
type=None),
],
containing_type=None,
options=None,
serialized_start=196,
- serialized_end=310,
+ serialized_end=311,
)
],
containing_type=None,
options=None,
- serialized_start=312,
- serialized_end=365,
+ serialized_start=313,
+ serialized_end=366,
)
CTRL_CMD_ECHO = 0
CTRL_CMD_GET_RADIO_STATE = 1
CTRL_CMD_SET_RADIO_STATE = 2
-CTRL_CMD_SET_MT_CALL = 3
+CTRL_CMD_SET_MT_CALL = 1001
CTRL_STATUS_OK = 0
CTRL_STATUS_ERR = 1
}
/**
- * Generate an MT call
- */
- this.ctrlSetMTCall = function(req) {
- print('ctrlSetMTCall');
-
- var mtReq = new Object();
-
- mtReq = ctrlSchema['ril_proto.CtrlReqSetMTCall'].parse(req.protobuf);
- setMTCall(mtReq.phoneNumber, mtReq.name);
-
- result.sendResponse = false;
- return result;
- }
-
- /**
* Process the request
*/
this.process = function(req) {
// Assume the result will be true, successful and nothing to return
result.sendResponse = true;
- result.ctrlStatus = 0;
+ result.ctrlStatus = CTRL_STATUS_OK;
result.responseProtobuf = emptyProtobuf;
// Default result will be success with no response protobuf
this.ctrlDispatchTable = new Array();
this.ctrlDispatchTable[CTRL_CMD_GET_RADIO_STATE] = this.ctrlGetRadioState;
this.ctrlDispatchTable[CTRL_CMD_SET_RADIO_STATE] = this.ctrlSetRadioState;
- this.ctrlDispatchTable[CTRL_CMD_SET_MT_CALL] = this.ctrlSetMTCall;
print('CtrlServer() ctor X');
}
try {
print('onCtrlServerCmd E cmd=' + cmd + ' token=' + token);
- var req = new Object();
- req.cmd = cmd;
- req.token = token;
- req.protobuf = protobuf;
-
print('onCtrlServerCmd add the request:');
- ctrlWorker.add(req);
+ if (!isCtrlServerDispatchCommand(cmd)) {
+ var ctrlServerReq = new Object();
+ ctrlServerReq.cmd = cmd;
+ ctrlServerReq.token = token;
+ ctrlServerReq.protobuf = protobuf;
+ print('onCtrlServerCmd: command to control server, add to the worker queue');
+ // If it is a command to the control server, add to the control server worker queue
+ ctrlWorker.add(ctrlServerReq);
+ } else {
+ // For other commands, we need to dispatch to the corresponding components
+ try {
+ print('onCtrlServerCmd: get entry from dispatchTable cmd:' + cmd );
+ entry = ctrlServerDispatchTable[cmd];
+ if (typeof entry == 'undefined') {
+ throw ('entry = dispatchTable[' + cmd + '] was undefined');
+ } else {
+ var req = new Request(cmd, token, protobuf, ctrlSchema, entry.schemaName);
+ for(i = 0; i < entry.components.length; i++) {
+ entry.components[i].add(req);
+ }
+ }
+ } catch (err) {
+ print('onCtrlServerCmd: Unknown cmd=' + cmd + ' err=' + err);
+ sendCtrlRequestComplete(RIL_E_REQUEST_NOT_SUPPORTED, cmd, token);
+ }
+ }
print('onCtrlServerCmd X cmd=' + cmd + ' token=' + token);
} catch (err) {
print('onCtrlServerCmd X Exception err=' + err);
}
}
+function isCtrlServerDispatchCommand(cmd) {
+ return (cmd > CTRL_CMD_DISPATH_BASE)
+}
+
+/**
+ * Dispatch table for request, the control server will send those requests to
+ * the corresponding components.
+ *
+ * Each table entry is index by the CTRL_CMD_xxxx
+ * and contains an array of components this request
+ * is to be sent to and the name of the schema
+ * that converts the incoming protobuf to the
+ * appropriate request data.
+ *
+ * ctrlServerDispatchTable[CTRL_CMD_xxx].components = Array of components
+ * ctrlServerDisptachTable[CTRL_CMD_xxx].Entry.schemaName = 'Name-of-schema';
+ */
+var ctrlServerDispatchTable = new Array();
+
+ctrlServerDispatchTable[CTRL_CMD_SET_MT_CALL] = { // 1001
+ 'components' : [simulatedRadioWorker],
+ 'schemaName' : 'CtrlReqSetMTCall',
+};
+
/**
* Optional tests
*/
dispatchTable[RIL_REQUEST_GET_IMEISV] = { // 39
'components' : [simulatedIccWorker],
};
+dispatchTable[RIL_REQUEST_ANSWER] = { // 40
+ 'components' : [simulatedRadioWorker],
+};
dispatchTable[RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE] = { // 45
'components' : [simulatedRadioWorker],
};
var RIL_UNSOL_RESEND_INCALL_MUTE = 1030
/**
- * Control commands in ctrl.proto
+ * Control commands in ctrl.proto for control server
*/
var CTRL_CMD_GET_RADIO_STATE = 1
var CTRL_CMD_SET_RADIO_STATE = 2
/**
+ * Control commands in ctrl.proto that will be dispatched to
+ * simulatedRadio or simulatedIcc
+ */
+var CTRL_CMD_DISPATH_BASE = 1000
+var CTRL_CMD_SET_MT_CALL = 1001
+
+/* status for control commands, defined in ctrl.proto */
+var CTRL_STATUS_OK = 0
+var CTRL_STATUS_ERR = 1
+
+/**
* Local requests from simulated_radio or simulated_icc
*/
var CMD_DELAY_TEST = 2000
var CMD_UNSOL_SIGNAL_STRENGTH = 2001
var CMD_UNSOL_CALL_STATE_CHANGED = 2002 // Send RIL_UNSOL_CALL_STATE_CHANGED
var CMD_CALL_STATE_CHANGE = 2003 // call state change: dialing->alert->active
+var CMD_UNSOL_CALL_RING = 2004
/**
* Other variables
}
/**
- * Create an incoming call
- */
-function setMTCall(phoneNumber) {
- print('createIncomingCall, number=' + phoneNumber + ' E');
-
- if (simulatedRadio.numberActiveCalls <= 0) {
- // If there is no connection in use, the call state is INCOMING
- state = CALLSTATE_INCOMING;
- } else {
- // If the incoming call is a second call, the state is WAITING
- state = CALLSTATE_WAITING;
- }
-
- // Add call to the call array
- simulatedRadio.addCall(state, phoneNumber, '');
-
- // Send unsolicited response of call state change
- simulatedRadioWorker.add(
- {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED});
-}
-
-/**
* Create a call.
*
* @return a RilCall
var maxNumberActiveCalls = 7;
var maxConnectionsPerCall = 5; // only 5 connections allowed per call
+ // Flag to denote whether an incoming/waiting call is answered
+ var incomingCallIsAnswered = false;
// Array of "active" calls
var calls = Array(maxNumberActiveCalls + 1);
switch (calls[i].state) {
case CALLSTATE_HOLDING:
case CALLSTATE_WAITING:
+ case CALLSTATE_INCOMING:
this.removeCall(i);
+ incomingCallIsAnswered = true;
break;
default:
result.rilErrCode = RIL_E_GENERIC_FAILURE;
}
/**
+ * Handle RIL_REQUEST_ANSWER
+ *
+ * @param req is the Request
+ */
+ this.rilRequestAnswer = function(req) { // 40
+ print('Radio: rilRequestAnswer');
+
+ if (numberActiveCalls != 1) {
+ result.rilErrCode = RIL_E_GENERIC_FAILURE;
+ return result;
+ } else {
+ for (var i = 0; i < calls.length; i++) {
+ if (typeof calls[i] != 'undefined') {
+ if (calls[i].state == CALLSTATE_INCOMING) {
+ calls[i].state = CALLSTATE_ACTIVE;
+ break;
+ } else {
+ result.rilErrCode = RIL_E_GENERIC_FAILURE;
+ this.removeCall(i);
+ return result;
+ }
+ } // end of processing call[i]
+ } // end of for
+ }
+ incomingCallIsAnswered = true;
+ return result;
+ }
+
+ /**
* Handle RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE
*
* @param req is the Request
result.sendResponse = false;
return result;
}
+
+ /**
+ * send UNSOL_CALL_STATE_CHANGED and UNSOL_CALL_RING
+ */
+ this.cmdUnsolCallRing = function(req) { // 2004
+ print('cmdUnsolCallRing: req.reqNum=' + req.reqNum);
+ sendRilUnsolicitedResponse(RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED);
+ sendRilUnsolicitedResponse(RIL_UNSOL_CALL_RING);
+
+ // Send the next alert in 3 seconds. [refer to ril.h definition]
+ simulatedRadioWorker.addDelayed(
+ {'reqNum' : CMD_UNSOL_CALL_RING}, 3000);
+ result.sendResponse = false;
+ return result;
+ }
+
+ /**
+ * Create an incoming call for the giving number
+ * return CTRL_STATUS_ERR if there is already a call in any of the states of
+ * dialing, alerting, incoming, waiting [TS 22 030 6.5] , else
+ * return CTRL_STATUS_OK and update the call state
+ */
+ this.ctrlServerCmdStartInComingCall = function(req) { // 1001
+ print('ctrlServerCmdStartInComingCall: req.reqNum:' + req.reqNum);
+ print('ctrlServerCmdStartInComingCall: req.data.phonenumber:' + req.data.phoneNumber);
+
+ var phoneNumber = req.data.phoneNumber;
+ var state;
+
+ if (numberActiveCalls <= 0) {
+ // If there is no connection in use, the call state is INCOMING
+ state = CALLSTATE_INCOMING;
+ } else {
+ // If there is call in any of the states of dialing, alerting, incoming
+ // waiting, this MT call can not be set
+ for (var i = 0; i < calls.length; i++) {
+ if (typeof calls[i] != 'undefined') {
+ if ( (calls[i].state == CALLSTATE_DIALING) ||
+ (calls[i].state == CALLSTATE_ALERTING) ||
+ (calls[i].state == CALLSTATE_INCOMING) ||
+ (calls[i].state == CALLSTATE_WAITING))
+ {
+ result.rilErrCode = CTRL_STATUS_ERR;
+ return result;
+ }
+ }
+ }
+ // If the incoming call is a second call, the state is WAITING
+ state = CALLSTATE_WAITING;
+ }
+
+ // Add call to the call array
+ this.addCall(state, phoneNumber, '');
+
+ // set the incomingCallIsAnswered flag to be false
+ incomingCallIsAnswered = false;
+
+ simulatedRadioWorker.add(
+ {'reqNum' : CMD_UNSOL_CALL_RING});
+
+ result.rilErrCode = CTRL_STATUS_OK;
+ return result;
+ }
+
/**
* Process the request by dispatching to the request handlers
*/
try {
// Pass "this" object to each ril request call such that
// they have the same scope
- result = (this.radioDispatchTable[req.reqNum]).call(this, req);
+ if ((req.reqNum == CMD_UNSOL_CALL_RING) && incomingCallIsAnswered) {
+ print('no need to send UNSOL_CALL_RING');
+ } else {
+ result = (this.radioDispatchTable[req.reqNum]).call(this, req);
+ }
} catch (err) {
print('Radio:process err = ' + err);
print('Radio: Unknown reqNum=' + req.reqNum);
lastReq = req.reqNum;
}
if (result.sendResponse) {
- sendRilRequestComplete(result.rilErrCode, req.reqNum,
- req.token, result.responseProtobuf);
+ if (isCtrlServerDispatchCommand(req.reqNum)) {
+ print('Command ' + req.reqNum + ' is a control server command');
+ sendCtrlRequestComplete(result.rilErrCode, req.reqNum,
+ req.token, result.responseProtobuf);
+ } else {
+ print('Request ' + req.reqNum + ' is a ril request');
+ sendRilRequestComplete(result.rilErrCode, req.reqNum,
+ req.token, result.responseProtobuf);
+ }
}
-
//print('Radio X: req.reqNum=' + req.reqNum + ' req.token=' + req.token);
} catch (err) {
print('Radio: Exception req.reqNum=' +
this.rilRequestRegistrationState;
this.radioDispatchTable[RIL_REQUEST_GPRS_REGISTRATION_STATE] = // 21
this.rilRequestGprsRegistrationState;
+ this.radioDispatchTable[RIL_REQUEST_ANSWER] = // 40
+ this.rilRequestAnswer;
this.radioDispatchTable[RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE] = // 45
this.rilRequestQueryNeworkSelectionMode;
this.radioDispatchTable[RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC] = // 46
this.radioDispatchTable[RIL_REQUEST_SCREEN_STATE] = // 61
this.rilRequestScreenState;
+ this.radioDispatchTable[CTRL_CMD_SET_MT_CALL] = //1001
+ this.ctrlServerCmdStartInComingCall;
+
this.radioDispatchTable[CMD_DELAY_TEST] = // 2000
this.cmdDelayTest;
this.radioDispatchTable[CMD_UNSOL_SIGNAL_STRENGTH] = // 2001
this.cmdUnsolCallStateChanged;
this.radioDispatchTable[CMD_CALL_STATE_CHANGE] = //2003
this.cmdCallStateChange;
+ this.radioDispatchTable[CMD_UNSOL_CALL_RING] = //2004
+ this.cmdUnsolCallRing;
+
+ this.radioDispatchTable[CTRL_CMD_SET_MT_CALL] = //1001
+ this.ctrlServerCmdStartInComingCall;
print('Radio: constructor X');
}
* limitations under the License.
*/
-
+/**
+ * TODO:update tests in the format of test incoming call
+ * Have a global counter to count passes and failures
+ */
/**
* A test to test set signal strength
*/
}
/**
+ * A test for creating incoming call
+ */
+if (false) {
+ /* Only one incoming call is in the call list */
+ function verifyIncomingCall() {
+ var calls = simulatedRadio.getCalls();
+ var numIncomingCalls = 0;
+ for (var i = 0; i < calls.length; i++) {
+ if (typeof calls[i] != 'undefined') {
+ if (calls[i].state == CALLSTATE_INCOMING) {
+ numIncomingCalls++;
+ }
+ }
+ }
+ return (numIncomingCalls == 1);
+ }
+
+ function testStartIncomingCall() {
+ print('testCreateIncomingCall E:');
+
+ var req = new Object();
+ req.reqNum = CTRL_CMD_SET_MT_CALL;
+ req.data = new Object();
+ req.data.phoneNumber = '6502249208';
+
+ var numberTestPass = 0;
+ var numberTestFail = 0;
+
+ // case 1: incoming call is the only active call
+ var result = new Object();
+ result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
+ if ( (result.rilErrCode == CTRL_STATUS_OK) && verifyIncomingCall()) {
+ numberTestPass++;
+ } else {
+ numberTestFail++;
+ print('testStartIncomingCall: TEST CASE 1 FAIL');
+ }
+
+ // case 2: one incoming call, add another incoming call will fail
+ req.data.phoneNumber = '6502223456';
+ result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
+ if ((result.rilErrCode == CTRL_STATUS_ERR) && verifyIncomingCall()) {
+ numberTestPass++;
+ } else {
+ numberTestFail++;
+ print('testStartIncomingCall: TEST CASE 2 FAIL');
+ }
+
+ // case 3: one dialing call, add another incoming call will fail
+ // Make the first call in dialing state
+ var calls = simulatedRadio.getCalls();
+ for (var i = 0; i < calls.length; i++) {
+ if (typeof calls[i] != 'undefined') {
+ if (calls[i].state == CALLSTATE_INCOMING) {
+ calls[i].state = CALLSTATE_DIALING;
+ break;
+ }
+ }
+ }
+ result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
+ if (result.rilErrCode == CTRL_STATUS_ERR) {
+ numberTestPass++;
+ } else {
+ numberTestFail++;
+ print('testStartIncomingCall: TEST CASE 3 FAIL');
+ }
+
+ // case 4: one dialing call, adding another incoming call will fail
+ calls[i].state = CALLSTATE_ALERTING;
+ result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
+ if (result.rilErrCode == CTRL_STATUS_ERR) {
+ numberTestPass++;
+ } else {
+ numberTestFail++;
+ print('testStartIncomingCall: TEST CASE 4 FAIL');
+ }
+
+ // case 5: one active call, adding another incoming call will succeed
+ calls[i].state = CALLSTATE_ACTIVE;
+ result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
+ if (result.rilErrCode == CTRL_STATUS_OK) {
+ numberTestPass++;
+ } else {
+ numberTestFail++;
+ print('testStartIncomingCall: TEST CASE 5 FAIL');
+ }
+
+ print('*************TEST RESULT ****************');
+ print('Number of Test Passed: ' + numberTestPass);
+ print('Number of Test Failed: ' + numberTestFail);
+ print('************ End **********************');
+ // after the test, remove any calls
+ for (i = 0; i < calls.length; i++) {
+ simulatedRadio.removeCall(i);
+ }
+ print('testStartIncomingCall X:');
+ }
+
+ testStartIncomingCall();
+}
+
+/**
* A test for RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND
*/
if (false) {
CTRL_CMD_ECHO = 0;
CTRL_CMD_GET_RADIO_STATE = 1;
CTRL_CMD_SET_RADIO_STATE = 2;
- CTRL_CMD_SET_MT_CALL = 3;
+ CTRL_CMD_SET_MT_CALL = 1001;
}
enum CtrlStatus {
OSDN Git Service
