| /** |
| * Copyright (C) 2010 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. |
| */ |
| |
| /** |
| * The Radio object contains a set of methods and objects to handle ril request |
| * which is passed from simulatedRadioWorker queue. The global object initialize |
| * an instance of Radio object by calling "new Radio". For each ril request, |
| * rilDispatchTable gets searched and the corresponding method is called. |
| * Extra requests are also defined to process unsolicited rerequests. |
| * |
| * The rilDispatchTable is an array indexed by RIL_REQUEST_* or REQUEST_UNSOL_*, |
| * in which each request corresponds to a functions defined in the Radio object. |
| * We need to pay attention when using "this" within those functions. When they are |
| * called in "this.process" using |
| * result = this.radioDispatchTable[req.reqNum])(req); |
| * this scope of "this" within those functions are the radioDispatchTable, not the |
| * object that "this.process" belongs to. Using "this." to access other |
| * functions in the object may cause trouble. |
| * To avoid that, the object is passed in when those functions are called as |
| * shown in the following: |
| * result = (this.radioDispatchTable[req.reqNum]).call(this, req); |
| */ |
| |
| /** |
| * Set radio state |
| */ |
| function setRadioState(newState) { |
| newRadioState = newState; |
| if (typeof newState == 'string') { |
| newRadioState = globals[newState]; |
| if (typeof newRadioState == 'undefined') { |
| throw('setRadioState: Unknow string: ' + newState); |
| } |
| } |
| if ((newRadioState < RADIOSTATE_OFF) || (newRadioState > RADIOSTATE_NV_READY)) { |
| throw('setRadioState: newRadioState: ' + newRadioState + ' is invalid'); |
| } |
| gRadioState = newRadioState; |
| sendRilUnsolicitedResponse(RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED); |
| } |
| |
| /** |
| * Create a call. |
| * |
| * @return a RilCall |
| */ |
| function RilCall(state, phoneNumber, callerName) { |
| this.state = state; |
| this.index = 0; |
| this.toa = 0; |
| this.isMpty = false; |
| this.isMt = false; |
| this.als = 0; |
| this.isVoice = true; |
| this.isVoicePrivacy = false; |
| this.number = phoneNumber; |
| this.numberPresentation = 0; |
| this.name = callerName; |
| } |
| |
| /** |
| * Simulated Radio |
| */ |
| function Radio() { |
| var registrationState = '1'; |
| var lac = '0'; |
| var cid = '0'; |
| var radioTechnology = '3'; |
| var baseStationId = NULL_RESPONSE_STRING; |
| var baseStationLatitude = NULL_RESPONSE_STRING; |
| var baseStationLongitude = NULL_RESPONSE_STRING; |
| var concurrentServices = NULL_RESPONSE_STRING; |
| var systemId = NULL_RESPONSE_STRING; |
| var networkId = NULL_RESPONSE_STRING; |
| var roamingIndicator = NULL_RESPONSE_STRING; |
| var prlActive = NULL_RESPONSE_STRING; |
| var defaultRoamingIndicator = NULL_RESPONSE_STRING; |
| var registrationDeniedReason = NULL_RESPONSE_STRING; |
| var primaryScrambingCode = NULL_RESPONSE_STRING; |
| |
| var NETWORK_SELECTION_MODE_AUTOMATIC = 0; |
| var NETWORK_SELECTION_MODE_MANUAL = 1; |
| var networkSelectionMode = NETWORK_SELECTION_MODE_AUTOMATIC; |
| |
| var muteState = 0; // disable mute |
| |
| // Number of active calls in calls |
| var numberActiveCalls = 0; |
| |
| // Maximum number of active calls |
| var maxNumberActiveCalls = 7; |
| var maxConnectionsPerCall = 5; // only 5 connections allowed per call |
| |
| // Flag to denote whether an incoming/waiting call is answered |
| var incomingCallIsProcessed = false; |
| |
| // Call transition flag |
| var callTransitionFlag = false; // default to auto-transition |
| |
| var lastCallFailCause = 0; |
| |
| // Array of "active" calls |
| var calls = Array(maxNumberActiveCalls + 1); |
| |
| // The result returned by the request handlers |
| var result = new Object(); |
| |
| function GWSignalStrength() { |
| this.signalStrength = 10; // 10 * 2 + (-113) = -93dBm, make it three bars |
| this.bitErrorRate = 0; |
| } |
| |
| function CDMASignalStrength() { |
| this.dbm = -1; |
| this.ecio = -1; |
| } |
| |
| function EVDOSignalStrength() { |
| this.dbm = -1; |
| this.ecio = -1; |
| this.signalNoiseRatio = 0; |
| } |
| |
| var gwSignalStrength = new GWSignalStrength; |
| var cdmaSignalStrength = new CDMASignalStrength(); |
| var evdoSignalStrength = new EVDOSignalStrength(); |
| |
| /** |
| * The the array of calls, this is a sparse |
| * array and some elements maybe 'undefined'. |
| * |
| * @return Array of RilCall's |
| */ |
| this.getCalls = function() { |
| return calls; |
| } |
| |
| /** |
| * @return the RilCall at calls[index] or null if undefined. |
| */ |
| this.getCall = function(index) { |
| var c = null; |
| try { |
| c = calls[index]; |
| if (typeof c == 'undefined') { |
| c = null; |
| } |
| } catch (err) { |
| c = null; |
| } |
| return c; |
| } |
| |
| /** |
| * @return the first call that is in the given state |
| */ |
| this.getCallIdByState = function(callState) { |
| if ((callState < CALLSTATE_ACTIVE) || (callState > CALLSTATE_WAITING)) { |
| return null; |
| } |
| for (var i = 0; i < calls.length; i++) { |
| if (typeof calls[i] != 'undefined') { |
| if (calls[i].state == callState) { |
| return i; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** Add an active call |
| * |
| * @return a RilCall or null if too many active calls. |
| */ |
| this.addCall = function(state, phoneNumber, callerName) { |
| print('Radio: addCall'); |
| var c = null; |
| if (numberActiveCalls < maxNumberActiveCalls) { |
| numberActiveCalls += 1; |
| c = new RilCall(state, phoneNumber, callerName); |
| // call index should fall in the closure of [1, 7] |
| // Search for an "undefined" element in the array and insert the call |
| for (var i = 1; i < (maxNumberActiveCalls + 1); i++) { |
| print('Radio: addCall, i=' + i); |
| if (typeof calls[i] == 'undefined') { |
| print('Radio: addCall, calls[' + i + '] is undefined'); |
| c.index = i; |
| calls[i] = c; |
| break; |
| } |
| } |
| this.printCalls(calls); |
| } |
| return c; |
| } |
| |
| /** |
| * Remove the call, does nothing if the call is undefined. |
| * |
| * @param index into calls to remove. |
| * @return the call removed or null if did not exist |
| */ |
| this.removeCall = function(index) { |
| var c = null; |
| if ((numberActiveCalls > 0) |
| && (index < calls.length) |
| && (typeof calls[index] != 'undefined')) { |
| c = calls[index]; |
| delete calls[index]; |
| numberActiveCalls -= 1; |
| if (numberActiveCalls == 0) { |
| calls = new Array(); |
| } |
| } else { |
| c = null; |
| } |
| return c; |
| } |
| |
| /** |
| * Print the call |
| * |
| * @param c is the RilCall to print |
| */ |
| this.printCall = function(c) { |
| if ((c != null) && (typeof c != 'undefined')) { |
| print('c[' + c.index + ']: index=' + c.index + ' state=' + c.state + |
| ' number=' + c.number + ' name=' + c.name); |
| } |
| } |
| |
| /** |
| * Print all the calls. |
| * |
| * @param callArray is an Array of RilCall's |
| */ |
| this.printCalls = function(callArray) { |
| if (typeof callArray == 'undefined') { |
| callArray = calls; |
| } |
| print('callArray.length=' + callArray.length); |
| for (var i = 0; i < callArray.length; i++) { |
| if ((callArray[i] == null) || (typeof callArray[i] == 'undefined')) { |
| print('c[' + i + ']: undefined'); |
| } else { |
| this.printCall(callArray[i]); |
| } |
| } |
| } |
| |
| /** |
| * Count number of calls in the given state |
| * |
| * @param callState is the give state |
| */ |
| this.countCallsInState = function(callState) { |
| var count = 0; |
| if ((callState < CALLSTATE_ACTIVE) || (callState > CALLSTATE_WAITING)) { |
| // not a valid call state |
| return null; |
| } |
| for (var i = 0; i < calls.length; i++) { |
| if (typeof calls[i] != 'undefined') { |
| if (calls[i].state == callState) { |
| count++; |
| } |
| } |
| } |
| return count; |
| } |
| |
| /** |
| * Print signal strength |
| */ |
| this.printSignalStrength = function() { |
| print('rssi: ' + gwSignalStrength.signalStrength); |
| print('bitErrorRate: ' + gwSignalStrength.bitErrorRate); |
| print('cdmaDbm: ' + cdmaSignalStrength.dbm); |
| print('cdmaEcio: ' + cdmaSignalStrength.ecio); |
| print('evdoRssi: ' + evdoSignalStrength.dbm); |
| print('evdoEcio: ' + evdoSignalStrength.ecio); |
| print('evdoSnr: ' + evdoSignalStrength.signalNoiseRatio); |
| } |
| |
| /** |
| * set signal strength |
| * |
| * @param rssi and bitErrorRate are signal strength parameters for GSM |
| * cdmaDbm, cdmaEcio, evdoRssi, evdoEcio, evdoSnr are parameters for CDMA & EVDO |
| */ |
| this.setSignalStrength = function(rssi, bitErrorRate, cdmaDbm, cdmaEcio, evdoRssi, |
| evdoEcio, evdoSnr) { |
| print('setSignalStrength E'); |
| |
| if (rssi != 99) { |
| if ((rssi < 0) || (rssi > 31)) { |
| throw ('not a valid signal strength'); |
| } |
| } |
| // update signal strength |
| gwSignalStrength.signalStrength = rssi; |
| gwSignalStrength.bitErrorRate = bitErrorRate; |
| cdmaSignalStrength.dbm = cdmaDbm; |
| cdmaSignalStrength.ecio = cdmaEcio; |
| evdoSignalStrength.dbm = evdoRssi; |
| evdoSignalStrength.ecio = evdoEcio; |
| evdoSignalStrength.signalNoiseRatio = evdoSnr; |
| |
| // pack the signal strength into RspSignalStrength and send a unsolicited response |
| var rsp = new Object(); |
| |
| rsp.gwSignalstrength = gwSignalStrength; |
| rsp.cdmSignalstrength = cdmaSignalStrength; |
| rsp.evdoSignalstrength = evdoSignalStrength; |
| |
| var response = rilSchema[packageNameAndSeperator + |
| 'RspSignalStrength'].serialize(rsp); |
| |
| sendRilUnsolicitedResponse(RIL_UNSOL_SIGNAL_STRENGTH, response); |
| |
| // send the unsolicited signal strength every 1 minute. |
| simulatedRadioWorker.addDelayed( |
| {'reqNum' : CMD_UNSOL_SIGNAL_STRENGTH}, 60000); |
| print('setSignalStrength X'); |
| } |
| |
| /** |
| * Handle RIL_REQUEST_GET_CURRENT_CALL |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestGetCurrentCalls = function(req) { // 9 |
| print('Radio: rilRequestGetCurrentCalls E'); |
| var rsp = new Object(); |
| |
| // pack calls into rsp.calls |
| rsp.calls = new Array(); |
| var i; |
| var j; |
| for (i = 0, j = 0; i < calls.length; i++) { |
| if (typeof calls[i] != 'undefined') { |
| rsp.calls[j++] = calls[i]; |
| } |
| } |
| result.responseProtobuf = rilSchema[packageNameAndSeperator + |
| 'RspGetCurrentCalls'].serialize(rsp); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_DIAL |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestDial = function(req) { // 10 |
| print('Radio: rilRequestDial E'); |
| var newCall = new Object(); |
| newCall = this.addCall(CALLSTATE_DIALING, req.data.address, ''); |
| if (newCall == null) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| return result; |
| } |
| this.printCalls(calls); |
| |
| print('after add the call'); |
| // Set call state to dialing |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_CALL_STATE_CHANGE, |
| 'callType' : OUTGOING, |
| 'callIndex' : newCall.index, |
| 'nextState' : CALLSTATE_DIALING}); |
| if (!callTransitionFlag) { |
| // for auto transition |
| // Update call state to alerting after 1 second |
| simulatedRadioWorker.addDelayed( |
| {'reqNum' : CMD_CALL_STATE_CHANGE, |
| 'callType' : OUTGOING, |
| 'callIndex' : newCall.index, |
| 'nextState' : CALLSTATE_ALERTING}, 1000); |
| // Update call state to active after 2 seconds |
| simulatedRadioWorker.addDelayed( |
| {'reqNum' : CMD_CALL_STATE_CHANGE, |
| 'callType' : OUTGOING, |
| 'callIndex': newCall.index, |
| 'nextState' : CALLSTATE_ACTIVE}, 2000); |
| } |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_HANG_UP |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestHangUp = function(req) { // 12 |
| print('Radio: rilRequestHangUp data.connection_index=' + req.data.connectionIndex); |
| if (this.removeCall(req.data.connectionIndex) == null) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| print('no connection to hangup'); |
| } |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND |
| * Hang up waiting or held |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestHangupWaitingOrBackground = function(req) { // 13 |
| print('Radio: rilRequestHangupWaitingOrBackground'); |
| if (numberActiveCalls <= 0) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| } else { |
| for (var i = 0; i < calls.length; i++) { |
| if (typeof calls[i] != 'undefined') { |
| switch (calls[i].state) { |
| case CALLSTATE_HOLDING: |
| case CALLSTATE_WAITING: |
| case CALLSTATE_INCOMING: |
| this.removeCall(i); |
| incomingCallIsProcessed = true; |
| break; |
| default: |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| break; |
| } |
| this.printCalls(calls); |
| if(result.rilErrCode == RIL_E_GENERIC_FAILURE) { |
| return result; |
| } |
| } // end of processing call[i] |
| } // end of for |
| } |
| // Send out RIL_UNSOL_CALL_STATE_CHANGED after the request is returned |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND |
| * release all active calls (if any exist) and resume held or waiting calls. |
| * @param req is the Request |
| */ |
| this.rilRequestHangUpForegroundResumeBackground = function(req) { //14 |
| print('Radio: rilRequestHangUpForegroundResumeBackground'); |
| if (numberActiveCalls <= 0) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| } else { |
| for (var i = 0; i < calls.length; i++) { |
| if (typeof calls[i] != 'undefined') { |
| switch (calls[i].state) { |
| case CALLSTATE_ACTIVE: |
| this.removeCall(i); |
| break; |
| case CALLSTATE_HOLDING: |
| case CALLSTATE_WAITING: |
| calls[i].state = CALLSTATE_ACTIVE; |
| break; |
| default: |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| break; |
| } |
| this.printCalls(calls); |
| if(result.rilErrCode == RIL_E_GENERIC_FAILURE) { |
| return result; |
| } |
| } // end of processing call[i] |
| } |
| } |
| // Send out RIL_UNSOL_CALL_STATE_CHANGED after the request is returned |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE |
| * |
| * 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 |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestSwitchWaitingOrHoldingAndActive = function(req) { // 15 |
| print('Radio: rilRequestSwitchWaitingOrHoldingAndActive'); |
| print('Radio: lastReq = ' + lastReq); |
| print('Radio: req.reqNum = ' + req.reqNum); |
| if (lastReq == req.reqNum) { |
| print('Radio: called twice'); |
| return result; |
| } |
| |
| if (numberActiveCalls <= 0) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| } else { |
| for (var i = 0; i < calls.length; i++) { |
| if (typeof calls[i] != 'undefined') { |
| switch (calls[i].state) { |
| case CALLSTATE_ACTIVE: |
| calls[i].state = CALLSTATE_HOLDING; |
| break; |
| case CALLSTATE_HOLDING: |
| case CALLSTATE_WAITING: |
| calls[i].state = CALLSTATE_ACTIVE; |
| break; |
| default: |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| break; |
| } |
| this.printCalls(calls); |
| if(result.rilErrCode == RIL_E_GENERIC_FAILURE) { |
| return result; |
| } |
| } // end of processing call[i] |
| } // end of for |
| } |
| // Send out RIL_UNSOL_CALL_STATE_CHANGED after the request is returned |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_CONFERENCE |
| * Conference holding and active |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestConference = function(req) { // 16 |
| print('Radio: rilRequestConference E'); |
| if ((numberActiveCalls <= 0) || (numberActiveCalls > maxConnectionsPerCall)) { |
| // The maximum number of connections within a call is 5 |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| return result; |
| } else { |
| var numCallsInBadState = 0; |
| for (var i = 0; i < calls.length; i++) { |
| if (typeof calls[i] != 'undefined') { |
| if ((calls[i].state != CALLSTATE_ACTIVE) && |
| (calls[i].state != CALLSTATE_HOLDING)) { |
| numCallsInBadState++; |
| } |
| } |
| } |
| |
| // if there are calls not in ACITVE or HOLDING state, return error |
| if (numCallsInBadState > 0) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| return result; |
| } else { // conference ACTIVE and HOLDING calls |
| for (var i = 0; i < calls.length; i++) { |
| if (typeof calls[i] != 'undefined') { |
| switch (calls[i].state) { |
| case CALLSTATE_ACTIVE: |
| break; |
| case CALLSTATE_HOLDING: |
| calls[i].state = CALLSTATE_ACTIVE; |
| break; |
| default: |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| break; |
| } |
| } |
| this.printCalls(calls); |
| if(result.rilErrCode == RIL_E_GENERIC_FAILURE) { |
| return result; |
| } |
| } |
| } |
| } |
| |
| // Only if conferencing is successful, |
| // Send out RIL_UNSOL_CALL_STATE_CHANGED after the request is returned |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_LAST_CALL_FAIL_CAUSE |
| * |
| * @param req is the request |
| */ |
| this.rilRequestLastCallFailCause = function(req) { |
| print('Radio: rilRequestLastCallFailCause E'); |
| |
| var rsp = new Object(); |
| rsp.integers = new Array(); |
| rsp.integers[0] = lastCallFailCause; |
| |
| result.responseProtobuf = rilSchema[packageNameAndSeperator + |
| 'RspIntegers'].serialize(rsp); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_SIGNAL_STRENGTH |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestSignalStrength = function(req) { // 19 |
| print('Radio: rilRequestSignalStrength E'); |
| var rsp = new Object(); |
| |
| // pack the signal strength into RspSignalStrength |
| rsp.gwSignalstrength = gwSignalStrength; |
| rsp.cdmaSignalstrength = cdmaSignalStrength; |
| rsp.evdoSignalstrength = evdoSignalStrength; |
| |
| result.responseProtobuf = rilSchema[packageNameAndSeperator + |
| 'RspSignalStrength'].serialize(rsp); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_REGISTRATION_STATE |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestRegistrationState = function(req) { // 20 |
| print('Radio: rilRequestRegistrationState'); |
| |
| var rsp = new Object(); |
| rsp.strings = Array(); |
| rsp.strings[0] = registrationState; |
| rsp.strings[1] = lac; |
| rsp.strings[2] = cid; |
| rsp.strings[3] = radioTechnology; |
| rsp.strings[4] = baseStationId; |
| rsp.strings[5] = baseStationLatitude; |
| rsp.strings[6] = baseStationLongitude; |
| rsp.strings[7] = concurrentServices; |
| rsp.strings[8] = systemId; |
| rsp.strings[9] = networkId; |
| rsp.strings[10] = roamingIndicator; |
| rsp.strings[11] = prlActive; |
| rsp.strings[12] = defaultRoamingIndicator; |
| rsp.strings[13] = registrationDeniedReason; |
| rsp.strings[14] = primaryScrambingCode; |
| |
| result.responseProtobuf = rilSchema[packageNameAndSeperator + |
| 'RspStrings'].serialize(rsp); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_GPRS_REGISTRATION_STATE |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestGprsRegistrationState = function(req) { // 21 |
| print('Radio: rilRequestGprsRegistrationState'); |
| |
| var rsp = new Object(); |
| rsp.strings = Array(); |
| rsp.strings[0] = registrationState; |
| rsp.strings[1] = lac; |
| rsp.strings[2] = cid; |
| rsp.strings[3] = radioTechnology; |
| |
| result.responseProtobuf = rilSchema[packageNameAndSeperator + |
| 'RspStrings'].serialize(rsp); |
| return result; |
| } |
| |
| /** |
| * 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 |
| } |
| incomingCallIsProcessed = true; |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestQueryNeworkSelectionMode = function(req) { // 45 |
| print('Radio: rilRequestQueryNeworkSelectionMode'); |
| |
| var rsp = new Object(); |
| rsp.integers = Array(); |
| rsp.integers[0] = networkSelectionMode; |
| |
| result.responseProtobuf = rilSchema[packageNameAndSeperator + |
| 'RspIntegers'].serialize(rsp); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestSetNeworkSelectionAutomatic = function(req) { // 46 |
| print('Radio: rilRequestSetNeworkSelectionAutomatic'); |
| |
| networkSelectionMode = NETWORK_SELECTION_MODE_AUTOMATIC; |
| |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_BASE_BAND_VERSION |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestBaseBandVersion = function(req) { // 51 |
| print('Radio: rilRequestBaseBandVersion'); |
| var rsp = new Object(); |
| rsp.strings = Array(); |
| rsp.strings[0] = gBaseBandVersion; |
| |
| result.responseProtobuf = rilSchema[packageNameAndSeperator + |
| 'RspStrings'].serialize(rsp); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_SEPRATE_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 |
| * |
| * See TS 22.084 1.3.8.2 (iii) |
| * |
| * @param req is the Request |
| */ |
| this.rilReqestSeparateConnection = function(req) { // 52 |
| print('Radio: rilReqestSeparateConnection'); |
| var index = req.data.index; |
| |
| if (numberActiveCalls <= 0) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| return result; |
| } else { |
| // get the connection to separate |
| var separateConn = this.getCall(req.data.index); |
| if (separateConn == null) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| return result; |
| } else { |
| if (separateConn.state != CALLSTATE_ACTIVE) { |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| return result; |
| } |
| // Put all other connections in hold. |
| for (var i = 0; i < calls.length; i++) { |
| if (index != i) { |
| // put all the active call to hold |
| if (typeof calls[i] != 'undefined') { |
| switch (calls[i].state) { |
| case CALLSTATE_ACTIVE: |
| calls[i].state = CALLSTATE_HOLDING; |
| break; |
| default: |
| result.rilErrCode = RIL_E_GENERIC_FAILURE; |
| break; |
| } |
| this.printCalls(calls); |
| if(result.rilErrCode == RIL_E_GENERIC_FAILURE) { |
| return result; |
| } |
| } // end of processing call[i] |
| } |
| } // end of for |
| } |
| } |
| |
| // Send out RIL_UNSOL_CALL_STATE_CHANGED after the request is returned |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_SET_MUTE |
| */ |
| this.rilRequestSetMute = function(req) { // 53 |
| print('Radio: rilRequestSetMute: req.data.state=' + req.data.state); |
| muteState = req.data.state; |
| if (gRadioState == RADIOSTATE_UNAVAILABLE) { |
| result.rilErrCode = RIL_E_RADIO_NOT_AVAILABLE; |
| } |
| return result; |
| } |
| |
| /** |
| * Handle RIL_REQUEST_SCREEN_STATE |
| * |
| * @param req is the Request |
| */ |
| this.rilRequestScreenState = function(req) { // 61 |
| print('Radio: rilRequestScreenState: req.data.state=' + req.data.state); |
| screenState = req.data.state; |
| return result; |
| } |
| |
| /** |
| * Delay test |
| */ |
| this.cmdDelayTest = function(req) { // 2000 |
| print('cmdDelayTest: req.hello=' + req.hello); |
| result.sendResponse = false; |
| return result; |
| } |
| |
| /** |
| * Delay for RIL_UNSOL_SIGNAL_STRENGTH |
| * TODO: Simulate signal strength changes: |
| * Method 1: provide an array for signal strength, and send the unsolicited |
| * reponse periodically (the period can also be simulated) |
| * Method 2: Simulate signal strength randomly (within a certain range) and |
| * send the response periodically. |
| */ |
| this.cmdUnsolSignalStrength = function(req) { // 2001 |
| print('cmdUnsolSignalStrength: req.reqNum=' + req.reqNum); |
| var rsp = new Object(); |
| |
| // pack the signal strength into RspSignalStrength |
| rsp.gwSignalstrength = gwSignalStrength; |
| rsp.cdmaSignalstrength = cdmaSignalStrength; |
| rsp.evdoSignalstrength = evdoSignalStrength; |
| |
| response = rilSchema[packageNameAndSeperator + |
| 'RspSignalStrength'].serialize(rsp); |
| |
| // upldate signal strength |
| sendRilUnsolicitedResponse(RIL_UNSOL_SIGNAL_STRENGTH, response); |
| |
| // Send the unsolicited signal strength every 1 minute. |
| simulatedRadioWorker.addDelayed( |
| {'reqNum' : CMD_UNSOL_SIGNAL_STRENGTH}, 60000); |
| |
| // this is not a request, no response is needed |
| result.sendResponse = false; |
| return result; |
| } |
| |
| /** |
| * Send RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED |
| */ |
| this.cmdUnsolCallStateChanged = function(req) { // 2002 |
| print('cmdUnsolCallStateChanged: req.reqNum=' + req.reqNum); |
| sendRilUnsolicitedResponse(RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED); |
| result.sendResponse = false; |
| return result; |
| } |
| |
| /** |
| * Simulate call state change |
| */ |
| this.cmdCallStateChange = function(req) { // 2003 |
| print('cmdCallStateChange: req.reqNum=' + req.reqNum); |
| print('cmdCallStateChange: req.callType=' + req.callType); |
| print('cmdCallStateChange: req.callIndex=' + req.callIndex); |
| print('cmdCallStateChange: req.nextState=' + req.nextState); |
| |
| // if it is an outgoing call, update the call state of the call |
| // Send out call state changed flag |
| var curCall = this.getCall(req.callIndex); |
| this.printCall(curCall); |
| |
| if (curCall != null) { |
| curCall.state = req.nextState; |
| } else { |
| this.removeCall(req.callIndex); |
| } |
| |
| // TODO: if it is an incoming call, update the call state of the call |
| // Send out call state change flag |
| // Send out RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| 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); |
| if(!incomingCallIsProcessed) { |
| 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 incomingCallIsProcessed flag to be false |
| incomingCallIsProcessed = false; |
| |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_RING}); |
| |
| result.rilErrCode = CTRL_STATUS_OK; |
| return result; |
| } |
| |
| /** |
| * Handle control command CTRL_CMD_HANGUP_CONN_REMOTE |
| * hangup the connection for the given failure cause |
| * |
| *@param req is the control request |
| */ |
| this.ctrlServerCmdHangupConnRemote = function(req) { // 1002 |
| print('ctrlServerCmdHangupConnRemote: req.data.connectionId=' + req.data.connectionId + |
| ' req.data.callFailCause' + req.data.callFailCause); |
| |
| var connection = req.data.connectionId; |
| var failureCause = req.data.callFailCause; |
| |
| this.printCalls(calls); |
| var hangupCall = this.removeCall(connection); |
| if (hangupCall == null) { |
| print('ctrlServerCmdHangupConnRemote: connection id is required.'); |
| result.rilErrCode = CTRL_STATUS_ERR; |
| return result; |
| } else { |
| // for incoming call, stop sending call ring |
| if ((hangupCall.state == CALLSTATE_INCOMING) || |
| (hangupCall.state == CALLSTATE_WAITING)) { |
| incomingCallIsProcessed = true; |
| } |
| } |
| this.printCalls(calls); |
| lastCallFailCause = failureCause; |
| |
| // send out call state changed response |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| |
| result.rilErrCode = CTRL_STATUS_OK; |
| return result; |
| } |
| |
| /** |
| * Set call transition flag |
| */ |
| this.ctrlServerCmdSetCallTransitionFlag = function(req) { // 1003 |
| print('ctrlServerCmdSetCallTransitionFlag: flag=' + req.data.flag); |
| |
| callTransitionFlag = req.data.flag; |
| result.rilErrCode = CTRL_STATUS_OK; |
| return result; |
| } |
| |
| /** |
| * Set the dialing call to alert |
| */ |
| this.ctrlServerCmdSetCallAlert = function(req) { // 1004 |
| print('ctrlServerCmdSetCallAlert: E'); |
| |
| if (callTransitionFlag == false) { |
| print('ctrlServerCmdSetCallAlert: need to set the flag first'); |
| result.rilErrCode = CTRL_STATUS_ERR; |
| return result; |
| } |
| if (numberActiveCalls <= 0) { |
| print('ctrlServerCmdSetCallAlert: no active calls'); |
| result.rilErrCode = CTRL_STATUS_ERR; |
| return result; |
| } |
| var dialingCalls = this.countCallsInState(CALLSTATE_DIALING); |
| var index = this.getCallIdByState(CALLSTATE_DIALING); |
| if ((dialingCalls == 1) && (index != null)) { |
| calls[index].state = CALLSTATE_ALERTING; |
| } else { |
| // if there 0 or more than one call in dialing state, return error |
| print('ctrlServerCmdSetCallAlert: no valid calls in dialing state'); |
| result.rilErrCode = CTRL_STATUS_ERR; |
| return result; |
| } |
| // send unsolicited call state change response |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| |
| result.rilErrCode = CTRL_STATUS_OK; |
| return result; |
| } |
| |
| /** |
| * Set the alserting call to active |
| */ |
| this.ctrlServerCmdSetCallActive = function(req) { // 1005 |
| print('ctrlServerCmdSetCallActive: E'); |
| |
| if (callTransitionFlag == false) { |
| print('ctrlServerCmdSetCallActive: need to set the flag firt'); |
| result.rilErrCode = CTRL_STATUS_ERR; |
| return result; |
| } |
| if (numberActiveCalls <= 0) { |
| print('ctrlServerCmdSetCallActive: no active calls'); |
| result.rilErrCode = CTRL_STATUS_ERR; |
| return result; |
| } |
| var alertingCalls = this.countCallsInState(CALLSTATE_ALERTING); |
| var index = this.getCallIdByState(CALLSTATE_ALERTING); |
| if ((alertingCalls == 1) && (index != null)) { |
| calls[index].state = CALLSTATE_ACTIVE; |
| } else { |
| print('ctrlServerCmdSetCallActive: no valid calls in alert state'); |
| result.rilErrCode = CTRL_STATUS_ERR; |
| return result; |
| } |
| // send out unsolicited call state change response |
| simulatedRadioWorker.add( |
| {'reqNum' : CMD_UNSOL_CALL_STATE_CHANGED}); |
| |
| result.rilErrCode = CTRL_STATUS_OK; |
| return result; |
| } |
| |
| /** |
| * Add a dialing call |
| */ |
| this.ctrlServerCmdAddDialingCall = function(req) { // 1006 |
| print('ctrlServerCmdAddDialingCall: E'); |
| |
| var phoneNumber = req.data.phoneNumber; |
| var dialingCalls = this.countCallsInState(CALLSTATE_DIALING); |
| if (dialingCalls == 0) { |
| this.addCall(CALLSTATE_DIALING, phoneNumber, ''); |
| result.rilErrCode = CTRL_STATUS_OK; |
| } else { |
| print('ctrlServerCmdAddDialingCall: add dialing call failed'); |
| result.rilErrCode = CTRL_STATUS_ERR; |
| } |
| return result; |
| } |
| |
| /** |
| * Process the request by dispatching to the request handlers |
| */ |
| this.process = function(req) { |
| try { |
| print('Radio E: req.reqNum=' + req.reqNum + ' req.token=' + req.token); |
| |
| // Assume the result will be true, successful and nothing to return |
| result.sendResponse = true; |
| result.rilErrCode = RIL_E_SUCCESS; |
| result.responseProtobuf = emptyProtobuf; |
| |
| try { |
| // Pass "this" object to each ril request call such that |
| // they have the same scope |
| result = (this.radioDispatchTable[req.reqNum]).call(this, req); |
| } catch (err) { |
| print('Radio:process err = ' + err); |
| print('Radio: Unknown reqNum=' + req.reqNum); |
| result.rilErrCode = RIL_E_REQUEST_NOT_SUPPORTED; |
| } |
| |
| if (req.reqNum < 200) { |
| lastReq = req.reqNum; |
| } |
| if (result.sendResponse) { |
| 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=' + |
| req.reqNum + ' req.token=' + req.token + ' err=' + err); |
| } |
| } |
| |
| /** |
| * Construct the simulated radio |
| */ |
| print('Radio: constructor E'); |
| this.radioDispatchTable = new Array(); |
| this.radioDispatchTable[RIL_REQUEST_GET_CURRENT_CALLS] = // 9 |
| this.rilRequestGetCurrentCalls; |
| this.radioDispatchTable[RIL_REQUEST_DIAL] = // 10 |
| this.rilRequestDial; |
| this.radioDispatchTable[RIL_REQUEST_HANGUP] = // 12 |
| this.rilRequestHangUp; |
| this.radioDispatchTable[RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND] = // 13 |
| this.rilRequestHangupWaitingOrBackground; |
| this.radioDispatchTable[RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND] = // 14 |
| this.rilRequestHangUpForegroundResumeBackground; |
| this.radioDispatchTable[RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE] = // 15 |
| this.rilRequestSwitchWaitingOrHoldingAndActive; |
| this.radioDispatchTable[RIL_REQUEST_CONFERENCE] = // 16 |
| this.rilRequestConference; |
| this.radioDispatchTable[RIL_REQUEST_LAST_CALL_FAIL_CAUSE] = // 18 |
| this.rilRequestLastCallFailCause; |
| this.radioDispatchTable[RIL_REQUEST_SIGNAL_STRENGTH] = // 19 |
| this.rilRequestSignalStrength; |
| this.radioDispatchTable[RIL_REQUEST_REGISTRATION_STATE] = // 20 |
| 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.rilRequestSetNeworkSelectionAutomatic; |
| this.radioDispatchTable[RIL_REQUEST_BASEBAND_VERSION] = // 51 |
| this.rilRequestBaseBandVersion; |
| this.radioDispatchTable[RIL_REQUEST_SEPARATE_CONNECTION] = // 52 |
| this.rilReqestSeparateConnection; |
| this.radioDispatchTable[RIL_REQUEST_SET_MUTE] = // 53 |
| this.rilRequestSetMute; |
| this.radioDispatchTable[RIL_REQUEST_SCREEN_STATE] = // 61 |
| this.rilRequestScreenState; |
| |
| this.radioDispatchTable[CTRL_CMD_SET_MT_CALL] = //1001 |
| this.ctrlServerCmdStartInComingCall; |
| this.radioDispatchTable[CTRL_CMD_HANGUP_CONN_REMOTE] = //1002 |
| this.ctrlServerCmdHangupConnRemote; |
| this.radioDispatchTable[CTRL_CMD_SET_CALL_TRANSITION_FLAG] = //1003 |
| this.ctrlServerCmdSetCallTransitionFlag; |
| this.radioDispatchTable[CTRL_CMD_SET_CALL_ALERT] = // 1004 |
| this.ctrlServerCmdSetCallAlert; |
| this.radioDispatchTable[CTRL_CMD_SET_CALL_ACTIVE] = // 1005 |
| this.ctrlServerCmdSetCallActive; |
| this.radioDispatchTable[CTRL_CMD_ADD_DIALING_CALL] = // 1006 |
| this.ctrlServerCmdAddDialingCall; |
| |
| this.radioDispatchTable[CMD_DELAY_TEST] = // 2000 |
| this.cmdDelayTest; |
| this.radioDispatchTable[CMD_UNSOL_SIGNAL_STRENGTH] = // 2001 |
| this.cmdUnsolSignalStrength; |
| this.radioDispatchTable[CMD_UNSOL_CALL_STATE_CHANGED] = // 2002 |
| this.cmdUnsolCallStateChanged; |
| this.radioDispatchTable[CMD_CALL_STATE_CHANGE] = //2003 |
| this.cmdCallStateChange; |
| this.radioDispatchTable[CMD_UNSOL_CALL_RING] = //2004 |
| this.cmdUnsolCallRing; |
| |
| print('Radio: constructor X'); |
| } |
| |
| // The simulated radio instance and its associated Worker |
| var simulatedRadio = new Radio(); |
| var simulatedRadioWorker = new Worker(function (req) { |
| simulatedRadio.process(req); |
| }); |
| simulatedRadioWorker.run(); |
| |
| // TODO: this is a workaround for bug http://b/issue?id=3001613 |
| // When adding a new all, two RIL_REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE |
| // will be sent from the framework. |
| var lastReq = 0; |
| |
| /** |
| * Optional tests |
| */ |
| if (false) { |
| include("simulated_radio_tests.js"); |
| } |
