src/CommonAPI/DBus/DBusConnection.h

   1 /* Copyright (C) 2013 BMW Group
   2  * Author: Manfred Bathelt (manfred.bathelt@bmw.de)
   3  * Author: Juergen Gehring (juergen.gehring@bmw.de)
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   7 #ifndef COMMONAPI_DBUS_DBUS_CONNECTION_H_
   8 #define COMMONAPI_DBUS_DBUS_CONNECTION_H_
   9
  10 #include "DBusProxyConnection.h"
  11 #include "DBusDaemonProxy.h"
  12 #include "DBusServiceRegistry.h"
  13 #include "DBusObjectManager.h"
  14
  15 #include <dbus/dbus.h>
  16
  17
  18 namespace CommonAPI {
  19 namespace DBus {
  20
  21 class DBusConnection;
  22 class DBusObjectManager;
  23
  24 class DBusConnectionStatusEvent: public DBusProxyConnection::ConnectionStatusEvent {
  25     friend class DBusConnection;
  26 };
  27
  28
  29 class DBusConnection: public DBusProxyConnection, public std::enable_shared_from_this<DBusConnection> {
  30  public:
  31         enum BusType {
  32                 SESSION = DBUS_BUS_SESSION,
  33                 SYSTEM = DBUS_BUS_SYSTEM,
  34                 STARTER = DBUS_BUS_STARTER,
  35                 WRAPPED
  36         };
  37
  38         inline static std::shared_ptr<DBusConnection> getBus(const BusType& busType);
  39         inline static std::shared_ptr<DBusConnection> wrapLibDBus(::DBusConnection* libDbusConnection);
  40         inline static std::shared_ptr<DBusConnection> getSessionBus();
  41         inline static std::shared_ptr<DBusConnection> getSystemBus();
  42         inline static std::shared_ptr<DBusConnection> getStarterBus();
  43
  44         DBusConnection(const DBusConnection&) = delete;
  45         DBusConnection(::DBusConnection* libDbusConnection);
  46
  47         DBusConnection& operator=(const DBusConnection&) = delete;
  48         virtual ~DBusConnection();
  49
  50         BusType getBusType() const;
  51
  52         bool connect();
  53         bool connect(DBusError& dbusError);
  54         void disconnect();
  55
  56         virtual bool isConnected() const;
  57
  58         virtual ConnectionStatusEvent& getConnectionStatusEvent();
  59
  60         virtual bool requestServiceNameAndBlock(const std::string& serviceName) const;
  61         virtual bool releaseServiceName(const std::string& serviceName) const;
  62
  63         bool sendDBusMessage(const DBusMessage& dbusMessage, uint32_t* allocatedSerial = NULL) const;
  64
  65         static const int kDefaultSendTimeoutMs = 100 * 1000;
  66
  67         std::future<CallStatus> sendDBusMessageWithReplyAsync(
  68                         const DBusMessage& dbusMessage,
  69                         std::unique_ptr<DBusMessageReplyAsyncHandler> dbusMessageReplyAsyncHandler,
  70                         int timeoutMilliseconds = kDefaultSendTimeoutMs) const;
  71
  72         DBusMessage sendDBusMessageWithReplyAndBlock(const DBusMessage& dbusMessage,
  73                                                      DBusError& dbusError,
  74                                                      int timeoutMilliseconds = kDefaultSendTimeoutMs) const;
  75
  76         DBusSignalHandlerToken addSignalMemberHandler(const std::string& objectPath,
  77                                                       const std::string& interfaceName,
  78                                                       const std::string& interfaceMemberName,
  79                                                       const std::string& interfaceMemberSignature,
  80                                                       DBusSignalHandler* dbusSignalHandler);
  81
  82         void registerObjectPath(const std::string& objectPath);
  83         void unregisterObjectPath(const std::string& objectPath);
  84
  85         void removeSignalMemberHandler(const DBusSignalHandlerToken& dbusSignalHandlerToken);
  86
  87         bool readWriteDispatch(int timeoutMilliseconds = -1);
  88
  89         virtual const std::shared_ptr<DBusDaemonProxy>& getDBusDaemonProxy();
  90     virtual const std::shared_ptr<DBusServiceRegistry>& getDBusServiceRegistry();
  91     virtual const std::shared_ptr<DBusObjectManager>& getDBusObjectManager();
  92
  93  private:
  94     void dispatch();
  95
  96     std::thread dispatchThread_;
  97     bool stopDispatching_;
  98
  99         DBusConnection(BusType busType);
 100
 101         void addLibdbusSignalMatchRule(const std::string& objectPath,
 102                                        const std::string& interfaceName,
 103                                        const std::string& interfaceMemberName);
 104
 105         void removeLibdbusSignalMatchRule(const std::string& objectPath,
 106                                           const std::string& interfaceName,
 107                                           const std::string& interfaceMemberName);
 108
 109         void initLibdbusObjectPathHandlerAfterConnect();
 110
 111         void initLibdbusSignalFilterAfterConnect();
 112
 113         ::DBusHandlerResult onLibdbusObjectPathMessage(::DBusMessage* libdbusMessage) const;
 114
 115         ::DBusHandlerResult onLibdbusSignalFilter(::DBusMessage* libdbusMessage);
 116
 117         static void onLibdbusPendingCallNotifyThunk(::DBusPendingCall* libdbusPendingCall, void *userData);
 118         static void onLibdbusDataCleanup(void* userData);
 119
 120         static ::DBusHandlerResult onLibdbusObjectPathMessageThunk(::DBusConnection* libdbusConnection,
 121                                                                    ::DBusMessage* libdbusMessage,
 122                                                                     void* userData);
 123
 124         static ::DBusHandlerResult onLibdbusSignalFilterThunk(::DBusConnection* libdbusConnection,
 125                                                               ::DBusMessage* libdbusMessage,
 126                                                                void* userData);
 127
 128         BusType busType_;
 129
 130         ::DBusConnection* libdbusConnection_;
 131
 132         std::shared_ptr<DBusDaemonProxy> dbusDaemonProxy_;
 133         std::shared_ptr<DBusServiceRegistry> dbusServiceRegistry_;
 134     std::shared_ptr<DBusObjectManager> dbusObjectManager_;
 135
 136         DBusConnectionStatusEvent dbusConnectionStatusEvent_;
 137
 138         typedef std::tuple<std::string, std::string, std::string> DBusSignalMatchRuleTuple;
 139         typedef std::pair<uint32_t, std::string> DBusSignalMatchRuleMapping;
 140         typedef std::unordered_map<DBusSignalMatchRuleTuple, DBusSignalMatchRuleMapping> DBusSignalMatchRulesMap;
 141         DBusSignalMatchRulesMap dbusSignalMatchRulesMap_;
 142
 143     bool isLibdbusSignalFilterAdded_;
 144
 145     DBusSignalHandlerTable dbusSignalHandlerTable_;
 146
 147     // referenceCount, objectPath
 148     typedef std::unordered_map<std::string, uint32_t> LibdbusRegisteredObjectPathHandlersTable;
 149     LibdbusRegisteredObjectPathHandlersTable libdbusRegisteredObjectPaths_;
 150
 151     static DBusObjectPathVTable libdbusObjectPathVTable_;
 152 };
 153
 154 std::shared_ptr<DBusConnection> DBusConnection::getBus(const BusType& busType) {
 155         return std::shared_ptr<DBusConnection>(new DBusConnection(busType));
 156 }
 157
 158 std::shared_ptr<DBusConnection> DBusConnection::wrapLibDBus(::DBusConnection* libDbusConnection) {
 159     return std::shared_ptr<DBusConnection>(new DBusConnection(libDbusConnection));
 160 }
 161
 162 std::shared_ptr<DBusConnection> DBusConnection::getSessionBus() {
 163         return getBus(BusType::SESSION);
 164 }
 165
 166 std::shared_ptr<DBusConnection> DBusConnection::getSystemBus() {
 167         return getBus(BusType::SYSTEM);
 168 }
 169
 170 std::shared_ptr<DBusConnection> DBusConnection::getStarterBus() {
 171         return getBus(BusType::STARTER);
 172 }
 173
 174
 175 } // namespace DBus
 176 } // namespace CommonAPI
 177
 178 #endif // COMMONAPI_DBUS_DBUS_CONNECTION_H_