c7fda188ae
We need to be able to receive calls if the device is able to reassociate with any AP later on. Change-Id: Ib7aafb98386bf250ed9b5ec0a5b519594efa1649
1346 lines
49 KiB
Java
1346 lines
49 KiB
Java
/*
|
|
* 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.AlarmManager;
|
|
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.Process;
|
|
import android.os.RemoteException;
|
|
import android.os.ServiceManager;
|
|
import android.os.SystemClock;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
|
|
import java.io.IOException;
|
|
import java.net.DatagramSocket;
|
|
import java.net.InetAddress;
|
|
import java.net.UnknownHostException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.Timer;
|
|
import java.util.TimerTask;
|
|
import java.util.TreeSet;
|
|
import javax.sip.SipException;
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public final class SipService extends ISipService.Stub {
|
|
private static final String TAG = "SipService";
|
|
private static final boolean DEBUGV = false;
|
|
private static final boolean DEBUG = true;
|
|
private static final boolean DEBUG_TIMER = DEBUG && false;
|
|
private static final int EXPIRY_TIME = 3600;
|
|
private static final int SHORT_EXPIRY_TIME = 10;
|
|
private static final int MIN_EXPIRY_TIME = 60;
|
|
|
|
private Context mContext;
|
|
private String mLocalIp;
|
|
private String mNetworkType;
|
|
private boolean mConnected;
|
|
private WakeupTimer mTimer;
|
|
private WifiManager.WifiLock mWifiLock;
|
|
private boolean mWifiOnly;
|
|
|
|
private MyExecutor mExecutor;
|
|
|
|
// 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 boolean mScreenOn;
|
|
|
|
/**
|
|
* 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)) {
|
|
ServiceManager.addService("sip", new SipService(context));
|
|
context.sendBroadcast(new Intent(SipManager.ACTION_SIP_SERVICE_UP));
|
|
Log.i(TAG, "SIP service started");
|
|
}
|
|
}
|
|
|
|
private SipService(Context context) {
|
|
if (DEBUG) Log.d(TAG, " service started!");
|
|
mContext = context;
|
|
mConnectivityReceiver = new ConnectivityReceiver();
|
|
context.registerReceiver(mConnectivityReceiver,
|
|
new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
|
|
context.registerReceiver(mScreenOnOffReceiver,
|
|
new IntentFilter(Intent.ACTION_SCREEN_ON));
|
|
context.registerReceiver(mScreenOnOffReceiver,
|
|
new IntentFilter(Intent.ACTION_SCREEN_OFF));
|
|
|
|
mTimer = new WakeupTimer(context);
|
|
mWifiOnly = SipManager.isSipWifiOnly(context);
|
|
}
|
|
|
|
BroadcastReceiver mScreenOnOffReceiver = new BroadcastReceiver() {
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
String action = intent.getAction();
|
|
if (Intent.ACTION_SCREEN_OFF.equals(action)) {
|
|
mScreenOn = true;
|
|
} else if (Intent.ACTION_SCREEN_ON.equals(action)) {
|
|
mScreenOn = false;
|
|
}
|
|
}
|
|
};
|
|
|
|
private MyExecutor getExecutor() {
|
|
// create mExecutor lazily
|
|
if (mExecutor == null) mExecutor = new MyExecutor();
|
|
return mExecutor;
|
|
}
|
|
|
|
public synchronized SipProfile[] getListOfProfiles() {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, null);
|
|
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()]);
|
|
}
|
|
|
|
public void open(SipProfile localProfile) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, null);
|
|
localProfile.setCallingUid(Binder.getCallingUid());
|
|
try {
|
|
createGroup(localProfile);
|
|
} catch (SipException e) {
|
|
Log.e(TAG, "openToMakeCalls()", e);
|
|
// TODO: how to send the exception back
|
|
}
|
|
}
|
|
|
|
public synchronized void open3(SipProfile localProfile,
|
|
PendingIntent incomingCallPendingIntent,
|
|
ISipSessionListener listener) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, null);
|
|
localProfile.setCallingUid(Binder.getCallingUid());
|
|
if (incomingCallPendingIntent == null) {
|
|
Log.w(TAG, "incomingCallPendingIntent cannot be null; "
|
|
+ "the profile is not opened");
|
|
return;
|
|
}
|
|
if (DEBUG) Log.d(TAG, "open3: " + localProfile.getUriString() + ": "
|
|
+ incomingCallPendingIntent + ": " + listener);
|
|
try {
|
|
SipSessionGroupExt group = createGroup(localProfile,
|
|
incomingCallPendingIntent, listener);
|
|
if (localProfile.getAutoRegistration()) {
|
|
group.openToReceiveCalls();
|
|
if (isWifiActive()) grabWifiLock();
|
|
}
|
|
} catch (SipException e) {
|
|
Log.e(TAG, "openToReceiveCalls()", 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);
|
|
}
|
|
|
|
public synchronized void close(String localProfileUri) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, null);
|
|
SipSessionGroupExt group = mSipGroups.get(localProfileUri);
|
|
if (group == null) return;
|
|
if (!isCallerCreatorOrRadio(group)) {
|
|
Log.d(TAG, "only creator or radio can close this profile");
|
|
return;
|
|
}
|
|
|
|
group = mSipGroups.remove(localProfileUri);
|
|
notifyProfileRemoved(group.getLocalProfile());
|
|
group.close();
|
|
if (isWifiActive() && !anyOpened()) releaseWifiLock();
|
|
}
|
|
|
|
public synchronized boolean isOpened(String localProfileUri) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, null);
|
|
SipSessionGroupExt group = mSipGroups.get(localProfileUri);
|
|
if (group == null) return false;
|
|
if (isCallerCreatorOrRadio(group)) {
|
|
return group.isOpened();
|
|
} else {
|
|
Log.i(TAG, "only creator or radio can query on the profile");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public synchronized boolean isRegistered(String localProfileUri) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, null);
|
|
SipSessionGroupExt group = mSipGroups.get(localProfileUri);
|
|
if (group == null) return false;
|
|
if (isCallerCreatorOrRadio(group)) {
|
|
return group.isRegistered();
|
|
} else {
|
|
Log.i(TAG, "only creator or radio can query on the profile");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public synchronized void setRegistrationListener(String localProfileUri,
|
|
ISipSessionListener listener) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, null);
|
|
SipSessionGroupExt group = mSipGroups.get(localProfileUri);
|
|
if (group == null) return;
|
|
if (isCallerCreator(group)) {
|
|
group.setListener(listener);
|
|
} else {
|
|
Log.i(TAG, "only creator can set listener on the profile");
|
|
}
|
|
}
|
|
|
|
public synchronized ISipSession createSession(SipProfile localProfile,
|
|
ISipSessionListener listener) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, null);
|
|
localProfile.setCallingUid(Binder.getCallingUid());
|
|
if (!mConnected) return null;
|
|
try {
|
|
SipSessionGroupExt group = createGroup(localProfile);
|
|
return group.createSession(listener);
|
|
} catch (SipException e) {
|
|
Log.w(TAG, "createSession()", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public synchronized ISipSession getPendingSession(String callId) {
|
|
mContext.enforceCallingOrSelfPermission(
|
|
android.Manifest.permission.USE_SIP, 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) {
|
|
Log.w(TAG, "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 (DEBUG) Log.d(TAG, "notify: profile added: " + localProfile);
|
|
Intent intent = new Intent(SipManager.ACTION_SIP_ADD_PHONE);
|
|
intent.putExtra(SipManager.EXTRA_LOCAL_URI, localProfile.getUriString());
|
|
mContext.sendBroadcast(intent);
|
|
}
|
|
|
|
private void notifyProfileRemoved(SipProfile localProfile) {
|
|
if (DEBUG) Log.d(TAG, "notify: profile removed: " + localProfile);
|
|
Intent intent = new Intent(SipManager.ACTION_SIP_REMOVE_PHONE);
|
|
intent.putExtra(SipManager.EXTRA_LOCAL_URI, localProfile.getUriString());
|
|
mContext.sendBroadcast(intent);
|
|
}
|
|
|
|
private boolean anyOpened() {
|
|
for (SipSessionGroupExt group : mSipGroups.values()) {
|
|
if (group.isOpened()) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void grabWifiLock() {
|
|
if (mWifiLock == null) {
|
|
if (DEBUG) Log.d(TAG, "acquire wifi lock");
|
|
mWifiLock = ((WifiManager)
|
|
mContext.getSystemService(Context.WIFI_SERVICE))
|
|
.createWifiLock(WifiManager.WIFI_MODE_FULL, TAG);
|
|
mWifiLock.acquire();
|
|
}
|
|
}
|
|
|
|
private void releaseWifiLock() {
|
|
if (mWifiLock != null) {
|
|
if (DEBUG) Log.d(TAG, "release wifi lock");
|
|
mWifiLock.release();
|
|
mWifiLock = null;
|
|
}
|
|
}
|
|
|
|
private boolean isWifiActive() {
|
|
return "WIFI".equalsIgnoreCase(mNetworkType);
|
|
}
|
|
|
|
private synchronized void onConnectivityChanged(
|
|
String type, boolean connected) {
|
|
if (DEBUG) Log.d(TAG, "onConnectivityChanged(): "
|
|
+ mNetworkType + (mConnected? " CONNECTED" : " DISCONNECTED")
|
|
+ " --> " + type + (connected? " CONNECTED" : " DISCONNECTED"));
|
|
|
|
boolean sameType = type.equals(mNetworkType);
|
|
if (!sameType && !connected) return;
|
|
|
|
boolean wasWifi = "WIFI".equalsIgnoreCase(mNetworkType);
|
|
boolean isWifi = "WIFI".equalsIgnoreCase(type);
|
|
boolean wifiOff = (isWifi && !connected) || (wasWifi && !sameType);
|
|
boolean wifiOn = isWifi && connected;
|
|
if (wifiOff) {
|
|
if (mScreenOn) releaseWifiLock();
|
|
// If the screen is off, we still keep the wifi lock in order
|
|
// to be able to reassociate with any available AP. Otherwise,
|
|
// the wifi driver could be stopped after 15 mins of idle time.
|
|
} else if (wifiOn) {
|
|
if (anyOpened()) grabWifiLock();
|
|
}
|
|
|
|
try {
|
|
boolean wasConnected = mConnected;
|
|
mNetworkType = type;
|
|
mConnected = connected;
|
|
|
|
if (wasConnected) {
|
|
mLocalIp = null;
|
|
for (SipSessionGroupExt group : mSipGroups.values()) {
|
|
group.onConnectivityChanged(false);
|
|
}
|
|
}
|
|
|
|
if (connected) {
|
|
mLocalIp = determineLocalIp();
|
|
for (SipSessionGroupExt group : mSipGroups.values()) {
|
|
group.onConnectivityChanged(true);
|
|
}
|
|
}
|
|
|
|
} catch (SipException e) {
|
|
Log.e(TAG, "onConnectivityChanged()", e);
|
|
}
|
|
}
|
|
|
|
private synchronized void addPendingSession(ISipSession session) {
|
|
try {
|
|
mPendingSessions.put(session.getCallId(), session);
|
|
} catch (RemoteException e) {
|
|
// should not happen with a local call
|
|
Log.e(TAG, "addPendingSession()", e);
|
|
}
|
|
}
|
|
|
|
private class SipSessionGroupExt extends SipSessionAdapter {
|
|
private SipSessionGroup mSipGroup;
|
|
private PendingIntent mIncomingCallPendingIntent;
|
|
private boolean mOpened;
|
|
|
|
private AutoRegistrationProcess mAutoRegistration =
|
|
new AutoRegistrationProcess();
|
|
|
|
public SipSessionGroupExt(SipProfile localProfile,
|
|
PendingIntent incomingCallPendingIntent,
|
|
ISipSessionListener listener) throws SipException {
|
|
String password = localProfile.getPassword();
|
|
SipProfile p = duplicate(localProfile);
|
|
mSipGroup = createSipSessionGroup(mLocalIp, p, password);
|
|
mIncomingCallPendingIntent = incomingCallPendingIntent;
|
|
mAutoRegistration.setListener(listener);
|
|
}
|
|
|
|
public SipProfile getLocalProfile() {
|
|
return mSipGroup.getLocalProfile();
|
|
}
|
|
|
|
// network connectivity is tricky because network can be disconnected
|
|
// at any instant so need to deal with exceptions carefully even when
|
|
// you think you are connected
|
|
private SipSessionGroup createSipSessionGroup(String localIp,
|
|
SipProfile localProfile, String password) throws SipException {
|
|
try {
|
|
return new SipSessionGroup(localIp, localProfile, password);
|
|
} catch (IOException e) {
|
|
// network disconnected
|
|
Log.w(TAG, "createSipSessionGroup(): network disconnected?");
|
|
if (localIp != null) {
|
|
return createSipSessionGroup(null, localProfile, password);
|
|
} else {
|
|
// recursive
|
|
Log.wtf(TAG, "impossible!");
|
|
throw new RuntimeException("createSipSessionGroup");
|
|
}
|
|
}
|
|
}
|
|
|
|
private SipProfile duplicate(SipProfile p) {
|
|
try {
|
|
return new SipProfile.Builder(p).setPassword("*").build();
|
|
} catch (Exception e) {
|
|
Log.wtf(TAG, "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 {
|
|
mOpened = true;
|
|
if (mConnected) {
|
|
mSipGroup.openToReceiveCalls(this);
|
|
mAutoRegistration.start(mSipGroup);
|
|
}
|
|
if (DEBUG) Log.d(TAG, " openToReceiveCalls: " + getUri() + ": "
|
|
+ mIncomingCallPendingIntent);
|
|
}
|
|
|
|
public void onConnectivityChanged(boolean connected)
|
|
throws SipException {
|
|
mSipGroup.onConnectivityChanged();
|
|
if (connected) {
|
|
resetGroup(mLocalIp);
|
|
if (mOpened) openToReceiveCalls();
|
|
} else {
|
|
// close mSipGroup but remember mOpened
|
|
if (DEBUG) Log.d(TAG, " close auto reg temporarily: "
|
|
+ getUri() + ": " + mIncomingCallPendingIntent);
|
|
mSipGroup.close();
|
|
mAutoRegistration.stop();
|
|
}
|
|
}
|
|
|
|
private void resetGroup(String localIp) throws SipException {
|
|
try {
|
|
mSipGroup.reset(localIp);
|
|
} catch (IOException e) {
|
|
// network disconnected
|
|
Log.w(TAG, "resetGroup(): network disconnected?");
|
|
if (localIp != null) {
|
|
resetGroup(null); // reset w/o local IP
|
|
} else {
|
|
// recursive
|
|
Log.wtf(TAG, "impossible!");
|
|
throw new RuntimeException("resetGroup");
|
|
}
|
|
}
|
|
}
|
|
|
|
public void close() {
|
|
mOpened = false;
|
|
mSipGroup.close();
|
|
mAutoRegistration.stop();
|
|
if (DEBUG) Log.d(TAG, " close: " + getUri() + ": "
|
|
+ mIncomingCallPendingIntent);
|
|
}
|
|
|
|
public ISipSession createSession(ISipSessionListener listener) {
|
|
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()) {
|
|
session.endCall();
|
|
return;
|
|
}
|
|
|
|
// send out incoming call broadcast
|
|
addPendingSession(session);
|
|
Intent intent = SipManager.createIncomingCallBroadcast(
|
|
session.getCallId(), sessionDescription);
|
|
if (DEBUG) Log.d(TAG, " ringing~~ " + getUri() + ": "
|
|
+ caller.getUri() + ": " + session.getCallId()
|
|
+ " " + mIncomingCallPendingIntent);
|
|
mIncomingCallPendingIntent.send(mContext,
|
|
SipManager.INCOMING_CALL_RESULT_CODE, intent);
|
|
} catch (PendingIntent.CanceledException e) {
|
|
Log.w(TAG, "pendingIntent is canceled, drop incoming call");
|
|
session.endCall();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onError(ISipSession session, int errorCode,
|
|
String message) {
|
|
if (DEBUG) Log.d(TAG, "sip session error: "
|
|
+ SipErrorCode.toString(errorCode) + ": " + message);
|
|
}
|
|
|
|
public boolean isOpened() {
|
|
return mOpened;
|
|
}
|
|
|
|
public boolean isRegistered() {
|
|
return mAutoRegistration.isRegistered();
|
|
}
|
|
|
|
private String getUri() {
|
|
return mSipGroup.getLocalProfileUri();
|
|
}
|
|
}
|
|
|
|
// KeepAliveProcess is controlled by AutoRegistrationProcess.
|
|
// All methods will be invoked in sync with SipService.this except realRun()
|
|
private class KeepAliveProcess implements Runnable {
|
|
private static final String TAG = "\\KEEPALIVE/";
|
|
private static final int INTERVAL = 10;
|
|
private SipSessionGroup.SipSessionImpl mSession;
|
|
private boolean mRunning = false;
|
|
|
|
public KeepAliveProcess(SipSessionGroup.SipSessionImpl session) {
|
|
mSession = session;
|
|
}
|
|
|
|
public void start() {
|
|
if (mRunning) return;
|
|
mRunning = true;
|
|
mTimer.set(INTERVAL * 1000, this);
|
|
}
|
|
|
|
// timeout handler
|
|
public void run() {
|
|
if (!mRunning) return;
|
|
final SipSessionGroup.SipSessionImpl session = mSession;
|
|
|
|
// delegate to mExecutor
|
|
getExecutor().addTask(new Runnable() {
|
|
public void run() {
|
|
realRun(session);
|
|
}
|
|
});
|
|
}
|
|
|
|
// real timeout handler
|
|
private void realRun(SipSessionGroup.SipSessionImpl session) {
|
|
synchronized (SipService.this) {
|
|
if (notCurrentSession(session)) return;
|
|
|
|
session = session.duplicate();
|
|
if (DEBUGV) Log.v(TAG, "~~~ keepalive");
|
|
mTimer.cancel(this);
|
|
session.sendKeepAlive();
|
|
if (session.isReRegisterRequired()) {
|
|
mSession.register(EXPIRY_TIME);
|
|
} else {
|
|
mTimer.set(INTERVAL * 1000, this);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stop() {
|
|
mRunning = false;
|
|
mSession = null;
|
|
mTimer.cancel(this);
|
|
}
|
|
|
|
private boolean notCurrentSession(ISipSession session) {
|
|
return (session != mSession) || !mRunning;
|
|
}
|
|
}
|
|
|
|
private class AutoRegistrationProcess extends SipSessionAdapter
|
|
implements Runnable {
|
|
private SipSessionGroup.SipSessionImpl mSession;
|
|
private SipSessionListenerProxy mProxy = new SipSessionListenerProxy();
|
|
private KeepAliveProcess mKeepAliveProcess;
|
|
private int mBackoff = 1;
|
|
private boolean mRegistered;
|
|
private long mExpiryTime;
|
|
private int mErrorCode;
|
|
private String mErrorMessage;
|
|
private boolean mRunning = false;
|
|
|
|
private String getAction() {
|
|
return toString();
|
|
}
|
|
|
|
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
|
|
mSession.unregister();
|
|
if (DEBUG) Log.d(TAG, "start AutoRegistrationProcess for "
|
|
+ mSession.getLocalProfile().getUriString());
|
|
}
|
|
}
|
|
|
|
public void stop() {
|
|
if (!mRunning) return;
|
|
mRunning = false;
|
|
mSession.setListener(null);
|
|
if (mConnected && mRegistered) mSession.unregister();
|
|
|
|
mTimer.cancel(this);
|
|
if (mKeepAliveProcess != null) {
|
|
mKeepAliveProcess.stop();
|
|
mKeepAliveProcess = null;
|
|
}
|
|
|
|
mRegistered = false;
|
|
setListener(mProxy.getListener());
|
|
}
|
|
|
|
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 (!mConnected) {
|
|
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) {
|
|
Log.w(TAG, "setListener(): " + t);
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean isRegistered() {
|
|
return mRegistered;
|
|
}
|
|
|
|
// timeout handler
|
|
public void run() {
|
|
synchronized (SipService.this) {
|
|
if (!mRunning) return;
|
|
final SipSessionGroup.SipSessionImpl session = mSession;
|
|
|
|
// delegate to mExecutor
|
|
getExecutor().addTask(new Runnable() {
|
|
public void run() {
|
|
realRun(session);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
// real timeout handler
|
|
private void realRun(SipSessionGroup.SipSessionImpl session) {
|
|
synchronized (SipService.this) {
|
|
if (notCurrentSession(session)) return;
|
|
mErrorCode = SipErrorCode.NO_ERROR;
|
|
mErrorMessage = null;
|
|
if (DEBUG) Log.d(TAG, "~~~ registering");
|
|
if (mConnected) session.register(EXPIRY_TIME);
|
|
}
|
|
}
|
|
|
|
private boolean isBehindNAT(String address) {
|
|
try {
|
|
byte[] d = InetAddress.getByName(address).getAddress();
|
|
if ((d[0] == 10) ||
|
|
(((0x000000FF & ((int)d[0])) == 172) &&
|
|
((0x000000F0 & ((int)d[1])) == 16)) ||
|
|
(((0x000000FF & ((int)d[0])) == 192) &&
|
|
((0x000000FF & ((int)d[1])) == 168))) {
|
|
return true;
|
|
}
|
|
} catch (UnknownHostException e) {
|
|
Log.e(TAG, "isBehindAT()" + address, e);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void restart(int duration) {
|
|
if (DEBUG) Log.d(TAG, "Refresh registration " + 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 (DEBUG) Log.d(TAG, "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);
|
|
return true;
|
|
}
|
|
return !mRunning;
|
|
}
|
|
|
|
@Override
|
|
public void onRegistrationDone(ISipSession session, int duration) {
|
|
if (DEBUG) Log.d(TAG, "onRegistrationDone(): " + session);
|
|
synchronized (SipService.this) {
|
|
if (notCurrentSession(session)) return;
|
|
|
|
mProxy.onRegistrationDone(session, duration);
|
|
|
|
if (duration > 0) {
|
|
mSession.clearReRegisterRequired();
|
|
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);
|
|
|
|
if (isBehindNAT(mLocalIp) ||
|
|
mSession.getLocalProfile().getSendKeepAlive()) {
|
|
if (mKeepAliveProcess == null) {
|
|
mKeepAliveProcess =
|
|
new KeepAliveProcess(mSession);
|
|
}
|
|
mKeepAliveProcess.start();
|
|
}
|
|
}
|
|
} else {
|
|
mRegistered = false;
|
|
mExpiryTime = -1L;
|
|
if (DEBUG) Log.d(TAG, "Refresh registration immediately");
|
|
run();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onRegistrationFailed(ISipSession session, int errorCode,
|
|
String message) {
|
|
if (DEBUG) Log.d(TAG, "onRegistrationFailed(): " + session + ": "
|
|
+ SipErrorCode.toString(errorCode) + ": " + message);
|
|
synchronized (SipService.this) {
|
|
if (notCurrentSession(session)) return;
|
|
|
|
switch (errorCode) {
|
|
case SipErrorCode.INVALID_CREDENTIALS:
|
|
case SipErrorCode.SERVER_UNREACHABLE:
|
|
if (DEBUG) Log.d(TAG, " pause auto-registration");
|
|
stop();
|
|
default:
|
|
restartLater();
|
|
}
|
|
|
|
mErrorCode = errorCode;
|
|
mErrorMessage = message;
|
|
mProxy.onRegistrationFailed(session, errorCode, message);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onRegistrationTimeout(ISipSession session) {
|
|
if (DEBUG) Log.d(TAG, "onRegistrationTimeout(): " + session);
|
|
synchronized (SipService.this) {
|
|
if (notCurrentSession(session)) return;
|
|
|
|
mErrorCode = SipErrorCode.TIME_OUT;
|
|
mProxy.onRegistrationTimeout(session);
|
|
restartLater();
|
|
}
|
|
}
|
|
|
|
private void restartLater() {
|
|
mRegistered = false;
|
|
restart(backoffDuration());
|
|
if (mKeepAliveProcess != null) {
|
|
mKeepAliveProcess.stop();
|
|
mKeepAliveProcess = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private class ConnectivityReceiver extends BroadcastReceiver {
|
|
private Timer mTimer = new Timer();
|
|
private MyTimerTask mTask;
|
|
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
String action = intent.getAction();
|
|
if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
|
|
Bundle b = intent.getExtras();
|
|
if (b != null) {
|
|
NetworkInfo netInfo = (NetworkInfo)
|
|
b.get(ConnectivityManager.EXTRA_NETWORK_INFO);
|
|
String type = netInfo.getTypeName();
|
|
NetworkInfo.State state = netInfo.getState();
|
|
|
|
if (mWifiOnly && (netInfo.getType() !=
|
|
ConnectivityManager.TYPE_WIFI)) {
|
|
if (DEBUG) {
|
|
Log.d(TAG, "Wifi only, other connectivity ignored: "
|
|
+ type);
|
|
}
|
|
return;
|
|
}
|
|
|
|
NetworkInfo activeNetInfo = getActiveNetworkInfo();
|
|
if (DEBUG) {
|
|
if (activeNetInfo != null) {
|
|
Log.d(TAG, "active network: "
|
|
+ activeNetInfo.getTypeName()
|
|
+ ((activeNetInfo.getState() == NetworkInfo.State.CONNECTED)
|
|
? " CONNECTED" : " DISCONNECTED"));
|
|
} else {
|
|
Log.d(TAG, "active network: null");
|
|
}
|
|
}
|
|
if ((state == NetworkInfo.State.CONNECTED)
|
|
&& (activeNetInfo != null)
|
|
&& (activeNetInfo.getType() != netInfo.getType())) {
|
|
if (DEBUG) Log.d(TAG, "ignore connect event: " + type
|
|
+ ", active: " + activeNetInfo.getTypeName());
|
|
return;
|
|
}
|
|
|
|
if (state == NetworkInfo.State.CONNECTED) {
|
|
if (DEBUG) Log.d(TAG, "Connectivity alert: CONNECTED " + type);
|
|
onChanged(type, true);
|
|
} else if (state == NetworkInfo.State.DISCONNECTED) {
|
|
if (DEBUG) Log.d(TAG, "Connectivity alert: DISCONNECTED " + type);
|
|
onChanged(type, false);
|
|
} else {
|
|
if (DEBUG) Log.d(TAG, "Connectivity alert not processed: "
|
|
+ state + " " + type);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private NetworkInfo getActiveNetworkInfo() {
|
|
ConnectivityManager cm = (ConnectivityManager)
|
|
mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
|
|
return cm.getActiveNetworkInfo();
|
|
}
|
|
|
|
private void onChanged(String type, boolean connected) {
|
|
synchronized (SipService.this) {
|
|
// When turning on WIFI, it needs some time for network
|
|
// connectivity to get stabile so we defer good news (because
|
|
// we want to skip the interim ones) but deliver bad news
|
|
// immediately
|
|
if (connected) {
|
|
if (mTask != null) mTask.cancel();
|
|
mTask = new MyTimerTask(type, connected);
|
|
mTimer.schedule(mTask, 2 * 1000L);
|
|
// TODO: hold wakup lock so that we can finish change before
|
|
// the device goes to sleep
|
|
} else {
|
|
if ((mTask != null) && mTask.mNetworkType.equals(type)) {
|
|
mTask.cancel();
|
|
}
|
|
onConnectivityChanged(type, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private class MyTimerTask extends TimerTask {
|
|
private boolean mConnected;
|
|
private String mNetworkType;
|
|
|
|
public MyTimerTask(String type, boolean connected) {
|
|
mNetworkType = type;
|
|
mConnected = connected;
|
|
}
|
|
|
|
// timeout handler
|
|
@Override
|
|
public void run() {
|
|
// delegate to mExecutor
|
|
getExecutor().addTask(new Runnable() {
|
|
public void run() {
|
|
realRun();
|
|
}
|
|
});
|
|
}
|
|
|
|
private void realRun() {
|
|
synchronized (SipService.this) {
|
|
if (mTask != this) {
|
|
Log.w(TAG, " unexpected task: " + mNetworkType
|
|
+ (mConnected ? " CONNECTED" : "DISCONNECTED"));
|
|
return;
|
|
}
|
|
mTask = null;
|
|
if (DEBUG) Log.d(TAG, " deliver change for " + mNetworkType
|
|
+ (mConnected ? " CONNECTED" : "DISCONNECTED"));
|
|
onConnectivityChanged(mNetworkType, mConnected);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// TODO: clean up pending SipSession(s) periodically
|
|
|
|
|
|
/**
|
|
* Timer that can schedule events to occur even when the device is in sleep.
|
|
* Only used internally in this package.
|
|
*/
|
|
class WakeupTimer extends BroadcastReceiver {
|
|
private static final String TAG = "_SIP.WkTimer_";
|
|
private static final String TRIGGER_TIME = "TriggerTime";
|
|
|
|
private Context mContext;
|
|
private AlarmManager mAlarmManager;
|
|
|
|
// runnable --> time to execute in SystemClock
|
|
private TreeSet<MyEvent> mEventQueue =
|
|
new TreeSet<MyEvent>(new MyEventComparator());
|
|
|
|
private PendingIntent mPendingIntent;
|
|
|
|
public WakeupTimer(Context context) {
|
|
mContext = context;
|
|
mAlarmManager = (AlarmManager)
|
|
context.getSystemService(Context.ALARM_SERVICE);
|
|
|
|
IntentFilter filter = new IntentFilter(getAction());
|
|
context.registerReceiver(this, filter);
|
|
}
|
|
|
|
/**
|
|
* Stops the timer. No event can be scheduled after this method is called.
|
|
*/
|
|
public synchronized void stop() {
|
|
mContext.unregisterReceiver(this);
|
|
if (mPendingIntent != null) {
|
|
mAlarmManager.cancel(mPendingIntent);
|
|
mPendingIntent = null;
|
|
}
|
|
mEventQueue.clear();
|
|
mEventQueue = null;
|
|
}
|
|
|
|
private synchronized boolean stopped() {
|
|
if (mEventQueue == null) {
|
|
Log.w(TAG, "Timer stopped");
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private void cancelAlarm() {
|
|
mAlarmManager.cancel(mPendingIntent);
|
|
mPendingIntent = null;
|
|
}
|
|
|
|
private void recalculatePeriods() {
|
|
if (mEventQueue.isEmpty()) return;
|
|
|
|
MyEvent firstEvent = mEventQueue.first();
|
|
int minPeriod = firstEvent.mMaxPeriod;
|
|
long minTriggerTime = firstEvent.mTriggerTime;
|
|
for (MyEvent e : mEventQueue) {
|
|
e.mPeriod = e.mMaxPeriod / minPeriod * minPeriod;
|
|
int interval = (int) (e.mLastTriggerTime + e.mMaxPeriod
|
|
- minTriggerTime);
|
|
interval = interval / minPeriod * minPeriod;
|
|
e.mTriggerTime = minTriggerTime + interval;
|
|
}
|
|
TreeSet<MyEvent> newQueue = new TreeSet<MyEvent>(
|
|
mEventQueue.comparator());
|
|
newQueue.addAll((Collection<MyEvent>) mEventQueue);
|
|
mEventQueue.clear();
|
|
mEventQueue = newQueue;
|
|
if (DEBUG_TIMER) {
|
|
Log.d(TAG, "queue re-calculated");
|
|
printQueue();
|
|
}
|
|
}
|
|
|
|
// Determines the period and the trigger time of the new event and insert it
|
|
// to the queue.
|
|
private void insertEvent(MyEvent event) {
|
|
long now = SystemClock.elapsedRealtime();
|
|
if (mEventQueue.isEmpty()) {
|
|
event.mTriggerTime = now + event.mPeriod;
|
|
mEventQueue.add(event);
|
|
return;
|
|
}
|
|
MyEvent firstEvent = mEventQueue.first();
|
|
int minPeriod = firstEvent.mPeriod;
|
|
if (minPeriod <= event.mMaxPeriod) {
|
|
event.mPeriod = event.mMaxPeriod / minPeriod * minPeriod;
|
|
int interval = event.mMaxPeriod;
|
|
interval -= (int) (firstEvent.mTriggerTime - now);
|
|
interval = interval / minPeriod * minPeriod;
|
|
event.mTriggerTime = firstEvent.mTriggerTime + interval;
|
|
mEventQueue.add(event);
|
|
} else {
|
|
long triggerTime = now + event.mPeriod;
|
|
if (firstEvent.mTriggerTime < triggerTime) {
|
|
event.mTriggerTime = firstEvent.mTriggerTime;
|
|
event.mLastTriggerTime -= event.mPeriod;
|
|
} else {
|
|
event.mTriggerTime = triggerTime;
|
|
}
|
|
mEventQueue.add(event);
|
|
recalculatePeriods();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets a periodic timer.
|
|
*
|
|
* @param period the timer period; in milli-second
|
|
* @param callback is called back when the timer goes off; the same callback
|
|
* can be specified in multiple timer events
|
|
*/
|
|
public synchronized void set(int period, Runnable callback) {
|
|
if (stopped()) return;
|
|
|
|
long now = SystemClock.elapsedRealtime();
|
|
MyEvent event = new MyEvent(period, callback, now);
|
|
insertEvent(event);
|
|
|
|
if (mEventQueue.first() == event) {
|
|
if (mEventQueue.size() > 1) cancelAlarm();
|
|
scheduleNext();
|
|
}
|
|
|
|
long triggerTime = event.mTriggerTime;
|
|
if (DEBUG_TIMER) {
|
|
Log.d(TAG, " add event " + event + " scheduled at "
|
|
+ showTime(triggerTime) + " at " + showTime(now)
|
|
+ ", #events=" + mEventQueue.size());
|
|
printQueue();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Cancels all the timer events with the specified callback.
|
|
*
|
|
* @param callback the callback
|
|
*/
|
|
public synchronized void cancel(Runnable callback) {
|
|
if (stopped() || mEventQueue.isEmpty()) return;
|
|
if (DEBUG_TIMER) Log.d(TAG, "cancel:" + callback);
|
|
|
|
MyEvent firstEvent = mEventQueue.first();
|
|
for (Iterator<MyEvent> iter = mEventQueue.iterator();
|
|
iter.hasNext();) {
|
|
MyEvent event = iter.next();
|
|
if (event.mCallback == callback) {
|
|
iter.remove();
|
|
if (DEBUG_TIMER) Log.d(TAG, " cancel found:" + event);
|
|
}
|
|
}
|
|
if (mEventQueue.isEmpty()) {
|
|
cancelAlarm();
|
|
} else if (mEventQueue.first() != firstEvent) {
|
|
cancelAlarm();
|
|
firstEvent = mEventQueue.first();
|
|
firstEvent.mPeriod = firstEvent.mMaxPeriod;
|
|
firstEvent.mTriggerTime = firstEvent.mLastTriggerTime
|
|
+ firstEvent.mPeriod;
|
|
recalculatePeriods();
|
|
scheduleNext();
|
|
}
|
|
if (DEBUG_TIMER) {
|
|
Log.d(TAG, "after cancel:");
|
|
printQueue();
|
|
}
|
|
}
|
|
|
|
private void scheduleNext() {
|
|
if (stopped() || mEventQueue.isEmpty()) return;
|
|
|
|
if (mPendingIntent != null) {
|
|
throw new RuntimeException("pendingIntent is not null!");
|
|
}
|
|
|
|
MyEvent event = mEventQueue.first();
|
|
Intent intent = new Intent(getAction());
|
|
intent.putExtra(TRIGGER_TIME, event.mTriggerTime);
|
|
PendingIntent pendingIntent = mPendingIntent =
|
|
PendingIntent.getBroadcast(mContext, 0, intent,
|
|
PendingIntent.FLAG_UPDATE_CURRENT);
|
|
mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
|
|
event.mTriggerTime, pendingIntent);
|
|
}
|
|
|
|
@Override
|
|
public synchronized void onReceive(Context context, Intent intent) {
|
|
String action = intent.getAction();
|
|
if (getAction().equals(action)
|
|
&& intent.getExtras().containsKey(TRIGGER_TIME)) {
|
|
mPendingIntent = null;
|
|
long triggerTime = intent.getLongExtra(TRIGGER_TIME, -1L);
|
|
execute(triggerTime);
|
|
} else {
|
|
Log.d(TAG, "unrecognized intent: " + intent);
|
|
}
|
|
}
|
|
|
|
private void printQueue() {
|
|
int count = 0;
|
|
for (MyEvent event : mEventQueue) {
|
|
Log.d(TAG, " " + event + ": scheduled at "
|
|
+ showTime(event.mTriggerTime) + ": last at "
|
|
+ showTime(event.mLastTriggerTime));
|
|
if (++count >= 5) break;
|
|
}
|
|
if (mEventQueue.size() > count) {
|
|
Log.d(TAG, " .....");
|
|
} else if (count == 0) {
|
|
Log.d(TAG, " <empty>");
|
|
}
|
|
}
|
|
|
|
private void execute(long triggerTime) {
|
|
if (DEBUG_TIMER) Log.d(TAG, "time's up, triggerTime = "
|
|
+ showTime(triggerTime) + ": " + mEventQueue.size());
|
|
if (stopped() || mEventQueue.isEmpty()) return;
|
|
|
|
for (MyEvent event : mEventQueue) {
|
|
if (event.mTriggerTime != triggerTime) break;
|
|
if (DEBUG_TIMER) Log.d(TAG, "execute " + event);
|
|
|
|
event.mLastTriggerTime = event.mTriggerTime;
|
|
event.mTriggerTime += event.mPeriod;
|
|
|
|
// run the callback in a new thread to prevent deadlock
|
|
new Thread(event.mCallback, "SipServiceTimerCallbackThread")
|
|
.start();
|
|
}
|
|
if (DEBUG_TIMER) {
|
|
Log.d(TAG, "after timeout execution");
|
|
printQueue();
|
|
}
|
|
scheduleNext();
|
|
}
|
|
|
|
private String getAction() {
|
|
return toString();
|
|
}
|
|
|
|
private String showTime(long time) {
|
|
int ms = (int) (time % 1000);
|
|
int s = (int) (time / 1000);
|
|
int m = s / 60;
|
|
s %= 60;
|
|
return String.format("%d.%d.%d", m, s, ms);
|
|
}
|
|
}
|
|
|
|
private static class MyEvent {
|
|
int mPeriod;
|
|
int mMaxPeriod;
|
|
long mTriggerTime;
|
|
long mLastTriggerTime;
|
|
Runnable mCallback;
|
|
|
|
MyEvent(int period, Runnable callback, long now) {
|
|
mPeriod = mMaxPeriod = period;
|
|
mCallback = callback;
|
|
mLastTriggerTime = now;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
String s = super.toString();
|
|
s = s.substring(s.indexOf("@"));
|
|
return s + ":" + (mPeriod / 1000) + ":" + (mMaxPeriod / 1000) + ":"
|
|
+ toString(mCallback);
|
|
}
|
|
|
|
private String toString(Object o) {
|
|
String s = o.toString();
|
|
int index = s.indexOf("$");
|
|
if (index > 0) s = s.substring(index + 1);
|
|
return s;
|
|
}
|
|
}
|
|
|
|
private static class MyEventComparator implements Comparator<MyEvent> {
|
|
public int compare(MyEvent e1, MyEvent e2) {
|
|
if (e1 == e2) return 0;
|
|
int diff = e1.mMaxPeriod - e2.mMaxPeriod;
|
|
if (diff == 0) diff = -1;
|
|
return diff;
|
|
}
|
|
|
|
public boolean equals(Object that) {
|
|
return (this == that);
|
|
}
|
|
}
|
|
|
|
// Single-threaded executor
|
|
private static class MyExecutor extends Handler {
|
|
MyExecutor() {
|
|
super(createLooper());
|
|
}
|
|
|
|
private static Looper createLooper() {
|
|
HandlerThread thread = new HandlerThread("SipService");
|
|
thread.start();
|
|
return thread.getLooper();
|
|
}
|
|
|
|
void addTask(Runnable task) {
|
|
Message.obtain(this, 0/* don't care */, task).sendToTarget();
|
|
}
|
|
|
|
@Override
|
|
public void handleMessage(Message msg) {
|
|
if (msg.obj instanceof Runnable) {
|
|
((Runnable) msg.obj).run();
|
|
} else {
|
|
Log.w(TAG, "can't handle msg: " + msg);
|
|
}
|
|
}
|
|
}
|
|
}
|