Move the sip related codes to framework.
Change-Id: Ib81dadc39b73325c8438f078c7251857a83834fe
diff --git a/voip/java/android/net/rtp/AudioCodec.java b/voip/java/android/net/rtp/AudioCodec.java
new file mode 100644
index 0000000..89e6aa9
--- /dev/null
+++ b/voip/java/android/net/rtp/AudioCodec.java
@@ -0,0 +1,56 @@
+/*
+ * 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 android.net.rtp;
+
+/** @hide */
+public class AudioCodec {
+ public static final AudioCodec ULAW = new AudioCodec("PCMU", 8000, 160, 0);
+ public static final AudioCodec ALAW = new AudioCodec("PCMA", 8000, 160, 8);
+
+ /**
+ * Returns system supported codecs.
+ */
+ public static AudioCodec[] getSystemSupportedCodecs() {
+ return new AudioCodec[] {AudioCodec.ULAW, AudioCodec.ALAW};
+ }
+
+ /**
+ * Returns the codec instance if it is supported by the system.
+ *
+ * @param name name of the codec
+ * @return the matched codec or null if the codec name is not supported by
+ * the system
+ */
+ public static AudioCodec getSystemSupportedCodec(String name) {
+ for (AudioCodec codec : getSystemSupportedCodecs()) {
+ if (codec.name.equals(name)) return codec;
+ }
+ return null;
+ }
+
+ public final String name;
+ public final int sampleRate;
+ public final int sampleCount;
+ public final int defaultType;
+
+ private AudioCodec(String name, int sampleRate, int sampleCount, int defaultType) {
+ this.name = name;
+ this.sampleRate = sampleRate;
+ this.sampleCount = sampleCount;
+ this.defaultType = defaultType;
+ }
+}
diff --git a/voip/java/android/net/rtp/AudioGroup.java b/voip/java/android/net/rtp/AudioGroup.java
new file mode 100644
index 0000000..dc86082
--- /dev/null
+++ b/voip/java/android/net/rtp/AudioGroup.java
@@ -0,0 +1,91 @@
+/*
+ * 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 android.net.rtp;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ */
+/** @hide */
+public class AudioGroup {
+ public static final int MODE_ON_HOLD = 0;
+ public static final int MODE_MUTED = 1;
+ public static final int MODE_NORMAL = 2;
+ public static final int MODE_EC_ENABLED = 3;
+
+ private final Map<AudioStream, Integer> mStreams;
+ private int mMode = MODE_ON_HOLD;
+
+ private int mNative;
+ static {
+ System.loadLibrary("rtp_jni");
+ }
+
+ public AudioGroup() {
+ mStreams = new HashMap<AudioStream, Integer>();
+ }
+
+ public int getMode() {
+ return mMode;
+ }
+
+ public synchronized native void setMode(int mode);
+
+ synchronized void add(AudioStream stream, AudioCodec codec, int codecType, int dtmfType) {
+ if (!mStreams.containsKey(stream)) {
+ try {
+ int id = add(stream.getMode(), stream.dup(),
+ stream.getRemoteAddress().getHostAddress(), stream.getRemotePort(),
+ codec.name, codec.sampleRate, codec.sampleCount, codecType, dtmfType);
+ mStreams.put(stream, id);
+ } catch (NullPointerException e) {
+ throw new IllegalStateException(e);
+ }
+ }
+ }
+
+ private native int add(int mode, int socket, String remoteAddress, int remotePort,
+ String codecName, int sampleRate, int sampleCount, int codecType, int dtmfType);
+
+ synchronized void remove(AudioStream stream) {
+ Integer id = mStreams.remove(stream);
+ if (id != null) {
+ remove(id);
+ }
+ }
+
+ private native void remove(int id);
+
+ /**
+ * Sends a DTMF digit to every {@link AudioStream} in this group. Currently
+ * only event {@code 0} to {@code 15} are supported.
+ *
+ * @throws IllegalArgumentException if the event is invalid.
+ */
+ public native synchronized void sendDtmf(int event);
+
+ public synchronized void reset() {
+ remove(-1);
+ }
+
+ @Override
+ protected void finalize() throws Throwable {
+ reset();
+ super.finalize();
+ }
+}
diff --git a/voip/java/android/net/rtp/AudioStream.java b/voip/java/android/net/rtp/AudioStream.java
new file mode 100644
index 0000000..a955fd2
--- /dev/null
+++ b/voip/java/android/net/rtp/AudioStream.java
@@ -0,0 +1,136 @@
+/*
+ * 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 android.net.rtp;
+
+import java.net.InetAddress;
+import java.net.SocketException;
+
+/**
+ * AudioStream represents a RTP stream carrying audio payloads.
+ */
+/** @hide */
+public class AudioStream extends RtpStream {
+ private AudioCodec mCodec;
+ private int mCodecType = -1;
+ private int mDtmfType = -1;
+ private AudioGroup mGroup;
+
+ /**
+ * Creates an AudioStream on the given local address. Note that the local
+ * port is assigned automatically to conform with RFC 3550.
+ *
+ * @param address The network address of the local host to bind to.
+ * @throws SocketException if the address cannot be bound or a problem
+ * occurs during binding.
+ */
+ public AudioStream(InetAddress address) throws SocketException {
+ super(address);
+ }
+
+ /**
+ * Returns {@code true} if the stream already joined an {@link AudioGroup}.
+ */
+ @Override
+ public final boolean isBusy() {
+ return mGroup != null;
+ }
+
+ /**
+ * Returns the joined {@link AudioGroup}.
+ */
+ public AudioGroup getAudioGroup() {
+ return mGroup;
+ }
+
+ /**
+ * Joins an {@link AudioGroup}. Each stream can join only one group at a
+ * time. The group can be changed by passing a different one or removed
+ * by calling this method with {@code null}.
+ *
+ * @param group The AudioGroup to join or {@code null} to leave.
+ * @throws IllegalStateException if the stream is not properly configured.
+ * @see AudioGroup
+ */
+ public void join(AudioGroup group) {
+ if (mGroup == group) {
+ return;
+ }
+ if (mGroup != null) {
+ mGroup.remove(this);
+ mGroup = null;
+ }
+ if (group != null) {
+ group.add(this, mCodec, mCodecType, mDtmfType);
+ mGroup = group;
+ }
+ }
+
+ /**
+ * Sets the {@link AudioCodec} and its RTP payload type. According to RFC
+ * 3551, the type must be in the range of 0 and 127, where 96 and above are
+ * dynamic types. For codecs with static mappings (non-negative
+ * {@link AudioCodec#defaultType}), assigning a different non-dynamic type
+ * is disallowed.
+ *
+ * @param codec The AudioCodec to be used.
+ * @param type The RTP payload type.
+ * @throws IllegalArgumentException if the type is invalid or used by DTMF.
+ * @throws IllegalStateException if the stream is busy.
+ */
+ public void setCodec(AudioCodec codec, int type) {
+ if (isBusy()) {
+ throw new IllegalStateException("Busy");
+ }
+ if (type < 0 || type > 127 || (type != codec.defaultType && type < 96)) {
+ throw new IllegalArgumentException("Invalid type");
+ }
+ if (type == mDtmfType) {
+ throw new IllegalArgumentException("The type is used by DTMF");
+ }
+ mCodec = codec;
+ mCodecType = type;
+ }
+
+ /**
+ * Sets the RTP payload type for dual-tone multi-frequency (DTMF) digits.
+ * The primary usage is to send digits to the remote gateway to perform
+ * certain tasks, such as second-stage dialing. According to RFC 2833, the
+ * RTP payload type for DTMF is assigned dynamically, so it must be in the
+ * range of 96 and 127. One can use {@code -1} to disable DTMF and free up
+ * the previous assigned value. This method cannot be called when the stream
+ * already joined an {@link AudioGroup}.
+ *
+ * @param type The RTP payload type to be used or {@code -1} to disable it.
+ * @throws IllegalArgumentException if the type is invalid or used by codec.
+ * @throws IllegalStateException if the stream is busy.
+ * @see AudioGroup#sendDtmf(int)
+ */
+ public void setDtmfType(int type) {
+ if (isBusy()) {
+ throw new IllegalStateException("Busy");
+ }
+ if (type != -1) {
+ if (type < 96 || type > 127) {
+ throw new IllegalArgumentException("Invalid type");
+ }
+ if (type == mCodecType) {
+ throw new IllegalArgumentException("The type is used by codec");
+ }
+ }
+ mDtmfType = type;
+ }
+}
diff --git a/voip/java/android/net/rtp/RtpStream.java b/voip/java/android/net/rtp/RtpStream.java
new file mode 100644
index 0000000..ef5ca17
--- /dev/null
+++ b/voip/java/android/net/rtp/RtpStream.java
@@ -0,0 +1,173 @@
+/*
+ * 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 android.net.rtp;
+
+import java.net.InetAddress;
+import java.net.Inet4Address;
+import java.net.Inet6Address;
+import java.net.SocketException;
+
+/**
+ * RtpStream represents a base class of media streams running over
+ * Real-time Transport Protocol (RTP).
+ */
+/** @hide */
+public class RtpStream {
+ public static final int MODE_NORMAL = 0;
+ public static final int MODE_SEND_ONLY = 1;
+ public static final int MODE_RECEIVE_ONLY = 2;
+
+ private final InetAddress mLocalAddress;
+ private final int mLocalPort;
+
+ private InetAddress mRemoteAddress;
+ private int mRemotePort = -1;
+ private int mMode = MODE_NORMAL;
+
+ private int mNative;
+ static {
+ System.loadLibrary("rtp_jni");
+ }
+
+ /**
+ * Creates a RtpStream on the given local address. Note that the local
+ * port is assigned automatically to conform with RFC 3550.
+ *
+ * @param address The network address of the local host to bind to.
+ * @throws SocketException if the address cannot be bound or a problem
+ * occurs during binding.
+ */
+ RtpStream(InetAddress address) throws SocketException {
+ mLocalPort = create(address.getHostAddress());
+ mLocalAddress = address;
+ }
+
+ private native int create(String address) throws SocketException;
+
+ /**
+ * Returns the network address of the local host.
+ */
+ public InetAddress getLocalAddress() {
+ return mLocalAddress;
+ }
+
+ /**
+ * Returns the network port of the local host.
+ */
+ public int getLocalPort() {
+ return mLocalPort;
+ }
+
+ /**
+ * Returns the network address of the remote host or {@code null} if the
+ * stream is not associated.
+ */
+ public InetAddress getRemoteAddress() {
+ return mRemoteAddress;
+ }
+
+ /**
+ * Returns the network port of the remote host or {@code -1} if the stream
+ * is not associated.
+ */
+ public int getRemotePort() {
+ return mRemotePort;
+ }
+
+ /**
+ * Returns {@code true} if the stream is busy. This method is intended to be
+ * overridden by subclasses.
+ */
+ public boolean isBusy() {
+ return false;
+ }
+
+ /**
+ * Returns the current mode. The initial mode is {@link #MODE_NORMAL}.
+ */
+ public int getMode() {
+ return mMode;
+ }
+
+ /**
+ * Changes the current mode. It must be one of {@link #MODE_NORMAL},
+ * {@link #MODE_SEND_ONLY}, and {@link #MODE_RECEIVE_ONLY}.
+ *
+ * @param mode The mode to change to.
+ * @throws IllegalArgumentException if the mode is invalid.
+ * @throws IllegalStateException if the stream is busy.
+ * @see #isBusy()
+ */
+ public void setMode(int mode) {
+ if (isBusy()) {
+ throw new IllegalStateException("Busy");
+ }
+ if (mode != MODE_NORMAL && mode != MODE_SEND_ONLY && mode != MODE_RECEIVE_ONLY) {
+ throw new IllegalArgumentException("Invalid mode");
+ }
+ mMode = mode;
+ }
+
+ /**
+ * Associates with a remote host.
+ *
+ * @param address The network address of the remote host.
+ * @param port The network port of the remote host.
+ * @throws IllegalArgumentException if the address is not supported or the
+ * port is invalid.
+ * @throws IllegalStateException if the stream is busy.
+ * @see #isBusy()
+ */
+ public void associate(InetAddress address, int port) {
+ if (isBusy()) {
+ throw new IllegalStateException("Busy");
+ }
+ if (!(address instanceof Inet4Address && mLocalAddress instanceof Inet4Address) &&
+ !(address instanceof Inet6Address && mLocalAddress instanceof Inet6Address)) {
+ throw new IllegalArgumentException("Unsupported address");
+ }
+ if (port < 0 || port > 65535) {
+ throw new IllegalArgumentException("Invalid port");
+ }
+ mRemoteAddress = address;
+ mRemotePort = port;
+ }
+
+ synchronized native int dup();
+
+ /**
+ * Releases allocated resources. The stream becomes inoperable after calling
+ * this method.
+ *
+ * @throws IllegalStateException if the stream is busy.
+ * @see #isBusy()
+ */
+ public void release() {
+ if (isBusy()) {
+ throw new IllegalStateException("Busy");
+ }
+ close();
+ }
+
+ private synchronized native void close();
+
+ @Override
+ protected void finalize() throws Throwable {
+ close();
+ super.finalize();
+ }
+}
diff --git a/voip/java/android/net/sip/BinderHelper.java b/voip/java/android/net/sip/BinderHelper.java
new file mode 100644
index 0000000..bd3da32
--- /dev/null
+++ b/voip/java/android/net/sip/BinderHelper.java
@@ -0,0 +1,79 @@
+/*
+ * 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 android.net.sip;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.ConditionVariable;
+import android.os.IBinder;
+import android.os.IInterface;
+import android.os.Looper;
+import android.util.Log;
+
+// TODO: throw away this class after moving SIP classes to framework
+// This class helps to get IBinder instance of a service in a blocking call.
+// The method cannot be called in app's main thread as the ServiceConnection
+// callback will.
+class BinderHelper<T extends IInterface> {
+ private Context mContext;
+ private IBinder mBinder;
+ private Class<T> mClass;
+
+ BinderHelper(Context context, Class<T> klass) {
+ mContext = context;
+ mClass = klass;
+ }
+
+ void startService() {
+ mContext.startService(new Intent(mClass.getName()));
+ }
+
+ void stopService() {
+ mContext.stopService(new Intent(mClass.getName()));
+ }
+
+ IBinder getBinder() {
+ // cannot call this method in app's main thread
+ if (Looper.getMainLooper().getThread() == Thread.currentThread()) {
+ throw new RuntimeException(
+ "This method cannot be called in app's main thread");
+ }
+
+ final ConditionVariable cv = new ConditionVariable();
+ cv.close();
+ ServiceConnection c = new ServiceConnection() {
+ public synchronized void onServiceConnected(
+ ComponentName className, IBinder binder) {
+ Log.v("BinderHelper", "service connected!");
+ mBinder = binder;
+ cv.open();
+ mContext.unbindService(this);
+ }
+
+ public void onServiceDisconnected(ComponentName className) {
+ cv.open();
+ mContext.unbindService(this);
+ }
+ };
+ if (mContext.bindService(new Intent(mClass.getName()), c, 0)) {
+ cv.block(4500);
+ }
+ return mBinder;
+ }
+}
diff --git a/voip/java/android/net/sip/ISipService.aidl b/voip/java/android/net/sip/ISipService.aidl
new file mode 100644
index 0000000..6c68213
--- /dev/null
+++ b/voip/java/android/net/sip/ISipService.aidl
@@ -0,0 +1,42 @@
+/*
+ * 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 android.net.sip;
+
+import android.net.sip.ISipSession;
+import android.net.sip.ISipSessionListener;
+import android.net.sip.SipProfile;
+
+/**
+ * {@hide}
+ */
+interface ISipService {
+ void open(in SipProfile localProfile);
+ void open3(in SipProfile localProfile,
+ String incomingCallBroadcastAction,
+ in ISipSessionListener listener);
+ void close(in String localProfileUri);
+ boolean isOpened(String localProfileUri);
+ boolean isRegistered(String localProfileUri);
+ void setRegistrationListener(String localProfileUri,
+ ISipSessionListener listener);
+
+ ISipSession createSession(in SipProfile localProfile,
+ in ISipSessionListener listener);
+ ISipSession getPendingSession(String callId);
+
+ SipProfile[] getListOfProfiles();
+}
diff --git a/voip/java/android/net/sip/ISipSession.aidl b/voip/java/android/net/sip/ISipSession.aidl
new file mode 100644
index 0000000..fbcb056
--- /dev/null
+++ b/voip/java/android/net/sip/ISipSession.aidl
@@ -0,0 +1,147 @@
+/*
+ * 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 android.net.sip;
+
+import android.net.sip.ISipSessionListener;
+import android.net.sip.SessionDescription;
+import android.net.sip.SipProfile;
+
+/**
+ * A SIP session that is associated with a SIP dialog or a transaction
+ * (e.g., registration) not within a dialog.
+ * @hide
+ */
+interface ISipSession {
+ /**
+ * Gets the IP address of the local host on which this SIP session runs.
+ *
+ * @return the IP address of the local host
+ */
+ String getLocalIp();
+
+ /**
+ * Gets the SIP profile that this session is associated with.
+ *
+ * @return the SIP profile that this session is associated with
+ */
+ SipProfile getLocalProfile();
+
+ /**
+ * Gets the SIP profile that this session is connected to. Only available
+ * when the session is associated with a SIP dialog.
+ *
+ * @return the SIP profile that this session is connected to
+ */
+ SipProfile getPeerProfile();
+
+ /**
+ * Gets the session state. The value returned must be one of the states in
+ * {@link SipSessionState}. One may convert it to {@link SipSessionState} by
+ * <code>
+ * Enum.valueOf(SipSessionState.class, session.getState());
+ * </code>
+ *
+ * @return the session state
+ */
+ String getState();
+
+ /**
+ * Checks if the session is in a call.
+ *
+ * @return true if the session is in a call
+ */
+ boolean isInCall();
+
+ /**
+ * Gets the call ID of the session.
+ *
+ * @return the call ID
+ */
+ String getCallId();
+
+
+ /**
+ * Sets the listener to listen to the session events. A {@link ISipSession}
+ * can only hold one listener at a time. Subsequent calls to this method
+ * override the previous listener.
+ *
+ * @param listener to listen to the session events of this object
+ */
+ void setListener(in ISipSessionListener listener);
+
+
+ /**
+ * Performs registration to the server specified by the associated local
+ * profile. The session listener is called back upon success or failure of
+ * registration. The method is only valid to call when the session state is
+ * in {@link SipSessionState#READY_TO_CALL}.
+ *
+ * @param duration duration in second before the registration expires
+ * @see ISipSessionListener
+ */
+ void register(int duration);
+
+ /**
+ * Performs unregistration to the server specified by the associated local
+ * profile. Unregistration is technically the same as registration with zero
+ * expiration duration. The session listener is called back upon success or
+ * failure of unregistration. The method is only valid to call when the
+ * session state is in {@link SipSessionState#READY_TO_CALL}.
+ *
+ * @see ISipSessionListener
+ */
+ void unregister();
+
+ /**
+ * Initiates a call to the specified profile. The session listener is called
+ * back upon defined session events. The method is only valid to call when
+ * the session state is in {@link SipSessionState#READY_TO_CALL}.
+ *
+ * @param callee the SIP profile to make the call to
+ * @param sessionDescription the session description of this call
+ * @see ISipSessionListener
+ */
+ void makeCall(in SipProfile callee,
+ in SessionDescription sessionDescription);
+
+ /**
+ * Answers an incoming call with the specified session description. The
+ * method is only valid to call when the session state is in
+ * {@link SipSessionState#INCOMING_CALL}.
+ *
+ * @param sessionDescription the session description to answer this call
+ */
+ void answerCall(in SessionDescription sessionDescription);
+
+ /**
+ * Ends an established call, terminates an outgoing call or rejects an
+ * incoming call. The method is only valid to call when the session state is
+ * in {@link SipSessionState#IN_CALL},
+ * {@link SipSessionState#INCOMING_CALL},
+ * {@link SipSessionState#OUTGOING_CALL} or
+ * {@link SipSessionState#OUTGOING_CALL_RING_BACK}.
+ */
+ void endCall();
+
+ /**
+ * Changes the session description during a call. The method is only valid
+ * to call when the session state is in {@link SipSessionState#IN_CALL}.
+ *
+ * @param sessionDescription the new session description
+ */
+ void changeCall(in SessionDescription sessionDescription);
+}
diff --git a/voip/java/android/net/sip/ISipSessionListener.aidl b/voip/java/android/net/sip/ISipSessionListener.aidl
new file mode 100644
index 0000000..8570958
--- /dev/null
+++ b/voip/java/android/net/sip/ISipSessionListener.aidl
@@ -0,0 +1,126 @@
+/*
+ * 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 android.net.sip;
+
+import android.net.sip.ISipSession;
+import android.net.sip.SipProfile;
+
+/**
+ * Listener class to listen to SIP session events.
+ * @hide
+ */
+interface ISipSessionListener {
+ /**
+ * Called when an INVITE request is sent to initiate a new call.
+ *
+ * @param session the session object that carries out the transaction
+ */
+ void onCalling(in ISipSession session);
+
+ /**
+ * Called when an INVITE request is received.
+ *
+ * @param session the session object that carries out the transaction
+ * @param caller the SIP profile of the caller
+ * @param sessionDescription the caller's session description
+ */
+ void onRinging(in ISipSession session, in SipProfile caller,
+ in byte[] sessionDescription);
+
+ /**
+ * Called when a RINGING response is received for the INVITE request sent
+ *
+ * @param session the session object that carries out the transaction
+ */
+ void onRingingBack(in ISipSession session);
+
+ /**
+ * Called when the session is established.
+ *
+ * @param session the session object that is associated with the dialog
+ * @param sessionDescription the peer's session description
+ */
+ void onCallEstablished(in ISipSession session,
+ in byte[] sessionDescription);
+
+ /**
+ * Called when the session is terminated.
+ *
+ * @param session the session object that is associated with the dialog
+ */
+ void onCallEnded(in ISipSession session);
+
+ /**
+ * Called when the peer is busy during session initialization.
+ *
+ * @param session the session object that carries out the transaction
+ */
+ void onCallBusy(in ISipSession session);
+
+ /**
+ * Called when an error occurs during session initialization and
+ * termination.
+ *
+ * @param session the session object that carries out the transaction
+ * @param errorClass name of the exception class
+ * @param errorMessage error message
+ */
+ void onError(in ISipSession session, String errorClass,
+ String errorMessage);
+
+ /**
+ * Called when an error occurs during session modification negotiation.
+ *
+ * @param session the session object that carries out the transaction
+ * @param errorClass name of the exception class
+ * @param errorMessage error message
+ */
+ void onCallChangeFailed(in ISipSession session, String errorClass,
+ String errorMessage);
+
+ /**
+ * Called when a registration request is sent.
+ *
+ * @param session the session object that carries out the transaction
+ */
+ void onRegistering(in ISipSession session);
+
+ /**
+ * Called when registration is successfully done.
+ *
+ * @param session the session object that carries out the transaction
+ * @param duration duration in second before the registration expires
+ */
+ void onRegistrationDone(in ISipSession session, int duration);
+
+ /**
+ * Called when the registration fails.
+ *
+ * @param session the session object that carries out the transaction
+ * @param errorClass name of the exception class
+ * @param errorMessage error message
+ */
+ void onRegistrationFailed(in ISipSession session, String errorClass,
+ String errorMessage);
+
+ /**
+ * Called when the registration gets timed out.
+ *
+ * @param session the session object that carries out the transaction
+ */
+ void onRegistrationTimeout(in ISipSession session);
+}
diff --git a/voip/java/android/net/sip/SdpSessionDescription.java b/voip/java/android/net/sip/SdpSessionDescription.java
new file mode 100644
index 0000000..0c29935
--- /dev/null
+++ b/voip/java/android/net/sip/SdpSessionDescription.java
@@ -0,0 +1,428 @@
+/*
+ * 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 android.net.sip;
+
+import gov.nist.javax.sdp.SessionDescriptionImpl;
+import gov.nist.javax.sdp.fields.AttributeField;
+import gov.nist.javax.sdp.fields.ConnectionField;
+import gov.nist.javax.sdp.fields.MediaField;
+import gov.nist.javax.sdp.fields.OriginField;
+import gov.nist.javax.sdp.fields.ProtoVersionField;
+import gov.nist.javax.sdp.fields.SessionNameField;
+import gov.nist.javax.sdp.fields.TimeField;
+import gov.nist.javax.sdp.parser.SDPAnnounceParser;
+
+import android.util.Log;
+
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Vector;
+import javax.sdp.Connection;
+import javax.sdp.MediaDescription;
+import javax.sdp.SdpException;
+
+/**
+ * A session description that follows SDP (Session Description Protocol).
+ * Refer to <a href="http://tools.ietf.org/html/rfc4566">RFC 4566</a>.
+ * @hide
+ */
+public class SdpSessionDescription extends SessionDescription {
+ private static final String TAG = "SDP";
+ private static final String AUDIO = "audio";
+ private static final String RTPMAP = "rtpmap";
+ private static final String PTIME = "ptime";
+ private static final String SENDONLY = "sendonly";
+ private static final String RECVONLY = "recvonly";
+ private static final String INACTIVE = "inactive";
+
+ private SessionDescriptionImpl mSessionDescription;
+
+ /**
+ * The audio codec information parsed from "rtpmap".
+ */
+ public static class AudioCodec {
+ public final int payloadType;
+ public final String name;
+ public final int sampleRate;
+ public final int sampleCount;
+
+ public AudioCodec(int payloadType, String name, int sampleRate,
+ int sampleCount) {
+ this.payloadType = payloadType;
+ this.name = name;
+ this.sampleRate = sampleRate;
+ this.sampleCount = sampleCount;
+ }
+ }
+
+ /**
+ * The builder class used to create an {@link SdpSessionDescription} object.
+ */
+ public static class Builder {
+ private SdpSessionDescription mSdp = new SdpSessionDescription();
+ private SessionDescriptionImpl mSessionDescription;
+
+ public Builder(String sessionName) throws SdpException {
+ mSessionDescription = new SessionDescriptionImpl();
+ mSdp.mSessionDescription = mSessionDescription;
+ try {
+ ProtoVersionField proto = new ProtoVersionField();
+ proto.setVersion(0);
+ mSessionDescription.addField(proto);
+
+ TimeField time = new TimeField();
+ time.setZero();
+ mSessionDescription.addField(time);
+
+ SessionNameField session = new SessionNameField();
+ session.setValue(sessionName);
+ mSessionDescription.addField(session);
+ } catch (Exception e) {
+ throwSdpException(e);
+ }
+ }
+
+ public Builder setConnectionInfo(String networkType, String addressType,
+ String addr) throws SdpException {
+ try {
+ ConnectionField connection = new ConnectionField();
+ connection.setNetworkType(networkType);
+ connection.setAddressType(addressType);
+ connection.setAddress(addr);
+ mSessionDescription.addField(connection);
+ } catch (Exception e) {
+ throwSdpException(e);
+ }
+ return this;
+ }
+
+ public Builder setOrigin(SipProfile user, long sessionId,
+ long sessionVersion, String networkType, String addressType,
+ String address) throws SdpException {
+ try {
+ OriginField origin = new OriginField();
+ origin.setUsername(user.getUserName());
+ origin.setSessionId(sessionId);
+ origin.setSessionVersion(sessionVersion);
+ origin.setAddressType(addressType);
+ origin.setNetworkType(networkType);
+ origin.setAddress(address);
+ mSessionDescription.addField(origin);
+ } catch (Exception e) {
+ throwSdpException(e);
+ }
+ return this;
+ }
+
+ public Builder addMedia(String media, int port, int numPorts,
+ String transport, Integer... types) throws SdpException {
+ MediaField field = new MediaField();
+ Vector<Integer> typeVector = new Vector<Integer>();
+ Collections.addAll(typeVector, types);
+ try {
+ field.setMediaType(media);
+ field.setMediaPort(port);
+ field.setPortCount(numPorts);
+ field.setProtocol(transport);
+ field.setMediaFormats(typeVector);
+ mSessionDescription.addField(field);
+ } catch (Exception e) {
+ throwSdpException(e);
+ }
+ return this;
+ }
+
+ public Builder addMediaAttribute(String type, String name, String value)
+ throws SdpException {
+ try {
+ MediaDescription md = mSdp.getMediaDescription(type);
+ if (md == null) {
+ throw new SdpException("Should add media first!");
+ }
+ AttributeField attribute = new AttributeField();
+ attribute.setName(name);
+ attribute.setValueAllowNull(value);
+ mSessionDescription.addField(attribute);
+ } catch (Exception e) {
+ throwSdpException(e);
+ }
+ return this;
+ }
+
+ public Builder addSessionAttribute(String name, String value)
+ throws SdpException {
+ try {
+ AttributeField attribute = new AttributeField();
+ attribute.setName(name);
+ attribute.setValueAllowNull(value);
+ mSessionDescription.addField(attribute);
+ } catch (Exception e) {
+ throwSdpException(e);
+ }
+ return this;
+ }
+
+ private void throwSdpException(Exception e) throws SdpException {
+ if (e instanceof SdpException) {
+ throw (SdpException) e;
+ } else {
+ throw new SdpException(e.toString(), e);
+ }
+ }
+
+ public SdpSessionDescription build() {
+ return mSdp;
+ }
+ }
+
+ private SdpSessionDescription() {
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param sdpString an SDP session description to parse
+ */
+ public SdpSessionDescription(String sdpString) throws SdpException {
+ try {
+ mSessionDescription = new SDPAnnounceParser(sdpString).parse();
+ } catch (ParseException e) {
+ throw new SdpException(e.toString(), e);
+ }
+ verify();
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param content a raw SDP session description to parse
+ */
+ public SdpSessionDescription(byte[] content) throws SdpException {
+ this(new String(content));
+ }
+
+ private void verify() throws SdpException {
+ // make sure the syntax is correct over the fields we're interested in
+ Vector<MediaDescription> descriptions = (Vector<MediaDescription>)
+ mSessionDescription.getMediaDescriptions(false);
+ for (MediaDescription md : descriptions) {
+ md.getMedia().getMediaPort();
+ Connection connection = md.getConnection();
+ if (connection != null) connection.getAddress();
+ md.getMedia().getFormats();
+ }
+ Connection connection = mSessionDescription.getConnection();
+ if (connection != null) connection.getAddress();
+ }
+
+ /**
+ * Gets the connection address of the media.
+ *
+ * @param type the media type; e.g., "AUDIO"
+ * @return the media connection address of the peer
+ */
+ public String getPeerMediaAddress(String type) {
+ try {
+ MediaDescription md = getMediaDescription(type);
+ Connection connection = md.getConnection();
+ if (connection == null) {
+ connection = mSessionDescription.getConnection();
+ }
+ return ((connection == null) ? null : connection.getAddress());
+ } catch (SdpException e) {
+ // should not occur
+ return null;
+ }
+ }
+
+ /**
+ * Gets the connection port number of the media.
+ *
+ * @param type the media type; e.g., "AUDIO"
+ * @return the media connection port number of the peer
+ */
+ public int getPeerMediaPort(String type) {
+ try {
+ MediaDescription md = getMediaDescription(type);
+ return md.getMedia().getMediaPort();
+ } catch (SdpException e) {
+ // should not occur
+ return -1;
+ }
+ }
+
+ private boolean containsAttribute(String type, String name) {
+ if (name == null) return false;
+ MediaDescription md = getMediaDescription(type);
+ Vector<AttributeField> v = (Vector<AttributeField>)
+ md.getAttributeFields();
+ for (AttributeField field : v) {
+ if (name.equals(field.getAttribute().getName())) return true;
+ }
+ return false;
+ }
+
+ /**
+ * Checks if the media is "sendonly".
+ *
+ * @param type the media type; e.g., "AUDIO"
+ * @return true if the media is "sendonly"
+ */
+ public boolean isSendOnly(String type) {
+ boolean answer = containsAttribute(type, SENDONLY);
+ Log.d(TAG, " sendonly? " + answer);
+ return answer;
+ }
+
+ /**
+ * Checks if the media is "recvonly".
+ *
+ * @param type the media type; e.g., "AUDIO"
+ * @return true if the media is "recvonly"
+ */
+ public boolean isReceiveOnly(String type) {
+ boolean answer = containsAttribute(type, RECVONLY);
+ Log.d(TAG, " recvonly? " + answer);
+ return answer;
+ }
+
+ /**
+ * Checks if the media is in sending; i.e., not "recvonly" and not
+ * "inactive".
+ *
+ * @param type the media type; e.g., "AUDIO"
+ * @return true if the media is sending
+ */
+ public boolean isSending(String type) {
+ boolean answer = !containsAttribute(type, RECVONLY)
+ && !containsAttribute(type, INACTIVE);
+
+ Log.d(TAG, " sending? " + answer);
+ return answer;
+ }
+
+ /**
+ * Checks if the media is in receiving; i.e., not "sendonly" and not
+ * "inactive".
+ *
+ * @param type the media type; e.g., "AUDIO"
+ * @return true if the media is receiving
+ */
+ public boolean isReceiving(String type) {
+ boolean answer = !containsAttribute(type, SENDONLY)
+ && !containsAttribute(type, INACTIVE);
+ Log.d(TAG, " receiving? " + answer);
+ return answer;
+ }
+
+ private AudioCodec parseAudioCodec(String rtpmap, int ptime) {
+ String[] ss = rtpmap.split(" ");
+ int payloadType = Integer.parseInt(ss[0]);
+
+ ss = ss[1].split("/");
+ String name = ss[0];
+ int sampleRate = Integer.parseInt(ss[1]);
+ int channelCount = 1;
+ if (ss.length > 2) channelCount = Integer.parseInt(ss[2]);
+ int sampleCount = sampleRate / (1000 / ptime) * channelCount;
+ return new AudioCodec(payloadType, name, sampleRate, sampleCount);
+ }
+
+ /**
+ * Gets the list of audio codecs in this session description.
+ *
+ * @return the list of audio codecs in this session description
+ */
+ public List<AudioCodec> getAudioCodecs() {
+ MediaDescription md = getMediaDescription(AUDIO);
+ if (md == null) return new ArrayList<AudioCodec>();
+
+ // FIXME: what happens if ptime is missing
+ int ptime = 20;
+ try {
+ String value = md.getAttribute(PTIME);
+ if (value != null) ptime = Integer.parseInt(value);
+ } catch (Throwable t) {
+ Log.w(TAG, "getCodecs(): ignored: " + t);
+ }
+
+ List<AudioCodec> codecs = new ArrayList<AudioCodec>();
+ Vector<AttributeField> v = (Vector<AttributeField>)
+ md.getAttributeFields();
+ for (AttributeField field : v) {
+ try {
+ if (RTPMAP.equals(field.getName())) {
+ AudioCodec codec = parseAudioCodec(field.getValue(), ptime);
+ if (codec != null) codecs.add(codec);
+ }
+ } catch (Throwable t) {
+ Log.w(TAG, "getCodecs(): ignored: " + t);
+ }
+ }
+ return codecs;
+ }
+
+ /**
+ * Gets the media description of the specified type.
+ *
+ * @param type the media type; e.g., "AUDIO"
+ * @return the media description of the specified type
+ */
+ public MediaDescription getMediaDescription(String type) {
+ MediaDescription[] all = getMediaDescriptions();
+ if ((all == null) || (all.length == 0)) return null;
+ for (MediaDescription md : all) {
+ String t = md.getMedia().getMedia();
+ if (t.equalsIgnoreCase(type)) return md;
+ }
+ return null;
+ }
+
+ /**
+ * Gets all the media descriptions in this session description.
+ *
+ * @return all the media descriptions in this session description
+ */
+ public MediaDescription[] getMediaDescriptions() {
+ try {
+ Vector<MediaDescription> descriptions = (Vector<MediaDescription>)
+ mSessionDescription.getMediaDescriptions(false);
+ MediaDescription[] all = new MediaDescription[descriptions.size()];
+ return descriptions.toArray(all);
+ } catch (SdpException e) {
+ Log.e(TAG, "getMediaDescriptions", e);
+ }
+ return null;
+ }
+
+ @Override
+ public String getType() {
+ return "sdp";
+ }
+
+ @Override
+ public byte[] getContent() {
+ return mSessionDescription.toString().getBytes();
+ }
+
+ @Override
+ public String toString() {
+ return mSessionDescription.toString();
+ }
+}
diff --git a/voip/java/android/net/sip/SessionDescription.aidl b/voip/java/android/net/sip/SessionDescription.aidl
new file mode 100644
index 0000000..a120d16
--- /dev/null
+++ b/voip/java/android/net/sip/SessionDescription.aidl
@@ -0,0 +1,19 @@
+/*
+ * 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 android.net.sip;
+
+parcelable SessionDescription;
diff --git a/voip/java/android/net/sip/SessionDescription.java b/voip/java/android/net/sip/SessionDescription.java
new file mode 100644
index 0000000..d476f0b
--- /dev/null
+++ b/voip/java/android/net/sip/SessionDescription.java
@@ -0,0 +1,83 @@
+/*
+ * 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 android.net.sip;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+/**
+ * Abstract class of a session description.
+ * @hide
+ */
+public abstract class SessionDescription implements Parcelable {
+ /** @hide */
+ public static final Parcelable.Creator<SessionDescription> CREATOR =
+ new Parcelable.Creator<SessionDescription>() {
+ public SessionDescription createFromParcel(Parcel in) {
+ return new SessionDescriptionImpl(in);
+ }
+
+ public SessionDescription[] newArray(int size) {
+ return new SessionDescriptionImpl[size];
+ }
+ };
+
+ /**
+ * Gets the type of the session description; e.g., "SDP".
+ *
+ * @return the session description type
+ */
+ public abstract String getType();
+
+ /**
+ * Gets the raw content of the session description.
+ *
+ * @return the content of the session description
+ */
+ public abstract byte[] getContent();
+
+ /** @hide */
+ public void writeToParcel(Parcel out, int flags) {
+ out.writeString(getType());
+ out.writeByteArray(getContent());
+ }
+
+ /** @hide */
+ public int describeContents() {
+ return 0;
+ }
+
+ private static class SessionDescriptionImpl extends SessionDescription {
+ private String mType;
+ private byte[] mContent;
+
+ SessionDescriptionImpl(Parcel in) {
+ mType = in.readString();
+ mContent = in.createByteArray();
+ }
+
+ @Override
+ public String getType() {
+ return mType;
+ }
+
+ @Override
+ public byte[] getContent() {
+ return mContent;
+ }
+ }
+}
diff --git a/voip/java/android/net/sip/SipAudioCall.java b/voip/java/android/net/sip/SipAudioCall.java
new file mode 100644
index 0000000..abdc9d7
--- /dev/null
+++ b/voip/java/android/net/sip/SipAudioCall.java
@@ -0,0 +1,306 @@
+/*
+ * 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 android.net.sip;
+
+import android.net.rtp.AudioGroup;
+import android.net.rtp.AudioStream;
+import android.os.Message;
+
+import javax.sip.SipException;
+
+/**
+ * Interface for making audio calls over SIP.
+ * @hide
+ */
+public interface SipAudioCall {
+ /** Listener class for all event callbacks. */
+ public interface Listener {
+ /**
+ * Called when the call object is ready to make another call.
+ *
+ * @param call the call object that is ready to make another call
+ */
+ void onReadyToCall(SipAudioCall call);
+
+ /**
+ * Called when a request is sent out to initiate a new call.
+ *
+ * @param call the call object that carries out the audio call
+ */
+ void onCalling(SipAudioCall call);
+
+ /**
+ * Called when a new call comes in.
+ *
+ * @param call the call object that carries out the audio call
+ * @param caller the SIP profile of the caller
+ */
+ void onRinging(SipAudioCall call, SipProfile caller);
+
+ /**
+ * Called when a RINGING response is received for the INVITE request sent
+ *
+ * @param call the call object that carries out the audio call
+ */
+ void onRingingBack(SipAudioCall call);
+
+ /**
+ * Called when the session is established.
+ *
+ * @param call the call object that carries out the audio call
+ */
+ void onCallEstablished(SipAudioCall call);
+
+ /**
+ * Called when the session is terminated.
+ *
+ * @param call the call object that carries out the audio call
+ */
+ void onCallEnded(SipAudioCall call);
+
+ /**
+ * Called when the peer is busy during session initialization.
+ *
+ * @param call the call object that carries out the audio call
+ */
+ void onCallBusy(SipAudioCall call);
+
+ /**
+ * Called when the call is on hold.
+ *
+ * @param call the call object that carries out the audio call
+ */
+ void onCallHeld(SipAudioCall call);
+
+ /**
+ * Called when an error occurs.
+ *
+ * @param call the call object that carries out the audio call
+ * @param errorMessage error message
+ */
+ void onError(SipAudioCall call, String errorMessage);
+ }
+
+ /**
+ * The adapter class for {@link SipAudioCall#Listener}. The default
+ * implementation of all callback methods is no-op.
+ */
+ public class Adapter implements Listener {
+ protected void onChanged(SipAudioCall call) {
+ }
+ public void onReadyToCall(SipAudioCall call) {
+ onChanged(call);
+ }
+ public void onCalling(SipAudioCall call) {
+ onChanged(call);
+ }
+ public void onRinging(SipAudioCall call, SipProfile caller) {
+ onChanged(call);
+ }
+ public void onRingingBack(SipAudioCall call) {
+ onChanged(call);
+ }
+ public void onCallEstablished(SipAudioCall call) {
+ onChanged(call);
+ }
+ public void onCallEnded(SipAudioCall call) {
+ onChanged(call);
+ }
+ public void onCallBusy(SipAudioCall call) {
+ onChanged(call);
+ }
+ public void onCallHeld(SipAudioCall call) {
+ onChanged(call);
+ }
+ public void onError(SipAudioCall call, String errorMessage) {
+ onChanged(call);
+ }
+ }
+
+ /**
+ * Sets the listener to listen to the audio call events. The method calls
+ * {@link #setListener(Listener, false)}.
+ *
+ * @param listener to listen to the audio call events of this object
+ * @see #setListener(Listener, boolean)
+ */
+ void setListener(Listener listener);
+
+ /**
+ * Sets the listener to listen to the audio call events. A
+ * {@link SipAudioCall} can only hold one listener at a time. Subsequent
+ * calls to this method override the previous listener.
+ *
+ * @param listener to listen to the audio call events of this object
+ * @param callbackImmediately set to true if the caller wants to be called
+ * back immediately on the current state
+ */
+ void setListener(Listener listener, boolean callbackImmediately);
+
+ /**
+ * Closes this object. The object is not usable after being closed.
+ */
+ void close();
+
+ /**
+ * Initiates an audio call to the specified profile.
+ *
+ * @param callee the SIP profile to make the call to
+ * @param sipManager the {@link SipManager} object to help make call with
+ */
+ void makeCall(SipProfile callee, SipManager sipManager) throws SipException;
+
+ /**
+ * Attaches an incoming call to this call object.
+ *
+ * @param session the session that receives the incoming call
+ * @param sdp the session description of the incoming call
+ */
+ void attachCall(ISipSession session, SdpSessionDescription sdp)
+ throws SipException;
+
+ /** Ends a call. */
+ void endCall() throws SipException;
+
+ /**
+ * Puts a call on hold. When succeeds,
+ * {@link #Listener#onCallHeld(SipAudioCall)} is called.
+ */
+ void holdCall() throws SipException;
+
+ /** Answers a call. */
+ void answerCall() throws SipException;
+
+ /**
+ * Continues a call that's on hold. When succeeds,
+ * {@link #Listener#onCallEstablished(SipAudioCall)} is called.
+ */
+ void continueCall() throws SipException;
+
+ /** Puts the device to in-call mode. */
+ void setInCallMode();
+
+ /** Puts the device to speaker mode. */
+ void setSpeakerMode();
+
+ /** Toggles mute. */
+ void toggleMute();
+
+ /**
+ * Checks if the call is on hold.
+ *
+ * @return true if the call is on hold
+ */
+ boolean isOnHold();
+
+ /**
+ * Checks if the call is muted.
+ *
+ * @return true if the call is muted
+ */
+ boolean isMuted();
+
+ /**
+ * Sends a DTMF code.
+ *
+ * @param code the DTMF code to send
+ */
+ void sendDtmf(int code);
+
+ /**
+ * Sends a DTMF code.
+ *
+ * @param code the DTMF code to send
+ * @param result the result message to send when done
+ */
+ void sendDtmf(int code, Message result);
+
+ /**
+ * Gets the {@link AudioStream} object used in this call. The object
+ * represents the RTP stream that carries the audio data to and from the
+ * peer. The object may not be created before the call is established. And
+ * it is undefined after the call ends or the {@link #close} method is
+ * called.
+ *
+ * @return the {@link AudioStream} object or null if the RTP stream has not
+ * yet been set up
+ */
+ AudioStream getAudioStream();
+
+ /**
+ * Gets the {@link AudioGroup} object which the {@link AudioStream} object
+ * joins. The group object may not exist before the call is established.
+ * Also, the {@code AudioStream} may change its group during a call (e.g.,
+ * after the call is held/un-held). Finally, the {@code AudioGroup} object
+ * returned by this method is undefined after the call ends or the
+ * {@link #close} method is called.
+ *
+ * @return the {@link AudioGroup} object or null if the RTP stream has not
+ * yet been set up
+ * @see #getAudioStream
+ */
+ AudioGroup getAudioGroup();
+
+ /**
+ * Checks if the call is established.
+ *
+ * @return true if the call is established
+ */
+ boolean isInCall();
+
+ /**
+ * Gets the local SIP profile.
+ *
+ * @return the local SIP profile
+ */
+ SipProfile getLocalProfile();
+
+ /**
+ * Gets the peer's SIP profile.
+ *
+ * @return the peer's SIP profile
+ */
+ SipProfile getPeerProfile();
+
+ /**
+ * Gets the state of the {@link ISipSession} that carries this call.
+ *
+ * @return the session state
+ */
+ SipSessionState getState();
+
+ /**
+ * Gets the {@link ISipSession} that carries this call.
+ *
+ * @return the session object that carries this call
+ */
+ ISipSession getSipSession();
+
+ /**
+ * Enables/disables the ring-back tone.
+ *
+ * @param enabled true to enable; false to disable
+ */
+ void setRingbackToneEnabled(boolean enabled);
+
+ /**
+ * Enables/disables the ring tone.
+ *
+ * @param enabled true to enable; false to disable
+ */
+ void setRingtoneEnabled(boolean enabled);
+}
diff --git a/voip/java/android/net/sip/SipAudioCallImpl.java b/voip/java/android/net/sip/SipAudioCallImpl.java
new file mode 100644
index 0000000..57e0bd2
--- /dev/null
+++ b/voip/java/android/net/sip/SipAudioCallImpl.java
@@ -0,0 +1,701 @@
+/*
+ * 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 android.net.sip;
+
+import gov.nist.javax.sdp.fields.SDPKeywords;
+
+import android.content.Context;
+import android.media.AudioManager;
+import android.media.Ringtone;
+import android.media.RingtoneManager;
+import android.media.ToneGenerator;
+import android.net.Uri;
+import android.net.rtp.AudioCodec;
+import android.net.rtp.AudioGroup;
+import android.net.rtp.AudioStream;
+import android.net.rtp.RtpStream;
+import android.net.sip.ISipSession;
+import android.net.sip.SdpSessionDescription;
+import android.net.sip.SessionDescription;
+import android.net.sip.SipAudioCall;
+import android.net.sip.SipManager;
+import android.net.sip.SipProfile;
+import android.net.sip.SipSessionAdapter;
+import android.net.sip.SipSessionState;
+import android.os.Message;
+import android.os.RemoteException;
+import android.os.Vibrator;
+import android.provider.Settings;
+import android.util.Log;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.text.ParseException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.sdp.SdpException;
+import javax.sip.SipException;
+
+/**
+ * Class that handles an audio call over SIP.
+ */
+/** @hide */
+public class SipAudioCallImpl extends SipSessionAdapter
+ implements SipAudioCall {
+ private static final String TAG = SipAudioCallImpl.class.getSimpleName();
+ private static final boolean RELEASE_SOCKET = true;
+ private static final boolean DONT_RELEASE_SOCKET = false;
+ private static final String AUDIO = "audio";
+ private static final int DTMF = 101;
+
+ private Context mContext;
+ private SipProfile mLocalProfile;
+ private SipAudioCall.Listener mListener;
+ private ISipSession mSipSession;
+ private SdpSessionDescription mPeerSd;
+
+ private AudioStream mRtpSession;
+ private SdpSessionDescription.AudioCodec mCodec;
+ private long mSessionId = -1L; // SDP session ID
+ private boolean mInCall = false;
+ private boolean mMuted = false;
+ private boolean mHold = false;
+
+ private boolean mRingbackToneEnabled = true;
+ private boolean mRingtoneEnabled = true;
+ private Ringtone mRingtone;
+ private ToneGenerator mRingbackTone;
+
+ private SipProfile mPendingCallRequest;
+
+ public SipAudioCallImpl(Context context, SipProfile localProfile) {
+ mContext = context;
+ mLocalProfile = localProfile;
+ }
+
+ public void setListener(SipAudioCall.Listener listener) {
+ setListener(listener, false);
+ }
+
+ public void setListener(SipAudioCall.Listener listener,
+ boolean callbackImmediately) {
+ mListener = listener;
+ if ((listener == null) || !callbackImmediately) return;
+ try {
+ SipSessionState state = getState();
+ switch (state) {
+ case READY_TO_CALL:
+ listener.onReadyToCall(this);
+ break;
+ case INCOMING_CALL:
+ listener.onRinging(this, getPeerProfile(mSipSession));
+ startRinging();
+ break;
+ case OUTGOING_CALL:
+ listener.onCalling(this);
+ break;
+ default:
+ listener.onError(this, "wrong state to attach call: " + state);
+ }
+ } catch (Throwable t) {
+ Log.e(TAG, "setListener()", t);
+ }
+ }
+
+ public synchronized boolean isInCall() {
+ return mInCall;
+ }
+
+ public synchronized boolean isOnHold() {
+ return mHold;
+ }
+
+ public void close() {
+ close(true);
+ }
+
+ private synchronized void close(boolean closeRtp) {
+ if (closeRtp) stopCall(RELEASE_SOCKET);
+ stopRingbackTone();
+ stopRinging();
+ mSipSession = null;
+ mInCall = false;
+ mHold = false;
+ mSessionId = -1L;
+ }
+
+ public synchronized SipProfile getLocalProfile() {
+ return mLocalProfile;
+ }
+
+ public synchronized SipProfile getPeerProfile() {
+ try {
+ return (mSipSession == null) ? null : mSipSession.getPeerProfile();
+ } catch (RemoteException e) {
+ return null;
+ }
+ }
+
+ public synchronized SipSessionState getState() {
+ if (mSipSession == null) return SipSessionState.READY_TO_CALL;
+ try {
+ return Enum.valueOf(SipSessionState.class, mSipSession.getState());
+ } catch (RemoteException e) {
+ return SipSessionState.REMOTE_ERROR;
+ }
+ }
+
+
+ public synchronized ISipSession getSipSession() {
+ return mSipSession;
+ }
+
+ @Override
+ public void onCalling(ISipSession session) {
+ Log.d(TAG, "calling... " + session);
+ Listener listener = mListener;
+ if (listener != null) {
+ try {
+ listener.onCalling(SipAudioCallImpl.this);
+ } catch (Throwable t) {
+ Log.e(TAG, "onCalling()", t);
+ }
+ }
+ }
+
+ @Override
+ public void onRingingBack(ISipSession session) {
+ Log.d(TAG, "sip call ringing back: " + session);
+ if (!mInCall) startRingbackTone();
+ Listener listener = mListener;
+ if (listener != null) {
+ try {
+ listener.onRingingBack(SipAudioCallImpl.this);
+ } catch (Throwable t) {
+ Log.e(TAG, "onRingingBack()", t);
+ }
+ }
+ }
+
+ @Override
+ public synchronized void onRinging(ISipSession session,
+ SipProfile peerProfile, byte[] sessionDescription) {
+ try {
+ if ((mSipSession == null) || !mInCall
+ || !session.getCallId().equals(mSipSession.getCallId())) {
+ // should not happen
+ session.endCall();
+ return;
+ }
+
+ // session changing request
+ try {
+ mPeerSd = new SdpSessionDescription(sessionDescription);
+ answerCall();
+ } catch (Throwable e) {
+ Log.e(TAG, "onRinging()", e);
+ session.endCall();
+ }
+ } catch (RemoteException e) {
+ Log.e(TAG, "onRinging()", e);
+ }
+ }
+
+ private synchronized void establishCall(byte[] sessionDescription) {
+ stopRingbackTone();
+ stopRinging();
+ try {
+ SdpSessionDescription sd =
+ new SdpSessionDescription(sessionDescription);
+ Log.d(TAG, "sip call established: " + sd);
+ startCall(sd);
+ mInCall = true;
+ } catch (SdpException e) {
+ Log.e(TAG, "createSessionDescription()", e);
+ }
+ }
+
+ @Override
+ public void onCallEstablished(ISipSession session,
+ byte[] sessionDescription) {
+ establishCall(sessionDescription);
+ Listener listener = mListener;
+ if (listener != null) {
+ try {
+ if (mHold) {
+ listener.onCallHeld(SipAudioCallImpl.this);
+ } else {
+ listener.onCallEstablished(SipAudioCallImpl.this);
+ }
+ } catch (Throwable t) {
+ Log.e(TAG, "onCallEstablished()", t);
+ }
+ }
+ }
+
+ @Override
+ public void onCallEnded(ISipSession session) {
+ Log.d(TAG, "sip call ended: " + session);
+ close();
+ Listener listener = mListener;
+ if (listener != null) {
+ try {
+ listener.onCallEnded(SipAudioCallImpl.this);
+ } catch (Throwable t) {
+ Log.e(TAG, "onCallEnded()", t);
+ }
+ }
+ }
+
+ @Override
+ public void onCallBusy(ISipSession session) {
+ Log.d(TAG, "sip call busy: " + session);
+ close(false);
+ Listener listener = mListener;
+ if (listener != null) {
+ try {
+ listener.onCallBusy(SipAudioCallImpl.this);
+ } catch (Throwable t) {
+ Log.e(TAG, "onCallBusy()", t);
+ }
+ }
+ }
+
+ @Override
+ public void onCallChangeFailed(ISipSession session,
+ String className, String message) {
+ Log.d(TAG, "sip call change failed: " + message);
+ Listener listener = mListener;
+ if (listener != null) {
+ try {
+ listener.onError(SipAudioCallImpl.this,
+ className + ": " + message);
+ } catch (Throwable t) {
+ Log.e(TAG, "onCallBusy()", t);
+ }
+ }
+ }
+
+ @Override
+ public void onError(ISipSession session, String className,
+ String message) {
+ Log.d(TAG, "sip session error: " + className + ": " + message);
+ synchronized (this) {
+ if (!isInCall()) close(true);
+ }
+ Listener listener = mListener;
+ if (listener != null) {
+ try {
+ listener.onError(SipAudioCallImpl.this,
+ className + ": " + message);
+ } catch (Throwable t) {
+ Log.e(TAG, "onError()", t);
+ }
+ }
+ }
+
+ public synchronized void attachCall(ISipSession session,
+ SdpSessionDescription sdp) throws SipException {
+ mSipSession = session;
+ mPeerSd = sdp;
+ try {
+ session.setListener(this);
+ } catch (Throwable e) {
+ Log.e(TAG, "attachCall()", e);
+ throwSipException(e);
+ }
+ }
+
+ public synchronized void makeCall(SipProfile peerProfile,
+ SipManager sipManager) throws SipException {
+ try {
+ mSipSession = sipManager.createSipSession(mLocalProfile, this);
+ if (mSipSession == null) {
+ throw new SipException(
+ "Failed to create SipSession; network available?");
+ }
+ mSipSession.makeCall(peerProfile, createOfferSessionDescription());
+ } catch (Throwable e) {
+ if (e instanceof SipException) {
+ throw (SipException) e;
+ } else {
+ throwSipException(e);
+ }
+ }
+ }
+
+ public synchronized void endCall() throws SipException {
+ try {
+ stopRinging();
+ if (mSipSession != null) mSipSession.endCall();
+ stopCall(true);
+ } catch (Throwable e) {
+ throwSipException(e);
+ }
+ }
+
+ public synchronized void holdCall() throws SipException {
+ if (mHold) return;
+ try {
+ mSipSession.changeCall(createHoldSessionDescription());
+ mHold = true;
+ } catch (Throwable e) {
+ throwSipException(e);
+ }
+
+ AudioGroup audioGroup = getAudioGroup();
+ if (audioGroup != null) audioGroup.setMode(AudioGroup.MODE_ON_HOLD);
+ }
+
+ public synchronized void answerCall() throws SipException {
+ try {
+ stopRinging();
+ mSipSession.answerCall(createAnswerSessionDescription());
+ } catch (Throwable e) {
+ Log.e(TAG, "answerCall()", e);
+ throwSipException(e);
+ }
+ }
+
+ public synchronized void continueCall() throws SipException {
+ if (!mHold) return;
+ try {
+ mHold = false;
+ mSipSession.changeCall(createContinueSessionDescription());
+ } catch (Throwable e) {
+ throwSipException(e);
+ }
+
+ AudioGroup audioGroup = getAudioGroup();
+ if (audioGroup != null) audioGroup.setMode(AudioGroup.MODE_NORMAL);
+ }
+
+ private SessionDescription createOfferSessionDescription() {
+ AudioCodec[] codecs = AudioCodec.getSystemSupportedCodecs();
+ return createSdpBuilder(true, convert(codecs)).build();
+ }
+
+ private SessionDescription createAnswerSessionDescription() {
+ try {
+ // choose an acceptable media from mPeerSd to answer
+ SdpSessionDescription.AudioCodec codec = getCodec(mPeerSd);
+ SdpSessionDescription.Builder sdpBuilder =
+ createSdpBuilder(false, codec);
+ if (mPeerSd.isSendOnly(AUDIO)) {
+ sdpBuilder.addMediaAttribute(AUDIO, "recvonly", (String) null);
+ } else if (mPeerSd.isReceiveOnly(AUDIO)) {
+ sdpBuilder.addMediaAttribute(AUDIO, "sendonly", (String) null);
+ }
+ return sdpBuilder.build();
+ } catch (SdpException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private SessionDescription createHoldSessionDescription() {
+ try {
+ return createSdpBuilder(false, mCodec)
+ .addMediaAttribute(AUDIO, "sendonly", (String) null)
+ .build();
+ } catch (SdpException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private SessionDescription createContinueSessionDescription() {
+ return createSdpBuilder(true, mCodec).build();
+ }
+
+ private String getMediaDescription(SdpSessionDescription.AudioCodec codec) {
+ return String.format("%d %s/%d", codec.payloadType, codec.name,
+ codec.sampleRate);
+ }
+
+ private long getSessionId() {
+ if (mSessionId < 0) {
+ mSessionId = System.currentTimeMillis();
+ }
+ return mSessionId;
+ }
+
+ private SdpSessionDescription.Builder createSdpBuilder(
+ boolean addTelephoneEvent,
+ SdpSessionDescription.AudioCodec... codecs) {
+ String localIp = getLocalIp();
+ SdpSessionDescription.Builder sdpBuilder;
+ try {
+ long sessionVersion = System.currentTimeMillis();
+ sdpBuilder = new SdpSessionDescription.Builder("SIP Call")
+ .setOrigin(mLocalProfile, getSessionId(), sessionVersion,
+ SDPKeywords.IN, SDPKeywords.IPV4, localIp)
+ .setConnectionInfo(SDPKeywords.IN, SDPKeywords.IPV4,
+ localIp);
+ List<Integer> codecIds = new ArrayList<Integer>();
+ for (SdpSessionDescription.AudioCodec codec : codecs) {
+ codecIds.add(codec.payloadType);
+ }
+ if (addTelephoneEvent) codecIds.add(DTMF);
+ sdpBuilder.addMedia(AUDIO, getLocalMediaPort(), 1, "RTP/AVP",
+ codecIds.toArray(new Integer[codecIds.size()]));
+ for (SdpSessionDescription.AudioCodec codec : codecs) {
+ sdpBuilder.addMediaAttribute(AUDIO, "rtpmap",
+ getMediaDescription(codec));
+ }
+ if (addTelephoneEvent) {
+ sdpBuilder.addMediaAttribute(AUDIO, "rtpmap",
+ DTMF + " telephone-event/8000");
+ }
+ // FIXME: deal with vbr codec
+ sdpBuilder.addMediaAttribute(AUDIO, "ptime", "20");
+ } catch (SdpException e) {
+ throw new RuntimeException(e);
+ }
+ return sdpBuilder;
+ }
+
+ public synchronized void toggleMute() {
+ AudioGroup audioGroup = getAudioGroup();
+ if (audioGroup != null) {
+ audioGroup.setMode(
+ mMuted ? AudioGroup.MODE_NORMAL : AudioGroup.MODE_MUTED);
+ mMuted = !mMuted;
+ }
+ }
+
+ public synchronized boolean isMuted() {
+ return mMuted;
+ }
+
+ public synchronized void setInCallMode() {
+ ((AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE))
+ .setSpeakerphoneOn(false);
+ ((AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE))
+ .setMode(AudioManager.MODE_NORMAL);
+ }
+
+ public synchronized void setSpeakerMode() {
+ ((AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE))
+ .setSpeakerphoneOn(true);
+ }
+
+ public void sendDtmf(int code) {
+ sendDtmf(code, null);
+ }
+
+ public synchronized void sendDtmf(int code, Message result) {
+ AudioGroup audioGroup = getAudioGroup();
+ if ((audioGroup != null) && (mSipSession != null)
+ && (SipSessionState.IN_CALL == getState())) {
+ Log.v(TAG, "send DTMF: " + code);
+ audioGroup.sendDtmf(code);
+ }
+ if (result != null) result.sendToTarget();
+ }
+
+ public synchronized AudioStream getAudioStream() {
+ return mRtpSession;
+ }
+
+ public synchronized AudioGroup getAudioGroup() {
+ return ((mRtpSession == null) ? null : mRtpSession.getAudioGroup());
+ }
+
+ private SdpSessionDescription.AudioCodec getCodec(SdpSessionDescription sd) {
+ HashMap<String, AudioCodec> acceptableCodecs =
+ new HashMap<String, AudioCodec>();
+ for (AudioCodec codec : AudioCodec.getSystemSupportedCodecs()) {
+ acceptableCodecs.put(codec.name, codec);
+ }
+ for (SdpSessionDescription.AudioCodec codec : sd.getAudioCodecs()) {
+ AudioCodec matchedCodec = acceptableCodecs.get(codec.name);
+ if (matchedCodec != null) return codec;
+ }
+ Log.w(TAG, "no common codec is found, use PCM/0");
+ return convert(AudioCodec.ULAW);
+ }
+
+ private AudioCodec convert(SdpSessionDescription.AudioCodec codec) {
+ AudioCodec c = AudioCodec.getSystemSupportedCodec(codec.name);
+ return ((c == null) ? AudioCodec.ULAW : c);
+ }
+
+ private SdpSessionDescription.AudioCodec convert(AudioCodec codec) {
+ return new SdpSessionDescription.AudioCodec(codec.defaultType,
+ codec.name, codec.sampleRate, codec.sampleCount);
+ }
+
+ private SdpSessionDescription.AudioCodec[] convert(AudioCodec[] codecs) {
+ SdpSessionDescription.AudioCodec[] copies =
+ new SdpSessionDescription.AudioCodec[codecs.length];
+ for (int i = 0, len = codecs.length; i < len; i++) {
+ copies[i] = convert(codecs[i]);
+ }
+ return copies;
+ }
+
+ private void startCall(SdpSessionDescription peerSd) {
+ stopCall(DONT_RELEASE_SOCKET);
+
+ mPeerSd = peerSd;
+ String peerMediaAddress = peerSd.getPeerMediaAddress(AUDIO);
+ // TODO: handle multiple media fields
+ int peerMediaPort = peerSd.getPeerMediaPort(AUDIO);
+ Log.i(TAG, "start audiocall " + peerMediaAddress + ":" + peerMediaPort);
+
+ int localPort = getLocalMediaPort();
+ int sampleRate = 8000;
+ int frameSize = sampleRate / 50; // 160
+ try {
+ // TODO: get sample rate from sdp
+ mCodec = getCodec(peerSd);
+
+ AudioStream audioStream = mRtpSession;
+ audioStream.associate(InetAddress.getByName(peerMediaAddress),
+ peerMediaPort);
+ audioStream.setCodec(convert(mCodec), mCodec.payloadType);
+ audioStream.setDtmfType(DTMF);
+ Log.d(TAG, "start media: localPort=" + localPort + ", peer="
+ + peerMediaAddress + ":" + peerMediaPort);
+
+ audioStream.setMode(RtpStream.MODE_NORMAL);
+ if (!mHold) {
+ // FIXME: won't work if peer is not sending nor receiving
+ if (!peerSd.isSending(AUDIO)) {
+ Log.d(TAG, " not receiving");
+ audioStream.setMode(RtpStream.MODE_SEND_ONLY);
+ }
+ if (!peerSd.isReceiving(AUDIO)) {
+ Log.d(TAG, " not sending");
+ audioStream.setMode(RtpStream.MODE_RECEIVE_ONLY);
+ }
+ }
+ setInCallMode();
+
+ AudioGroup audioGroup = new AudioGroup();
+ audioStream.join(audioGroup);
+ if (mHold) {
+ audioGroup.setMode(AudioGroup.MODE_ON_HOLD);
+ } else if (mMuted) {
+ audioGroup.setMode(AudioGroup.MODE_MUTED);
+ } else {
+ audioGroup.setMode(AudioGroup.MODE_NORMAL);
+ }
+ } catch (Exception e) {
+ Log.e(TAG, "call()", e);
+ }
+ }
+
+ private void stopCall(boolean releaseSocket) {
+ Log.d(TAG, "stop audiocall");
+ if (mRtpSession != null) {
+ mRtpSession.join(null);
+
+ if (releaseSocket) {
+ mRtpSession.release();
+ mRtpSession = null;
+ }
+ }
+ setInCallMode();
+ }
+
+ private int getLocalMediaPort() {
+ if (mRtpSession != null) return mRtpSession.getLocalPort();
+ try {
+ AudioStream s = mRtpSession =
+ new AudioStream(InetAddress.getByName(getLocalIp()));
+ return s.getLocalPort();
+ } catch (IOException e) {
+ Log.w(TAG, "getLocalMediaPort(): " + e);
+ throw new RuntimeException(e);
+ }
+ }
+
+ private String getLocalIp() {
+ try {
+ return mSipSession.getLocalIp();
+ } catch (RemoteException e) {
+ // FIXME
+ return "127.0.0.1";
+ }
+ }
+
+ public synchronized void setRingbackToneEnabled(boolean enabled) {
+ mRingbackToneEnabled = enabled;
+ }
+
+ public synchronized void setRingtoneEnabled(boolean enabled) {
+ mRingtoneEnabled = enabled;
+ }
+
+ private void startRingbackTone() {
+ if (!mRingbackToneEnabled) return;
+ if (mRingbackTone == null) {
+ // The volume relative to other sounds in the stream
+ int toneVolume = 80;
+ mRingbackTone = new ToneGenerator(
+ AudioManager.STREAM_VOICE_CALL, toneVolume);
+ }
+ mRingbackTone.startTone(ToneGenerator.TONE_CDMA_LOW_PBX_L);
+ }
+
+ private void stopRingbackTone() {
+ if (mRingbackTone != null) {
+ mRingbackTone.stopTone();
+ mRingbackTone.release();
+ mRingbackTone = null;
+ }
+ }
+
+ private void startRinging() {
+ if (!mRingtoneEnabled) return;
+ ((Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE))
+ .vibrate(new long[] {0, 1000, 1000}, 1);
+ AudioManager am = (AudioManager)
+ mContext.getSystemService(Context.AUDIO_SERVICE);
+ if (am.getStreamVolume(AudioManager.STREAM_RING) > 0) {
+ String ringtoneUri =
+ Settings.System.DEFAULT_RINGTONE_URI.toString();
+ mRingtone = RingtoneManager.getRingtone(mContext,
+ Uri.parse(ringtoneUri));
+ mRingtone.play();
+ }
+ }
+
+ private void stopRinging() {
+ ((Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE))
+ .cancel();
+ if (mRingtone != null) mRingtone.stop();
+ }
+
+ private void throwSipException(Throwable throwable) throws SipException {
+ if (throwable instanceof SipException) {
+ throw (SipException) throwable;
+ } else {
+ throw new SipException("", throwable);
+ }
+ }
+
+ private SipProfile getPeerProfile(ISipSession session) {
+ try {
+ return session.getPeerProfile();
+ } catch (RemoteException e) {
+ return null;
+ }
+ }
+}
diff --git a/voip/java/android/net/sip/SipManager.java b/voip/java/android/net/sip/SipManager.java
new file mode 100644
index 0000000..f28b41c
--- /dev/null
+++ b/voip/java/android/net/sip/SipManager.java
@@ -0,0 +1,499 @@
+/*
+ * 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 android.net.sip;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.Looper;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+
+import java.text.ParseException;
+import javax.sip.SipException;
+
+/**
+ * The class provides API for various SIP related tasks. Specifically, the API
+ * allows the application to:
+ * <ul>
+ * <li>register a {@link SipProfile} to have the background SIP service listen
+ * to incoming calls and broadcast them with registered command string. See
+ * {@link #open(SipProfile, String, SipRegistrationListener)},
+ * {@link #open(SipProfile)}, {@link #close(String)},
+ * {@link #isOpened(String)} and {@link isRegistered(String)}. It also
+ * facilitates handling of the incoming call broadcast intent. See
+ * {@link #isIncomingCallIntent(Intent)}, {@link #getCallId(Intent)},
+ * {@link #getOfferSessionDescription(Intent)} and
+ * {@link #takeAudioCall(Context, Intent, SipAudioCall.Listener)}.</li>
+ * <li>make/take SIP-based audio calls. See
+ * {@link #makeAudioCall(Context, SipProfile, SipProfile, SipAudioCall.Listener)}
+ * and {@link #takeAudioCall(Context, Intent, SipAudioCall.Listener}.</li>
+ * <li>register/unregister with a SIP service provider. See
+ * {@link #register(SipProfile, int, ISipSessionListener)} and
+ * {@link #unregister(SipProfile, ISipSessionListener)}.</li>
+ * <li>process SIP events directly with a {@link ISipSession} created by
+ * {@link createSipSession(SipProfile, ISipSessionListener)}.</li>
+ * </ul>
+ * @hide
+ */
+public class SipManager {
+ /** @hide */
+ public static final String SIP_INCOMING_CALL_ACTION =
+ "com.android.phone.SIP_INCOMING_CALL";
+ /** @hide */
+ public static final String SIP_ADD_PHONE_ACTION =
+ "com.android.phone.SIP_ADD_PHONE";
+ /** @hide */
+ public static final String SIP_REMOVE_PHONE_ACTION =
+ "com.android.phone.SIP_REMOVE_PHONE";
+ /** @hide */
+ public static final String LOCAL_URI_KEY = "LOCAL SIPURI";
+
+ private static final String CALL_ID_KEY = "CallID";
+ private static final String OFFER_SD_KEY = "OfferSD";
+
+ private ISipService mSipService;
+
+ // Will be removed once the SIP service is integrated into framework
+ private BinderHelper<ISipService> mBinderHelper;
+
+ /**
+ * Creates a manager instance and initializes the background SIP service.
+ * Will be removed once the SIP service is integrated into framework.
+ *
+ * @param context context to start the SIP service
+ * @return the manager instance
+ */
+ public static SipManager getInstance(final Context context) {
+ final SipManager manager = new SipManager();
+ manager.createSipService(context);
+ return manager;
+ }
+
+ private SipManager() {
+ }
+
+ private void createSipService(Context context) {
+ if (mSipService != null) return;
+ IBinder b = ServiceManager.getService(Context.SIP_SERVICE);
+ mSipService = ISipService.Stub.asInterface(b);
+ }
+
+ /**
+ * Opens the profile for making calls and/or receiving calls. Subsequent
+ * SIP calls can be made through the default phone UI. The caller may also
+ * make subsequent calls through
+ * {@link #makeAudioCall(Context, String, String, SipAudioCall.Listener)}.
+ * If the receiving-call option is enabled in the profile, the SIP service
+ * will register the profile to the corresponding server periodically in
+ * order to receive calls from the server.
+ *
+ * @param localProfile the SIP profile to make calls from
+ * @throws SipException if the profile contains incorrect settings or
+ * calling the SIP service results in an error
+ */
+ public void open(SipProfile localProfile) throws SipException {
+ try {
+ mSipService.open(localProfile);
+ } catch (RemoteException e) {
+ throw new SipException("open()", e);
+ }
+ }
+
+ /**
+ * Opens the profile for making calls and/or receiving calls. Subsequent
+ * SIP calls can be made through the default phone UI. The caller may also
+ * make subsequent calls through
+ * {@link #makeAudioCall(Context, String, String, SipAudioCall.Listener)}.
+ * If the receiving-call option is enabled in the profile, the SIP service
+ * will register the profile to the corresponding server periodically in
+ * order to receive calls from the server.
+ *
+ * @param localProfile the SIP profile to receive incoming calls for
+ * @param incomingCallBroadcastAction the action to be broadcast when an
+ * incoming call is received
+ * @param listener to listen to registration events; can be null
+ * @throws SipException if the profile contains incorrect settings or
+ * calling the SIP service results in an error
+ */
+ public void open(SipProfile localProfile,
+ String incomingCallBroadcastAction,
+ SipRegistrationListener listener) throws SipException {
+ try {
+ mSipService.open3(localProfile, incomingCallBroadcastAction,
+ createRelay(listener));
+ } catch (RemoteException e) {
+ throw new SipException("open()", e);
+ }
+ }
+
+ /**
+ * Sets the listener to listen to registration events. No effect if the
+ * profile has not been opened to receive calls
+ * (see {@link #open(SipProfile, String, SipRegistrationListener)} and
+ * {@link #open(SipProfile)}).
+ *
+ * @param localProfileUri the URI of the profile
+ * @param listener to listen to registration events; can be null
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public void setRegistrationListener(String localProfileUri,
+ SipRegistrationListener listener) throws SipException {
+ try {
+ mSipService.setRegistrationListener(
+ localProfileUri, createRelay(listener));
+ } catch (RemoteException e) {
+ throw new SipException("setRegistrationListener()", e);
+ }
+ }
+
+ /**
+ * Closes the specified profile to not make/receive calls. All the resources
+ * that were allocated to the profile are also released.
+ *
+ * @param localProfileUri the URI of the profile to close
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public void close(String localProfileUri) throws SipException {
+ try {
+ mSipService.close(localProfileUri);
+ } catch (RemoteException e) {
+ throw new SipException("close()", e);
+ }
+ }
+
+ /**
+ * Checks if the specified profile is enabled to receive calls.
+ *
+ * @param localProfileUri the URI of the profile in question
+ * @return true if the profile is enabled to receive calls
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public boolean isOpened(String localProfileUri) throws SipException {
+ try {
+ return mSipService.isOpened(localProfileUri);
+ } catch (RemoteException e) {
+ throw new SipException("isOpened()", e);
+ }
+ }
+
+ /**
+ * Checks if the specified profile is registered to the server for
+ * receiving calls.
+ *
+ * @param localProfileUri the URI of the profile in question
+ * @return true if the profile is registered to the server
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public boolean isRegistered(String localProfileUri) throws SipException {
+ try {
+ return mSipService.isRegistered(localProfileUri);
+ } catch (RemoteException e) {
+ throw new SipException("isRegistered()", e);
+ }
+ }
+
+ /**
+ * Creates a {@link SipAudioCall} to make a call.
+ *
+ * @param context context to create a {@link SipAudioCall} object
+ * @param localProfile the SIP profile to make the call from
+ * @param peerProfile the SIP profile to make the call to
+ * @param listener to listen to the call events from {@link SipAudioCall};
+ * can be null
+ * @return a {@link SipAudioCall} object
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public SipAudioCall makeAudioCall(Context context, SipProfile localProfile,
+ SipProfile peerProfile, SipAudioCall.Listener listener)
+ throws SipException {
+ SipAudioCall call = new SipAudioCallImpl(context, localProfile);
+ call.setListener(listener);
+ call.makeCall(peerProfile, this);
+ return call;
+ }
+
+ /**
+ * Creates a {@link SipAudioCall} to make a call. To use this method, one
+ * must call {@link #open(SipProfile)} first.
+ *
+ * @param context context to create a {@link SipAudioCall} object
+ * @param localProfileUri URI of the SIP profile to make the call from
+ * @param peerProfileUri URI of the SIP profile to make the call to
+ * @param listener to listen to the call events from {@link SipAudioCall};
+ * can be null
+ * @return a {@link SipAudioCall} object
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public SipAudioCall makeAudioCall(Context context, String localProfileUri,
+ String peerProfileUri, SipAudioCall.Listener listener)
+ throws SipException {
+ try {
+ return makeAudioCall(context,
+ new SipProfile.Builder(localProfileUri).build(),
+ new SipProfile.Builder(peerProfileUri).build(), listener);
+ } catch (ParseException e) {
+ throw new SipException("build SipProfile", e);
+ }
+ }
+
+ /**
+ * The method calls {@code takeAudioCall(context, incomingCallIntent,
+ * listener, true}.
+ *
+ * @see #takeAudioCall(Context, Intent, SipAudioCall.Listener, boolean)
+ */
+ public SipAudioCall takeAudioCall(Context context,
+ Intent incomingCallIntent, SipAudioCall.Listener listener)
+ throws SipException {
+ return takeAudioCall(context, incomingCallIntent, listener, true);
+ }
+
+ /**
+ * Creates a {@link SipAudioCall} to take an incoming call. Before the call
+ * is returned, the listener will receive a
+ * {@link SipAudioCall#Listener.onRinging(SipAudioCall, SipProfile)}
+ * callback.
+ *
+ * @param context context to create a {@link SipAudioCall} object
+ * @param incomingCallIntent the incoming call broadcast intent
+ * @param listener to listen to the call events from {@link SipAudioCall};
+ * can be null
+ * @return a {@link SipAudioCall} object
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public SipAudioCall takeAudioCall(Context context,
+ Intent incomingCallIntent, SipAudioCall.Listener listener,
+ boolean ringtoneEnabled) throws SipException {
+ if (incomingCallIntent == null) return null;
+
+ String callId = getCallId(incomingCallIntent);
+ if (callId == null) {
+ throw new SipException("Call ID missing in incoming call intent");
+ }
+
+ byte[] offerSd = getOfferSessionDescription(incomingCallIntent);
+ if (offerSd == null) {
+ throw new SipException("Session description missing in incoming "
+ + "call intent");
+ }
+
+ try {
+ SdpSessionDescription sdp = new SdpSessionDescription(offerSd);
+
+ ISipSession session = mSipService.getPendingSession(callId);
+ if (session == null) return null;
+ SipAudioCall call = new SipAudioCallImpl(
+ context, session.getLocalProfile());
+ call.setRingtoneEnabled(ringtoneEnabled);
+ call.attachCall(session, sdp);
+ call.setListener(listener);
+ return call;
+ } catch (Throwable t) {
+ throw new SipException("takeAudioCall()", t);
+ }
+ }
+
+ /**
+ * Checks if the intent is an incoming call broadcast intent.
+ *
+ * @param intent the intent in question
+ * @return true if the intent is an incoming call broadcast intent
+ */
+ public static boolean isIncomingCallIntent(Intent intent) {
+ if (intent == null) return false;
+ String callId = getCallId(intent);
+ byte[] offerSd = getOfferSessionDescription(intent);
+ return ((callId != null) && (offerSd != null));
+ }
+
+ /**
+ * Gets the call ID from the specified incoming call broadcast intent.
+ *
+ * @param incomingCallIntent the incoming call broadcast intent
+ * @return the call ID or null if the intent does not contain it
+ */
+ public static String getCallId(Intent incomingCallIntent) {
+ return incomingCallIntent.getStringExtra(CALL_ID_KEY);
+ }
+
+ /**
+ * Gets the offer session description from the specified incoming call
+ * broadcast intent.
+ *
+ * @param incomingCallIntent the incoming call broadcast intent
+ * @return the offer session description or null if the intent does not
+ * have it
+ */
+ public static byte[] getOfferSessionDescription(Intent incomingCallIntent) {
+ return incomingCallIntent.getByteArrayExtra(OFFER_SD_KEY);
+ }
+
+ /**
+ * Creates an incoming call broadcast intent.
+ *
+ * @param action the action string to broadcast
+ * @param callId the call ID of the incoming call
+ * @param sessionDescription the session description of the incoming call
+ * @return the incoming call intent
+ * @hide
+ */
+ public static Intent createIncomingCallBroadcast(String action,
+ String callId, byte[] sessionDescription) {
+ Intent intent = new Intent(action);
+ intent.putExtra(CALL_ID_KEY, callId);
+ intent.putExtra(OFFER_SD_KEY, sessionDescription);
+ return intent;
+ }
+
+ /**
+ * Registers the profile to the corresponding server for receiving calls.
+ * {@link #open(SipProfile, String, SipRegistrationListener)} is still
+ * needed to be called at least once in order for the SIP service to
+ * broadcast an intent when an incoming call is received.
+ *
+ * @param localProfile the SIP profile to register with
+ * @param expiryTime registration expiration time (in second)
+ * @param listener to listen to the registration events
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public void register(SipProfile localProfile, int expiryTime,
+ SipRegistrationListener listener) throws SipException {
+ try {
+ ISipSession session = mSipService.createSession(
+ localProfile, createRelay(listener));
+ session.register(expiryTime);
+ } catch (RemoteException e) {
+ throw new SipException("register()", e);
+ }
+ }
+
+ /**
+ * Unregisters the profile from the corresponding server for not receiving
+ * further calls.
+ *
+ * @param localProfile the SIP profile to register with
+ * @param listener to listen to the registration events
+ * @throws SipException if calling the SIP service results in an error
+ */
+ public void unregister(SipProfile localProfile,
+ SipRegistrationListener listener) throws SipException {
+ try {
+ ISipSession session = mSipService.createSession(
+ localProfile, createRelay(listener));
+ session.unregister();
+ } catch (RemoteException e) {
+ throw new SipException("unregister()", e);
+ }
+ }
+
+ /**
+ * Gets the {@link ISipSession} that handles the incoming call. For audio
+ * calls, consider to use {@link SipAudioCall} to handle the incoming call.
+ * See {@link #takeAudioCall(Context, Intent, SipAudioCall.Listener)}.
+ * Note that the method may be called only once for the same intent. For
+ * subsequent calls on the same intent, the method returns null.
+ *
+ * @param incomingCallIntent the incoming call broadcast intent
+ * @return the session object that handles the incoming call
+ */
+ public ISipSession getSessionFor(Intent incomingCallIntent)
+ throws SipException {
+ try {
+ String callId = getCallId(incomingCallIntent);
+ return mSipService.getPendingSession(callId);
+ } catch (RemoteException e) {
+ throw new SipException("getSessionFor()", e);
+ }
+ }
+
+ private static ISipSessionListener createRelay(
+ SipRegistrationListener listener) {
+ return ((listener == null) ? null : new ListenerRelay(listener));
+ }
+
+ /**
+ * Creates a {@link ISipSession} with the specified profile. Use other
+ * methods, if applicable, instead of interacting with {@link ISipSession}
+ * directly.
+ *
+ * @param localProfile the SIP profile the session is associated with
+ * @param listener to listen to SIP session events
+ */
+ public ISipSession createSipSession(SipProfile localProfile,
+ ISipSessionListener listener) throws SipException {
+ try {
+ return mSipService.createSession(localProfile, listener);
+ } catch (RemoteException e) {
+ throw new SipException("createSipSession()", e);
+ }
+ }
+
+ /**
+ * Gets the list of profiles hosted by the SIP service. The user information
+ * (username, password and display name) are crossed out.
+ * @hide
+ */
+ public SipProfile[] getListOfProfiles() {
+ try {
+ return mSipService.getListOfProfiles();
+ } catch (RemoteException e) {
+ return null;
+ }
+ }
+
+ private static class ListenerRelay extends SipSessionAdapter {
+ private SipRegistrationListener mListener;
+
+ // listener must not be null
+ public ListenerRelay(SipRegistrationListener listener) {
+ mListener = listener;
+ }
+
+ private String getUri(ISipSession session) {
+ try {
+ return session.getLocalProfile().getUriString();
+ } catch (RemoteException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Override
+ public void onRegistering(ISipSession session) {
+ mListener.onRegistering(getUri(session));
+ }
+
+ @Override
+ public void onRegistrationDone(ISipSession session, int duration) {
+ long expiryTime = duration;
+ if (duration > 0) expiryTime += System.currentTimeMillis();
+ mListener.onRegistrationDone(getUri(session), expiryTime);
+ }
+
+ @Override
+ public void onRegistrationFailed(ISipSession session, String className,
+ String message) {
+ mListener.onRegistrationFailed(getUri(session), className, message);
+ }
+
+ @Override
+ public void onRegistrationTimeout(ISipSession session) {
+ mListener.onRegistrationFailed(getUri(session),
+ SipException.class.getName(), "registration timed out");
+ }
+ }
+}
diff --git a/voip/java/android/net/sip/SipProfile.aidl b/voip/java/android/net/sip/SipProfile.aidl
new file mode 100644
index 0000000..3b6f68f
--- /dev/null
+++ b/voip/java/android/net/sip/SipProfile.aidl
@@ -0,0 +1,19 @@
+/*
+ * 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 android.net.sip;
+
+parcelable SipProfile;
diff --git a/voip/java/android/net/sip/SipProfile.java b/voip/java/android/net/sip/SipProfile.java
new file mode 100644
index 0000000..e71c293
--- /dev/null
+++ b/voip/java/android/net/sip/SipProfile.java
@@ -0,0 +1,401 @@
+/*
+ * 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 android.net.sip;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.text.TextUtils;
+
+import java.io.Serializable;
+import java.text.ParseException;
+import javax.sip.InvalidArgumentException;
+import javax.sip.ListeningPoint;
+import javax.sip.PeerUnavailableException;
+import javax.sip.SipFactory;
+import javax.sip.address.Address;
+import javax.sip.address.AddressFactory;
+import javax.sip.address.SipURI;
+import javax.sip.address.URI;
+
+/**
+ * Class containing a SIP account, domain and server information.
+ * @hide
+ */
+public class SipProfile implements Parcelable, Serializable {
+ private static final long serialVersionUID = 1L;
+ private static final int DEFAULT_PORT = 5060;
+ private Address mAddress;
+ private String mProxyAddress;
+ private String mPassword;
+ private String mDomain;
+ private String mProtocol = ListeningPoint.UDP;
+ private String mProfileName;
+ private boolean mSendKeepAlive = false;
+ private boolean mAutoRegistration = true;
+
+ /** @hide */
+ public static final Parcelable.Creator<SipProfile> CREATOR =
+ new Parcelable.Creator<SipProfile>() {
+ public SipProfile createFromParcel(Parcel in) {
+ return new SipProfile(in);
+ }
+
+ public SipProfile[] newArray(int size) {
+ return new SipProfile[size];
+ }
+ };
+
+ /**
+ * Class to help create a {@link SipProfile}.
+ */
+ public static class Builder {
+ private AddressFactory mAddressFactory;
+ private SipProfile mProfile = new SipProfile();
+ private SipURI mUri;
+ private String mDisplayName;
+ private String mProxyAddress;
+
+ {
+ try {
+ mAddressFactory =
+ SipFactory.getInstance().createAddressFactory();
+ } catch (PeerUnavailableException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param uriString the URI string as "sip:<user_name>@<domain>"
+ * @throws ParseException if the string is not a valid URI
+ */
+ public Builder(String uriString) throws ParseException {
+ if (uriString == null) {
+ throw new NullPointerException("uriString cannot be null");
+ }
+ URI uri = mAddressFactory.createURI(fix(uriString));
+ if (uri instanceof SipURI) {
+ mUri = (SipURI) uri;
+ } else {
+ throw new ParseException(uriString + " is not a SIP URI", 0);
+ }
+ mProfile.mDomain = mUri.getHost();
+ }
+
+ /**
+ * Constructor.
+ *
+ * @param username username of the SIP account
+ * @param serverDomain the SIP server domain; if the network address
+ * is different from the domain, use
+ * {@link #setOutboundProxy(String)} to set server address
+ * @throws ParseException if the parameters are not valid
+ */
+ public Builder(String username, String serverDomain)
+ throws ParseException {
+ if ((username == null) || (serverDomain == null)) {
+ throw new NullPointerException(
+ "username and serverDomain cannot be null");
+ }
+ mUri = mAddressFactory.createSipURI(username, serverDomain);
+ mProfile.mDomain = serverDomain;
+ }
+
+ private String fix(String uriString) {
+ return (uriString.trim().toLowerCase().startsWith("sip:")
+ ? uriString
+ : "sip:" + uriString);
+ }
+
+ /**
+ * Sets the name of the profile. This name is given by user.
+ *
+ * @param name name of the profile
+ * @return this builder object
+ */
+ public Builder setProfileName(String name) {
+ mProfile.mProfileName = name;
+ return this;
+ }
+
+ /**
+ * Sets the password of the SIP account
+ *
+ * @param password password of the SIP account
+ * @return this builder object
+ */
+ public Builder setPassword(String password) {
+ mUri.setUserPassword(password);
+ return this;
+ }
+
+ /**
+ * Sets the port number of the server. By default, it is 5060.
+ *
+ * @param port port number of the server
+ * @return this builder object
+ * @throws InvalidArgumentException if the port number is out of range
+ */
+ public Builder setPort(int port) throws InvalidArgumentException {
+ mUri.setPort(port);
+ return this;
+ }
+
+ /**
+ * Sets the protocol used to connect to the SIP server. Currently,
+ * only "UDP" and "TCP" are supported.
+ *
+ * @param protocol the protocol string
+ * @return this builder object
+ * @throws InvalidArgumentException if the protocol is not recognized
+ */
+ public Builder setProtocol(String protocol)
+ throws InvalidArgumentException {
+ if (protocol == null) {
+ throw new NullPointerException("protocol cannot be null");
+ }
+ protocol = protocol.toUpperCase();
+ if (!protocol.equals("UDP") && !protocol.equals("TCP")) {
+ throw new InvalidArgumentException(
+ "unsupported protocol: " + protocol);
+ }
+ mProfile.mProtocol = protocol;
+ return this;
+ }
+
+ /**
+ * Sets the outbound proxy of the SIP server.
+ *
+ * @param outboundProxy the network address of the outbound proxy
+ * @return this builder object
+ */
+ public Builder setOutboundProxy(String outboundProxy) {
+ mProxyAddress = outboundProxy;
+ return this;
+ }
+
+ /**
+ * Sets the display name of the user.
+ *
+ * @param displayName display name of the user
+ * @return this builder object
+ */
+ public Builder setDisplayName(String displayName) {
+ mDisplayName = displayName;
+ return this;
+ }
+
+ /**
+ * Sets the send keep-alive flag.
+ *
+ * @param flag true if sending keep-alive message is required,
+ * false otherwise
+ * @return this builder object
+ */
+ public Builder setSendKeepAlive(boolean flag) {
+ mProfile.mSendKeepAlive = flag;
+ return this;
+ }
+
+
+ /**
+ * Sets the auto. registration flag.
+ *
+ * @param flag true if the profile will be registered automatically,
+ * false otherwise
+ * @return this builder object
+ */
+ public Builder setAutoRegistration(boolean flag) {
+ mProfile.mAutoRegistration = flag;
+ return this;
+ }
+
+ /**
+ * Builds and returns the SIP profile object.
+ *
+ * @return the profile object created
+ */
+ public SipProfile build() {
+ // remove password from URI
+ mProfile.mPassword = mUri.getUserPassword();
+ mUri.setUserPassword(null);
+ try {
+ mProfile.mAddress = mAddressFactory.createAddress(
+ mDisplayName, mUri);
+ if (!TextUtils.isEmpty(mProxyAddress)) {
+ SipURI uri = (SipURI)
+ mAddressFactory.createURI(fix(mProxyAddress));
+ mProfile.mProxyAddress = uri.getHost();
+ }
+ } catch (ParseException e) {
+ // must not occur
+ throw new RuntimeException(e);
+ }
+ return mProfile;
+ }
+ }
+
+ private SipProfile() {
+ }
+
+ private SipProfile(Parcel in) {
+ mAddress = (Address) in.readSerializable();
+ mProxyAddress = in.readString();
+ mPassword = in.readString();
+ mDomain = in.readString();
+ mProtocol = in.readString();
+ mProfileName = in.readString();
+ mSendKeepAlive = (in.readInt() == 0) ? false : true;
+ mAutoRegistration = (in.readInt() == 0) ? false : true;
+ }
+
+ /** @hide */
+ public void writeToParcel(Parcel out, int flags) {
+ out.writeSerializable(mAddress);
+ out.writeString(mProxyAddress);
+ out.writeString(mPassword);
+ out.writeString(mDomain);
+ out.writeString(mProtocol);
+ out.writeString(mProfileName);
+ out.writeInt(mSendKeepAlive ? 1 : 0);
+ out.writeInt(mAutoRegistration ? 1 : 0);
+ }
+
+ /** @hide */
+ public int describeContents() {
+ return 0;
+ }
+
+ /**
+ * Gets the SIP URI of this profile.
+ *
+ * @return the SIP URI of this profile
+ */
+ public SipURI getUri() {
+ return (SipURI) mAddress.getURI();
+ }
+
+ /**
+ * Gets the SIP URI string of this profile.
+ *
+ * @return the SIP URI string of this profile
+ */
+ public String getUriString() {
+ return mAddress.getURI().toString();
+ }
+
+ /**
+ * Gets the SIP address of this profile.
+ *
+ * @return the SIP address of this profile
+ */
+ public Address getSipAddress() {
+ return mAddress;
+ }
+
+ /**
+ * Gets the display name of the user.
+ *
+ * @return the display name of the user
+ */
+ public String getDisplayName() {
+ return mAddress.getDisplayName();
+ }
+
+ /**
+ * Gets the username.
+ *
+ * @return the username
+ */
+ public String getUserName() {
+ return getUri().getUser();
+ }
+
+ /**
+ * Gets the password.
+ *
+ * @return the password
+ */
+ public String getPassword() {
+ return mPassword;
+ }
+
+ /**
+ * Gets the SIP domain.
+ *
+ * @return the SIP domain
+ */
+ public String getSipDomain() {
+ return mDomain;
+ }
+
+ /**
+ * Gets the port number of the SIP server.
+ *
+ * @return the port number of the SIP server
+ */
+ public int getPort() {
+ int port = getUri().getPort();
+ return (port == -1) ? DEFAULT_PORT : port;
+ }
+
+ /**
+ * Gets the protocol used to connect to the server.
+ *
+ * @return the protocol
+ */
+ public String getProtocol() {
+ return mProtocol;
+ }
+
+ /**
+ * Gets the network address of the server outbound proxy.
+ *
+ * @return the network address of the server outbound proxy
+ */
+ public String getProxyAddress() {
+ return mProxyAddress;
+ }
+
+ /**
+ * Gets the (user-defined) name of the profile.
+ *
+ * @return name of the profile
+ */
+ public String getProfileName() {
+ return mProfileName;
+ }
+
+ /**
+ * Gets the flag of 'Sending keep-alive'.
+ *
+ * @return the flag of sending SIP keep-alive messages.
+ */
+ public boolean getSendKeepAlive() {
+ return mSendKeepAlive;
+ }
+
+ /**
+ * Gets the flag of 'Auto Registration'.
+ *
+ * @return the flag of registering the profile automatically.
+ */
+ public boolean getAutoRegistration() {
+ return mAutoRegistration;
+ }
+}
diff --git a/voip/java/android/net/sip/SipRegistrationListener.java b/voip/java/android/net/sip/SipRegistrationListener.java
new file mode 100644
index 0000000..63faaf8
--- /dev/null
+++ b/voip/java/android/net/sip/SipRegistrationListener.java
@@ -0,0 +1,48 @@
+/*
+ * 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 android.net.sip;
+
+/**
+ * Listener class to listen to SIP registration events.
+ * @hide
+ */
+public interface SipRegistrationListener {
+ /**
+ * Called when a registration request is sent.
+ *
+ * @param localProfileUri the URI string of the SIP profile to register with
+ */
+ void onRegistering(String localProfileUri);
+
+ /**
+ * Called when registration is successfully done.
+ *
+ * @param localProfileUri the URI string of the SIP profile to register with
+ * @param expiryTime duration in second before the registration expires
+ */
+ void onRegistrationDone(String localProfileUri, long expiryTime);
+
+ /**
+ * Called when the registration fails.
+ *
+ * @param localProfileUri the URI string of the SIP profile to register with
+ * @param errorClass name of the exception class
+ * @param errorMessage error message
+ */
+ void onRegistrationFailed(String localProfileUri, String errorClass,
+ String errorMessage);
+}
diff --git a/voip/java/android/net/sip/SipSessionAdapter.java b/voip/java/android/net/sip/SipSessionAdapter.java
new file mode 100644
index 0000000..cfb71d7
--- /dev/null
+++ b/voip/java/android/net/sip/SipSessionAdapter.java
@@ -0,0 +1,67 @@
+/*
+ * 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 android.net.sip;
+
+/**
+ * Adapter class for {@link ISipSessionListener}. Default implementation of all
+ * callback methods is no-op.
+ * @hide
+ */
+public class SipSessionAdapter extends ISipSessionListener.Stub {
+ public void onCalling(ISipSession session) {
+ }
+
+ public void onRinging(ISipSession session, SipProfile caller,
+ byte[] sessionDescription) {
+ }
+
+ public void onRingingBack(ISipSession session) {
+ }
+
+ public void onCallEstablished(
+ ISipSession session, byte[] sessionDescription) {
+ }
+
+ public void onCallEnded(ISipSession session) {
+ }
+
+ public void onCallBusy(ISipSession session) {
+ }
+
+ public void onCallChanged(ISipSession session, byte[] sessionDescription) {
+ }
+
+ public void onCallChangeFailed(ISipSession session, String className,
+ String message) {
+ }
+
+ public void onError(ISipSession session, String className, String message) {
+ }
+
+ public void onRegistering(ISipSession session) {
+ }
+
+ public void onRegistrationDone(ISipSession session, int duration) {
+ }
+
+ public void onRegistrationFailed(ISipSession session, String className,
+ String message) {
+ }
+
+ public void onRegistrationTimeout(ISipSession session) {
+ }
+}
diff --git a/voip/java/android/net/sip/SipSessionState.java b/voip/java/android/net/sip/SipSessionState.java
new file mode 100644
index 0000000..5bab112
--- /dev/null
+++ b/voip/java/android/net/sip/SipSessionState.java
@@ -0,0 +1,66 @@
+/*
+ * 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 android.net.sip;
+
+/**
+ * Defines {@link ISipSession} states.
+ * @hide
+ */
+public enum SipSessionState {
+ /** When session is ready to initiate a call or transaction. */
+ READY_TO_CALL,
+
+ /** When the registration request is sent out. */
+ REGISTERING,
+
+ /** When the unregistration request is sent out. */
+ DEREGISTERING,
+
+ /** When an INVITE request is received. */
+ INCOMING_CALL,
+
+ /** When an OK response is sent for the INVITE request received. */
+ INCOMING_CALL_ANSWERING,
+
+ /** When an INVITE request is sent. */
+ OUTGOING_CALL,
+
+ /** When a RINGING response is received for the INVITE request sent. */
+ OUTGOING_CALL_RING_BACK,
+
+ /** When a CANCEL request is sent for the INVITE request sent. */
+ OUTGOING_CALL_CANCELING,
+
+ /** When a call is established. */
+ IN_CALL,
+
+ /** Some error occurs when making a remote call to {@link ISipSession}. */
+ REMOTE_ERROR,
+
+ /** When an OPTIONS request is sent. */
+ PINGING;
+
+ /**
+ * Checks if the specified string represents the same state as this object.
+ *
+ * @return true if the specified string represents the same state as this
+ * object
+ */
+ public boolean equals(String state) {
+ return toString().equals(state);
+ }
+}