| /* |
| * 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. |
| */ |
| |
| package com.android.server.sip; |
| |
| import android.app.AppOpsManager; |
| import android.app.PendingIntent; |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.net.ConnectivityManager; |
| import android.net.NetworkInfo; |
| import android.net.sip.ISipService; |
| import android.net.sip.ISipSession; |
| import android.net.sip.ISipSessionListener; |
| import android.net.sip.SipErrorCode; |
| import android.net.sip.SipManager; |
| import android.net.sip.SipProfile; |
| import android.net.sip.SipSession; |
| import android.net.sip.SipSessionAdapter; |
| import android.net.wifi.WifiManager; |
| import android.os.Binder; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.PowerManager; |
| import android.os.Process; |
| import android.os.RemoteException; |
| import android.os.ServiceManager; |
| import android.os.SystemClock; |
| import android.telephony.Rlog; |
| |
| import java.io.IOException; |
| import java.net.DatagramSocket; |
| import java.net.InetAddress; |
| import java.net.UnknownHostException; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.concurrent.Executor; |
| import javax.sip.SipException; |
| |
| /** |
| * @hide |
| */ |
| public final class SipService extends ISipService.Stub { |
| static final String TAG = "SipService"; |
| static final boolean DBG = true; |
| private static final int EXPIRY_TIME = 3600; |
| private static final int SHORT_EXPIRY_TIME = 10; |
| private static final int MIN_EXPIRY_TIME = 60; |
| private static final int DEFAULT_KEEPALIVE_INTERVAL = 10; // in seconds |
| private static final int DEFAULT_MAX_KEEPALIVE_INTERVAL = 120; // in seconds |
| |
| private Context mContext; |
| private String mLocalIp; |
| private int mNetworkType = -1; |
| private SipWakeupTimer mTimer; |
| private WifiManager.WifiLock mWifiLock; |
| private boolean mSipOnWifiOnly; |
| |
| private final AppOpsManager mAppOps; |
| |
| private SipKeepAliveProcessCallback mSipKeepAliveProcessCallback; |
| |
| private MyExecutor mExecutor = new MyExecutor(); |
| |
| // SipProfile URI --> group |
| private Map<String, SipSessionGroupExt> mSipGroups = |
| new HashMap<String, SipSessionGroupExt>(); |
| |
| // session ID --> session |
| private Map<String, ISipSession> mPendingSessions = |
| new HashMap<String, ISipSession>(); |
| |
| private ConnectivityReceiver mConnectivityReceiver; |
| private SipWakeLock mMyWakeLock; |
| private int mKeepAliveInterval; |
| private int mLastGoodKeepAliveInterval = DEFAULT_KEEPALIVE_INTERVAL; |
| |
| /** |
| * Starts the SIP service. Do nothing if the SIP API is not supported on the |
| * device. |
| */ |
| public static void start(Context context) { |
| if (SipManager.isApiSupported(context)) { |
| if (ServiceManager.getService("sip") == null) { |
| ServiceManager.addService("sip", new SipService(context)); |
| context.sendBroadcast(new Intent(SipManager.ACTION_SIP_SERVICE_UP)); |
| if (DBG) slog("start:"); |
| } |
| } |
| } |
| |
| private SipService(Context context) { |
| if (DBG) log("SipService: started!"); |
| mContext = context; |
| mConnectivityReceiver = new ConnectivityReceiver(); |
| |
| mWifiLock = ((WifiManager) |
| context.getSystemService(Context.WIFI_SERVICE)) |
| .createWifiLock(WifiManager.WIFI_MODE_FULL, TAG); |
| mWifiLock.setReferenceCounted(false); |
| mSipOnWifiOnly = SipManager.isSipWifiOnly(context); |
| |
| mMyWakeLock = new SipWakeLock((PowerManager) |
| context.getSystemService(Context.POWER_SERVICE)); |
| |
| mTimer = new SipWakeupTimer(context, mExecutor); |
| mAppOps = mContext.getSystemService(AppOpsManager.class); |
| } |
| |
| @Override |
| public synchronized SipProfile[] getListOfProfiles(String opPackageName) { |
| if (!canUseSip(opPackageName, "getListOfProfiles")) { |
| return new SipProfile[0]; |
| } |
| boolean isCallerRadio = isCallerRadio(); |
| ArrayList<SipProfile> profiles = new ArrayList<SipProfile>(); |
| for (SipSessionGroupExt group : mSipGroups.values()) { |
| if (isCallerRadio || isCallerCreator(group)) { |
| profiles.add(group.getLocalProfile()); |
| } |
| } |
| return profiles.toArray(new SipProfile[profiles.size()]); |
| } |
| |
| @Override |
| public synchronized void open(SipProfile localProfile, String opPackageName) { |
| if (!canUseSip(opPackageName, "open")) { |
| return; |
| } |
| localProfile.setCallingUid(Binder.getCallingUid()); |
| try { |
| createGroup(localProfile); |
| } catch (SipException e) { |
| loge("openToMakeCalls()", e); |
| // TODO: how to send the exception back |
| } |
| } |
| |
| @Override |
| public synchronized void open3(SipProfile localProfile, |
| PendingIntent incomingCallPendingIntent, |
| ISipSessionListener listener, |
| String opPackageName) { |
| if (!canUseSip(opPackageName, "open3")) { |
| return; |
| } |
| localProfile.setCallingUid(Binder.getCallingUid()); |
| if (incomingCallPendingIntent == null) { |
| if (DBG) log("open3: incomingCallPendingIntent cannot be null; " |
| + "the profile is not opened"); |
| return; |
| } |
| if (DBG) log("open3: " + localProfile.getUriString() + ": " |
| + incomingCallPendingIntent + ": " + listener); |
| try { |
| SipSessionGroupExt group = createGroup(localProfile, |
| incomingCallPendingIntent, listener); |
| if (localProfile.getAutoRegistration()) { |
| group.openToReceiveCalls(); |
| updateWakeLocks(); |
| } |
| } catch (SipException e) { |
| loge("open3:", e); |
| // TODO: how to send the exception back |
| } |
| } |
| |
| private boolean isCallerCreator(SipSessionGroupExt group) { |
| SipProfile profile = group.getLocalProfile(); |
| return (profile.getCallingUid() == Binder.getCallingUid()); |
| } |
| |
| private boolean isCallerCreatorOrRadio(SipSessionGroupExt group) { |
| return (isCallerRadio() || isCallerCreator(group)); |
| } |
| |
| private boolean isCallerRadio() { |
| return (Binder.getCallingUid() == Process.PHONE_UID); |
| } |
| |
| @Override |
| public synchronized void close(String localProfileUri, String opPackageName) { |
| if (!canUseSip(opPackageName, "close")) { |
| return; |
| } |
| SipSessionGroupExt group = mSipGroups.get(localProfileUri); |
| if (group == null) return; |
| if (!isCallerCreatorOrRadio(group)) { |
| if (DBG) log("only creator or radio can close this profile"); |
| return; |
| } |
| |
| group = mSipGroups.remove(localProfileUri); |
| notifyProfileRemoved(group.getLocalProfile()); |
| group.close(); |
| |
| updateWakeLocks(); |
| } |
| |
| @Override |
| public synchronized boolean isOpened(String localProfileUri, String opPackageName) { |
| if (!canUseSip(opPackageName, "isOpened")) { |
| return false; |
| } |
| SipSessionGroupExt group = mSipGroups.get(localProfileUri); |
| if (group == null) return false; |
| if (isCallerCreatorOrRadio(group)) { |
| return true; |
| } else { |
| if (DBG) log("only creator or radio can query on the profile"); |
| return false; |
| } |
| } |
| |
| @Override |
| public synchronized boolean isRegistered(String localProfileUri, String opPackageName) { |
| if (!canUseSip(opPackageName, "isRegistered")) { |
| return false; |
| } |
| SipSessionGroupExt group = mSipGroups.get(localProfileUri); |
| if (group == null) return false; |
| if (isCallerCreatorOrRadio(group)) { |
| return group.isRegistered(); |
| } else { |
| if (DBG) log("only creator or radio can query on the profile"); |
| return false; |
| } |
| } |
| |
| @Override |
| public synchronized void setRegistrationListener(String localProfileUri, |
| ISipSessionListener listener, String opPackageName) { |
| if (!canUseSip(opPackageName, "setRegistrationListener")) { |
| return; |
| } |
| SipSessionGroupExt group = mSipGroups.get(localProfileUri); |
| if (group == null) return; |
| if (isCallerCreator(group)) { |
| group.setListener(listener); |
| } else { |
| if (DBG) log("only creator can set listener on the profile"); |
| } |
| } |
| |
| @Override |
| public synchronized ISipSession createSession(SipProfile localProfile, |
| ISipSessionListener listener, String opPackageName) { |
| if (DBG) log("createSession: profile" + localProfile); |
| if (!canUseSip(opPackageName, "createSession")) { |
| return null; |
| } |
| localProfile.setCallingUid(Binder.getCallingUid()); |
| if (mNetworkType == -1) { |
| if (DBG) log("createSession: mNetworkType==-1 ret=null"); |
| return null; |
| } |
| try { |
| SipSessionGroupExt group = createGroup(localProfile); |
| return group.createSession(listener); |
| } catch (SipException e) { |
| if (DBG) loge("createSession;", e); |
| return null; |
| } |
| } |
| |
| @Override |
| public synchronized ISipSession getPendingSession(String callId, String opPackageName) { |
| if (!canUseSip(opPackageName, "getPendingSession")) { |
| return null; |
| } |
| if (callId == null) return null; |
| return mPendingSessions.get(callId); |
| } |
| |
| private String determineLocalIp() { |
| try { |
| DatagramSocket s = new DatagramSocket(); |
| s.connect(InetAddress.getByName("192.168.1.1"), 80); |
| return s.getLocalAddress().getHostAddress(); |
| } catch (IOException e) { |
| if (DBG) loge("determineLocalIp()", e); |
| // dont do anything; there should be a connectivity change going |
| return null; |
| } |
| } |
| |
| private SipSessionGroupExt createGroup(SipProfile localProfile) |
| throws SipException { |
| String key = localProfile.getUriString(); |
| SipSessionGroupExt group = mSipGroups.get(key); |
| if (group == null) { |
| group = new SipSessionGroupExt(localProfile, null, null); |
| mSipGroups.put(key, group); |
| notifyProfileAdded(localProfile); |
| } else if (!isCallerCreator(group)) { |
| throw new SipException("only creator can access the profile"); |
| } |
| return group; |
| } |
| |
| private SipSessionGroupExt createGroup(SipProfile localProfile, |
| PendingIntent incomingCallPendingIntent, |
| ISipSessionListener listener) throws SipException { |
| String key = localProfile.getUriString(); |
| SipSessionGroupExt group = mSipGroups.get(key); |
| if (group != null) { |
| if (!isCallerCreator(group)) { |
| throw new SipException("only creator can access the profile"); |
| } |
| group.setIncomingCallPendingIntent(incomingCallPendingIntent); |
| group.setListener(listener); |
| } else { |
| group = new SipSessionGroupExt(localProfile, |
| incomingCallPendingIntent, listener); |
| mSipGroups.put(key, group); |
| notifyProfileAdded(localProfile); |
| } |
| return group; |
| } |
| |
| private void notifyProfileAdded(SipProfile localProfile) { |
| if (DBG) log("notify: profile added: " + localProfile); |
| Intent intent = new Intent(SipManager.ACTION_SIP_ADD_PHONE); |
| intent.putExtra(SipManager.EXTRA_LOCAL_URI, localProfile.getUriString()); |
| mContext.sendBroadcast(intent); |
| if (mSipGroups.size() == 1) { |
| registerReceivers(); |
| } |
| } |
| |
| private void notifyProfileRemoved(SipProfile localProfile) { |
| if (DBG) log("notify: profile removed: " + localProfile); |
| Intent intent = new Intent(SipManager.ACTION_SIP_REMOVE_PHONE); |
| intent.putExtra(SipManager.EXTRA_LOCAL_URI, localProfile.getUriString()); |
| mContext.sendBroadcast(intent); |
| if (mSipGroups.size() == 0) { |
| unregisterReceivers(); |
| } |
| } |
| |
| private void stopPortMappingMeasurement() { |
| if (mSipKeepAliveProcessCallback != null) { |
| mSipKeepAliveProcessCallback.stop(); |
| mSipKeepAliveProcessCallback = null; |
| } |
| } |
| |
| private void startPortMappingLifetimeMeasurement( |
| SipProfile localProfile) { |
| startPortMappingLifetimeMeasurement(localProfile, |
| DEFAULT_MAX_KEEPALIVE_INTERVAL); |
| } |
| |
| private void startPortMappingLifetimeMeasurement( |
| SipProfile localProfile, int maxInterval) { |
| if ((mSipKeepAliveProcessCallback == null) |
| && (mKeepAliveInterval == -1) |
| && isBehindNAT(mLocalIp)) { |
| if (DBG) log("startPortMappingLifetimeMeasurement: profile=" |
| + localProfile.getUriString()); |
| |
| int minInterval = mLastGoodKeepAliveInterval; |
| if (minInterval >= maxInterval) { |
| // If mLastGoodKeepAliveInterval also does not work, reset it |
| // to the default min |
| minInterval = mLastGoodKeepAliveInterval |
| = DEFAULT_KEEPALIVE_INTERVAL; |
| log(" reset min interval to " + minInterval); |
| } |
| mSipKeepAliveProcessCallback = new SipKeepAliveProcessCallback( |
| localProfile, minInterval, maxInterval); |
| mSipKeepAliveProcessCallback.start(); |
| } |
| } |
| |
| private void restartPortMappingLifetimeMeasurement( |
| SipProfile localProfile, int maxInterval) { |
| stopPortMappingMeasurement(); |
| mKeepAliveInterval = -1; |
| startPortMappingLifetimeMeasurement(localProfile, maxInterval); |
| } |
| |
| private synchronized void addPendingSession(ISipSession session) { |
| try { |
| cleanUpPendingSessions(); |
| mPendingSessions.put(session.getCallId(), session); |
| if (DBG) log("#pending sess=" + mPendingSessions.size()); |
| } catch (RemoteException e) { |
| // should not happen with a local call |
| loge("addPendingSession()", e); |
| } |
| } |
| |
| private void cleanUpPendingSessions() throws RemoteException { |
| Map.Entry<String, ISipSession>[] entries = |
| mPendingSessions.entrySet().toArray( |
| new Map.Entry[mPendingSessions.size()]); |
| for (Map.Entry<String, ISipSession> entry : entries) { |
| if (entry.getValue().getState() != SipSession.State.INCOMING_CALL) { |
| mPendingSessions.remove(entry.getKey()); |
| } |
| } |
| } |
| |
| private synchronized boolean callingSelf(SipSessionGroupExt ringingGroup, |
| SipSessionGroup.SipSessionImpl ringingSession) { |
| String callId = ringingSession.getCallId(); |
| for (SipSessionGroupExt group : mSipGroups.values()) { |
| if ((group != ringingGroup) && group.containsSession(callId)) { |
| if (DBG) log("call self: " |
| + ringingSession.getLocalProfile().getUriString() |
| + " -> " + group.getLocalProfile().getUriString()); |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private synchronized void onKeepAliveIntervalChanged() { |
| for (SipSessionGroupExt group : mSipGroups.values()) { |
| group.onKeepAliveIntervalChanged(); |
| } |
| } |
| |
| private int getKeepAliveInterval() { |
| return (mKeepAliveInterval < 0) |
| ? mLastGoodKeepAliveInterval |
| : mKeepAliveInterval; |
| } |
| |
| private boolean isBehindNAT(String address) { |
| try { |
| // TODO: How is isBehindNAT used and why these constanst address: |
| // 10.x.x.x | 192.168.x.x | 172.16.x.x .. 172.19.x.x |
| byte[] d = InetAddress.getByName(address).getAddress(); |
| if ((d[0] == 10) || |
| (((0x000000FF & d[0]) == 172) && |
| ((0x000000F0 & d[1]) == 16)) || |
| (((0x000000FF & d[0]) == 192) && |
| ((0x000000FF & d[1]) == 168))) { |
| return true; |
| } |
| } catch (UnknownHostException e) { |
| loge("isBehindAT()" + address, e); |
| } |
| return false; |
| } |
| |
| private boolean canUseSip(String packageName, String message) { |
| mContext.enforceCallingOrSelfPermission( |
| android.Manifest.permission.USE_SIP, message); |
| |
| return mAppOps.noteOp(AppOpsManager.OP_USE_SIP, Binder.getCallingUid(), |
| packageName) == AppOpsManager.MODE_ALLOWED; |
| } |
| |
| private class SipSessionGroupExt extends SipSessionAdapter { |
| private static final String SSGE_TAG = "SipSessionGroupExt"; |
| private static final boolean SSGE_DBG = true; |
| private SipSessionGroup mSipGroup; |
| private PendingIntent mIncomingCallPendingIntent; |
| private boolean mOpenedToReceiveCalls; |
| |
| private SipAutoReg mAutoRegistration = |
| new SipAutoReg(); |
| |
| public SipSessionGroupExt(SipProfile localProfile, |
| PendingIntent incomingCallPendingIntent, |
| ISipSessionListener listener) throws SipException { |
| if (SSGE_DBG) log("SipSessionGroupExt: profile=" + localProfile); |
| mSipGroup = new SipSessionGroup(duplicate(localProfile), |
| localProfile.getPassword(), mTimer, mMyWakeLock); |
| mIncomingCallPendingIntent = incomingCallPendingIntent; |
| mAutoRegistration.setListener(listener); |
| } |
| |
| public SipProfile getLocalProfile() { |
| return mSipGroup.getLocalProfile(); |
| } |
| |
| public boolean containsSession(String callId) { |
| return mSipGroup.containsSession(callId); |
| } |
| |
| public void onKeepAliveIntervalChanged() { |
| mAutoRegistration.onKeepAliveIntervalChanged(); |
| } |
| |
| // TODO: remove this method once SipWakeupTimer can better handle variety |
| // of timeout values |
| void setWakeupTimer(SipWakeupTimer timer) { |
| mSipGroup.setWakeupTimer(timer); |
| } |
| |
| private SipProfile duplicate(SipProfile p) { |
| try { |
| return new SipProfile.Builder(p).setPassword("*").build(); |
| } catch (Exception e) { |
| loge("duplicate()", e); |
| throw new RuntimeException("duplicate profile", e); |
| } |
| } |
| |
| public void setListener(ISipSessionListener listener) { |
| mAutoRegistration.setListener(listener); |
| } |
| |
| public void setIncomingCallPendingIntent(PendingIntent pIntent) { |
| mIncomingCallPendingIntent = pIntent; |
| } |
| |
| public void openToReceiveCalls() throws SipException { |
| mOpenedToReceiveCalls = true; |
| if (mNetworkType != -1) { |
| mSipGroup.openToReceiveCalls(this); |
| mAutoRegistration.start(mSipGroup); |
| } |
| if (SSGE_DBG) log("openToReceiveCalls: " + getUri() + ": " |
| + mIncomingCallPendingIntent); |
| } |
| |
| public void onConnectivityChanged(boolean connected) |
| throws SipException { |
| if (SSGE_DBG) { |
| log("onConnectivityChanged: connected=" + connected + " uri=" |
| + getUri() + ": " + mIncomingCallPendingIntent); |
| } |
| mSipGroup.onConnectivityChanged(); |
| if (connected) { |
| mSipGroup.reset(); |
| if (mOpenedToReceiveCalls) openToReceiveCalls(); |
| } else { |
| mSipGroup.close(); |
| mAutoRegistration.stop(); |
| } |
| } |
| |
| public void close() { |
| mOpenedToReceiveCalls = false; |
| mSipGroup.close(); |
| mAutoRegistration.stop(); |
| if (SSGE_DBG) log("close: " + getUri() + ": " + mIncomingCallPendingIntent); |
| } |
| |
| public ISipSession createSession(ISipSessionListener listener) { |
| if (SSGE_DBG) log("createSession"); |
| return mSipGroup.createSession(listener); |
| } |
| |
| @Override |
| public void onRinging(ISipSession s, SipProfile caller, |
| String sessionDescription) { |
| SipSessionGroup.SipSessionImpl session = |
| (SipSessionGroup.SipSessionImpl) s; |
| synchronized (SipService.this) { |
| try { |
| if (!isRegistered() || callingSelf(this, session)) { |
| if (SSGE_DBG) log("onRinging: end notReg or self"); |
| session.endCall(); |
| return; |
| } |
| |
| // send out incoming call broadcast |
| addPendingSession(session); |
| Intent intent = SipManager.createIncomingCallBroadcast( |
| session.getCallId(), sessionDescription); |
| if (SSGE_DBG) log("onRinging: uri=" + getUri() + ": " |
| + caller.getUri() + ": " + session.getCallId() |
| + " " + mIncomingCallPendingIntent); |
| mIncomingCallPendingIntent.send(mContext, |
| SipManager.INCOMING_CALL_RESULT_CODE, intent); |
| } catch (PendingIntent.CanceledException e) { |
| loge("onRinging: pendingIntent is canceled, drop incoming call", e); |
| session.endCall(); |
| } |
| } |
| } |
| |
| @Override |
| public void onError(ISipSession session, int errorCode, |
| String message) { |
| if (SSGE_DBG) log("onError: errorCode=" + errorCode + " desc=" |
| + SipErrorCode.toString(errorCode) + ": " + message); |
| } |
| |
| public boolean isOpenedToReceiveCalls() { |
| return mOpenedToReceiveCalls; |
| } |
| |
| public boolean isRegistered() { |
| return mAutoRegistration.isRegistered(); |
| } |
| |
| private String getUri() { |
| return mSipGroup.getLocalProfileUri(); |
| } |
| |
| private void log(String s) { |
| Rlog.d(SSGE_TAG, s); |
| } |
| |
| private void loge(String s, Throwable t) { |
| Rlog.e(SSGE_TAG, s, t); |
| } |
| |
| } |
| |
| private class SipKeepAliveProcessCallback implements Runnable, |
| SipSessionGroup.KeepAliveProcessCallback { |
| private static final String SKAI_TAG = "SipKeepAliveProcessCallback"; |
| private static final boolean SKAI_DBG = true; |
| private static final int MIN_INTERVAL = 5; // in seconds |
| private static final int PASS_THRESHOLD = 10; |
| private static final int NAT_MEASUREMENT_RETRY_INTERVAL = 120; // in seconds |
| private SipProfile mLocalProfile; |
| private SipSessionGroupExt mGroup; |
| private SipSessionGroup.SipSessionImpl mSession; |
| private int mMinInterval; |
| private int mMaxInterval; |
| private int mInterval; |
| private int mPassCount; |
| |
| public SipKeepAliveProcessCallback(SipProfile localProfile, |
| int minInterval, int maxInterval) { |
| mMaxInterval = maxInterval; |
| mMinInterval = minInterval; |
| mLocalProfile = localProfile; |
| } |
| |
| public void start() { |
| synchronized (SipService.this) { |
| if (mSession != null) { |
| return; |
| } |
| |
| mInterval = (mMaxInterval + mMinInterval) / 2; |
| mPassCount = 0; |
| |
| // Don't start measurement if the interval is too small |
| if (mInterval < DEFAULT_KEEPALIVE_INTERVAL || checkTermination()) { |
| if (SKAI_DBG) log("start: measurement aborted; interval=[" + |
| mMinInterval + "," + mMaxInterval + "]"); |
| return; |
| } |
| |
| try { |
| if (SKAI_DBG) log("start: interval=" + mInterval); |
| |
| mGroup = new SipSessionGroupExt(mLocalProfile, null, null); |
| // TODO: remove this line once SipWakeupTimer can better handle |
| // variety of timeout values |
| mGroup.setWakeupTimer(new SipWakeupTimer(mContext, mExecutor)); |
| |
| mSession = (SipSessionGroup.SipSessionImpl) |
| mGroup.createSession(null); |
| mSession.startKeepAliveProcess(mInterval, this); |
| } catch (Throwable t) { |
| onError(SipErrorCode.CLIENT_ERROR, t.toString()); |
| } |
| } |
| } |
| |
| public void stop() { |
| synchronized (SipService.this) { |
| if (mSession != null) { |
| mSession.stopKeepAliveProcess(); |
| mSession = null; |
| } |
| if (mGroup != null) { |
| mGroup.close(); |
| mGroup = null; |
| } |
| mTimer.cancel(this); |
| if (SKAI_DBG) log("stop"); |
| } |
| } |
| |
| private void restart() { |
| synchronized (SipService.this) { |
| // Return immediately if the measurement process is stopped |
| if (mSession == null) return; |
| |
| if (SKAI_DBG) log("restart: interval=" + mInterval); |
| try { |
| mSession.stopKeepAliveProcess(); |
| mPassCount = 0; |
| mSession.startKeepAliveProcess(mInterval, this); |
| } catch (SipException e) { |
| loge("restart", e); |
| } |
| } |
| } |
| |
| private boolean checkTermination() { |
| return ((mMaxInterval - mMinInterval) < MIN_INTERVAL); |
| } |
| |
| // SipSessionGroup.KeepAliveProcessCallback |
| @Override |
| public void onResponse(boolean portChanged) { |
| synchronized (SipService.this) { |
| if (!portChanged) { |
| if (++mPassCount != PASS_THRESHOLD) return; |
| // update the interval, since the current interval is good to |
| // keep the port mapping. |
| if (mKeepAliveInterval > 0) { |
| mLastGoodKeepAliveInterval = mKeepAliveInterval; |
| } |
| mKeepAliveInterval = mMinInterval = mInterval; |
| if (SKAI_DBG) { |
| log("onResponse: portChanged=" + portChanged + " mKeepAliveInterval=" |
| + mKeepAliveInterval); |
| } |
| onKeepAliveIntervalChanged(); |
| } else { |
| // Since the rport is changed, shorten the interval. |
| mMaxInterval = mInterval; |
| } |
| if (checkTermination()) { |
| // update mKeepAliveInterval and stop measurement. |
| stop(); |
| // If all the measurements failed, we still set it to |
| // mMinInterval; If mMinInterval still doesn't work, a new |
| // measurement with min interval=DEFAULT_KEEPALIVE_INTERVAL |
| // will be conducted. |
| mKeepAliveInterval = mMinInterval; |
| if (SKAI_DBG) { |
| log("onResponse: checkTermination mKeepAliveInterval=" |
| + mKeepAliveInterval); |
| } |
| } else { |
| // calculate the new interval and continue. |
| mInterval = (mMaxInterval + mMinInterval) / 2; |
| if (SKAI_DBG) { |
| log("onResponse: mKeepAliveInterval=" + mKeepAliveInterval |
| + ", new mInterval=" + mInterval); |
| } |
| restart(); |
| } |
| } |
| } |
| |
| // SipSessionGroup.KeepAliveProcessCallback |
| @Override |
| public void onError(int errorCode, String description) { |
| if (SKAI_DBG) loge("onError: errorCode=" + errorCode + " desc=" + description); |
| restartLater(); |
| } |
| |
| // timeout handler |
| @Override |
| public void run() { |
| mTimer.cancel(this); |
| restart(); |
| } |
| |
| private void restartLater() { |
| synchronized (SipService.this) { |
| int interval = NAT_MEASUREMENT_RETRY_INTERVAL; |
| mTimer.cancel(this); |
| mTimer.set(interval * 1000, this); |
| } |
| } |
| |
| private void log(String s) { |
| Rlog.d(SKAI_TAG, s); |
| } |
| |
| private void loge(String s) { |
| Rlog.d(SKAI_TAG, s); |
| } |
| |
| private void loge(String s, Throwable t) { |
| Rlog.d(SKAI_TAG, s, t); |
| } |
| } |
| |
| private class SipAutoReg extends SipSessionAdapter |
| implements Runnable, SipSessionGroup.KeepAliveProcessCallback { |
| private String SAR_TAG; |
| private static final boolean SAR_DBG = true; |
| private static final int MIN_KEEPALIVE_SUCCESS_COUNT = 10; |
| |
| private SipSessionGroup.SipSessionImpl mSession; |
| private SipSessionGroup.SipSessionImpl mKeepAliveSession; |
| private SipSessionListenerProxy mProxy = new SipSessionListenerProxy(); |
| private int mBackoff = 1; |
| private boolean mRegistered; |
| private long mExpiryTime; |
| private int mErrorCode; |
| private String mErrorMessage; |
| private boolean mRunning = false; |
| |
| private int mKeepAliveSuccessCount = 0; |
| |
| public void start(SipSessionGroup group) { |
| if (!mRunning) { |
| mRunning = true; |
| mBackoff = 1; |
| mSession = (SipSessionGroup.SipSessionImpl) |
| group.createSession(this); |
| // return right away if no active network connection. |
| if (mSession == null) return; |
| |
| // start unregistration to clear up old registration at server |
| // TODO: when rfc5626 is deployed, use reg-id and sip.instance |
| // in registration to avoid adding duplicate entries to server |
| mMyWakeLock.acquire(mSession); |
| mSession.unregister(); |
| SAR_TAG = "SipAutoReg:" + mSession.getLocalProfile().getUriString(); |
| if (SAR_DBG) log("start: group=" + group); |
| } |
| } |
| |
| private void startKeepAliveProcess(int interval) { |
| if (SAR_DBG) log("startKeepAliveProcess: interval=" + interval); |
| if (mKeepAliveSession == null) { |
| mKeepAliveSession = mSession.duplicate(); |
| } else { |
| mKeepAliveSession.stopKeepAliveProcess(); |
| } |
| try { |
| mKeepAliveSession.startKeepAliveProcess(interval, this); |
| } catch (SipException e) { |
| loge("startKeepAliveProcess: interval=" + interval, e); |
| } |
| } |
| |
| private void stopKeepAliveProcess() { |
| if (mKeepAliveSession != null) { |
| mKeepAliveSession.stopKeepAliveProcess(); |
| mKeepAliveSession = null; |
| } |
| mKeepAliveSuccessCount = 0; |
| } |
| |
| // SipSessionGroup.KeepAliveProcessCallback |
| @Override |
| public void onResponse(boolean portChanged) { |
| synchronized (SipService.this) { |
| if (portChanged) { |
| int interval = getKeepAliveInterval(); |
| if (mKeepAliveSuccessCount < MIN_KEEPALIVE_SUCCESS_COUNT) { |
| if (SAR_DBG) { |
| log("onResponse: keepalive doesn't work with interval " |
| + interval + ", past success count=" |
| + mKeepAliveSuccessCount); |
| } |
| if (interval > DEFAULT_KEEPALIVE_INTERVAL) { |
| restartPortMappingLifetimeMeasurement( |
| mSession.getLocalProfile(), interval); |
| mKeepAliveSuccessCount = 0; |
| } |
| } else { |
| if (SAR_DBG) { |
| log("keep keepalive going with interval " |
| + interval + ", past success count=" |
| + mKeepAliveSuccessCount); |
| } |
| mKeepAliveSuccessCount /= 2; |
| } |
| } else { |
| // Start keep-alive interval measurement on the first |
| // successfully kept-alive SipSessionGroup |
| startPortMappingLifetimeMeasurement( |
| mSession.getLocalProfile()); |
| mKeepAliveSuccessCount++; |
| } |
| |
| if (!mRunning || !portChanged) return; |
| |
| // The keep alive process is stopped when port is changed; |
| // Nullify the session so that the process can be restarted |
| // again when the re-registration is done |
| mKeepAliveSession = null; |
| |
| // Acquire wake lock for the registration process. The |
| // lock will be released when registration is complete. |
| mMyWakeLock.acquire(mSession); |
| mSession.register(EXPIRY_TIME); |
| } |
| } |
| |
| // SipSessionGroup.KeepAliveProcessCallback |
| @Override |
| public void onError(int errorCode, String description) { |
| if (SAR_DBG) { |
| loge("onError: errorCode=" + errorCode + " desc=" + description); |
| } |
| onResponse(true); // re-register immediately |
| } |
| |
| public void stop() { |
| if (!mRunning) return; |
| mRunning = false; |
| mMyWakeLock.release(mSession); |
| if (mSession != null) { |
| mSession.setListener(null); |
| if (mNetworkType != -1 && mRegistered) mSession.unregister(); |
| } |
| |
| mTimer.cancel(this); |
| stopKeepAliveProcess(); |
| |
| mRegistered = false; |
| setListener(mProxy.getListener()); |
| } |
| |
| public void onKeepAliveIntervalChanged() { |
| if (mKeepAliveSession != null) { |
| int newInterval = getKeepAliveInterval(); |
| if (SAR_DBG) { |
| log("onKeepAliveIntervalChanged: interval=" + newInterval); |
| } |
| mKeepAliveSuccessCount = 0; |
| startKeepAliveProcess(newInterval); |
| } |
| } |
| |
| public void setListener(ISipSessionListener listener) { |
| synchronized (SipService.this) { |
| mProxy.setListener(listener); |
| |
| try { |
| int state = (mSession == null) |
| ? SipSession.State.READY_TO_CALL |
| : mSession.getState(); |
| if ((state == SipSession.State.REGISTERING) |
| || (state == SipSession.State.DEREGISTERING)) { |
| mProxy.onRegistering(mSession); |
| } else if (mRegistered) { |
| int duration = (int) |
| (mExpiryTime - SystemClock.elapsedRealtime()); |
| mProxy.onRegistrationDone(mSession, duration); |
| } else if (mErrorCode != SipErrorCode.NO_ERROR) { |
| if (mErrorCode == SipErrorCode.TIME_OUT) { |
| mProxy.onRegistrationTimeout(mSession); |
| } else { |
| mProxy.onRegistrationFailed(mSession, mErrorCode, |
| mErrorMessage); |
| } |
| } else if (mNetworkType == -1) { |
| mProxy.onRegistrationFailed(mSession, |
| SipErrorCode.DATA_CONNECTION_LOST, |
| "no data connection"); |
| } else if (!mRunning) { |
| mProxy.onRegistrationFailed(mSession, |
| SipErrorCode.CLIENT_ERROR, |
| "registration not running"); |
| } else { |
| mProxy.onRegistrationFailed(mSession, |
| SipErrorCode.IN_PROGRESS, |
| String.valueOf(state)); |
| } |
| } catch (Throwable t) { |
| loge("setListener: ", t); |
| } |
| } |
| } |
| |
| public boolean isRegistered() { |
| return mRegistered; |
| } |
| |
| // timeout handler: re-register |
| @Override |
| public void run() { |
| synchronized (SipService.this) { |
| if (!mRunning) return; |
| |
| mErrorCode = SipErrorCode.NO_ERROR; |
| mErrorMessage = null; |
| if (SAR_DBG) log("run: registering"); |
| if (mNetworkType != -1) { |
| mMyWakeLock.acquire(mSession); |
| mSession.register(EXPIRY_TIME); |
| } |
| } |
| } |
| |
| private void restart(int duration) { |
| if (SAR_DBG) log("restart: duration=" + duration + "s later."); |
| mTimer.cancel(this); |
| mTimer.set(duration * 1000, this); |
| } |
| |
| private int backoffDuration() { |
| int duration = SHORT_EXPIRY_TIME * mBackoff; |
| if (duration > 3600) { |
| duration = 3600; |
| } else { |
| mBackoff *= 2; |
| } |
| return duration; |
| } |
| |
| @Override |
| public void onRegistering(ISipSession session) { |
| if (SAR_DBG) log("onRegistering: " + session); |
| synchronized (SipService.this) { |
| if (notCurrentSession(session)) return; |
| |
| mRegistered = false; |
| mProxy.onRegistering(session); |
| } |
| } |
| |
| private boolean notCurrentSession(ISipSession session) { |
| if (session != mSession) { |
| ((SipSessionGroup.SipSessionImpl) session).setListener(null); |
| mMyWakeLock.release(session); |
| return true; |
| } |
| return !mRunning; |
| } |
| |
| @Override |
| public void onRegistrationDone(ISipSession session, int duration) { |
| if (SAR_DBG) log("onRegistrationDone: " + session); |
| synchronized (SipService.this) { |
| if (notCurrentSession(session)) return; |
| |
| mProxy.onRegistrationDone(session, duration); |
| |
| if (duration > 0) { |
| mExpiryTime = SystemClock.elapsedRealtime() |
| + (duration * 1000); |
| |
| if (!mRegistered) { |
| mRegistered = true; |
| // allow some overlap to avoid call drop during renew |
| duration -= MIN_EXPIRY_TIME; |
| if (duration < MIN_EXPIRY_TIME) { |
| duration = MIN_EXPIRY_TIME; |
| } |
| restart(duration); |
| |
| SipProfile localProfile = mSession.getLocalProfile(); |
| if ((mKeepAliveSession == null) && (isBehindNAT(mLocalIp) |
| || localProfile.getSendKeepAlive())) { |
| startKeepAliveProcess(getKeepAliveInterval()); |
| } |
| } |
| mMyWakeLock.release(session); |
| } else { |
| mRegistered = false; |
| mExpiryTime = -1L; |
| if (SAR_DBG) log("Refresh registration immediately"); |
| run(); |
| } |
| } |
| } |
| |
| @Override |
| public void onRegistrationFailed(ISipSession session, int errorCode, |
| String message) { |
| if (SAR_DBG) log("onRegistrationFailed: " + session + ": " |
| + SipErrorCode.toString(errorCode) + ": " + message); |
| synchronized (SipService.this) { |
| if (notCurrentSession(session)) return; |
| |
| switch (errorCode) { |
| case SipErrorCode.INVALID_CREDENTIALS: |
| case SipErrorCode.SERVER_UNREACHABLE: |
| if (SAR_DBG) log(" pause auto-registration"); |
| stop(); |
| break; |
| default: |
| restartLater(); |
| } |
| |
| mErrorCode = errorCode; |
| mErrorMessage = message; |
| mProxy.onRegistrationFailed(session, errorCode, message); |
| mMyWakeLock.release(session); |
| } |
| } |
| |
| @Override |
| public void onRegistrationTimeout(ISipSession session) { |
| if (SAR_DBG) log("onRegistrationTimeout: " + session); |
| synchronized (SipService.this) { |
| if (notCurrentSession(session)) return; |
| |
| mErrorCode = SipErrorCode.TIME_OUT; |
| mProxy.onRegistrationTimeout(session); |
| restartLater(); |
| mMyWakeLock.release(session); |
| } |
| } |
| |
| private void restartLater() { |
| if (SAR_DBG) loge("restartLater"); |
| mRegistered = false; |
| restart(backoffDuration()); |
| } |
| |
| private void log(String s) { |
| Rlog.d(SAR_TAG, s); |
| } |
| |
| private void loge(String s) { |
| Rlog.e(SAR_TAG, s); |
| } |
| |
| private void loge(String s, Throwable e) { |
| Rlog.e(SAR_TAG, s, e); |
| } |
| } |
| |
| private class ConnectivityReceiver extends BroadcastReceiver { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| Bundle bundle = intent.getExtras(); |
| if (bundle != null) { |
| final NetworkInfo info = (NetworkInfo) |
| bundle.get(ConnectivityManager.EXTRA_NETWORK_INFO); |
| |
| // Run the handler in MyExecutor to be protected by wake lock |
| mExecutor.execute(new Runnable() { |
| @Override |
| public void run() { |
| onConnectivityChanged(info); |
| } |
| }); |
| } |
| } |
| } |
| |
| private void registerReceivers() { |
| mContext.registerReceiver(mConnectivityReceiver, |
| new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION)); |
| if (DBG) log("registerReceivers:"); |
| } |
| |
| private void unregisterReceivers() { |
| mContext.unregisterReceiver(mConnectivityReceiver); |
| if (DBG) log("unregisterReceivers:"); |
| |
| // Reset variables maintained by ConnectivityReceiver. |
| mWifiLock.release(); |
| mNetworkType = -1; |
| } |
| |
| private void updateWakeLocks() { |
| for (SipSessionGroupExt group : mSipGroups.values()) { |
| if (group.isOpenedToReceiveCalls()) { |
| // Also grab the WifiLock when we are disconnected, so the |
| // system will keep trying to reconnect. It will be released |
| // when the system eventually connects to something else. |
| if (mNetworkType == ConnectivityManager.TYPE_WIFI || mNetworkType == -1) { |
| mWifiLock.acquire(); |
| } else { |
| mWifiLock.release(); |
| } |
| return; |
| } |
| } |
| mWifiLock.release(); |
| mMyWakeLock.reset(); // in case there's a leak |
| } |
| |
| private synchronized void onConnectivityChanged(NetworkInfo info) { |
| // We only care about the default network, and getActiveNetworkInfo() |
| // is the only way to distinguish them. However, as broadcasts are |
| // delivered asynchronously, we might miss DISCONNECTED events from |
| // getActiveNetworkInfo(), which is critical to our SIP stack. To |
| // solve this, if it is a DISCONNECTED event to our current network, |
| // respect it. Otherwise get a new one from getActiveNetworkInfo(). |
| if (info == null || info.isConnected() || info.getType() != mNetworkType) { |
| ConnectivityManager cm = (ConnectivityManager) |
| mContext.getSystemService(Context.CONNECTIVITY_SERVICE); |
| info = cm.getActiveNetworkInfo(); |
| } |
| |
| // Some devices limit SIP on Wi-Fi. In this case, if we are not on |
| // Wi-Fi, treat it as a DISCONNECTED event. |
| int networkType = (info != null && info.isConnected()) ? info.getType() : -1; |
| if (mSipOnWifiOnly && networkType != ConnectivityManager.TYPE_WIFI) { |
| networkType = -1; |
| } |
| |
| // Ignore the event if the current active network is not changed. |
| if (mNetworkType == networkType) { |
| // TODO: Maybe we need to send seq/generation number |
| return; |
| } |
| if (DBG) { |
| log("onConnectivityChanged: " + mNetworkType + |
| " -> " + networkType); |
| } |
| |
| try { |
| if (mNetworkType != -1) { |
| mLocalIp = null; |
| stopPortMappingMeasurement(); |
| for (SipSessionGroupExt group : mSipGroups.values()) { |
| group.onConnectivityChanged(false); |
| } |
| } |
| mNetworkType = networkType; |
| |
| if (mNetworkType != -1) { |
| mLocalIp = determineLocalIp(); |
| mKeepAliveInterval = -1; |
| mLastGoodKeepAliveInterval = DEFAULT_KEEPALIVE_INTERVAL; |
| for (SipSessionGroupExt group : mSipGroups.values()) { |
| group.onConnectivityChanged(true); |
| } |
| } |
| updateWakeLocks(); |
| } catch (SipException e) { |
| loge("onConnectivityChanged()", e); |
| } |
| } |
| |
| private static Looper createLooper() { |
| HandlerThread thread = new HandlerThread("SipService.Executor"); |
| thread.start(); |
| return thread.getLooper(); |
| } |
| |
| // Executes immediate tasks in a single thread. |
| // Hold/release wake lock for running tasks |
| private class MyExecutor extends Handler implements Executor { |
| MyExecutor() { |
| super(createLooper()); |
| } |
| |
| @Override |
| public void execute(Runnable task) { |
| mMyWakeLock.acquire(task); |
| Message.obtain(this, 0/* don't care */, task).sendToTarget(); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| if (msg.obj instanceof Runnable) { |
| executeInternal((Runnable) msg.obj); |
| } else { |
| if (DBG) log("handleMessage: not Runnable ignore msg=" + msg); |
| } |
| } |
| |
| private void executeInternal(Runnable task) { |
| try { |
| task.run(); |
| } catch (Throwable t) { |
| loge("run task: " + task, t); |
| } finally { |
| mMyWakeLock.release(task); |
| } |
| } |
| } |
| |
| private void log(String s) { |
| Rlog.d(TAG, s); |
| } |
| |
| private static void slog(String s) { |
| Rlog.d(TAG, s); |
| } |
| |
| private void loge(String s, Throwable e) { |
| Rlog.e(TAG, s, e); |
| } |
| } |
