src/CommonAPI/DBus/DBusProxy.cpp

   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 #include "DBusProxy.h"
   5 #include "DBusServiceRegistry.h"
   6 #include "DBusUtils.h"
   7
   8 #include <algorithm>
   9 #include <cassert>
  10 #include <iostream>
  11 #include <dbus/dbus.h>
  12 #include <functional>
  13 #include <CommonAPI/Event.h>
  14
  15 namespace CommonAPI {
  16 namespace DBus {
  17
  18 DBusProxyStatusEvent::DBusProxyStatusEvent(DBusProxy* dbusProxy) :
  19                 dbusProxy_(dbusProxy) {
  20 }
  21
  22 void DBusProxyStatusEvent::onFirstListenerAdded(const Listener& listener) {
  23     auto serviceStatusListener = std::bind(
  24                     &DBusProxyStatusEvent::onServiceAvailableSignalHandler,
  25                     this,
  26                     std::placeholders::_1,
  27                     std::placeholders::_2);
  28
  29     subscription_ = dbusProxy_->getDBusConnection()->getDBusServiceRegistry()->getServiceStatusEvent().subscribe(
  30                     dbusProxy_->dbusBusName_ + ":" + dbusProxy_->dbusObjectPath_ + ":" + dbusProxy_->interfaceName_,
  31                     serviceStatusListener);
  32 }
  33
  34 void DBusProxyStatusEvent::onLastListenerRemoved(const Listener& listener) {
  35     dbusProxy_->getDBusConnection()->getDBusServiceRegistry()->getServiceStatusEvent().unsubscribe(subscription_);
  36 }
  37
  38 SubscriptionStatus DBusProxyStatusEvent::onServiceAvailableSignalHandler(const std::string& name,
  39                                                                          const AvailabilityStatus& availabilityStatus) {
  40     AvailabilityStatus availability = availabilityStatus;
  41
  42     return notifyListeners(availability);
  43 }
  44
  45 const std::string DBusProxy::domain_ = "local";
  46
  47 DBusProxy::DBusProxy(const std::string& dbusBusName,
  48                      const std::string& dbusObjectPath,
  49                      const std::string& interfaceName,
  50                      const std::shared_ptr<DBusProxyConnection>& dbusProxyConnection) :
  51                                                  dbusBusName_(dbusBusName),
  52                                  dbusObjectPath_(dbusObjectPath),
  53                                  interfaceName_(interfaceName),
  54                                  statusEvent_(this),
  55                                  interfaceVersionAttribute_(*this, "getInterfaceVersion"),
  56                                  available_(false),
  57                                  availableSet_(false),
  58                                  connection_(dbusProxyConnection) {
  59 }
  60
  61 DBusProxy::DBusProxy(const std::string& dbusBusName,
  62                      const std::string& dbusObjectPath,
  63                      const std::string& interfaceName,
  64                      const std::shared_ptr<DBusProxyConnection>& connection,
  65                      const bool isAlwaysAvailable) :
  66                  dbusBusName_(dbusBusName),
  67                  dbusObjectPath_(dbusObjectPath),
  68                  interfaceName_(interfaceName),
  69                  statusEvent_(this),
  70                  interfaceVersionAttribute_(*this, "getInterfaceVersion"),
  71                  available_(isAlwaysAvailable),
  72                  availableSet_(isAlwaysAvailable),
  73                  connection_(connection) {
  74 }
  75
  76 std::string DBusProxy::getAddress() const {
  77     return domain_ + ":" + interfaceName_ + ":" + dbusBusName_;
  78 }
  79
  80 const std::string& DBusProxy::getDomain() const {
  81     return domain_;
  82 }
  83
  84 const std::string& DBusProxy::getServiceId() const {
  85     return getInterfaceName();
  86 }
  87
  88 const std::string& DBusProxy::getInstanceId() const {
  89     return dbusBusName_;
  90 }
  91
  92
  93 bool DBusProxy::isAvailable() const {
  94     if (!availableSet_) {
  95         auto status = getDBusConnection()->getDBusServiceRegistry()->getReadyFuture().wait_for(std::chrono::milliseconds(1));
  96         if (checkReady(status)) {
  97             available_ = getDBusConnection()->getDBusServiceRegistry()->isServiceInstanceAlive(getAddress());
  98             availableSet_ = true;
  99         }
 100     }
 101     return available_;
 102 }
 103
 104 bool DBusProxy::isAvailableBlocking() const {
 105
 106     if (!availableSet_) {
 107         getDBusConnection()->getDBusServiceRegistry()->getReadyFuture().wait();
 108         available_ = getDBusConnection()->getDBusServiceRegistry()->isServiceInstanceAlive(getAddress());
 109         availableSet_ = true;
 110     }
 111     return available_;
 112 }
 113
 114 ProxyStatusEvent& DBusProxy::getProxyStatusEvent() {
 115     return statusEvent_;
 116 }
 117
 118 InterfaceVersionAttribute& DBusProxy::getInterfaceVersionAttribute() {
 119     return interfaceVersionAttribute_;
 120 }
 121
 122 DBusMessage DBusProxy::createMethodCall(const char* methodName,
 123                                         const char* methodSignature) const {
 124     return DBusMessage::createMethodCall(
 125                     dbusBusName_.c_str(),
 126                     dbusObjectPath_.c_str(),
 127                     getInterfaceName().c_str(),
 128                     methodName,
 129                     methodSignature);
 130 }
 131
 132 } // namespace DBus
 133 } // namespace CommonAPI