| /* |
| * Copyright (C) 2014 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. |
| */ |
| |
| package com.android.internal.telephony.dataconnection; |
| |
| import com.android.internal.util.AsyncChannel; |
| import com.android.internal.util.Protocol; |
| import com.android.internal.util.State; |
| import com.android.internal.util.StateMachine; |
| import com.android.internal.telephony.Phone; |
| import com.android.internal.telephony.PhoneConstants; |
| import com.android.internal.telephony.PhoneBase; |
| import com.android.internal.telephony.PhoneProxy; |
| import com.android.internal.telephony.dataconnection.DcSwitchAsyncChannel.RequestInfo; |
| |
| import android.os.Message; |
| import android.telephony.Rlog; |
| |
| public class DcSwitchStateMachine extends StateMachine { |
| private static final boolean DBG = true; |
| private static final boolean VDBG = false; |
| private static final String LOG_TAG = "DcSwitchSM"; |
| |
| // ***** Event codes for driving the state machine |
| private static final int BASE = Protocol.BASE_DATA_CONNECTION_TRACKER + 0x00001000; |
| private static final int EVENT_CONNECTED = BASE + 0; |
| |
| private int mId; |
| private Phone mPhone; |
| private AsyncChannel mAc; |
| |
| private IdleState mIdleState = new IdleState(); |
| private AttachingState mAttachingState = new AttachingState(); |
| private AttachedState mAttachedState = new AttachedState(); |
| private DetachingState mDetachingState = new DetachingState(); |
| private DefaultState mDefaultState = new DefaultState(); |
| |
| protected DcSwitchStateMachine(Phone phone, String name, int id) { |
| super(name); |
| if (DBG) log("DcSwitchState constructor E"); |
| mPhone = phone; |
| mId = id; |
| |
| addState(mDefaultState); |
| addState(mIdleState, mDefaultState); |
| addState(mAttachingState, mDefaultState); |
| addState(mAttachedState, mDefaultState); |
| addState(mDetachingState, mDefaultState); |
| setInitialState(mIdleState); |
| if (DBG) log("DcSwitchState constructor X"); |
| } |
| |
| // public void notifyDataConnection(int phoneId, String state, String reason, |
| // String apnName, String apnType, boolean unavailable) { |
| // if (phoneId == mId && |
| // TextUtils.equals(state, PhoneConstants.DataState.CONNECTED.toString())) { |
| // sendMessage(obtainMessage(EVENT_CONNECTED)); |
| // } |
| // } |
| |
| private class IdleState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log("IdleState: enter"); |
| |
| try { |
| DctController.getInstance().processRequests(); |
| } catch (RuntimeException e) { |
| if (DBG) loge("DctController is not ready"); |
| } |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case DcSwitchAsyncChannel.REQ_CONNECT: { |
| if (DBG) { |
| log("IdleState: REQ_CONNECT"); |
| } |
| |
| PhoneBase pb = (PhoneBase)((PhoneProxy)mPhone).getActivePhone(); |
| pb.mCi.setDataAllowed(true, null); |
| |
| mAc.replyToMessage(msg, DcSwitchAsyncChannel.RSP_CONNECT, |
| PhoneConstants.APN_REQUEST_STARTED); |
| |
| transitionTo(mAttachingState); |
| retVal = HANDLED; |
| break; |
| } |
| |
| case DcSwitchAsyncChannel.EVENT_DATA_ATTACHED: |
| if (DBG) { |
| log("AttachingState: EVENT_DATA_ATTACHED"); |
| } |
| transitionTo(mAttachedState); |
| retVal = HANDLED; |
| break; |
| |
| case EVENT_CONNECTED: { |
| if (DBG) { |
| log("IdleState: Receive invalid event EVENT_CONNECTED!"); |
| } |
| retVal = HANDLED; |
| break; |
| } |
| default: |
| if (VDBG) { |
| log("IdleState: nothandled msg.what=0x" + |
| Integer.toHexString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| |
| private class AttachingState extends State { |
| @Override |
| public void enter() { |
| log("AttachingState: enter"); |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case DcSwitchAsyncChannel.REQ_CONNECT: { |
| if (DBG) { |
| log("AttachingState: REQ_CONNECT"); |
| } |
| |
| PhoneBase pb = (PhoneBase) ((PhoneProxy) mPhone).getActivePhone(); |
| pb.mCi.setDataAllowed(true, null); |
| |
| mAc.replyToMessage(msg, DcSwitchAsyncChannel.RSP_CONNECT, |
| PhoneConstants.APN_REQUEST_STARTED); |
| retVal = HANDLED; |
| break; |
| } |
| |
| case DcSwitchAsyncChannel.EVENT_DATA_ATTACHED: |
| if (DBG) { |
| log("AttachingState: EVENT_DATA_ATTACHED"); |
| } |
| transitionTo(mAttachedState); |
| retVal = HANDLED; |
| break; |
| |
| case DcSwitchAsyncChannel.REQ_DISCONNECT_ALL: { |
| if (DBG) { |
| log("AttachingState: REQ_DISCONNECT_ALL" ); |
| } |
| DctController.getInstance().releaseAllRequests(mId); |
| mAc.replyToMessage(msg, DcSwitchAsyncChannel.RSP_DISCONNECT_ALL, |
| PhoneConstants.APN_REQUEST_STARTED); |
| |
| transitionTo(mDetachingState); |
| retVal = HANDLED; |
| break; |
| } |
| |
| default: |
| if (VDBG) { |
| log("AttachingState: nothandled msg.what=0x" + |
| Integer.toHexString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| |
| private class AttachedState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log("AttachedState: enter"); |
| //When enter attached state, we need exeute all requests. |
| DctController.getInstance().executeAllRequests(mId); |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case DcSwitchAsyncChannel.REQ_CONNECT: { |
| RequestInfo apnRequest = (RequestInfo)msg.obj; |
| if (DBG) { |
| log("AttachedState: REQ_CONNECT, apnRequest=" + apnRequest); |
| } |
| |
| DctController.getInstance().executeRequest(apnRequest); |
| mAc.replyToMessage(msg, DcSwitchAsyncChannel.RSP_CONNECT, |
| PhoneConstants.APN_REQUEST_STARTED); |
| |
| retVal = HANDLED; |
| break; |
| } |
| case DcSwitchAsyncChannel.REQ_DISCONNECT: { |
| RequestInfo apnRequest = (RequestInfo)msg.obj; |
| if (DBG) { |
| log("AttachedState: REQ_DISCONNECT apnRequest=" + apnRequest); |
| } |
| |
| DctController.getInstance().releaseRequest(apnRequest); |
| mAc.replyToMessage(msg, DcSwitchAsyncChannel.RSP_CONNECT, |
| PhoneConstants.APN_REQUEST_STARTED); |
| |
| retVal = HANDLED; |
| break; |
| } |
| |
| case DcSwitchAsyncChannel.REQ_DISCONNECT_ALL: { |
| if (DBG) { |
| log("AttachedState: REQ_DISCONNECT_ALL" ); |
| } |
| DctController.getInstance().releaseAllRequests(mId); |
| mAc.replyToMessage(msg, DcSwitchAsyncChannel.RSP_DISCONNECT_ALL, |
| PhoneConstants.APN_REQUEST_STARTED); |
| |
| transitionTo(mDetachingState); |
| retVal = HANDLED; |
| break; |
| } |
| |
| case DcSwitchAsyncChannel.EVENT_DATA_DETACHED: { |
| if (DBG) { |
| log("AttachedState: EVENT_DATA_DETACHED"); |
| } |
| transitionTo(mAttachingState); |
| retVal = HANDLED; |
| break; |
| } |
| |
| default: |
| if (VDBG) { |
| log("AttachedState: nothandled msg.what=0x" + |
| Integer.toHexString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| |
| private class DetachingState extends State { |
| @Override |
| public void enter() { |
| if (DBG) log("DetachingState: enter"); |
| PhoneBase pb = (PhoneBase)((PhoneProxy)mPhone).getActivePhone(); |
| pb.mCi.setDataAllowed(false, obtainMessage( |
| DcSwitchAsyncChannel.EVENT_DATA_DETACHED)); |
| } |
| |
| @Override |
| public boolean processMessage(Message msg) { |
| boolean retVal; |
| |
| switch (msg.what) { |
| case DcSwitchAsyncChannel.EVENT_DATA_DETACHED: { |
| if (DBG) { |
| log("DetachingState: EVENT_DATA_DETACHED"); |
| } |
| transitionTo(mIdleState); |
| retVal = HANDLED; |
| break; |
| } |
| |
| case DcSwitchAsyncChannel.REQ_DISCONNECT_ALL: { |
| if (DBG) { |
| log("DetachingState: REQ_DISCONNECT_ALL, already detaching" ); |
| } |
| mAc.replyToMessage(msg, DcSwitchAsyncChannel.RSP_DISCONNECT_ALL, |
| PhoneConstants.APN_REQUEST_STARTED); |
| retVal = HANDLED; |
| break; |
| } |
| |
| default: |
| if (VDBG) { |
| log("DetachingState: nothandled msg.what=0x" + |
| Integer.toHexString(msg.what)); |
| } |
| retVal = NOT_HANDLED; |
| break; |
| } |
| return retVal; |
| } |
| } |
| |
| private class DefaultState extends State { |
| @Override |
| public boolean processMessage(Message msg) { |
| switch (msg.what) { |
| case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: { |
| if (mAc != null) { |
| if (VDBG) log("Disconnecting to previous connection mAc=" + mAc); |
| mAc.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, |
| AsyncChannel.STATUS_FULL_CONNECTION_REFUSED_ALREADY_CONNECTED); |
| } else { |
| mAc = new AsyncChannel(); |
| mAc.connected(null, getHandler(), msg.replyTo); |
| if (VDBG) log("DcDefaultState: FULL_CONNECTION reply connected"); |
| mAc.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, |
| AsyncChannel.STATUS_SUCCESSFUL, mId, "hi"); |
| } |
| break; |
| } |
| case AsyncChannel.CMD_CHANNEL_DISCONNECT: { |
| if (VDBG) log("CMD_CHANNEL_DISCONNECT"); |
| mAc.disconnect(); |
| break; |
| } |
| case AsyncChannel.CMD_CHANNEL_DISCONNECTED: { |
| if (VDBG) log("CMD_CHANNEL_DISCONNECTED"); |
| mAc = null; |
| break; |
| } |
| case DcSwitchAsyncChannel.REQ_IS_IDLE_STATE: { |
| boolean val = getCurrentState() == mIdleState; |
| if (VDBG) log("REQ_IS_IDLE_STATE isIdle=" + val); |
| mAc.replyToMessage(msg, DcSwitchAsyncChannel.RSP_IS_IDLE_STATE, val ? 1 : 0); |
| break; |
| } |
| case DcSwitchAsyncChannel.REQ_IS_IDLE_OR_DETACHING_STATE: { |
| boolean val = (getCurrentState() == mIdleState || |
| getCurrentState() == mDetachingState); |
| if (VDBG) log("REQ_IS_IDLE_OR_DETACHING_STATE isIdleDetaching=" + val); |
| mAc.replyToMessage(msg, |
| DcSwitchAsyncChannel.RSP_IS_IDLE_OR_DETACHING_STATE, val ? 1 : 0); |
| break; |
| } |
| default: |
| if (DBG) { |
| log("DefaultState: shouldn't happen but ignore msg.what=0x" + |
| Integer.toHexString(msg.what)); |
| } |
| break; |
| } |
| return HANDLED; |
| } |
| } |
| |
| @Override |
| protected void log(String s) { |
| Rlog.d(LOG_TAG, "[" + getName() + "] " + s); |
| } |
| } |
