Another try replacing operationHandle with PendingOperation, to be
consistent with the rest of the library.
BR
Andrunko
typedef SharedPtr<ChannelDispatchOperation> ChannelDispatchOperationPtr;
typedef SharedPtr<ChannelRequest> ChannelRequestPtr;
class ChannelDispatchOperation : public StatefulDBusProxy,
private OptionalInterfaceFactory<ChannelDispatchOperation>,
public ReadyObject,
public SharedData
{
Q_OBJECT
public:
static ChannelDispatchOperationPtr create(const QString &objectPath,
const QVariantMap &immutableProperties);
~ChannelDispatchOperation();
AccountPtr account() const;
ConnectionPtr connection() const;
QList<ChannelPtr> channels() const;
QStringList possibleHandlers() const;
PendingOperation *handleWith(const QString &handler);
PendingOperation *claim();
Q_SIGNALS:
void channelLost(const QString &channelObjectPath, const QString &errorName,
const QString &errorMessage);
// TODO should we have finished, or use invalidated?
};
class ChannelRequest : public StatefulDBusProxy,
private OptionalInterfaceFactory<ChannelDispatchOperation>,
public ReadyObject,
public SharedData
{
Q_OBJECT
public:
static ChannelRequestPtr create(const QString &objectPath,
const QVariantMap &immutableProperties);
~ChannelRequest();
AccountPtr account() const;
QDateTime userActionTime() const;
QVariantMap requests() const;
PendingOperation *proceed();
PendingOperation *cancel();
Q_SIGNALS:
void failed(const QString &errorName, const QString &errorMessage);
void succeeded();
};
class BaseClient : public QObject
{
Q_OBJECT
public:
BaseClient(const QVariantMap &filters, QObject *parent = 0);
~BaseClient();
QVariantMap filters() const;
};
class BaseObserverClient : public BaseClient
{
public:
BaseObserver(const QVariantMap &filters, QObject *parent = 0);
virtual ~BaseObserver();
// call operation->setFinished/WithError when done with this method
virtual void observeChannels(PendingOperation *operation,
const AccountPtr &account,
const ConnectionPtr &connection,
const QList<ChannelPtr> &channels,
const ChannelDispatchOperationPtr &dispatchOperation) = 0;
};
class BaseApproverClient : public BaseClient
{
public:
BaseApprover(const QVariantMap &filters, QObject *parent = 0);
virtual ~BaseApprover();
// call operation->setFinished/WithError when done with this method
virtual void addDispatchOperation(PendingOperation *operation,
const ChannelDispatchOperationPtr &dispatchOperation) = 0;
};
class BaseHandlerClient : public BaseClient
{
public:
BaseHandler(const QVariantMap &filters, QObject *parent = 0);
virtual ~BaseHandler();
// addRequest/removeFailedRequest will only be called if true, default =
// true
void listenRequests(bool listen);
// call operation->setFinished/WithError when done with these methods
virtual void handleChannels(PendingOperation *operation,
const AccountPtr &account,
const ConnectionPtr &connection,
const QList<ChannelPtr> &channels,
const QList<ChannelRequestPtr> &requestsSatisfied,
const QDateTime &userActionTime) = 0;
virtual void addRequest(PendingOperation *operation,
const ChannelRequestPtr &request);
virtual void removeFailedRequest(PendingOperation *operation,
const ChannelRequestPtr &request,
const QString &error, const QString &message) = 0;
};
class ClientRegister : public QObject
{
public:
// clientName is the name to be used
ClientRegister(const QString &clientName, bool unique = false,
QObject *parent = 0);
~ClientRegister();
QString clientName() const;
bool addObserverClient(ObserverClient *client);
bool addApproverClient(ApproverClient *client);
bool addHandlerClient(HandlerClient *client);
bool registerClients();
// unregister all clients
void unregisterClients();
// unregister a given client if the client is registered
bool unregisterClient(BaseClient *client);
};
void MyHandler : public BaseHandlerClient
{
public:
MyHandler(const QVariantMap &filters, QObject *parent = 0);
~MyHandler();
void handleChannels(PendingOperation *operation,
const AccountPtr &account,
const ConnectionPtr &connection,
const QList<ChannelPtr> &channels,
const QStringList &requestsSatisfiedObjectPaths,
const QDateTime &userActionTime)
{
foreach (const ChannelPtr &channel, channels) {
MyHandlerUI *handlerUI = lookupHandlerUIByChannel(channel);
if (!handlerUI) {
// create handler UI to handle channel
...
}
handlerUI->show();
}
operation->setFinished();
}
virtual void addRequest(PendingOperation *operation,
const QString &requestObjectPath,
const QVariantMap &requestProperties)
{
...
operation->setFinished();
}
virtual void removeFailedRequest(PendingOperation *operation,
const QString &requestObjectPath,
const QString &error, const QString &message)
{
...
operation->setFinished();
}
};
ClientRegister *r = new ClientRegister("myclient");
QVariantMap map;
map.insert("org.freedesktop.Telepathy.Channel.ChannelType",
"org.freedesktop.Telepathy.Channel.Type.Text");
map.insert("org.freedesktop.Telepathy.Channel.TargetHandleType",
Telepathy::HandleTypeContact);
MyHandler *h = new MyHandler(filters, r);
r->addHandlerClient(h);
r->registerClients();
_______________________________________________
telepathy mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/telepathy
