* #36737: switch back to svn repo, remove assert in sip_transaction.c
diff --git a/jni/pjproject-android/.svn/pristine/80/807803c4678028b3cec3005f751515ebf1d0fd87.svn-base b/jni/pjproject-android/.svn/pristine/80/807803c4678028b3cec3005f751515ebf1d0fd87.svn-base
new file mode 100644
index 0000000..6dc5efe
--- /dev/null
+++ b/jni/pjproject-android/.svn/pristine/80/807803c4678028b3cec3005f751515ebf1d0fd87.svn-base
@@ -0,0 +1,2946 @@
+# $Id$
+#
+# Object oriented PJSUA wrapper.
+#
+# Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+
+"""Multimedia communication client library based on SIP protocol.
+
+This implements a fully featured multimedia communication client
+library based on PJSIP stack (http://www.pjsip.org)
+
+
+1. FEATURES
+
+ - Session Initiation Protocol (SIP) features:
+ - Basic registration and call
+ - Multiple accounts
+ - Call hold, attended and unattended call transfer
+ - Presence
+ - Instant messaging
+ - Multiple SIP accounts
+ - Media features:
+ - Audio
+ - Conferencing
+ - Narrowband and wideband
+ - Codecs: PCMA, PCMU, GSM, iLBC, Speex, G.722, L16
+ - RTP/RTCP
+ - Secure RTP (SRTP)
+ - WAV playback, recording, and playlist
+ - NAT traversal features
+ - Symmetric RTP
+ - STUN
+ - TURN
+ - ICE
+
+
+2. USING
+
+See http://www.pjsip.org/trac/wiki/Python_SIP_Tutorial for a more thorough
+tutorial. The paragraphs below explain basic tasks on using this module.
+
+
+"""
+import _pjsua
+import thread
+import threading
+import weakref
+import time
+
+class Error:
+ """Error exception class.
+
+ Member documentation:
+
+ op_name -- name of the operation that generated this error.
+ obj -- the object that generated this error.
+ err_code -- the error code.
+
+ """
+ op_name = ""
+ obj = None
+ err_code = -1
+ _err_msg = ""
+
+ def __init__(self, op_name, obj, err_code, err_msg=""):
+ self.op_name = op_name
+ self.obj = obj
+ self.err_code = err_code
+ self._err_msg = err_msg
+
+ def err_msg(self):
+ "Retrieve the description of the error."
+ if self._err_msg != "":
+ return self._err_msg
+ self._err_msg = Lib.strerror(self.err_code)
+ return self._err_msg
+
+ def __str__(self):
+ return "Object: " + str(self.obj) + ", operation=" + self.op_name + \
+ ", error=" + self.err_msg()
+
+#
+# Constants
+#
+
+class TransportType:
+ """SIP transport type constants.
+
+ Member documentation:
+ UNSPECIFIED -- transport type is unknown or unspecified
+ UDP -- UDP transport
+ TCP -- TCP transport
+ TLS -- TLS transport
+ IPV6 -- this is not a transport type but rather a flag
+ to select the IPv6 version of a transport
+ UDP_IPV6 -- IPv6 UDP transport
+ TCP_IPV6 -- IPv6 TCP transport
+ """
+ UNSPECIFIED = 0
+ UDP = 1
+ TCP = 2
+ TLS = 3
+ IPV6 = 128
+ UDP_IPV6 = UDP + IPV6
+ TCP_IPV6 = TCP + IPV6
+
+class TransportFlag:
+ """Transport flags to indicate the characteristics of the transport.
+
+ Member documentation:
+
+ RELIABLE -- transport is reliable.
+ SECURE -- transport is secure.
+ DATAGRAM -- transport is datagram based.
+
+ """
+ RELIABLE = 1
+ SECURE = 2
+ DATAGRAM = 4
+
+class CallRole:
+ """Call role constants.
+
+ Member documentation:
+
+ CALLER -- role is caller
+ CALLEE -- role is callee
+
+ """
+ CALLER = 0
+ CALLEE = 1
+
+class CallState:
+ """Call state constants.
+
+ Member documentation:
+
+ NULL -- call is not initialized.
+ CALLING -- initial INVITE is sent.
+ INCOMING -- initial INVITE is received.
+ EARLY -- provisional response has been sent or received.
+ CONNECTING -- 200/OK response has been sent or received.
+ CONFIRMED -- ACK has been sent or received.
+ DISCONNECTED -- call is disconnected.
+ """
+ NULL = 0
+ CALLING = 1
+ INCOMING = 2
+ EARLY = 3
+ CONNECTING = 4
+ CONFIRMED = 5
+ DISCONNECTED = 6
+
+
+class MediaState:
+ """Call media state constants.
+
+ Member documentation:
+
+ NULL -- media is not available.
+ ACTIVE -- media is active.
+ LOCAL_HOLD -- media is put on-hold by local party.
+ REMOTE_HOLD -- media is put on-hold by remote party.
+ ERROR -- media error (e.g. ICE negotiation failure).
+ """
+ NULL = 0
+ ACTIVE = 1
+ LOCAL_HOLD = 2
+ REMOTE_HOLD = 3
+ ERROR = 4
+
+
+class MediaDir:
+ """Media direction constants.
+
+ Member documentation:
+
+ NULL -- media is not active
+ ENCODING -- media is active in transmit/encoding direction only.
+ DECODING -- media is active in receive/decoding direction only
+ ENCODING_DECODING -- media is active in both directions.
+ """
+ NULL = 0
+ ENCODING = 1
+ DECODING = 2
+ ENCODING_DECODING = 3
+
+
+class PresenceActivity:
+ """Presence activities constants.
+
+ Member documentation:
+
+ UNKNOWN -- the person activity is unknown
+ AWAY -- the person is currently away
+ BUSY -- the person is currently engaging in other activity
+ """
+ UNKNOWN = 0
+ AWAY = 1
+ BUSY = 2
+
+
+class SubscriptionState:
+ """Presence subscription state constants.
+
+ """
+ NULL = 0
+ SENT = 1
+ ACCEPTED = 2
+ PENDING = 3
+ ACTIVE = 4
+ TERMINATED = 5
+ UNKNOWN = 6
+
+
+class TURNConnType:
+ """These constants specifies the connection type to TURN server.
+
+ Member documentation:
+ UDP -- use UDP transport.
+ TCP -- use TCP transport.
+ TLS -- use TLS transport.
+ """
+ UDP = 17
+ TCP = 6
+ TLS = 255
+
+
+class UAConfig:
+ """User agent configuration to be specified in Lib.init().
+
+ Member documentation:
+
+ max_calls -- maximum number of calls to be supported.
+ nameserver -- list of nameserver hostnames or IP addresses. Nameserver
+ must be configured if DNS SRV resolution is desired.
+ stun_domain -- if nameserver is configured, this can be used to query
+ the STUN server with DNS SRV.
+ stun_host -- the hostname or IP address of the STUN server. This will
+ also be used if DNS SRV resolution for stun_domain fails.
+ user_agent -- Optionally specify the user agent name.
+ """
+ max_calls = 4
+ nameserver = []
+ stun_domain = ""
+ stun_host = ""
+ user_agent = "pjsip python"
+
+ def _cvt_from_pjsua(self, cfg):
+ self.max_calls = cfg.max_calls
+ self.thread_cnt = cfg.thread_cnt
+ self.nameserver = cfg.nameserver
+ self.stun_domain = cfg.stun_domain
+ self.stun_host = cfg.stun_host
+ self.user_agent = cfg.user_agent
+
+ def _cvt_to_pjsua(self):
+ cfg = _pjsua.config_default()
+ cfg.max_calls = self.max_calls
+ cfg.thread_cnt = 0
+ cfg.nameserver = self.nameserver
+ cfg.stun_domain = self.stun_domain
+ cfg.stun_host = self.stun_host
+ cfg.user_agent = self.user_agent
+ return cfg
+
+
+class LogConfig:
+ """Logging configuration to be specified in Lib.init().
+
+ Member documentation:
+
+ msg_logging -- specify if SIP messages should be logged. Set to
+ True.
+ level -- specify the input verbosity level.
+ console_level -- specify the output verbosity level.
+ decor -- specify log decoration.
+ filename -- specify the log filename.
+ callback -- specify callback to be called to write the logging
+ messages. Sample function:
+
+ def log_cb(level, str, len):
+ print str,
+
+ """
+ msg_logging = True
+ level = 5
+ console_level = 5
+ decor = 0
+ filename = ""
+ callback = None
+
+ def __init__(self, level=-1, filename="", callback=None,
+ console_level=-1):
+ self._cvt_from_pjsua(_pjsua.logging_config_default())
+ if level != -1:
+ self.level = level
+ if filename != "":
+ self.filename = filename
+ if callback != None:
+ self.callback = callback
+ if console_level != -1:
+ self.console_level = console_level
+
+ def _cvt_from_pjsua(self, cfg):
+ self.msg_logging = cfg.msg_logging
+ self.level = cfg.level
+ self.console_level = cfg.console_level
+ self.decor = cfg.decor
+ self.filename = cfg.log_filename
+ self.callback = cfg.cb
+
+ def _cvt_to_pjsua(self):
+ cfg = _pjsua.logging_config_default()
+ cfg.msg_logging = self.msg_logging
+ cfg.level = self.level
+ cfg.console_level = self.console_level
+ cfg.decor = self.decor
+ cfg.log_filename = self.filename
+ cfg.cb = self.callback
+ return cfg
+
+
+class MediaConfig:
+ """Media configuration to be specified in Lib.init().
+
+ Member documentation:
+
+ clock_rate -- specify the core clock rate of the audio,
+ most notably the conference bridge.
+ snd_clock_rate -- optionally specify different clock rate for
+ the sound device.
+ snd_auto_close_time -- specify the duration in seconds when the
+ sound device should be closed after inactivity
+ period.
+ channel_count -- specify the number of channels to open the sound
+ device and the conference bridge.
+ audio_frame_ptime -- specify the length of audio frames in millisecond.
+ max_media_ports -- specify maximum number of audio ports to be
+ supported by the conference bridge.
+ quality -- specify the audio quality setting (1-10)
+ ptime -- specify the audio packet length of transmitted
+ RTP packet.
+ no_vad -- disable Voice Activity Detector (VAD) or Silence
+ Detector (SD)
+ ilbc_mode -- specify iLBC codec mode (must be 30 for now)
+ tx_drop_pct -- randomly drop transmitted RTP packets (for
+ simulation). Number is in percent.
+ rx_drop_pct -- randomly drop received RTP packets (for
+ simulation). Number is in percent.
+ ec_options -- Echo Canceller option (specify zero).
+ ec_tail_len -- specify Echo Canceller tail length in milliseconds.
+ Value zero will disable the echo canceller.
+ jb_min -- specify the minimum jitter buffer size in
+ milliseconds. Put -1 for default.
+ jb_max -- specify the maximum jitter buffer size in
+ milliseconds. Put -1 for default.
+ enable_ice -- enable Interactive Connectivity Establishment (ICE)
+ enable_turn -- enable TURN relay. TURN server settings must also
+ be configured.
+ turn_server -- specify the domain or hostname or IP address of
+ the TURN server, in "host[:port]" format.
+ turn_conn_type -- specify connection type to the TURN server, from
+ the TURNConnType constant.
+ turn_cred -- specify AuthCred for the TURN credential.
+ """
+ clock_rate = 16000
+ snd_clock_rate = 0
+ snd_auto_close_time = 5
+ channel_count = 1
+ audio_frame_ptime = 20
+ max_media_ports = 32
+ quality = 6
+ ptime = 0
+ no_vad = False
+ ilbc_mode = 30
+ tx_drop_pct = 0
+ rx_drop_pct = 0
+ ec_options = 0
+ ec_tail_len = 256
+ jb_min = -1
+ jb_max = -1
+ enable_ice = True
+ enable_turn = False
+ turn_server = ""
+ turn_conn_type = TURNConnType.UDP
+ turn_cred = None
+
+ def __init__(self):
+ default = _pjsua.media_config_default()
+ self._cvt_from_pjsua(default)
+
+ def _cvt_from_pjsua(self, cfg):
+ self.clock_rate = cfg.clock_rate
+ self.snd_clock_rate = cfg.snd_clock_rate
+ self.snd_auto_close_time = cfg.snd_auto_close_time
+ self.channel_count = cfg.channel_count
+ self.audio_frame_ptime = cfg.audio_frame_ptime
+ self.max_media_ports = cfg.max_media_ports
+ self.quality = cfg.quality
+ self.ptime = cfg.ptime
+ self.no_vad = cfg.no_vad
+ self.ilbc_mode = cfg.ilbc_mode
+ self.tx_drop_pct = cfg.tx_drop_pct
+ self.rx_drop_pct = cfg.rx_drop_pct
+ self.ec_options = cfg.ec_options
+ self.ec_tail_len = cfg.ec_tail_len
+ self.jb_min = cfg.jb_min
+ self.jb_max = cfg.jb_max
+ self.enable_ice = cfg.enable_ice
+ self.enable_turn = cfg.enable_turn
+ self.turn_server = cfg.turn_server
+ self.turn_conn_type = cfg.turn_conn_type
+ if cfg.turn_username:
+ self.turn_cred = AuthCred(cfg.turn_realm, cfg.turn_username,
+ cfg.turn_passwd, cfg.turn_passwd_type)
+ else:
+ self.turn_cred = None
+
+ def _cvt_to_pjsua(self):
+ cfg = _pjsua.media_config_default()
+ cfg.clock_rate = self.clock_rate
+ cfg.snd_clock_rate = self.snd_clock_rate
+ cfg.snd_auto_close_time = self.snd_auto_close_time
+ cfg.channel_count = self.channel_count
+ cfg.audio_frame_ptime = self.audio_frame_ptime
+ cfg.max_media_ports = self.max_media_ports
+ cfg.quality = self.quality
+ cfg.ptime = self.ptime
+ cfg.no_vad = self.no_vad
+ cfg.ilbc_mode = self.ilbc_mode
+ cfg.tx_drop_pct = self.tx_drop_pct
+ cfg.rx_drop_pct = self.rx_drop_pct
+ cfg.ec_options = self.ec_options
+ cfg.ec_tail_len = self.ec_tail_len
+ cfg.jb_min = self.jb_min
+ cfg.jb_max = self.jb_max
+ cfg.enable_ice = self.enable_ice
+ cfg.enable_turn = self.enable_turn
+ cfg.turn_server = self.turn_server
+ cfg.turn_conn_type = self.turn_conn_type
+ if self.turn_cred:
+ cfg.turn_realm = self.turn_cred.realm
+ cfg.turn_username = self.turn_cred.username
+ cfg.turn_passwd_type = self.turn_cred.passwd_type
+ cfg.turn_passwd = self.turn_cred.passwd
+ return cfg
+
+
+class TransportConfig:
+ """SIP transport configuration class.
+
+ Member configuration:
+
+ port -- port number.
+ bound_addr -- optionally specify the address to bind the socket to.
+ Default is empty to bind to INADDR_ANY.
+ public_addr -- optionally override the published address for this
+ transport. If empty, the default behavior is to get
+ the public address from STUN or from the selected
+ local interface. Format is "host:port".
+ qos_type -- High level traffic classification.
+ Enumerator:
+ 0: PJ_QOS_TYPE_BEST_EFFORT
+ Best effort traffic (default value). Any QoS function calls with
+ specifying this value are effectively no-op
+ 1: PJ_QOS_TYPE_BACKGROUND
+ Background traffic.
+ 2: PJ_QOS_TYPE_VIDEO
+ Video traffic.
+ 3: PJ_QOS_TYPE_VOICE
+ Voice traffic.
+ 4: PJ_QOS_TYPE_CONTROL
+ Control traffic.
+ qos_params_flags -- Determines which values to set, bitmask of pj_qos_flag.
+ PJ_QOS_PARAM_HAS_DSCP = 1
+ PJ_QOS_PARAM_HAS_SO_PRIO = 2
+ PJ_QOS_PARAM_HAS_WMM = 4
+ qos_params_dscp_val -- The 6 bits DSCP value to set.
+ qos_params_so_prio -- Socket SO_PRIORITY value.
+ qos_params_wmm_prio -- Standard WMM priorities.
+ Enumerator:
+ 0: PJ_QOS_WMM_PRIO_BULK_EFFORT: Bulk effort priority
+ 1: PJ_QOS_WMM_PRIO_BULK: Bulk priority.
+ 2: PJ_QOS_WMM_PRIO_VIDEO: Video priority
+ 3: PJ_QOS_WMM_PRIO_VOICE: Voice priority.
+ """
+ port = 0
+ bound_addr = ""
+ public_addr = ""
+
+ qos_type = 0
+ qos_params_flags = 0
+ qos_params_dscp_val = 0
+ qos_params_so_prio = 0
+ qos_params_wmm_prio = 0
+
+
+
+ def __init__(self, port=0,
+ bound_addr="", public_addr=""):
+ self.port = port
+ self.bound_addr = bound_addr
+ self.public_addr = public_addr
+
+ def _cvt_from_pjsua(self, cfg):
+ self.port = cfg.port
+ self.bound_addr = cfg.bound_addr
+ self.public_addr = cfg.public_addr
+ self.qos_type = cfg.qos_type
+ self.qos_params_flags = cfg.qos_params_flags
+ self.qos_params_dscp_val = cfg.qos_params_dscp_val
+ self.qos_params_so_prio = cfg.qos_params_so_prio
+ self.qos_params_wmm_prio = cfg.qos_params_wmm_prio
+
+ def _cvt_to_pjsua(self):
+ cfg = _pjsua.transport_config_default()
+ cfg.port = self.port
+ cfg.bound_addr = self.bound_addr
+ cfg.public_addr = self.public_addr
+ cfg.qos_type = self.qos_type
+ cfg.qos_params_flags = self.qos_params_flags
+ cfg.qos_params_dscp_val = self.qos_params_dscp_val
+ cfg.qos_params_so_prio = self.qos_params_so_prio
+ cfg.qos_params_wmm_prio = self.qos_params_wmm_prio
+
+ return cfg
+
+
+class TransportInfo:
+ """SIP transport info.
+
+ Member documentation:
+
+ type -- transport type, from TransportType constants.
+ description -- longer description for this transport.
+ is_reliable -- True if transport is reliable.
+ is_secure -- True if transport is secure.
+ is_datagram -- True if transport is datagram based.
+ host -- the IP address of this transport.
+ port -- the port number.
+ ref_cnt -- number of objects referencing this transport.
+ """
+ type = ""
+ description = ""
+ is_reliable = False
+ is_secure = False
+ is_datagram = False
+ host = ""
+ port = 0
+ ref_cnt = 0
+
+ def __init__(self, ti):
+ self.type = ti.type_name
+ self.description = ti.info
+ self.is_reliable = (ti.flag & TransportFlag.RELIABLE)
+ self.is_secure = (ti.flag & TransportFlag.SECURE)
+ self.is_datagram = (ti.flag & TransportFlag.DATAGRAM)
+ self.host = ti.addr
+ self.port = ti.port
+ self.ref_cnt = ti.usage_count
+
+
+class Transport:
+ "SIP transport class."
+ _id = -1
+ _lib = None
+ _obj_name = ""
+
+ def __init__(self, lib, id):
+ self._lib = weakref.proxy(lib)
+ self._id = id
+ self._obj_name = "{Transport " + self.info().description + "}"
+ _Trace((self, 'created'))
+
+ def __del__(self):
+ _Trace((self, 'destroyed'))
+
+ def __str__(self):
+ return self._obj_name
+
+ def info(self):
+ """Get TransportInfo.
+ """
+ lck = self._lib.auto_lock()
+ ti = _pjsua.transport_get_info(self._id)
+ if not ti:
+ self._lib._err_check("info()", self, -1, "Invalid transport")
+ return TransportInfo(ti)
+
+ def enable(self):
+ """Enable this transport."""
+ lck = self._lib.auto_lock()
+ err = _pjsua.transport_set_enable(self._id, True)
+ self._lib._err_check("enable()", self, err)
+
+ def disable(self):
+ """Disable this transport."""
+ lck = self._lib.auto_lock()
+ err = _pjsua.transport_set_enable(self._id, 0)
+ self._lib._err_check("disable()", self, err)
+
+ def close(self, force=False):
+ """Close and destroy this transport.
+
+ Keyword argument:
+ force -- force deletion of this transport (not recommended).
+ """
+ lck = self._lib.auto_lock()
+ err = _pjsua.transport_close(self._id, force)
+ self._lib._err_check("close()", self, err)
+
+
+class SIPUri:
+ """Helper class to parse the most important components of SIP URI.
+
+ Member documentation:
+
+ scheme -- URI scheme ("sip" or "sips")
+ user -- user part of the URI (may be empty)
+ host -- host name part
+ port -- optional port number (zero if port is not specified).
+ transport -- transport parameter, or empty if transport is not
+ specified.
+
+ """
+ scheme = ""
+ user = ""
+ host = ""
+ port = 0
+ transport = ""
+
+ def __init__(self, uri=None):
+ if uri:
+ self.decode(uri)
+
+ def decode(self, uri):
+ """Parse SIP URL.
+
+ Keyword argument:
+ uri -- the URI string.
+
+ """
+ self.scheme, self.user, self.host, self.port, self.transport = \
+ _pjsua.parse_simple_uri(uri)
+
+ def encode(self):
+ """Encode this object into SIP URI string.
+
+ Return:
+ URI string.
+
+ """
+ output = self.scheme + ":"
+ if self.user and len(self.user):
+ output = output + self.user + "@"
+ output = output + self.host
+ if self.port:
+ output = output + ":" + output(self.port)
+ if self.transport:
+ output = output + ";transport=" + self.transport
+ return output
+
+
+class AuthCred:
+ """Authentication credential for SIP or TURN account.
+
+ Member documentation:
+
+ scheme -- authentication scheme (default is "Digest")
+ realm -- realm
+ username -- username
+ passwd_type -- password encoding (zero for plain-text)
+ passwd -- the password
+ """
+ scheme = "Digest"
+ realm = "*"
+ username = ""
+ passwd_type = 0
+ passwd = ""
+
+ def __init__(self, realm, username, passwd, scheme="Digest", passwd_type=0):
+ self.scheme = scheme
+ self.realm = realm
+ self.username = username
+ self.passwd_type = passwd_type
+ self.passwd = passwd
+
+
+class AccountConfig:
+ """ This describes account configuration to create an account.
+
+ Member documentation:
+
+ priority -- account priority for matching incoming
+ messages.
+ id -- SIP URI of this account. This setting is
+ mandatory.
+ force_contact -- force to use this URI as Contact URI. Setting
+ this value is generally not recommended.
+ reg_uri -- specify the registrar URI. Mandatory if
+ registration is required.
+ reg_timeout -- specify the SIP registration refresh interval
+ in seconds.
+ require_100rel -- specify if reliable provisional response is
+ to be enforced (with Require header).
+ publish_enabled -- specify if PUBLISH should be used. When
+ enabled, the PUBLISH will be sent to the
+ registrar.
+ pidf_tuple_id -- optionally specify the tuple ID in outgoing
+ PIDF document.
+ proxy -- list of proxy URI.
+ auth_cred -- list of AuthCred containing credentials to
+ authenticate against the registrars and
+ the proxies.
+ auth_initial_send -- specify if empty Authorization header should be
+ sent. May be needed for IMS.
+ auth_initial_algorithm -- when auth_initial_send is enabled, optionally
+ specify the authentication algorithm to use.
+ Valid values are "md5", "akav1-md5", or
+ "akav2-md5".
+ transport_id -- optionally specify the transport ID to be used
+ by this account. Shouldn't be needed unless
+ for specific requirements (e.g. in multi-homed
+ scenario).
+ allow_contact_rewrite -- specify whether the account should learn its
+ Contact address from REGISTER response and
+ update the registration accordingly. Default is
+ True.
+ ka_interval -- specify the interval to send NAT keep-alive
+ packet.
+ ka_data -- specify the NAT keep-alive packet contents.
+ use_srtp -- specify the SRTP usage policy. Valid values
+ are: 0=disable, 1=optional, 2=mandatory.
+ Default is 0.
+ srtp_secure_signaling -- specify the signaling security level required
+ by SRTP. Valid values are: 0=no secure
+ transport is required, 1=hop-by-hop secure
+ transport such as TLS is required, 2=end-to-
+ end secure transport is required (i.e. "sips").
+ rtp_transport_cfg -- the rtp-transport-configuration that is usede, when
+ a rtp-connection is being established.
+ """
+ priority = 0
+ id = ""
+ force_contact = ""
+ reg_uri = ""
+ reg_timeout = 0
+ require_100rel = False
+ publish_enabled = False
+ pidf_tuple_id = ""
+ proxy = []
+ auth_cred = []
+ auth_initial_send = False
+ auth_initial_algorithm = ""
+ transport_id = -1
+ allow_contact_rewrite = True
+ ka_interval = 15
+ ka_data = "\r\n"
+ use_srtp = 0
+ srtp_secure_signaling = 1
+ rtp_transport_cfg = None
+
+ def __init__(self, domain="", username="", password="",
+ display="", registrar="", proxy=""):
+ """
+ Construct account config. If domain argument is specified,
+ a typical configuration will be built.
+
+ Keyword arguments:
+ domain -- domain name of the server.
+ username -- user name.
+ password -- plain-text password.
+ display -- optional display name for the user name.
+ registrar -- the registrar URI. If domain name is specified
+ and this argument is empty, the registrar URI
+ will be constructed from the domain name.
+ proxy -- the proxy URI. If domain name is specified
+ and this argument is empty, the proxy URI
+ will be constructed from the domain name.
+
+ """
+ default = _pjsua.acc_config_default()
+ self._cvt_from_pjsua(default)
+ if domain!="":
+ self.build_config(domain, username, password,
+ display, registrar, proxy)
+ self.rtp_transport_cfg = TransportConfig()
+
+ def build_config(self, domain, username, password, display="",
+ registrar="", proxy="", rtp_transport_cfg = None):
+ """
+ Construct account config. If domain argument is specified,
+ a typical configuration will be built.
+
+ Keyword arguments:
+ domain -- domain name of the server.
+ username -- user name.
+ password -- plain-text password.
+ display -- optional display name for the user name.
+ registrar -- the registrar URI. If domain name is specified
+ and this argument is empty, the registrar URI
+ will be constructed from the domain name.
+ proxy -- the proxy URI. If domain name is specified
+ and this argument is empty, the proxy URI
+ will be constructed from the domain name.
+
+ """
+ if display != "":
+ display = display + " "
+ userpart = username
+ if userpart != "":
+ userpart = userpart + "@"
+ self.id = display + "<sip:" + userpart + domain + ">"
+ self.reg_uri = registrar
+ if self.reg_uri == "":
+ self.reg_uri = "sip:" + domain
+ if proxy == "":
+ proxy = "sip:" + domain + ";lr"
+ if proxy.find(";lr") == -1:
+ proxy = proxy + ";lr"
+ self.proxy.append(proxy)
+ if username != "":
+ self.auth_cred.append(AuthCred("*", username, password))
+
+ if (rtp_transport_cfg is not None):
+ self.rtp_transport_cfg = rtp_transport_cfg
+ else:
+ self.rtp_transport_cfg = TransportConfig()
+
+ def _cvt_from_pjsua(self, cfg):
+ self.priority = cfg.priority
+ self.id = cfg.id
+ self.force_contact = cfg.force_contact
+ self.reg_uri = cfg.reg_uri
+ self.reg_timeout = cfg.reg_timeout
+ self.require_100rel = cfg.require_100rel
+ self.publish_enabled = cfg.publish_enabled
+ self.pidf_tuple_id = cfg.pidf_tuple_id
+ self.proxy = cfg.proxy
+ for cred in cfg.cred_info:
+ self.auth_cred.append(AuthCred(cred.realm, cred.username,
+ cred.data, cred.scheme,
+ cred.data_type))
+ self.auth_initial_send = cfg.auth_initial_send
+ self.auth_initial_algorithm = cfg.auth_initial_algorithm
+ self.transport_id = cfg.transport_id
+ self.allow_contact_rewrite = cfg.allow_contact_rewrite
+ self.ka_interval = cfg.ka_interval
+ self.ka_data = cfg.ka_data
+ self.use_srtp = cfg.use_srtp
+ self.srtp_secure_signaling = cfg.srtp_secure_signaling
+ if (self.rtp_transport_cfg is not None):
+ self.rtp_transport_cfg._cvt_from_pjsua(cfg.rtp_transport_cfg)
+
+ def _cvt_to_pjsua(self):
+ cfg = _pjsua.acc_config_default()
+ cfg.priority = self.priority
+ cfg.id = self.id
+ cfg.force_contact = self.force_contact
+ cfg.reg_uri = self.reg_uri
+ cfg.reg_timeout = self.reg_timeout
+ cfg.require_100rel = self.require_100rel
+ cfg.publish_enabled = self.publish_enabled
+ cfg.pidf_tuple_id = self.pidf_tuple_id
+ cfg.proxy = self.proxy
+ for cred in self.auth_cred:
+ c = _pjsua.Pjsip_Cred_Info()
+ c.realm = cred.realm
+ c.scheme = cred.scheme
+ c.username = cred.username
+ c.data_type = cred.passwd_type
+ c.data = cred.passwd
+ cfg.cred_info.append(c)
+
+ cfg.auth_initial_send = self.auth_initial_send
+ cfg.auth_initial_algorithm = self.auth_initial_algorithm
+ cfg.transport_id = self.transport_id
+ cfg.allow_contact_rewrite = self.allow_contact_rewrite
+ cfg.ka_interval = self.ka_interval
+ cfg.ka_data = self.ka_data
+ cfg.use_srtp = self.use_srtp
+ cfg.srtp_secure_signaling = self.srtp_secure_signaling
+
+ if (self.rtp_transport_cfg is not None):
+ cfg.rtp_transport_cfg = self.rtp_transport_cfg._cvt_to_pjsua()
+
+ return cfg
+
+
+# Account information
+class AccountInfo:
+ """This describes Account info. Application retrives account info
+ with Account.info().
+
+ Member documentation:
+
+ is_default -- True if this is the default account.
+ uri -- the account URI.
+ reg_active -- True if registration is active for this account.
+ reg_expires -- contains the current registration expiration value,
+ in seconds.
+ reg_status -- the registration status. If the value is less than
+ 700, it specifies SIP status code. Value greater than
+ this specifies the error code.
+ reg_reason -- contains the registration status text (e.g. the
+ error message).
+ online_status -- the account's presence online status, True if it's
+ publishing itself as online.
+ online_text -- the account's presence status text.
+
+ """
+ is_default = False
+ uri = ""
+ reg_active = False
+ reg_expires = -1
+ reg_status = 0
+ reg_reason = ""
+ online_status = False
+ online_text = ""
+
+ def __init__(self, ai):
+ self.is_default = ai.is_default
+ self.uri = ai.acc_uri
+ self.reg_active = ai.has_registration
+ self.reg_expires = ai.expires
+ self.reg_status = ai.status
+ self.reg_reason = ai.status_text
+ self.online_status = ai.online_status
+ self.online_text = ai.online_status_text
+
+# Account callback
+class AccountCallback:
+ """Class to receive notifications on account's events.
+
+ Derive a class from this class and register it to the Account object
+ using Account.set_callback() to start receiving events from the Account
+ object.
+
+ Member documentation:
+
+ account -- the Account object.
+
+ """
+ account = None
+
+ def __init__(self, account=None):
+ self._set_account(account)
+
+ def __del__(self):
+ pass
+
+ def _set_account(self, account):
+ if account:
+ self.account = weakref.proxy(account)
+ else:
+ self.account = None
+
+ def on_reg_state(self):
+ """Notification that the registration status has changed.
+ """
+ pass
+
+ def on_incoming_call(self, call):
+ """Notification about incoming call.
+
+ Application should implement one of on_incoming_call() or
+ on_incoming_call2(), otherwise, the default behavior is to
+ reject the call with default status code. Note that if both are
+ implemented, only on_incoming_call2() will be called.
+
+ Keyword arguments:
+ call -- the new incoming call
+ """
+ call.hangup()
+
+ def on_incoming_call2(self, call, rdata):
+ """Notification about incoming call, with received SIP message info.
+
+ Application should implement one of on_incoming_call() or
+ on_incoming_call2(), otherwise, the default behavior is to
+ reject the call with default status code. Note that if both are
+ implemented, only on_incoming_call2() will be called.
+
+ Keyword arguments:
+ call -- the new incoming call
+ rdata -- the received message
+ """
+ call.hangup()
+
+ def on_incoming_subscribe(self, buddy, from_uri, contact_uri, pres_obj):
+ """Notification when incoming SUBSCRIBE request is received.
+
+ Application may use this callback to authorize the incoming
+ subscribe request (e.g. ask user permission if the request
+ should be granted)
+
+ Keyword arguments:
+ buddy -- The buddy object, if buddy is found. Otherwise
+ the value is None.
+ from_uri -- The URI string of the sender.
+ pres_obj -- Opaque presence subscription object, which is
+ needed by Account.pres_notify()
+
+ Return:
+ Tuple (code, reason), where:
+ code: The status code. If code is >= 300, the
+ request is rejected. If code is 200, the
+ request is accepted and NOTIFY will be sent
+ automatically. If code is 202, application
+ must accept or reject the request later with
+ Account.press_notify().
+ reason: Optional reason phrase, or None to use the
+ default reasoh phrase for the status code.
+ """
+ return (200, None)
+
+ def on_pager(self, from_uri, contact, mime_type, body):
+ """
+ Notification that incoming instant message is received on
+ this account.
+
+ Keyword arguments:
+ from_uri -- sender's URI
+ contact -- sender's Contact URI
+ mime_type -- MIME type of the instant message body
+ body -- the instant message body
+
+ """
+ pass
+
+ def on_pager_status(self, to_uri, body, im_id, code, reason):
+ """
+ Notification about the delivery status of previously sent
+ instant message.
+
+ Keyword arguments:
+ to_uri -- the destination URI of the message
+ body -- the message body
+ im_id -- message ID
+ code -- SIP status code
+ reason -- SIP reason phrase
+
+ """
+ pass
+
+ def on_typing(self, from_uri, contact, is_typing):
+ """
+ Notification that remote is typing or stop typing.
+
+ Keyword arguments:
+ buddy -- Buddy object for the sender, if found. Otherwise
+ this will be None
+ from_uri -- sender's URI of the indication
+ contact -- sender's contact URI
+ is_typing -- boolean to indicate whether remote is currently
+ typing an instant message.
+
+ """
+ pass
+
+ def on_mwi_info(self, body):
+ """
+ Notification about change in Message Summary / Message Waiting
+ Indication (RFC 3842) status. MWI subscription must be enabled
+ in the account config to receive this notification.
+
+ Keyword arguments:
+ body -- String containing message body as received in the
+ NOTIFY request.
+
+ """
+ pass
+
+
+
+class Account:
+ """This describes SIP account class.
+
+ PJSUA accounts provide identity (or identities) of the user who is
+ currently using the application. In SIP terms, the identity is used
+ as the From header in outgoing requests.
+
+ Account may or may not have client registration associated with it.
+ An account is also associated with route set and some authentication
+ credentials, which are used when sending SIP request messages using
+ the account. An account also has presence's online status, which
+ will be reported to remote peer when they subscribe to the account's
+ presence, or which is published to a presence server if presence
+ publication is enabled for the account.
+
+ Account is created with Lib.create_account(). At least one account
+ MUST be created. If no user association is required, application can
+ create a userless account by calling Lib.create_account_for_transport().
+ A userless account identifies local endpoint instead of a particular
+ user, and it correspond with a particular transport instance.
+
+ Also one account must be set as the default account, which is used as
+ the account to use when PJSUA fails to match a request with any other
+ accounts.
+
+ """
+ _id = -1
+ _lib = None
+ _cb = AccountCallback(None)
+ _obj_name = ""
+
+ def __init__(self, lib, id, cb=None):
+ """Construct this class. This is normally called by Lib class and
+ not by application.
+
+ Keyword arguments:
+ lib -- the Lib instance.
+ id -- the pjsua account ID.
+ cb -- AccountCallback instance to receive events from this Account.
+ If callback is not specified here, it must be set later
+ using set_callback().
+ """
+ self._id = id
+ self._lib = weakref.ref(lib)
+ self._obj_name = "{Account " + self.info().uri + "}"
+ self.set_callback(cb)
+ _pjsua.acc_set_user_data(self._id, self)
+ _Trace((self, 'created'))
+
+ def __del__(self):
+ if self._id != -1:
+ _pjsua.acc_set_user_data(self._id, 0)
+ _Trace((self, 'destroyed'))
+
+ def __str__(self):
+ return self._obj_name
+
+ def info(self):
+ """Retrieve AccountInfo for this account.
+ """
+ lck = self._lib().auto_lock()
+ ai = _pjsua.acc_get_info(self._id)
+ if ai==None:
+ self._lib()._err_check("info()", self, -1, "Invalid account")
+ return AccountInfo(ai)
+
+ def is_valid(self):
+ """
+ Check if this account is still valid.
+
+ """
+ lck = self._lib().auto_lock()
+ return _pjsua.acc_is_valid(self._id)
+
+ def set_callback(self, cb):
+ """Register callback to receive notifications from this object.
+
+ Keyword argument:
+ cb -- AccountCallback instance.
+
+ """
+ if cb:
+ self._cb = cb
+ else:
+ self._cb = AccountCallback(self)
+ self._cb._set_account(self)
+
+ def set_default(self):
+ """ Set this account as default account to send outgoing requests
+ and as the account to receive incoming requests when more exact
+ matching criteria fails.
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.acc_set_default(self._id)
+ self._lib()._err_check("set_default()", self, err)
+
+ def is_default(self):
+ """ Check if this account is the default account.
+
+ """
+ lck = self._lib().auto_lock()
+ def_id = _pjsua.acc_get_default()
+ return self.is_valid() and def_id==self._id
+
+ def delete(self):
+ """ Delete this account.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.acc_set_user_data(self._id, 0)
+ self._lib()._err_check("delete()", self, err)
+ err = _pjsua.acc_del(self._id)
+ self._lib()._err_check("delete()", self, err)
+ self._id = -1
+
+ def set_basic_status(self, is_online):
+ """ Set basic presence status of this account.
+
+ Keyword argument:
+ is_online -- boolean to indicate basic presence availability.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.acc_set_online_status(self._id, is_online)
+ self._lib()._err_check("set_basic_status()", self, err)
+
+ def set_presence_status(self, is_online,
+ activity=PresenceActivity.UNKNOWN,
+ pres_text="", rpid_id=""):
+ """ Set presence status of this account.
+
+ Keyword arguments:
+ is_online -- boolean to indicate basic presence availability
+ activity -- value from PresenceActivity
+ pres_text -- optional string to convey additional information about
+ the activity (such as "On the phone")
+ rpid_id -- optional string to be placed as RPID ID.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.acc_set_online_status2(self._id, is_online, activity,
+ pres_text, rpid_id)
+ self._lib()._err_check("set_presence_status()", self, err)
+
+ def set_registration(self, renew):
+ """Manually renew registration or unregister from the server.
+
+ Keyword argument:
+ renew -- boolean to indicate whether registration is renewed.
+ Setting this value for False will trigger unregistration.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.acc_set_registration(self._id, renew)
+ self._lib()._err_check("set_registration()", self, err)
+
+ def set_transport(self, transport):
+ """Set this account to only use the specified transport to send
+ outgoing requests.
+
+ Keyword argument:
+ transport -- Transport object.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.acc_set_transport(self._id, transport._id)
+ self._lib()._err_check("set_transport()", self, err)
+
+ def make_call(self, dst_uri, cb=None, hdr_list=None):
+ """Make outgoing call to the specified URI.
+
+ Keyword arguments:
+ dst_uri -- Destination SIP URI.
+ cb -- CallCallback instance to be installed to the newly
+ created Call object. If this CallCallback is not
+ specified (i.e. None is given), it must be installed
+ later using call.set_callback().
+ hdr_list -- Optional list of headers to be sent with outgoing
+ INVITE
+
+ Return:
+ Call instance.
+ """
+ lck = self._lib().auto_lock()
+ call = Call(self._lib(), -1, cb)
+ err, cid = _pjsua.call_make_call(self._id, dst_uri, 0,
+ call, Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("make_call()", self, err)
+ call.attach_to_id(cid)
+ return call
+
+ def add_buddy(self, uri, cb=None):
+ """Add new buddy.
+
+ Keyword argument:
+ uri -- SIP URI of the buddy
+ cb -- BuddyCallback instance to be installed to the newly
+ created Buddy object. If this callback is not specified
+ (i.e. None is given), it must be installed later using
+ buddy.set_callback().
+
+ Return:
+ Buddy object
+ """
+ lck = self._lib().auto_lock()
+ buddy_cfg = _pjsua.buddy_config_default()
+ buddy_cfg.uri = uri
+ buddy_cfg.subscribe = False
+ err, buddy_id = _pjsua.buddy_add(buddy_cfg)
+ self._lib()._err_check("add_buddy()", self, err)
+ buddy = Buddy(self._lib(), buddy_id, self, cb)
+ return buddy
+
+ def pres_notify(self, pres_obj, state, reason="", hdr_list=None):
+ """Send NOTIFY to inform account presence status or to terminate
+ server side presence subscription.
+
+ Keyword arguments:
+ pres_obj -- The subscription object from on_incoming_subscribe()
+ callback
+ state -- Subscription state, from SubscriptionState
+ reason -- Optional reason phrase.
+ hdr_list -- Optional header list.
+ """
+ lck = self._lib().auto_lock()
+ _pjsua.acc_pres_notify(self._id, pres_obj, state, reason,
+ Lib._create_msg_data(hdr_list))
+
+ def send_pager(self, uri, text, im_id=0, content_type="text/plain", \
+ hdr_list=None):
+ """Send instant message to arbitrary URI.
+
+ Keyword arguments:
+ text -- Instant message to be sent
+ uri -- URI to send the Instant Message to.
+ im_id -- Optional instant message ID to identify this
+ instant message when delivery status callback
+ is called.
+ content_type -- MIME type identifying the instant message
+ hdr_list -- Optional list of headers to be sent with the
+ request.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.im_send(self._id, uri, \
+ content_type, text, \
+ Lib._create_msg_data(hdr_list), \
+ im_id)
+ self._lib()._err_check("send_pager()", self, err)
+
+class CallCallback:
+ """Class to receive event notification from Call objects.
+
+ Use Call.set_callback() method to install instance of this callback
+ class to receive event notifications from the call object.
+
+ Member documentation:
+
+ call -- the Call object.
+
+ """
+ call = None
+
+ def __init__(self, call=None):
+ self._set_call(call)
+
+ def __del__(self):
+ pass
+
+ def _set_call(self, call):
+ if call:
+ self.call = weakref.proxy(call)
+ else:
+ self.call = None
+
+ def on_state(self):
+ """Notification that the call's state has changed.
+
+ """
+ pass
+
+ def on_media_state(self):
+ """Notification that the call's media state has changed.
+
+ """
+ pass
+
+ def on_dtmf_digit(self, digits):
+ """Notification on incoming DTMF digits.
+
+ Keyword argument:
+ digits -- string containing the received digits.
+
+ """
+ pass
+
+ def on_transfer_request(self, dst, code):
+ """Notification that call is being transfered by remote party.
+
+ Application can decide to accept/reject transfer request by returning
+ code greater than or equal to 500. The default behavior is to accept
+ the transfer by returning 202.
+
+ Keyword arguments:
+ dst -- string containing the destination URI
+ code -- the suggested status code to return to accept the request.
+
+ Return:
+ the callback should return 202 to accept the request, or 300-699 to
+ reject the request.
+
+ """
+ return code
+
+ def on_transfer_status(self, code, reason, final, cont):
+ """
+ Notification about the status of previous call transfer request.
+
+ Keyword arguments:
+ code -- SIP status code to indicate completion status.
+ text -- SIP status reason phrase.
+ final -- if True then this is a final status and no further
+ notifications will be sent for this call transfer
+ status.
+ cont -- suggested return value.
+
+ Return:
+ If the callback returns false then no further notification will
+ be sent for the transfer request for this call.
+
+ """
+ return cont
+
+ def on_replace_request(self, code, reason):
+ """Notification when incoming INVITE with Replaces header is received.
+
+ Application may reject the request by returning value greather than
+ or equal to 500. The default behavior is to accept the request.
+
+ Keyword arguments:
+ code -- default status code to return
+ reason -- default reason phrase to return
+
+ Return:
+ The callback should return (code, reason) tuple.
+
+ """
+ return code, reason
+
+ def on_replaced(self, new_call):
+ """
+ Notification that this call will be replaced with new_call.
+ After this callback is called, this call will be disconnected.
+
+ Keyword arguments:
+ new_call -- the new call that will replace this call.
+ """
+ pass
+
+ def on_pager(self, mime_type, body):
+ """
+ Notification that incoming instant message is received on
+ this call.
+
+ Keyword arguments:
+ mime_type -- MIME type of the instant message body.
+ body -- the instant message body.
+
+ """
+ pass
+
+ def on_pager_status(self, body, im_id, code, reason):
+ """
+ Notification about the delivery status of previously sent
+ instant message.
+
+ Keyword arguments:
+ body -- message body
+ im_id -- message ID
+ code -- SIP status code
+ reason -- SIP reason phrase
+
+ """
+ pass
+
+ def on_typing(self, is_typing):
+ """
+ Notification that remote is typing or stop typing.
+
+ Keyword arguments:
+ is_typing -- boolean to indicate whether remote is currently
+ typing an instant message.
+
+ """
+ pass
+
+
+class CallInfo:
+ """This structure contains various information about Call.
+
+ Application may retrieve this information with Call.info().
+
+ Member documentation:
+
+ role -- CallRole
+ account -- Account object.
+ uri -- SIP URI of local account.
+ contact -- local Contact URI.
+ remote_uri -- remote SIP URI.
+ remote_contact -- remote Contact URI
+ sip_call_id -- call's Call-ID identification
+ state -- CallState
+ state_text -- state text.
+ last_code -- last SIP status code
+ last_reason -- text phrase for last_code
+ media_state -- MediaState
+ media_dir -- MediaDir
+ conf_slot -- conference slot number for this call.
+ call_time -- call's connected duration in seconds.
+ total_time -- total call duration in seconds.
+ """
+ role = CallRole.CALLER
+ account = None
+ uri = ""
+ contact = ""
+ remote_uri = ""
+ remote_contact = ""
+ sip_call_id = ""
+ state = CallState.NULL
+ state_text = ""
+ last_code = 0
+ last_reason = ""
+ media_state = MediaState.NULL
+ media_dir = MediaDir.NULL
+ conf_slot = -1
+ call_time = 0
+ total_time = 0
+
+ def __init__(self, lib=None, ci=None):
+ if lib and ci:
+ self._cvt_from_pjsua(lib, ci)
+
+ def _cvt_from_pjsua(self, lib, ci):
+ self.role = ci.role
+ self.account = lib._lookup_account(ci.acc_id)
+ self.uri = ci.local_info
+ self.contact = ci.local_contact
+ self.remote_uri = ci.remote_info
+ self.remote_contact = ci.remote_contact
+ self.sip_call_id = ci.call_id
+ self.state = ci.state
+ self.state_text = ci.state_text
+ self.last_code = ci.last_status
+ self.last_reason = ci.last_status_text
+ self.media_state = ci.media_status
+ self.media_dir = ci.media_dir
+ self.conf_slot = ci.conf_slot
+ self.call_time = ci.connect_duration / 1000
+ self.total_time = ci.total_duration / 1000
+
+
+class Call:
+ """This class represents SIP call.
+
+ Application initiates outgoing call with Account.make_call(), and
+ incoming calls are reported in AccountCallback.on_incoming_call().
+ """
+ _id = -1
+ _cb = None
+ _lib = None
+ _obj_name = ""
+
+ def __init__(self, lib, call_id, cb=None):
+ self._lib = weakref.ref(lib)
+ self.set_callback(cb)
+ self.attach_to_id(call_id)
+ _Trace((self, 'created'))
+
+ def __del__(self):
+ if self._id != -1:
+ _pjsua.call_set_user_data(self._id, 0)
+ _Trace((self, 'destroyed'))
+
+ def __str__(self):
+ return self._obj_name
+
+ def attach_to_id(self, call_id):
+ lck = self._lib().auto_lock()
+ if self._id != -1:
+ _pjsua.call_set_user_data(self._id, 0)
+ self._id = call_id
+ if self._id != -1:
+ _pjsua.call_set_user_data(self._id, self)
+ self._obj_name = "{Call " + self.info().remote_uri + "}"
+ else:
+ self._obj_name = "{Call object}"
+
+ def set_callback(self, cb):
+ """
+ Set callback object to retrieve event notifications from this call.
+
+ Keyword arguments:
+ cb -- CallCallback instance.
+ """
+ if cb:
+ self._cb = cb
+ else:
+ self._cb = CallCallback(self)
+ self._cb._set_call(self)
+
+ def info(self):
+ """
+ Get the CallInfo.
+ """
+ lck = self._lib().auto_lock()
+ ci = _pjsua.call_get_info(self._id)
+ if not ci:
+ self._lib()._err_check("info", self, -1, "Invalid call")
+ call_info = CallInfo(self._lib(), ci)
+ return call_info
+
+ def is_valid(self):
+ """
+ Check if this call is still valid.
+ """
+ lck = self._lib().auto_lock()
+ return _pjsua.call_is_active(self._id)
+
+ def dump_status(self, with_media=True, indent="", max_len=1024):
+ """
+ Dump the call status.
+ """
+ lck = self._lib().auto_lock()
+ return _pjsua.call_dump(self._id, with_media, max_len, indent)
+
+ def answer(self, code=200, reason="", hdr_list=None):
+ """
+ Send provisional or final response to incoming call.
+
+ Keyword arguments:
+ code -- SIP status code.
+ reason -- Reason phrase. Put empty to send default reason
+ phrase for the status code.
+ hdr_list -- Optional list of headers to be sent with the
+ INVITE response.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_answer(self._id, code, reason,
+ Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("answer()", self, err)
+
+ def hangup(self, code=603, reason="", hdr_list=None):
+ """
+ Terminate the call.
+
+ Keyword arguments:
+ code -- SIP status code.
+ reason -- Reason phrase. Put empty to send default reason
+ phrase for the status code.
+ hdr_list -- Optional list of headers to be sent with the
+ message.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_hangup(self._id, code, reason,
+ Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("hangup()", self, err)
+
+ def hold(self, hdr_list=None):
+ """
+ Put the call on hold.
+
+ Keyword arguments:
+ hdr_list -- Optional list of headers to be sent with the
+ message.
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_set_hold(self._id, Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("hold()", self, err)
+
+ def unhold(self, hdr_list=None):
+ """
+ Release the call from hold.
+
+ Keyword arguments:
+ hdr_list -- Optional list of headers to be sent with the
+ message.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_reinvite(self._id, True,
+ Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("unhold()", self, err)
+
+ def reinvite(self, hdr_list=None):
+ """
+ Send re-INVITE and optionally offer new codecs to use.
+
+ Keyword arguments:
+ hdr_list -- Optional list of headers to be sent with the
+ message.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_reinvite(self._id, True,
+ Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("reinvite()", self, err)
+
+ def update(self, hdr_list=None, options=0):
+ """
+ Send UPDATE and optionally offer new codecs to use.
+
+ Keyword arguments:
+ hdr_list -- Optional list of headers to be sent with the
+ message.
+ options -- Must be zero for now.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_update(self._id, options,
+ Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("update()", self, err)
+
+ def transfer(self, dest_uri, hdr_list=None):
+ """
+ Transfer the call to new destination.
+
+ Keyword arguments:
+ dest_uri -- Specify the SIP URI to transfer the call to.
+ hdr_list -- Optional list of headers to be sent with the
+ message.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_xfer(self._id, dest_uri,
+ Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("transfer()", self, err)
+
+ def transfer_to_call(self, call, hdr_list=None, options=0):
+ """
+ Attended call transfer.
+
+ Keyword arguments:
+ call -- The Call object to transfer call to.
+ hdr_list -- Optional list of headers to be sent with the
+ message.
+ options -- Must be zero for now.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_xfer_replaces(self._id, call._id, options,
+ Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("transfer_to_call()", self, err)
+
+ def dial_dtmf(self, digits):
+ """
+ Send DTMF digits with RTP event package.
+
+ Keyword arguments:
+ digits -- DTMF digit string.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_dial_dtmf(self._id, digits)
+ self._lib()._err_check("dial_dtmf()", self, err)
+
+ def send_request(self, method, hdr_list=None, content_type=None,
+ body=None):
+ """
+ Send arbitrary request to remote call.
+
+ This is useful for example to send INFO request. Note that this
+ function should not be used to send request that will change the
+ call state such as CANCEL or BYE.
+
+ Keyword arguments:
+ method -- SIP method name.
+ hdr_list -- Optional header list to be sent with the request.
+ content_type -- Content type to describe the body, if the body
+ is present
+ body -- Optional SIP message body.
+
+ """
+ lck = self._lib().auto_lock()
+ if hdr_list or body:
+ msg_data = _pjsua.Msg_Data()
+ if hdr_list:
+ msg_data.hdr_list = hdr_list
+ if content_type:
+ msg_data.content_type = content_type
+ if body:
+ msg_data.msg_body = body
+ else:
+ msg_data = None
+
+ err = _pjsua.call_send_request(self._id, method, msg_data)
+ self._lib()._err_check("send_request()", self, err)
+
+ def send_pager(self, text, im_id=0, content_type="text/plain",
+ hdr_list=None):
+ """Send instant message inside a call.
+
+ Keyword arguments:
+ text -- Instant message to be sent
+ im_id -- Optional instant message ID to identify this
+ instant message when delivery status callback
+ is called.
+ content_type -- MIME type identifying the instant message
+ hdr_list -- Optional list of headers to be sent with the
+ request.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.call_send_im(self._id, \
+ content_type, text, \
+ Lib._create_msg_data(hdr_list), \
+ im_id)
+ self._lib()._err_check("send_pager()", self, err)
+
+
+class BuddyInfo:
+ """This class contains information about Buddy. Application may
+ retrieve this information by calling Buddy.info().
+
+ Member documentation:
+
+ uri -- the Buddy URI.
+ contact -- the Buddy Contact URI, if available.
+ online_status -- the presence online status.
+ online_text -- the presence online status text.
+ activity -- the PresenceActivity
+ subscribed -- specify whether buddy's presence status is currently
+ being subscribed.
+ sub_state -- SubscriptionState
+ sub_term_reason -- The termination reason string of the last presence
+ subscription to this buddy, if any.
+ """
+ uri = ""
+ contact = ""
+ online_status = 0
+ online_text = ""
+ activity = PresenceActivity.UNKNOWN
+ subscribed = False
+ sub_state = SubscriptionState.NULL
+ sub_term_reason = ""
+
+ def __init__(self, pjsua_bi=None):
+ if pjsua_bi:
+ self._cvt_from_pjsua(pjsua_bi)
+
+ def _cvt_from_pjsua(self, inf):
+ self.uri = inf.uri
+ self.contact = inf.contact
+ self.online_status = inf.status
+ self.online_text = inf.status_text
+ self.activity = inf.activity
+ self.subscribed = inf.monitor_pres
+ self.sub_state = inf.sub_state
+ self.sub_term_reason = inf.sub_term_reason
+
+
+class BuddyCallback:
+ """This class can be used to receive notifications about Buddy's
+ presence status change. Application needs to derive a class from
+ this class, and register the instance with Buddy.set_callback().
+
+ Member documentation:
+
+ buddy -- the Buddy object.
+ """
+ buddy = None
+
+ def __init__(self, buddy=None):
+ self._set_buddy(buddy)
+
+ def _set_buddy(self, buddy):
+ if buddy:
+ self.buddy = weakref.proxy(buddy)
+ else:
+ self.buddy = None
+
+ def on_state(self):
+ """
+ Notification that buddy's presence state has changed. Application
+ may then retrieve the new status with Buddy.info() function.
+ """
+ pass
+
+ def on_pager(self, mime_type, body):
+ """Notification that incoming instant message is received from
+ this buddy.
+
+ Keyword arguments:
+ mime_type -- MIME type of the instant message body
+ body -- the instant message body
+
+ """
+ pass
+
+ def on_pager_status(self, body, im_id, code, reason):
+ """Notification about the delivery status of previously sent
+ instant message.
+
+ Keyword arguments:
+ body -- the message body
+ im_id -- message ID
+ code -- SIP status code
+ reason -- SIP reason phrase
+
+ """
+ pass
+
+ def on_typing(self, is_typing):
+ """Notification that remote is typing or stop typing.
+
+ Keyword arguments:
+ is_typing -- boolean to indicate whether remote is currently
+ typing an instant message.
+
+ """
+ pass
+
+
+class Buddy:
+ """A Buddy represents person or remote agent.
+
+ This class provides functions to subscribe to buddy's presence and
+ to send or receive instant messages from the buddy.
+ """
+ _id = -1
+ _lib = None
+ _cb = None
+ _obj_name = ""
+ _acc = None
+
+ def __init__(self, lib, id, account, cb):
+ self._id = id
+ self._lib = weakref.ref(lib)
+ self._acc = weakref.ref(account)
+ self._obj_name = "{Buddy " + self.info().uri + "}"
+ self.set_callback(cb)
+ _pjsua.buddy_set_user_data(self._id, self)
+ _Trace((self, 'created'))
+
+ def __del__(self):
+ if self._id != -1:
+ _pjsua.buddy_set_user_data(self._id, 0)
+ _Trace((self, 'destroyed'))
+
+ def __str__(self):
+ return self._obj_name
+
+ def info(self):
+ """
+ Get buddy info as BuddyInfo.
+ """
+ lck = self._lib().auto_lock()
+ return BuddyInfo(_pjsua.buddy_get_info(self._id))
+
+ def set_callback(self, cb):
+ """Install callback to receive notifications from this object.
+
+ Keyword argument:
+ cb -- BuddyCallback instance.
+ """
+ if cb:
+ self._cb = cb
+ else:
+ self._cb = BuddyCallback(self)
+ self._cb._set_buddy(self)
+
+ def subscribe(self):
+ """
+ Subscribe to buddy's presence status notification.
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.buddy_subscribe_pres(self._id, True)
+ self._lib()._err_check("subscribe()", self, err)
+
+ def unsubscribe(self):
+ """
+ Unsubscribe from buddy's presence status notification.
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.buddy_subscribe_pres(self._id, False)
+ self._lib()._err_check("unsubscribe()", self, err)
+
+ def delete(self):
+ """
+ Remove this buddy from the buddy list.
+ """
+ lck = self._lib().auto_lock()
+ if self._id != -1:
+ _pjsua.buddy_set_user_data(self._id, 0)
+ err = _pjsua.buddy_del(self._id)
+ self._lib()._err_check("delete()", self, err)
+
+ def send_pager(self, text, im_id=0, content_type="text/plain", \
+ hdr_list=None):
+ """Send instant message to remote buddy.
+
+ Keyword arguments:
+ text -- Instant message to be sent
+ im_id -- Optional instant message ID to identify this
+ instant message when delivery status callback
+ is called.
+ content_type -- MIME type identifying the instant message
+ hdr_list -- Optional list of headers to be sent with the
+ request.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.im_send(self._acc()._id, self.info().uri, \
+ content_type, text, \
+ Lib._create_msg_data(hdr_list), \
+ im_id)
+ self._lib()._err_check("send_pager()", self, err)
+
+ def send_typing_ind(self, is_typing=True, hdr_list=None):
+ """Send typing indication to remote buddy.
+
+ Keyword argument:
+ is_typing -- boolean to indicate wheter user is typing.
+ hdr_list -- Optional list of headers to be sent with the
+ request.
+
+ """
+ lck = self._lib().auto_lock()
+ err = _pjsua.im_typing(self._acc()._id, self.info().uri, \
+ is_typing, Lib._create_msg_data(hdr_list))
+ self._lib()._err_check("send_typing_ind()", self, err)
+
+
+
+# Sound device info
+class SoundDeviceInfo:
+ """This described the sound device info.
+
+ Member documentation:
+ name -- device name.
+ input_channels -- number of capture channels supported.
+ output_channels -- number of playback channels supported.
+ default_clock_rate -- default sampling rate.
+ """
+ name = ""
+ input_channels = 0
+ output_channels = 0
+ default_clock_rate = 0
+
+ def __init__(self, sdi):
+ self.name = sdi.name
+ self.input_channels = sdi.input_count
+ self.output_channels = sdi.output_count
+ self.default_clock_rate = sdi.default_samples_per_sec
+
+
+# Codec info
+class CodecInfo:
+ """This describes codec info.
+
+ Member documentation:
+ name -- codec name
+ priority -- codec priority (0-255)
+ clock_rate -- clock rate
+ channel_count -- number of channels
+ avg_bps -- average bandwidth in bits per second
+ frm_ptime -- base frame length in milliseconds
+ ptime -- RTP frame length in milliseconds.
+ pt -- payload type.
+ vad_enabled -- specify if Voice Activity Detection is currently
+ enabled.
+ plc_enabled -- specify if Packet Lost Concealment is currently
+ enabled.
+ """
+ name = ""
+ priority = 0
+ clock_rate = 0
+ channel_count = 0
+ avg_bps = 0
+ frm_ptime = 0
+ ptime = 0
+ pt = 0
+ vad_enabled = False
+ plc_enabled = False
+
+ def __init__(self, codec_info, codec_param):
+ self.name = codec_info.codec_id
+ self.priority = codec_info.priority
+ self.clock_rate = codec_param.info.clock_rate
+ self.channel_count = codec_param.info.channel_cnt
+ self.avg_bps = codec_param.info.avg_bps
+ self.frm_ptime = codec_param.info.frm_ptime
+ self.ptime = codec_param.info.frm_ptime * \
+ codec_param.setting.frm_per_pkt
+ self.ptime = codec_param.info.pt
+ self.vad_enabled = codec_param.setting.vad
+ self.plc_enabled = codec_param.setting.plc
+
+ def _cvt_to_pjsua(self):
+ ci = _pjsua.Codec_Info()
+ ci.codec_id = self.name
+ ci.priority = self.priority
+ return ci
+
+
+# Codec parameter
+class CodecParameter:
+ """This specifies various parameters that can be configured for codec.
+
+ Member documentation:
+
+ ptime -- specify the outgoing RTP packet length in milliseconds.
+ vad_enabled -- specify if VAD should be enabled.
+ plc_enabled -- specify if PLC should be enabled.
+ """
+ ptime = 0
+ vad_enabled = False
+ plc_enabled = False
+ _codec_param = None
+
+ def __init__(self, codec_param):
+ self.ptime = codec_param.info.frm_ptime * \
+ codec_param.setting.frm_per_pkt
+ self.vad_enabled = codec_param.setting.vad
+ self.plc_enabled = codec_param.setting.plc
+ self._codec_param = codec_param
+
+ def _cvt_to_pjsua(self):
+ self._codec_param.setting.frm_per_pkt = self.ptime / \
+ self._codec_param.info.frm_ptime
+ self._codec_param.setting.vad = self.vad_enabled
+ self._codec_param.setting.plc = self.plc_enabled
+ return self._codec_param
+
+
+# Library mutex
+class _LibMutex:
+ def __init__(self, lck):
+ self._lck = lck
+ self._lck.acquire()
+ #_Trace(('lock acquired',))
+
+ def __del__(self):
+ try:
+ self._lck.release()
+ #_Trace(('lock released',))
+ except:
+ #_Trace(('lock release error',))
+ pass
+
+
+# PJSUA Library
+_lib = None
+enable_trace = False
+
+class Lib:
+ """Library instance.
+
+ """
+ _quit = False
+ _has_thread = False
+ _lock = None
+
+ def __init__(self):
+ global _lib
+ if _lib:
+ raise Error("__init()__", None, -1,
+ "Library instance already exist")
+
+ self._lock = threading.RLock()
+ err = _pjsua.create()
+ self._err_check("_pjsua.create()", None, err)
+ _lib = self
+
+ def __del__(self):
+ _pjsua.destroy()
+ del self._lock
+ _Trace(('Lib destroyed',))
+
+ def __str__(self):
+ return "Lib"
+
+ @staticmethod
+ def instance():
+ """Return singleton instance of Lib.
+ """
+ return _lib
+
+ def init(self, ua_cfg=None, log_cfg=None, media_cfg=None):
+ """
+ Initialize pjsua with the specified configurations.
+
+ Keyword arguments:
+ ua_cfg -- optional UAConfig instance
+ log_cfg -- optional LogConfig instance
+ media_cfg -- optional MediaConfig instance
+
+ """
+ if not ua_cfg: ua_cfg = UAConfig()
+ if not log_cfg: log_cfg = LogConfig()
+ if not media_cfg: media_cfg = MediaConfig()
+
+ py_ua_cfg = ua_cfg._cvt_to_pjsua()
+ py_ua_cfg.cb.on_call_state = _cb_on_call_state
+ py_ua_cfg.cb.on_incoming_call = _cb_on_incoming_call
+ py_ua_cfg.cb.on_call_media_state = _cb_on_call_media_state
+ py_ua_cfg.cb.on_dtmf_digit = _cb_on_dtmf_digit
+ py_ua_cfg.cb.on_call_transfer_request = _cb_on_call_transfer_request
+ py_ua_cfg.cb.on_call_transfer_status = _cb_on_call_transfer_status
+ py_ua_cfg.cb.on_call_replace_request = _cb_on_call_replace_request
+ py_ua_cfg.cb.on_call_replaced = _cb_on_call_replaced
+ py_ua_cfg.cb.on_reg_state = _cb_on_reg_state
+ py_ua_cfg.cb.on_incoming_subscribe = _cb_on_incoming_subscribe
+ py_ua_cfg.cb.on_buddy_state = _cb_on_buddy_state
+ py_ua_cfg.cb.on_pager = _cb_on_pager
+ py_ua_cfg.cb.on_pager_status = _cb_on_pager_status
+ py_ua_cfg.cb.on_typing = _cb_on_typing
+ py_ua_cfg.cb.on_mwi_info = _cb_on_mwi_info;
+
+ err = _pjsua.init(py_ua_cfg, log_cfg._cvt_to_pjsua(),
+ media_cfg._cvt_to_pjsua())
+ self._err_check("init()", self, err)
+
+ def destroy(self):
+ """Destroy the library, and pjsua."""
+ global _lib
+ if self._has_thread:
+ self._quit = 1
+ loop = 0
+ while self._quit != 2 and loop < 400:
+ self.handle_events(5)
+ loop = loop + 1
+ time.sleep(0.050)
+ _pjsua.destroy()
+ _lib = None
+
+ def start(self, with_thread=True):
+ """Start the library.
+
+ Keyword argument:
+ with_thread -- specify whether the module should create worker
+ thread.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.start()
+ self._err_check("start()", self, err)
+ self._has_thread = with_thread
+ if self._has_thread:
+ thread.start_new(_worker_thread_main, (0,))
+
+ def handle_events(self, timeout=50):
+ """Poll the events from underlying pjsua library.
+
+ Application must poll the stack periodically if worker thread
+ is disable when starting the library.
+
+ Keyword argument:
+ timeout -- in milliseconds.
+
+ """
+ lck = self.auto_lock()
+ return _pjsua.handle_events(timeout)
+
+ def thread_register(self, name):
+ """Register external threads (threads that are not created by PJSIP,
+ such as threads that are created by Python API) to PJSIP.
+
+ The call must be made from the new thread before calling any pjlib
+ functions.
+
+ Keyword arguments:
+ name -- Non descriptive name for the thread
+ """
+ dummy = 1
+ err = _pjsua.thread_register(name, dummy)
+ self._err_check("thread_register()", self, err)
+
+ def verify_sip_url(self, sip_url):
+ """Verify that the specified string is a valid URI.
+
+ Keyword argument:
+ sip_url -- the URL string.
+
+ Return:
+ 0 is the the URI is valid, otherwise the appropriate error
+ code is returned.
+
+ """
+ lck = self.auto_lock()
+ return _pjsua.verify_sip_url(sip_url)
+
+ def create_transport(self, type, cfg=None):
+ """Create SIP transport instance of the specified type.
+
+ Keyword arguments:
+ type -- transport type from TransportType constant.
+ cfg -- TransportConfig instance
+
+ Return:
+ Transport object
+
+ """
+ lck = self.auto_lock()
+ if not cfg: cfg=TransportConfig()
+ err, tp_id = _pjsua.transport_create(type, cfg._cvt_to_pjsua())
+ self._err_check("create_transport()", self, err)
+ return Transport(self, tp_id)
+
+ def create_account(self, acc_config, set_default=True, cb=None):
+ """
+ Create a new local pjsua account using the specified configuration.
+
+ Keyword arguments:
+ acc_config -- AccountConfig
+ set_default -- boolean to specify whether to use this as the
+ default account.
+ cb -- AccountCallback instance.
+
+ Return:
+ Account instance
+
+ """
+ lck = self.auto_lock()
+ err, acc_id = _pjsua.acc_add(acc_config._cvt_to_pjsua(), set_default)
+ self._err_check("create_account()", self, err)
+ return Account(self, acc_id, cb)
+
+ def create_account_for_transport(self, transport, set_default=True,
+ cb=None):
+ """Create a new local pjsua transport for the specified transport.
+
+ Keyword arguments:
+ transport -- the Transport instance.
+ set_default -- boolean to specify whether to use this as the
+ default account.
+ cb -- AccountCallback instance.
+
+ Return:
+ Account instance
+
+ """
+ lck = self.auto_lock()
+ err, acc_id = _pjsua.acc_add_local(transport._id, set_default)
+ self._err_check("create_account_for_transport()", self, err)
+ return Account(self, acc_id, cb)
+
+ def hangup_all(self):
+ """Hangup all calls.
+
+ """
+ lck = self.auto_lock()
+ _pjsua.call_hangup_all()
+
+ # Sound device API
+
+ def enum_snd_dev(self):
+ """Enumerate sound devices in the system.
+
+ Return:
+ list of SoundDeviceInfo. The index of the element specifies
+ the device ID for the device.
+ """
+ lck = self.auto_lock()
+ sdi_list = _pjsua.enum_snd_devs()
+ info = []
+ for sdi in sdi_list:
+ info.append(SoundDeviceInfo(sdi))
+ return info
+
+ def get_snd_dev(self):
+ """Get the device IDs of current sound devices used by pjsua.
+
+ Return:
+ (capture_dev_id, playback_dev_id) tuple
+ """
+ lck = self.auto_lock()
+ return _pjsua.get_snd_dev()
+
+ def set_snd_dev(self, capture_dev, playback_dev):
+ """Change the current sound devices.
+
+ Keyword arguments:
+ capture_dev -- the device ID of capture device to be used
+ playback_dev -- the device ID of playback device to be used.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.set_snd_dev(capture_dev, playback_dev)
+ self._err_check("set_current_sound_devices()", self, err)
+
+ def set_null_snd_dev(self):
+ """Disable the sound devices. This is useful if the system
+ does not have sound device installed.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.set_null_snd_dev()
+ self._err_check("set_null_snd_dev()", self, err)
+
+
+ # Conference bridge
+
+ def conf_get_max_ports(self):
+ """Get the conference bridge capacity.
+
+ Return:
+ conference bridge capacity.
+
+ """
+ lck = self.auto_lock()
+ return _pjsua.conf_get_max_ports()
+
+ def conf_connect(self, src_slot, dst_slot):
+ """Establish unidirectional media flow from souce to sink.
+
+ One source may transmit to multiple destinations/sink. And if
+ multiple sources are transmitting to the same sink, the media
+ will be mixed together. Source and sink may refer to the same ID,
+ effectively looping the media.
+
+ If bidirectional media flow is desired, application needs to call
+ this function twice, with the second one having the arguments
+ reversed.
+
+ Keyword arguments:
+ src_slot -- integer to identify the conference slot number of
+ the source/transmitter.
+ dst_slot -- integer to identify the conference slot number of
+ the destination/receiver.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.conf_connect(src_slot, dst_slot)
+ self._err_check("conf_connect()", self, err)
+
+ def conf_disconnect(self, src_slot, dst_slot):
+ """Disconnect media flow from the source to destination port.
+
+ Keyword arguments:
+ src_slot -- integer to identify the conference slot number of
+ the source/transmitter.
+ dst_slot -- integer to identify the conference slot number of
+ the destination/receiver.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.conf_disconnect(src_slot, dst_slot)
+ self._err_check("conf_disconnect()", self, err)
+
+ def conf_set_tx_level(self, slot, level):
+ """Adjust the signal level to be transmitted from the bridge to
+ the specified port by making it louder or quieter.
+
+ Keyword arguments:
+ slot -- integer to identify the conference slot number.
+ level -- Signal level adjustment. Value 1.0 means no level
+ adjustment, while value 0 means to mute the port.
+ """
+ lck = self.auto_lock()
+ err = _pjsua.conf_set_tx_level(slot, level)
+ self._err_check("conf_set_tx_level()", self, err)
+
+ def conf_set_rx_level(self, slot, level):
+ """Adjust the signal level to be received from the specified port
+ (to the bridge) by making it louder or quieter.
+
+ Keyword arguments:
+ slot -- integer to identify the conference slot number.
+ level -- Signal level adjustment. Value 1.0 means no level
+ adjustment, while value 0 means to mute the port.
+ """
+ lck = self.auto_lock()
+ err = _pjsua.conf_set_rx_level(slot, level)
+ self._err_check("conf_set_rx_level()", self, err)
+
+ def conf_get_signal_level(self, slot):
+ """Get last signal level transmitted to or received from the
+ specified port. The signal levels are float values from 0.0 to 1.0,
+ with 0.0 indicates no signal, and 1.0 indicates the loudest signal
+ level.
+
+ Keyword arguments:
+ slot -- integer to identify the conference slot number.
+
+ Return value:
+ (tx_level, rx_level) tuple.
+ """
+ lck = self.auto_lock()
+ err, tx_level, rx_level = _pjsua.conf_get_signal_level(slot)
+ self._err_check("conf_get_signal_level()", self, err)
+ return (tx_level, rx_level)
+
+
+
+ # Codecs API
+
+ def enum_codecs(self):
+ """Return list of codecs supported by pjsua.
+
+ Return:
+ list of CodecInfo
+
+ """
+ lck = self.auto_lock()
+ ci_list = _pjsua.enum_codecs()
+ codec_info = []
+ for ci in ci_list:
+ cp = _pjsua.codec_get_param(ci.codec_id)
+ if cp:
+ codec_info.append(CodecInfo(ci, cp))
+ return codec_info
+
+ def set_codec_priority(self, name, priority):
+ """Change the codec priority.
+
+ Keyword arguments:
+ name -- Codec name
+ priority -- Codec priority, which range is 0-255.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.codec_set_priority(name, priority)
+ self._err_check("set_codec_priority()", self, err)
+
+ def get_codec_parameter(self, name):
+ """Get codec parameter for the specified codec.
+
+ Keyword arguments:
+ name -- codec name.
+
+ """
+ lck = self.auto_lock()
+ cp = _pjsua.codec_get_param(name)
+ if not cp:
+ self._err_check("get_codec_parameter()", self, -1,
+ "Invalid codec name")
+ return CodecParameter(cp)
+
+ def set_codec_parameter(self, name, param):
+ """Modify codec parameter for the specified codec.
+
+ Keyword arguments:
+ name -- codec name
+ param -- codec parameter.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.codec_set_param(name, param._cvt_to_pjsua())
+ self._err_check("set_codec_parameter()", self, err)
+
+ # WAV playback and recording
+
+ def create_player(self, filename, loop=False):
+ """Create WAV file player.
+
+ Keyword arguments
+ filename -- WAV file name
+ loop -- boolean to specify whether playback should
+ automatically restart upon EOF
+ Return:
+ WAV player ID
+
+ """
+ lck = self.auto_lock()
+ opt = 0
+ if not loop:
+ opt = opt + 1
+ err, player_id = _pjsua.player_create(filename, opt)
+ self._err_check("create_player()", self, err)
+ return player_id
+
+ def player_get_slot(self, player_id):
+ """Get the conference port ID for the specified player.
+
+ Keyword arguments:
+ player_id -- the WAV player ID
+
+ Return:
+ Conference slot number for the player
+
+ """
+ lck = self.auto_lock()
+ slot = _pjsua.player_get_conf_port(player_id)
+ if slot < 0:
+ self._err_check("player_get_slot()", self, -1,
+ "Invalid player id")
+ return slot
+
+ def player_set_pos(self, player_id, pos):
+ """Set WAV playback position.
+
+ Keyword arguments:
+ player_id -- WAV player ID
+ pos -- playback position, in samples
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.player_set_pos(player_id, pos)
+ self._err_check("player_set_pos()", self, err)
+
+ def player_destroy(self, player_id):
+ """Destroy the WAV player.
+
+ Keyword arguments:
+ player_id -- the WAV player ID.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.player_destroy(player_id)
+ self._err_check("player_destroy()", self, err)
+
+ def create_playlist(self, filelist, label="playlist", loop=True):
+ """Create WAV playlist.
+
+ Keyword arguments:
+ filelist -- List of WAV file names.
+ label -- Optional name to be assigned to the playlist
+ object (useful for logging)
+ loop -- boolean to specify whether playback should
+ automatically restart upon EOF
+
+ Return:
+ playlist_id
+ """
+ lck = self.auto_lock()
+ opt = 0
+ if not loop:
+ opt = opt + 1
+ err, playlist_id = _pjsua.playlist_create(label, filelist, opt)
+ self._err_check("create_playlist()", self, err)
+ return playlist_id
+
+ def playlist_get_slot(self, playlist_id):
+ """Get the conference port ID for the specified playlist.
+
+ Keyword arguments:
+ playlist_id -- the WAV playlist ID
+
+ Return:
+ Conference slot number for the playlist
+
+ """
+ lck = self.auto_lock()
+ slot = _pjsua.player_get_conf_port(playlist_id)
+ if slot < 0:
+ self._err_check("playlist_get_slot()", self, -1,
+ "Invalid playlist id")
+ return slot
+
+ def playlist_destroy(self, playlist_id):
+ """Destroy the WAV playlist.
+
+ Keyword arguments:
+ playlist_id -- the WAV playlist ID.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.player_destroy(playlist_id)
+ self._err_check("playlist_destroy()", self, err)
+
+ def create_recorder(self, filename):
+ """Create WAV file recorder.
+
+ Keyword arguments
+ filename -- WAV file name
+
+ Return:
+ WAV recorder ID
+
+ """
+ lck = self.auto_lock()
+ err, rec_id = _pjsua.recorder_create(filename, 0, None, -1, 0)
+ self._err_check("create_recorder()", self, err)
+ return rec_id
+
+ def recorder_get_slot(self, rec_id):
+ """Get the conference port ID for the specified recorder.
+
+ Keyword arguments:
+ rec_id -- the WAV recorder ID
+
+ Return:
+ Conference slot number for the recorder
+
+ """
+ lck = self.auto_lock()
+ slot = _pjsua.recorder_get_conf_port(rec_id)
+ if slot < 1:
+ self._err_check("recorder_get_slot()", self, -1,
+ "Invalid recorder id")
+ return slot
+
+ def recorder_destroy(self, rec_id):
+ """Destroy the WAV recorder.
+
+ Keyword arguments:
+ rec_id -- the WAV recorder ID.
+
+ """
+ lck = self.auto_lock()
+ err = _pjsua.recorder_destroy(rec_id)
+ self._err_check("recorder_destroy()", self, err)
+
+
+ # Internal functions
+
+ @staticmethod
+ def strerror(err):
+ return _pjsua.strerror(err)
+
+ def _err_check(self, op_name, obj, err_code, err_msg=""):
+ if err_code != 0:
+ raise Error(op_name, obj, err_code, err_msg)
+
+ @staticmethod
+ def _create_msg_data(hdr_list):
+ if not hdr_list:
+ return None
+ msg_data = _pjsua.Msg_Data()
+ msg_data.hdr_list = hdr_list
+ return msg_data
+
+ def auto_lock(self):
+ return _LibMutex(self._lock)
+
+ # Internal dictionary manipulation for calls, accounts, and buddies
+
+ def _lookup_call(self, call_id):
+ return _pjsua.call_get_user_data(call_id)
+
+ def _lookup_account(self, acc_id):
+ return _pjsua.acc_get_user_data(acc_id)
+
+ def _lookup_buddy(self, buddy_id, uri=None):
+ if buddy_id != -1:
+ buddy = _pjsua.buddy_get_user_data(buddy_id)
+ elif uri:
+ buddy_id = _pjsua.buddy_find(uri)
+ if buddy_id != -1:
+ buddy = _pjsua.buddy_get_user_data(buddy_id)
+ else:
+ buddy = None
+ else:
+ buddy = None
+
+ return buddy
+
+ # Account allbacks
+
+ def _cb_on_reg_state(self, acc_id):
+ acc = self._lookup_account(acc_id)
+ if acc:
+ acc._cb.on_reg_state()
+
+ def _cb_on_incoming_subscribe(self, acc_id, buddy_id, from_uri,
+ contact_uri, pres_obj):
+ acc = self._lookup_account(acc_id)
+ if acc:
+ buddy = self._lookup_buddy(buddy_id)
+ return acc._cb.on_incoming_subscribe(buddy, from_uri, contact_uri,
+ pres_obj)
+ else:
+ return (404, None)
+
+ def _cb_on_incoming_call(self, acc_id, call_id, rdata):
+ acc = self._lookup_account(acc_id)
+ if acc:
+ if 'on_incoming_call2' in acc._cb.__class__.__dict__:
+ acc._cb.on_incoming_call2( Call(self, call_id), rdata )
+ else:
+ acc._cb.on_incoming_call( Call(self, call_id) )
+ else:
+ _pjsua.call_hangup(call_id, 603, None, None)
+
+ # Call callbacks
+
+ def _cb_on_call_state(self, call_id):
+ call = self._lookup_call(call_id)
+ if call:
+ if call._id == -1:
+ call.attach_to_id(call_id)
+ done = (call.info().state == CallState.DISCONNECTED)
+ call._cb.on_state()
+ if done:
+ _pjsua.call_set_user_data(call_id, 0)
+ else:
+ pass
+
+ def _cb_on_call_media_state(self, call_id):
+ call = self._lookup_call(call_id)
+ if call:
+ call._cb.on_media_state()
+
+ def _cb_on_dtmf_digit(self, call_id, digits):
+ call = self._lookup_call(call_id)
+ if call:
+ call._cb.on_dtmf_digit(digits)
+
+ def _cb_on_call_transfer_request(self, call_id, dst, code):
+ call = self._lookup_call(call_id)
+ if call:
+ return call._cb.on_transfer_request(dst, code)
+ else:
+ return 603
+
+ def _cb_on_call_transfer_status(self, call_id, code, text, final, cont):
+ call = self._lookup_call(call_id)
+ if call:
+ return call._cb.on_transfer_status(code, text, final, cont)
+ else:
+ return cont
+
+ def _cb_on_call_replace_request(self, call_id, rdata, code, reason):
+ call = self._lookup_call(call_id)
+ if call:
+ return call._cb.on_replace_request(code, reason)
+ else:
+ return code, reason
+
+ def _cb_on_call_replaced(self, old_call_id, new_call_id):
+ old_call = self._lookup_call(old_call_id)
+ new_call = self._lookup_call(new_call_id)
+ if old_call and new_call:
+ old_call._cb.on_replaced(new_call)
+
+ def _cb_on_pager(self, call_id, from_uri, to_uri, contact, mime_type,
+ body, acc_id):
+ call = None
+ if call_id != -1:
+ call = self._lookup_call(call_id)
+ if call:
+ call._cb.on_pager(mime_type, body)
+ else:
+ acc = self._lookup_account(acc_id)
+ buddy = self._lookup_buddy(-1, from_uri)
+ if buddy:
+ buddy._cb.on_pager(mime_type, body)
+ else:
+ acc._cb.on_pager(from_uri, contact, mime_type, body)
+
+ def _cb_on_pager_status(self, call_id, to_uri, body, user_data,
+ code, reason, acc_id):
+ call = None
+ if call_id != -1:
+ call = self._lookup_call(call_id)
+ if call:
+ call._cb.on_pager_status(body, user_data, code, reason)
+ else:
+ acc = self._lookup_account(acc_id)
+ buddy = self._lookup_buddy(-1, to_uri)
+ if buddy:
+ buddy._cb.on_pager_status(body, user_data, code, reason)
+ else:
+ acc._cb.on_pager_status(to_uri, body, user_data, code, reason)
+
+ def _cb_on_typing(self, call_id, from_uri, to_uri, contact, is_typing,
+ acc_id):
+ call = None
+ if call_id != -1:
+ call = self._lookup_call(call_id)
+ if call:
+ call._cb.on_typing(is_typing)
+ else:
+ acc = self._lookup_account(acc_id)
+ buddy = self._lookup_buddy(-1, from_uri)
+ if buddy:
+ buddy._cb.on_typing(is_typing)
+ else:
+ acc._cb.on_typing(from_uri, contact, is_typing)
+
+ def _cb_on_mwi_info(self, acc_id, body):
+ acc = self._lookup_account(acc_id)
+ if acc:
+ return acc._cb.on_mwi_info(body)
+
+ def _cb_on_buddy_state(self, buddy_id):
+ buddy = self._lookup_buddy(buddy_id)
+ if buddy:
+ buddy._cb.on_state()
+
+#
+# Internal
+#
+
+def _cb_on_call_state(call_id, e):
+ _lib._cb_on_call_state(call_id)
+
+def _cb_on_incoming_call(acc_id, call_id, rdata):
+ _lib._cb_on_incoming_call(acc_id, call_id, rdata)
+
+def _cb_on_call_media_state(call_id):
+ _lib._cb_on_call_media_state(call_id)
+
+def _cb_on_dtmf_digit(call_id, digits):
+ _lib._cb_on_dtmf_digit(call_id, digits)
+
+def _cb_on_call_transfer_request(call_id, dst, code):
+ return _lib._cb_on_call_transfer_request(call_id, dst, code)
+
+def _cb_on_call_transfer_status(call_id, code, reason, final, cont):
+ return _lib._cb_on_call_transfer_status(call_id, code, reason,
+ final, cont)
+def _cb_on_call_replace_request(call_id, rdata, code, reason):
+ return _lib._cb_on_call_replace_request(call_id, rdata, code, reason)
+
+def _cb_on_call_replaced(old_call_id, new_call_id):
+ _lib._cb_on_call_replaced(old_call_id, new_call_id)
+
+def _cb_on_reg_state(acc_id):
+ _lib._cb_on_reg_state(acc_id)
+
+def _cb_on_incoming_subscribe(acc_id, buddy_id, from_uri, contact_uri, pres):
+ return _lib._cb_on_incoming_subscribe(acc_id, buddy_id, from_uri,
+ contact_uri, pres)
+
+def _cb_on_buddy_state(buddy_id):
+ _lib._cb_on_buddy_state(buddy_id)
+
+def _cb_on_pager(call_id, from_uri, to, contact, mime_type, body, acc_id):
+ _lib._cb_on_pager(call_id, from_uri, to, contact, mime_type, body, acc_id)
+
+def _cb_on_pager_status(call_id, to, body, user_data, status, reason, acc_id):
+ _lib._cb_on_pager_status(call_id, to, body, user_data,
+ status, reason, acc_id)
+
+def _cb_on_typing(call_id, from_uri, to, contact, is_typing, acc_id):
+ _lib._cb_on_typing(call_id, from_uri, to, contact, is_typing, acc_id)
+
+def _cb_on_mwi_info(acc_id, body):
+ _lib._cb_on_mwi_info(acc_id, body)
+
+# Worker thread
+def _worker_thread_main(arg):
+ global _lib
+ _Trace(('worker thread started..',))
+ thread_desc = 0;
+ err = _pjsua.thread_register("python worker", thread_desc)
+ _lib._err_check("thread_register()", _lib, err)
+ while _lib and _lib._quit == 0:
+ _lib.handle_events(1)
+ time.sleep(0.050)
+ if _lib:
+ _lib._quit = 2
+ _Trace(('worker thread exited..',))
+
+def _Trace(args):
+ global enable_trace
+ if enable_trace:
+ print "** ",
+ for arg in args:
+ print arg,
+ print " **"
+