705 lines
15 KiB
C++
705 lines
15 KiB
C++
|
/*
|
||
|
|
* SPDX-License-Identifier: LicenseRef-Unisoc-General-1.0
|
||
|
|
|
||
|
|
* Copyright 2016-2023 Unisoc (Shanghai) Technologies Co., Ltd
|
||
|
|
|
||
|
|
* Licensed under the Unisoc General Software License, version 1.0 (the License);
|
||
|
|
* you may not use this file except in compliance with the License. You may obtain a copy of the License at
|
||
|
|
|
||
|
|
* https://www.unisoc.com/en_us/license/UNISOC_GENERAL_LICENSE_V1.0-EN_US
|
||
|
|
|
||
|
|
* Software distributed under the License is distributed on an "AS IS" BASIS,
|
||
|
|
* WITHOUT WARRANTIES OF ANY KIND, either express or implied.
|
||
|
|
* See the Unisoc General Software License, version 1.0 for more details.
|
||
|
|
*/
|
||
|
|
#include <Message.h>
|
||
|
|
|
||
|
|
#include <dbus/dbus.h>
|
||
|
|
#include <cstdlib>
|
||
|
|
|
||
|
|
#include "InternalError.h"
|
||
|
|
#include "MessageInternal.h"
|
||
|
|
#include "Debug.h"
|
||
|
|
using namespace UDBus;
|
||
|
|
|
||
|
|
static bool isBasicType(int typeCode)
|
||
|
|
{
|
||
|
|
switch (typeCode) {
|
||
|
|
case DBUS_TYPE_DOUBLE:
|
||
|
|
case DBUS_TYPE_UINT64:
|
||
|
|
case DBUS_TYPE_INT64:
|
||
|
|
case DBUS_TYPE_UINT32:
|
||
|
|
case DBUS_TYPE_INT32:
|
||
|
|
case DBUS_TYPE_UINT16:
|
||
|
|
case DBUS_TYPE_INT16:
|
||
|
|
case DBUS_TYPE_STRING:
|
||
|
|
case DBUS_TYPE_OBJECT_PATH:
|
||
|
|
case DBUS_TYPE_UNIX_FD:
|
||
|
|
case DBUS_TYPE_BYTE:
|
||
|
|
case DBUS_TYPE_SIGNATURE:
|
||
|
|
case DBUS_TYPE_BOOLEAN:
|
||
|
|
return true;
|
||
|
|
default:
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter::MessageIter()
|
||
|
|
: mPrivate(new UDBusPrivate), mMsg(nullptr) {}
|
||
|
|
|
||
|
|
MessageIter::MessageIter(Message &msg)
|
||
|
|
: mPrivate(new UDBusPrivate), mMsg(&msg) {}
|
||
|
|
|
||
|
|
MessageIter::MessageIter(const MessageIter &iter)
|
||
|
|
: mPrivate(new UDBusPrivate(*iter.mPrivate)), mMsg(iter.mMsg) {}
|
||
|
|
|
||
|
|
MessageIter::~MessageIter()
|
||
|
|
{
|
||
|
|
delete mPrivate;
|
||
|
|
mPrivate = nullptr;
|
||
|
|
mMsg = nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter &MessageIter::operator =(const MessageIter &iter)
|
||
|
|
{
|
||
|
|
if (this != &iter) {
|
||
|
|
*mPrivate = *iter.mPrivate;
|
||
|
|
mMsg = iter.mMsg;
|
||
|
|
}
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendBasic(int type_id, void *value)
|
||
|
|
{
|
||
|
|
return dbus_message_iter_append_basic(&mPrivate->iter, type_id, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendFd(int fd)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_UNIX_FD, &fd);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendSignature(const char *chars)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_SIGNATURE, &chars);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendPath(const char *chars)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_OBJECT_PATH, &chars);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendArray(char type, const void *ptr, size_t length)
|
||
|
|
{
|
||
|
|
return dbus_message_iter_append_fixed_array(&mPrivate->iter, type, &ptr, length);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendByte(unsigned char b)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_BYTE, &b);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendDouble(double d)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_DOUBLE, &d);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendUint64(unsigned long long u)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_UINT64, &u);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendInt64(signed long long i)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_INT64, &i);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendUint32(unsigned int u)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_UINT32, &u);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendInt32(signed int i)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_INT32, &i);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendUint16(unsigned short u)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_UINT16, &u);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendInt16(signed short i)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_INT16, &i);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendString(const char *chars)
|
||
|
|
{
|
||
|
|
return AppendBasic(DBUS_TYPE_STRING, &chars);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AppendBool(bool b)
|
||
|
|
{
|
||
|
|
dbus_bool_t db = b ? TRUE : FALSE;
|
||
|
|
return AppendBasic(DBUS_TYPE_BOOLEAN, &db);
|
||
|
|
}
|
||
|
|
|
||
|
|
signed short MessageIter::GetInt16()
|
||
|
|
{
|
||
|
|
signed short i;
|
||
|
|
GetBasic(DBUS_TYPE_INT16, &i);
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned short MessageIter::GetUint16()
|
||
|
|
{
|
||
|
|
unsigned short u;
|
||
|
|
GetBasic(DBUS_TYPE_UINT16, &u);
|
||
|
|
return u;
|
||
|
|
}
|
||
|
|
|
||
|
|
signed int MessageIter::GetInt32()
|
||
|
|
{
|
||
|
|
signed int i;
|
||
|
|
GetBasic(DBUS_TYPE_INT32, &i);
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned int MessageIter::GetUint32()
|
||
|
|
{
|
||
|
|
unsigned int u;
|
||
|
|
GetBasic(DBUS_TYPE_UINT32, &u);
|
||
|
|
return u;
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned long long MessageIter::GetUint64()
|
||
|
|
{
|
||
|
|
unsigned long long u;
|
||
|
|
GetBasic(DBUS_TYPE_UINT64, &u);
|
||
|
|
return u;
|
||
|
|
}
|
||
|
|
|
||
|
|
signed long long MessageIter::GetInt64()
|
||
|
|
{
|
||
|
|
signed long long i;
|
||
|
|
GetBasic(DBUS_TYPE_INT64, &i);
|
||
|
|
return i;
|
||
|
|
}
|
||
|
|
|
||
|
|
double MessageIter::GetDouble()
|
||
|
|
{
|
||
|
|
double d;
|
||
|
|
GetBasic(DBUS_TYPE_DOUBLE, &d);
|
||
|
|
return d;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MessageIter::GetBasic(int type_id, void *ptr)
|
||
|
|
{
|
||
|
|
if (Type() != type_id)
|
||
|
|
throw ErrorInvalidArgs("type mismatch");
|
||
|
|
dbus_message_iter_get_basic(&mPrivate->iter, ptr);
|
||
|
|
}
|
||
|
|
|
||
|
|
unsigned char MessageIter::GetByte()
|
||
|
|
{
|
||
|
|
unsigned char b;
|
||
|
|
GetBasic(DBUS_TYPE_BYTE, &b);
|
||
|
|
return b;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::GetBool()
|
||
|
|
{
|
||
|
|
dbus_bool_t db;
|
||
|
|
GetBasic(DBUS_TYPE_BOOLEAN, &db);
|
||
|
|
return db ? true : false;
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *MessageIter::GetString()
|
||
|
|
{
|
||
|
|
char *chars;
|
||
|
|
GetBasic(DBUS_TYPE_STRING, &chars);
|
||
|
|
return chars;
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *MessageIter::GetPath()
|
||
|
|
{
|
||
|
|
char *path;
|
||
|
|
GetBasic(DBUS_TYPE_OBJECT_PATH, &path);
|
||
|
|
return path;
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *MessageIter::GetSignature()
|
||
|
|
{
|
||
|
|
char *signature;
|
||
|
|
GetBasic(DBUS_TYPE_SIGNATURE, &signature);
|
||
|
|
return signature;
|
||
|
|
}
|
||
|
|
|
||
|
|
int MessageIter::GetFd()
|
||
|
|
{
|
||
|
|
int fd;
|
||
|
|
GetBasic(DBUS_TYPE_UNIX_FD, &fd);
|
||
|
|
return fd;
|
||
|
|
}
|
||
|
|
|
||
|
|
int MessageIter::GetArray(void *ptr)
|
||
|
|
{
|
||
|
|
int length = 0;
|
||
|
|
dbus_message_iter_get_fixed_array(&mPrivate->iter, ptr, &length);
|
||
|
|
return length;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::AtEnd()
|
||
|
|
{
|
||
|
|
return Type() == DBUS_TYPE_INVALID;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::HasNext()
|
||
|
|
{
|
||
|
|
return dbus_message_iter_has_next(&mPrivate->iter);
|
||
|
|
}
|
||
|
|
|
||
|
|
char *MessageIter::Signature() const
|
||
|
|
{
|
||
|
|
return dbus_message_iter_get_signature(&mPrivate->iter);
|
||
|
|
}
|
||
|
|
|
||
|
|
int MessageIter::ArrayType()
|
||
|
|
{
|
||
|
|
return dbus_message_iter_get_element_type(&mPrivate->iter);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::IsDict()
|
||
|
|
{
|
||
|
|
return IsArray() && dbus_message_iter_get_element_type(&mPrivate->iter) == DBUS_TYPE_DICT_ENTRY;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool MessageIter::IsArray()
|
||
|
|
{
|
||
|
|
return dbus_message_iter_get_arg_type(&mPrivate->iter) == DBUS_TYPE_ARRAY;
|
||
|
|
}
|
||
|
|
|
||
|
|
int MessageIter::Type()
|
||
|
|
{
|
||
|
|
return dbus_message_iter_get_arg_type(&mPrivate->iter);
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter MessageIter::CreateVariant(const char *sig)
|
||
|
|
{
|
||
|
|
MessageIter var(Msg());
|
||
|
|
dbus_message_iter_open_container(
|
||
|
|
&mPrivate->iter, DBUS_TYPE_VARIANT, sig, &var.mPrivate->iter
|
||
|
|
);
|
||
|
|
return var;
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter MessageIter::CreateArray(const char *sig)
|
||
|
|
{
|
||
|
|
MessageIter arr(Msg());
|
||
|
|
dbus_message_iter_open_container(
|
||
|
|
&mPrivate->iter, DBUS_TYPE_ARRAY, sig, &arr.mPrivate->iter
|
||
|
|
);
|
||
|
|
return arr;
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter MessageIter::CreateDictEntry()
|
||
|
|
{
|
||
|
|
MessageIter ent(Msg());
|
||
|
|
dbus_message_iter_open_container(
|
||
|
|
&mPrivate->iter, DBUS_TYPE_DICT_ENTRY, nullptr, &ent.mPrivate->iter
|
||
|
|
);
|
||
|
|
return ent;
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter MessageIter::CreateStruct()
|
||
|
|
{
|
||
|
|
MessageIter stu(Msg());
|
||
|
|
dbus_message_iter_open_container(
|
||
|
|
&mPrivate->iter, DBUS_TYPE_STRUCT, nullptr, &stu.mPrivate->iter
|
||
|
|
);
|
||
|
|
return stu;
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter MessageIter::Recurse()
|
||
|
|
{
|
||
|
|
MessageIter iter(Msg());
|
||
|
|
dbus_message_iter_recurse(&mPrivate->iter, &iter.mPrivate->iter);
|
||
|
|
return iter;
|
||
|
|
}
|
||
|
|
|
||
|
|
void MessageIter::CloseContainer(MessageIter &container)
|
||
|
|
{
|
||
|
|
dbus_message_iter_close_container(&mPrivate->iter, &container.mPrivate->iter);
|
||
|
|
}
|
||
|
|
|
||
|
|
void MessageIter::CopyData(MessageIter &dest)
|
||
|
|
{
|
||
|
|
for (MessageIter &orig = *this; !orig.AtEnd(); ++orig) {
|
||
|
|
if (isBasicType(orig.Type())) {
|
||
|
|
unsigned char variant[8];
|
||
|
|
orig.GetBasic(orig.Type(), &variant);
|
||
|
|
dest.AppendBasic(orig.Type(), &variant);
|
||
|
|
} else {
|
||
|
|
MessageIter dest_container (dest.Msg());
|
||
|
|
MessageIter orig_container = orig.Recurse();
|
||
|
|
char *signature = orig_container.Signature();
|
||
|
|
dbus_message_iter_open_container(
|
||
|
|
&dest.mPrivate->iter, orig.Type(),
|
||
|
|
orig.Type() == DBUS_TYPE_DICT_ENTRY ||
|
||
|
|
orig.Type() == DBUS_TYPE_STRUCT
|
||
|
|
? nullptr: signature,
|
||
|
|
&dest_container.mPrivate->iter);
|
||
|
|
|
||
|
|
orig_container.CopyData(dest_container);
|
||
|
|
dest.CloseContainer(dest_container);
|
||
|
|
free(signature);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter MessageIter::operator ++(int)
|
||
|
|
{
|
||
|
|
MessageIter copy(*this);
|
||
|
|
++(*this);
|
||
|
|
return copy;
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter &MessageIter::operator ++()
|
||
|
|
{
|
||
|
|
dbus_message_iter_next(&mPrivate->iter);
|
||
|
|
return (*this);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*/
|
||
|
|
|
||
|
|
Message::Message()
|
||
|
|
: mPrivate(new UDBusPrivate)
|
||
|
|
{
|
||
|
|
isSync = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
Message::Message(Message::UDBusPrivate *p, bool incref)
|
||
|
|
: mPrivate(p)
|
||
|
|
{
|
||
|
|
if (mPrivate->msg && incref) dbus_message_ref(mPrivate->msg);
|
||
|
|
isSync = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
Message::Message(const Message &m)
|
||
|
|
: mPrivate(m.mPrivate)
|
||
|
|
{
|
||
|
|
if (mPrivate->msg)
|
||
|
|
dbus_message_ref(mPrivate->msg);
|
||
|
|
isSync = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
Message::~Message()
|
||
|
|
{
|
||
|
|
if (mPrivate->msg)
|
||
|
|
dbus_message_unref(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
Message &Message::operator = (const Message &m)
|
||
|
|
{
|
||
|
|
if (&m != this) {
|
||
|
|
if (mPrivate->msg)
|
||
|
|
dbus_message_unref(mPrivate->msg);
|
||
|
|
mPrivate = m.mPrivate;
|
||
|
|
if (mPrivate->msg)
|
||
|
|
dbus_message_ref(mPrivate->msg);
|
||
|
|
}
|
||
|
|
isSync = m.isSync;
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Message::GetSync()
|
||
|
|
{
|
||
|
|
return isSync;
|
||
|
|
}
|
||
|
|
|
||
|
|
UDBus::Tag *Message::GetTag() const
|
||
|
|
{
|
||
|
|
return mPrivate->tag;
|
||
|
|
}
|
||
|
|
|
||
|
|
const char* Message::GetErrorName() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_error_name(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *Message::Destination() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_destination(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *Message::Sender() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_sender(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
int Message::ReplySerial() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_reply_serial(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
int Message::Serial() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_serial(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Message::SetReplySerial(int s)
|
||
|
|
{
|
||
|
|
return dbus_message_set_reply_serial(mPrivate->msg, s);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Message::SetSender(const char *s)
|
||
|
|
{
|
||
|
|
return dbus_message_set_sender(mPrivate->msg, s);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Message::SetDestination(const char *s)
|
||
|
|
{
|
||
|
|
return dbus_message_set_destination(mPrivate->msg, s);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Message::SetSync(bool sync)
|
||
|
|
{
|
||
|
|
isSync = sync;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Message::IsError() const
|
||
|
|
{
|
||
|
|
return Type() == DBUS_MESSAGE_TYPE_ERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Message::IsSignal(const char *interface, const char* member) const
|
||
|
|
{
|
||
|
|
return dbus_message_is_signal(mPrivate->msg, interface, member);
|
||
|
|
}
|
||
|
|
|
||
|
|
void Message::Terminate()
|
||
|
|
{
|
||
|
|
dbus_message_append_args(mPrivate->msg, DBUS_TYPE_INVALID);
|
||
|
|
}
|
||
|
|
|
||
|
|
int Message::Type() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_type(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
Message Message::Copy()
|
||
|
|
{
|
||
|
|
UDBusPrivate *pvt = new UDBusPrivate(mPrivate->msg ? dbus_message_copy(mPrivate->msg) : nullptr);
|
||
|
|
return Message(pvt);
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter Message::Writer()
|
||
|
|
{
|
||
|
|
MessageIter iter(*this);
|
||
|
|
dbus_message_iter_init_append(mPrivate->msg, &iter.mPrivate->iter);
|
||
|
|
return iter;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool Message::Append(int orig, ...)
|
||
|
|
{
|
||
|
|
va_list val_list;
|
||
|
|
va_start(val_list, orig);
|
||
|
|
bool ret = dbus_message_append_args_valist(mPrivate->msg, orig, val_list);
|
||
|
|
va_end(val_list);
|
||
|
|
return ret;
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageIter Message::Reader() const
|
||
|
|
{
|
||
|
|
MessageIter iter(const_cast<Message &>(*this));
|
||
|
|
dbus_message_iter_init(mPrivate->msg, &iter.mPrivate->iter);
|
||
|
|
return iter;
|
||
|
|
}
|
||
|
|
|
||
|
|
void CallMessage::Ref(void)
|
||
|
|
{
|
||
|
|
if (mPrivate->msg)
|
||
|
|
dbus_message_ref(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
void CallMessage::Unref(void)
|
||
|
|
{
|
||
|
|
if (mPrivate->msg)
|
||
|
|
dbus_message_unref(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
UDbusErrorMessage::UDbusErrorMessage()
|
||
|
|
{
|
||
|
|
mPrivate->msg = dbus_message_new(DBUS_MESSAGE_TYPE_ERROR);
|
||
|
|
}
|
||
|
|
|
||
|
|
UDbusErrorMessage::UDbusErrorMessage(const Message &to_reply, const char *name, const char *message)
|
||
|
|
{
|
||
|
|
mPrivate->msg = dbus_message_new_error(to_reply.mPrivate->msg, name, message);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool UDbusErrorMessage::operator == (const UDbusErrorMessage &m) const
|
||
|
|
{
|
||
|
|
return dbus_message_is_error(mPrivate->msg, m.GetName());
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *UDbusErrorMessage::GetName() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_error_name(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool UDbusErrorMessage::SetName(const char *n)
|
||
|
|
{
|
||
|
|
return dbus_message_set_error_name(mPrivate->msg, n);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*/
|
||
|
|
|
||
|
|
SignalMessage::SignalMessage(const char *name)
|
||
|
|
{
|
||
|
|
mPrivate->msg = dbus_message_new(DBUS_MESSAGE_TYPE_SIGNAL);
|
||
|
|
SetMember(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
SignalMessage::SignalMessage(const char *path, const char *interface, const char *name)
|
||
|
|
{
|
||
|
|
mPrivate->msg = dbus_message_new_signal(path, interface, name);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool SignalMessage::operator == (const SignalMessage &m) const
|
||
|
|
{
|
||
|
|
return dbus_message_is_signal(mPrivate->msg, m.GetInterface(), m.GetMember());
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *SignalMessage::GetInterface() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_interface(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool SignalMessage::SetInterface(const char *i)
|
||
|
|
{
|
||
|
|
return dbus_message_set_interface(mPrivate->msg, i);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *SignalMessage::GetMember() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_member(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool SignalMessage::SetMember(const char *m)
|
||
|
|
{
|
||
|
|
return dbus_message_set_member(mPrivate->msg, m);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *SignalMessage::GetPath() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_path(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
char **SignalMessage::GetPathSplit() const
|
||
|
|
{
|
||
|
|
char **p = nullptr;
|
||
|
|
dbus_message_get_path_decomposed(mPrivate->msg, &p); //todo: return as a std::vector ?
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool SignalMessage::SetPath(const char *p)
|
||
|
|
{
|
||
|
|
return dbus_message_set_path(mPrivate->msg, p);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
*/
|
||
|
|
|
||
|
|
CallMessage::CallMessage()
|
||
|
|
{
|
||
|
|
mPrivate->msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
|
||
|
|
}
|
||
|
|
|
||
|
|
CallMessage &CallMessage::operator = (const CallMessage &m)
|
||
|
|
{
|
||
|
|
if (&m != this) {
|
||
|
|
if (mPrivate->msg)
|
||
|
|
dbus_message_unref(mPrivate->msg);
|
||
|
|
mPrivate = m.mPrivate;
|
||
|
|
if (mPrivate->msg)
|
||
|
|
dbus_message_ref(mPrivate->msg);
|
||
|
|
}
|
||
|
|
return *this;
|
||
|
|
}
|
||
|
|
|
||
|
|
CallMessage::CallMessage(const char *dest, const char *path, const char *iface, const char *method)
|
||
|
|
{
|
||
|
|
mPrivate->msg = dbus_message_new_method_call(dest, path, iface, method);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CallMessage::operator == (const CallMessage &m) const
|
||
|
|
{
|
||
|
|
return dbus_message_is_method_call(mPrivate->msg, m.GetInterface(), m.GetMember());
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *CallMessage::GetInterface() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_interface(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CallMessage::SetInterface(const char *i)
|
||
|
|
{
|
||
|
|
return dbus_message_set_interface(mPrivate->msg, i);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *CallMessage::GetMember() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_member(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CallMessage::SetMember(const char *m)
|
||
|
|
{
|
||
|
|
return dbus_message_set_member(mPrivate->msg, m);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *CallMessage::GetPath() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_path(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
char **CallMessage::GetPathSplit() const
|
||
|
|
{
|
||
|
|
char **p = nullptr;
|
||
|
|
dbus_message_get_path_decomposed(mPrivate->msg, &p);
|
||
|
|
return p;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CallMessage::SetPath(const char *p)
|
||
|
|
{
|
||
|
|
return dbus_message_set_path(mPrivate->msg, p);
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *CallMessage::GetSignature() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_signature(mPrivate->msg);
|
||
|
|
}
|
||
|
|
|
||
|
|
TagMessage::TagMessage(UDBus::Tag *tag)
|
||
|
|
{
|
||
|
|
mPrivate->tag = tag;
|
||
|
|
}
|
||
|
|
|
||
|
|
ReturnMessage::ReturnMessage(const CallMessage &callee)
|
||
|
|
{
|
||
|
|
mPrivate = new UDBusPrivate(dbus_message_new_method_return(callee.mPrivate->msg));
|
||
|
|
}
|
||
|
|
|
||
|
|
ReturnMessage::ReturnMessage()
|
||
|
|
{
|
||
|
|
mPrivate = nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
const char *ReturnMessage::GetSignature() const
|
||
|
|
{
|
||
|
|
return dbus_message_get_signature(mPrivate->msg);
|
||
|
|
}
|