Home · All Classes · All Namespaces · Modules · Functions · Files
Signals | Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Properties
Tp::Account Class Reference

The Account class represents a Telepathy account. More...

#include <TelepathyQt4/Account>

Inherits Tp::StatelessDBusProxy, and Tp::OptionalInterfaceFactory< Account >.

List of all members.

Signals

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Properties


Detailed Description

The Account class represents a Telepathy account.

Account adds the following features compared to using Client::AccountManagerInterface directly:

The remote object accessor functions on this object (isValidAccount(), isEnabled(), and so on) don't make any D-Bus calls; instead, they return/use values cached from a previous introspection run. The introspection process populates their values in the most efficient way possible based on what the service implements. Their return value is mostly undefined until the introspection process is completed, i.e. isReady() returns true. See the individual accessor descriptions for more details.

Signals are emitted to indicate that properties have changed, for example displayNameChanged(), iconNameChanged(), etc.

Convenience methods to create channels using the channel dispatcher such as ensureTextChat(), createFileTransfer() are provided.

To avoid unnecessary D-Bus traffic, some methods only return valid information after a specific feature has been enabled by calling becomeReady() with the desired set of features as an argument, and waiting for the resulting PendingOperation to finish. For instance, to retrieve the account protocol information, it is necessary to call becomeReady() with Account::FeatureProtocolInfo included in the argument. The required features are documented by each method.

If the account is deleted from the AccountManager, this object will not be deleted automatically; however, it will emit invalidated() with error code #TELEPATHY_QT4_ERROR_OBJECT_REMOVED and will cease to be useful.

Usage

Creating an account object

The easiest way to create account objects is through AccountManager. One can just use the AccountManager convenience methods such as AccountManager::validAccounts() to get a list of account objects representing valid accounts.

If you already know the object path, you can just call create(). For example:

 AccountPtr acc = Account::create(busName, objectPath); 

An AccountPtr object is returned, which will automatically keep track of object lifetime.

You can also provide a D-Bus connection as a QDBusConnection:

 AccountPtr acc = Account::create(QDBusConnection::sessionBus(),
         busName, objectPath);

Making account ready to use

An Account object needs to become ready before usage, meaning that the introspection process finished and the object accessors can be used.

To make the object ready, use becomeReady() and wait for the PendingOperation::finished() signal to be emitted.

 class MyClass : public QObject
 {
     QOBJECT

 public:
     MyClass(QObject *parent = 0);
     ~MyClass() { }

 private Q_SLOTS:
     void onAccountReady(Tp::PendingOperation*);

 private:
     AccountPtr acc;
 };

 MyClass::MyClass(const QString &busName, const QString &objectPath,
         QObject *parent)
     : QObject(parent)
       acc(Account::create(busName, objectPath))
 {
     connect(acc->becomeReady(),
             SIGNAL(finished(Tp::PendingOperation*)),
             SLOT(onAccountReady(Tp::PendingOperation*)));
 }

 void MyClass::onAccountReady(Tp::PendingOperation *op)
 {
     if (op->isError()) {
         qWarning() << "Account cannot become ready:" <<
             op->errorName() << "-" << op->errorMessage();
         return;
     }

     // Account is now ready
     qDebug() << "Display name:" << acc->displayName();
 }

See Asynchronous Object Model, Shared Pointer Usage


Constructor & Destructor Documentation

Tp::Account::~Account ( ) [virtual]

Class destructor.

Tp::Account::Account ( const QDBusConnection &  bus,
const QString &  busName,
const QString &  objectPath,
const ConnectionFactoryConstPtr &  connectionFactory,
const ChannelFactoryConstPtr &  channelFactory,
const ContactFactoryConstPtr &  contactFactory,
const Feature coreFeature 
) [protected]

Construct a new Account object using the given bus and the given factories.

A warning is printed if the factories are not for bus.

Parameters:
busQDBusConnection to use.
busNameThe account well-known bus name (sometimes called a "service name"). This is usually the same as the account manager bus name TELEPATHY_ACCOUNT_MANAGER_BUS_NAME.
objectPathThe account object path.
connectionFactoryThe connection factory to use.
channelFactoryThe channel factory to use.
contactFactoryThe contact factory to use.
coreFeatureThe core feature of the Account subclass. The corresponding introspectable should depend on Account::FeatureCore.

Member Function Documentation

AccountPtr Tp::Account::create ( const QString &  busName,
const QString &  objectPath,
const ConnectionFactoryConstPtr &  connectionFactory = ConnectionFactory::create(QDBusConnection::sessionBus()),
const ChannelFactoryConstPtr &  channelFactory = ChannelFactory::create(QDBusConnection::sessionBus()),
const ContactFactoryConstPtr &  contactFactory = ContactFactory::create() 
) [static]

Create a new Account object using QDBusConnection::sessionBus() and the given factories.

A warning is printed if the factories are not for QDBusConnection::sessionBus().

Parameters:
busNameThe account well-known bus name (sometimes called a "service name"). This is usually the same as the account manager bus name TELEPATHY_ACCOUNT_MANAGER_BUS_NAME.
objectPathThe account object path.
connectionFactoryThe connection factory to use.
channelFactoryThe channel factory to use.
contactFactoryThe contact factory to use.
Returns:
An AccountPtr object pointing to the newly created Account object.
AccountPtr Tp::Account::create ( const QDBusConnection &  bus,
const QString &  busName,
const QString &  objectPath,
const ConnectionFactoryConstPtr &  connectionFactory,
const ChannelFactoryConstPtr &  channelFactory,
const ContactFactoryConstPtr &  contactFactory = ContactFactory::create() 
) [static]

Create a new Account object using the given bus and the given factories.

A warning is printed if the factories are not for bus.

Parameters:
busQDBusConnection to use.
busNameThe account well-known bus name (sometimes called a "service name"). This is usually the same as the account manager bus name TELEPATHY_ACCOUNT_MANAGER_BUS_NAME.
objectPathThe account object path.
connectionFactoryThe connection factory to use.
channelFactoryThe channel factory to use.
contactFactoryThe contact factory to use.
Returns:
An AccountPtr object pointing to the newly created Account object.
ConnectionFactoryConstPtr Tp::Account::connectionFactory ( ) const

Return the connection factory used by this account.

Only read access is provided. This allows constructing object instances and examining the object construction settings, but not changing settings. Allowing changes would lead to tricky situations where objects constructed at different times by the account would have unpredictably different construction settings (eg. subclass).

Returns:
Read-only pointer to the factory.
ChannelFactoryConstPtr Tp::Account::channelFactory ( ) const

Return the channel factory used by this account.

Only read access is provided. This allows constructing object instances and examining the object construction settings, but not changing settings. Allowing changes would lead to tricky situations where objects constructed at different times by the account would have unpredictably different construction settings (eg. subclass).

Returns:
Read-only pointer to the factory.
ContactFactoryConstPtr Tp::Account::contactFactory ( ) const

Return the contact factory used by this account.

Only read access is provided. This allows constructing object instances and examining the object construction settings, but not changing settings. Allowing changes would lead to tricky situations where objects constructed at different times by the account would have unpredictably different construction settings (eg. subclass).

Returns:
Read-only pointer to the factory.
bool Tp::Account::isValidAccount ( ) const

Return whether this is a valid account.

If true, this account is considered by the account manager to be complete and usable. If false, user action is required to make it usable, and it will never attempt to connect (for instance, this might be caused by the absence of a required parameter).

This method requires Account::FeatureCore to be enabled.

Returns:
true if the account is valid, false otherwise.
See also:
validityChanged()
bool Tp::Account::isEnabled ( ) const

Return whether this account is enabled.

Gives the users the possibility to prevent an account from being used. This flag does not change the validity of the account.

This method requires Account::FeatureCore to be enabled.

Returns:
true if the account is enabled, false otherwise.
See also:
stateChanged()
PendingOperation * Tp::Account::setEnabled ( bool  value)

Set whether this account should be enabled or disabled.

Parameters:
valueWhether this account should be enabled or disabled.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
stateChanged()
QString Tp::Account::cmName ( ) const
QString Tp::Account::protocolName ( ) const
QString Tp::Account::serviceName ( ) const
PendingOperation * Tp::Account::setServiceName ( const QString &  value)

Set the service name of this account.

Parameters:
valueThe service name of this account.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
serviceNameChanged()
ProfilePtr Tp::Account::profile ( ) const
QString Tp::Account::displayName ( ) const
PendingOperation * Tp::Account::setDisplayName ( const QString &  value)

Set the display name of this account.

Parameters:
valueThe display name of this account.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
displayNameChanged()
QString Tp::Account::iconName ( ) const
PendingOperation * Tp::Account::setIconName ( const QString &  value)

Set the icon name of this account.

Parameters:
valueThe icon name of this account.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
iconNameChanged()
QString Tp::Account::nickname ( ) const
PendingOperation * Tp::Account::setNickname ( const QString &  value)

Set the nickname of this account.

Parameters:
valueThe nickname of this account.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
nicknameChanged()
AvatarSpec Tp::Account::avatarRequirements ( ) const
const Avatar& Tp::Account::avatar ( ) const
PendingOperation * Tp::Account::setAvatar ( const Avatar &  avatar)

Set avatar of this account.

Parameters:
avatarThe avatar of this account.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
avatarChanged()
QVariantMap Tp::Account::parameters ( ) const
PendingStringList * Tp::Account::updateParameters ( const QVariantMap &  set,
const QStringList &  unset 
)

Update this account parameters.

On success, the pending operation returned by this method will produce a list of strings, which are the names of parameters whose changes will not take effect until the account is disconnected and reconnected (for instance by calling reconnect()).

Parameters:
setParameters to set.
unsetParameters to unset.
Returns:
A PendingStringList which will emit PendingStringList::finished when the request has been made
See also:
parametersChanged(), reconnect()
ProtocolInfo Tp::Account::protocolInfo ( ) const
ConnectionCapabilities Tp::Account::capabilities ( ) const
bool Tp::Account::connectsAutomatically ( ) const
PendingOperation * Tp::Account::setConnectsAutomatically ( bool  value)

Set whether this account should be put online automatically whenever possible.

Parameters:
valueValue indicating if this account should be put online whenever possible.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
connectsAutomaticallyPropertyChanged()
bool Tp::Account::hasBeenOnline ( ) const
ConnectionStatus Tp::Account::connectionStatus ( ) const
ConnectionStatusReason Tp::Account::connectionStatusReason ( ) const
QString Tp::Account::connectionError ( ) const
Connection::ErrorDetails Tp::Account::connectionErrorDetails ( ) const
ConnectionPtr Tp::Account::connection ( ) const
bool Tp::Account::isChangingPresence ( ) const

Return whether this account's connection is changing presence.

This method requires Account::FeatureCore to be enabled.

Returns:
Whether this account's connection is changing presence.
See also:
changingPresence(), currentPresenceChanged(), setRequestedPresence()
PresenceSpecList Tp::Account::allowedPresenceStatuses ( bool  includeAllStatuses = false) const

Return a list of presences allowed by a connection to this account.

In particular, for the statuses reported here it can be assumed that setting them as the requested presence via setRequestedPresence() will eventually result in currentPresence() changing to exactly said presence. Other statuses are only guaranteed to be matched as closely as possible.

The statuses can be also used for the automatic presence, as set by setAutomaticPresence(), with the exception of any status specifications for which Presence::type() is Tp::ConnectionPresenceTypeOffline for the Presence returned by PresenceSpec::presence().

However, the optional parameter can be used to allow reporting also other possible presence statuses on this protocol besides the others that can be set on yourself. These are purely informatory, for e.g. adjusting an UI to allow all possible remote contact statuses to be displayed.

An offline presence status is always included, because it's always valid to make an account offline by setting the requested presence to an offline status.

Full functionality requires FeatureProtocolInfo and FeatureProfile to be ready as well as Connection with Connection::FeatureSimplePresence enabled. If the connection is online and Connection::FeatureSimplePresence is enabled, it will return the connection allowed statuses, otherwise it will return a list os statuses based on profile() and protocolInfo() information if the corresponding features are enabled.

If there's a mismatch between the presence status info provided in the .profile file and/or the .manager file and what an online Connection actually reports (for example, the said data files are missing or too old to include presence information), the returned value can change, in particular when connectionChanged() is emitted with a connection for which connection->status() == Tp::ConnectionStatusConnected.

Parameters:
includeAllStatusesWhether the returned list will include all statuses or just the ones that can are settable using setRequestedPresence().
Returns:
A list of presences allowed by a connection to this account.
uint Tp::Account::maxPresenceStatusMessageLength ( ) const

Returns the maximum length for a presence status message.

If a status message set using setCurrentPresence() is longer than the maximum length allowed, the message will be truncated and currentPresenceChanged() will be emitted (if setting the presence worked) with the truncated message.

Full functionality requires Connection with Connection::FeatureSimplePresence enabled. If the connection is online and Connection::FeatureSimplePresence is enabled, it will return the connection maximum status message length, otherwise it will return 0.

Returns:
The maximum length for a presence status message, or 0 if there is no limit.
Presence Tp::Account::automaticPresence ( ) const
PendingOperation * Tp::Account::setAutomaticPresence ( const Presence presence)

Set the presence status that this account should have if it is brought online automatically by the account manager.

Parameters:
presenceThe presence to set when this account is brought online automatically by the account manager.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
automaticPresenceChanged(), setRequestedPresence()
Presence Tp::Account::currentPresence ( ) const
Presence Tp::Account::requestedPresence ( ) const
PendingOperation * Tp::Account::setRequestedPresence ( const Presence presence)

Set the requested presence.

When requested presence is changed, the account manager should attempt to manipulate the connection to make currentPresence() match requestedPresence() as closely as possible.

Parameters:
presenceThe requested presence.
Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
See also:
requestedPresenceChanged(), currentPresence(), automaticPresence(), setAutomaticPresence()
bool Tp::Account::isOnline ( ) const

Return whether this account is online.

Returns:
true if this account is online, otherwise false.
QString Tp::Account::uniqueIdentifier ( ) const
QString Tp::Account::normalizedName ( ) const
PendingOperation * Tp::Account::reconnect ( )

If this account is currently connected, disconnect and reconnect it. If it is currently trying to connect, cancel the attempt to connect and start another. If it is currently disconnected, do nothing.

Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
PendingOperation * Tp::Account::remove ( )

Delete this account.

Returns:
A PendingOperation which will emit PendingOperation::finished when the request has been made.
bool Tp::Account::supportsRequestHints ( ) const

Return whether passing hints on channel requests on this account is known to be supported.

The return value is undefined unless Account::FeatureCore is ready on this account proxy.

Returns:
true if supported, false if not.
bool Tp::Account::requestsSucceedWithChannel ( ) const

Return whether the ChannelRequest::succeeded(const Tp::ChannelPtr &) signal is expected to be emitted with a non-NULL channel parameter for requests made using this account.

This can be used as a run-time check for the Channel Dispatcher implementation being new enough. In particular, similarly old Channel Dispatchers don't support request hints either, so the return value for this function and Account::supportsRequestHints() will bet he same.

The return value is undefined unless Account::FeatureCore is ready on this account proxy.

Returns:
true if supported, false if not.
PendingChannelRequest * Tp::Account::ensureTextChat ( const QString &  contactIdentifier,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureTextChat(contactIdentifier, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureTextChat ( const QString &  contactIdentifier,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that a text channel with the given contact contactIdentifier exists, creating it if necessary.

See ensureChannel() for more details.

Parameters:
contactIdentifierThe identifier of the contact to chat with.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::ensureTextChat ( const ContactPtr &  contact,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureTextChat(contact, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureTextChat ( const ContactPtr &  contact,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that a text channel with the given contact contact exists, creating it if necessary.

See ensureChannel() for more details.

Parameters:
contactThe contact to chat with.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::ensureTextChatroom ( const QString &  roomName,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureTextChatroom(roomName, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureTextChatroom ( const QString &  roomName,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that a text chat room with the given room name roomName exists, creating it if necessary.

See ensureChannel() for more details.

Parameters:
roomNameThe name of the chat room.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::ensureStreamedMediaCall ( const QString &  contactIdentifier,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureStreamedMediaCall(contactIdentifier, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureStreamedMediaCall ( const QString &  contactIdentifier,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that a media channel with the given contact contactIdentifier exists, creating it if necessary.

See ensureChannel() for more details.

Parameters:
contactIdentifierThe identifier of the contact to call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::ensureStreamedMediaCall ( const ContactPtr &  contact,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureStreamedMediaCall(contact, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureStreamedMediaCall ( const ContactPtr &  contact,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that a media channel with the given contact contact exists, creating it if necessary.

See ensureChannel() for more details.

Parameters:
contactThe contact to call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::ensureStreamedMediaAudioCall ( const QString &  contactIdentifier,
QDateTime  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureStreamedMediaAudioCall(contactIdentifier, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureStreamedMediaAudioCall ( const QString &  contactIdentifier,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that an audio call with the given contact contactIdentifier exists, creating it if necessary.

See ensureChannel() for more details.

This will only work on relatively modern connection managers, like telepathy-gabble 0.9.0 or later.

Parameters:
contactIdentifierThe identifier of the contact to call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::ensureStreamedMediaAudioCall ( const ContactPtr &  contact,
QDateTime  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureStreamedMediaAudioCall(contact, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureStreamedMediaAudioCall ( const ContactPtr &  contact,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that an audio call with the given contact contact exists, creating it if necessary.

See ensureChannel() for more details.

This will only work on relatively modern connection managers, like telepathy-gabble 0.9.0 or later.

Parameters:
contactThe contact to call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::ensureStreamedMediaVideoCall ( const QString &  contactIdentifier,
bool  withAudio = true,
QDateTime  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureStreamedMediaVideoCall(contactIdentifier, withAudio, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureStreamedMediaVideoCall ( const QString &  contactIdentifier,
bool  withAudio,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that a video call with the given contact contactIdentifier exists, creating it if necessary.

See ensureChannel() for more details.

This will only work on relatively modern connection managers, like telepathy-gabble 0.9.0 or later.

Parameters:
contactIdentifierThe identifier of the contact to call.
withAudiotrue if both audio and video are required, false for a video-only call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::ensureStreamedMediaVideoCall ( const ContactPtr &  contact,
bool  withAudio = true,
QDateTime  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureStreamedMediaVideoCall(contact, withAudio, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureStreamedMediaVideoCall ( const ContactPtr &  contact,
bool  withAudio,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that a video call with the given contact contact exists, creating it if necessary.

See ensureChannel() for more details.

This will only work on relatively modern connection managers, like telepathy-gabble 0.9.0 or later.

Parameters:
contactThe contact to call.
withAudiotrue if both audio and video are required, false for a video-only call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createFileTransfer ( const QString &  contactIdentifier,
const FileTransferChannelCreationProperties properties,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createFileTransfer(contactIdentifier, properties, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createFileTransfer ( const QString &  contactIdentifier,
const FileTransferChannelCreationProperties properties,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to create a file transfer channel with the given contact contact.

Parameters:
contactIdentifierThe identifier of the contact to send a file.
fileNameThe suggested filename for the receiver.
propertiesThe desired properties.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createFileTransfer ( const ContactPtr &  contact,
const FileTransferChannelCreationProperties properties,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createFileTransfer(contact, properties, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createFileTransfer ( const ContactPtr &  contact,
const FileTransferChannelCreationProperties properties,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to create a file transfer channel with the given contact contact.

Parameters:
contactThe contact to send a file.
propertiesThe desired properties.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createStreamTube ( const QString &  contactIdentifier,
const QString &  service,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString(),
const ChannelRequestHints hints = ChannelRequestHints() 
)

Start a request to create a stream tube channel with the given contact identifier contactIdentifier.

Parameters:
contactIdentifierThe identifier of the contact to open a stream tube with.
serviceThe stream tube service.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest* Tp::Account::createStreamTube ( const ContactPtr &  contact,
const QString &  service,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString(),
const ChannelRequestHints hints = ChannelRequestHints() 
)
PendingChannelRequest * Tp::Account::createConferenceStreamedMediaCall ( const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers = QStringList(),
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createConferenceStreamedMediaCall(channels, initialInviteeContactsIdentifiers, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createConferenceStreamedMediaCall ( const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to create a conference media call with the given channels channels.

Parameters:
channelsThe conference channels.
initialInviteeContactsIdentifiersA list of additional contacts identifiers to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createConferenceStreamedMediaCall ( const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts = QList<ContactPtr>(),
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createConferenceStreamedMediaCall(channels, initialInviteeContacts, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createConferenceStreamedMediaCall ( const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to create a conference media call with the given channels channels.

Parameters:
channelsThe conference channels.
initialInviteeContactsA list of additional contacts to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createConferenceTextChat ( const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts = QList<ContactPtr>(),
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createConferenceTextChat(channels, initialInviteeContacts, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createConferenceTextChat ( const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to create a conference text chat with the given channels channels.

Parameters:
channelsThe conference channels.
initialInviteeContactsA list of additional contacts to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createConferenceTextChat ( const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers = QStringList(),
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createConferenceTextChat(channels, initialInviteeContactsIdentifiers, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createConferenceTextChat ( const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to create a conference text chat with the given channels channels.

Parameters:
channelsThe conference channels.
initialInviteeContactsIdentifiersA list of additional contacts identifiers to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createConferenceTextChatRoom ( const QString &  roomName,
const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers = QStringList(),
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createConferenceTextChatroom(roomName, channels, initialInviteeContactsIdentifiers, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createConferenceTextChatroom ( const QString &  roomName,
const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers = QStringList(),
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString(),
const ChannelRequestHints hints = ChannelRequestHints() 
)

Start a request to create a conference text chat room with the given channels channels and room name roomName.

Parameters:
roomNameThe room name.
channelsThe conference channels.
initialInviteeContactsIdentifiersA list of additional contacts identifiers to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createConferenceTextChatRoom ( const QString &  roomName,
const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts = QList<ContactPtr>(),
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createConferenceTextChatroom(roomName, channels, initialInviteeContacts, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createConferenceTextChatroom ( const QString &  roomName,
const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts = QList<ContactPtr>(),
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString(),
const ChannelRequestHints hints = ChannelRequestHints() 
)

Start a request to create a conference text chat room with the given channels channels and room name roomName.

Parameters:
roomNameThe room name.
channelsThe conference channels.
initialInviteeContactsA list of additional contacts to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
ensureChannel(), createChannel()
PendingChannelRequest * Tp::Account::createContactSearch ( const QString &  server = QString(),
uint  limit = 0,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createContactSearch(server, limit, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createContactSearch ( const QString &  server,
uint  limit,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to create a contact search channel with the given server server and limit limit.

Parameters:
serverFor protocols which support searching for contacts on multiple servers with different DNS names (like XMPP), the DNS name of the server to be searched, e.g. "characters.shakespeare.lit". Otherwise, an empty string.
limitThe desired maximum number of results that should be returned by a doing a search. If the protocol does not support specifying a limit for the number of results returned at a time, this will be ignored.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
createChannel()
PendingChannel * Tp::Account::ensureAndHandleTextChat ( const QString &  contactIdentifier,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that a text channel with the given contact contactIdentifier exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
contactIdentifierThe identifier of the contact to chat with.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::ensureAndHandleTextChat ( const ContactPtr &  contact,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that a text channel with the given contact contact exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
contactThe contact to chat with.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::ensureAndHandleTextChatroom ( const QString &  roomName,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that a text chat room with the given room name roomName exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
roomNameThe name of the chat room.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::ensureAndHandleStreamedMediaCall ( const QString &  contactIdentifier,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that a media channel with the given contact contactIdentifier exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
contactIdentifierThe identifier of the contact to call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::ensureAndHandleStreamedMediaCall ( const ContactPtr &  contact,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that a media channel with the given contact contact exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
contactThe contact to call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::ensureAndHandleStreamedMediaAudioCall ( const QString &  contactIdentifier,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that an audio call with the given contact contactIdentifier exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

This will only work on relatively modern connection managers, like telepathy-gabble 0.9.0 or later.

Parameters:
contactIdentifierThe identifier of the contact to call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::ensureAndHandleStreamedMediaAudioCall ( const ContactPtr &  contact,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that an audio call with the given contact contact exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

This will only work on relatively modern connection managers, like telepathy-gabble 0.9.0 or later.

Parameters:
contactThe contact to call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::ensureAndHandleStreamedMediaVideoCall ( const QString &  contactIdentifier,
bool  withAudio = true,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that a video call with the given contact contactIdentifier exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

This will only work on relatively modern connection managers, like telepathy-gabble 0.9.0 or later.

Parameters:
contactIdentifierThe identifier of the contact to call.
withAudiotrue if both audio and video are required, false for a video-only call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::ensureAndHandleStreamedMediaVideoCall ( const ContactPtr &  contact,
bool  withAudio = true,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to ensure that a video call with the given contact contact exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

This will only work on relatively modern connection managers, like telepathy-gabble 0.9.0 or later.

Parameters:
contactThe contact to call.
withAudiotrue if both audio and video are required, false for a video-only call.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleFileTransfer ( const QString &  contactIdentifier,
const FileTransferChannelCreationProperties properties,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a file transfer channel with the given contact contactIdentifier. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
contactIdentifierThe identifier of the contact to send a file.
propertiesThe desired properties.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleFileTransfer ( const ContactPtr &  contact,
const FileTransferChannelCreationProperties properties,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a file transfer channel with the given contact contact. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
contactThe contact to send a file.
propertiesThe desired properties.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleStreamTube ( const QString &  contactIdentifier,
const QString &  service,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a stream tube channel with the given contact identifier contactIdentifier. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
contactIdentifierThe identifier of the contact to open a stream tube with.
serviceThe stream tube service.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleStreamTube ( const ContactPtr &  contact,
const QString &  service,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a stream tube channel with the given contact contact. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
contactThe contact to open a stream tube with.
serviceThe stream tube service.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleConferenceTextChat ( const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts = QList<ContactPtr>(),
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a conference text chat with the given channels channels. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
channelsThe conference channels.
initialInviteeContactsA list of additional contacts to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleConferenceTextChat ( const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers = QStringList(),
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a conference text chat with the given channels channels. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
channelsThe conference channels.
initialInviteeContactsIdentifiersA list of additional contacts identifiers to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleConferenceTextChatroom ( const QString &  roomName,
const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers = QStringList(),
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a conference text chat room with the given channels channels and room name roomName. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
roomNameThe room name.
channelsThe conference channels.
initialInviteeContactsIdentifiersA list of additional contacts identifiers to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleConferenceTextChatroom ( const QString &  roomName,
const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts = QList<ContactPtr>(),
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a conference text chat room with the given channels channels and room name roomName. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
roomNameThe room name.
channelsThe conference channels.
initialInviteeContactsA list of additional contacts to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleConferenceStreamedMediaCall ( const QList< ChannelPtr > &  channels,
const QStringList &  initialInviteeContactsIdentifiers = QStringList(),
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a conference media call with the given channels channels. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
channelsThe conference channels.
initialInviteeContactsIdentifiersA list of additional contacts identifiers to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleConferenceStreamedMediaCall ( const QList< ChannelPtr > &  channels,
const QList< ContactPtr > &  initialInviteeContacts = QList<ContactPtr>(),
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a conference media call with the given channels channels. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
channelsThe conference channels.
initialInviteeContactsA list of additional contacts to be invited to this conference when it is created.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannel * Tp::Account::createAndHandleContactSearch ( const QString &  server = QString(),
uint  limit = 0,
const QDateTime &  userActionTime = QDateTime::currentDateTime() 
)

Start a request to create a contact search channel with the given server server and limit limit. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Parameters:
serverFor protocols which support searching for contacts on multiple servers with different DNS names (like XMPP), the DNS name of the server to be searched, e.g. "characters.shakespeare.lit". Otherwise, an empty string. If the protocol does not support specifying a search server, this will be ignored.
limitThe desired maximum number of results that should be returned by a doing a search. If the protocol does not support specifying a limit for the number of results returned at a time, this will be ignored.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
See also:
ensureAndHandleChannel(), createAndHandleChannel()
PendingChannelRequest * Tp::Account::createChannel ( const QVariantMap &  request,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as createChannel(request, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::createChannel ( const QVariantMap &  request,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to create a channel. This initially just creates a PendingChannelRequest object, which can be used to track the success or failure of the request, or to cancel it.

Helper methods for text chat, text chat room, media call and conference are provided and should be used if appropriate.

Parameters:
requestA dictionary containing desirable properties.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
createChannel()
PendingChannelRequest * Tp::Account::ensureChannel ( const QVariantMap &  request,
const QDateTime &  userActionTime = QDateTime::currentDateTime(),
const QString &  preferredHandler = QString() 
)

Same as ensureChannel(request, userActionTime, preferredHandler, ChannelRequestHints())

PendingChannelRequest * Tp::Account::ensureChannel ( const QVariantMap &  request,
const QDateTime &  userActionTime,
const QString &  preferredHandler,
const ChannelRequestHints hints 
)

Start a request to ensure that a channel exists, creating it if necessary. This initially just creates a PendingChannelRequest object, which can be used to track the success or failure of the request, or to cancel it.

Helper methods for text chat, text chat room, media call and conference are provided and should be used if appropriate.

Parameters:
requestA dictionary containing desirable properties.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
preferredHandlerEither the well-known bus name (starting with org.freedesktop.Telepathy.Client.) of the preferred handler for this channel, or an empty string to indicate that any handler would be acceptable.
hintsArbitrary metadata which will be relayed to the handler if supported, as indicated by supportsRequestHints().
Returns:
A PendingChannelRequest which will emit PendingChannelRequest::finished when the request has been made.
See also:
createChannel()
PendingChannel * Tp::Account::createAndHandleChannel ( const QVariantMap &  request,
const QDateTime &  userActionTime 
)

Start a request to create channel. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Helper methods for text chat, text chat room, media call and conference are provided and should be used if appropriate.

The caller is responsible for closing the channel with Channel::requestClose() or Channel::requestLeave() when it has finished handling it.

A possible error returned by this method is #TELEPATHY_ERROR_NOT_AVAILABLE, in case a conflicting channel that matches request already exists.

Parameters:
requestA dictionary containing desirable properties.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
PendingChannel * Tp::Account::ensureAndHandleChannel ( const QVariantMap &  request,
const QDateTime &  userActionTime 
)

Start a request to ensure that a channel exists, creating it if necessary. This initially just creates a PendingChannel object, which can be used to track the success or failure of the request.

Helper methods for text chat, text chat room, media call and conference are provided and should be used if appropriate.

The caller is responsible for closing the channel with Channel::requestClose() or Channel::requestLeave() when it has finished handling it.

A possible error returned by this method is #TELEPATHY_ERROR_NOT_YOURS, in case somebody else is already handling a channel that matches request.

Parameters:
requestA dictionary containing desirable properties.
userActionTimeThe time at which user action occurred, or QDateTime() if this channel request is for some reason not involving user action.
Returns:
A PendingChannel which will emit PendingChannel::finished successfully, when the Channel is available for handling using PendingChannel::channel(), or with an error if one has been encountered.
void Tp::Account::removed ( ) [signal]
void Tp::Account::serviceNameChanged ( const QString &  serviceName) [signal]

This signal is emitted when the value of serviceName() of this account changes.

Parameters:
serviceNameThe new service name of this account.
See also:
serviceName(), setServiceName()
void Tp::Account::profileChanged ( const Tp::ProfilePtr &  profile) [signal]

This signal is emitted when the value of profile() of this account changes.

Parameters:
profileThe new profile of this account.
See also:
profile()
void Tp::Account::displayNameChanged ( const QString &  displayName) [signal]

This signal is emitted when the value of displayName() of this account changes.

Parameters:
displayNameThe new display name of this account.
See also:
displayName(), setDisplayName()
void Tp::Account::iconNameChanged ( const QString &  iconName) [signal]

This signal is emitted when the value of iconName() of this account changes.

Parameters:
iconNameThe new icon name of this account.
See also:
iconName(), setIconName()
void Tp::Account::nicknameChanged ( const QString &  nickname) [signal]

This signal is emitted when the value of nickname() of this account changes.

Parameters:
nicknameThe new nickname of this account.
See also:
nickname(), setNickname()
void Tp::Account::normalizedNameChanged ( const QString &  normalizedName) [signal]

This signal is emitted when the value of normalizedName() of this account changes.

Parameters:
normalizedNameThe new normalized name of this account.
See also:
normalizedName()
void Tp::Account::validityChanged ( bool  validity) [signal]

This signal is emitted when the value of isValidAccount() of this account changes.

Parameters:
validityThe new validity of this account.
See also:
isValidAccount()
void Tp::Account::stateChanged ( bool  state) [signal]

This signal is emitted when the value of isEnabled() of this account changes.

Parameters:
stateThe new state of this account.
See also:
isEnabled()
void Tp::Account::capabilitiesChanged ( const Tp::ConnectionCapabilities capabilities) [signal]
void Tp::Account::connectsAutomaticallyPropertyChanged ( bool  connectsAutomatically) [signal]

This signal is emitted when the value of connectsAutomatically() of this account changes.

Parameters:
connectsAutomaticallyThe new value of connects automatically property of this account.
See also:
isEnabled()
void Tp::Account::firstOnline ( ) [signal]

This signal is emitted when this account is first put online.

See also:
hasBeenOnline()
void Tp::Account::parametersChanged ( const QVariantMap &  parameters) [signal]

This signal is emitted when the value of parameters() of this account changes.

Parameters:
parametersThe new parameters of this account.
See also:
parameters()
void Tp::Account::changingPresence ( bool  value) [signal]

This signal is emitted when the value of isChangingPresence() of this account changes.

Parameters:
valueWhether this account's connection is changing presence.
See also:
isChangingPresence()
void Tp::Account::automaticPresenceChanged ( const Tp::Presence automaticPresence) [signal]

This signal is emitted when the value of automaticPresence() of this account changes.

Parameters:
automaticPresenceThe new value of automatic presence property of this account.
See also:
automaticPresence()
void Tp::Account::currentPresenceChanged ( const Tp::Presence currentPresence) [signal]

This signal is emitted when the value of currentPresence() of this account changes.

Parameters:
currentPresenceThe new value of current presence property of this account.
See also:
currentPresence()
void Tp::Account::requestedPresenceChanged ( const Tp::Presence requestedPresence) [signal]

This signal is emitted when the value of requestedPresence() of this account changes.

Parameters:
requestedPresenceThe new value of requested presence property of this account.
See also:
requestedPresence()
void Tp::Account::onlinenessChanged ( bool  online) [signal]

This signal is emitted when the value of isOnline() of this account changes.

Parameters:
onlineWhether this account is online.
See also:
currentPresence()
void Tp::Account::avatarChanged ( const Tp::Avatar &  avatar) [signal]

This signal is emitted when the value of avatar() of this account changes.

Parameters:
avatarThe new avatar of this account.
See also:
avatar()
void Tp::Account::connectionStatusChanged ( Tp::ConnectionStatus  status) [signal]

This signal is emitted when the connection status of this account changes.

Parameters:
statusThe new status of this account connection.
statusReasonThe new status reason of this account connection.
errorNameThe D-Bus error name for the last disconnection or connection failure,
errorDetailsThe error details related to errorName.
See also:
connectionStatus(), connectionStatusReason(), connectionError(), connectionErrorDetails(), Connection::ErrorDetails
void Tp::Account::connectionChanged ( const Tp::ConnectionPtr &  connection) [signal]

This signal is emitted when the value of connection() of this account changes.

Parameters:
connectionA ConnectionPtr pointing to the new Connection object or a null ConnectionPtr if there is no connection.
See also:
connection()
Client::AccountInterface * Tp::Account::baseInterface ( ) const [protected]

Return the Client::AccountInterface interface proxy object for this account. This method is protected since the convenience methods provided by this class should generally be used instead of calling D-Bus methods directly.

Returns:
A pointer to the existing Client::AccountInterface object for this Account object.
Client::ChannelDispatcherInterface * Tp::Account::dispatcherInterface ( ) const [protected]

Return the Client::ChannelDispatcherInterface interface proxy object to use for requesting channels on this account.

This method is protected since the convenience methods provided by this class should generally be used instead of calling D-Bus methods directly.

Returns:
A pointer to the existing Client::ChannelDispatcherInterface object for this Account object.

Member Data Documentation

Feature representing the core that needs to become ready to make the Account object usable.

Note that this feature must be enabled in order to use most Account methods. See specific methods documentation for more details.

When calling isReady(), becomeReady(), this feature is implicitly added to the requested features.

Feature used in order to access account avatar info.

See avatar specific methods' documentation for more details.

Feature used in order to access account protocol info.

See protocol info specific methods' documentation for more details.

Feature used in order to access account capabilities.

This feature will enable FeatureProtocolInfo and FeatureProfile.

See capabilities specific methods' documentation for more details.

Feature used in order to access account profile info.

See profile specific methods' documentation for more details.


Property Documentation

bool Tp::Account::valid [read]
bool Tp::Account::enabled [read]
QString Tp::Account::cmName [read]

Return the connection manager name of this account.

This method requires Account::FeatureCore to be enabled.

Returns:
The connection manager name of this account.
QString Tp::Account::protocolName [read]

Return the protocol name of this account.

This method requires Account::FeatureCore to be enabled.

Returns:
The protocol name of this account.
QString Tp::Account::serviceName [read]

Return the service name of this account.

Note that this method will fallback to protocolName() if service name is not known.

This method requires Account::FeatureCore to be enabled.

Returns:
The service name of this account.
See also:
serviceNameChanged(), protocolName()
ProfilePtr Tp::Account::profile [read]

Return the profile used for this account.

Note that if a profile for serviceName() is not available, a fake profile (Profile::isFake() will return true) will be returned in case protocolInfo() is valid.

The fake profile will contain the following info:

This method requires Account::FeatureProfile to be enabled.

Returns:
The profile for this account.
See also:
profileChanged()
QString Tp::Account::displayName [read]

Return the display name of this account.

This method requires Account::FeatureCore to be enabled.

Returns:
The display name of this account.
See also:
displayNameChanged()
QString Tp::Account::iconName [read]

Return the icon name of this account.

This method requires Account::FeatureCore to be enabled.

If the account has no icon, and Account::FeatureProfile is enabled, the icon from the result of profile() will be used.

If neither the account nor the profile has an icon, and Account::FeatureProtocolInfo is enabled, the icon from protocolInfo() will be used if set.

As a last resort, "im-" + protocolName() will be returned.

This matches the fallbacks recommended by the Telepathy specification.

Returns:
The icon name of this account.
See also:
iconNameChanged()
QString Tp::Account::nickname [read]

Return the nickname of this account.

This method requires Account::FeatureCore to be enabled.

Returns:
The nickname of this account.
See also:
nicknameChanged()
AvatarSpec Tp::Account::avatarRequirements [read]

Return a AvatarSpec representing the avatar requirements (size limits, supported MIME types, etc) for avatars passed to setAvatar().

For now this method will only return the avatar requirements found in protocolInfo() if FeatureProtocolInfo is ready.

Returns:
The avatar requirements for avatars passed to setAvatar().
const Avatar & Tp::Account::avatar [read]

Return the avatar of this account.

This method requires Account::FeatureAvatar to be enabled.

Returns:
The avatar of this account.
See also:
avatarChanged()
QVariantMap Tp::Account::parameters [read]

Return the parameters of this account.

This method requires Account::FeatureCore to be enabled.

Returns:
The parameters of this account.
See also:
parametersChanged()
ProtocolInfo Tp::Account::protocolInfo [read]

Return the protocol info of this account protocol.

This method requires Account::FeatureProtocolInfo to be enabled.

Returns:
The protocol info of this account protocol.
ConnectionCapabilities Tp::Account::capabilities [read]

Return the capabilities for this account.

This method requires Account::FeatureCapabilities to be enabled.

Note that this method will return the connection() capabilities if the account is online and ready. If the account is disconnected, it will fallback to return the subtraction of the protocolInfo() capabilities and the profile unsupported capabilities.

Returns:
The capabilities for this account.
bool Tp::Account::hasBeenOnline [read]

Return whether this account has ever been put online successfully.

This property cannot change from true to false, only from false to true. When the account successfully goes online for the first time, or when it is detected that this has already happened, the firstOnline() signal is emitted.

This method requires Account::FeatureCore to be enabled.

Returns:
Whether the account has ever been online.
bool Tp::Account::connectsAutomatically [read]

Return whether this account should be put online automatically whenever possible.

This method requires Account::FeatureCore to be enabled.

Returns:
true if it should try to connect automatically, false otherwise.
See also:
connectsAutomaticallyPropertyChanged()
ConnectionStatus Tp::Account::connectionStatus [read]

Return the status of this account connection.

This method requires Account::FeatureCore to be enabled.

Returns:
The status of this account connection.
See also:
connectionStatusChanged()
ConnectionStatusReason Tp::Account::connectionStatusReason [read]

Return the status reason of this account connection.

This method requires Account::FeatureCore to be enabled.

Returns:
The status reason of this account connection.
See also:
connectionStatusChanged()
QString Tp::Account::connectionError [read]

Return the D-Bus error name for the last disconnection or connection failure, (in particular, #TELEPATHY_ERROR_CANCELLED if it was disconnected by user request), or an empty string if the account is connected.

This method requires Account::FeatureCore to be enabled.

Returns:
The D-Bus error name for the last disconnection or connection failure.
See also:
connectionErrorDetails(), connectionStatus(), connectionStatusReason(), connectionStatusChanged()
Connection::ErrorDetails Tp::Account::connectionErrorDetails [read]

Return a map containing extensible error details related to connectionError().

The keys for this map are defined by the Telepathy D-Bus Interface Specification. They will typically include <literal>debug-message</literal>, which is a debugging message in the C locale.

This method requires Account::FeatureCore to be enabled.

Returns:
A map containing extensible error details related to connectionError().
See also:
connectionError(), connectionStatus(), connectionStatusReason(), connectionStatusChanged(), Connection::ErrorDetails.
ConnectionPtr Tp::Account::connection [read]

Return the ConnectionPtr object of this account.

Note that the returned ConnectionPtr object will not be cached by the Account instance; applications should do it themselves.

Remember to call Connection::becomeReady on the new connection to make sure it is ready before using it.

This method requires Account::FeatureCore to be enabled.

Returns:
A ConnectionPtr object pointing to the Connection object of this account, or a null ConnectionPtr if this account does not currently have a connection or if an error occurred.
See also:
connectionChanged()
bool Tp::Account::changingPresence [read]
Presence Tp::Account::automaticPresence [read]

Return the presence status that this account will have set on it by the account manager if it brings it online automatically.

This method requires Account::FeatureCore to be enabled.

Returns:
The presence that will be set by the account manager if this account is brought online automatically by it.
See also:
automaticPresenceChanged()
Presence Tp::Account::currentPresence [read]

Return the actual presence of this account.

This method requires Account::FeatureCore to be enabled.

Returns:
The actual presence of this account.
See also:
currentPresenceChanged(), setRequestedPresence(), requestedPresence(), automaticPresence()
Presence Tp::Account::requestedPresence [read]

Return the requested presence of this account.

This method requires Account::FeatureCore to be enabled.

Returns:
The requested presence of this account.
See also:
requestedPresenceChanged(), setRequestedPresence(), currentPresence(), automaticPresence()
bool Tp::Account::online [read]
QString Tp::Account::uniqueIdentifier [read]

Return the unique identifier of this account.

This identifier should be unique per AccountManager implementation, i.e. at least per QDBusConnection.

Returns:
The unique identifier of this account.
QString Tp::Account::normalizedName [read]

Return the normalized user ID of the local user of this account.

It is unspecified whether this user ID is globally unique.

As currently implemented, IRC user IDs are only unique within the same IRCnet. On some saner protocols, the user ID includes a DNS name which provides global uniqueness.

If this value is not known yet (which will always be the case for accounts that have never been online), it will be an empty string.

It is possible that this value will change if the connection manager's normalization algorithm changes.

This method requires Account::FeatureCore to be enabled.

Returns:
Account normalized user ID of the local user.
See also:
normalizedNameChanged()


Copyright © 2008-2011 Collabora Ltd. and Nokia Corporation
Telepathy-Qt4 0.6.0