src/CommonAPI/DBus/DBusConnection.h

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