[telepathy-butterfly/master] Don't use hard-coded values and use logging utilies intead of 'print'
Louis-Francis Ratté-Boulianne
louis-francis.ratte-boulianne at collabora.co.uk
Thu Sep 10 06:48:19 PDT 2009
---
butterfly/channel/media.py | 45 ++++++------
butterfly/media/constants.py | 35 ++++++++++
butterfly/media/session_handler.py | 35 +++++-----
butterfly/media/stream_handler.py | 132 ++++++++++++++++++++---------------
4 files changed, 150 insertions(+), 97 deletions(-)
create mode 100644 butterfly/media/constants.py
diff --git a/butterfly/channel/media.py b/butterfly/channel/media.py
index 4a8f44f..87bc311 100644
--- a/butterfly/channel/media.py
+++ b/butterfly/channel/media.py
@@ -57,20 +57,21 @@ class ButterflyMediaChannel(
self._session_handler = ButterflySessionHandler(self._conn, self, call.media_session)
self.NewSessionHandler(self._session_handler, self._session_handler.subtype)
- self.GroupFlagsChanged(telepathy.CHANNEL_GROUP_FLAG_CAN_REMOVE, 0)
- self.GroupFlagsChanged(telepathy.CHANNEL_GROUP_FLAG_MESSAGE_REMOVE, 0)
- self.GroupFlagsChanged(telepathy.CHANNEL_GROUP_FLAG_MESSAGE_REJECT, 0)
+ flags = (telepathy.CHANNEL_GROUP_FLAG_CAN_REMOVE |
+ telepathy.CHANNEL_GROUP_FLAG_MESSAGE_REMOVE |
+ telepathy.CHANNEL_GROUP_FLAG_MESSAGE_REJECT)
+ self.GroupFlagsChanged(flags, 0)
self.__add_initial_participants()
def Close(self):
- print "Channel closed by client"
+ logger.info("Channel closed by client")
self._call.end()
def GetSessionHandlers(self):
return [(self._session_handler, self._session_handler.subtype)]
def ListStreams(self):
- print "ListStreams"
+ logger.info("List streams")
streams = dbus.Array([], signature="a(uuuuuu)")
for handler in self._session_handler.ListStreams():
streams.append((handler.id, self._handle, handler.type,
@@ -78,7 +79,7 @@ class ButterflyMediaChannel(
return streams
def RequestStreams(self, handle, types):
- print "RequestStreams %r %r %r" % (handle, self._handle, types)
+ logger.info("Request streams %r %r %r" % (handle, self._handle, types))
if self._handle.get_id() == 0:
self._handle = self._conn.handle(telepathy.HANDLE_TYPE_CONTACT, handle)
@@ -93,11 +94,11 @@ class ButterflyMediaChannel(
return streams
def RequestStreamDirection(self, id, direction):
- print "RequestStreamDirection %r %r" % (id, direction)
+ logger.info("Request stream direction %r %r" % (id, direction))
self._session_handler.GetStream(id).direction = direction
def RemoveStreams(self, streams):
- print "RemoveStreams %r" % streams
+ logger.info("Remove streams %r" % streams)
for id in streams:
self._session_handler.RemoveStream(id)
if not self._session_handler.HasStreams():
@@ -113,7 +114,7 @@ class ButterflyMediaChannel(
return info
def AddMembers(self, handles, message):
- print "Add members", handles, message
+ logger.info("Add members %r: %s" % (handles, message))
for handle in handles:
print handle, self.GetSelfHandle()
if handle == int(self.GetSelfHandle()):
@@ -121,18 +122,18 @@ class ButterflyMediaChannel(
self._call.accept()
def RemoveMembers(self, handles, message):
- print "Remove members", handles, message
+ logger.info("Remove members %r: %s" % (handles, message))
def RemoveMembersWithReason(self, handles, message, reason):
- print "Remove members", handles, message, reason
+ logger.info("Remove members %r: %s (%i)" % (handles, message, reason))
#papyon.event.call.CallEventInterface
def on_call_accepted(self):
- self.on_call_answered(3, 0)
+ self.on_call_answered(telepathy.MEDIA_STREAM_DIRECTION_BIDIRECTIONAL, 0)
#papyon.event.call.CallEventInterface
def on_call_rejected(self, response):
- self.on_call_answered(0, 0)
+ self.on_call_answered(telepathy.MEDIA_STREAM_DIRECTION_NONE, 0)
def on_call_answered(self, direction, pending_send):
for handler in self._session_handler.ListStreams():
@@ -141,14 +142,14 @@ class ButterflyMediaChannel(
#papyon.event.call.CallEventInterface
def on_call_ended(self):
- print "Call ended"
+ logger.info("Call has ended")
telepathy.server.ChannelTypeStreamedMedia.Close(self)
self.remove_from_connection()
self._session_handler.remove_from_connection()
#papyon.event.media.MediaSessionEventInterface
def on_stream_created(self, stream):
- print "Media Stream created upon peer request"
+ logger.info("Media Stream created upon peer request")
handler = self._session_handler.HandleStream(stream)
handler.connect("state-changed", self.on_stream_state_changed)
handler.connect("error", self.on_stream_error)
@@ -156,7 +157,7 @@ class ButterflyMediaChannel(
#papyon.event.media.MediaSessionEventInterface
def on_stream_added(self, stream):
handler = self._session_handler.NewStream(stream)
- print "Media Stream %i added" % handler.id
+ logger.info("Media Stream %i added" % handler.id)
self.StreamAdded(handler.id, self._handle, handler.type)
self.StreamDirectionChanged(handler.id, handler.direction,
handler.pending_send)
@@ -164,7 +165,7 @@ class ButterflyMediaChannel(
#papyon.event.media.MediaSessionEventInterface
def on_stream_removed(self, stream):
handler = self._session_handler.FindStream(stream)
- print "Media Stream %i removed" % handler.id
+ logger.info("Media Stream %i removed" % handler.id)
self._session_handler.RemoveStream(handler.id)
del handler
@@ -172,7 +173,7 @@ class ButterflyMediaChannel(
def on_contact_presence_changed(self, contact):
if contact == self._call.peer and \
contact.presence == papyon.Presence.OFFLINE:
- print "%s is now offline, closing channel" % contact
+ logger.info("%s is now offline, closing channel" % contact)
self.Close()
#StreamHandler event
@@ -190,12 +191,12 @@ class ButterflyMediaChannel(
local_pending = []
remote_pending = []
- if False:
- remote_pending.append(self._handle)
- added.append(self._conn.GetSelfHandle())
- else:
+ if self._call.incoming:
local_pending.append(self._conn.GetSelfHandle())
added.append(self._handle)
+ else:
+ remote_pending.append(self._handle)
+ added.append(self._conn.GetSelfHandle())
self.MembersChanged('', added, [], local_pending, remote_pending,
0, telepathy.CHANNEL_GROUP_CHANGE_REASON_NONE)
diff --git a/butterfly/media/constants.py b/butterfly/media/constants.py
new file mode 100644
index 0000000..e8abd01
--- /dev/null
+++ b/butterfly/media/constants.py
@@ -0,0 +1,35 @@
+# telepathy-butterfly - an MSN connection manager for Telepathy
+#
+# Copyright (C) 2009 Collabora Ltd.
+#
+# 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
+
+import telepathy
+
+STUN_SERVER_IP = "64.14.48.28"
+STUN_SERVER_PORT = 3478
+
+DEFAULT_PROFILE = "AVP"
+PRIORITY_FACTOR = 65536.0
+
+StreamTypes = {
+ "audio": telepathy.MEDIA_STREAM_TYPE_AUDIO,
+ "video": telepathy.MEDIA_STREAM_TYPE_VIDEO
+}
+
+StreamNames = {
+ telepathy.MEDIA_STREAM_TYPE_AUDIO: "audio",
+ telepathy.MEDIA_STREAM_TYPE_VIDEO: "video"
+}
diff --git a/butterfly/media/session_handler.py b/butterfly/media/session_handler.py
index 7d5f888..e422ad8 100644
--- a/butterfly/media/session_handler.py
+++ b/butterfly/media/session_handler.py
@@ -27,10 +27,13 @@ import papyon.event
from butterfly.util.decorator import async
from butterfly.handle import ButterflyHandleFactory
from butterfly.media import ButterflyStreamHandler
+from butterfly.media.constants import *
from papyon.media.constants import *
__all__ = ['ButterflySessionHandler']
+logger = logging.getLogger('Butterfly.SessionHandler')
+
class ButterflySessionHandler (telepathy.server.MediaSessionHandler):
def __init__(self, connection, channel, session):
self._conn = connection
@@ -38,12 +41,6 @@ class ButterflySessionHandler (telepathy.server.MediaSessionHandler):
self._stream_handlers = {}
self._next_stream_id = 0
self._type = session.type
- if self._type == MediaSessionType.WEBCAM_SEND:
- self._subtype = "msncamsend"
- elif self._type == MediaSessionType.WEBCAM_RECV:
- self._subtype = "msncamrecv"
- else:
- self._subtype = "rtp"
self._ready = False
self._pending_handlers = []
@@ -57,7 +54,12 @@ class ButterflySessionHandler (telepathy.server.MediaSessionHandler):
@property
def subtype(self):
- return self._subtype
+ if self._type == MediaSessionType.WEBCAM_SEND:
+ return "msncamsend"
+ elif self._type == MediaSessionType.WEBCAM_RECV:
+ return "msncamrecv"
+ else:
+ return "rtp"
@property
def type(self):
@@ -67,14 +69,14 @@ class ButterflySessionHandler (telepathy.server.MediaSessionHandler):
return "%s/stream%d" % (self._object_path, id)
def Ready(self):
- print "Session ready", self._pending_handlers
+ logger.info("Session ready")
self._ready = True
for handler in self._pending_handlers:
self.NewStream(handler=handler)
self._pending_handlers = []
def Error(self, code, message):
- print "Session error", code, message
+ logger.error("Session received error %i: %s" % (code, message))
def GetStream(self, id):
return self._stream_handlers[id]
@@ -92,19 +94,16 @@ class ButterflySessionHandler (telepathy.server.MediaSessionHandler):
def ListStreams(self):
return self._stream_handlers.values()
- def CreateStream(self, type, direction):
- if type == telepathy.MEDIA_STREAM_TYPE_AUDIO:
- media_type = "audio"
- else:
- media_type = "video"
- stream = self._session.create_stream(media_type, direction, True)
+ def CreateStream(self, stream_type, direction):
+ name = StreamNames[stream_type]
+ stream = self._session.create_stream(name, direction, True)
handler = self.HandleStream(stream)
self._session.add_pending_stream(stream)
return handler
def HandleStream(self, stream):
handler = ButterflyStreamHandler(self._conn, self, stream)
- print "Session add stream handler", handler.id
+ logger.info("Added stream handler %i" % handler.id)
self._stream_handlers[handler.id] = handler
return handler
@@ -114,13 +113,13 @@ class ButterflySessionHandler (telepathy.server.MediaSessionHandler):
if not self._ready:
self._pending_handlers.append(handler)
return handler
- print "Session new stream handler", handler.id
+ logger.info("New stream handler %i" % handler.id)
path = self.get_stream_path(handler.id)
self.NewStreamHandler(path, handler.id, handler.type, handler.direction)
return handler
def RemoveStream(self, id):
- print "Session remove stream handler", id
+ logger.info("Removed stream handler %i" % id)
if id in self._stream_handlers:
handler = self._stream_handlers[id]
handler.remove_from_connection()
diff --git a/butterfly/media/stream_handler.py b/butterfly/media/stream_handler.py
index d3e08bf..f591666 100644
--- a/butterfly/media/stream_handler.py
+++ b/butterfly/media/stream_handler.py
@@ -16,10 +16,12 @@
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+from constants import *
+
import base64
+import logging
import dbus
-
import telepathy
import papyon
import papyon.event
@@ -28,10 +30,7 @@ from papyon.media import *
__all__ = ['ButterflyStreamHandler']
-StreamTypes = {
- "audio": 0,
- "video": 1
-}
+logger = logging.getLogger('Butterfly.StreamHandler')
class ButterflyStreamHandler (
telepathy.server.DBusProperties,
@@ -41,14 +40,13 @@ class ButterflyStreamHandler (
def __init__(self, connection, session, stream):
self._id = session.next_stream_id
path = session.get_stream_path(self._id)
- print "New stream %i" % self._id
self._conn = connection
self._session = session
self._stream = stream
self._interfaces = set()
self._callbacks = {}
- self._state = 1
+ self._state = telepathy.MEDIA_STREAM_STATE_CONNECTING
self._direction = stream.direction
if self._stream.controlling:
self._pending_send = telepathy.MEDIA_STREAM_PENDING_REMOTE_SEND
@@ -117,11 +115,10 @@ class ButterflyStreamHandler (
@property
def stun_servers(self):
- if self._session.type in (MediaSessionType.SIP,
- MediaSessionType.TUNNELED_SIP):
- return [("64.14.48.28", dbus.UInt32(3478))]
- else:
- return dbus.Array([], signature="(su)")
+ servers = dbus.Array([], signature="(su)")
+ if self._session.type in (MediaSessionType.SIP, MediaSessionType.TUNNELED_SIP):
+ servers.append(((STUN_SERVER_IP, dbus.UInt32(STUN_SERVER_PORT))))
+ return servers
def set_direction(self, direction, pending_send):
self._direction = direction
@@ -136,9 +133,9 @@ class ButterflyStreamHandler (
cb(self, *args)
def Ready(self, codecs):
- print "Stream %i is ready" % self._id
- webcam = (self._session.type is MediaSessionType.WEBCAM_SEND or
- self._session.type is MediaSessionType.WEBCAM_RECV)
+ logger.info("Stream %i is ready" % self._id)
+ is_webcam = (self._session.type is MediaSessionType.WEBCAM_SEND or
+ self._session.type is MediaSessionType.WEBCAM_RECV)
if self._remote_candidates:
self.SetRemoteCandidateList(self._remote_candidates)
@@ -150,20 +147,21 @@ class ButterflyStreamHandler (
self.SetStreamSending(self._direction &
telepathy.MEDIA_STREAM_DIRECTION_SEND)
- if self.created_locally or webcam:
+ if self.created_locally or is_webcam:
self.SetLocalCodecs(codecs)
def StreamState(self, state):
- print "StreamState : ", state
+ logger.info("Stream %i state changed to %i" % (self._id, state))
self._state = state
self.emit("state-changed", state)
def Error(self, code, message):
- print "StreamError - %i - %s" % (code, message)
+ logger.error("Stream %i received error %i: %s" % (self._id, code, message))
self.emit("error", code, message)
self.Close()
def NewNativeCandidate(self, id, transports):
+ logger.info("Stream %i received new native candidate %i" % (self._id, id))
candidates = []
for transport in transports:
candidates.append(self.convert_tp_candidate(id, transport))
@@ -171,108 +169,128 @@ class ButterflyStreamHandler (
self._stream.new_local_candidate(candidate)
def NativeCandidatesPrepared(self):
+ logger.info("Stream %i natice candidates are prepared" % self._id)
self._stream.local_candidates_prepared()
def NewActiveCandidatePair(self, native_id, remote_id):
- print "New active candidate pair %s %s" % (native_id, remote_id)
+ logger.info("Stream %i new active candidate pair %s %s" % (self._id,
+ native_id, remote_id))
self._stream.new_active_candidate_pair(native_id, remote_id)
def SetLocalCodecs(self, codecs):
- print "Set Local Codecs"
+ logger.info("Stream %i received local codecs" % self._id)
list = self.convert_tp_codecs(codecs)
self._stream.set_local_codecs(list)
def SupportedCodecs(self, codecs):
- print "SupportedCodecs: ", codecs
+ logger.info("Stream %i received supported codecs" % self._id)
list = self.convert_tp_codecs(codecs)
self._stream.set_local_codecs(list)
def CodecChoice(self, codec_id):
- print "CodecChoice :", codec_id
+ logger.info("Stream %i codec choice is %i" % (self._id, codec_id))
def CodecsUpdated(self, codecs):
- print "CodecsUpdated: ", codecs
+ logger.info("Stream %i received updated codecs" % self._id)
#papyon.event.MediaStreamEventInterface
def on_remote_candidates_received(self, candidates):
- list = self.convert_ice_candidates(candidates)
+ list = self.convert_media_candidates(candidates)
self._remote_candidates = list
if self._stream.controlling:
self.SetRemoteCandidateList(list)
#papyon.event.MediaStreamEventInterface
def on_remote_codecs_received(self, codecs):
- list = self.convert_sdp_codecs(codecs)
+ list = self.convert_media_codecs(codecs)
self._remote_codecs = list
if self._stream.controlling:
self.SetRemoteCodecs(list)
#papyon.event.MediaStreamEventInterface
def on_stream_closed(self):
- print "Media Stream %i closed" % self._id
- self._state = 0
+ logger.info("Stream %i closed" % self._id)
+ self._state = telepathy.MEDIA_STREAM_STATE_DISCONNECTED
self.emit("state-changed", self._state)
self.Close()
- def convert_sdp_codecs(self, codecs):
+ def convert_media_codecs(self, codecs):
list = []
for codec in codecs:
- list.append(self.convert_sdp_codec(codec))
+ list.append(self.convert_media_codec(codec))
return list
- def convert_sdp_codec(self, codec):
+
+ # Conversion functions between papyon objects and telepathy structures
+
+ def convert_media_codec(self, codec):
return (codec.payload, codec.encoding, self._type, codec.clockrate, 0,
codec.params)
def convert_tp_codecs(self, codecs):
list = []
for codec in codecs:
- c = MediaCodec(codec[0], codec[1], codec[3], codec[5])
+ payload, encoding, ctype, clockrate, channels, params = codec
+ c = MediaCodec(payload, encoding, clockrate, params)
list.append(c)
return list
- def convert_ice_candidates(self, candidates):
+ def convert_media_candidates(self, candidates):
array = {}
for c in candidates:
if c.transport == "UDP":
- proto = 0
+ proto = telepathy.MEDIA_STREAM_BASE_PROTO_UDP
else:
- proto = 1
+ proto = telepathy.MEDIA_STREAM_BASE_PROTO_TCP
+
if c.type == "host":
- type = 0
+ type = telepathy.MEDIA_STREAM_TRANSPORT_TYPE_LOCAL
elif c.type == "srflx" or c.type == "prflx":
- type = 1
+ type = telepathy.MEDIA_STREAM_TRANSPORT_TYPE_DERIVED
elif c.type == "relay":
- type = 2
+ type = telepathy.MEDIA_STREAM_TRANSPORT_TYPE_RELAY
else:
- type = 0
+ type = telepathy.MEDIA_STREAM_TRANSPORT_TYPE_LOCAL
+
if c.priority is not None:
- preference = float(c.priority) / 65536.0
+ preference = float(c.priority) / PRIORITY_FACTOR
else:
preference = 1.0
+
transport = (c.component_id, c.ip, c.port, proto, self._session.subtype,
- "AVP", preference, type, c.username, c.password)
+ DEFAULT_PROFILE, preference, type, c.username, c.password)
array.setdefault(c.foundation, []).append(transport)
return array.items()
def convert_tp_candidate(self, id, transport):
- proto = "UDP"
- priority = int(transport[6] * 65536)
- if transport[7] == 0:
- type = "host"
- addr = None
- port = None
- elif transport[7] == 1:
- type = "srflx"
- addr = "192.168.1.102"
- port = int(transport[2])
- elif transport[7] == 2:
- type = "relay"
- addr = None
- port = None
- return MediaCandidate(id, int(transport[0]), proto, priority,
- transport[8], transport[9], type, transport[1],
- int(transport[2]), addr, port)
+ (component_id, ip, port, proto, subtype, profile,
+ preference, ttype, username, password) = transport
+
+ component_id = int(component_id)
+ port = int(port)
+ priority = int(preference * PRIORITY_FACTOR)
+
+ if proto == telepathy.MEDIA_STREAM_BASE_PROTO_UDP:
+ proto = "UDP"
+ elif proto == telepathy.MEDIA_STREAM_BASE_PROTO_TCP:
+ proto = "TCP"
+
+ if ttype == telepathy.MEDIA_STREAM_TRANSPORT_TYPE_LOCAL:
+ ttype = "host"
+ base_addr = None
+ base_port = None
+ elif ttype == telepathy.MEDIA_STREAM_TRANSPORT_TYPE_DERIVED:
+ ttype = "srflx"
+ local_ip = self._conn.msn_client.local_ip
+ base_addr = local_ip
+ base_port = port
+ elif ttype == telepathy.MEDIA_STREAM_TRANSPORT_TYPE_RELAY:
+ ttype = "relay"
+ base_addr = None
+ base_port = None
+
+ return MediaCandidate(id, component_id, proto, priority,
+ username, password, ttype, ip, port, base_addr, base_port)
def convert_relay(self, relay):
info = {"ip": relay.ip, "port": dbus.UInt32(relay.port),
--
1.5.6.5
More information about the telepathy-commits
mailing list