diff options
Diffstat (limited to 'AudioManagerDaemon/src/CAmNodeStateCommunicatorDBus.cpp')
-rw-r--r-- | AudioManagerDaemon/src/CAmNodeStateCommunicatorDBus.cpp | 776 |
1 files changed, 776 insertions, 0 deletions
diff --git a/AudioManagerDaemon/src/CAmNodeStateCommunicatorDBus.cpp b/AudioManagerDaemon/src/CAmNodeStateCommunicatorDBus.cpp new file mode 100644 index 0000000..4173890 --- /dev/null +++ b/AudioManagerDaemon/src/CAmNodeStateCommunicatorDBus.cpp @@ -0,0 +1,776 @@ +/** + * Copyright (C) 2012, BMW AG + * + * This file is part of GENIVI Project AudioManager. + * + * Contributions are licensed to the GENIVI Alliance under one or more + * Contribution License Agreements. + * + * \copyright + * This Source Code Form is subject to the terms of the + * Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with + * this file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * + * \author Christian Linke, christian.linke@bmw.de BMW 2012 + * + * \file CAmNodeStateCommunicatorDBus.cpp + * For further information see http://www.genivi.org/. + * + */ + +#include "CAmNodeStateCommunicatorDBus.h" +#include <assert.h> +#include <string> +#include <fstream> +#include <sstream> +#include <stdexcept> +#include "CAmControlSender.h" +#include "shared/CAmDltWrapper.h" +#include "config.h" + +namespace am +{ + +static DBusObjectPathVTable gObjectPathVTable; + +CAmNodeStateCommunicatorDBus::CAmNodeStateCommunicatorDBus(CAmDbusWrapper* iDbusWrapper) : CAmNodeStateCommunicator(), + mpDbusWrapper(iDbusWrapper), // + mpDBusConnection(NULL) +{ + assert(mpDbusWrapper); + logInfo("CAmNodeStateCommunicator::CAmNodeStateCommunicator started"); + + //save the DBusConnection + mpDbusWrapper->getDBusConnection(mpDBusConnection); + assert(mpDBusConnection!=NULL); + + //register the path and the callback for receiving messages + std::string path("LifeCycleConsumer"); + gObjectPathVTable.message_function=CAmNodeStateCommunicatorDBus::receiveCallback; + mpDbusWrapper->registerCallback(&gObjectPathVTable, path, this); + + //now we need to make sure we catch the signals from the NSM: + dbus_bus_add_match(mpDBusConnection, "type=\'signal\',path=\'/org/genivi/NodeStateManager\'", NULL); + if (!dbus_connection_add_filter(mpDBusConnection, CAmNodeStateCommunicatorDBus::signalCallback, this, NULL)) + { + logError("CAmNodeStateCommunicator::CAmNodeStateCommunicator not enought memory!"); + throw std::runtime_error("CAmNodeStateCommunicator::CAmNodeStateCommunicator not enought memory!"); + } + dbus_connection_flush(mpDBusConnection); +} + +CAmNodeStateCommunicatorDBus::~CAmNodeStateCommunicatorDBus() +{} + +/** retrieves the actual restartReason + * + * @param restartReason + * @return E_OK on success + */ +am_Error_e CAmNodeStateCommunicatorDBus::nsmGetRestartReasonProperty(NsmRestartReason_e& restartReason) +{ + int32_t answer(0); + am_Error_e error=readIntegerProperty("RestartReason",answer); + restartReason=static_cast<NsmRestartReason_e>(answer); + return(error); +} + +/** retrieves the actual shutdownreason + * + * @param ShutdownReason + * @return E_OK on success + */ +am_Error_e CAmNodeStateCommunicatorDBus::nsmGetShutdownReasonProperty(NsmShutdownReason_e& ShutdownReason) +{ + int32_t answer(0); + am_Error_e error=readIntegerProperty("ShutdownReason",answer); + ShutdownReason=static_cast<NsmShutdownReason_e>(answer); + return(error); +} + +/** retrieves the actual runnuing reason + * + * @param nsmRunningReason + * @return E_OK on success + */ +am_Error_e CAmNodeStateCommunicatorDBus::nsmGetRunningReasonProperty(NsmRunningReason_e& nsmRunningReason) +{ + int32_t answer(0); + am_Error_e error=readIntegerProperty("WakeUpReason",answer); + nsmRunningReason=static_cast<NsmRunningReason_e>(answer); + return(error); +} + +/** gets the node state + * + * @param nsmNodeState + * @return NsmErrorStatus_Ok on success + */ +NsmErrorStatus_e CAmNodeStateCommunicatorDBus::nsmGetNodeState(NsmNodeState_e& nsmNodeState) +{ + DBusError error; + dbus_error_init(&error); + + uint32_t nodeStateID; + uint32_t returnedError; + + DBusMessage * message = dbus_message_new_method_call(NSM_BUS_INTERFACE, NSM_PATH, NSM_INTERFACE, "GetNodeState"); + + if (!message) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetNodeState dbus error:", error.message); + return (NsmErrorStatus_Dbus); + } + + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDBusConnection, message, -1, &error)); + if (!reply) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetNodeState failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + + if(!dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &nodeStateID, DBUS_TYPE_INT32, &returnedError, DBUS_TYPE_INVALID)) + return (NsmErrorStatus_Dbus); + + dbus_message_unref(reply); + + nsmNodeState=static_cast<NsmNodeState_e>(nodeStateID); + return (static_cast<NsmErrorStatus_e>(returnedError)); +} + +/** gets the session state for a session and seatID + * + * @param sessionName the name of the session + * @param seatID the seatID + * @param sessionState + * @return NsmErrorStatus_Ok on success + */ +NsmErrorStatus_e CAmNodeStateCommunicatorDBus::nsmGetSessionState(const std::string& sessionName, const NsmSeat_e& seatID, NsmSessionState_e& sessionState) +{ + DBusError error; + dbus_error_init(&error); + DBusMessageIter iter; + + uint32_t returnedError; + int32_t BsessionState(0); + + DBusMessage * message = dbus_message_new_method_call(NSM_BUS_INTERFACE, NSM_PATH, NSM_INTERFACE, "GetSessionState"); + + if (!message) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetSessionState dbus error:", error.message); + return (NsmErrorStatus_Dbus); + } + + dbus_message_iter_init_append(message, &iter); + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &sessionName)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmGetSessionState no more memory"); + return (NsmErrorStatus_Dbus); + } + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32, &seatID)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmGetSessionState no more memory"); + return (NsmErrorStatus_Dbus); + } + + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDBusConnection, message, -1, &error)); + if (!reply) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetSessionState failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + + if(!dbus_message_get_args(reply, &error, + DBUS_TYPE_INT32, &BsessionState, + DBUS_TYPE_INT32, &returnedError,DBUS_TYPE_INVALID)) + return (NsmErrorStatus_Dbus); + + dbus_message_unref(reply); + + sessionState=static_cast<NsmSessionState_e>(BsessionState); + return (static_cast<NsmErrorStatus_e>(returnedError)); +} + +/** gets the application mode + * + * @param applicationMode + * @return NsmErrorStatus_Ok on success + */ +NsmErrorStatus_e CAmNodeStateCommunicatorDBus::nsmGetApplicationMode(NsmApplicationMode_e& applicationMode) +{ + DBusError error; + dbus_error_init(&error); + + uint32_t BapplicationMode(0),returnedError(0); + + DBusMessage * message = dbus_message_new_method_call(NSM_BUS_INTERFACE, NSM_PATH, NSM_INTERFACE, "GetApplicationMode"); + + if (!message) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetApplicationMode dbus error:", error.message); + return (NsmErrorStatus_Dbus); + } + + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDBusConnection, message, -1, &error)); + if (!reply) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetApplicationMode failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + + if(!dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &BapplicationMode, DBUS_TYPE_INT32, &returnedError, DBUS_TYPE_INVALID)) + return (NsmErrorStatus_Dbus); + + dbus_message_unref(reply); + + applicationMode=static_cast<NsmApplicationMode_e>(BapplicationMode); + return (static_cast<NsmErrorStatus_e>(returnedError)); +} + +/** this function registers the AudioManager as shutdown client at the NSM + * for more information check the Nodestatemanager + * @param shutdownMode the shutdownmode you wish to set + * @param timeoutMs the timeout you need to have + * @return NsmErrorStatus_Ok on success + */ +NsmErrorStatus_e CAmNodeStateCommunicatorDBus::nsmRegisterShutdownClient(const uint32_t shutdownMode, const uint32_t timeoutMs) +{ + DBusError error; + DBusMessageIter iter; + dbus_error_init(&error); + int32_t returnError(0); + std::string path = std::string(DBUS_SERVICE_OBJECT_PATH) + "/LifeCycleConsumer"; + const char* charPath = path.c_str(); + const char* service =DBUS_SERVICE_PREFIX; + DBusMessage * message = dbus_message_new_method_call(NSM_BUS_INTERFACE, NSM_PATH, NSM_INTERFACE, "RegisterShutdownClient"); + + if (!message) + { + logError( "CAmNodeStateCommunicatorDBus::nsmRegisterShutdownClient dbus error:", error.message); + return (NsmErrorStatus_Dbus); + } + dbus_message_iter_init_append(message, &iter); + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &service)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmRegisterShutdownClient no more memory"); + return (NsmErrorStatus_Dbus); + } + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &charPath)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmRegisterShutdownClient no more memory"); + return (NsmErrorStatus_Dbus); + } + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &shutdownMode)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmRegisterShutdownClient no more memory"); + return (NsmErrorStatus_Dbus); + } + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &timeoutMs)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmRegisterShutdownClient no more memory"); + return (NsmErrorStatus_Dbus); + } + + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDBusConnection, message, -1, &error)); + dbus_message_unref(message); + + if (!reply) + { + logError( "CAmRoutingDbusSend::send failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + + if(!dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &returnError,DBUS_TYPE_INVALID)) + { + logError( "CAmRoutingDbusSend::send failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + dbus_message_unref(reply); + + return (static_cast<NsmErrorStatus_e>(returnError)); + +} + +/** this function unregisters the AudioManager as shutdown client at the NSM + * + * @param shutdownMode + * @return NsmErrorStatus_Ok on success + */ +NsmErrorStatus_e CAmNodeStateCommunicatorDBus::nsmUnRegisterShutdownClient(const uint32_t shutdownMode) +{ + DBusError error; + DBusMessageIter iter; + dbus_error_init(&error); + int32_t returnError(0); + std::string path = std::string(DBUS_SERVICE_OBJECT_PATH) + "/LifeCycleConsumer"; + const char* charPath = path.c_str(); + const char* service =DBUS_SERVICE_PREFIX; + DBusMessage * message = dbus_message_new_method_call(NSM_BUS_INTERFACE, NSM_PATH, NSM_INTERFACE, "UnRegisterShutdownClient"); + + if (!message) + { + logError( "CAmNodeStateCommunicatorDBus::nsmUnRegisterShutdownClient dbus error:", error.message); + return (NsmErrorStatus_Dbus); + } + dbus_message_iter_init_append(message, &iter); + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &service)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmUnRegisterShutdownClient no more memory"); + return (NsmErrorStatus_Dbus); + } + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &charPath)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmUnRegisterShutdownClient no more memory"); + return (NsmErrorStatus_Dbus); + } + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &shutdownMode)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmUnRegisterShutdownClient no more memory"); + return (NsmErrorStatus_Dbus); + } + + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDBusConnection, message, -1, &error)); + dbus_message_unref(message); + + if (!reply) + { + logError( "CAmNodeStateCommunicatorDBus::nsmUnRegisterShutdownClient failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + + if(!dbus_message_get_args(reply, &error, DBUS_TYPE_INT32, &returnError, DBUS_TYPE_INVALID)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmUnRegisterShutdownClient failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + dbus_message_unref(reply); + + return (static_cast<NsmErrorStatus_e>(returnError)); +} + +/** returns the interface version + * + * @param version + * @return E_OK on success + */ +am_Error_e CAmNodeStateCommunicatorDBus::nsmGetInterfaceVersion(uint32_t& version) +{ + DBusError error; + dbus_error_init(&error); + + DBusMessage * message = dbus_message_new_method_call(NSM_BUS_INTERFACE, NSM_PATH, NSM_INTERFACE, "GetInterfaceVersion"); + + if (!message) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetInterfaceVersion dbus error:", error.message); + return (E_UNKNOWN); + } + + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDBusConnection, message, -1, &error)); + + dbus_message_unref(message); + + if (!reply) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetInterfaceVersion failed, dbus error", error.message); + return (E_UNKNOWN); + } + + if(!dbus_message_get_args(reply, &error, DBUS_TYPE_UINT32, &version, DBUS_TYPE_INVALID)) + { + logError("CAmNodeStateCommunicatorDBus::nsmGetInterfaceVersion failed, dbus error", error.message); + return (E_UNKNOWN); + } + + dbus_message_unref(reply); + + return (E_OK); +} + +/** sends out the Lifecycle request complete message + * + * @param RequestId + * @param status + * @return NsmErrorStatus_Ok on success + */ +NsmErrorStatus_e CAmNodeStateCommunicatorDBus::nsmSendLifecycleRequestComplete(const uint32_t RequestId, const NsmErrorStatus_e status) +{ + DBusError error; + DBusMessageIter iter; + dbus_error_init(&error); + int32_t returnError(0); + DBusMessage * message = dbus_message_new_method_call(NSM_BUS_INTERFACE, NSM_PATH, NSM_INTERFACE, "LifecycleRequestComplete"); + + if (!message) + { + logError( "CAmNodeStateCommunicatorDBus::nsmSendLifecycleRequestComplete dbus error:", error.message); + return (NsmErrorStatus_Dbus); + } + dbus_message_iter_init_append(message, &iter); + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32, &RequestId)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmSendLifecycleRequestComplete no more memory"); + return (NsmErrorStatus_Dbus); + } + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_INT32,&status)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmSendLifecycleRequestComplete no more memory"); + return (NsmErrorStatus_Dbus); + } + + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDBusConnection, message, -1, &error)); + dbus_message_unref(message); + + if (!reply) + { + logError( "CAmNodeStateCommunicatorDBus::nsmSendLifecycleRequestComplete failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + + if(!dbus_message_get_args(reply, &error,DBUS_TYPE_INT32, &returnError, DBUS_TYPE_INVALID)) + { + logError( "CAmNodeStateCommunicatorDBus::nsmSendLifecycleRequestComplete failed, dbus error", error.message); + return (NsmErrorStatus_Dbus); + } + dbus_message_unref(reply); + + return (static_cast<NsmErrorStatus_e>(returnError)); +} + +DBusHandlerResult CAmNodeStateCommunicatorDBus::receiveCallback(DBusConnection* conn, DBusMessage* msg, void* user_data) +{ + CAmNodeStateCommunicatorDBus* instance = static_cast<CAmNodeStateCommunicatorDBus*>(user_data); + assert(instance); + return (instance->receiveCallbackDelegate(conn,msg)); +} + +DBusHandlerResult CAmNodeStateCommunicatorDBus::receiveCallbackDelegate(DBusConnection* conn, DBusMessage* msg) +{ + if (dbus_message_is_method_call(msg, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) + { + sendIntrospection(conn, msg); + return (DBUS_HANDLER_RESULT_HANDLED); + } + else + { + DBusMessage * returnMessage; + dbus_uint32_t Request(0),RequestId(0); + //no introspection - ok. So we are only interested in out LifecycleRequest message... + std::string method(dbus_message_get_member(msg)); + if (method=="LifecycleRequest") + { + DBusMessageIter iter,replyIter; + if (!dbus_message_iter_init(msg, &iter)) + { + logError("CAmNodeStateCommunicatorDBus::receiveCallbackDelegate DBus Message has no arguments!"); + returnMessage = dbus_message_new_error(msg,DBUS_ERROR_INVALID_ARGS, "DBUS Message has no arguments!"); + sendMessage(returnMessage,msg); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + if (dbus_message_iter_get_arg_type(&iter)!=DBUS_TYPE_UINT32) + { + logError("CAmNodeStateCommunicatorDBus::receiveCallbackDelegate DBus Message has invalid arguments!"); + returnMessage = dbus_message_new_error(msg,DBUS_ERROR_INVALID_ARGS,"DBus argument is not uint32_t!"); + sendMessage(returnMessage,msg); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + dbus_message_iter_get_basic(&iter, &Request); + dbus_message_iter_next(&iter); + + if (dbus_message_iter_get_arg_type(&iter)!=DBUS_TYPE_UINT32) + { + logError("CAmNodeStateCommunicatorDBus::receiveCallbackDelegate DBus Message has invalid arguments!"); + returnMessage = dbus_message_new_error(msg,DBUS_ERROR_INVALID_ARGS,"DBus argument is not uint32_t!"); + sendMessage(returnMessage,msg); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + dbus_message_iter_get_basic(&iter, &RequestId); + + assert(mpControlSender); + NsmErrorStatus_e returnError = mpControlSender->hookSystemLifecycleRequest(static_cast<uint32_t>(Request),static_cast<uint32_t>(RequestId)); + + returnMessage = dbus_message_new_method_return(msg); + + if (returnMessage == NULL) + { + logError("CAmNodeStateCommunicatorDBus::receiveCallbackDelegate Cannot allocate DBus message!"); + returnMessage = dbus_message_new_error(msg,DBUS_ERROR_NO_MEMORY,"Cannot create reply!"); + sendMessage(returnMessage,msg); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + dbus_message_iter_init_append(returnMessage, &replyIter); + + if (!dbus_message_iter_append_basic(&replyIter, DBUS_TYPE_INT32, &returnError)) + { + logError("CAmNodeStateCommunicatorDBus::receiveCallbackDelegate Cannot allocate DBus message!"); + returnMessage = dbus_message_new_error(msg,DBUS_ERROR_NO_MEMORY,"Cannot create reply!"); + } + sendMessage(returnMessage,msg); + return (DBUS_HANDLER_RESULT_HANDLED); + } + } + return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED); +} + +void CAmNodeStateCommunicatorDBus::sendIntrospection(DBusConnection* conn, DBusMessage* msg) +{ + assert(conn != NULL); + assert(msg != NULL); + DBusMessage* reply; + DBusMessageIter args; + dbus_uint32_t serial = 0; + + // create a reply from the message + reply = dbus_message_new_method_return(msg); + std::string fullpath(NSM_INTROSPECTION_FILE); + std::ifstream in(fullpath.c_str(), std::ifstream::in); + if (!in) + { + logError("IAmCommandReceiverShadow::sendIntrospection could not load xml file ",fullpath); + throw std::runtime_error("IAmCommandReceiverShadow::sendIntrospection Could not load introspecton XML"); + } + std::stringstream buffer; + buffer << in.rdbuf(); + std::string introspect = buffer.str(); + const char* string = introspect.c_str(); + + // add the arguments to the reply + dbus_message_iter_init_append(reply, &args); + if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &string)) + { + logError( "CAmNodeStateCommunicatorDBus::sendIntrospection DBUS handler Out Of Memory!"); + } + + // send the reply && flush the connection + if (!dbus_connection_send(conn, reply, &serial)) + { + logError( "CAmNodeStateCommunicatorDBus::sendIntrospection DBUS handler Out Of Memory!"); + } + dbus_connection_flush(conn); + + // free the reply + dbus_message_unref(reply); +} + +void CAmNodeStateCommunicatorDBus::sendMessage(DBusMessage* message, DBusMessage* origMessage) +{ + dbus_uint32_t serial = dbus_message_get_serial(origMessage); + + if(!dbus_connection_send(mpDBusConnection, message, &serial)) + { + logError( "CAmNodeStateCommunicatorDBus::sendMessage DBUS handler Out Of Memory!"); + } + dbus_connection_flush(mpDBusConnection); + dbus_message_unref(message); +} + +DBusHandlerResult CAmNodeStateCommunicatorDBus::signalCallback(DBusConnection* conn, DBusMessage* msg, void* user_data) +{ + (void) conn; + CAmNodeStateCommunicatorDBus* instance(static_cast<CAmNodeStateCommunicatorDBus*>(user_data)); + + const char* iface = dbus_message_get_interface(msg); + if (iface==NULL) + return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + std::string interface(iface); + std::string member = dbus_message_get_member(msg); + + if (interface=="org.genivi.NodeStateManager.Consumer") + { + if (member=="NodeState") + { + int32_t nodeState; + DBusMessageIter iter; + if (!dbus_message_iter_init(msg, &iter)) + { + logError("CAmNodeStateCommunicatorDBus::signalCallback NodeState DBus Message has no arguments!"); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + if (dbus_message_iter_get_arg_type(&iter)!=DBUS_TYPE_INT32) + { + logError("CAmNodeStateCommunicatorDBus::signalCallback NodeState DBus Message has invalid arguments!"); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + dbus_message_iter_get_basic(&iter, &nodeState); + + logInfo("CAmNodeStateCommunicatorDBus::signalCallback got signal NodeState, with nodeState",nodeState); + + assert(instance->mpControlSender); + instance->mpControlSender->hookSystemNodeStateChanged(static_cast<NsmNodeState_e>(nodeState)); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + else if (member=="NodeApplicationMode") + { + int32_t nodeApplicationMode; + DBusMessageIter iter; + if (!dbus_message_iter_init(msg, &iter)) + { + logError("CAmNodeStateCommunicatorDBus::signalCallback nodeApplicationMode DBus Message has no arguments!"); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + if (dbus_message_iter_get_arg_type(&iter)!=DBUS_TYPE_INT32) + { + logError("CAmNodeStateCommunicatorDBus::signalCallback nodeApplicationMode DBus Message has invalid arguments!"); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + dbus_message_iter_get_basic(&iter, &nodeApplicationMode); + + logInfo("CAmNodeStateCommunicatorDBus::signalCallback got signal nodeApplicationMode, with applicationMode",nodeApplicationMode); + + assert(instance->mpControlSender); + instance->mpControlSender->hookSystemNodeApplicationModeChanged(static_cast<NsmApplicationMode_e>(nodeApplicationMode)); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + else if (member=="SessionStateChanged") + { + std::string sessionName; + NsmSeat_e seatID; + NsmSessionState_e sessionState; + DBusMessageIter iter; + if (!dbus_message_iter_init(msg, &iter)) + { + logError("CAmNodeStateCommunicatorDBus::signalCallback nodeApplicationMode DBus Message has no arguments!"); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + if (dbus_message_iter_get_arg_type(&iter)!=DBUS_TYPE_STRING) + { + logError("CAmNodeStateCommunicatorDBus::signalCallback nodeApplicationMode DBus Message has invalid arguments!"); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + char * sessionNameChar; + dbus_message_iter_get_basic(&iter, &sessionNameChar); + sessionName=std::string(sessionNameChar); + dbus_message_iter_next(&iter); + + if (dbus_message_iter_get_arg_type(&iter)!=DBUS_TYPE_INT32) + { + logError("CAmNodeStateCommunicatorDBus::signalCallback nodeApplicationMode DBus Message has invalid arguments!"); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + dbus_message_iter_get_basic(&iter, &seatID); + dbus_message_iter_next(&iter); + + if (dbus_message_iter_get_arg_type(&iter)!=DBUS_TYPE_INT32) + { + logError("CAmNodeStateCommunicatorDBus::signalCallback nodeApplicationMode DBus Message has invalid arguments!"); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + dbus_message_iter_get_basic(&iter, &sessionState); + + + logInfo("CAmNodeStateCommunicatorDBus::signalCallback got signal sessionStateChanged, with session",sessionName,"seatID=",seatID,"sessionState",sessionState); + + assert(instance->mpControlSender); + instance->mpControlSender->hookSystemSessionStateChanged(sessionName,seatID,sessionState); + return (DBUS_HANDLER_RESULT_HANDLED); + } + + else + { + return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED); + } + } + + return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED); +} + +am_Error_e CAmNodeStateCommunicatorDBus::readIntegerProperty(const std::string property, int32_t& value) +{ + DBusError error; + dbus_error_init(&error); + DBusMessageIter iter,iterVariant; + + DBusMessage * message = dbus_message_new_method_call(NSM_BUS_INTERFACE, NSM_PATH, "org.freedesktop.DBus.Properties", "Get"); + + if (!message) + { + logError("CAmNodeStateCommunicatorDBus::readIntegerProperty dbus error:", error.message); + dbus_message_unref(message); + return (E_UNKNOWN); + } + + + dbus_message_iter_init_append(message, &iter); + const char *interface=NSM_INTERFACE; + const char *propertyChar=property.c_str(); + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &interface)) + { + logError("CAmNodeStateCommunicatorDBus::readIntegerProperty append error"); + dbus_message_unref(message); + return (E_UNKNOWN); + } + + if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &propertyChar)) + { + logError("CAmNodeStateCommunicatorDBus::readIntegerProperty append error"); + dbus_message_unref(message); + return (E_UNKNOWN); + } + + DBusMessage* reply(dbus_connection_send_with_reply_and_block(mpDBusConnection, message, -1, &error)); + if (!reply) + { + logError("CAmNodeStateCommunicatorDBus::readIntegerProperty failed, dbus error", error.message); + dbus_message_unref(message); + return (E_UNKNOWN); + } + + if(!dbus_message_iter_init(reply,&iterVariant)) + { + logError("CAmNodeStateCommunicatorDBus::readIntegerProperty failed, dbus error", error.message); + dbus_message_unref(message); + dbus_message_unref(reply); + return (E_UNKNOWN); + } + if (dbus_message_iter_get_arg_type (&iterVariant)!= DBUS_TYPE_VARIANT) + { + logError("CAmNodeStateCommunicatorDBus::readIntegerProperty failed, dbus return type wrong"); + dbus_message_unref(reply); + dbus_message_unref(message); + return (E_UNKNOWN); + } + DBusMessageIter subiter; + dbus_message_iter_recurse (&iterVariant, &subiter); + if (dbus_message_iter_get_arg_type (&subiter)!= DBUS_TYPE_INT32) + { + logError("CAmNodeStateCommunicatorDBus::readIntegerProperty failed, dbus return type wrong"); + dbus_message_unref(reply); + dbus_message_unref(message); + return (E_UNKNOWN); + } + + dbus_message_iter_get_basic(&subiter,&value); + dbus_message_unref(reply); + dbus_message_unref(message); + + return (E_OK); +} + +} /* namespace am */ |