mm1_modem_proxy.cc

// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "shill/mm1_modem_proxy.h"

#include <base/logging.h>

#include "cellular_error.h"

using std::string;

namespace shill {
namespace mm1 {

ModemProxy::ModemProxy(ModemProxyDelegate *delegate,
                       DBus::Connection *connection,
                       const string &path,
                       const string &service)
    : proxy_(delegate, connection, path, service) {}

ModemProxy::~ModemProxy() {}

void ModemProxy::Enable(const bool &enable,
                        AsyncCallHandler *call_handler,
                        int timeout) {
  proxy_.Enable(enable, call_handler, timeout);
}

void ModemProxy::ListBearers(AsyncCallHandler *call_handler,
                             int timeout) {
  proxy_.ListBearers(call_handler, timeout);
}

void ModemProxy::CreateBearer(
    const DBusPropertiesMap &properties,
    AsyncCallHandler *call_handler,
    int timeout) {
  proxy_.CreateBearer(properties, call_handler, timeout);
}

void ModemProxy::DeleteBearer(const ::DBus::Path &bearer,
                              AsyncCallHandler *call_handler,
                              int timeout) {
  proxy_.DeleteBearer(bearer, call_handler, timeout);
}

void ModemProxy::Reset(AsyncCallHandler *call_handler, int timeout) {
  proxy_.Reset(call_handler, timeout);
}

void ModemProxy::FactoryReset(const std::string &code,
                              AsyncCallHandler *call_handler,
                              int timeout) {
  proxy_.FactoryReset(code, call_handler, timeout);
}

void ModemProxy::SetAllowedModes(const uint32_t &modes,
                                 const uint32_t &preferred,
                                 AsyncCallHandler *call_handler,
                                 int timeout) {
  proxy_.SetAllowedModes(modes, preferred, call_handler, timeout);
}

void ModemProxy::SetBands(const std::vector< uint32_t > &bands,
                          AsyncCallHandler *call_handler,
                          int timeout) {
  proxy_.SetBands(bands, call_handler, timeout);
}

void ModemProxy::Command(const std::string &cmd,
                         const uint32_t &user_timeout,
                         AsyncCallHandler *call_handler,
                         int timeout) {
  proxy_.Command(cmd, user_timeout, call_handler, timeout);
}

// Inherited properties from ModemProxyInterface.
const ::DBus::Path ModemProxy::Sim() {
  return proxy_.Sim();
};
uint32_t ModemProxy::ModemCapabilities() {
  return proxy_.ModemCapabilities();
};
uint32_t ModemProxy::CurrentCapabilities() {
  return proxy_.CurrentCapabilities();
};
uint32_t ModemProxy::MaxBearers() {
  return proxy_.MaxBearers();
};
uint32_t ModemProxy::MaxActiveBearers() {
  return proxy_.MaxActiveBearers();
};
const std::string ModemProxy::Manufacturer() {
  return proxy_.Manufacturer();
};
const std::string ModemProxy::Model() {
  return proxy_.Model();
};
const std::string ModemProxy::Revision() {
  return proxy_.Revision();
};
const std::string ModemProxy::DeviceIdentifier() {
  return proxy_.DeviceIdentifier();
};
const std::string ModemProxy::Device() {
  return proxy_.Device();
};
const std::string ModemProxy::Driver() {
  return proxy_.Driver();
};
const std::string ModemProxy::Plugin() {
  return proxy_.Plugin();
};
const std::string ModemProxy::EquipmentIdentifier() {
  return proxy_.EquipmentIdentifier();
};
uint32_t ModemProxy::UnlockRequired() {
  return proxy_.UnlockRequired();
};
const std::map< uint32_t, uint32_t > ModemProxy::UnlockRetries() {
  return proxy_.UnlockRetries();
};
uint32_t ModemProxy::State() {
  return proxy_.State();
};
uint32_t ModemProxy::AccessTechnologies() {
  return proxy_.AccessTechnologies();
};
const ::DBus::Struct< uint32_t, bool > ModemProxy::SignalQuality() {
  return proxy_.SignalQuality();
};
uint32_t ModemProxy::SupportedModes() {
  return proxy_.SupportedModes();
};
uint32_t ModemProxy::AllowedModes() {
  return proxy_.AllowedModes();
};
uint32_t ModemProxy::PreferredMode() {
  return proxy_.PreferredMode();
};
const std::vector< uint32_t > ModemProxy::SupportedBands() {
  return proxy_.SupportedBands();
};
const std::vector< uint32_t > ModemProxy::Bands() {
  return proxy_.Bands();
};

ModemProxy::Proxy::Proxy(ModemProxyDelegate *delegate,
                         DBus::Connection *connection,
                         const std::string &path,
                         const std::string &service)
    : DBus::ObjectProxy(*connection, path, service.c_str()),
      delegate_(delegate) {}

ModemProxy::Proxy::~Proxy() {}

// Signal callbacks inherited from Proxy
void ModemProxy::Proxy::StateChanged(const uint32_t &old,
                                     const uint32_t &_new,
                                     const uint32_t &reason) {
  delegate_->OnStateChanged(old, _new, reason);
}

// Method callbacks inherited from
// org::freedesktop::ModemManager1::ModemProxy
void ModemProxy::Proxy::EnableCallback(const ::DBus::Error& dberror,
                                       void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnEnableCallback(error, call_handler);
}

void ModemProxy::Proxy::ListBearersCallback(
    const std::vector< ::DBus::Path > &bearers,
    const ::DBus::Error& dberror,
    void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnListBearersCallback(bearers, error, call_handler);
}

void ModemProxy::Proxy::CreateBearerCallback(const ::DBus::Path &path,
                                             const ::DBus::Error& dberror,
                                             void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnCreateBearerCallback(path, error, call_handler);
}

void ModemProxy::Proxy::DeleteBearerCallback(const ::DBus::Error& dberror,
                                             void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnDeleteBearerCallback(error, call_handler);
}

void ModemProxy::Proxy::ResetCallback(const ::DBus::Error& dberror,
                                      void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnResetCallback(error, call_handler);
}

void ModemProxy::Proxy::FactoryResetCallback(const ::DBus::Error& dberror,
                                             void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnFactoryResetCallback(error, call_handler);
}

void ModemProxy::Proxy::SetAllowedModesCallback(
    const ::DBus::Error& dberror,
    void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnSetAllowedModesCallback(error, call_handler);
}

void ModemProxy::Proxy::SetBandsCallback(const ::DBus::Error& dberror,
                                         void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnSetBandsCallback(error, call_handler);
}

void ModemProxy::Proxy::CommandCallback(const std::string &response,
                                        const ::DBus::Error& dberror,
                                        void *data) {
  AsyncCallHandler *call_handler = reinterpret_cast<AsyncCallHandler *>(data);
  Error error;
  CellularError::FromDBusError(dberror, &error),
      delegate_->OnCommandCallback(response, error, call_handler);
}

}  // namespace mm1
}  // namespace shill