From c6c19d3806952ece8a1c0823cb2c55dac11db865 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Fri, 28 May 2010 19:55:53 -0500 Subject: [PATCH] Include _generated now so I get all the latest fancy stuff --- src/tp/__init__.py | 8 +- src/tp/_generated/Account.py | 174 +++++++ src/tp/_generated/Account_Interface_Avatar.py | 55 +++ src/tp/_generated/Account_Manager.py | 84 ++++ src/tp/_generated/Channel.py | 153 ++++++ src/tp/_generated/Channel_Dispatch_Operation.py | 262 ++++++++++ src/tp/_generated/Channel_Dispatcher.py | 153 ++++++ .../Channel_Dispatcher_Interface_Operation_List.py | 68 +++ src/tp/_generated/Channel_Handler.py | 37 ++ src/tp/_generated/Channel_Interface_Call_State.py | 57 +++ src/tp/_generated/Channel_Interface_Chat_State.py | 64 +++ src/tp/_generated/Channel_Interface_DTMF.py | 59 +++ src/tp/_generated/Channel_Interface_Destroyable.py | 78 +++ src/tp/_generated/Channel_Interface_Group.py | 317 ++++++++++++ src/tp/_generated/Channel_Interface_Hold.py | 119 +++++ .../Channel_Interface_Media_Signalling.py | 83 ++++ src/tp/_generated/Channel_Interface_Messages.py | 167 +++++++ src/tp/_generated/Channel_Interface_Password.py | 73 +++ src/tp/_generated/Channel_Interface_Tube.py | 72 +++ src/tp/_generated/Channel_Request.py | 131 +++++ src/tp/_generated/Channel_Type_Contact_List.py | 96 ++++ src/tp/_generated/Channel_Type_DBus_Tube.py | 87 ++++ src/tp/_generated/Channel_Type_File_Transfer.py | 148 ++++++ src/tp/_generated/Channel_Type_Room_List.py | 122 +++++ src/tp/_generated/Channel_Type_Stream_Tube.py | 89 ++++ src/tp/_generated/Channel_Type_Streamed_Media.py | 257 ++++++++++ src/tp/_generated/Channel_Type_Text.py | 236 +++++++++ src/tp/_generated/Channel_Type_Tubes.py | 178 +++++++ src/tp/_generated/Client.py | 101 ++++ src/tp/_generated/Client_Approver.py | 104 ++++ src/tp/_generated/Client_Handler.py | 104 ++++ src/tp/_generated/Client_Interface_Requests.py | 115 +++++ src/tp/_generated/Client_Observer.py | 128 +++++ src/tp/_generated/Connection.py | 348 ++++++++++++++ src/tp/_generated/Connection_Interface_Aliasing.py | 95 ++++ src/tp/_generated/Connection_Interface_Avatars.py | 170 +++++++ src/tp/_generated/Connection_Interface_Balance.py | 45 ++ .../Connection_Interface_Capabilities.py | 107 +++++ .../Connection_Interface_Contact_Capabilities.py | 118 +++++ src/tp/_generated/Connection_Interface_Contacts.py | 46 ++ src/tp/_generated/Connection_Interface_Location.py | 107 +++++ src/tp/_generated/Connection_Interface_Presence.py | 203 ++++++++ src/tp/_generated/Connection_Interface_Requests.py | 125 +++++ .../Connection_Interface_Simple_Presence.py | 173 +++++++ src/tp/_generated/Connection_Manager.py | 259 ++++++++++ src/tp/_generated/Debug.py | 51 ++ src/tp/_generated/Media_Session_Handler.py | 62 +++ src/tp/_generated/Media_Stream_Handler.py | 297 ++++++++++++ src/tp/_generated/Properties_Interface.py | 91 ++++ src/tp/_generated/__init__.py | 1 + src/tp/_generated/constants.py | 374 +++++++++++++++ src/tp/_generated/errors.py | 502 ++++++++++++++++++++ src/tp/_generated/interfaces.py | 89 ++++ src/tp/channel.py | 24 +- src/tp/channelhandler.py | 2 +- src/tp/conn.py | 16 +- src/tp/connmgr.py | 2 +- src/tp/debug.py | 2 +- src/tp/media.py | 6 +- src/tp/properties.py | 2 +- 60 files changed, 7265 insertions(+), 31 deletions(-) create mode 100644 src/tp/_generated/Account.py create mode 100644 src/tp/_generated/Account_Interface_Avatar.py create mode 100644 src/tp/_generated/Account_Manager.py create mode 100644 src/tp/_generated/Channel.py create mode 100644 src/tp/_generated/Channel_Dispatch_Operation.py create mode 100644 src/tp/_generated/Channel_Dispatcher.py create mode 100644 src/tp/_generated/Channel_Dispatcher_Interface_Operation_List.py create mode 100644 src/tp/_generated/Channel_Handler.py create mode 100644 src/tp/_generated/Channel_Interface_Call_State.py create mode 100644 src/tp/_generated/Channel_Interface_Chat_State.py create mode 100644 src/tp/_generated/Channel_Interface_DTMF.py create mode 100644 src/tp/_generated/Channel_Interface_Destroyable.py create mode 100644 src/tp/_generated/Channel_Interface_Group.py create mode 100644 src/tp/_generated/Channel_Interface_Hold.py create mode 100644 src/tp/_generated/Channel_Interface_Media_Signalling.py create mode 100644 src/tp/_generated/Channel_Interface_Messages.py create mode 100644 src/tp/_generated/Channel_Interface_Password.py create mode 100644 src/tp/_generated/Channel_Interface_Tube.py create mode 100644 src/tp/_generated/Channel_Request.py create mode 100644 src/tp/_generated/Channel_Type_Contact_List.py create mode 100644 src/tp/_generated/Channel_Type_DBus_Tube.py create mode 100644 src/tp/_generated/Channel_Type_File_Transfer.py create mode 100644 src/tp/_generated/Channel_Type_Room_List.py create mode 100644 src/tp/_generated/Channel_Type_Stream_Tube.py create mode 100644 src/tp/_generated/Channel_Type_Streamed_Media.py create mode 100644 src/tp/_generated/Channel_Type_Text.py create mode 100644 src/tp/_generated/Channel_Type_Tubes.py create mode 100644 src/tp/_generated/Client.py create mode 100644 src/tp/_generated/Client_Approver.py create mode 100644 src/tp/_generated/Client_Handler.py create mode 100644 src/tp/_generated/Client_Interface_Requests.py create mode 100644 src/tp/_generated/Client_Observer.py create mode 100644 src/tp/_generated/Connection.py create mode 100644 src/tp/_generated/Connection_Interface_Aliasing.py create mode 100644 src/tp/_generated/Connection_Interface_Avatars.py create mode 100644 src/tp/_generated/Connection_Interface_Balance.py create mode 100644 src/tp/_generated/Connection_Interface_Capabilities.py create mode 100644 src/tp/_generated/Connection_Interface_Contact_Capabilities.py create mode 100644 src/tp/_generated/Connection_Interface_Contacts.py create mode 100644 src/tp/_generated/Connection_Interface_Location.py create mode 100644 src/tp/_generated/Connection_Interface_Presence.py create mode 100644 src/tp/_generated/Connection_Interface_Requests.py create mode 100644 src/tp/_generated/Connection_Interface_Simple_Presence.py create mode 100644 src/tp/_generated/Connection_Manager.py create mode 100644 src/tp/_generated/Debug.py create mode 100644 src/tp/_generated/Media_Session_Handler.py create mode 100644 src/tp/_generated/Media_Stream_Handler.py create mode 100644 src/tp/_generated/Properties_Interface.py create mode 100644 src/tp/_generated/__init__.py create mode 100644 src/tp/_generated/constants.py create mode 100644 src/tp/_generated/errors.py create mode 100644 src/tp/_generated/interfaces.py diff --git a/src/tp/__init__.py b/src/tp/__init__.py index d0f561b..427ab8a 100644 --- a/src/tp/__init__.py +++ b/src/tp/__init__.py @@ -33,10 +33,10 @@ from media import * 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 diff --git a/src/tp/_generated/Account.py b/src/tp/_generated/Account.py new file mode 100644 index 0000000..519d58f --- /dev/null +++ b/src/tp/_generated/Account.py @@ -0,0 +1,174 @@ +# -*- 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 diff --git a/src/tp/_generated/Account_Interface_Avatar.py b/src/tp/_generated/Account_Interface_Avatar.py new file mode 100644 index 0000000..0a9afc1 --- /dev/null +++ b/src/tp/_generated/Account_Interface_Avatar.py @@ -0,0 +1,55 @@ +# -*- 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 diff --git a/src/tp/_generated/Account_Manager.py b/src/tp/_generated/Account_Manager.py new file mode 100644 index 0000000..dbdfc4a --- /dev/null +++ b/src/tp/_generated/Account_Manager.py @@ -0,0 +1,84 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel.py b/src/tp/_generated/Channel.py new file mode 100644 index 0000000..0c91bf0 --- /dev/null +++ b/src/tp/_generated/Channel.py @@ -0,0 +1,153 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Dispatch_Operation.py b/src/tp/_generated/Channel_Dispatch_Operation.py new file mode 100644 index 0000000..dbd16a6 --- /dev/null +++ b/src/tp/_generated/Channel_Dispatch_Operation.py @@ -0,0 +1,262 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Dispatcher.py b/src/tp/_generated/Channel_Dispatcher.py new file mode 100644 index 0000000..7d78b79 --- /dev/null +++ b/src/tp/_generated/Channel_Dispatcher.py @@ -0,0 +1,153 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Dispatcher_Interface_Operation_List.py b/src/tp/_generated/Channel_Dispatcher_Interface_Operation_List.py new file mode 100644 index 0000000..63adc93 --- /dev/null +++ b/src/tp/_generated/Channel_Dispatcher_Interface_Operation_List.py @@ -0,0 +1,68 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Handler.py b/src/tp/_generated/Channel_Handler.py new file mode 100644 index 0000000..186a967 --- /dev/null +++ b/src/tp/_generated/Channel_Handler.py @@ -0,0 +1,37 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_Call_State.py b/src/tp/_generated/Channel_Interface_Call_State.py new file mode 100644 index 0000000..ae94024 --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Call_State.py @@ -0,0 +1,57 @@ +# -*- 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 + ). + + 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 diff --git a/src/tp/_generated/Channel_Interface_Chat_State.py b/src/tp/_generated/Channel_Interface_Chat_State.py new file mode 100644 index 0000000..5bb73d9 --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Chat_State.py @@ -0,0 +1,64 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_DTMF.py b/src/tp/_generated/Channel_Interface_DTMF.py new file mode 100644 index 0000000..cec8889 --- /dev/null +++ b/src/tp/_generated/Channel_Interface_DTMF.py @@ -0,0 +1,59 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_Destroyable.py b/src/tp/_generated/Channel_Interface_Destroyable.py new file mode 100644 index 0000000..0e0e633 --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Destroyable.py @@ -0,0 +1,78 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_Group.py b/src/tp/_generated/Channel_Interface_Group.py new file mode 100644 index 0000000..3a7492a --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Group.py @@ -0,0 +1,317 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_Hold.py b/src/tp/_generated/Channel_Interface_Hold.py new file mode 100644 index 0000000..cf1f16b --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Hold.py @@ -0,0 +1,119 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_Media_Signalling.py b/src/tp/_generated/Channel_Interface_Media_Signalling.py new file mode 100644 index 0000000..dee3376 --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Media_Signalling.py @@ -0,0 +1,83 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_Messages.py b/src/tp/_generated/Channel_Interface_Messages.py new file mode 100644 index 0000000..76ccc9c --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Messages.py @@ -0,0 +1,167 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_Password.py b/src/tp/_generated/Channel_Interface_Password.py new file mode 100644 index 0000000..8125552 --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Password.py @@ -0,0 +1,73 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Interface_Tube.py b/src/tp/_generated/Channel_Interface_Tube.py new file mode 100644 index 0000000..814c834 --- /dev/null +++ b/src/tp/_generated/Channel_Interface_Tube.py @@ -0,0 +1,72 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Request.py b/src/tp/_generated/Channel_Request.py new file mode 100644 index 0000000..8aa867d --- /dev/null +++ b/src/tp/_generated/Channel_Request.py @@ -0,0 +1,131 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Type_Contact_List.py b/src/tp/_generated/Channel_Type_Contact_List.py new file mode 100644 index 0000000..cd5826e --- /dev/null +++ b/src/tp/_generated/Channel_Type_Contact_List.py @@ -0,0 +1,96 @@ +# -*- 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. + """ diff --git a/src/tp/_generated/Channel_Type_DBus_Tube.py b/src/tp/_generated/Channel_Type_DBus_Tube.py new file mode 100644 index 0000000..907ddc7 --- /dev/null +++ b/src/tp/_generated/Channel_Type_DBus_Tube.py @@ -0,0 +1,87 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Type_File_Transfer.py b/src/tp/_generated/Channel_Type_File_Transfer.py new file mode 100644 index 0000000..310ae0d --- /dev/null +++ b/src/tp/_generated/Channel_Type_File_Transfer.py @@ -0,0 +1,148 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Type_Room_List.py b/src/tp/_generated/Channel_Type_Room_List.py new file mode 100644 index 0000000..f26a1c5 --- /dev/null +++ b/src/tp/_generated/Channel_Type_Room_List.py @@ -0,0 +1,122 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Type_Stream_Tube.py b/src/tp/_generated/Channel_Type_Stream_Tube.py new file mode 100644 index 0000000..fdbc4be --- /dev/null +++ b/src/tp/_generated/Channel_Type_Stream_Tube.py @@ -0,0 +1,89 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Type_Streamed_Media.py b/src/tp/_generated/Channel_Type_Streamed_Media.py new file mode 100644 index 0000000..2177ed7 --- /dev/null +++ b/src/tp/_generated/Channel_Type_Streamed_Media.py @@ -0,0 +1,257 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Type_Text.py b/src/tp/_generated/Channel_Type_Text.py new file mode 100644 index 0000000..39213be --- /dev/null +++ b/src/tp/_generated/Channel_Type_Text.py @@ -0,0 +1,236 @@ +# -*- 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 diff --git a/src/tp/_generated/Channel_Type_Tubes.py b/src/tp/_generated/Channel_Type_Tubes.py new file mode 100644 index 0000000..2ba5a83 --- /dev/null +++ b/src/tp/_generated/Channel_Type_Tubes.py @@ -0,0 +1,178 @@ +# -*- 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 diff --git a/src/tp/_generated/Client.py b/src/tp/_generated/Client.py new file mode 100644 index 0000000..62edfc3 --- /dev/null +++ b/src/tp/_generated/Client.py @@ -0,0 +1,101 @@ +# -*- 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. + """ diff --git a/src/tp/_generated/Client_Approver.py b/src/tp/_generated/Client_Approver.py new file mode 100644 index 0000000..862d890 --- /dev/null +++ b/src/tp/_generated/Client_Approver.py @@ -0,0 +1,104 @@ +# -*- 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 diff --git a/src/tp/_generated/Client_Handler.py b/src/tp/_generated/Client_Handler.py new file mode 100644 index 0000000..2d228ae --- /dev/null +++ b/src/tp/_generated/Client_Handler.py @@ -0,0 +1,104 @@ +# -*- 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 diff --git a/src/tp/_generated/Client_Interface_Requests.py b/src/tp/_generated/Client_Interface_Requests.py new file mode 100644 index 0000000..8802ba4 --- /dev/null +++ b/src/tp/_generated/Client_Interface_Requests.py @@ -0,0 +1,115 @@ +# -*- 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 diff --git a/src/tp/_generated/Client_Observer.py b/src/tp/_generated/Client_Observer.py new file mode 100644 index 0000000..5d43f54 --- /dev/null +++ b/src/tp/_generated/Client_Observer.py @@ -0,0 +1,128 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection.py b/src/tp/_generated/Connection.py new file mode 100644 index 0000000..852f308 --- /dev/null +++ b/src/tp/_generated/Connection.py @@ -0,0 +1,348 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Aliasing.py b/src/tp/_generated/Connection_Interface_Aliasing.py new file mode 100644 index 0000000..c561785 --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Aliasing.py @@ -0,0 +1,95 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Avatars.py b/src/tp/_generated/Connection_Interface_Avatars.py new file mode 100644 index 0000000..e104d23 --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Avatars.py @@ -0,0 +1,170 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Balance.py b/src/tp/_generated/Connection_Interface_Balance.py new file mode 100644 index 0000000..f1a668e --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Balance.py @@ -0,0 +1,45 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Capabilities.py b/src/tp/_generated/Connection_Interface_Capabilities.py new file mode 100644 index 0000000..142e36d --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Capabilities.py @@ -0,0 +1,107 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Contact_Capabilities.py b/src/tp/_generated/Connection_Interface_Contact_Capabilities.py new file mode 100644 index 0000000..30aa39a --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Contact_Capabilities.py @@ -0,0 +1,118 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Contacts.py b/src/tp/_generated/Connection_Interface_Contacts.py new file mode 100644 index 0000000..82fa390 --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Contacts.py @@ -0,0 +1,46 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Location.py b/src/tp/_generated/Connection_Interface_Location.py new file mode 100644 index 0000000..7972eb2 --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Location.py @@ -0,0 +1,107 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Presence.py b/src/tp/_generated/Connection_Interface_Presence.py new file mode 100644 index 0000000..0680faf --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Presence.py @@ -0,0 +1,203 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Requests.py b/src/tp/_generated/Connection_Interface_Requests.py new file mode 100644 index 0000000..98d5c80 --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Requests.py @@ -0,0 +1,125 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Interface_Simple_Presence.py b/src/tp/_generated/Connection_Interface_Simple_Presence.py new file mode 100644 index 0000000..faf86b9 --- /dev/null +++ b/src/tp/_generated/Connection_Interface_Simple_Presence.py @@ -0,0 +1,173 @@ +# -*- 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 diff --git a/src/tp/_generated/Connection_Manager.py b/src/tp/_generated/Connection_Manager.py new file mode 100644 index 0000000..98be26f --- /dev/null +++ b/src/tp/_generated/Connection_Manager.py @@ -0,0 +1,259 @@ +# -*- 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 diff --git a/src/tp/_generated/Debug.py b/src/tp/_generated/Debug.py new file mode 100644 index 0000000..dc96703 --- /dev/null +++ b/src/tp/_generated/Debug.py @@ -0,0 +1,51 @@ +# -*- 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 diff --git a/src/tp/_generated/Media_Session_Handler.py b/src/tp/_generated/Media_Session_Handler.py new file mode 100644 index 0000000..03f6c5c --- /dev/null +++ b/src/tp/_generated/Media_Session_Handler.py @@ -0,0 +1,62 @@ +# -*- 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 diff --git a/src/tp/_generated/Media_Stream_Handler.py b/src/tp/_generated/Media_Stream_Handler.py new file mode 100644 index 0000000..13a2b16 --- /dev/null +++ b/src/tp/_generated/Media_Stream_Handler.py @@ -0,0 +1,297 @@ +# -*- 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 diff --git a/src/tp/_generated/Properties_Interface.py b/src/tp/_generated/Properties_Interface.py new file mode 100644 index 0000000..8520c68 --- /dev/null +++ b/src/tp/_generated/Properties_Interface.py @@ -0,0 +1,91 @@ +# -*- 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 diff --git a/src/tp/_generated/__init__.py b/src/tp/_generated/__init__.py new file mode 100644 index 0000000..da6f5d8 --- /dev/null +++ b/src/tp/_generated/__init__.py @@ -0,0 +1 @@ +# Placeholder for package diff --git a/src/tp/_generated/constants.py b/src/tp/_generated/constants.py new file mode 100644 index 0000000..efe4040 --- /dev/null +++ b/src/tp/_generated/constants.py @@ -0,0 +1,374 @@ +# -*- 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 + diff --git a/src/tp/_generated/errors.py b/src/tp/_generated/errors.py new file mode 100644 index 0000000..dc3eea0 --- /dev/null +++ b/src/tp/_generated/errors.py @@ -0,0 +1,502 @@ +# -*- 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 diff --git a/src/tp/_generated/interfaces.py b/src/tp/_generated/interfaces.py new file mode 100644 index 0000000..ee2aae3 --- /dev/null +++ b/src/tp/_generated/interfaces.py @@ -0,0 +1,89 @@ +# -*- 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' diff --git a/src/tp/channel.py b/src/tp/channel.py index e53134a..592b201 100644 --- a/src/tp/channel.py +++ b/src/tp/channel.py @@ -39,7 +39,7 @@ from telepathy.interfaces import (CHANNEL_INTERFACE, 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 @@ -135,7 +135,7 @@ class Channel(_Channel, 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): @@ -152,7 +152,7 @@ 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): @@ -169,7 +169,7 @@ 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): @@ -186,7 +186,7 @@ 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): @@ -215,7 +215,7 @@ 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): @@ -300,14 +300,14 @@ 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): @@ -377,13 +377,13 @@ 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): @@ -402,4 +402,4 @@ class ChannelInterfacePassword(_ChannelInterfacePassword): self._password_flags &= ~removed -from telepathy._generated.Channel_Interface_Call_State import ChannelInterfaceCallState +from _generated.Channel_Interface_Call_State import ChannelInterfaceCallState diff --git a/src/tp/channelhandler.py b/src/tp/channelhandler.py index 5bef170..6d43a5b 100644 --- a/src/tp/channelhandler.py +++ b/src/tp/channelhandler.py @@ -16,4 +16,4 @@ # 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 diff --git a/src/tp/conn.py b/src/tp/conn.py index 256a574..c0e1ce2 100644 --- a/src/tp/conn.py +++ b/src/tp/conn.py @@ -42,7 +42,7 @@ from telepathy.interfaces import (CONN_INTERFACE, 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])') @@ -332,15 +332,15 @@ class Connection(_Connection, DBusProperties): 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 @@ -398,7 +398,7 @@ class ConnectionInterfaceCapabilities(_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 @@ -550,11 +550,11 @@ class 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 diff --git a/src/tp/connmgr.py b/src/tp/connmgr.py index 8167108..27aef01 100644 --- a/src/tp/connmgr.py +++ b/src/tp/connmgr.py @@ -23,7 +23,7 @@ import dbus.service 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): diff --git a/src/tp/debug.py b/src/tp/debug.py index aa7c6e3..1fef6b9 100644 --- a/src/tp/debug.py +++ b/src/tp/debug.py @@ -23,7 +23,7 @@ from telepathy.constants import (DEBUG_LEVEL_ERROR, 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 diff --git a/src/tp/media.py b/src/tp/media.py index 7d1ce7b..e3c854f 100644 --- a/src/tp/media.py +++ b/src/tp/media.py @@ -22,7 +22,7 @@ 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 diff --git a/src/tp/properties.py b/src/tp/properties.py index 65faaed..74fde3d 100644 --- a/src/tp/properties.py +++ b/src/tp/properties.py @@ -24,7 +24,7 @@ import dbus.service 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): -- 1.7.9.5