static void signalCallback( GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
AutomotiveManager* manager = static_cast<AutomotiveManager*>(user_data);
if(!manager)
{
DebugOut(DebugOut::Error)<<"Bad user_data"<<endl;
return;
}
gchar* name=nullptr;
gchar* newOwner=nullptr;
gchar* oldOwner = nullptr;
g_variant_get(parameters,"(sss)",&name, &oldOwner, &newOwner);
std::list<AbstractDBusInterface*> toRemove;
if(std::string(newOwner) == "")
{
for(auto &i : manager->subscribedProcesses)
{
AbstractDBusInterface* iface = i.first;
for(auto itr = i.second.begin(); itr != i.second.end(); itr++)
{
std::string n = *itr;
if(n == name)
{
DebugOut()<<"unreferencing "<<n<<" from the subscription of "<<iface->objectPath()<<endl;
itr = manager->subscribedProcesses[iface].erase(itr);
DebugOut()<<"new ref count: "<<manager->subscribedProcesses[iface].size()<<endl;
}
}
if(manager->subscribedProcesses[iface].empty())
{
DebugOut()<<"No more subscribers. Unregistering: "<<iface->objectPath()<<endl;
///Defer removal to not screw up the list
toRemove.push_back(iface);
iface->unregisterObject();
}
}
for(auto & i : toRemove)
{
manager->subscribedProcesses.erase(i);
}
}
g_free(name);
g_free(newOwner);
g_free(oldOwner);
}
std::list<AbstractDBusInterface *> AbstractDBusInterface::getObjectsForProperty(string object)
{
std::list<AbstractDBusInterface *> l;
for(auto itr = objectMap.begin(); itr != objectMap.end(); itr++)
{
AbstractDBusInterface * interface = (*itr).second;
if(interface->objectName() == object)
l.push_back(interface);
}
return l;
}
static void signalCallback( GDBusConnection *connection,
const gchar *sender_name,
const gchar *object_path,
const gchar *interface_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
{
AutomotiveManager* manager = static_cast<AutomotiveManager*>(user_data);
gchar* name=nullptr;
gchar* newOwner=nullptr;
gchar* oldOwner = nullptr;
g_variant_get(parameters,"(sss)",&name, &oldOwner, &newOwner);
if(std::string(newOwner) == "")
{
for(auto i : manager->subscribedProcesses)
{
AbstractDBusInterface* iface = i.first;
for(auto n : i.second)
{
if(n == name)
{
DebugOut()<<"unreferencing "<<n<<" from the subscription of "<<iface->objectPath()<<endl;
manager->subscribedProcesses[iface].remove(n);
}
}
if(manager->subscribedProcesses[iface].empty())
{
DebugOut()<<"No more subscribers. Unregistering."<<endl;
iface->unregisterObject();
}
}
}
g_free(name);
g_free(newOwner);
g_free(oldOwner);
}
static void handleMethodCall(GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
AutomotiveManager* manager = static_cast<AutomotiveManager*>(user_data);
std::string method = method_name;
if(method == "findProperty")
{
DebugOut(DebugOut::Warning)<<"org.automotive.Manager.findProperty() is deprecated. Use org.automotive.Manager.FindObject() instead."<<endl;
gchar* arg;
g_variant_get(parameters,"(s)",&arg);
std::string objectToFind = arg;
if(objectToFind == "")
{
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(objectToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.PropertyNotFound", "Object not found");
return;
}
auto itr = interfaces.begin();
g_dbus_method_invocation_return_value(invocation, g_variant_new("(o)",(*itr)->objectPath().c_str()));
///TODO: we might need to clean up stuff there (like var)
}
else if(method == "FindObject")
{
gchar* arg;
g_variant_get(parameters,"(s)",&arg);
std::string objectToFind = arg;
if(objectToFind == "")
{
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(objectToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Object not found");
return;
}
GVariantBuilder params;
g_variant_builder_init(¶ms, G_VARIANT_TYPE_ARRAY);
for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++)
{
AbstractDBusInterface* t = *itr;
if(!t->isSupported())
continue;
GVariant *newvar = g_variant_new("o",t->objectPath().c_str());
g_variant_builder_add_value(¶ms, newvar);
}
//GVariant* var = g_variant_builder_end(¶ms);
g_dbus_method_invocation_return_value(invocation, g_variant_new("(ao)",¶ms));
///TODO: we might need to clean up stuff there (like var)
}
else if(method == "FindObjectForZone")
{
gchar* arg;
int zone;
g_variant_get(parameters,"(si)", &arg, &zone);
std::string propertyToFind = arg;
if(propertyToFind == "")
{
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(propertyToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found");
return;
}
for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++)
{
AbstractDBusInterface* t = *itr;
if(t->zone() == (Zone::Type)zone)
{
g_dbus_method_invocation_return_value(invocation,g_variant_new("(o)", t->objectPath().c_str()));
return;
}
}
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found");
}
else if (method == "ZonesForObjectName")
{
gchar* arg;
g_variant_get(parameters,"(s)",&arg);
std::string propertyToFind = arg;
if(propertyToFind == "")
{
g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(propertyToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found");
return;
}
GVariantBuilder params;
g_variant_builder_init(¶ms, G_VARIANT_TYPE_ARRAY);
for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++)
{
AbstractDBusInterface* t = *itr;
GVariant *newvar = g_variant_new("i",t->zone());
g_variant_builder_add_value(¶ms, newvar);
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(ai)",¶ms));
}
else if(method == "List")
{
std::list<AbstractDBusInterface*> list = AbstractDBusInterface::interfaces();
if(!list.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.Error", "No supported objects");
return;
}
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
for(auto itr = list.begin(); itr != list.end(); itr++)
{
if(!(*itr)->isSupported())
continue;
std::string objectName = (*itr)->objectName();
g_variant_builder_add(&builder, "s", objectName.c_str());
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(as)",&builder));
}
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_UNKNOWN_METHOD, "Unknown method.");
}
static void handleMethodCall(GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
AutomotiveManager* manager = static_cast<AutomotiveManager*>(user_data);
std::string method = method_name;
uint pid = getPid(sender);
if(DebugOut::getDebugThreshhold() >= 6)
{
DebugOut(6)<<"DBus method call from: "<<sender<< " pid: " <<pid<< " interface: "<<interface_name<<" method: "<<method<<endl;
DebugOut(6)<<"DBus method call path: "<<object_path<<endl;
}
if(method == "FindObject")
{
gchar* arg;
g_variant_get(parameters,"(s)",&arg);
std::string objectToFind = arg;
if(objectToFind == "")
{
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(objectToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Object not found");
return;
}
GVariantBuilder params;
g_variant_builder_init(¶ms, G_VARIANT_TYPE_ARRAY);
bool hasItems = false;
for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++)
{
AbstractDBusInterface* t = *itr;
if(!t->isSupported())
continue;
hasItems = true;
if(!t->isRegistered())
t->registerObject();
std::list<std::string> processes = manager->subscribedProcesses[t];
if(!contains(processes,sender))
{
DebugOut()<<"Referencing "<<t->objectPath()<<" with sender: "<<sender<<endl;
manager->subscribedProcesses[t].push_back(sender);
}
GVariant *newvar = g_variant_new("o",t->objectPath().c_str());
g_variant_builder_add_value(¶ms, newvar);
}
if(hasItems)
g_dbus_method_invocation_return_value(invocation, g_variant_new("(ao)",¶ms));
else
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found");
}
else if(method == "FindObjectForZone")
{
gchar* arg;
int zone;
g_variant_get(parameters,"(si)", &arg, &zone);
std::string propertyToFind = arg;
if(propertyToFind == "")
{
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(propertyToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation, "org.automotive.Manager.ObjectNotFound", "Property not found");
return;
}
for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++)
{
AbstractDBusInterface* t = *itr;
if(t->zone() == (Zone::Type)zone)
{
if(!t->isRegistered())
t->registerObject();
std::list<std::string> processes = manager->subscribedProcesses[t];
if(!contains(processes,sender))
{
DebugOut()<<"Referencing "<<t->objectPath()<<" with sender: "<<sender<<endl;
manager->subscribedProcesses[t].push_back(sender);
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(o)", t->objectPath().c_str()));
return;
}
}
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.InvalidZone", "zone not found");
}
else if (method == "ZonesForObjectName")
{
gchar* arg;
g_variant_get(parameters,"(s)",&arg);
std::string propertyToFind = arg;
if(propertyToFind == "")
{
g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(propertyToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found");
return;
}
GVariantBuilder params;
g_variant_builder_init(¶ms, G_VARIANT_TYPE_ARRAY);
for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++)
{
AbstractDBusInterface* t = *itr;
GVariant *newvar = g_variant_new("i",t->zone());
g_variant_builder_add_value(¶ms, newvar);
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(ai)",¶ms));
}
else if(method == "List")
{
std::list<AbstractDBusInterface*> list = AbstractDBusInterface::interfaces();
if(!list.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.Error", "No supported objects");
return;
}
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
for(auto itr = list.begin(); itr != list.end(); itr++)
{
if(!(*itr)->isSupported())
continue;
std::string objectName = (*itr)->objectName();
g_variant_builder_add(&builder, "s", objectName.c_str());
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(as)",&builder));
}
else if(method == "SourcesForObjectName")
{
gchar* arg;
g_variant_get(parameters,"(s)",&arg);
std::string propertyToFind = arg;
if(propertyToFind == "")
{
g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(propertyToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found");
return;
}
GVariantBuilder params;
g_variant_builder_init(¶ms, G_VARIANT_TYPE_ARRAY);
for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++)
{
AbstractDBusInterface* t = *itr;
string source = t->source();
boost::algorithm::erase_all(source, "-");
GVariant *newvar = g_variant_new("s", source.c_str());
g_variant_builder_add_value(¶ms, newvar);
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(as)",¶ms));
}
else if(method == "FindObjectForSourceZone")
{
gchar* arg;
gchar* arg2;
int zone;
g_variant_get(parameters,"(ssi)", &arg, &arg2, &zone);
std::string propertyToFind = arg;
std::string source = arg2;
if(propertyToFind == "" || source == "")
{
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_INVALID_ARGS, "Invalid argument.");
return;
}
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(propertyToFind);
if(!interfaces.size())
{
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found");
return;
}
for(auto itr = interfaces.begin(); itr != interfaces.end(); itr++)
{
AbstractDBusInterface* t = *itr;
string targetSource = t->source();
boost::algorithm::erase_all(targetSource, "-");
if(t->zone() == (Zone::Type)zone && source == targetSource)
{
if(!t->isRegistered())
t->registerObject();
std::list<std::string> processes = manager->subscribedProcesses[t];
if(!contains(processes,sender))
{
DebugOut()<<"Referencing "<<t->objectPath()<<" with sender: "<<sender<<endl;
manager->subscribedProcesses[t].push_back(sender);
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(o)", t->objectPath().c_str()));
return;
}
}
g_dbus_method_invocation_return_dbus_error(invocation,"org.automotive.Manager.ObjectNotFound", "Property not found");
}
else if(method == "SupportsProperty")
{
gchar* objectName;
gchar* propertyToFindStr;
g_variant_get(parameters,"(ss)",&objectName, &propertyToFindStr);
auto objectNamePtr = amb::make_super(objectName);
auto propertyToFindStrPtr = amb::make_super(propertyToFindStr);
DebugOut(6) << "Checking " << objectNamePtr.get() << " for member: " << propertyToFindStrPtr.get() << endl;
std::list<AbstractDBusInterface*> interfaces = AbstractDBusInterface::getObjectsForProperty(objectNamePtr.get());
for(auto i : interfaces)
{
if(i->hasPropertyDBus(propertyToFindStrPtr.get()))
{
DebugOut(6) << "member " << propertyToFindStrPtr.get() << " of " << objectNamePtr.get() << " was found!!" << endl;
g_dbus_method_invocation_return_value(invocation, g_variant_new("(b)", true));
return;
}
}
DebugOut(6) << "member " << propertyToFindStrPtr.get() << " of " << objectNamePtr.get() << " was not found." << endl;
g_dbus_method_invocation_return_value(invocation,g_variant_new("(b)", false));
}
else
{
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_UNKNOWN_METHOD, "Unknown method.");
}
}
void AbstractDBusInterface::handleMyMethodCall(GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
const gchar *interface_name,
const gchar *method_name,
GVariant *parameters,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
std::string method = method_name;
AbstractDBusInterface* iface = static_cast<AbstractDBusInterface*>(user_data);
if(DebugOut::getDebugThreshhold() >= 6)
{
DebugOut(6)<<"DBus method call from: "<<sender<< " pid: " <<getPid(sender)<< " interface: "<<interface_name<<" method: "<<method<<endl;
DebugOut(6)<<"DBus method call path: "<<object_path<<endl;
}
g_assert(iface);
if(std::string(interface_name) == "org.freedesktop.DBus.Properties")
{
if(method == "Get")
{
gchar* propertyName = nullptr;
gchar* ifaceName = nullptr;
g_variant_get(parameters, "(ss)", &ifaceName, &propertyName);
DebugOut(6) << "Parameter signature: " << g_variant_get_type_string(parameters) << endl;
// DebugOut(6) << "Get property " << propertyName << " for interface " << ifaceName << endl;
GError* error = nullptr;
auto value = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, propertyName, &error, iface);
amb::make_super(error);
if(!value)
{
g_dbus_method_invocation_return_dbus_error(invocation, std::string(std::string(ifaceName)+".PropertyNotFound").c_str(), "Property not found in interface");
}
g_dbus_method_invocation_return_value(invocation, g_variant_new("(v)", value));
return;
}
else if(method == "GetAll")
{
gchar* ifaceName = nullptr;
g_variant_get(parameters, "(s)", &ifaceName);
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
auto propertyMap = iface->getProperties();
for(auto itr : propertyMap)
{
auto prop = itr.second;
GError* error = nullptr;
auto value = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, prop->name().c_str(), &error, iface);
amb::make_super(error);
g_variant_builder_add(&builder, "{sv}", prop->name().c_str(), g_variant_new("v", value));
//sequence
auto sequence = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, std::string(prop->name()+"Sequence").c_str(), &error, iface);
g_variant_builder_add(&builder, "{sv}", std::string(prop->name()+"Sequence").c_str(), g_variant_new("v", sequence));
auto quality = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, std::string(prop->name()+"ValueQuality").c_str(), &error, iface);
g_variant_builder_add(&builder, "{sv}", std::string(prop->name()+"ValueQuality").c_str(), g_variant_new("v", quality));
auto freq = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, std::string(prop->name()+"UpdateFrequency").c_str(), &error, iface);
g_variant_builder_add(&builder, "{sv}", std::string(prop->name()+"UpdateFrequency").c_str(), g_variant_new("v", freq));
}
auto time = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, "Time", nullptr, iface);
auto zone = AbstractDBusInterface::getProperty(connection, sender, object_path, ifaceName, "Zone", nullptr, iface);
g_variant_builder_add(&builder, "{sv}", "Time", g_variant_new("v", time));
g_variant_builder_add(&builder, "{sv}", "Zone", g_variant_new("v", zone));
g_dbus_method_invocation_return_value(invocation, g_variant_new("(a{sv})", &builder));
return;
}
else if(method == "Set")
{
gchar* ifaceName = nullptr;
gchar* propName = nullptr;
GVariant* value;
g_variant_get(parameters, "(ssv)", &ifaceName, &propName, &value);
AbstractDBusInterface::setProperty(connection, sender, object_path, ifaceName, propName, value, nullptr, iface,
[&invocation, &ifaceName](bool success, AsyncPropertyReply::Error error) {
if(success)
{
g_dbus_method_invocation_return_value(invocation, nullptr);
}
else
{
g_dbus_method_invocation_return_dbus_error(invocation, ifaceName, AsyncPropertyReply::errorToStr(error).c_str());
}
});
return;
}
}
else if(method == "GetHistory")
{
double beginTime = 0;
double endTime = 0;
g_variant_get(parameters, "(dd)", &beginTime, &endTime);
auto propertyMap = iface->getProperties();
PropertyList propertyList;
for(auto itr = propertyMap.begin(); itr != propertyMap.end(); itr++)
{
VariantType* prop = (*itr).second;
if(!contains(propertyList, prop->ambPropertyName()))
propertyList.push_back(prop->ambPropertyName());
}
std::string ifaceName = iface->interfaceName();
AsyncRangePropertyRequest request;
request.properties = propertyList;
request.timeBegin = beginTime;
request.timeEnd = endTime;
request.zone = iface->zone();
//request.sourceUuid = iface->source();
request.completed = [&invocation,&ifaceName](AsyncRangePropertyReply* r)
{
auto reply = amb::make_unique(r);
if(!reply->success)
{
stringstream str;
str<<"Error during request: "<<AsyncPropertyReply::errorToStr(reply->error);
ifaceName += ".Error";
g_dbus_method_invocation_return_dbus_error(invocation, ifaceName.c_str(), str.str().c_str());
return;
}
if(!reply->values.size())
{
ifaceName += ".Error";
g_dbus_method_invocation_return_dbus_error(invocation, ifaceName.c_str(), "No results");
return;
}
GVariantBuilder builder;
g_variant_builder_init(&builder, G_VARIANT_TYPE("a{svd}"));
for(auto itr = reply->values.begin(); itr != reply->values.end(); itr++)
{
AbstractPropertyType* value = *itr;
g_variant_builder_add(&builder, "{svd}", value->name.c_str(), g_variant_ref(value->toVariant()),value->timestamp);
}
g_dbus_method_invocation_return_value(invocation,g_variant_new("(a{svd})",&builder));
};
iface->re->getRangePropertyAsync(request);
return;
}
g_dbus_method_invocation_return_error(invocation,G_DBUS_ERROR,G_DBUS_ERROR_UNKNOWN_METHOD, "Unknown method.");
}
GVariant* AbstractDBusInterface::getProperty(GDBusConnection* connection, const gchar* sender, const gchar* objectPath, const gchar* interfaceName,
const gchar* propertyName, GError** error, gpointer userData)
{
if(DebugOut::getDebugThreshhold() >= 6)
{
DebugOut(6)<<"DBus GetProperty call from: "<<sender<< " pid: " <<getPid(sender)<< " interface: "<<interfaceName<<" property: "<<propertyName<<endl;
DebugOut(6)<<"DBus GetProperty call path: "<<objectPath<<endl;
}
std::string pn = propertyName;
if(pn == "Time")
{
if(objectMap.find(objectPath) == objectMap.end())
{
DebugOut(DebugOut::Error)<<objectPath<<" is not a valid object path."<<endl;
return nullptr;
}
double time = objectMap[objectPath]->time();
GVariant* value = g_variant_new("d", time);
return value;
}
else if(boost::ends_with(pn, "Sequence"))
{
AbstractDBusInterface* t = static_cast<AbstractDBusInterface*>(userData);
int pos = pn.find("Sequence");
std::string p = pn.substr(0,pos);
VariantType * theProperty = t->property(p);
if(!theProperty)
{
DebugOut(DebugOut::Error)<<"Invalid Sequence property: "<<p<<endl;
return nullptr;
}
int sequence = theProperty->sequence();
GVariant* value = g_variant_new("i", sequence);
return value;
}
else if(boost::ends_with(pn, "ValueQuality"))
{
AbstractDBusInterface* t = static_cast<AbstractDBusInterface*>(userData);
int pos = pn.find("ValueQuality");
std::string p = pn.substr(0, pos);
VariantType * theProperty = t->property(p);
if(!theProperty)
{
DebugOut(DebugOut::Error)<<"Invalid ValueQuality property: "<<p<<endl;
return nullptr;
}
int quality = theProperty->value()->valueQuality;
GVariant* value = g_variant_new("i", quality);
return value;
}
else if(boost::ends_with(pn, "UpdateFrequency"))
{
AbstractDBusInterface* t = static_cast<AbstractDBusInterface*>(userData);
int pos = pn.find("UpdateFrequency");
std::string p = pn.substr(0, pos);
VariantType * theProperty = t->property(p);
if(!theProperty)
{
DebugOut(DebugOut::Error)<<"Invalid UpdateFrequency property: "<<p<<endl;
return nullptr;
}
int freq = theProperty->updateFrequency();
GVariant* value = g_variant_new("i", freq);
return value;
}
else if(pn == "Zone")
{
if(objectMap.find(objectPath) == objectMap.end())
{
DebugOut(DebugOut::Error)<<objectPath<<" is not a valid object path."<<endl;
return nullptr;
}
Zone::Type zone = objectMap[objectPath]->zone();
GVariant* value = g_variant_new("i",(int)zone);
return value;
}
if(objectMap.count(objectPath))
{
GVariant* value = objectMap[objectPath]->getProperty(propertyName);
DebugOut(6) << "Returning value for: " << propertyName << endl;
return value;
}
DebugOut(DebugOut::Error)<<"No interface for" << interfaceName <<endl;
return nullptr;
}
