from properties import *
try:
- from telepathy._generated.Client_Observer import ClientObserver as Observer
- from telepathy._generated.Client_Approver import ClientApprover as Approver
- from telepathy._generated.Client_Handler import ClientHandler as Handler
- from telepathy._generated.Client_Interface_Requests import ClientInterfaceRequests
+ from _generated.Client_Observer import ClientObserver as Observer
+ from _generated.Client_Approver import ClientApprover as Approver
+ from _generated.Client_Handler import ClientHandler as Handler
+ from _generated.Client_Interface_Requests import ClientInterfaceRequests
except ImportError:
pass
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+
+"""
+
+import dbus.service
+
+
+class Account(dbus.service.Object):
+ """\
+ An Account object encapsulates the necessary details to make a
+ Telepathy connection.
+
+ Accounts are uniquely identified by object path. The object path
+ of an Account MUST take the form
+ /org/freedesktop/Telepathy/Account/cm/proto/acct, where:
+
+
+ cm is the same Connection_Manager_Name
+ that appears in the connection manager's well-known bus name and
+ object path
+ proto is the Protocol name as seen in
+ ConnectionManager.ListProtocols,
+ but with "-" replaced with "_"
+ (i.e. the same as in the object-path of a Connection)
+ acct is an arbitrary string of ASCII letters, digits
+ and underscores, starting with a letter or underscore, which
+ uniquely identifies this account
+ Clients SHOULD parse the object path to discover the
+ connection manager and protocol
+ Clients MUST NOT attempt to parse acct
+ Clients MUST NOT assume that acct matches
+ the connection-specific part of a Connection's object-path and
+ bus name
+ The account manager SHOULD choose acct such that if
+ an account is deleted, its object path will be re-used if and only
+ if the new account is in some sense "the same"
+ (incorporating the 'account' parameter in some way is
+ recommended)
+
+
+
+ This API avoids specifying the "profiles" used in Mission Control
+ 4.x or the "presets" that have been proposed to replace them. An
+ optional interface will be provided for AM implementations
+ that want to provide presets.
+
+ There is deliberately no functionality here for opening channels;
+ we intend to provide that in the channel dispatcher.
+
+ Other missing features which would be better in their own
+ interfaces:
+
+
+ dynamic parameter-providing (aka provisioning)
+ saved server capabilities
+ account conditions
+ account grouping
+
+
+
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Account', in_signature='', out_signature='')
+ def Remove(self):
+ """Delete the account.
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Account', in_signature='a{sv}as', out_signature='as')
+ def UpdateParameters(self, Set, Unset):
+ """
+ Change the value of the Parameters
+ property.
+
+ If any of the changed parameters'
+ Conn_Mgr_Param_Flags include
+ DBus_Property, the change will be applied to the
+ corresponding D-Bus Property on the active
+ Connection, if there is one. Changes to
+ other parameters will not take effect until the next time the account
+ is disconnected and reconnected.
+
+
+ In general, reconnecting is a destructive operation that shouldn't
+ happen as a side-effect. In particular, migration tools that
+ twiddle the settings of all accounts shouldn't cause an automatic
+ disconnect and reconnect.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Account', in_signature='', out_signature='')
+ def Reconnect(self):
+ """
+ Re-connect this account. If the account is currently disconnected
+ and the requested presence is offline, or if the account
+ is not Enabled or not
+ Valid, this does nothing.
+
+ If the account is disconnected and the requested presence is not
+ offline, this forces an attempt to connect with the requested
+ presence immediately.
+
+ If the account is connecting or connected, this is equivalent to
+ remembering the current value of
+ RequestedPresence, setting its value
+ to (OFFLINE, "offline", ""), waiting for the change to take effect,
+ then setting its value to the value that was previously
+ remembered.
+
+
+ Clients desiring "instant apply" semantics for CM parameters MAY
+ call this method to achieve that.
+
+
+ In particular, if the account's
+ Connection is in the Connecting
+ state, calling this method causes the attempt to connect to be
+ aborted and re-tried.
+
+
+ This is necessary to ensure that the new parameters are
+ picked up.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Account', signature='')
+ def Removed(self):
+ """
+ This account has been removed.
+
+
+ This is redundant with AccountRemoved,
+ but it's still worth having,
+ to avoid having to bind to AccountManager.AccountRemoved to tell
+ you whether your Account is valid — ideally, an account-editing UI
+ should only care about a single Account.
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Account', signature='a{sv}')
+ def AccountPropertyChanged(self, Properties):
+ """
+ The values of one or more properties on this interface (that do not
+ specify that this signal does not apply to them) may have changed.
+ This does not cover properties of other interfaces, which must
+ provide their own change notification if appropriate.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2008 Collabora Ltd.
+Copyright (C) 2008 Nokia Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+
+"""
+
+import dbus.service
+
+
+class AccountInterfaceAvatar(dbus.service.Interface):
+ """\
+ This interface extends the core Account interface to provide a
+ user-settable avatar image.
+
+
+ The avatar could have been a property on the core Account interface,
+ but was moved to a separate interface because it is likely to be
+ large. This means that clients can safely use GetAll to get
+ properties on the core Account interface without flooding the
+ session bus with large images.
+
+
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Account.Interface.Avatar')
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Account.Interface.Avatar', signature='')
+ def AvatarChanged(self):
+ """
+ Emitted when the Avatar property changes.
+
+ The avatar itself is deliberately not included in this
+ signal, to reduce bus traffic in the (likely common) case where no
+ running application cares about the user's own avatar.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+
+"""
+
+import dbus.service
+
+
+class AccountManager(dbus.service.Object):
+ """\
+ The account manager is a central service used to store account
+ details.
+
+ The current account manager is defined to be the process that owns
+ the well-known bus name org.freedesktop.Telepathy.AccountManager on
+ the session bus. This process must export an
+ /org/freedesktop/Telepathy/AccountManager object with the
+ AccountManager interface.
+
+ Until a mechanism exists for making a reasonable automatic choice
+ of AccountManager implementation, implementations SHOULD NOT
+ register as an activatable service for the AccountManager's
+ well-known bus name. Instead, it is RECOMMENDED that some component
+ of the user's session will select and activate a particular
+ implementation, and that other Telepathy-enabled programs can
+ detect whether Telepathy is in use by checking whether the
+ AccountManager's well-known name is in use at runtime.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.AccountManager', in_signature='sssa{sv}a{sv}', out_signature='o')
+ def CreateAccount(self, Connection_Manager, Protocol, Display_Name, Parameters, Properties):
+ """
+ Request the creation of a new Account. The
+ account manager SHOULD NOT allow invalid accounts to be created.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.AccountManager', signature='o')
+ def AccountRemoved(self, Account):
+ """
+ The given account has been removed.
+
+
+ This is effectively change notification for the valid and invalid
+ accounts lists. On emission of this signal, the Account indicated
+ will no longer be present in either of the lists.
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.AccountManager', signature='ob')
+ def AccountValidityChanged(self, Account, Valid):
+ """
+ The validity of the given account has changed. New accounts are
+ also indicated by this signal, as an account validity change
+ (usually to True) on an account that did not previously exist.
+
+
+ This is effectively change notification for the valid and invalid
+ accounts lists.
+
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2005-2009 Collabora Limited
+Copyright © 2005-2009 Nokia Corporation
+Copyright © 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class Channel(dbus.service.Object):
+ """\
+ All communication in the Telepathy framework is carried out via channel
+ objects which are created and managed by connections. This interface must
+ be implemented by all channel objects, along with one single channel type,
+ such as Channel.Type.ContactList
+ which represents a list of people (such as a buddy list) or a Channel.Type.Text which
+ represents a channel over which textual messages are sent and received.
+
+ Each Channel's object path MUST start with the object path of
+ its associated Connection, followed
+ by '/'. There MAY be any number of additional object-path components,
+ which clients MUST NOT attempt to parse.
+
+
+ This ensures that Channel object paths are unique, even between
+ Connections and CMs, because Connection object paths are
+ guaranteed-unique via their link to the well-known bus name.
+
+ If all connection managers in use are known to comply with at least
+ spec version 0.17.10, then the Connection's object path can
+ even be determined from the Channel's without any additional
+ information, by taking the first 7 components.
+
+
+ Each channel may have an immutable handle associated with it, which
+ may be any handle type, such as a contact, room or list handle,
+ indicating that the channel is for communicating with that handle.
+
+ If a channel does not have a handle (an "anonymous channel" with
+ Target_Handle = 0 and Target_Handle_Type = Handle_Type_None), it
+ means that the channel is defined by some other terms, such as it
+ may be a transient group defined only by its members as visible
+ through the Channel.Interface.Group
+ interface.
+
+ Other optional interfaces can be implemented to indicate other available
+ functionality, such as Channel.Interface.Group
+ if the channel contains a number of contacts, Channel.Interface.Password
+ to indicate that a channel may have a password set to require entry, and
+ Properties for
+ extra data about channels which represent chat rooms or voice calls. The
+ interfaces implemented may not vary after the channel's creation has been
+ signalled to the bus (with the connection's NewChannel
+ signal).
+
+ Specific connection manager implementations may implement channel types and
+ interfaces which are not contained within this specification in order to
+ support further functionality. To aid interoperability between client and
+ connection manager implementations, the interfaces specified here should be
+ used wherever applicable, and new interfaces made protocol-independent
+ wherever possible. Because of the potential for 3rd party interfaces adding
+ methods or signals with conflicting names, the D-Bus interface names should
+ always be used to invoke methods and bind signals.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel', in_signature='', out_signature='')
+ def Close(self):
+ """
+ Request that the channel be closed. This is not the case until
+ the Closed signal has been emitted, and
+ depending on the connection
+ manager this may simply remove you from the channel on the server,
+ rather than causing it to stop existing entirely. Some channels
+ such as contact list channels may not be closed.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel', in_signature='', out_signature='s')
+ def GetChannelType(self):
+ """
+ Returns the interface name for the type of this channel. Clients
+ SHOULD use the ChannelType property
+ instead, falling back to this method only if necessary.
+
+
+ The GetAll method lets clients retrieve all properties in one
+ round-trip.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel', in_signature='', out_signature='uu')
+ def GetHandle(self):
+ """
+ Returns the handle type and number if this channel represents a
+ communication with a particular contact, room or server-stored list, or
+ zero if it is transient and defined only by its contents. Clients
+ SHOULD use the TargetHandle and
+ TargetHandleType properties instead,
+ falling back to this method only if necessary.
+
+
+ The GetAll method lets clients retrieve all properties in one
+ round-trip.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel', in_signature='', out_signature='as')
+ def GetInterfaces(self):
+ """
+ Get the optional interfaces implemented by the channel.
+ Clients SHOULD use the Interfaces
+ property instead, falling back to this method only if necessary.
+
+
+ The GetAll method lets clients retrieve all properties in one
+ round-trip.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel', signature='')
+ def Closed(self):
+ """
+ Emitted when the channel has been closed. Method calls on the
+ channel are no longer valid after this signal has been emitted,
+ and the connection manager may then remove the object from the bus
+ at any point.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelDispatchOperation(dbus.service.Object):
+ """\
+ A channel dispatch operation is an object in the ChannelDispatcher
+ representing a batch of unrequested channels being announced to
+ client
+ Approver
+ processes.
+
+ These objects can result from new incoming channels or channels
+ which are automatically created for some reason, but cannot result
+ from outgoing requests for channels.
+
+ More specifically, whenever the
+ Connection.Interface.Requests.NewChannels
+ signal contains channels whose
+ Requested
+ property is false, or whenever the
+ Connection.NewChannel
+ signal contains a channel with suppress_handler false,
+ one or more ChannelDispatchOperation objects are created for those
+ channels.
+
+ (If some channels in a NewChannels signal are in different bundles,
+ this is an error. The channel dispatcher SHOULD recover by treating
+ the NewChannels signal as if it had been several NewChannels signals
+ each containing one channel.)
+
+ First, the channel dispatcher SHOULD construct a list of all the
+ Handlers
+ that could handle all the channels (based on their HandlerChannelFilter
+ property), ordered by
+ priority in some implementation-dependent way. If there are handlers
+ which could handle all the channels, one channel dispatch operation
+ SHOULD be created for all the channels. If there are not, one channel
+ dispatch operation SHOULD be created for each channel, each with
+ a list of channel handlers that could handle that channel.
+
+ If no handler at all can handle a channel, the channel dispatcher
+ SHOULD terminate that channel instead of creating a channel dispatcher
+ for it. It is RECOMMENDED that the channel dispatcher closes
+ the channels using Channel.Interface.Destroyable.Destroy
+ if supported, or Channel.Close
+ otherwise. As a special case, the channel dispatcher SHOULD NOT close
+ ContactList
+ channels, and if Close fails, the channel dispatcher SHOULD ignore
+ that channel.
+
+
+ ContactList channels are strange. We hope to replace them with
+ something better, such as an interface on the Connection, in a
+ future version of this specification.
+
+
+ When listing channel handlers, priority SHOULD be given to
+ channel handlers that are already handling channels from the same
+ bundle.
+
+ If a handler with BypassApproval
+ = True could handle all of the channels in the dispatch
+ operation, then the channel dispatcher SHOULD call HandleChannels
+ on that handler, and (assuming the call succeeds) emit
+ Finished and stop processing those
+ channels without involving any approvers.
+
+
+ Some channel types can be picked up "quietly" by an existing
+ channel handler. If a Text
+ channel is added to an existing bundle containing a StreamedMedia
+ channel, there shouldn't be
+ any approvers, flashing icons or notification bubbles, if the
+ the UI for the StreamedMedia channel can just add a text box
+ and display the message.
+
+
+ Otherwise, the channel dispatcher SHOULD send the channel dispatch
+ operation to all relevant approvers (in parallel) and wait for an
+ approver to claim the channels or request that they are handled.
+ See
+ AddDispatchOperation
+ for more details on this.
+
+ Finally, if the approver requested it, the channel dispatcher SHOULD
+ send the channels to a handler.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.ChannelDispatchOperation', in_signature='s', out_signature='')
+ def HandleWith(self, Handler):
+ """
+ Called by an approver to accept a channel bundle and request that
+ the given handler be used to handle it.
+
+ If successful, this method will cause the ChannelDispatchOperation
+ object to disappear, emitting
+ Finished.
+
+ However, this method may fail because the dispatch has already been
+ completed and the object has already gone. If this occurs, it
+ indicates that another approver has asked for the bundle to be
+ handled by a particular handler. The approver MUST NOT attempt
+ to interact with the channels further in this case, unless it is
+ separately invoked as the handler.
+
+ Approvers which are also channel handlers SHOULD use
+ Claim instead
+ of HandleWith to request that they can handle a channel bundle
+ themselves.
+
+ (FIXME: list some possible errors)
+
+ If the channel handler raises an error from HandleChannels,
+ this method
+ MAY respond by raising that same error, even if it is not
+ specifically documented here.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.ChannelDispatchOperation', in_signature='', out_signature='')
+ def Claim(self):
+ """
+ Called by an approver to claim channels for handling
+ internally. If this method is called successfully, the process
+ calling this method becomes the handler for the channel, but
+ does not have the HandleChannels
+ method called on it.
+
+ Clients that call Claim on channels but do not immediately
+ close them SHOULD implement the Handler interface and its
+ HandledChannels
+ property.
+
+ Approvers wishing to reject channels MUST call this method to
+ claim ownership of them, and MUST NOT call
+ Close
+ on the channels unless/until this method returns successfully.
+
+
+ The channel dispatcher can't know how best to close arbitrary
+ channel types, so it leaves it up to the approver to do so.
+ For instance, for Text channels it is necessary
+ to acknowledge any messages that have already been displayed to
+ the user first - ideally, the approver would display and then
+ acknowledge the messages - or to call Channel.Interface.Destroyable.Destroy
+ if the destructive behaviour of that method is desired.
+
+ Similarly, an Approver for StreamedMedia channels can close the
+ channel with a reason (e.g. "busy") if desired. The channel
+ dispatcher, which is designed to have no specific knowledge
+ of particular channel types, can't do that.
+
+
+ If successful, this method will cause the ChannelDispatchOperation
+ object to disappear, emitting
+ Finished, in the same way as for
+ HandleWith.
+
+ This method may fail because the dispatch operation has already
+ been completed. Again, see HandleWith for more details. The approver
+ MUST NOT attempt to interact with the channels further in this
+ case.
+
+ (FIXME: list some other possible errors)
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.ChannelDispatchOperation', signature='oss')
+ def ChannelLost(self, Channel, Error, Message):
+ """
+ A channel has closed before it could be claimed or handled. If
+ this is emitted for the last remaining channel in a channel
+ dispatch operation, it MUST immediately be followed by
+ Finished.
+
+ This signal MUST NOT be emitted until all Approvers that were
+ invoked have returned (successfully or with an error) from
+ their AddDispatchOperation
+ method.
+
+
+ This means that Approvers can connect to the ChannelLost signal
+ in a race-free way. Non-approver processes that discover
+ a channel dispatch operation in some way (such as observers)
+ will have to follow the usual "connect to signals then recover
+ state" model - first connect to ChannelLost and
+ Finished,
+ then download Channels (and
+ on error, perhaps assume that the operation has already
+ Finished).
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.ChannelDispatchOperation', signature='')
+ def Finished(self):
+ """
+ Emitted when this dispatch operation finishes. The dispatch
+ operation is no longer present and further methods must not be
+ called on it.
+
+ Approvers that have a user interface SHOULD stop notifying the user
+ about the channels in response to this signal; they MAY assume that
+ on errors, they would have received
+ ChannelLost first.
+
+ Its object path SHOULD NOT be reused for a subsequent dispatch
+ operation; the ChannelDispatcher MUST choose object paths
+ in a way that avoids immediate re-use.
+
+
+ Otherwise, clients might accidentally call
+ HandleWith or
+ Claim on a new dispatch operation
+ instead of the one they intended to handle.
+
+
+ This signal MUST NOT be emitted until all Approvers that were
+ invoked have returned (successfully or with an error) from
+ their AddDispatchOperation
+ method.
+
+
+ This means that Approvers can connect to the ChannelLost signal
+ in a race-free way. Non-approver processes that discover
+ a channel dispatch operation in some way (such as observers)
+ will have to follow the usual "connect to signals then recover
+ state" model - first connect to
+ ChannelLost and
+ Finished, then download Channels
+ (and on error, perhaps assume that the operation has already
+ Finished).
+
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelDispatcher(dbus.service.Object):
+ """\
+ The channel dispatcher is responsible for responding to new
+ channels and launching client processes to handle them. It also
+ provides functionality for client processes to request that new
+ channels are created.
+
+ If a channel dispatcher is running, it is responsible for dispatching
+ new channels on all
+ Connections
+ created by the
+ AccountManager.
+ Connections not created by the AccountManager are outside the scope
+ of the channel dispatcher.
+
+
+ Connections created by standalone Telepathy clients
+ that do not intend to interact with the channel dispatcher
+ should be ignored - otherwise, the channel dispatcher would try
+ to launch handlers for channels that the standalone client
+ was already handling internally.
+
+
+ The current channel dispatcher is defined to be the process that
+ owns the well-known bus name
+ org.freedesktop.Telepathy.ChannelDispatcher on
+ the session bus. This process MUST export an object with this
+ interface at the object path
+ /org/freedesktop/Telepathy/ChannelDispatcher.
+
+ Until a mechanism exists for making a reasonable automatic choice
+ of ChannelDispatcher implementation, implementations SHOULD NOT
+ register as an activatable service for the ChannelDispatcher's
+ well-known bus name. Instead, it is RECOMMENDED that some component
+ of the user's session will select and activate a particular
+ implementation, and that other Telepathy-enabled programs
+ can detect whether channel request/dispatch functionality is available
+ by checking whether the ChannelDispatcher's well-known name is in use
+ at runtime.
+
+ There are three categories of client process defined by this
+ specification:
+
+
+ Observer
+ Observers monitor the creation of new channels. This
+ functionality can be used for things like message logging.
+ All observers are notified simultaneously.
+
+ Approver
+
+ Approvers notify the user that new channels have been created,
+ and also select which channel handler will be used for the channel,
+ either by asking the user or by choosing the most appropriate
+ channel handler.
+
+
+ Handler
+
+ Each new channel or set of channels is passed to exactly one
+ handler as its final destination. A typical channel handler is a
+ user interface process handling channels of a particular type.
+
+
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.ChannelDispatcher', in_signature='oa{sv}xs', out_signature='o')
+ def CreateChannel(self, Account, Requested_Properties, User_Action_Time, Preferred_Handler):
+ """
+ Start a request to create a channel. This initially just creates a
+ ChannelRequest
+ object, which can be used to continue the request and track its
+ success or failure.
+
+
+ The request can take a long time - in the worst case, the
+ channel dispatcher has to ask the account manager to put the
+ account online, the account manager has to ask the operating
+ system to obtain an Internet connection, and the operating
+ system has to ask the user whether to activate an Internet
+ connection using an on-demand mechanism like dialup.
+
+ This means that using a single D-Bus method call and response
+ to represent the whole request will tend to lead to that call
+ timing out, which is not the behaviour we want.
+
+
+ If this method is called for an Account that is disabled, invalid
+ or otherwise unusable, no error is signalled until
+ ChannelRequest.Proceed
+ is called, at which point
+ ChannelRequest.Failed
+ is emitted with an appropriate error.
+
+
+ This means there's only one code path for errors, apart from
+ InvalidArgument for "that request makes no sense".
+
+ It also means that the request will proceed if the account is
+ enabled after calling CreateChannel, but before calling
+ Proceed.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.ChannelDispatcher', in_signature='oa{sv}xs', out_signature='o')
+ def EnsureChannel(self, Account, Requested_Properties, User_Action_Time, Preferred_Handler):
+ """
+ Start a request to ensure that a channel exists, creating it if
+ necessary. This initially just creates a ChannelRequest
+ object, which can be used to continue the request and track its
+ success or failure.
+
+ If this method is called for an Account that is disabled, invalid
+ or otherwise unusable, no error is signalled until
+ ChannelRequest.Proceed
+ is called, at which point
+ ChannelRequest.Failed
+ is emitted with an appropriate error.
+
+
+ The rationale is as for CreateChannel.
+
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelDispatcherInterfaceOperationList(dbus.service.Interface):
+ """\
+ This interface allows users of the ChannelDispatcher to enumerate
+ all the pending dispatch operations, with change notification.
+
+
+ The existence of the
+ DispatchOperations property allows a
+ newly started approver to pick up existing dispatch operations.
+
+ This is on a separate interface so clients that aren't interested
+ in doing this aren't woken up by its signals.
+
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList')
+
+ @dbus.service.signal('org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList', signature='oa{sv}')
+ def NewDispatchOperation(self, Dispatch_Operation, Properties):
+ """
+ Emitted when a dispatch operation is added to
+ DispatchOperations.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList', signature='o')
+ def DispatchOperationFinished(self, Dispatch_Operation):
+ """
+ Emitted when a dispatch operation finishes (i.e. exactly once per
+ emission of ChannelDispatchOperation.Finished).
+
+
+ Strictly speaking this is redundant with
+ ChannelDispatchOperation.Finished, but it provides full
+ change-notification for the
+ DispatchOperations property.
+
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2007-2008 Collabora Limited
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelHandler(dbus.service.Object):
+ """\
+ An interface exported by Mission Control 4 client applications which
+ are able to handle incoming channels.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.ChannelHandler', in_signature='sosouu', out_signature='')
+ def HandleChannel(self, Bus_Name, Connection, Channel_Type, Channel, Handle_Type, Handle):
+ """
+ Called when a channel handler should handle a new channel.
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2008 Collabora Limited
+ Copyright (C) 2008 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceCallState(dbus.service.Interface):
+ """\
+ An interface for streamed media channels that can indicate call
+ progress or call states. The presence of this interface is no guarantee
+ that call states will actually be signalled (for instance, SIP
+ implementations are not guaranteed to generate status 180 Ringing, so a
+ call can be accepted without the Ringing flag ever having been set;
+ similarly, Jingle implementations are not guaranteed to send
+ <ringing/>).
+
+ To notify the other participant in the call that they are on hold,
+ see Hold.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.CallState')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.CallState', in_signature='', out_signature='a{uu}')
+ def GetCallStates(self):
+ """
+ Get the current call states for all contacts involved in this call.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.CallState', signature='uu')
+ def CallStateChanged(self, Contact, State):
+ """
+ Emitted when the state of a member of the channel has changed.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2007 Collabora Limited
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceChatState(dbus.service.Interface):
+ """\
+ An interface for channels for receiving notifications of remote contacts'
+ state, and for notifying remote contacts of the local state.
+
+ Clients should assume that a contact's state is Channel_Chat_State_Inactive
+ unless they receive a notification otherwise.
+
+ The Channel_Chat_State_Gone state is treated differently to other states:
+
+ It may not be used for multi-user chats
+ It may not be explicitly sent
+ It should be automatically sent when the channel is closed
+ It must not be sent to the peer if a channel is closed without being used
+ Receiving it must not cause a new channel to be opened
+
+
+ The different states are defined by XEP-0085, but may be applied to any suitable protocol.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.ChatState')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.ChatState', in_signature='u', out_signature='')
+ def SetChatState(self, State):
+ """
+ Set the local state and notify other members of the channel that it
+ has changed.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.ChatState', signature='uu')
+ def ChatStateChanged(self, Contact, State):
+ """
+ Emitted when the state of a member of the channel has changed.
+ This includes local state.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2005, 2006 Collabora Limited
+Copyright (C) 2005, 2006 Nokia Corporation
+Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceDTMF(dbus.service.Interface):
+ """\
+ An interface that gives a Channel the ability to send DTMF events over
+ audio streams which have been established using the StreamedMedia channel
+ type. The event codes used are in common with those defined in RFC4733, and are
+ listed in the DTMF_Event enumeration.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.DTMF')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.DTMF', in_signature='uy', out_signature='')
+ def StartTone(self, Stream_ID, Event):
+ """
+ Start sending a DTMF tone on this stream. Where possible, the tone
+ will continue until StopTone is called.
+ On certain protocols, it may
+ only be possible to send events with a predetermined length. In this
+ case, the implementation may emit a fixed-length tone, and the StopTone
+ method call should return NotAvailable.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.DTMF', in_signature='u', out_signature='')
+ def StopTone(self, Stream_ID):
+ """
+ Stop sending any DTMF tone which has been started using the
+ StartTone
+ method. If there is no current tone, this method will do nothing.
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2008 Collabora Ltd.
+Copyright (C) 2008 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceDestroyable(dbus.service.Interface):
+ """\
+ This interface exists to support channels where
+ Channel.Close
+ is insufficiently destructive. At the moment this means
+ Channel.Type.Text,
+ but the existence of this interface means that unsupported channels
+ can be terminated in a non-channel-type-specific way.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.Destroyable')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Destroyable', in_signature='', out_signature='')
+ def Destroy(self):
+ """
+ Close the channel abruptly, possibly with loss of data. The
+ connection manager MUST NOT re-create the channel unless/until
+ more events occur.
+
+
+ The main motivating situation for this method is that when a Text
+ channel with pending messages is closed with Close, it comes back
+ as an incoming channel (to avoid a race between Close and an
+ incoming message). If Destroy is called on a Text channel, the CM
+ should delete all pending messages and close the channel, and
+ the channel shouldn't be re-created until/unless another message
+ arrives.
+
+
+ Most clients SHOULD call
+ Channel.Close
+ instead. However, if a client explicitly intends to destroy the
+ channel with possible loss of data, it SHOULD call this method
+ if this interface is supported (according to the
+ Channel.Interfaces
+ property), falling back to Close if not.
+
+ In particular, channel dispatchers SHOULD use this method if
+ available when terminating channels that cannot be handled
+ correctly (for instance, if no handler has been installed for
+ a channel type, or if the handler crashes repeatedly).
+
+ Connection managers do not need to implement this interface on
+ channels where Close and Destroy would be equivalent.
+
+
+ Callers need to be able to fall back to Close in any case.
+
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2005-2009 Collabora Limited
+Copyright © 2005-2009 Nokia Corporation
+Copyright © 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceGroup(dbus.service.Interface):
+ """\
+ Interface for channels which have multiple members, and where the members
+ of the channel can change during its lifetime. Your presence in the channel
+ cannot be presumed by the channel's existence (for example, a channel you
+ may request membership of but your request may not be granted).
+
+ This interface implements three lists: a list of current members
+ (Members), and two lists of local pending
+ and remote pending members
+ (LocalPendingMembers and
+ RemotePendingMembers, respectively).
+ Contacts on the remote
+ pending list have been invited to the channel, but the remote user has not
+ accepted the invitation. Contacts on the local pending list have requested
+ membership of the channel, but the local user of the framework must accept
+ their request before they may join. A single contact should never appear on
+ more than one of the three lists. The lists are empty when the channel is
+ created, and the MembersChanged signal
+ (and, if the channel's GroupFlags contains
+ Members_Changed_Detailed, the
+ MembersChangedDetailed signal)
+ should be emitted when information
+ is retrieved from the server, or changes occur.
+
+ If the MembersChanged or
+ MembersChangedDetailed signal indicates
+ that the SelfHandle has been removed from
+ the channel, and the channel subsequently emits Closed,
+ clients SHOULD consider the details given in the MembersChanged or
+ MembersChangedDetailed signal to be the reason why the channel closed.
+
+ Addition of members to the channel may be requested by using
+ AddMembers. If
+ remote acknowledgement is required, use of the AddMembers method will cause
+ users to appear on the remote pending list. If no acknowledgement is
+ required, AddMembers will add contacts to the member list directly. If a
+ contact is awaiting authorisation on the local pending list, AddMembers
+ will grant their membership request.
+
+ Removal of contacts from the channel may be requested by using
+ RemoveMembers. If a contact is awaiting
+ authorisation on the local pending
+ list, RemoveMembers will refuse their membership request. If a contact is
+ on the remote pending list but has not yet accepted the invitation,
+ RemoveMembers will rescind the request if possible.
+
+ It should not be presumed that the requester of a channel implementing this
+ interface is immediately granted membership, or indeed that they are a
+ member at all, unless they appear in the list. They may, for instance,
+ be placed into the remote pending list until a connection has been
+ established or the request acknowledged remotely.
+
+ If the local user joins a Group channel whose members or other state
+ cannot be discovered until the user joins (e.g. many chat room
+ implementations), the connection manager should ensure that the channel
+ is, as far as possible, in a consistent state before adding the local
+ contact to the members set; until this happens, the local contact should
+ be in the remote-pending set. For instance, if the connection manager
+ queries the server to find out the initial members list for the
+ channel, it should leave the local contact in the remote-pending set
+ until it has finished receiving the initial members list.
+
+
+ If the protocol provides no reliable way to tell whether the complete
+ initial members list has been received yet, the connection manager
+ should make a best-effort attempt to wait for the full list
+ (in the worst case, waiting for a suitable arbitrary timeout)
+ rather than requiring user interfaces to do so on its behalf.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.Group')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='aus', out_signature='')
+ def AddMembers(self, Contacts, Message):
+ """
+ Invite all the given contacts into the channel, or accept requests for
+ channel membership for contacts on the pending local list.
+
+ A message may be provided along with the request, which will be sent
+ to the server if supported. See the CHANNEL_GROUP_FLAG_MESSAGE_ADD and
+ CHANNEL_GROUP_FLAG_MESSAGE_ACCEPT
+ GroupFlags to see in which cases this
+ message should be provided.
+
+ Attempting to add contacts who are already members is allowed;
+ connection managers must silently accept this, without error.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='', out_signature='auauau')
+ def GetAllMembers(self):
+ """
+ Returns arrays of all current, local and remote pending channel
+ members.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='', out_signature='u')
+ def GetGroupFlags(self):
+ """
+ Returns the value of the GroupFlags property.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='au', out_signature='au')
+ def GetHandleOwners(self, Handles):
+ """
+ If the CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES flag is set on
+ the channel, then the handles of the group members are specific
+ to this channel, and are not meaningful in a connection-wide
+ context such as contact lists. This method allows you to find
+ the owner of the handle if it can be discovered in this channel,
+ or 0 if the owner is not available.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='', out_signature='au')
+ def GetLocalPendingMembers(self):
+ """
+ Returns the To_Be_Added handle (only) for each structure in the
+ LocalPendingMembers property.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='', out_signature='a(uuus)')
+ def GetLocalPendingMembersWithInfo(self):
+ """
+ Returns the LocalPendingMembers property.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='', out_signature='au')
+ def GetMembers(self):
+ """
+ Returns the Members property.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='', out_signature='au')
+ def GetRemotePendingMembers(self):
+ """
+ Returns an array of handles representing contacts who have been
+ invited to the channel and are awaiting remote approval.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='', out_signature='u')
+ def GetSelfHandle(self):
+ """
+ Returns the value of the SelfHandle
+ property.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='aus', out_signature='')
+ def RemoveMembers(self, Contacts, Message):
+ """
+ Requests the removal of contacts from a channel, reject their
+ request for channel membership on the pending local list, or
+ rescind their invitation on the pending remote list.
+
+ If the SelfHandle is in a Group,
+ it can be removed via this method, in order to leave the group
+ gracefully. This is the recommended way to leave a chatroom, close
+ or reject a StreamedMedia
+ call, and so on.
+
+ Accordingly, connection managers SHOULD support
+ doing this, regardless of the value of
+ GroupFlags.
+ If doing so fails with PermissionDenied, this is considered to a bug
+ in the connection manager, but clients MUST recover by falling back
+ to closing the channel with the Close
+ method.
+
+ Removing any contact from the local pending list is always
+ allowed. Removing contacts other than the
+ SelfHandle from the channel's members
+ is allowed if and only if Channel_Group_Flag_Can_Remove is in the
+ GroupFlags,
+ while removing contacts other than the
+ SelfHandle from the remote pending list
+ is allowed if and only if Channel_Group_Flag_Can_Rescind is in the
+ GroupFlags.
+
+ A message may be provided along with the request, which will be
+ sent to the server if supported. See the
+ Channel_Group_Flag_Message_Remove,
+ Channel_Group_Flag_Message_Depart,
+ Channel_Group_Flag_Message_Reject and
+ Channel_Group_Flag_Message_Rescind
+ GroupFlags to see in which cases this
+ message should be provided.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Group', in_signature='ausu', out_signature='')
+ def RemoveMembersWithReason(self, Contacts, Message, Reason):
+ """
+ As RemoveMembers, but a reason code may
+ be provided where
+ appropriate. The reason code may be ignored if the underlying
+ protocol is unable to represent the given reason.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Group', signature='a{uu}au')
+ def HandleOwnersChanged(self, Added, Removed):
+ """
+ Emitted whenever the HandleOwners
+ property changes.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Group', signature='u')
+ def SelfHandleChanged(self, Self_Handle):
+ """
+ Emitted whenever the SelfHandle property
+ changes.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Group', signature='uu')
+ def GroupFlagsChanged(self, Added, Removed):
+ """
+ Emitted when the flags as returned by
+ GetGroupFlags are changed.
+ The user interface should be updated as appropriate.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Group', signature='sauauauauuu')
+ def MembersChanged(self, Message, Added, Removed, Local_Pending, Remote_Pending, Actor, Reason):
+ """
+ Emitted when contacts join any of the three lists (members, local
+ pending or remote pending) or when they leave any of the three lists.
+ There may also be a message from the server regarding this change,
+ which may be displayed to the user if desired.
+
+ All channel-specific handles that are mentioned in this signal
+ MUST be represented in the value of the
+ HandleOwners property.
+ In practice, this will mean that
+ HandleOwnersChanged is
+ emitted before emitting a MembersChanged signal in which
+ channel-specific handles are added, but that it is emitted
+ after emitting a MembersChanged signal in which
+ channel-specific handles are removed.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Group', signature='auauauaua{sv}')
+ def MembersChangedDetailed(self, Added, Removed, Local_Pending, Remote_Pending, Details):
+ """
+ Emitted when contacts join any of the three lists (members, local
+ pending or remote pending) or when they leave any of the three
+ lists. This signal provides a superset of the information provided by
+ MembersChanged;
+ if the channel's GroupFlags
+ contains Members_Changed_Detailed, then clients may listen exclusively
+ to this signal in preference to that signal.
+
+ All channel-specific handles that are mentioned in this signal
+ MUST be represented in the value of the
+ HandleOwners property. In practice,
+ this will mean that
+ HandleOwnersChanged is emitted
+ before emitting a MembersChangedDetailed signal in which
+ channel-specific handles are added, but that it is emitted
+ after emitting a MembersChangedDetailed signal in which
+ channel-specific handles are removed.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005-2008 Collabora Limited
+ Copyright (C) 2005-2008 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceHold(dbus.service.Interface):
+ """\
+ Interface for channels where you may put the channel on hold.
+ This only makes sense for channels where
+ you are streaming media to or from the members. (To see whether the
+ other participant has put you on hold, see CallState.)
+
+ If you place a channel on hold, this indicates that you do not wish
+ to be sent media streams by any of its members and will be ignoring
+ any media streams you continue to receive. It also requests that the
+ connection manager free up any resources that are only needed for
+ an actively used channel (e.g. in a GSM or PBX call, it will be
+ necessary to place an active call on hold before you can start
+ another call).
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.Hold')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Hold', in_signature='', out_signature='uu')
+ def GetHoldState(self):
+ """
+ Return whether the local user has placed the channel on hold.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Hold', in_signature='b', out_signature='')
+ def RequestHold(self, Hold):
+ """
+ Request that the channel be put on hold (be instructed not to send
+ any media streams to you) or be taken off hold.
+
+ If the connection manager can immediately tell that the requested
+ state change could not possibly succeed, this method SHOULD
+ return the NotAvailable error. If the requested state is the
+ same as the current state, this method SHOULD return successfully
+ without doing anything.
+
+ Otherwise, this method SHOULD immediately set the hold state to
+ Local_Hold_State_Pending_Hold or Local_Hold_State_Pending_Unhold
+ (as appropriate), emitting
+ HoldStateChanged if this is a change,
+ and return successfully.
+
+ The eventual success or failure of the request is indicated by a
+ subsequent HoldStateChanged signal, changing the hold state to
+ Local_Hold_State_Held or Local_Hold_State_Unheld.
+
+ If the channel has multiple streams, and the connection manager
+ succeeds in changing the hold state of one stream but fails to
+ change the hold state of another, it SHOULD attempt to revert
+ all streams to their previous hold states.
+
+ The following state transitions SHOULD be used, where
+ appropriate:
+
+
+ Successful hold:
+ (Unheld, any reason) → (Pending_Hold, Requested) →
+ (Held, Requested)
+
+ Successful unhold:
+ (Held, any reason) → (Pending_Unhold, Requested) →
+ (Unheld, Requested)
+
+ Attempting to unhold fails at the first attempt to acquire a
+ resource:
+ (Held, any reason) → (Pending_Unhold, Requested) →
+ (Held, Resource_Not_Available)
+
+ Attempting to unhold acquires one resource, but fails to acquire
+ a second, and takes time to release the first:
+ (Held, any reason) → (Pending_Unhold, Requested) →
+ (Pending_Hold, Resource_Not_Available) →
+ (Held, Resource_Not_Available)
+
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Hold', signature='uu')
+ def HoldStateChanged(self, HoldState, Reason):
+ """
+ Emitted to indicate that the hold state has changed for this channel.
+ This may occur as a consequence of you requesting a change with
+ RequestHold, or the state changing as a
+ result of a request from
+ another process.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright © 2005-2009 Collabora Limited
+ Copyright © 2005-2009 Nokia Corporation
+ Copyright © 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceMediaSignalling(dbus.service.Interface):
+ """\
+ An interface for signalling a channel containing synchronised media
+ sessions which can contain an arbitrary number of streams. The
+ presence of this interface on a Channel indicates that the connection
+ manager will not carry out the actual streaming for this channel,
+ and that the client handling the channel is responsible for doing
+ so; in most cases we recommend doing this by using the
+ telepathy-farsight library.
+
+
+ Streaming audio and (particularly) video requires a high level of
+ integration with the UI, and having the connection manager act as
+ a proxy would be likely to introduce unacceptable latency. As a
+ result, audio/video streaming is offloaded into the client
+ where possible, as an exception to the general design of
+ Telepathy.
+
+
+ The negotiation interface is based on the API of the
+ Farsight library.
+ This, in turn, is based upon the IETF MMusic ICE drafts, where
+ connections are established by signalling potential connection
+ candidates to the peer until a usable connection is found, and
+ codecs are negotiated with an SDP-style offer and answer. However,
+ the principles should be applicable to other media streaming methods
+ and the API re-used without difficulty.
+
+ Note that the naming conventions used in the MediaStreamHandler
+ and MediaSessionHandler interfaces are rather confusing; methods
+ have signal-like names and signals have method-like names, due to
+ the API being based rather too closely on that of Farsight. This
+ is for historical reasons and will be fixed in a future release
+ of the Telepathy specification.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.MediaSignalling')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.MediaSignalling', in_signature='', out_signature='a(os)')
+ def GetSessionHandlers(self):
+ """
+ Returns all currently active session handlers on this channel
+ as a list of (session_handler_path, type).
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.MediaSignalling', signature='os')
+ def NewSessionHandler(self, Session_Handler, Session_Type):
+ """
+ Signal that a session handler object has been created. The client
+ should create a session object and create streams for the streams
+ within.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceMessages(dbus.service.Interface):
+ """\
+ This interface extends the Text interface to support more general
+ messages, including:
+
+
+ messages with attachments (like MIME multipart/mixed)
+ groups of alternatives (like MIME multipart/alternative)
+ delivery reports
+ any extra types of message we need in future
+
+
+ Although this specification supports formatted (rich-text)
+ messages with unformatted alternatives, implementations SHOULD NOT
+ attempt to send formatted messages until the Telepathy specification
+ has also been extended to cover capability discovery for message
+ formatting.
+
+
+ We intend to expose all rich-text messages as XHTML-IM, but on some
+ protocols, formatting is an extremely limited subset of that format
+ (e.g. there are protocols where foreground/background colours, font
+ and size can be set, but only for entire messages).
+ Until we can tell UIs what controls to offer to the user, it's
+ unfriendly to offer the user controls that may have no effect.
+
+
+ This interface also replaces Text.SendError,
+ adding support for
+ protocols where the message content is not echoed back to the sender on
+ failure, adding support for receiving positive acknowledgements,
+ and using the Messages queue for state-recovery
+ (ensuring that incoming delivery reports are not lost if there is not
+ currently a process handling them).
+
+ If this interface is present, clients that support it SHOULD
+ listen for the MessageSent and
+ MessageReceived signals, and
+ ignore the Sent,
+ SendError
+ and Received
+ signals on the Text interface (which are guaranteed to duplicate
+ signals from this interface).
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.Messages')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Messages', in_signature='aa{sv}u', out_signature='s')
+ def SendMessage(self, Message, Flags):
+ """
+ Submit a message to the server for sending.
+ If this method returns successfully, the message has been submitted
+ to the server and the MessageSent
+ signal is emitted. A corresponding
+ Sent
+ signal on the Text interface MUST also be emitted.
+
+ This method MUST return before the MessageSent signal is
+ emitted.
+
+
+ This means that the process sending the message is the first
+ to see the Sent_Message_Token, and can
+ relate the message to the corresponding
+ MessageSent signal by comparing
+ message tokens (if supported by the protocol).
+
+
+ If this method fails, message submission to the server has failed
+ and no signal on this interface (or the Text interface) is
+ emitted.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Messages', in_signature='uau', out_signature='a{uv}')
+ def GetPendingMessageContent(self, Message_ID, Parts):
+ """
+ Retrieve the content of one or more parts of a pending message.
+ Note that this function may take a considerable amount of time
+ to return if the part's 'needs-retrieval' flag is true; consider
+ extending the default D-Bus method call timeout. Additional API is
+ likely to be added in future, to stream large message parts.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Messages', signature='aa{sv}us')
+ def MessageSent(self, Content, Flags, Message_Token):
+ """
+ Signals that a message has been submitted for sending. This
+ MUST be emitted exactly once per emission of the Sent
+ signal on the
+ Text interface.
+
+
+ This signal allows a process that is not the caller of
+ SendMessage to log sent messages. The double signal-emission
+ provides compatibility with older clients. Clients supporting
+ Messages should listen for Messages.MessageSent only (if the
+ channel has the Messages interface) or Text.Sent only
+ (otherwise).
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Messages', signature='au')
+ def PendingMessagesRemoved(self, Message_IDs):
+ """
+ The messages with the given IDs have been removed from the
+ PendingMessages list. Clients SHOULD NOT
+ attempt to acknowledge those messages.
+
+
+ This completes change notification for the PendingMessages property
+ (previously, there was change notification when pending messages
+ were added, but not when they were removed).
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Messages', signature='aa{sv}')
+ def MessageReceived(self, Message):
+ """
+ Signals that a message has been received and added to the pending
+ messages queue. This MUST be emitted exactly once per emission of the
+ Received
+ signal on the Text interface.
+
+
+ The double signal-emission provides compatibility with older
+ clients. Clients supporting Messages should listen for
+ Messages.MessageReceived only (if the channel has the Messages
+ interface) or Text.Received only (otherwise).
+
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""
+Copyright © 2005-2009 Collabora Limited
+Copyright © 2005-2009 Nokia Corporation
+Copyright © 2006 INdT
+
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfacePassword(dbus.service.Interface):
+ """\
+ Interface for channels that may have a password set that users need
+ to provide before being able to join, or may be able to view or change
+ once they have joined the channel.
+
+ The GetPasswordFlags method and the
+ associated PasswordFlagsChanged
+ signal indicate whether the channel has a password, whether the user
+ must now provide it to join, and whether it can be viewed or changed
+ by the user.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.Password')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Password', in_signature='', out_signature='u')
+ def GetPasswordFlags(self):
+ """
+ Returns the bitwise-OR of the flags relevant to the password on this
+ channel. The user interface can use this to present information about
+ which operations are currently valid.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Interface.Password', in_signature='s', out_signature='b')
+ def ProvidePassword(self, Password):
+ """
+ Provide the password so that the channel can be joined. Must be
+ called with the correct password in order for channel joining to
+ proceed if the 'provide' password flag is set.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Password', signature='uu')
+ def PasswordFlagsChanged(self, Added, Removed):
+ """
+ Emitted when the flags as returned by
+ GetPasswordFlags are changed.
+ The user interface should be updated as appropriate.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Limited
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelInterfaceTube(dbus.service.Interface):
+ """\
+ A tube is a mechanism for arbitrary data transfer between
+ two or more IM users, used to allow applications on the users'
+ systems to communicate without having to establish network
+ connections themselves. Currently, two types of tube exist:
+ Channel.Type.DBusTube and
+ Channel.Type.StreamTube. This interface contains
+ the properties, signals and methods common to both types of tube;
+ you can only create channels of a specific tube type, not of this
+ type. A tube channel contains exactly one tube; if you need several
+ tubes, you have to create several tube channels.
+
+ Tube channels can be requested for Handle_Type
+ Contact (for 1-1 communication) or Room (to communicate with others in
+ the room simultaneously).
+
+ As an exception to the usual handling of capabilities, connection managers
+ for protocols with capability discovery (such as XMPP) SHOULD advertise the
+ capability representing each Tube type that they support
+ (Channel.Type.DBusTube and/or
+ Channel.Type.StreamTube)
+ even if no client has indicated via
+ UpdateCapabilities
+ that such a tube is supported. They SHOULD also allow clients to offer tubes with any
+ Service or
+ ServiceName
+ to any contact which supports the corresponding tube capability.
+
+
+ This lowers the barrier to entry for those writing new tube
+ applications, and preserves interoperability with older versions of
+ the Telepathy stack which did not support rich capabilities.
+
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Channel.Interface.Tube')
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Interface.Tube', signature='u')
+ def TubeChannelStateChanged(self, State):
+ """
+ Emitted when the state of the tube channel changes. Valid state
+ transitions are documented with Tube_Channel_State.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelRequest(dbus.service.Object):
+ """\
+ A channel request is an object in the ChannelDispatcher representing
+ an ongoing request for some channels to be created or found. There
+ can be any number of ChannelRequest objects at the same time.
+
+ Its well-known bus name is the same as that of the ChannelDispatcher,
+ "org.freedesktop.Telepathy.ChannelDispatcher".
+
+
+ See
+ ChannelDispatcher.CreateChannel
+ for rationale for ChannelRequest being a separate object.
+
+
+ A channel request can be cancelled by any client (not just the one
+ that requested it). This means that the ChannelDispatcher will
+ Close
+ the resulting channel, or refrain from requesting it at all, rather
+ than dispatching it to a handler.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.ChannelRequest', in_signature='', out_signature='')
+ def Proceed(self):
+ """
+ Proceed with the channel request.
+
+
+ The client that created this object calls this method
+ when it has connected signal handlers for
+ Succeeded and
+ Failed.
+
+
+ Clients other than the client which created the ChannelRequest
+ MUST NOT call this method.
+
+ This method SHOULD return immediately; on success, the request
+ might still fail, but this will be indicated asynchronously
+ by the Failed signal.
+
+ Proceed cannot fail, unless clients have got the life-cycle
+ of a ChannelRequest seriously wrong (e.g. a client calls this
+ method twice, or a client that did not create the ChannelRequest
+ calls this method). If it fails, clients SHOULD assume that the
+ whole ChannelRequest has become useless.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.ChannelRequest', in_signature='', out_signature='')
+ def Cancel(self):
+ """
+ Cancel the channel request. The precise effect depends on the
+ current progress of the request.
+
+ If the connection manager has not already been asked to create
+ a channel, then Failed is emitted
+ immediately, and the channel request is removed.
+
+ If the connection manager has already been asked to create a
+ channel but has not produced one yet (e.g. if Connection.Interface.Requests.CreateChannel
+ has been called, but has not yet returned), then the
+ ChannelDispatcher will remember that the request has been cancelled.
+ When the channel appears, it will be closed (if it was newly
+ created and can be closed), and will not be dispatched to a
+ handler.
+
+ If the connection manager has already returned a channel, but the
+ channel has not yet been dispatched to a handler
+ then the channel dispatcher will not dispatch that
+ channel to a handler. If the channel was newly created for this
+ request, the channel dispatcher will close it with Close;
+ otherwise, the channel dispatcher will ignore it. In either case,
+ Failed will be emitted when processing
+ has been completed.
+
+ If Failed is emitted in response to
+ this method, the error SHOULD be
+ org.freedesktop.Telepathy.Error.Cancelled.
+
+ If the channel has already been dispatched to a handler, then
+ it's too late to call this method, and the channel request will
+ no longer exist.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.ChannelRequest', signature='ss')
+ def Failed(self, Error, Message):
+ """
+ The channel request has failed. It is no longer present,
+ and further methods must not be called on it.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.ChannelRequest', signature='')
+ def Succeeded(self):
+ """
+ The channel request has succeeded. It is no longer present,
+ and further methods must not be called on it.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005, 2006 Collabora Limited
+ Copyright (C) 2005, 2006 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelTypeContactList(dbus.service.Interface):
+ """\
+ A channel type for representing a list of people on the server which is
+ not used for communication. This is intended for use with the interface
+ Channel.Interface.Group
+ for managing buddy lists and privacy lists
+ on the server. This channel type has no methods because all of the
+ functionality it represents is available via the group interface.
+
+ There are currently two types of contact list:
+ HANDLE_TYPE_LIST is a "magic" server-defined list, and
+ HANDLE_TYPE_GROUP is a user-defined contact group.
+
+ For server-defined lists like the subscribe list, singleton instances
+ of this channel type should be created by the connection manager at
+ connection time if the list exists on the server, or may be requested
+ by using the appropriate handle. These handles can be obtained using
+ RequestHandles
+ with a Handle_Type of HANDLE_TYPE_LIST and one of the
+ following identifiers:
+
+
+ subscribe - the group of contacts for whom you receive presence
+ publish - the group of contacts who may receive your presence
+ hide - a group of contacts who are on the publish list but are temporarily disallowed from receiving your presence
+ allow - a group of contacts who may send you messages
+ deny - a group of contacts who may not send you messages
+ stored - on protocols where the user's contacts are stored, this
+ contact list contains all stored contacts regardless of subscription
+ status.
+
+
+ A contact can be in several server-defined lists. All lists are optional
+ to implement. If RequestHandles
+ or RequestChannel
+ for a particular contact list raises an error, this indicates that the
+ connection manager makes no particular statement about the list's contents;
+ clients MUST NOT consider this to be fatal.
+
+ If a client wants to list all of a user's contacts, it is appropriate to
+ use the union of the subscribe, publish and stored lists, including the
+ local and remote pending members.
+
+ For example in XMPP, contacts who have the subscription type "none",
+ "from", "to" and "both" can be respectively in the lists:
+
+
+ "none": stored
+ "from": stored and publish
+ "to": stored and subscribe
+ "both": stored, publish and subscribe
+
+
+ These contact list channels may not be closed.
+
+ For user-defined contact groups, instances of this channel type should
+ be created by the connection manager at connection time for each group
+ that exists on the server. New, empty groups can be created by calling
+ RequestHandles
+ with a Handle_Type of HANDLE_TYPE_GROUP and with the
+ name set to the human-readable UTF-8 name of the group.
+
+ User-defined groups may be deleted by calling Close on the
+ channel, but only if
+ the group is already empty. Closing a channel to a non-empty group is
+ not allowed; its members must be set to the empty set first.
+
+ On some protocols (e.g. XMPP) empty groups are not represented on the
+ server, so disconnecting from the server and reconnecting might cause
+ empty groups to vanish.
+ """
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Limited
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelTypeDBusTube(dbus.service.Interface):
+ """\
+ A D-Bus tube is an ordered reliable transport, for transporting D-Bus
+ traffic.
+
+ For each D-Bus tube, the connection manager listens on a D-Bus
+ server address, as detailed in the D-Bus specification. On this
+ address, it emulates a bus upon which each tube participant appears
+ as an endpoint.
+
+ The objects and interfaces which are expected to exist on the
+ emulated bus depend on the well-known name; typically, either the
+ participant who initiated the tube is expected to export the same
+ objects/interfaces that would be exported by a service of that name
+ on a bus, or all participants are expected to export those
+ objects/interfaces.
+
+ In a multi-user context (Handle_Type_Room) the tube behaves
+ like the D-Bus bus daemon, so participants can send each other
+ private messages, or can send broadcast messages which are
+ received by everyone in the tube (including themselves).
+ Each participant has a D-Bus unique name; connection managers
+ MUST prevent participants from sending messages with the wrong
+ sender unique name, and SHOULD attempt to avoid participants
+ receiving messages not intended for them.
+
+ In a 1-1 context (Handle_Type_Contact) the tube behaves like
+ a peer-to-peer D-Bus connection - arbitrary D-Bus messages with
+ any sender and/or destination can be sent by each participant,
+ and each participant receives all messages sent by the other
+ participant.
+
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.DBusTube', in_signature='a{sv}u', out_signature='s')
+ def Offer(self, parameters, access_control):
+ """
+ Offers a D-Bus tube providing the service specified.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.DBusTube', in_signature='u', out_signature='s')
+ def Accept(self, access_control):
+ """
+ Accept a D-Bus tube that's in the "local pending" state. The
+ connection manager will attempt to open the tube. The tube remains in
+ the "local pending" state until the TubeChannelStateChanged
+ signal is emitted.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.DBusTube', signature='a{us}au')
+ def DBusNamesChanged(self, Added, Removed):
+ """
+ Emitted on a multi-user (i.e. Handle_Type_Room) D-Bus tube when a
+ participant opens or closes the tube. This provides change
+ notification for the DBusNames property.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""
+ Copyright © 2008-2009 Collabora Limited
+
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Library General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelTypeFileTransfer(dbus.service.Interface):
+ """\
+ A channel type for transferring files. The
+ transmission of data between contacts is achieved by reading from
+ or writing to a socket. The type of the socket (local Unix, IPv4,
+ etc.) is decided on when the file transfer is offered or accepted.
+
+ A socket approach is used to make the transfer less dependent on both
+ client and connection manager knowing the same protocols. As an example,
+ when browsing an SMB share in a file manager, one selects "Send file"
+ and chooses a contact. Instead of passing a URL which would then require
+ the connection manager to connect to the SMB share itself, the client
+ passes a stream from which the connection manager reads, requiring no
+ further connection to the share. It also allows connection managers to
+ be more restricted in their access to the system, allowing tighter
+ security policies with eg SELinux, or more flexible deployments which
+ cross user or system boundaries.
+
+ The Telepathy client should connect to the socket or address that
+ the connection manager has set up and provided back to the clients
+ through the two methods.
+
+ In order to send a file, one should request a FileTransfer
+ channel for a contact, including at least the mandatory properties
+ (Filename,
+ Size and ContentType).
+ Then, one should
+ call ProvideFile to configure the socket that
+ will be used to transfer the file.
+
+ In order to receive an incoming file transfer, one should call
+ AcceptFile and then wait until the state
+ changes to Open. When the receiver wants to resume a transfer, the Offset
+ argument should be should be set to a non-zero value when calling
+ AcceptFile.
+
+ Once the offset has been negotiated, the
+ InitialOffsetDefined signal
+ is emitted and the InitialOffset property
+ is defined. The InitialOffsetDefined
+ signal is emitted before channel becomes Open.
+ The receiver MUST check the value of
+ InitialOffset for a difference in offset
+ from the requested value in AcceptFile.
+
+ When the state changes to Open, Clients can start the transfer of the
+ file using the offset previously announced.
+
+
+ If something goes wrong with the transfer,
+ Channel.Close
+ should be called on the channel.
+
+ The File channel type may be requested for handles of type
+ HANDLE_TYPE_CONTACT. If the channel is requested for any other
+ handle type then the behaviour is undefined.
+
+ Connection managers SHOULD NOT advertise support for file transfer to
+ other contacts unless it has been indicated by a call to
+ UpdateCapabilities.
+
+
+ People would send us files, and it would always fail. That would be silly.
+
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.FileTransfer', in_signature='uuvt', out_signature='v')
+ def AcceptFile(self, Address_Type, Access_Control, Access_Control_Param, Offset):
+ """
+ Accept a file transfer that's in the Pending state. The file
+ transfer's state becomes Accepted after this method is called.
+ At this point the client can connect to the socket. CM MUST emit
+ InitialOffsetDefined and change
+ the state to Open before writing to the socket.
+ Then InitialOffset should be respected in case
+ its value differs from the offset that was specified as an argument
+ to AcceptFile.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.FileTransfer', in_signature='uuv', out_signature='v')
+ def ProvideFile(self, Address_Type, Access_Control, Access_Control_Param):
+ """
+ Provide the file for an outgoing file transfer which has been offered.
+ Opens a socket that the client can use to provide a file to the connection manager.
+ The channel MUST have been requested, and will change state
+ to Open when this method is called if its state was Accepted.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.FileTransfer', signature='uu')
+ def FileTransferStateChanged(self, State, Reason):
+ """
+ Emitted when the state of a file transfer changes.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.FileTransfer', signature='t')
+ def TransferredBytesChanged(self, Count):
+ """
+ Emitted when the number of transferred bytes changes. This will not be
+ signalled with every single byte change. Instead, the most frequent
+ this signal will be emitted is once a second. This should be
+ sufficient, and the TransferredBytes
+ property SHOULD NOT be polled.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.FileTransfer', signature='t')
+ def InitialOffsetDefined(self, InitialOffset):
+ """
+ Emitted when the value of the InitialOffset
+ property has been negotiated. This signal MUST be emitted before the channel
+ becomes Open and clients have to use this offset when transferring the
+ file.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright © 2005-2009 Collabora Limited
+ Copyright © 2005-2009 Nokia Corporation
+ Copyright © 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelTypeRoomList(dbus.service.Interface):
+ """\
+ A channel type for listing named channels available on the server. Once the
+ ListRooms method is called, it emits signals for rooms present on the
+ server, until you Close this
+ channel. In some cases, it may not be possible
+ to stop the deluge of information from the server. This channel should be
+ closed when the room information is no longer being displayed, so that the
+ room handles can be freed.
+
+ This channel type may be implemented as a singleton on some protocols, so
+ clients should be prepared for the eventuality that they are given a
+ channel that is already in the middle of listing channels. The
+ ListingRooms signal, or
+ GetListingRooms method, can be used to check
+ this.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.RoomList', in_signature='', out_signature='b')
+ def GetListingRooms(self):
+ """
+ Check to see if there is already a room list request in progress
+ on this channel.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.RoomList', in_signature='', out_signature='')
+ def ListRooms(self):
+ """
+ Request the list of rooms from the server. The
+ ListingRooms (True) signal should be
+ emitted when this request is being processed,
+ GotRooms when any room information is
+ received, and ListingRooms (False) when
+ the request is complete.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.RoomList', in_signature='', out_signature='')
+ def StopListing(self):
+ """
+ Stop the room listing if it's in progress, but don't close the channel.
+ The ListingRooms (False) signal should
+ be emitted when the listing stops.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.RoomList', signature='a(usa{sv})')
+ def GotRooms(self, Rooms):
+ """
+ Emitted when information about rooms on the server becomes available.
+ The array contains the room handle (as can be passed to the
+ RequestChannel
+ method with HANDLE_TYPE_ROOM), the channel
+ type, and a dictionary containing further information about the
+ room as available. The following well-known keys and types are
+ recommended for use where appropriate:
+
+
+ handle-name (s)
+ The identifier of the room (as would be returned by
+ InspectHandles)
+
+ name (s)
+ The human-readable name of the room if different from the handle
+
+ description (s)
+ A description of the room's overall purpose
+
+ subject (s)
+ The current subject of conversation in the room
+
+ members (u)
+ The number of members in the room
+
+ password (b)
+ True if the room requires a password to enter
+
+ invite-only (b)
+ True if you cannot join the room, but must be invited
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.RoomList', signature='b')
+ def ListingRooms(self, Listing):
+ """
+ Emitted to indicate whether or not room listing request is currently
+ in progress.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Limited
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelTypeStreamTube(dbus.service.Interface):
+ """\
+ A stream tube is a transport for ordered, reliable data transfer,
+ similar to SOCK_STREAM sockets.
+
+ When offering a stream tube, the initiating client creates a local
+ listening socket and offers it to the recipient client using the
+ Offer method. When a
+ recipient accepts a stream tube using the
+ Accept method, the
+ recipient's connection manager creates a new local listening socket.
+ Each time the recipient's client connects to this socket, the
+ initiator's connection manager proxies this connection to the
+ originally offered socket.
+
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.StreamTube', in_signature='uvua{sv}', out_signature='')
+ def Offer(self, address_type, address, access_control, parameters):
+ """
+ Offer a stream tube exporting the local socket specified.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.StreamTube', in_signature='uuv', out_signature='v')
+ def Accept(self, address_type, access_control, access_control_param):
+ """
+ Accept a stream tube that's in the "local pending" state. The
+ connection manager will attempt to open the tube. The tube remains in
+ the "local pending" state until the TubeChannelStateChanged
+ signal is emitted.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.StreamTube', signature='uvu')
+ def NewRemoteConnection(self, Handle, Connection_Param, Connection_ID):
+ """
+ Emitted each time a participant opens a new connection to its
+ socket.
+
+ This signal is only fired on the offering side.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.StreamTube', signature='u')
+ def NewLocalConnection(self, Connection_ID):
+ """
+ Emitted when the tube application connects to the CM's socket.
+
+ This signal is only fired on the accepting side.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.StreamTube', signature='uss')
+ def ConnectionClosed(self, Connection_ID, Error, Message):
+ """
+ Emitted when a connection has been closed.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright © 2005-2009 Collabora Limited
+ Copyright © 2005-2009 Nokia Corporation
+ Copyright © 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelTypeStreamedMedia(dbus.service.Interface):
+ """\
+ A channel that can send and receive streamed media such as audio or video.
+ Provides a number of methods for listing and requesting new streams, and
+ signals to indicate when streams have been added, removed and changed
+ status.
+
+ To make a media call to a contact, clients should call CreateChannel
+ with ChannelType
+ = StreamedMedia,
+ TargetHandleType
+ = Contact, and one of TargetHandle
+ or TargetID
+ (which should yield a channel with the local user in Members,
+ and the remote contact as TargetHandle
+ but not in any group members list), then call
+ RequestStreams to initiate the call (at
+ which point the contact should appear in the channel's RemotePendingMembers).
+
+ In the past, several other patterns have been used to place outgoing
+ calls; see
+ 'Requesting StreamedMedia Channels' on the Telepathy wiki
+ for the details.
+
+ Incoming calls should be signalled as TargetHandleType
+ = Contact, TargetHandle
+ set to the remote contact, with the local user in LocalPendingMembers;
+ to accept the call, AddMembers
+ can be used to move the local user to the group's members.
+
+ When the local user accepts an incoming call, the connection manager
+ SHOULD change the direction of any streams with pending local send
+ to be sending, without altering whether those streams are
+ receiving.
+
+
+ This matches existing practice, and means that a client
+ can answer incoming calls and get an unmuted microphone/activated
+ webcam without having to take additional action to accept the
+ stream directions.
+
+ It does, however, introduce a race condition: a client believing
+ that it is accepting an audio-only call by calling AddMembers
+ can inadvertantly accept an audio + video call (and hence activate
+ sending from a webcam without the user's permission) if a video
+ stream is added just before AddMembers is processed. This race
+ should be removed when this specification is revised.
+
+
+ In general this should be used in conjunction with the MediaSignalling
+ interface to exchange connection candidates and codec choices with
+ whichever component is responsible for the streams. However, in certain
+ applications where no candidate exchange is necessary (eg the streams are
+ handled by specialised hardware which is controlled directly by the
+ connection manager), the signalling interface can be omitted and this
+ channel type used simply to control the streams.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', in_signature='', out_signature='a(uuuuuu)')
+ def ListStreams(self):
+ """
+ Returns an array of structs representing the streams currently active
+ within this channel. Each stream is identified by an unsigned integer
+ which is unique for each stream within the channel.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', in_signature='au', out_signature='')
+ def RemoveStreams(self, Streams):
+ """
+ Request that the given streams are removed. If all streams are
+ removed, the channel MAY close.
+
+ Clients SHOULD NOT attempt to terminate calls by removing all the
+ streams; instead, clients SHOULD terminate calls by removing the
+ Group.SelfHandle
+ from the channel, using either
+ RemoveMembers
+ or
+ RemoveMembersWithReason.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', in_signature='uu', out_signature='')
+ def RequestStreamDirection(self, Stream_ID, Stream_Direction):
+ """
+ Request a change in the direction of an existing stream. In particular,
+ this might be useful to stop sending media of a particular type,
+ or inform the peer that you are no longer using media that is being
+ sent to you.
+
+ Depending on the protocol, streams which are no longer sending in
+ either direction should be removed and a
+ StreamRemoved signal emitted.
+ Some direction changes can be enforced locally (for example,
+ BIDIRECTIONAL -> RECEIVE can be achieved by merely stopping sending),
+ others may not be possible on some protocols, and some need agreement
+ from the remote end. In this case, the MEDIA_STREAM_PENDING_REMOTE_SEND
+ flag will be set in the
+ StreamDirectionChanged signal, and the
+ signal
+ emitted again without the flag to indicate the resulting direction when
+ the remote end has accepted or rejected the change.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', in_signature='uau', out_signature='a(uuuuuu)')
+ def RequestStreams(self, Contact_Handle, Types):
+ """
+ Request that streams be established to exchange the given types of
+ media with the given member. In general this will try and establish a
+ bidirectional stream, but on some protocols it may not be possible to
+ indicate to the peer that you would like to receive media, so a
+ send-only stream will be created initially. In the cases where the
+ stream requires remote agreement (eg you wish to receive media from
+ them), the StreamDirectionChanged signal
+ will be emitted with the
+ MEDIA_STREAM_PENDING_REMOTE_SEND flag set, and the signal emitted again
+ with the flag cleared when the remote end has replied.
+
+ If streams of the requested types already exist, calling this
+ method results in the creation of additional streams. Accordingly,
+ clients wishing to have exactly one audio stream or exactly one
+ video stream SHOULD check for the current streams using
+ ListStreams before calling this
+ method.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', signature='uuu')
+ def StreamAdded(self, Stream_ID, Contact_Handle, Stream_Type):
+ """
+ Emitted when a new stream has been added to this channel.
+ Clients SHOULD assume that the stream's
+ Media_Stream_State is initially Disconnected.
+
+ If a connection manager needs to represent the addition of a stream
+ whose state is already Connecting or Connected, it MUST do this
+ by emitting StreamAdded, closely followed by
+ StreamStateChanged indicating a
+ change to the appropriate state.
+
+
+ Historically, it was not clear from the StreamAdded signal what
+ the state of the stream was. telepathy-spec 0.17.22
+ clarified this.
+
+
+ Similarly, clients SHOULD assume that the initial
+ Media_Stream_Direction of a newly added stream
+ is Receive, and that the initial
+ Media_Stream_Pending_Send is
+ Pending_Local_Send.
+
+ If a connection manager needs to represent the addition of a stream
+ whose direction or pending-send differs from those initial values,
+ it MUST do so by emitting StreamAdded, closely followed by
+ StreamDirectionChanged indicating a
+ change to the appropriate direction and pending-send state.
+
+
+ StreamAdded doesn't itself indicate the stream's direction; this
+ is unfortunate, but is preserved for compatibility.
+
+ This is the appropriate direction for streams added by a remote
+ contact on existing connection managers, and does not violate
+ user privacy by automatically sending audio or video (audio streams
+ start off muted, video streams start off not sending). For
+ streams added by the local user using the client receiving the
+ signal, the true direction can also be determined from the return
+ value of the RequestStreams
+ method.
+
+ Existing clients typically operate by maintaining a separate
+ idea of the directions that they would like the streams to have,
+ and enforcing these intended directions by calling
+ RequestStreamDirection whenever
+ needed.
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', signature='uuu')
+ def StreamDirectionChanged(self, Stream_ID, Stream_Direction, Pending_Flags):
+ """
+ Emitted when the direction or pending flags of a stream are
+ changed.
+
+ If the MEDIA_STREAM_PENDING_LOCAL_SEND flag is set, the remote user
+ has requested that we begin sending on this stream.
+ RequestStreamDirection
+ should be called to indicate whether or not this change is
+ acceptable.
+
+
+ This allows for a MSN-style user interface, "Fred has asked you
+ to enable your webcam. (Accept | Reject)", if desired.
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', signature='uus')
+ def StreamError(self, Stream_ID, Error_Code, Message):
+ """
+ Emitted when a stream encounters an error.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', signature='u')
+ def StreamRemoved(self, Stream_ID):
+ """
+ Emitted when a stream has been removed from this channel.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.StreamedMedia', signature='uu')
+ def StreamStateChanged(self, Stream_ID, Stream_State):
+ """
+ Emitted when a member's stream's state changes.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright © 2005-2009 Collabora Limited
+ Copyright © 2005-2009 Nokia Corporation
+ Copyright © 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelTypeText(dbus.service.Interface):
+ """\
+ A channel type for sending and receiving messages in plain text,
+ with no formatting. In future specifications, channels for sending
+ and receiving messages that can be reduced to plain text (i.e.
+ formatted text) should also have this type.
+
+ When a message is received, an identifier is assigned and a
+ Received signal emitted, and the message
+ placed in a pending queue which can be inspected with
+ ListPendingMessages. A client which has
+ handled the message by showing it to the user (or equivalent) should
+ acknowledge the receipt using the
+ AcknowledgePendingMessages method,
+ and the message will then be removed from the pending queue. Numeric
+ identifiers for received messages may be reused over the lifetime of
+ the channel.
+
+ Each message has an associated 'type' value, which should be one
+ of the values allowed by
+ Channel_Text_Message_Type.
+
+ Each message also has a flags value, which is a bitwise OR of the
+ flags given in Channel_Text_Message_Flags.
+
+ Sending messages can be requested using the
+ Send method, which will return
+ successfully and emit the Sent signal
+ when the message has been delivered to the server, or return an error
+ with no signal emission if there is a failure. If a message is sent but
+ delivery of the message later fails, this is indicated with the
+ SendError signal.
+
+ On protocols where additional contacts cannot be invited into
+ a one-to-one chat, or where a one-to-one chat is just a series of
+ individual personal messages rather than being represented by some
+ object on the server (i.e. most protocols), one-to-one chats should be
+ represented by a Text channel with Handle_Type
+ CONTACT.
+
+ Named chat rooms whose identity can be saved and used again later
+ (IRC channels, Jabber MUCs) are expected to be represented by Text
+ channels with Handle_Type ROOM and the Group
+ interface; they should usually also have the Properties interface.
+
+ Unnamed, transient chat rooms defined only by their members (e.g. on
+ MSN) are expected to be represented by Text channels with handle type
+ 0, handle 0, the Group
+ interface, and optionally the Properties interface.
+
+ On protocols where a conversation with a user is actually just
+ a nameless chat room starting with exactly two members, to which
+ more members can be invited, calling
+ RequestChannel
+ with type Text
+ and handle type CONTACT should continue to succeed, but may return
+ a channel with handle type 0, handle 0, the group interface,
+ and the local and remote contacts in its members.
+
+ If a channel of type Text is closed while it has pending messages,
+ the connection manager MUST allow this, but SHOULD open a new,
+ identical channel to deliver those messages, signalling it as a new
+ channel with the
+ NewChannel
+ signal (with the suppress_handler parameter set to FALSE).
+
+ If messages were sent on the old channel but the
+ Sentsignal has not yet been emitted
+ for those messages, the new channel SHOULD emit Sent for those
+ messages when appropriate - it behaves like a continuation of the
+ old channel.
+
+
+ In effect, this turns this situation, in which a client
+ is likely to lose messages:
+
+
+ UI window is closed
+ message arrives
+ text channel emits Received
+ UI calls Close on text channel before it has seen the
+ Received signal
+ text channel emits Closed and closes
+
+
+ into something nearly equivalent to this situation, which is
+ fine:
+
+
+ UI window is closed
+ UI calls Close on text channel
+ text channel emits Closed and closes
+ message arrives
+ new text channel is created, connection emits NewChannel
+ (the same or a different) UI handles it
+
+
+ suppress_handler must be set to FALSE so the replacement channel
+ will be handled by something.
+
+
+ As a result, Text channels SHOULD implement Channel.Interface.Destroyable.
+
+
+ This "respawning" behaviour becomes problematic if there is no
+ suitable handler for Text channels, or if a particular message
+ repeatedly crashes the Text channel handler; a channel dispatcher
+ can't just Close() the channel in these situations, because
+ it will come back.
+
+ In these situations, the channel dispatcher needs a last-resort
+ way to destroy the channel and stop it respawning. It could either
+ acknowledge the messages itself, or use the Destroyable interface;
+ the Destroyable interface has the advantage that it's not
+ channel-type-dependent, so the channel dispatcher only has to
+ understand one extra interface, however many channel types
+ eventually need a distinction between Close and Destroy.
+
+
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Text', in_signature='au', out_signature='')
+ def AcknowledgePendingMessages(self, IDs):
+ """
+ Inform the channel that you have handled messages by displaying them to
+ the user (or equivalent), so they can be removed from the pending queue.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Text', in_signature='', out_signature='au')
+ def GetMessageTypes(self):
+ """
+ Return an array indicating which types of message may be sent on this
+ channel.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Text', in_signature='b', out_signature='a(uuuuus)')
+ def ListPendingMessages(self, Clear):
+ """
+ List the messages currently in the pending queue, and optionally
+ remove then all.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Text', in_signature='us', out_signature='')
+ def Send(self, Type, Text):
+ """
+ Request that a message be sent on this channel. When the message has
+ been submitted for delivery, this method will return and the
+ Sent signal will be emitted. If the
+ message cannot be submitted for delivery, the method returns an error
+ and no signal is emitted.
+
+ This method SHOULD return before the Sent signal is
+ emitted.
+
+
+ When a Text channel implements the Messages
+ interface, that "SHOULD" becomes a "MUST".
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Text', signature='')
+ def LostMessage(self):
+ """
+ This signal is emitted to indicate that an incoming message was
+ not able to be stored and forwarded by the connection manager
+ due to lack of memory.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Text', signature='uuuuus')
+ def Received(self, ID, Timestamp, Sender, Type, Flags, Text):
+ """
+ Signals that a message with the given id, timestamp, sender, type
+ and text has been received on this channel. Applications that catch
+ this signal and reliably inform the user of the message should
+ acknowledge that they have dealt with the message with the
+ AcknowledgePendingMessages method.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Text', signature='uuus')
+ def SendError(self, Error, Timestamp, Type, Text):
+ """
+ Signals that an outgoing message has failed to send. The error
+ will be one of the values from ChannelTextSendError.
+
+ This signal should only be emitted for messages for which
+ Sent has already been emitted and
+ Send has already returned success.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Text', signature='uus')
+ def Sent(self, Timestamp, Type, Text):
+ """
+ Signals that a message has been submitted for sending.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""
+ Copyright © 2007-2009 Collabora Limited
+
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ChannelTypeTubes(dbus.service.Interface):
+ """\
+ A "tube" is a mechanism for arbitrary data transfer. Two types of
+ data transfer are currently specified: D-Bus messages, and streams of
+ bytes. Each tube has a service name, which is a string specifying the
+ kind of communication that takes place over it, and a dictionary of
+ arbitrary parameters. Tube parameters are commonly used for bootstrap
+ information such as usernames and passwords. Each tube is identified
+ by a locally unique identifier.
+
+ The Tubes channel type may be requested for handles of type
+ HANDLE_TYPE_CONTACT and HANDLE_TYPE_ROOM.
+
+ Stream tubes specify listening addresses using pairs of parameters
+ with signature 'u', 'v', where the integer 'u' is a member of
+ Socket_Address_Type and the v is dependent on the type of address.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='', out_signature='a{uau}')
+ def GetAvailableStreamTubeTypes(self):
+ """List the available address types and access-control types
+ for stream tubes.
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='', out_signature='au')
+ def GetAvailableTubeTypes(self):
+ """
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='', out_signature='a(uuusa{sv}u)')
+ def ListTubes(self):
+ """
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='sa{sv}', out_signature='u')
+ def OfferDBusTube(self, Service, Parameters):
+ """
+ Offers a D-Bus tube providing the service specified.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='sa{sv}uvuv', out_signature='u')
+ def OfferStreamTube(self, Service, Parameters, Address_Type, Address, Access_Control, Access_Control_Param):
+ """
+ Offer a stream tube exporting the local socket specified.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='u', out_signature='s')
+ def AcceptDBusTube(self, ID):
+ """
+ Accept a D-Bus tube that's in the "local pending" state. The
+ connection manager will attempt to open the tube. The tube remains in
+ the "local pending" state until the TubeStateChanged signal is
+ emitted.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='uuuv', out_signature='v')
+ def AcceptStreamTube(self, ID, Address_Type, Access_Control, Access_Control_Param):
+ """
+ Accept a stream tube that's in the "local pending" state. The
+ connection manager will attempt to open the tube. The tube remains in
+ the "local pending" state until the TubeStateChanged signal is
+ emitted.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='u', out_signature='')
+ def CloseTube(self, ID):
+ """
+ Close a tube.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='u', out_signature='s')
+ def GetDBusTubeAddress(self, ID):
+ """
+ For a D-Bus tube, return a string describing the address of the
+ private bus.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='u', out_signature='a(us)')
+ def GetDBusNames(self, ID):
+ """
+ For a multi-user (i.e. Handle_Type_Room) D-Bus tube, obtain a mapping
+ between contact handles and their unique bus names on this tube.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Channel.Type.Tubes', in_signature='u', out_signature='uv')
+ def GetStreamTubeSocketAddress(self, ID):
+ """
+ For a stream tube, obtain the address of the socket used to
+ communicate over this tube.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Tubes', signature='uuusa{sv}u')
+ def NewTube(self, ID, Initiator, Type, Service, Parameters, State):
+ """
+ Emitted when a tube is created.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Tubes', signature='uu')
+ def TubeStateChanged(self, ID, State):
+ """
+ Emitted when the state of a tube changes.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Tubes', signature='u')
+ def TubeClosed(self, ID):
+ """
+ Emitted when a tube has been closed. The ID of a closed tube is no
+ longer valid. The ID may later be reused for a new tube.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Tubes', signature='ua(us)au')
+ def DBusNamesChanged(self, ID, Added, Removed):
+ """
+ Emitted on a multi-user (i.e. Handle_Type_Room) D-Bus tube when a
+ participant opens or closes the tube.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Channel.Type.Tubes', signature='uu')
+ def StreamTubeNewConnection(self, ID, Handle):
+ """
+ Emitted on a stream tube when a participant opens a new connection
+ to its socket.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class Client(dbus.service.Object):
+ """\
+ Telepathy clients use connection managers, the channel dispatcher
+ and optionally the account manager to provide useful
+ functionality.
+
+ User interface processes are the obvious example of Telepathy
+ clients, but they can provide other functionality, such as
+ address-book synchronization.
+
+ Every running or activatable process with a well-known
+ name of the form org.freedesktop.Telepathy.Client.clientname
+ should be probed by the channel dispatcher to discover its
+ capabilities. Each client is either an observer, an
+ approver, a channel handler, or some combination
+ of these.
+
+
+ Activatable services (those with a D-Bus .service
+ file) must be supported so that we can run clients
+ in response to channel creation.
+
+ Non-activatable services (those that do not register a D-Bus
+ .service file for their well-known name, but do
+ request it at runtime) must be supported so that we can have
+ programs that process channels, but only if they are already
+ running - for instance, a full-screen media centre
+ application might do this.
+
+
+ The client name, clientname, MUST be a non-empty string of
+ ASCII digits, letters, dots and/or underscores, starting with a
+ letter, and without sets of two consecutive dots or a dot
+ followed by a digit. For non-activatable services, it MAY contain a
+ part that is generated per instance at runtime.
+
+
+ If each of a client Foo's instances should be able to manipulate
+ channels separately, the instance with unique name
+ :1.25 might request a well-known name like
+ org.freedesktop.Telepathy.Client.Foo._1._25.
+
+ (Note that well-known bus-name components may not start with a
+ digit, so o.f.T.Client.Foo.1.25 would not be acceptable.)
+
+
+ Each Client MUST export an object whose object path may be
+ determined by replacing '.' with '/' in the well-known name and
+ prepending '/'. This object represents its API as a Telepathy
+ client; the channel dispatcher will call its methods and read
+ its properties when appropriate.
+
+ As an optimization, activatable clients SHOULD install a file
+ $XDG_DATA_DIRS/telepathy/clients/clientname.client
+ containing a cached version of its immutable properties,
+ so that for most clients, the channel dispatcher can
+ just read a file to discover capabilities, instead of
+ having to service-activate the client immediately in order to fetch
+ its read-only properties. However, the D-Bus API is canonical, and
+ the channel dispatcher MUST support clients without such a file.
+
+ Non-activatable clients MAY install a .client file,
+ but there's not much point in them doing so.
+
+ The .client files MUST contain UTF-8 text with the same syntax
+ as
+ Desktop
+ Entry files (although the allowed groups, keys and values differ).
+ Every .client file MUST contain a group whose name is
+ the name of this interface.
+
+ The groups, keys and values in the .client file are
+ defined by individual interfaces. Each interface that can usefully
+ cache information in the .client file SHOULD correspond
+ to a group with the same name.
+ """
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ClientApprover(dbus.service.Object):
+ """\
+ Approvers are clients that notify the user that new channels have
+ been created by a contact, and allow the user to accept or reject
+ those channels. The new channels are represented by a ChannelDispatchOperation
+ object, which is passed to the
+ AddDispatchOperation method.
+
+
+ For instance, Empathy's tray icon, or the answer/reject window
+ seen when a Maemo device receives a VoIP call, should be
+ Approvers.
+
+
+ Approvers can also select which channel handler will be used for the
+ channel, for instance by offering the user a list of possible
+ handlers rather than just an accept/reject choice.
+ However, the Channel Dispatcher must be able to prioritize
+ possible handlers on its own using some reasonable heuristic,
+ probably based on user configuration.
+
+ It is possible (and useful) to have an approver and
+ a channel handler in the same process; this is particularly useful
+ if a channel handler wants to claim responsibility for particular
+ channels itself.
+
+ All approvers are notified simultaneously. For instance, in a
+ desktop system, there might be one approver that displays a
+ notification-area icon, one that is part of a contact list
+ window and highlights contacts there, and one that is part
+ of a full-screen media player.
+
+ Any approver can approve the handling of a channel dispatch operation
+ with a particular channel handler by calling the HandleWith
+ method. Approvers can also attempt to Claim
+ channels; if this succeeds, the approver may handle the channels
+ itself (if it is also a Handler), or close the channels in order to
+ reject them.
+
+ At the D-Bus level, there is no "reject" operation: approvers wishing
+ to reject channels SHOULD call the Claim method, then (if it succeeds)
+ close the channels in any way they see fit.
+
+ The first approver to reply gets its decision acted on; any other
+ approvers that reply at approximately the same time will get a D-Bus
+ error, indicating that the channel has already been dealt with.
+
+ Approvers should usually prompt the user and ask for
+ confirmation, rather than dispatching the channel to a handler
+ straight away.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Client.Approver', in_signature='a(oa{sv})oa{sv}', out_signature='')
+ def AddDispatchOperation(self, Channels, DispatchOperation, Properties):
+ """
+ Called by the channel dispatcher when a ChannelDispatchOperation
+ in which the approver has registered an interest is created,
+ or when the approver starts up while such channel dispatch
+ operations already exist.
+
+ The channel dispatcher SHOULD call this method on all approvers
+ at the same time. If an approver returns an error from this method,
+ the approver is assumed to be faulty.
+
+ If no approvers return from this method
+ successfully (including situations where there are no matching
+ approvers at all), the channel dispatcher SHOULD consider this
+ to be an error, and recover by dispatching the channel to the
+ most preferred handler.
+
+
+ Processes that aren't approvers (or don't at least ensure that there
+ is some approver) probably shouldn't be making connections
+ anyway, so there should always be at least one approver running.
+
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ClientHandler(dbus.service.Object):
+ """\
+ Handlers are the user interface for a channel. They turn an abstract
+ Telepathy channel into something the user wants to see, like a text
+ message stream or an audio and/or video call.
+
+ For its entire lifetime, each channel on a connection known to the
+ channel dispatcher is either being processed by the channel dispatcher,
+ or being handled by precisely one Handler.
+
+ Because each channel is only handled by one Handler, handlers may
+ perform actions that only make sense to do once, such as acknowledging
+ Text
+ messages, doing the actual streaming for StreamedMedia
+ channels with the MediaSignalling
+ interface, or transferring the file in FileTransfer
+ channels.
+
+ When a new incoming channel (one with
+ Requested
+ = FALSE) is offered to
+ Approvers
+ by the channel dispatcher, it also offers the Approvers a list of all
+ the running or activatable handlers whose
+ HandlerChannelFilter property
+ (possibly as cached in the .client file) indicates that they
+ are able to handle the channel. The Approvers can choose one of
+ those channel handlers to handle the channel.
+
+ When a new outgoing channel (one with
+ Requested
+ = TRUE) appears, the channel dispatcher passes it to an appropriate
+ channel handler automatically.
+
+
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Client.Handler', in_signature='ooa(oa{sv})aota{sv}', out_signature='')
+ def HandleChannels(self, Account, Connection, Channels, Requests_Satisfied, User_Action_Time, Handler_Info):
+ """
+ Called by the channel dispatcher when this client should handle these
+ channels, or when this client should present channels that it is already
+ handling to the user (e.g. bring them into the foreground).
+
+
+ Clients are expected to know what channels they're already handling,
+ and which channel object path corresponds to which window or tab.
+ This can easily be done using a hash table keyed by channels' object
+ paths.
+
+
+ This method can raise any D-Bus error. If it does, the
+ handler is assumed to have failed or crashed, and the channel
+ dispatcher MUST recover in an implementation-specific way; it MAY
+ attempt to dispatch the channels to another handler, or close the
+ channels.
+
+ If closing the channels, it is RECOMMENDED that the channel
+ dispatcher attempts to close the channels using
+ Channel.Close,
+ but resorts to calling
+ Channel.Interface.Destroyable.Destroy
+ (if available) or ignoring the channel (if not) if the same handler
+ repeatedly fails to handle channels.
+
+ After HandleChannels returns successfully, the client process is
+ considered to be responsible for the channel until it its unique
+ name disappears from the bus.
+
+
+ If a process has multiple Client bus names - some temporary and
+ some long-lived - and drops one of the temporary bus names in order
+ to reduce the set of channels that it will handle, any channels
+ that it is already handling should remain unaffected.
+
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ClientInterfaceRequests(dbus.service.Interface):
+ """\
+ This interface can be implemented by a Handler to be notified about
+ requests for channels that it is likely to be asked to handle.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Client.Interface.Requests')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Client.Interface.Requests', in_signature='oa{sv}', out_signature='')
+ def AddRequest(self, Request, Properties):
+ """
+ Called by the ChannelDispatcher to indicate that channels have been
+ requested, and that if the request is successful, they will probably
+ be handled by this Handler. The ChannelDispatcher SHOULD only
+ call this method on one handler per request.
+
+
+ This allows the UI to start preparing to handle the channels
+ in advance (e.g. render a window with an "in progress" message),
+ improving perceived responsiveness.
+
+ The use of "probably" is because you can't necessarily tell from
+ a channel request which handler will handle particular channels.
+ A reasonable heuristic would be to match the request against the
+ HandlerChannelFilter,
+ and respect the preferred handler (if any).
+
+
+ If the request succeeds and is given to the expected Handler,
+ the Requests_Satisfied parameter to
+ HandleChannels
+ can be used to match the channel to a previous AddRequest call.
+
+
+ This lets the UI direct the channels to the window that it
+ already opened.
+
+
+ If the request fails, the expected handler is notified by the
+ channel dispatcher calling its
+ RemoveRequest method.
+
+
+ This lets the UI close the window or display the error.
+
+
+ The channel dispatcher SHOULD remember which handler was notified,
+ and if the channel request succeeds, it SHOULD dispatch the channels
+ to the expected handler, unless the channels do not match that
+ handler's HandlerChannelFilter.
+ If the channels are not dispatched to the expected handler, the
+ handler that was expected is notified by the channel dispatcher
+ calling its RemoveRequest method
+ with the NotYours error.
+
+
+ Expected handling is for the UI to close the window it
+ previously opened.
+
+
+ Handlers SHOULD NOT return an error from this method; errors
+ returned from this method SHOULD NOT alter the channel dispatcher's
+ behaviour.
+
+
+ Calls to this method are merely a notification.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Client.Interface.Requests', in_signature='oss', out_signature='')
+ def RemoveRequest(self, Request, Error, Message):
+ """
+ Called by the ChannelDispatcher to indicate that a request
+ previously passed to AddRequest
+ has failed and should be disregarded.
+
+ Handlers SHOULD NOT return an error from this method; errors
+ returned from this method SHOULD NOT alter the channel dispatcher's
+ behaviour.
+
+
+ Calls to this method are merely a notification.
+
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2008-2009 Collabora Ltd.
+Copyright © 2008-2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ClientObserver(dbus.service.Object):
+ """\
+ Observers monitor the creation of new channels. This
+ functionality can be used for things like message logging.
+ All observers are notified simultaneously.
+
+ Observers SHOULD NOT modify the state of a channel except
+ via user interaction.
+
+
+ We want Observer UIs for file transfer channels (a progress
+ bar for the transfer) to be able to have a Cancel button.
+
+
+ Observers MUST NOT carry out actions that exactly one process
+ must take responsibility for (e.g. acknowledging Text
+ messages, or carrying out the actual transfer in a file transfer
+ channel).
+
+
+ Since arbitrarily many observers can be activated for
+ each channel, it would not make sense for observers to do things
+ that can only be done by one process (acknowledging
+ Text
+ messages, carrying out streaming for
+ StreamedMedia
+ channels, doing the actual data transfer for file transfers,
+ setting up the out-of-band connection for Tubes). The
+ Handler
+ is responsible for such tasks.
+
+ Handlers MAY, of course, delegate responsibility for these
+ tasks to other processes (including those run as observers),
+ but this MUST be done explicitly via a request from the Handler
+ to the Observer.
+
+
+ Whenever a collection of new channels is signalled, the channel
+ dispatcher will notify all running or activatable observers whose
+ ObserverChannelFilter property
+ (possibly as cached in the .client file) indicates that they are
+ interested in some of the channels.
+
+ Observers are activated for all channels in which they have
+ registered an interest - incoming, outgoing or automatically created -
+ although of course the ObserverChannelFilter property can be set
+ to filter on the
+ Requested
+ property.
+
+ Because it might take time for an observer to become ready (for
+ instance, a Text logger needs to wait until pending messages have been
+ downloaded), the channel dispatcher must wait (up to some timeout) for
+ all observers to return from
+ ObserveChannels before letting anything
+ destructive happen. Destructive things (e.g. acknowledging messages)
+ are defined to be done by handlers, therefore HandleWith and Claim
+ aren't allowed to succeed until all observers are ready.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Client.Observer', in_signature='ooa(oa{sv})oaoa{sv}', out_signature='')
+ def ObserveChannels(self, Account, Connection, Channels, Dispatch_Operation, Requests_Satisfied, Observer_Info):
+ """
+ Called by the channel dispatcher when channels in which the
+ observer has registered an interest are announced in a NewChannels
+ signal.
+
+ If the same NewChannels signal announces some channels that match
+ the filter, and some that do not, then only a subset of the channels
+ (those that do match the filter) are passed to this method.
+
+ If the channel dispatcher will split up the channels from a single
+ NewChannels signal and dispatch them separately (for instance
+ because no installed Handler can handle all of them), it will call
+ ObserveChannels several times.
+
+ The observer MUST NOT return from this method call until it is ready
+ for a handler for the channel to run (which may change the channel's
+ state).
+
+
+ The channel dispatcher must wait for observers to start up,
+ to avoid the following race: text channel logger (observer) gets
+ ObserveChannels, text channel handler gets
+ HandleChannels
+ channel handler starts up faster and acknowledges messages,
+ logger never sees those messages.
+
+
+ The channel dispatcher SHOULD NOT change its behaviour based on
+ whether this method succeeds or fails: there are no defined D-Bus
+ errors for this method, and if it fails, this only indicates that
+ an Observer is somehow broken.
+
+
+ The expected error response in the channel dispatcher is to
+ log a warning, and otherwise continue as though this method
+ had succeeded.
+
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2005-2009 Collabora Limited
+Copyright (C) 2005-2009 Nokia Corporation
+Copyright (C) 2006 INdT
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+USA.
+
+"""
+
+import dbus.service
+
+
+class Connection(dbus.service.Object):
+ """\
+ This models a connection to a single user account on a communication
+ service. Its basic capability is to provide the facility to request and
+ receive channels of differing types (such as text channels or streaming
+ media channels) which are used to carry out further communication.
+
+ In order to allow Connection objects to be discovered by new clients,
+ the object path and well-known bus name MUST be of the form
+ /org/freedesktop/Telepathy/Connection/cmname/proto/account
+ and
+ org.freedesktop.Telepathy.Connection.cmname.proto.account
+ where:
+
+
+ cmname is the same
+ Connection_Manager_Name that appears
+ in the connection manager's object path and well-known bus name
+ proto is the Protocol name as seen in
+ ListProtocols,
+ but with "-" replaced with "_" to get a valid
+ object path/bus name
+ account is some non-empty sequence of ASCII letters,
+ digits and underscores not starting with a digit
+
+
+ account SHOULD be formed such that any valid distinct
+ connection instance on this protocol has a distinct name. This
+ might be formed by including the server name followed by the user
+ name (escaped via some suitable mechanism like telepathy-glib's
+ tp_escape_as_identifier() function to preserve uniqueness); on
+ protocols where connecting multiple times is permissable, a
+ per-connection identifier might be necessary to ensure
+ uniqueness.
+
+ Clients MAY parse the object path to determine the connection
+ manager name and the protocol, but MUST NOT attempt to parse the
+ account part. Connection managers MAY use any unique string
+ for this part.
+
+ As well as the methods and signatures below, arbitrary interfaces may be
+ provided by the Connection object to represent extra connection-wide
+ functionality, such as the Connection.Interface.SimplePresence for
+ receiving and
+ reporting presence information, and Connection.Interface.Aliasing for
+ connections where contacts may set and change an alias for themselves.
+ These interfaces can be discovered using the
+ GetInterfaces method.
+
+ Contacts, rooms, and server-stored lists (such as subscribed contacts,
+ block lists, or allow lists) on a service are all represented by
+ immutable handles, which are unsigned non-zero integers which are
+ valid only for the lifetime of the connection object, and are used
+ throughout the protocol where these entities are represented, allowing
+ simple testing of equality within clients.
+
+ Zero as a handle value is sometimes used as a "null" value to mean
+ the absence of a contact, room, etc.
+
+ Handles have per-type uniqueness, meaning that
+ every (handle type, handle number) tuple is guaranteed to be unique within
+ a connection and that a handle alone (without its type) is meaningless or
+ ambiguous. Connection manager implementations should reference count these
+ handles to determine if they are in use either by any active clients or any
+ open channels, and may deallocate them when this ceases to be true. Clients
+ may request handles of a given type and identifier with the
+ RequestHandles method, inspect the entity
+ identifier with the InspectHandles
+ method, keep handles from being released with
+ HoldHandles, and notify that they are no
+ longer storing handles with
+ ReleaseHandles.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='', out_signature='')
+ def Connect(self):
+ """
+ Request that the connection be established. This will be done
+ asynchronously and errors will be returned by emitting
+ StatusChanged signals.
+
+ Calling this method on a Connection that is already connecting
+ or connected is allowed, and has no effect.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='', out_signature='')
+ def Disconnect(self):
+ """
+ Request that the connection be closed. This closes the connection if
+ it's not already in DISCONNECTED state, and destroys the connection
+ object.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='', out_signature='as')
+ def GetInterfaces(self):
+ """
+ Get the optional interfaces supported by this connection.
+ Before the connection status changes to CONNECTED, the return
+ from this method may change at any time, but it is guaranteed that
+ interfaces will only be added, not removed. After the connection
+ status changes to CONNECTED, the return from this method cannot
+ change further.
+
+ There is no explicit change notification; reasonable behaviour
+ for a client would be to retrieve the interfaces list once
+ initially, and once more when it becomes CONNECTED.
+
+
+ In some connection managers, certain capabilities of a connection
+ are known to be implemented for all connections (e.g. support
+ for SimplePresence), and some interfaces (like SimplePresence) can
+ even be used before connecting. Other capabilities may
+ or may not exist, depending on server functionality; by the time
+ the connection goes CONNECTED, the connection manager is expected
+ to have evaluated the server's functionality and enabled any extra
+ interfaces for the remainder of the Connection's lifetime.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='', out_signature='s')
+ def GetProtocol(self):
+ """
+ Get the protocol this connection is using.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='', out_signature='u')
+ def GetSelfHandle(self):
+ """
+ Returns the value of the SelfHandle property. Change notification
+ is via the SelfHandleChanged signal.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='', out_signature='u')
+ def GetStatus(self):
+ """
+ Get the current status as defined in the
+ StatusChanged signal.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='uau', out_signature='')
+ def HoldHandles(self, Handle_Type, Handles):
+ """
+ Notify the connection manger that your client is holding a copy
+ of handles which may not be in use in any existing channel or
+ list, and were not obtained by using the
+ RequestHandles method. For
+ example, a handle observed in an emitted signal, or displayed
+ somewhere in the UI that is not associated with a channel. The
+ connection manager must not deallocate a handle where any clients
+ have used this method to indicate it is in use until the
+ ReleaseHandles
+ method is called, or the clients disappear from the bus.
+
+ Note that HoldHandles is idempotent - calling it multiple times
+ is equivalent to calling it once. If a handle is "referenced" by
+ several components which share a D-Bus unique name, the client
+ should perform reference counting internally, and only call
+ ReleaseHandles when none of the cooperating components need the
+ handle any longer.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='uau', out_signature='as')
+ def InspectHandles(self, Handle_Type, Handles):
+ """
+ Return a string representation for a number of handles of a given
+ type.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='', out_signature='a(osuu)')
+ def ListChannels(self):
+ """
+ List all the channels which currently exist on this connection.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='uau', out_signature='')
+ def ReleaseHandles(self, Handle_Type, Handles):
+ """
+ Explicitly notify the connection manager that your client is no
+ longer holding any references to the given handles, and that they
+ may be deallocated if they are not held by any other clients or
+ referenced by any existing channels. See HoldHandles for notes.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='suub', out_signature='o')
+ def RequestChannel(self, Type, Handle_Type, Handle, Suppress_Handler):
+ """
+ Request a channel satisfying the specified type and communicating
+ with the contact, room, list etc. indicated by the given
+ handle_type and handle. The handle_type and handle may both be
+ zero to request the creation of a new, empty channel, which may
+ or may not be possible, depending on the protocol and channel
+ type.
+
+ On success, the returned channel will always be of the requested
+ type (i.e. implement the requested channel-type interface).
+
+ If a new, empty channel is requested, on success the returned
+ channel will always be an "anonymous" channel for which the type
+ and handle are both zero.
+
+ If a channel to a contact, room etc. is requested, on success, the
+ returned channel may either be a new or existing channel to
+ the requested entity (i.e. its
+ TargetHandleType
+ and TargetHandle
+ properties are the
+ requested handle type and handle), or a newly created "anonymous"
+ channel associated with the requested handle in some
+ implementation-specific way.
+
+ For example, for a contact handle, the returned channel
+ might be "anonymous", but implement the groups interface and have
+ the requested contact already present among the members.
+
+ If the request cannot be satisfied, an error is raised and no
+ channel is created.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection', in_signature='uas', out_signature='au')
+ def RequestHandles(self, Handle_Type, Identifiers):
+ """
+ Request several handles from the connection manager which represent a
+ number of contacts, rooms or server-stored lists on the service. The
+ connection manager should record that these handles are in use by the
+ client who invokes this method, and must not deallocate the handles
+ until the client disconnects from the bus or calls the
+ ReleaseHandles
+ method. Where the identifier refers to an entity that already has a
+ handle in this connection manager, this handle should be returned
+ instead. The handle number 0 must not be returned by the connection
+ manager.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection', signature='u')
+ def SelfHandleChanged(self, Self_Handle):
+ """
+ Emitted whenever the SelfHandle property
+ changes. If the connection
+ is not yet in the CONNECTED state, this signal is not guaranteed
+ to be emitted.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection', signature='osuub')
+ def NewChannel(self, Object_Path, Channel_Type, Handle_Type, Handle, Suppress_Handler):
+ """
+ Emitted when a new Channel object is created, either through user
+ request or incoming information from the service.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection', signature='sa{sv}')
+ def ConnectionError(self, Error, Details):
+ """
+ Emitted when an error occurs that renders this connection unusable.
+
+
+ Whenever this signal is emitted, it MUST immediately be followed by
+ a StatusChanged signal with status
+ Connection_Status_Disconnected and an appropriate reason
+ code.
+
+ Connection managers SHOULD emit this signal on disconnection, but
+ need not do so. Clients MUST support connection managers that emit
+ StatusChanged(Disconnected, ...) without first emitting
+ ConnectionError.
+
+
+ This signal provides additional information about the reason
+ for disconnection. The reason for connection is always
+ straightforward - it was requested - so it does not need further
+ explanation. However, on errors, it can be useful to provide
+ additional information.
+
+ The Connection_Status_Reason is not given
+ here, since it will be signalled in
+ StatusChanged. A reasonable client
+ implementation would be to store the information given by this
+ signal until StatusChanged is received, at which point the
+ information given by this signal can be used to supplement the
+ StatusChanged signal.
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection', signature='uu')
+ def StatusChanged(self, Status, Reason):
+ """
+ Emitted when the status of the connection changes. All states and
+ reasons have numerical values, as defined in ConnectionStatus
+ and ConnectionStatusReason.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005, 2006 Collabora Limited
+ Copyright (C) 2005, 2006 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceAliasing(dbus.service.Interface):
+ """\
+ An interface on connections to support protocols where contacts have an
+ alias which they can change at will. Provides a method for the user to set
+ their own alias, and a signal which should be emitted when a contact's
+ alias is changed or first discovered.
+
+ On connections where the user is allowed to set aliases for contacts and
+ store them on the server, the GetAliasFlags
+ method will have the CONNECTION_ALIAS_FLAG_USER_SET flag set, and the
+ SetAliases method may be called on contact
+ handles other than the user themselves.
+
+ Aliases are intended to be used as the main displayed name for the
+ contact, where available.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.Aliasing')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Aliasing', in_signature='', out_signature='u')
+ def GetAliasFlags(self):
+ """
+ Return a bitwise OR of flags detailing the behaviour of aliases on this
+ connection.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Aliasing', in_signature='au', out_signature='as')
+ def RequestAliases(self, Contacts):
+ """
+ Request the value of several contacts' aliases at once.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Aliasing', in_signature='au', out_signature='a{us}')
+ def GetAliases(self, Contacts):
+ """
+ Request the value of several contacts' aliases at once. This SHOULD
+ only return cached aliases, falling back on the contact identifier
+ (i.e. the string corresponding to the handle) if none is present. Also
+ if there was no cached alias, a request SHOULD be started of which the
+ result is later signalled by
+ AliasesChanged.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Aliasing', in_signature='a{us}', out_signature='')
+ def SetAliases(self, Aliases):
+ """
+ Request that the alias of the given contact be changed. Success will be
+ indicated by emitting an AliasesChanged
+ signal. On connections where the CONNECTION_ALIAS_FLAG_USER_SET flag is
+ not set, this method will only ever succeed if the contact is the
+ user's own handle (as returned by Connection.GetSelfHandle).
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Aliasing', signature='a(us)')
+ def AliasesChanged(self, Aliases):
+ """
+ Signal emitted when a contact's alias (or that of the user) is changed.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2005-2008 Collabora Limited
+Copyright (C) 2005-2008 Nokia Corporation
+Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceAvatars(dbus.service.Interface):
+ """\
+ An interface for requesting avatars for contacts on a given connection,
+ receiving notification when avatars are changed, and publishing your own
+ avatar.
+
+ Avatars are identified by a string, the Avatar_Token,
+ which represents a particular avatar. Tokens MUST be chosen by the
+ connection manager in such a way that the triple
+ (Connection_Manager_Name, Protocol,
+ Avatar_Token) uniquely identifies an avatar.
+ An empty token means that an avatar has not been set for this contact, and
+ a changed token implies the contact's avatar has changed, but the strings
+ should otherwise be considered opaque by clients.
+
+ A client should use GetKnownAvatarTokens
+ to request the tokens for the
+ avatars of all the contacts it is interested in when it connects. The
+ avatars can then be requested using
+ RequestAvatars for the contacts. Clients
+ should bind to the AvatarUpdated signal and
+ request a new copy of
+ the avatar when a contacts' avatar token changes. Clients should cache the
+ token and data of each contact's avatar between connections, to avoid
+ repeatedly retrieving the same avatar.
+
+ To publish an avatar, a client should use
+ SetAvatar to provide an image which meets
+ the requirements returned by the
+ GetAvatarRequirements
+ function. On some protocols the avatar is stored on the server, so setting
+ the avatar is persistent, but on others it is transferred via a peer to
+ peer mechanism, so needs to be set every connection. Hence, on every
+ connection, clients should inspect the avatar token of the connection's
+ self handle using GetKnownAvatarTokens; if
+ the self handle is not in the
+ returned map, the client should re-set the avatar. If the self handle's
+ avatar token is known, but the avatar has been changed locally since the
+ last connection, the client should upload the new avatar; if the avatar has
+ not changed locally, then the client should download the avatar from the
+ server if its token differs from the that of the local avatar.
+
+ To remove the published avatar on protocols which have persistent avatars,
+ a client should use the ClearAvatar method.
+ This method can safely be used even if there is no avatar for this
+ connection.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.Avatars')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Avatars', in_signature='', out_signature='asqqqqu')
+ def GetAvatarRequirements(self):
+ """
+ Get the required format of avatars on this connection.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Avatars', in_signature='au', out_signature='as')
+ def GetAvatarTokens(self, Contacts):
+ """
+ Get the unique tokens for all of the given contacts' avatars.
+
+ Using this method in new Telepathy clients is deprecated; use
+ GetKnownAvatarTokens instead.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Avatars', in_signature='au', out_signature='a{us}')
+ def GetKnownAvatarTokens(self, Contacts):
+ """
+ Get the unique tokens for the given contacts' avatars. These tokens
+ can be persisted across connections, and should be used by the client
+ to check whether the avatars have been updated. For handles other than
+ the self handle, only tokens that are already known are returned; an
+ empty token means the given contact has no avatar. However, a CM must
+ always have the tokens for the self handle if one is set (even if it is
+ set to no avatar). On protocols where the avatar does not persist
+ between connections, a CM should omit the self handle from the returned
+ map until an avatar is explicitly set or cleared.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Avatars', in_signature='u', out_signature='ays')
+ def RequestAvatar(self, Contact):
+ """
+ Request the avatar for a given contact. Using this method in new
+ Telepathy clients is deprecated; use RequestAvatars instead.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Avatars', in_signature='au', out_signature='')
+ def RequestAvatars(self, Contacts):
+ """
+ Request avatars for a number of contacts. The
+ AvatarRetrieved signal is emitted for
+ each avatar retrieved. If the handles are valid but retrieving an
+ avatar fails (for any reason, including the contact not having an
+ avatar) the AvatarRetrieved signal is not emitted for that contact.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Avatars', in_signature='ays', out_signature='s')
+ def SetAvatar(self, Avatar, MIME_Type):
+ """
+ Set a new avatar image for this connection. The avatar image must
+ respect the requirements obtained by
+ GetAvatarRequirements.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Avatars', in_signature='', out_signature='')
+ def ClearAvatar(self):
+ """
+ Remove the avatar image for this connection.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Avatars', signature='us')
+ def AvatarUpdated(self, Contact, New_Avatar_Token):
+ """
+ Emitted when the avatar for a contact has been updated, or first
+ discovered on this connection. If the token differs from the token
+ associated with the client's cached avatar for this contact, the new
+ avatar should be requested with
+ RequestAvatars.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Avatars', signature='usays')
+ def AvatarRetrieved(self, Contact, Token, Avatar, Type):
+ """
+ Emitted when the avatar for a contact has been retrieved.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright © 2009 Collabora Ltd.
+Copyright © 2009 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceBalance(dbus.service.Interface):
+ """\
+ In many real-time communication services the user can pay for certain
+ services, typically calls to the
+ PSTN,
+ in advance. In (at least) Skype, it's possible to query the current
+ balance in a machine-readable way.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.Balance')
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Balance', signature='(ius)')
+ def BalanceChanged(self, Balance):
+ """
+ Emitted when the user's balance has changed.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005, 2006 Collabora Limited
+ Copyright (C) 2005, 2006 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceCapabilities(dbus.service.Interface):
+ """\
+ An interface for connections where it is possible to know what channel
+ types may be requested before the request is made to the connection
+ object. Each capability represents a commitment by the connection
+ manager that it will ordinarily be able to create a channel when given
+ a request with the given type and handle.
+
+ Capabilities pertain to particular contact handles, and represent
+ activities such as having a text chat or a voice call with the user.
+ The activities are represented by the D-Bus interface name of the
+ channel type for that activity.
+
+ The generic capability flags are defined by
+ Connection_Capability_Flags.
+
+ In addition, channel types may have type specific capability flags of
+ their own, which are described in the documentation for each channel
+ type.
+
+ This interface also provides for user interfaces notifying the
+ connection manager of what capabilities to advertise for the user. This
+ is done by using the
+ AdvertiseCapabilities method, and deals
+ with the
+ interface names of channel types and the type specific flags pertaining
+ to them which are implemented by available client processes.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.Capabilities')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Capabilities', in_signature='a(su)as', out_signature='a(su)')
+ def AdvertiseCapabilities(self, Add, Remove):
+ """
+ Used by user interfaces to indicate which channel types they are able
+ to handle on this connection. Because these may be provided by
+ different client processes, this method accepts channel types to add
+ and remove from the set already advertised on this connection. The type
+ of advertised capabilities (create versus invite) is protocol-dependent
+ and hence cannot be set by the this method. In the case of a client
+ adding an already advertised channel type but with new channel type
+ specific flags, the connection manager should simply add the new flags
+ to the set of advertised capabilities.
+
+ Upon a successful invocation of this method, the
+ CapabilitiesChanged
+ signal will be emitted for the user's own handle ( Connection.GetSelfHandle)
+ by the connection manager to indicate the changes
+ that have been made. This signal should also be monitored to ensure
+ that the set is kept accurate - for example, a client may remove
+ capabilities or type specific capability flags when it exits
+ which are still provided by another client.
+
+ On connections managed by the ChannelDispatcher,
+ this method SHOULD NOT be used by clients other than the
+ ChannelDispatcher itself.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Capabilities', in_signature='au', out_signature='a(usuu)')
+ def GetCapabilities(self, Handles):
+ """
+ Returns an array of capabilities for the given contact handles.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Capabilities', signature='a(usuuuu)')
+ def CapabilitiesChanged(self, Caps):
+ """
+ Announce that there has been a change of capabilities on the
+ given handle.
+
+ If the handle is zero, the capabilities refer to the connection
+ itself, in some poorly defined way. This usage is deprecated and
+ clients should ignore it.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005, 2006, 2008 Collabora Limited
+ Copyright (C) 2005, 2006, 2008 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceContactCapabilities(dbus.service.Interface):
+ """\
+ Contact capabilities describe the channel classes which may be
+ created with a given contact in advance of attempting to create a
+ channel. Each capability represents a commitment by the
+ connection manager that it will ordinarily be able to create a channel
+ with a contact when given a request with the properties defined by the
+ channel class.
+
+ Capabilities pertain to particular contact handles, and represent
+ activities such as having a text chat, a voice call with the user or a
+ stream tube of a defined type.
+
+ This interface also enables user interfaces to notify the connection
+ manager what capabilities to advertise for the user to other contacts.
+ This is done by using the
+ UpdateCapabilities method.
+
+
+ XMPP is a major user of this interface: XMPP contacts will not,
+ in general, be callable using VoIP unless they advertise suitable
+ Jingle capabilities.
+
+ Many other protocols also have some concept of capability flags,
+ which this interface exposes in a protocol-independent way.
+
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities', in_signature='a(saa{sv}as)', out_signature='')
+ def UpdateCapabilities(self, Handler_Capabilities):
+ """
+ Alter the connection's advertised capabilities to include
+ the intersection of the given clients' capabilities with what the
+ connection manager is able to implement.
+
+ On connections managed by the ChannelDispatcher, processes other
+ than the ChannelDispatcher SHOULD NOT call this method, and the
+ ChannelDispatcher SHOULD use this method to advertise the
+ capabilities of all the registered Client.Handler
+ implementations.On connections not managed by the ChannelDispatcher,
+ clients MAY use this method directly, to indicate the channels they
+ will handle and the extra capabilities they have.
+
+ Upon a successful invocation of this method, the connection manager
+ will only emit the
+ ContactCapabilitiesChanged signal
+ for the user's SelfHandle
+ if, in the underlying protocol, the new capabilities are distinct
+ from the previous state.
+
+
+ The connection manager will essentially intersect the provided
+ capabilities and the channel classes it implements. Therefore,
+ certain properties which are never fixed for a channel class
+ (such as the target handle, or the Parameters property of a tube
+ channel) will almost certainly not be advertised.
+
+
+ This method MAY be called on a newly-created connection while it
+ is still in the DISCONNECTED state, to request that when the
+ connection connects, it will do so with the appropriate
+ capabilities. Doing so MUST NOT fail.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities', in_signature='au', out_signature='a{ua(a{sv}as)}')
+ def GetContactCapabilities(self, handles):
+ """
+ Returns an array of enhanced capabilities for the given contact handles.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities', signature='a{ua(a{sv}as)}')
+ def ContactCapabilitiesChanged(self, caps):
+ """
+ Announce that there has been a change of capabilities on the
+ given handles. A single signal can be emitted for several
+ contacts.
+
+
+ The underlying protocol can get several contacts' capabilities at
+ the same time.
+
+
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005-2008 Collabora Limited
+ Copyright (C) 2005, 2006 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 of the License, or (at
+ your option) any later version.
+
+ This library 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 Lesser
+ General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this library; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceContacts(dbus.service.Interface):
+ """\
+ This interface allows many attributes of many contacts to be
+ obtained in a single D-Bus round trip.
+
+ Each contact attribute has an string identifier
+ (Contact_Attribute), which is namespaced
+ by the D-Bus interface which defines it.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.Contacts')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Contacts', in_signature='auasb', out_signature='a{ua{sv}}')
+ def GetContactAttributes(self, Handles, Interfaces, Hold):
+ """
+ Return any number of contact attributes for the given handles.
+
+ """
+ raise NotImplementedError
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2008 Collabora Ltd.
+Copyright (C) 2008 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceLocation(dbus.service.Interface):
+ """\
+ An interface on connections to support protocols which allow users to
+ publish their current geographical location, and subscribe to the
+ current location of their contacts.
+
+ This interface is geared strongly towards automatic propagation and
+ use of this information, so focuses on latitude, longitude and
+ altitude which can be determined by GPS, although provision is also
+ included for an optional human-readable description of locations. All
+ co-ordinate information is required to be relative to the WGS84
+ datum.
+
+ The information published through this interface is intended to have
+ the same scope as presence information, so will normally be made
+ available to those individuals on the user's "publish" contact list.
+ Even so, user interfaces should not automatically publish location
+ information without the consent of the user, and it is recommended
+ that an option is made available to reduce the accuracy of the
+ reported information to allow the user to maintain their privacy.
+
+ Location information is represented using the terminology of XMPP's
+ XEP-0080
+ or the XEP-0080-derived
+ Geoclue API where
+ possible.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.Location')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Location', in_signature='au', out_signature='a{ua{sv}}')
+ def GetLocations(self, Contacts):
+ """
+ Return the current locations of the given contacts, if they are
+ already known. If any of the given contacts' locations are not known,
+ request their current locations, but return immediately without waiting
+ for a reply; if a reply with a non-empty location is later received
+ for those contacts, the LocationUpdated
+ signal will be emitted for them.
+
+
+ This method is appropriate for "lazy" location finding, for instance
+ displaying the location (if available) of everyone in your contact
+ list.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Location', in_signature='u', out_signature='a{sv}')
+ def RequestLocation(self, Contact):
+ """
+ Return the current location of the given contact. If necessary, make
+ a request to the server for up-to-date information, and wait for a
+ reply.
+
+
+ This method is appropriate for use in a "Contact Information..."
+ dialog; it can be used to show progress information (while waiting
+ for the method to return), and can distinguish between various error
+ conditions.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Location', in_signature='a{sv}', out_signature='')
+ def SetLocation(self, Location):
+ """
+ Set the local user's own location.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Location', signature='ua{sv}')
+ def LocationUpdated(self, Contact, Location):
+ """
+ Emitted when a contact's location changes or becomes known.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""
+ Copyright (C) 2005, 2006 Collabora Limited
+
+
+Copyright (C) 2005, 2006 Nokia Corporation
+
+
+Copyright (C) 2006 INdT
+
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfacePresence(dbus.service.Interface):
+ """\
+
+ This interface is for services which have a concept of presence which
+ can be published for yourself and monitored on your contacts.
+ Telepathy's definition of presence is based on that used by
+ the Galago project.
+
+ Presence on an individual (yourself or one of your contacts) is modelled as
+ a last activity time along with a set of zero or more statuses, each of
+ which may have arbitrary key/value parameters. Valid statuses are defined
+ per connection, and a list of them can be obtained with the
+ GetStatuses method.
+
+ (The SimplePresence interface which replaces this one restricts
+ presences to one status per contact, with an optional message, which is
+ in practice all that was implemented on this interface.)
+
+ Each status has an arbitrary string identifier which should have an agreed
+ meaning between the connection manager and any client which is expected to
+ make use of it. The well-known values defined by the SimplePresence
+ interface SHOULD be used where possible
+
+ As well as these well-known status identifiers, every status also has a
+ numerical type value chosen from
+ Connection_Presence_Type which can be used by the client
+ to classify even unknown statuses into different fundamental types.
+
+ These numerical types exist so that even if a client does not understand
+ the string identifier being used, and hence cannot present the presence to
+ the user to set on themselves, it may display an approximation of the
+ presence if it is set on a contact.
+
+ The dictionary of variant types allows the connection manager to exchange
+ further protocol-specific information with the client. It is recommended
+ that the string (s) argument 'message' be interpreted as an optional
+ message which can be associated with a presence status.
+
+ If the connection has a 'subscribe' contact list,
+ PresenceUpdate signals should be emitted to
+ indicate changes of contacts on this list, and should also be emitted for
+ changes in your own presence. Depending on the protocol, the signal may
+ also be emitted for others such as people with whom you are communicating,
+ and any user interface should be updated accordingly.
+
+ On some protocols, RequestPresence may
+ only succeed on contacts on your 'subscribe' list, and other contacts will
+ cause a PermissionDenied error. On protocols where there is no 'subscribe'
+ list, and RequestPresence succeeds, a client may poll the server
+ intermittently to update any display of presence information.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.Presence')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Presence', in_signature='sa{sv}', out_signature='')
+ def AddStatus(self, Status, Parameters):
+ """
+ Request that a single presence status is published for the user, along
+ with any desired parameters. Changes will be indicated by
+ PresenceUpdate signals being emitted.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Presence', in_signature='', out_signature='')
+ def ClearStatus(self):
+ """
+ Request that all of a user's presence statuses be removed. Be aware
+ that this request may simply result in the statuses being replaced by a
+ default available status. Changes will be indicated by
+ PresenceUpdate signals being emitted.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Presence', in_signature='au', out_signature='a{u(ua{sa{sv}})}')
+ def GetPresence(self, Contacts):
+ """
+ Get presence previously emitted by
+ PresenceUpdate for the given contacts.
+ Data is returned in the same structure as the PresenceUpdate signal.
+ Using this method in favour of
+ RequestPresence has the advantage that
+ it will not wake up each client connected to the PresenceUpdate signal.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Presence', in_signature='', out_signature='a{s(ubba{ss})}')
+ def GetStatuses(self):
+ """
+ Get a dictionary of the valid presence statuses for this connection.
+ This is only available when online because only some statuses will
+ be available on some servers.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Presence', in_signature='s', out_signature='')
+ def RemoveStatus(self, Status):
+ """
+ Request that the given presence status is no longer published for the
+ user. Changes will be indicated by
+ PresenceUpdate signals being emitted. As
+ with ClearStatus, removing a status may
+ actually result in it being replaced by a default available status.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Presence', in_signature='au', out_signature='')
+ def RequestPresence(self, Contacts):
+ """
+ Request the presence for contacts on this connection. A PresenceUpdate
+ signal will be emitted when they are received. This is not the same as
+ subscribing to the presence of a contact, which must be done using the
+ 'subscription' ContactList,
+ and on some protocols presence information may not be available unless
+ a subscription exists.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Presence', in_signature='u', out_signature='')
+ def SetLastActivityTime(self, Time):
+ """
+ Request that the recorded last activity time for the user be updated on
+ the server.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Presence', in_signature='a{sa{sv}}', out_signature='')
+ def SetStatus(self, Statuses):
+ """
+ Request that the user's presence be changed to the given statuses
+ and desired parameters. Changes will be reflected by
+ PresenceUpdate
+ signals being emitted.
+
+ Statuses whose Connection_Presence_Type
+ is Offline, Error or Unknown MUST NOT be passed to this
+ function. Connection managers SHOULD reject these statuses.
+
+
+ The same rationale as for SimplePresence.SetPresence
+ applies.
+
+
+ On certain protocols, this method may be
+ called on a newly-created connection which is still in the
+ DISCONNECTED state, and will sign on with the requested status.
+ If the requested status is not available after signing on,
+ NotAvailable will be returned and the connection will remain
+ offline, or if the protocol does not support signing on with
+ a certain status, Disconnected will be returned.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Presence', signature='a{u(ua{sa{sv}})}')
+ def PresenceUpdate(self, Presence):
+ """
+ This signal should be emitted when your own presence has been changed,
+ or the presence of the member of any of the connection's channels has
+ been changed, or when the presence requested by
+ RequestPresence is available.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2008 Collabora Limited
+Copyright (C) 2008 Nokia Corporation
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceRequests(dbus.service.Interface):
+ """\
+ An enhanced version of the Telepathy connection interface, which can
+ represent bundles of channels that should be dispatched together, and
+ does not assume any particular properties by which channels are
+ uniquely identifiable.
+
+ If this interface is implemented on a connection, then
+ NewChannels MUST be emitted for
+ all new channels, even those created with RequestChannel.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.Requests')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Requests', in_signature='a{sv}', out_signature='oa{sv}')
+ def CreateChannel(self, Request):
+ """
+ Request that an entirely new channel is created.
+
+
+ There is deliberately no flag corresponding to the
+ suppress_handler argument to
+ Connection.RequestChannel,
+ because passing a FALSE value for that argument is deprecated.
+ Requests made using this interface always behave as though
+ suppress_handler was TRUE.
+
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.Requests', in_signature='a{sv}', out_signature='boa{sv}')
+ def EnsureChannel(self, Request):
+ """
+ Request that channels are ensured to exist.
+
+
+ The connection manager is in the best position to determine which
+ existing channels could satisfy which requests.
+
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Requests', signature='a(oa{sv})')
+ def NewChannels(self, Channels):
+ """
+ New channels have been created. The connection manager SHOULD emit
+ a single signal for any group of closely related channels that are
+ created at the same time, so that the channel dispatcher can try to
+ dispatch them to a handler as a unit.
+
+ In particular, if additional channels are created as a side-effect
+ of a call to CreateChannel,
+ these channels SHOULD appear in the same NewChannels signal as
+ the channel that satisfies the request.
+
+
+ Joining a MUC Tube in XMPP requires joining the corresponding
+ MUC (chatroom), so a Text
+ channel can be created as a side-effect.
+
+
+ Every time NewChannels is emitted, it MUST be followed by
+ a Connection.NewChannel
+ signal for each channel.
+
+
+ The double signal emission is for the benefit of older Telepathy
+ clients, which won't be listening for NewChannels.
+
+ The more informative NewChannels signal comes first so that
+ clients that did not examine the connection to find
+ out whether Requests is supported will see the more informative
+ signal for each channel first, and then ignore the less
+ informative signal because it announces a new channel of which
+ they are already aware.
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.Requests', signature='o')
+ def ChannelClosed(self, Removed):
+ """
+ Emitted when a channel is closed and hence disappears from the
+ Channels property.
+
+
+ This is redundant with the Closed
+ signal on the channel itself, but it does provide full change
+ notification for the Channels property.
+
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005-2008 Collabora Limited
+ Copyright (C) 2005, 2006 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or modify it
+ under the terms of the GNU Lesser General Public License as published by
+ the Free Software Foundation; either version 2.1 of the License, or (at
+ your option) any later version.
+
+ This library 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 Lesser
+ General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public License
+ along with this library; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionInterfaceSimplePresence(dbus.service.Interface):
+ """\
+ This interface is for services which have a concept of presence which
+ can be published for yourself and monitored on your contacts.
+
+ Presence on an individual (yourself or one of your contacts) is
+ modelled as a status and a status message. Valid statuses are defined
+ per connection, and a list of those that can be set on youself
+ can be obtained from the
+ Statuses
+ property.
+
+ Each status has an arbitrary string identifier which should have an
+ agreed meaning between the connection manager and any client which is
+ expected to make use of it. The following well-known values should be
+ used where possible to allow clients to identify common choices:
+
+
+
+ status identifier
+ Connection_Presence_Type
+ comments
+
+
+ available
+ Connection_Presence_Type_Available
+
+
+
+ away
+ Connection_Presence_Type_Away
+
+
+
+ brb
+ Connection_Presence_Type_Away
+ Be Right Back (a more specific form of Away)
+
+
+ busy
+ Connection_Presence_Type_Busy
+
+
+ dnd
+ Connection_Presence_Type_Busy
+ Do Not Disturb (a more specific form of Busy)
+
+
+ xa
+ Connection_Presence_Type_Extended_Away
+ Extended Away
+
+
+ hidden
+ Connection_Presence_Type_Hidden
+ Also known as "Invisible" or "Appear Offline"
+
+
+ offline
+ Connection_Presence_Type_Offline
+
+
+
+ unknown
+ Connection_Presence_Type_Unknown
+ special, see below
+
+
+ error
+ Connection_Presence_Type_Error
+ special, see below
+
+
+
+ As well as these well-known status identifiers, every status also has
+ a numerical type value chosen from
+ Connection_Presence_Type which can be
+ used by the client to classify even unknown statuses into different
+ fundamental types.
+
+ These numerical types exist so that even if a client does not
+ understand the string identifier being used, and hence cannot present
+ the presence to the user to set on themselves, it may display an
+ approximation of the presence if it is set on a contact.
+
+ As well as the normal status identifiers, there are two special ones
+ that may be present: 'unknown' with type Unknown and 'error' with type
+ Error. 'unknown' indicates that it is impossible to determine the
+ presence of a contact at this time, for example because it's not on the
+ 'subscribe' list and the protocol only allows one to determine the
+ presence of contacts you're subscribed to. 'error' indicates that there
+ was a failure in determining the status of a contact.
+
+ If the connection has a 'subscribe' contact list,
+ PresencesChanged
+ signals should be emitted to indicate changes of contacts on this list,
+ and should also be emitted for changes in your own presence. Depending
+ on the protocol, the signal may also be emitted for others such as
+ people with whom you are communicating, and any user interface should
+ be updated accordingly.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Connection.Interface.SimplePresence')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.SimplePresence', in_signature='ss', out_signature='')
+ def SetPresence(self, Status, Status_Message):
+ """
+ Request that the presence status and status message are published for
+ the connection. Changes will be indicated by
+ PresencesChanged
+ signals being emitted.
+
+ This method may be called on a newly-created connection while it
+ is still in the DISCONNECTED state, to request that when the
+ connection connects, it will do so with the selected status.
+
+ In DISCONNECTED state the
+ Statuses
+ property will indicate which statuses are allowed to be set
+ while DISCONNECTED (none, if the Connection Manager doesn't allow
+ this). This value MUST NOT be cached, as the set of allowed
+ presences might change upon connecting.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Connection.Interface.SimplePresence', in_signature='au', out_signature='a{u(uss)}')
+ def GetPresences(self, Contacts):
+ """
+ Get presence previously emitted by
+ PresencesChanged for the given
+ contacts. Data is returned in the same structure as the
+ PresencesChanged signal; no additional network requests are made.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Connection.Interface.SimplePresence', signature='a{u(uss)}')
+ def PresencesChanged(self, Presence):
+ """
+ This signal should be emitted when your own presence has been changed,
+ or the presence of the member of any of the connection's channels has
+ been changed.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2005-2008 Collabora Limited
+Copyright (C) 2005-2008 Nokia Corporation
+Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class ConnectionManager(dbus.service.Object):
+ """\
+ A D-Bus service which allows connections to be created. The manager
+ processes are intended to be started by D-Bus service activation.
+
+ For service discovery, each Telepathy connection manager must have
+ a connection manager name (see
+ Connection_Manager_Name for syntax).
+
+ The connection manager must then provide a well-known bus name of
+ org.freedesktop.Telepathy.ConnectionManager.cmname
+ where cmname is its connection manager name. If it makes sense
+ to start the connection manager using D-Bus service activation, it
+ must register that well-known name for service activation by installing
+ a .service file.
+
+ Clients can list the running connection managers by calling the
+ ListNames method on the D-Bus daemon's org.freedesktop.DBus interface
+ and looking for names matching the above pattern; they can list the
+ activatable connection managers by calling ListActivatableNames, and
+ they should usually combine the two lists to get a complete list of
+ running or activatable connection managers.
+
+ When the connection manager is running, it must have an object
+ implementing the ConnectionManager interface at the object path
+ /org/freedesktop/Telepathy/ConnectionManager/cmname.
+
+
+ Connection managers' capabilities can be determined dynamically by
+ calling their ListProtocols method, then
+ for each protocol of interest, calling
+ GetParameters to discover the required and
+ optional parameters.
+ However, since it is inefficient to activate all possible connection
+ managers on the system just to find out what they can do, there
+ is a standard mechanism to store static information about CMs in
+ ".manager files".
+
+ To look up a connection manager's supported protocols, clients
+ should search the data directories specified by
+ the
+ freedesktop.org XDG Base Directory Specification ($XDG_DATA_HOME,
+ defaulting to $HOME/.local/share if unset, followed by
+ colon-separated paths from $XDG_DATA_DIRS, defaulting to
+ /usr/local/share:/usr/share if unset) for the first file named
+ telepathy/managers/cmname.manager that can be
+ read without error. This file has the same syntax as a
+ freedesktop.org Desktop Entry file.
+
+ Clients must still support connection managers for which no
+ .manager file can be found, which they can do by activating
+ the connection manager and calling its methods; the
+ .manager file is merely an optimization. Connection managers
+ whose list of protocols can change at any time (for instance, via
+ a plugin architecture) should not install a .manager
+ file.
+
+ For each protocol name proto that would be returned by
+ ListProtocols, the .manager file contains a group
+ headed [Protocol proto]. For each parameter
+ p that would be returned by GetParameters(proto), the
+ .manager file contains a key param-p with a value
+ consisting of a D-Bus signature (a single complete type), optionally
+ followed by a space and a space-separated list of flags. The supported
+ flags are:
+
+
+ required, corresponding to
+ Conn_Mgr_Param_Flag_Required
+ register, corresponding
+ to Conn_Mgr_Param_Flag_Register
+ secret, corresponding
+ to Conn_Mgr_Param_Flag_Secret
+ dbus-property, corresponding
+ to Conn_Mgr_Param_Flag_DBus_Property
+
+
+ The group may also contain a key default-p
+ whose value is a string form of the default value for the parameter.
+ If this key exists, it sets the default, and also sets the flag
+ Conn_Mgr_Param_Flag_Has_Default. The default value is formatted
+ according to the D-Bus signature as follows:
+
+
+ s (string)
+ The UTF-8 string, with the standard backslash escape
+ sequences supported by the Desktop Entry Specification
+ (the "localestring" type from the Desktop Entry Specification)
+ o (object path)
+ The object path as an ASCII string
+ b (boolean)
+ "true" (case-insensitively) or "1" means True, "false"
+ (case-insensitively) or "0" means False
+ y, q, u, t (8-, 16-, 32-, 64-bit unsigned integer)
+ ASCII decimal integer
+ n, i, x (16-, 32-, 64-bit signed integer)
+ ASCII decimal integer, optionally prefixed with "-"
+ d (double-precision floating point)
+ ASCII decimal number
+ as (array of string)
+ A sequence of UTF-8 strings each followed by a semicolon, with
+ any semicolons they contain escaped with a backslash
+ (the "localestrings" type from the Desktop Entry Specification)
+
+
+ Currently, no other D-Bus signatures are allowed to have default values,
+ but clients parsing the .manager file MUST ignore defaults
+ that they cannot parse, and treat them as if the
+ default-p key was not present at all.
+
+ It is not required that a connection manager be able to support multiple
+ protocols, or even multiple connections. When a connection is made, a
+ service name where the connection object can be found is returned. A
+ manager which can only make one connection may then remove itself from its
+ well-known bus name, causing a new connection manager to be activated when
+ somebody attempts to make a new connection.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.ConnectionManager', in_signature='s', out_signature='a(susv)')
+ def GetParameters(self, Protocol):
+ """
+ Get a list of the parameters which must or may be provided to the
+ RequestConnection method when connecting
+ to the given protocol,
+ or registering (the boolean "register" parameter is available,
+ and set to true).
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.ConnectionManager', in_signature='', out_signature='as')
+ def ListProtocols(self):
+ """
+ Get a list of protocol identifiers that are implemented by this
+ connection manager.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.ConnectionManager', in_signature='sa{sv}', out_signature='so')
+ def RequestConnection(self, Protocol, Parameters):
+ """
+ Request a
+ Connection
+ object representing a given account on a given
+ protocol with the given parameters. The method returns the bus name
+ and the object path where the new Connection object can be found,
+ which should have the status of Connection_Status_Disconnected, to
+ allow signal handlers to be attached before connecting is started
+ with the
+ Connect
+ method.
+
+ The parameters which must and may be provided in the parameters
+ dictionary can be discovered with the
+ GetParameters method. These
+ parameters, their types, and their default values may be cached
+ in files so that all available connection managers do not need to be
+ started to discover which protocols are available.
+
+ To request values for these parameters from the user, a client must
+ have prior knowledge of the meaning of the parameter names, so the
+ following well-known names and types should be used where appropriate:
+
+
+ account (s)
+ The identifier for the user's account on the server
+
+ server (s)
+ A fully qualified domain name or numeric IPv4 or IPv6 address.
+ Using the fully-qualified domain name form is recommended whenever
+ possible. If this parameter is specified and the account for that
+ protocol also specifies a server, this parameter should override
+ that in the user id.
+
+ port (q)
+ A TCP or UDP port number. If this parameter is specified and the
+ account for that protocol also specifies a port, this parameter
+ should override that in the account.
+
+ password (s)
+ A password associated with the account.
+
+ require-encryption (b)
+ Require encryption for this connection. A connection should fail
+ to connect if require-encryption is set and an encrypted connection
+ is not possible.
+
+ register (b)
+ This account should be created on the server if it does not
+ already exist.
+
+ ident (s)
+ The local username to report to the server if necessary, such as
+ in IRC.
+
+ fullname (s)
+ The user's full name if the service requires this when
+ authenticating or registering.
+
+ stun-server (s)
+ The IP address or FQDN of a STUN server to use for NAT traversal,
+ without any ":port" suffix.
+
+ stun-port (q)
+ The UDP port number on the stun-server to use for STUN. Only
+ significant if the stun-server is also supplied.
+
+ keepalive-interval (u)
+ The time in seconds between pings sent to the server to ensure
+ that the connection is still alive, or 0 to disable such
+ pings.
+
+
+ Every successful RequestConnection call will cause the emission of a
+ NewConnection signal for the same newly
+ created connection. The
+ requester can use the returned object path and service name
+ independently of the emission of that signal. In that case this signal
+ emission is most useful for, e.g. other processes that are monitoring
+ the creation of new connections.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.ConnectionManager', signature='sos')
+ def NewConnection(self, Bus_Name, Object_Path, Protocol):
+ """
+ Emitted when a new Connection object
+ is created.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+"""Copyright (C) 2009 Collabora Ltd.
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class Debug(dbus.service.Object):
+ """\
+ An interface for providing debug messages.
+
+ This interface is primarily provided by one object per
+ service, at the path /org/freedesktop/Telepathy/debug.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Debug', in_signature='', out_signature='a(dsus)')
+ def GetMessages(self):
+ """
+ Retrieve buffered debug messages. An implementation could have a
+ limit on how many message it keeps and so the array returned from
+ this method should not be assumed to be all of the messages in
+ the lifetime of the service.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Debug', signature='dsus')
+ def NewDebugMessage(self, time, domain, level, message):
+ """
+ Emitted when a debug messages is generated if the
+ Enabled property is set to TRUE.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005, 2006 Collabora Limited
+ Copyright (C) 2005, 2006 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class MediaSessionHandler(dbus.service.Object):
+ """\
+ An media session handler is an object that handles a number of synchronised
+ media streams.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.SessionHandler', in_signature='us', out_signature='')
+ def Error(self, Error_Code, Message):
+ """
+ Informs the connection manager that an error occured in this session.
+ If used, the connection manager must terminate the session and all of
+ the streams within it, and may also emit a StreamError
+ signal on the channel for each stream within the session.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.SessionHandler', in_signature='', out_signature='')
+ def Ready(self):
+ """
+ Inform the connection manager that a client is ready to handle
+ this session handler (i.e. that it has connected to the
+ NewStreamHandler signal and done any
+ other necessary setup).
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.SessionHandler', signature='ouuu')
+ def NewStreamHandler(self, Stream_Handler, ID, Media_Type, Direction):
+ """
+ Emitted when a new stream handler has been created for this
+ session.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005-2008 Collabora Limited
+ Copyright (C) 2005-2008 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class MediaStreamHandler(dbus.service.Object):
+ """\
+ Handles signalling the information pertaining to a specific media stream.
+ A client should provide information to this handler as and when it is
+ available.
+ """
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='u', out_signature='')
+ def CodecChoice(self, Codec_ID):
+ """
+ Inform the connection manager of codec used to receive data.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='us', out_signature='')
+ def Error(self, Error_Code, Message):
+ """
+ Inform the connection manager that an error occured in this stream. The
+ connection manager should emit the StreamError signal for the stream on
+ the relevant channel, and remove the stream from the session.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='', out_signature='')
+ def NativeCandidatesPrepared(self):
+ """
+ Informs the connection manager that all possible native candisates
+ have been discovered for the moment.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='ss', out_signature='')
+ def NewActiveCandidatePair(self, Native_Candidate_ID, Remote_Candidate_ID):
+ """
+ Informs the connection manager that a valid candidate pair
+ has been discovered and streaming is in progress.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='sa(usuussduss)', out_signature='')
+ def NewNativeCandidate(self, Candidate_ID, Transports):
+ """
+ Inform this MediaStreamHandler that a new native transport candidate
+ has been ascertained.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='a(usuuua{ss})', out_signature='')
+ def Ready(self, Codecs):
+ """
+ Inform the connection manager that a client is ready to handle
+ this StreamHandler. Also provide it with info about all supported
+ codecs.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='a(usuuua{ss})', out_signature='')
+ def SetLocalCodecs(self, Codecs):
+ """
+ Used to provide codecs after Ready(), so the media client can go
+ ready for an incoming call and exchange candidates/codecs before
+ knowing what local codecs are available.
+
+ This is useful for gatewaying calls between two connection managers.
+ Given an incoming call, you need to call
+ Ready to get the remote codecs before
+ you can use them as the "local" codecs to place the outgoing call,
+ and hence receive the outgoing call's remote codecs to use as the
+ incoming call's "local" codecs.
+
+ In this situation, you would pass an empty list of codecs to the
+ incoming call's Ready method, then later call SetLocalCodecs on the
+ incoming call in order to respond to the offer.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='u', out_signature='')
+ def StreamState(self, State):
+ """
+ Informs the connection manager of the stream's current state, as
+ as specified in Channel.Type.StreamedMedia::ListStreams.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='a(usuuua{ss})', out_signature='')
+ def SupportedCodecs(self, Codecs):
+ """
+ Inform the connection manager of the supported codecs for this session.
+ This is called after the connection manager has emitted SetRemoteCodecs
+ to notify what codecs are supported by the peer, and will thus be an
+ intersection of all locally supported codecs (passed to Ready)
+ and those supported by the peer.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='a(usuuua{ss})', out_signature='')
+ def CodecsUpdated(self, Codecs):
+ """
+ Inform the connection manager that the parameters of the supported
+ codecs for this session have changed. The connection manager should
+ send the new parameters to the remote contact.
+
+
+ This is required for H.264 and Theora, for example.
+
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='b', out_signature='')
+ def HoldState(self, Held):
+ """
+ Notify the connection manager that the stream's hold state has
+ been changed successfully in response to SetStreamHeld.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Media.StreamHandler', in_signature='', out_signature='')
+ def UnholdFailure(self):
+ """
+ Notify the connection manager that an attempt to reacquire the
+ necessary hardware or software resources to unhold the stream,
+ in response to SetStreamHeld, has failed.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='sa(usuussduss)')
+ def AddRemoteCandidate(self, Candidate_ID, Transports):
+ """
+ Signal emitted when the connection manager wishes to inform the
+ client of a new remote candidate.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='')
+ def Close(self):
+ """
+ Signal emitted when the connection manager wishes the stream to be
+ closed.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='s')
+ def RemoveRemoteCandidate(self, Candidate_ID):
+ """
+ Signal emitted when the connection manager wishes to inform the
+ client that the remote end has removed a previously usable
+ candidate.
+
+
+ It seemed like a good idea at the time, but wasn't.
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='ss')
+ def SetActiveCandidatePair(self, Native_Candidate_ID, Remote_Candidate_ID):
+ """
+ Emitted by the connection manager to inform the client that a
+ valid candidate pair has been discovered by the remote end
+ and streaming is in progress.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='a(sa(usuussduss))')
+ def SetRemoteCandidateList(self, Remote_Candidates):
+ """
+ Signal emitted when the connection manager wishes to inform the
+ client of all the available remote candidates at once.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='a(usuuua{ss})')
+ def SetRemoteCodecs(self, Codecs):
+ """
+ Signal emitted when the connection manager wishes to inform the
+ client of the codecs supported by the remote end.
+ If these codecs are compatible with the remote codecs, then the client
+ must call SupportedCodecs,
+ otherwise call Error.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='b')
+ def SetStreamPlaying(self, Playing):
+ """
+ If emitted with argument TRUE, this means that the connection manager
+ wishes to set the stream playing; this means that the streaming
+ implementation should expect to receive data. If emitted with argument
+ FALSE this signal is basically meaningless and should be ignored.
+
+
+ We're very sorry.
+
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='b')
+ def SetStreamSending(self, Sending):
+ """
+ Signal emitted when the connection manager wishes to set whether or not
+ the stream sends to the remote end.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='y')
+ def StartTelephonyEvent(self, Event):
+ """
+ Request that a telephony event (as defined by RFC 4733) is transmitted
+ over this stream until StopTelephonyEvent is called.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='')
+ def StopTelephonyEvent(self):
+ """
+ Request that any ongoing telephony events (as defined by RFC 4733)
+ being transmitted over this stream are stopped.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Media.StreamHandler', signature='b')
+ def SetStreamHeld(self, Held):
+ """
+ Emitted when the connection manager wishes to place the stream on
+ hold (so the streaming client should free hardware or software
+ resources) or take the stream off hold (so the streaming client
+ should reacquire the necessary resources).
+
+ When placing a channel's streams on hold, the connection manager
+ SHOULD notify the remote contact that this will be done (if
+ appropriate in the protocol) before it emits this signal.
+
+
+ It is assumed that relinquishing a resource will not fail.
+ If it does, the call is probably doomed anyway.
+
+
+ When unholding a channel's streams, the connection manager
+ SHOULD emit this signal and wait for success to be indicated
+ via HoldState before it notifies the remote contact that the
+ channel has been taken off hold.
+
+
+ This means that if a resource is unavailable, the remote
+ contact will never even be told that we tried to acquire it.
+
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+# Generated from the Telepathy spec
+""" Copyright (C) 2005-2007 Collabora Limited
+ Copyright (C) 2005, 2006 Nokia Corporation
+ Copyright (C) 2006 INdT
+
+ This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+import dbus.service
+
+
+class PropertiesInterface(dbus.service.Interface):
+ """\
+ Interface for channels and other objects, to allow querying and setting
+ properties. ListProperties returns which properties are valid for
+ the given channel, including their type, and an integer handle used to
+ refer to them in GetProperties, SetProperties, and the PropertiesChanged
+ signal. The values are represented by D-Bus variant types, and are
+ accompanied by flags indicating whether or not the property is readable or
+ writable.
+
+ Each property also has a flags value to indicate what methods are
+ available. This is a bitwise OR of PropertyFlags values.
+ """
+
+ def __init__(self):
+ self._interfaces.add('org.freedesktop.Telepathy.Properties')
+
+ @dbus.service.method('org.freedesktop.Telepathy.Properties', in_signature='au', out_signature='a(uv)')
+ def GetProperties(self, Properties):
+ """
+ Returns an array of (identifier, value) pairs containing the current
+ values of the given properties.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Properties', in_signature='', out_signature='a(ussu)')
+ def ListProperties(self):
+ """
+ Returns a dictionary of the properties available on this channel.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.method('org.freedesktop.Telepathy.Properties', in_signature='a(uv)', out_signature='')
+ def SetProperties(self, Properties):
+ """
+ Takes an array of (identifier, value) pairs containing desired
+ values to set the given properties. In the case of any errors, no
+ properties will be changed. When the changes have been acknowledged
+ by the server, the PropertiesChanged signal will be emitted.
+
+ All properties given must have the PROPERTY_FLAG_WRITE flag, or
+ PermissionDenied will be returned. If any variants are of the wrong
+ type, NotAvailable will be returned. If any given property identifiers
+ are invalid, InvalidArgument will be returned.
+
+ """
+ raise NotImplementedError
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Properties', signature='a(uv)')
+ def PropertiesChanged(self, Properties):
+ """
+ Emitted when the value of readable properties has changed.
+
+ """
+ pass
+
+ @dbus.service.signal('org.freedesktop.Telepathy.Properties', signature='a(uu)')
+ def PropertyFlagsChanged(self, Properties):
+ """
+ Emitted when the flags of some room properties have changed.
+
+ """
+ pass
+
\ No newline at end of file
--- /dev/null
+# Placeholder for package
--- /dev/null
+# -*- coding: utf-8 -*-
+"""List of constants, generated from the Telepathy spec version 0.19.0
+
+Copyright © 2005-2009 Collabora Limited
+Copyright © 2005-2009 Nokia Corporation
+Copyright © 2006 INdT
+
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+# Conn_Mgr_Param_Flags (bitfield/set of flags, 0 for none)
+CONN_MGR_PARAM_FLAG_REQUIRED = 1
+CONN_MGR_PARAM_FLAG_REGISTER = 2
+CONN_MGR_PARAM_FLAG_HAS_DEFAULT = 4
+CONN_MGR_PARAM_FLAG_SECRET = 8
+CONN_MGR_PARAM_FLAG_DBUS_PROPERTY = 16
+
+
+# Handle_Type
+HANDLE_TYPE_NONE = 0
+HANDLE_TYPE_CONTACT = 1
+HANDLE_TYPE_ROOM = 2
+HANDLE_TYPE_LIST = 3
+HANDLE_TYPE_GROUP = 4
+LAST_HANDLE_TYPE = 4
+# Connection_Status
+CONNECTION_STATUS_CONNECTED = 0
+CONNECTION_STATUS_CONNECTING = 1
+CONNECTION_STATUS_DISCONNECTED = 2
+LAST_CONNECTION_STATUS = 2
+# Connection_Status_Reason
+CONNECTION_STATUS_REASON_NONE_SPECIFIED = 0
+CONNECTION_STATUS_REASON_REQUESTED = 1
+CONNECTION_STATUS_REASON_NETWORK_ERROR = 2
+CONNECTION_STATUS_REASON_AUTHENTICATION_FAILED = 3
+CONNECTION_STATUS_REASON_ENCRYPTION_ERROR = 4
+CONNECTION_STATUS_REASON_NAME_IN_USE = 5
+CONNECTION_STATUS_REASON_CERT_NOT_PROVIDED = 6
+CONNECTION_STATUS_REASON_CERT_UNTRUSTED = 7
+CONNECTION_STATUS_REASON_CERT_EXPIRED = 8
+CONNECTION_STATUS_REASON_CERT_NOT_ACTIVATED = 9
+CONNECTION_STATUS_REASON_CERT_HOSTNAME_MISMATCH = 10
+CONNECTION_STATUS_REASON_CERT_FINGERPRINT_MISMATCH = 11
+CONNECTION_STATUS_REASON_CERT_SELF_SIGNED = 12
+CONNECTION_STATUS_REASON_CERT_OTHER_ERROR = 13
+LAST_CONNECTION_STATUS_REASON = 13
+# Connection_Alias_Flags (bitfield/set of flags, 0 for none)
+CONNECTION_ALIAS_FLAG_USER_SET = 1
+
+
+# Connection_Capability_Flags (bitfield/set of flags, 0 for none)
+CONNECTION_CAPABILITY_FLAG_CREATE = 1
+CONNECTION_CAPABILITY_FLAG_INVITE = 2
+
+
+# Contact_Info_Flag
+CONTACT_INFO_FLAG_CAN_SET = 1
+CONTACT_INFO_FLAG_PUSH = 2
+LAST_CONTACT_INFO_FLAG = 2
+# Contact_Info_Field_Flags (bitfield/set of flags, 0 for none)
+CONTACT_INFO_FIELD_FLAG_PARAMETERS_MANDATORY = 1
+
+
+# Connection_Presence_Type
+CONNECTION_PRESENCE_TYPE_UNSET = 0
+CONNECTION_PRESENCE_TYPE_OFFLINE = 1
+CONNECTION_PRESENCE_TYPE_AVAILABLE = 2
+CONNECTION_PRESENCE_TYPE_AWAY = 3
+CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY = 4
+CONNECTION_PRESENCE_TYPE_HIDDEN = 5
+CONNECTION_PRESENCE_TYPE_BUSY = 6
+CONNECTION_PRESENCE_TYPE_UNKNOWN = 7
+CONNECTION_PRESENCE_TYPE_ERROR = 8
+LAST_CONNECTION_PRESENCE_TYPE = 8
+# Rich_Presence_Access_Control_Type
+RICH_PRESENCE_ACCESS_CONTROL_TYPE_WHITELIST = 0
+RICH_PRESENCE_ACCESS_CONTROL_TYPE_PUBLISH_LIST = 1
+RICH_PRESENCE_ACCESS_CONTROL_TYPE_GROUP = 2
+RICH_PRESENCE_ACCESS_CONTROL_TYPE_OPEN = 3
+LAST_RICH_PRESENCE_ACCESS_CONTROL_TYPE = 3
+# Media_Stream_Type
+MEDIA_STREAM_TYPE_AUDIO = 0
+MEDIA_STREAM_TYPE_VIDEO = 1
+LAST_MEDIA_STREAM_TYPE = 1
+# Media_Stream_State
+MEDIA_STREAM_STATE_DISCONNECTED = 0
+MEDIA_STREAM_STATE_CONNECTING = 1
+MEDIA_STREAM_STATE_CONNECTED = 2
+LAST_MEDIA_STREAM_STATE = 2
+# Media_Stream_Direction
+MEDIA_STREAM_DIRECTION_NONE = 0
+MEDIA_STREAM_DIRECTION_SEND = 1
+MEDIA_STREAM_DIRECTION_RECEIVE = 2
+MEDIA_STREAM_DIRECTION_BIDIRECTIONAL = 3
+LAST_MEDIA_STREAM_DIRECTION = 3
+# Media_Stream_Pending_Send (bitfield/set of flags, 0 for none)
+MEDIA_STREAM_PENDING_LOCAL_SEND = 1
+MEDIA_STREAM_PENDING_REMOTE_SEND = 2
+
+
+# Channel_Media_Capabilities (bitfield/set of flags, 0 for none)
+CHANNEL_MEDIA_CAPABILITY_AUDIO = 1
+CHANNEL_MEDIA_CAPABILITY_VIDEO = 2
+CHANNEL_MEDIA_CAPABILITY_NAT_TRAVERSAL_STUN = 4
+CHANNEL_MEDIA_CAPABILITY_NAT_TRAVERSAL_GTALK_P2P = 8
+CHANNEL_MEDIA_CAPABILITY_NAT_TRAVERSAL_ICE_UDP = 16
+CHANNEL_MEDIA_CAPABILITY_IMMUTABLE_STREAMS = 32
+
+
+# Channel_Text_Send_Error
+CHANNEL_TEXT_SEND_ERROR_UNKNOWN = 0
+CHANNEL_TEXT_SEND_ERROR_OFFLINE = 1
+CHANNEL_TEXT_SEND_ERROR_INVALID_CONTACT = 2
+CHANNEL_TEXT_SEND_ERROR_PERMISSION_DENIED = 3
+CHANNEL_TEXT_SEND_ERROR_TOO_LONG = 4
+CHANNEL_TEXT_SEND_ERROR_NOT_IMPLEMENTED = 5
+LAST_CHANNEL_TEXT_SEND_ERROR = 5
+# Channel_Text_Message_Type
+CHANNEL_TEXT_MESSAGE_TYPE_NORMAL = 0
+CHANNEL_TEXT_MESSAGE_TYPE_ACTION = 1
+CHANNEL_TEXT_MESSAGE_TYPE_NOTICE = 2
+CHANNEL_TEXT_MESSAGE_TYPE_AUTO_REPLY = 3
+CHANNEL_TEXT_MESSAGE_TYPE_DELIVERY_REPORT = 4
+LAST_CHANNEL_TEXT_MESSAGE_TYPE = 4
+# Channel_Text_Message_Flags (bitfield/set of flags, 0 for none)
+CHANNEL_TEXT_MESSAGE_FLAG_TRUNCATED = 1
+CHANNEL_TEXT_MESSAGE_FLAG_NON_TEXT_CONTENT = 2
+CHANNEL_TEXT_MESSAGE_FLAG_SCROLLBACK = 4
+CHANNEL_TEXT_MESSAGE_FLAG_RESCUED = 8
+
+
+# Tube_Type
+TUBE_TYPE_DBUS = 0
+TUBE_TYPE_STREAM = 1
+LAST_TUBE_TYPE = 1
+# Tube_State
+TUBE_STATE_LOCAL_PENDING = 0
+TUBE_STATE_REMOTE_PENDING = 1
+TUBE_STATE_OPEN = 2
+LAST_TUBE_STATE = 2
+# File_Transfer_State
+FILE_TRANSFER_STATE_NONE = 0
+FILE_TRANSFER_STATE_PENDING = 1
+FILE_TRANSFER_STATE_ACCEPTED = 2
+FILE_TRANSFER_STATE_OPEN = 3
+FILE_TRANSFER_STATE_COMPLETED = 4
+FILE_TRANSFER_STATE_CANCELLED = 5
+LAST_FILE_TRANSFER_STATE = 5
+# File_Transfer_State_Change_Reason
+FILE_TRANSFER_STATE_CHANGE_REASON_NONE = 0
+FILE_TRANSFER_STATE_CHANGE_REASON_REQUESTED = 1
+FILE_TRANSFER_STATE_CHANGE_REASON_LOCAL_STOPPED = 2
+FILE_TRANSFER_STATE_CHANGE_REASON_REMOTE_STOPPED = 3
+FILE_TRANSFER_STATE_CHANGE_REASON_LOCAL_ERROR = 4
+FILE_TRANSFER_STATE_CHANGE_REASON_REMOTE_ERROR = 5
+LAST_FILE_TRANSFER_STATE_CHANGE_REASON = 5
+# File_Hash_Type
+FILE_HASH_TYPE_NONE = 0
+FILE_HASH_TYPE_MD5 = 1
+FILE_HASH_TYPE_SHA1 = 2
+FILE_HASH_TYPE_SHA256 = 3
+LAST_FILE_HASH_TYPE = 3
+# Channel_Contact_Search_State
+CHANNEL_CONTACT_SEARCH_STATE_NOT_STARTED = 0
+CHANNEL_CONTACT_SEARCH_STATE_IN_PROGRESS = 1
+CHANNEL_CONTACT_SEARCH_STATE_MORE_AVAILABLE = 2
+CHANNEL_CONTACT_SEARCH_STATE_COMPLETED = 3
+CHANNEL_CONTACT_SEARCH_STATE_FAILED = 4
+LAST_CHANNEL_CONTACT_SEARCH_STATE = 4
+# Call_State
+CALL_STATE_UNKNOWN = 0
+CALL_STATE_PENDING_INITIATOR = 1
+CALL_STATE_PENDING_RECEIVER = 2
+CALL_STATE_ACCEPTED = 3
+CALL_STATE_ENDED = 4
+LAST_CALL_STATE = 4
+# Call_Flags (bitfield/set of flags, 0 for none)
+CALL_FLAG_LOCALLY_RINGING = 1
+CALL_FLAG_QUEUED = 2
+CALL_FLAG_LOCALLY_HELD = 4
+CALL_FLAG_FORWARDED = 8
+CALL_FLAG_IN_PROGRESS = 16
+CALL_FLAG_CLEARING = 32
+
+
+# Call_State_Change_Reason
+CALL_STATE_CHANGE_REASON_UNKNOWN = 0
+CALL_STATE_CHANGE_REASON_USER_REQUESTED = 1
+LAST_CALL_STATE_CHANGE_REASON = 1
+# Call_Member_Flags (bitfield/set of flags, 0 for none)
+CALL_MEMBER_FLAG_RINGING = 1
+CALL_MEMBER_FLAG_HELD = 2
+
+
+# Channel_Call_State_Flags (bitfield/set of flags, 0 for none)
+CHANNEL_CALL_STATE_RINGING = 1
+CHANNEL_CALL_STATE_QUEUED = 2
+CHANNEL_CALL_STATE_HELD = 4
+CHANNEL_CALL_STATE_FORWARDED = 8
+CHANNEL_CALL_STATE_IN_PROGRESS = 16
+
+
+# Channel_Chat_State
+CHANNEL_CHAT_STATE_GONE = 0
+CHANNEL_CHAT_STATE_INACTIVE = 1
+CHANNEL_CHAT_STATE_ACTIVE = 2
+CHANNEL_CHAT_STATE_PAUSED = 3
+CHANNEL_CHAT_STATE_COMPOSING = 4
+LAST_CHANNEL_CHAT_STATE = 4
+# DTMF_Event
+DTMF_EVENT_DIGIT_0 = 0
+DTMF_EVENT_DIGIT_1 = 1
+DTMF_EVENT_DIGIT_2 = 2
+DTMF_EVENT_DIGIT_3 = 3
+DTMF_EVENT_DIGIT_4 = 4
+DTMF_EVENT_DIGIT_5 = 5
+DTMF_EVENT_DIGIT_6 = 6
+DTMF_EVENT_DIGIT_7 = 7
+DTMF_EVENT_DIGIT_8 = 8
+DTMF_EVENT_DIGIT_9 = 9
+DTMF_EVENT_ASTERISK = 10
+DTMF_EVENT_HASH = 11
+DTMF_EVENT_LETTER_A = 12
+DTMF_EVENT_LETTER_B = 13
+DTMF_EVENT_LETTER_C = 14
+DTMF_EVENT_LETTER_D = 15
+LAST_DTMF_EVENT = 15
+# Channel_Group_Flags (bitfield/set of flags, 0 for none)
+CHANNEL_GROUP_FLAG_CAN_ADD = 1
+CHANNEL_GROUP_FLAG_CAN_REMOVE = 2
+CHANNEL_GROUP_FLAG_CAN_RESCIND = 4
+CHANNEL_GROUP_FLAG_MESSAGE_ADD = 8
+CHANNEL_GROUP_FLAG_MESSAGE_REMOVE = 16
+CHANNEL_GROUP_FLAG_MESSAGE_ACCEPT = 32
+CHANNEL_GROUP_FLAG_MESSAGE_REJECT = 64
+CHANNEL_GROUP_FLAG_MESSAGE_RESCIND = 128
+CHANNEL_GROUP_FLAG_CHANNEL_SPECIFIC_HANDLES = 256
+CHANNEL_GROUP_FLAG_ONLY_ONE_GROUP = 512
+CHANNEL_GROUP_FLAG_HANDLE_OWNERS_NOT_AVAILABLE = 1024
+CHANNEL_GROUP_FLAG_PROPERTIES = 2048
+CHANNEL_GROUP_FLAG_MEMBERS_CHANGED_DETAILED = 4096
+CHANNEL_GROUP_FLAG_MESSAGE_DEPART = 8192
+
+
+# Channel_Group_Change_Reason
+CHANNEL_GROUP_CHANGE_REASON_NONE = 0
+CHANNEL_GROUP_CHANGE_REASON_OFFLINE = 1
+CHANNEL_GROUP_CHANGE_REASON_KICKED = 2
+CHANNEL_GROUP_CHANGE_REASON_BUSY = 3
+CHANNEL_GROUP_CHANGE_REASON_INVITED = 4
+CHANNEL_GROUP_CHANGE_REASON_BANNED = 5
+CHANNEL_GROUP_CHANGE_REASON_ERROR = 6
+CHANNEL_GROUP_CHANGE_REASON_INVALID_CONTACT = 7
+CHANNEL_GROUP_CHANGE_REASON_NO_ANSWER = 8
+CHANNEL_GROUP_CHANGE_REASON_RENAMED = 9
+CHANNEL_GROUP_CHANGE_REASON_PERMISSION_DENIED = 10
+CHANNEL_GROUP_CHANGE_REASON_SEPARATED = 11
+LAST_CHANNEL_GROUP_CHANGE_REASON = 11
+# Local_Hold_State
+LOCAL_HOLD_STATE_UNHELD = 0
+LOCAL_HOLD_STATE_HELD = 1
+LOCAL_HOLD_STATE_PENDING_HOLD = 2
+LOCAL_HOLD_STATE_PENDING_UNHOLD = 3
+LAST_LOCAL_HOLD_STATE = 3
+# Local_Hold_State_Reason
+LOCAL_HOLD_STATE_REASON_NONE = 0
+LOCAL_HOLD_STATE_REASON_REQUESTED = 1
+LOCAL_HOLD_STATE_REASON_RESOURCE_NOT_AVAILABLE = 2
+LAST_LOCAL_HOLD_STATE_REASON = 2
+# Channel_Password_Flags (bitfield/set of flags, 0 for none)
+CHANNEL_PASSWORD_FLAG_PROVIDE = 8
+
+
+# Message_Part_Support_Flags (bitfield/set of flags, 0 for none)
+MESSAGE_PART_SUPPORT_FLAG_ONE_ATTACHMENT = 1
+MESSAGE_PART_SUPPORT_FLAG_MULTIPLE_ATTACHMENTS = 2
+
+
+# Message_Sending_Flags (bitfield/set of flags, 0 for none)
+MESSAGE_SENDING_FLAG_REPORT_DELIVERY = 1
+
+
+# Delivery_Status
+DELIVERY_STATUS_UNKNOWN = 0
+DELIVERY_STATUS_DELIVERED = 1
+DELIVERY_STATUS_TEMPORARILY_FAILED = 2
+DELIVERY_STATUS_PERMANENTLY_FAILED = 3
+DELIVERY_STATUS_ACCEPTED = 4
+LAST_DELIVERY_STATUS = 4
+# Delivery_Reporting_Support_Flags (bitfield/set of flags, 0 for none)
+DELIVERY_REPORTING_SUPPORT_FLAG_RECEIVE_FAILURES = 1
+DELIVERY_REPORTING_SUPPORT_FLAG_RECEIVE_SUCCESSES = 2
+
+
+# Tube_Channel_State
+TUBE_CHANNEL_STATE_LOCAL_PENDING = 0
+TUBE_CHANNEL_STATE_REMOTE_PENDING = 1
+TUBE_CHANNEL_STATE_OPEN = 2
+TUBE_CHANNEL_STATE_NOT_OFFERED = 3
+LAST_TUBE_CHANNEL_STATE = 3
+# Socket_Address_Type
+SOCKET_ADDRESS_TYPE_UNIX = 0
+SOCKET_ADDRESS_TYPE_ABSTRACT_UNIX = 1
+SOCKET_ADDRESS_TYPE_IPV4 = 2
+SOCKET_ADDRESS_TYPE_IPV6 = 3
+LAST_SOCKET_ADDRESS_TYPE = 3
+# Socket_Access_Control
+SOCKET_ACCESS_CONTROL_LOCALHOST = 0
+SOCKET_ACCESS_CONTROL_PORT = 1
+SOCKET_ACCESS_CONTROL_NETMASK = 2
+SOCKET_ACCESS_CONTROL_CREDENTIALS = 3
+LAST_SOCKET_ACCESS_CONTROL = 3
+# Media_Stream_Error
+MEDIA_STREAM_ERROR_UNKNOWN = 0
+MEDIA_STREAM_ERROR_EOS = 1
+MEDIA_STREAM_ERROR_CODEC_NEGOTIATION_FAILED = 2
+MEDIA_STREAM_ERROR_CONNECTION_FAILED = 3
+MEDIA_STREAM_ERROR_NETWORK_ERROR = 4
+MEDIA_STREAM_ERROR_NO_CODECS = 5
+MEDIA_STREAM_ERROR_INVALID_CM_BEHAVIOR = 6
+MEDIA_STREAM_ERROR_MEDIA_ERROR = 7
+LAST_MEDIA_STREAM_ERROR = 7
+# Media_Stream_Base_Proto
+MEDIA_STREAM_BASE_PROTO_UDP = 0
+MEDIA_STREAM_BASE_PROTO_TCP = 1
+LAST_MEDIA_STREAM_BASE_PROTO = 1
+# Media_Stream_Transport_Type
+MEDIA_STREAM_TRANSPORT_TYPE_LOCAL = 0
+MEDIA_STREAM_TRANSPORT_TYPE_DERIVED = 1
+MEDIA_STREAM_TRANSPORT_TYPE_RELAY = 2
+LAST_MEDIA_STREAM_TRANSPORT_TYPE = 2
+# Call_Content_Disposition
+CALL_CONTENT_DISPOSITION_NONE = 0
+CALL_CONTENT_DISPOSITION_EARLY_MEDIA = 1
+CALL_CONTENT_DISPOSITION_INITIAL = 2
+LAST_CALL_CONTENT_DISPOSITION = 2
+# Sending_State
+SENDING_STATE_NONE = 0
+SENDING_STATE_PENDING_SEND = 1
+SENDING_STATE_SENDING = 2
+LAST_SENDING_STATE = 2
+# Stream_Transport_Type
+STREAM_TRANSPORT_TYPE_RAW_UDP = 0
+STREAM_TRANSPORT_TYPE_ICE = 1
+STREAM_TRANSPORT_TYPE_GTALK_P2P = 2
+STREAM_TRANSPORT_TYPE_WLM_8_5 = 3
+STREAM_TRANSPORT_TYPE_WLM_2009 = 4
+LAST_STREAM_TRANSPORT_TYPE = 4
+# Debug_Level
+DEBUG_LEVEL_ERROR = 0
+DEBUG_LEVEL_CRITICAL = 1
+DEBUG_LEVEL_WARNING = 2
+DEBUG_LEVEL_MESSAGE = 3
+DEBUG_LEVEL_INFO = 4
+DEBUG_LEVEL_DEBUG = 5
+LAST_DEBUG_LEVEL = 5
+# Property_Flags (bitfield/set of flags, 0 for none)
+PROPERTY_FLAG_READ = 1
+PROPERTY_FLAG_WRITE = 2
+
--- /dev/null
+# -*- coding: utf-8 -*-
+
+"""Exception classes, generated from the Telepathy spec
+
+Copyright © 2005-2009 Collabora Limited
+Copyright © 2005-2009 Nokia Corporation
+
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+
+from dbus import DBusException
+
+__all__ = (
+"NetworkError",
+"NotImplemented",
+"InvalidArgument",
+"NotAvailable",
+"PermissionDenied",
+"Disconnected",
+"InvalidHandle",
+"ChannelBanned",
+"ChannelFull",
+"ChannelInviteOnly",
+"NotYours",
+"Cancelled",
+"AuthenticationFailed",
+"EncryptionNotAvailable",
+"EncryptionError",
+"CertNotProvided",
+"CertUntrusted",
+"CertExpired",
+"CertNotActivated",
+"CertFingerprintMismatch",
+"CertHostnameMismatch",
+"CertSelfSigned",
+"CertInvalid",
+"NotCapable",
+"Offline",
+"ChannelKicked",
+"Busy",
+"NoAnswer",
+"DoesNotExist",
+"Terminated",
+"ConnectionRefused",
+"ConnectionFailed",
+"ConnectionLost",
+"AlreadyConnected",
+"ConnectionReplaced",
+"RegistrationExists",
+"ServiceBusy",
+"ResourceUnavailable",
+)
+
+
+class NetworkError(DBusException):
+ """\
+ Raised when there is an error reading from or writing to the network.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.NetworkError'
+
+class NotImplemented(DBusException):
+ """\
+ Raised when the requested method, channel, etc is not available on this connection.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.NotImplemented'
+
+class InvalidArgument(DBusException):
+ """\
+ Raised when one of the provided arguments is invalid.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.InvalidArgument'
+
+class NotAvailable(DBusException):
+ """\
+ Raised when the requested functionality is temporarily unavailable.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.NotAvailable'
+
+class PermissionDenied(DBusException):
+ """\
+ The user is not permitted to perform the requested operation.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.PermissionDenied'
+
+class Disconnected(DBusException):
+ """\
+ The connection is not currently connected and cannot be used.
+ This error may also be raised when operations are performed on a
+ Connection for which
+ StatusChanged
+ has signalled status Disconnected for reason None.
+
+
+ The second usage corresponds to None in the
+ Connection_Status_Reason enum; if a better reason
+ is available, the corresponding error should be used instead.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Disconnected'
+
+class InvalidHandle(DBusException):
+ """\
+ The handle specified is unknown on this channel or connection.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.InvalidHandle'
+
+class ChannelBanned(DBusException):
+ """\
+ You are banned from the channel.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Channel.Banned'
+
+class ChannelFull(DBusException):
+ """\
+ The channel is full.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Channel.Full'
+
+class ChannelInviteOnly(DBusException):
+ """\
+ The requested channel is invite-only.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Channel.InviteOnly'
+
+class NotYours(DBusException):
+ """\
+ The requested channel or other resource already exists, and another
+ user interface in this session is responsible for it.
+
+ User interfaces SHOULD handle this error unobtrusively, since it
+ indicates that some other user interface is already processing the
+ channel.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.NotYours'
+
+class Cancelled(DBusException):
+ """\
+ Raised by an ongoing request if it is cancelled by user request before
+ it has completed, or when operations are performed on an object which
+ the user has asked to close (for instance, a Connection where the user
+ has called Disconnect, or a Channel where the user has called Close).
+
+
+ The second form can be used to correspond to the Requested member in
+ the Connection_Status_Reason enum, or to
+ to represent the situation where disconnecting a Connection,
+ closing a Channel, etc. has been requested by the user but this
+ request has not yet been acted on, for instance because the
+ service will only act on the request when it has finished processing
+ an event queue.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cancelled'
+
+class AuthenticationFailed(DBusException):
+ """\
+ Raised when authentication with a service was unsuccessful.
+
+ This corresponds to Authentication_Failed in the
+ Connection_Status_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.AuthenticationFailed'
+
+class EncryptionNotAvailable(DBusException):
+ """\
+ Raised if a user request insisted that encryption should be used,
+ but encryption was not actually available.
+
+
+ This corresponds to part of Encryption_Error in the
+ Connection_Status_Reason enum. It's been separated
+ into a distinct error here because the two concepts that were part
+ of EncryptionError seem to be things that could reasonably appear
+ differently in the UI.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.EncryptionNotAvailable'
+
+class EncryptionError(DBusException):
+ """\
+ Raised if encryption appears to be available, but could not actually be
+ used (for instance if SSL/TLS negotiation fails).
+
+ This corresponds to part of Encryption_Error in the
+ Connection_Status_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.EncryptionError'
+
+class CertNotProvided(DBusException):
+ """\
+ Raised if the server did not provide a SSL/TLS certificate. This error
+ MUST NOT be used to represent the absence of a client certificate
+ provided by the Telepathy connection manager.
+
+ This corresponds to Cert_Not_Provided in the
+ Connection_Status_Reason enum. That error
+ explicitly applied only to server SSL certificates, so this one
+ is similarly limited; having the CM present a client certificate
+ is a possible future feature, but it should have its own error
+ handling.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cert.NotProvided'
+
+class CertUntrusted(DBusException):
+ """\
+ Raised if the server provided a SSL/TLS certificate signed by an
+ untrusted certifying authority. This error SHOULD NOT be used to
+ represent a self-signed certificate: see the Self Signed error for that.
+
+ This corresponds to Cert_Untrusted in the
+ Connection_Status_Reason enum, with a clarification
+ to avoid ambiguity.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cert.Untrusted'
+
+class CertExpired(DBusException):
+ """\
+ Raised if the server provided an expired SSL/TLS certificate.
+
+ This corresponds to Cert_Expired in the
+ Connection_Status_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cert.Expired'
+
+class CertNotActivated(DBusException):
+ """\
+ Raised if the server provided an SSL/TLS certificate that will become
+ valid at some point in the future.
+
+ This corresponds to Cert_Not_Activated in the
+ Connection_Status_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cert.NotActivated'
+
+class CertFingerprintMismatch(DBusException):
+ """\
+ Raised if the server provided an SSL/TLS certificate that did not have
+ the expected fingerprint.
+
+ This corresponds to Cert_Fingerprint_Mismatch in the
+ Connection_Status_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cert.FingerprintMismatch'
+
+class CertHostnameMismatch(DBusException):
+ """\
+ Raised if the server provided an SSL/TLS certificate that did not match
+ its hostname.
+
+ This corresponds to Cert_Hostname_Mismatch in the
+ Connection_Status_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cert.HostnameMismatch'
+
+class CertSelfSigned(DBusException):
+ """\
+ Raised if the server provided an SSL/TLS certificate that is self-signed
+ and untrusted.
+
+ This corresponds to Cert_Hostname_Mismatch in the
+ Connection_Status_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cert.SelfSigned'
+
+class CertInvalid(DBusException):
+ """\
+ Raised if the server provided an SSL/TLS certificate that is
+ unacceptable in some way that does not have a more specific error.
+
+ This corresponds to Cert_Other_Error in the
+ Connection_Status_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Cert.Invalid'
+
+class NotCapable(DBusException):
+ """\
+ Raised when requested functionality is unavailable due to contact
+ not having required capabilities.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.NotCapable'
+
+class Offline(DBusException):
+ """\
+ Raised when requested functionality is unavailable because a contact is
+ offline.
+
+
+ This corresponds to Offline in the
+ Channel_Group_Change_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Offline'
+
+class ChannelKicked(DBusException):
+ """\
+ Used to represent a user being ejected from a channel by another user,
+ for instance being kicked from a chatroom.
+
+
+ This corresponds to Kicked in the
+ Channel_Group_Change_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Channel.Kicked'
+
+class Busy(DBusException):
+ """\
+ Used to represent a user being removed from a channel because of a
+ "busy" indication. This error SHOULD NOT be used to represent a server
+ or other infrastructure being too busy to process a request - for that,
+ see ServerBusy.
+
+
+ This corresponds to Busy in the
+ Channel_Group_Change_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Busy'
+
+class NoAnswer(DBusException):
+ """\
+ Used to represent a user being removed from a channel because they did
+ not respond, e.g. to a StreamedMedia call.
+
+
+ This corresponds to No_Answer in the
+ Channel_Group_Change_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.NoAnswer'
+
+class DoesNotExist(DBusException):
+ """\
+ Raised when the requested user does not, in fact, exist.
+
+
+ This corresponds to Invalid_Contact in the
+ Channel_Group_Change_Reason enum, but can also be
+ used to represent other things not existing (like chatrooms, perhaps).
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.DoesNotExist'
+
+class Terminated(DBusException):
+ """\
+ Raised when a channel is terminated for an unspecified reason. In
+ particular, this error SHOULD be used whenever normal termination of
+ a 1-1 StreamedMedia call by the remote user is represented as a D-Bus
+ error name.
+
+
+ This corresponds to None in the
+ Channel_Group_Change_Reason enum.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.Terminated'
+
+class ConnectionRefused(DBusException):
+ """\
+ Raised when a connection is refused.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.ConnectionRefused'
+
+class ConnectionFailed(DBusException):
+ """\
+ Raised when a connection can't be established.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.ConnectionFailed'
+
+class ConnectionLost(DBusException):
+ """\
+ Raised when a connection is broken.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.ConnectionLost'
+
+class AlreadyConnected(DBusException):
+ """\
+ Raised when the user attempts to connect to an account but they are
+ already connected (perhaps from another client or computer), and the
+ protocol or account settings do not allow this.
+
+
+ XMPP can have this behaviour if the user chooses the same resource
+ in both clients (it is server-dependent whether the result is
+ AlreadyConnected on the new connection, ConnectionReplaced on the
+ old connection, or two successful connections).
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.AlreadyConnected'
+
+class ConnectionReplaced(DBusException):
+ """\
+ Raised by an existing connection to an account if it is replaced by
+ a new connection (perhaps from another client or computer).
+
+
+ In MSNP, when connecting twice with the same Passport, the new
+ connection "wins" and the old one is automatically disconnected.
+ XMPP can also have this behaviour if the user chooses the same
+ resource in two clients (it is server-dependent whether the result is
+ AlreadyConnected on the new connection, ConnectionReplaced on the
+ old connection, or two successful connections).
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.ConnectionReplaced'
+
+class RegistrationExists(DBusException):
+ """\
+ Raised during in-band registration if the server indicates that the
+ requested account already exists.
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.RegistrationExists'
+
+class ServiceBusy(DBusException):
+ """\
+ Raised if a server or some other piece of infrastructure cannot process
+ the request, e.g. due to resource limitations. Clients MAY try again
+ later.
+
+
+ This is not the same error as Busy, which indicates that a
+ user is busy.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.ServiceBusy'
+
+class ResourceUnavailable(DBusException):
+ """\
+ Raised if a request cannot be satisfied because a process local to the
+ user has insufficient resources. Clients MAY try again
+ later.
+
+
+ For instance, the ChannelDispatcher
+ might raise this error for some or all channel requests if it has
+ detected that there is not enough free memory.
+
+
+ """
+ _dbus_error_name = 'org.freedesktop.Telepathy.Error.ResourceUnavailable'
+
\ No newline at end of file
--- /dev/null
+# -*- coding: utf-8 -*-
+"""List of interfaces, generated from the Telepathy spec version 0.19.0
+
+Copyright © 2005-2009 Collabora Limited
+Copyright © 2005-2009 Nokia Corporation
+Copyright © 2006 INdT
+
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+
+"""
+CONNECTION_MANAGER = 'org.freedesktop.Telepathy.ConnectionManager'
+CONNECTION = 'org.freedesktop.Telepathy.Connection'
+CONNECTION_FUTURE = 'org.freedesktop.Telepathy.Connection.FUTURE'
+CONNECTION_INTERFACE_ALIASING = 'org.freedesktop.Telepathy.Connection.Interface.Aliasing'
+CONNECTION_INTERFACE_AVATARS = 'org.freedesktop.Telepathy.Connection.Interface.Avatars'
+CONNECTION_INTERFACE_BALANCE = 'org.freedesktop.Telepathy.Connection.Interface.Balance'
+CONNECTION_INTERFACE_CAPABILITIES = 'org.freedesktop.Telepathy.Connection.Interface.Capabilities'
+CONNECTION_INTERFACE_CONTACT_CAPABILITIES = 'org.freedesktop.Telepathy.Connection.Interface.ContactCapabilities'
+CONNECTION_INTERFACE_CONTACT_INFO = 'org.freedesktop.Telepathy.Connection.Interface.ContactInfo.DRAFT'
+CONNECTION_INTERFACE_CONTACTS = 'org.freedesktop.Telepathy.Connection.Interface.Contacts'
+CONNECTION_INTERFACE_LOCATION = 'org.freedesktop.Telepathy.Connection.Interface.Location'
+CONNECTION_INTERFACE_PRESENCE = 'org.freedesktop.Telepathy.Connection.Interface.Presence'
+CONNECTION_INTERFACE_RENAMING = 'org.freedesktop.Telepathy.Connection.Interface.Renaming'
+CONNECTION_INTERFACE_REQUESTS = 'org.freedesktop.Telepathy.Connection.Interface.Requests'
+CONNECTION_INTERFACE_SIMPLE_PRESENCE = 'org.freedesktop.Telepathy.Connection.Interface.SimplePresence'
+CHANNEL_BUNDLE = 'org.freedesktop.Telepathy.ChannelBundle.DRAFT'
+CHANNEL = 'org.freedesktop.Telepathy.Channel'
+CHANNEL_FUTURE = 'org.freedesktop.Telepathy.Channel.FUTURE'
+CHANNEL_TYPE_CONTACT_LIST = 'org.freedesktop.Telepathy.Channel.Type.ContactList'
+CHANNEL_TYPE_STREAMED_MEDIA = 'org.freedesktop.Telepathy.Channel.Type.StreamedMedia'
+CHANNEL_TYPE_ROOM_LIST = 'org.freedesktop.Telepathy.Channel.Type.RoomList'
+CHANNEL_TYPE_TEXT = 'org.freedesktop.Telepathy.Channel.Type.Text'
+CHANNEL_TYPE_TUBES = 'org.freedesktop.Telepathy.Channel.Type.Tubes'
+CHANNEL_TYPE_STREAM_TUBE = 'org.freedesktop.Telepathy.Channel.Type.StreamTube'
+CHANNEL_TYPE_DBUS_TUBE = 'org.freedesktop.Telepathy.Channel.Type.DBusTube'
+CHANNEL_TYPE_FILE_TRANSFER = 'org.freedesktop.Telepathy.Channel.Type.FileTransfer'
+CHANNEL_TYPE_CONTACT_SEARCH = 'org.freedesktop.Telepathy.Channel.Type.ContactSearch.DRAFT2'
+CHANNEL_TYPE_CALL = 'org.freedesktop.Telepathy.Channel.Type.Call.DRAFT'
+CHANNEL_INTERFACE_CALL_STATE = 'org.freedesktop.Telepathy.Channel.Interface.CallState'
+CHANNEL_INTERFACE_CHAT_STATE = 'org.freedesktop.Telepathy.Channel.Interface.ChatState'
+CHANNEL_INTERFACE_CONFERENCE = 'org.freedesktop.Telepathy.Channel.Interface.Conference.DRAFT'
+CHANNEL_INTERFACE_DESTROYABLE = 'org.freedesktop.Telepathy.Channel.Interface.Destroyable'
+CHANNEL_INTERFACE_DTMF = 'org.freedesktop.Telepathy.Channel.Interface.DTMF'
+CHANNEL_INTERFACE_GROUP = 'org.freedesktop.Telepathy.Channel.Interface.Group'
+CHANNEL_INTERFACE_HOLD = 'org.freedesktop.Telepathy.Channel.Interface.Hold'
+CHANNEL_INTERFACE_HTML = 'org.freedesktop.Telepathy.Channel.Interface.HTML.DRAFT'
+CHANNEL_INTERFACE_PASSWORD = 'org.freedesktop.Telepathy.Channel.Interface.Password'
+CHANNEL_INTERFACE_MEDIA_SIGNALLING = 'org.freedesktop.Telepathy.Channel.Interface.MediaSignalling'
+CHANNEL_INTERFACE_MERGEABLE_CONFERENCE = 'org.freedesktop.Telepathy.Channel.Interface.MergeableConference.DRAFT'
+CHANNEL_INTERFACE_MESSAGES = 'org.freedesktop.Telepathy.Channel.Interface.Messages'
+CHANNEL_INTERFACE_SPLITTABLE = 'org.freedesktop.Telepathy.Channel.Interface.Splittable.DRAFT'
+CHANNEL_INTERFACE_TUBE = 'org.freedesktop.Telepathy.Channel.Interface.Tube'
+MEDIA_SESSION_HANDLER = 'org.freedesktop.Telepathy.Media.SessionHandler'
+MEDIA_STREAM_HANDLER = 'org.freedesktop.Telepathy.Media.StreamHandler'
+CALL_CONTENT = 'org.freedesktop.Telepathy.Call.Content.DRAFT'
+CALL_CONTENT_INTERFACE_MEDIA = 'org.freedesktop.Telepathy.Call.Content.Interface.Media.DRAFT'
+CALL_CONTENT_CODEC_OFFER = 'org.freedesktop.Telepathy.Call.Content.CodecOffer.DRAFT'
+CALL_STREAM = 'org.freedesktop.Telepathy.Call.Stream.DRAFT'
+CALL_STREAM_INTERFACE_MEDIA = 'org.freedesktop.Telepathy.Call.Stream.Interface.Media.DRAFT'
+CALL_STREAM_ENDPOINT = 'org.freedesktop.Telepathy.Call.Stream.Endpoint.DRAFT'
+DEBUG = 'org.freedesktop.Telepathy.Debug'
+ACCOUNT_MANAGER = 'org.freedesktop.Telepathy.AccountManager'
+ACCOUNT = 'org.freedesktop.Telepathy.Account'
+ACCOUNT_INTERFACE_AVATAR = 'org.freedesktop.Telepathy.Account.Interface.Avatar'
+CHANNEL_DISPATCHER = 'org.freedesktop.Telepathy.ChannelDispatcher'
+CHANNEL_DISPATCHER_INTERFACE_OPERATION_LIST = 'org.freedesktop.Telepathy.ChannelDispatcher.Interface.OperationList'
+CHANNEL_DISPATCH_OPERATION = 'org.freedesktop.Telepathy.ChannelDispatchOperation'
+CHANNEL_REQUEST = 'org.freedesktop.Telepathy.ChannelRequest'
+CLIENT = 'org.freedesktop.Telepathy.Client'
+CLIENT_OBSERVER = 'org.freedesktop.Telepathy.Client.Observer'
+CLIENT_APPROVER = 'org.freedesktop.Telepathy.Client.Approver'
+CLIENT_HANDLER = 'org.freedesktop.Telepathy.Client.Handler'
+CLIENT_HANDLER_FUTURE = 'org.freedesktop.Telepathy.Client.Handler.FUTURE'
+CLIENT_INTERFACE_REQUESTS = 'org.freedesktop.Telepathy.Client.Interface.Requests'
+CHANNEL_HANDLER = 'org.freedesktop.Telepathy.ChannelHandler'
+PROPERTIES_INTERFACE = 'org.freedesktop.Telepathy.Properties'
MEDIA_SESSION_HANDLER,
MEDIA_STREAM_HANDLER)
-from telepathy._generated.Channel import Channel as _Channel
+from _generated.Channel import Channel as _Channel
from properties import DBusProperties
"""
return self._interfaces
-from telepathy._generated.Channel_Type_Contact_List \
+from _generated.Channel_Type_Contact_List \
import ChannelTypeContactList as _ChannelTypeContactListIface
class ChannelTypeContactList(Channel, _ChannelTypeContactListIface):
object_path=object_path)
-from telepathy._generated.Channel_Type_File_Transfer \
+from _generated.Channel_Type_File_Transfer \
import ChannelTypeFileTransfer as _ChannelTypeFileTransferIface
class ChannelTypeFileTransfer(Channel, _ChannelTypeFileTransferIface):
object_path=object_path)
-from telepathy._generated.Channel_Type_Streamed_Media \
+from _generated.Channel_Type_Streamed_Media \
import ChannelTypeStreamedMedia as _ChannelTypeStreamedMediaIface
class ChannelTypeStreamedMedia(Channel, _ChannelTypeStreamedMediaIface):
object_path=object_path)
-from telepathy._generated.Channel_Type_Room_List \
+from _generated.Channel_Type_Room_List \
import ChannelTypeRoomList as _ChannelTypeRoomListIface
class ChannelTypeRoomList(Channel, _ChannelTypeRoomListIface):
self._listing_rooms = listing
-from telepathy._generated.Channel_Type_Text \
+from _generated.Channel_Type_Text \
import ChannelTypeText as _ChannelTypeTextIface
class ChannelTypeText(Channel, _ChannelTypeTextIface):
self._pending_messages[id] = (timestamp, sender, type, flags, text)
-from telepathy._generated.Channel_Interface_Chat_State \
+from _generated.Channel_Interface_Chat_State \
import ChannelInterfaceChatState
-from telepathy._generated.Channel_Interface_DTMF import ChannelInterfaceDTMF
+from _generated.Channel_Interface_DTMF import ChannelInterfaceDTMF
-from telepathy._generated.Channel_Interface_Group \
+from _generated.Channel_Interface_Group \
import ChannelInterfaceGroup as _ChannelInterfaceGroup
class ChannelInterfaceGroup(_ChannelInterfaceGroup, DBusProperties):
self._remote_pending.difference_update(removed)
-from telepathy._generated.Channel_Interface_Hold import ChannelInterfaceHold
+from _generated.Channel_Interface_Hold import ChannelInterfaceHold
# ChannelInterfaceMediaSignalling is in telepathy.server.media
-from telepathy._generated.Channel_Interface_Password \
+from _generated.Channel_Interface_Password \
import ChannelInterfacePassword as _ChannelInterfacePassword
class ChannelInterfacePassword(_ChannelInterfacePassword):
self._password_flags &= ~removed
-from telepathy._generated.Channel_Interface_Call_State import ChannelInterfaceCallState
+from _generated.Channel_Interface_Call_State import ChannelInterfaceCallState
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-from telepathy._generated.Channel_Handler import ChannelHandler
+from _generated.Channel_Handler import ChannelHandler
from handle import Handle
from properties import DBusProperties
-from telepathy._generated.Connection import Connection as _Connection
+from _generated.Connection import Connection as _Connection
_BAD = re.compile(r'(?:^[0-9])|(?:[^A-Za-z0-9])')
return ret
-from telepathy._generated.Connection_Interface_Aliasing \
+from _generated.Connection_Interface_Aliasing \
import ConnectionInterfaceAliasing
-from telepathy._generated.Connection_Interface_Avatars \
+from _generated.Connection_Interface_Avatars \
import ConnectionInterfaceAvatars
-from telepathy._generated.Connection_Interface_Capabilities \
+from _generated.Connection_Interface_Capabilities \
import ConnectionInterfaceCapabilities \
as _ConnectionInterfaceCapabilities
# return all my capabilities
return [(ctype, caps[1]) for ctype, caps in my_caps.iteritems()]
-from telepathy._generated.Connection_Interface_Requests \
+from _generated.Connection_Interface_Requests \
import ConnectionInterfaceRequests \
as _ConnectionInterfaceRequests
self.signal_new_channels([channel])
-from telepathy._generated.Connection_Interface_Presence \
+from _generated.Connection_Interface_Presence \
import ConnectionInterfacePresence
-from telepathy._generated.Connection_Interface_Simple_Presence \
+from _generated.Connection_Interface_Simple_Presence \
import ConnectionInterfaceSimplePresence
-from telepathy._generated.Connection_Interface_Contacts \
+from _generated.Connection_Interface_Contacts \
import ConnectionInterfaceContacts
from telepathy.errors import NotImplemented
from telepathy.interfaces import CONN_MGR_INTERFACE
-from telepathy._generated.Connection_Manager \
+from _generated.Connection_Manager \
import ConnectionManager as _ConnectionManager
class ConnectionManager(_ConnectionManager):
DEBUG_LEVEL_INFO,
DEBUG_LEVEL_DEBUG)
-from telepathy._generated.Debug import Debug as _Debug
+from _generated.Debug import Debug as _Debug
from properties import DBusProperties
import dbus.service
from telepathy import *
-from telepathy._generated.Channel_Interface_Media_Signalling \
+from _generated.Channel_Interface_Media_Signalling \
import ChannelInterfaceMediaSignalling
-from telepathy._generated.Media_Session_Handler import MediaSessionHandler
-from telepathy._generated.Media_Stream_Handler import MediaStreamHandler
+from _generated.Media_Session_Handler import MediaSessionHandler
+from _generated.Media_Stream_Handler import MediaStreamHandler
from telepathy.interfaces import PROPERTIES_INTERFACE
import telepathy.errors
-from telepathy._generated.Properties_Interface import PropertiesInterface
+from _generated.Properties_Interface import PropertiesInterface
class DBusProperties(dbus.service.Interface):
def __init__(self):
projects / theonering / commitdiff