Home | History | Annotate | Download | only in dbus 
      1 //
      2 // Copyright (C) 2015 The Android Open Source Project
      3 //
      4 // Licensed under the Apache License, Version 2.0 (the "License");
      5 // you may not use this file except in compliance with the License.
      6 // You may obtain a copy of the License at
      7 //
      8 //      http://www.apache.org/licenses/LICENSE-2.0
      9 //
     10 // Unless required by applicable law or agreed to in writing, software
     11 // distributed under the License is distributed on an "AS IS" BASIS,
     12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 // See the License for the specific language governing permissions and
     14 // limitations under the License.
     15 //
     16 
     17 #include "shill/dbus/chromeos_mm1_modem_modem3gpp_proxy.h"
     18 
     19 #include <memory>
     20 
     21 #include "shill/cellular/cellular_error.h"
     22 #include "shill/logging.h"
     23 
     24 using std::string;
     25 
     26 namespace shill {
     27 
     28 namespace Logging {
     29 static auto kModuleLogScope = ScopeLogger::kDBus;
     30 static string ObjectID(const dbus::ObjectPath* p) { return p->value(); }
     31 }  // namespace Logging
     32 
     33 namespace mm1 {
     34 
     35 ChromeosModemModem3gppProxy::ChromeosModemModem3gppProxy(
     36     const scoped_refptr<dbus::Bus>& bus,
     37     const string& path,
     38     const string& service)
     39     : proxy_(
     40         new org::freedesktop::ModemManager1::Modem::Modem3gppProxy(
     41             bus, service, dbus::ObjectPath(path))) {}
     42 
     43 ChromeosModemModem3gppProxy::~ChromeosModemModem3gppProxy() {}
     44 
     45 void ChromeosModemModem3gppProxy::Register(const std::string& operator_id,
     46                                            Error* error,
     47                                            const ResultCallback& callback,
     48                                            int timeout) {
     49   SLOG(&proxy_->GetObjectPath(), 2) << __func__ << ": " << operator_id;
     50   proxy_->RegisterAsync(
     51       operator_id,
     52       base::Bind(&ChromeosModemModem3gppProxy::OnRegisterSuccess,
     53                  weak_factory_.GetWeakPtr(),
     54                  callback),
     55       base::Bind(&ChromeosModemModem3gppProxy::OnRegisterFailure,
     56                  weak_factory_.GetWeakPtr(),
     57                  callback));
     58 }
     59 
     60 void ChromeosModemModem3gppProxy::Scan(Error* error,
     61                                        const KeyValueStoresCallback& callback,
     62                                        int timeout) {
     63   SLOG(&proxy_->GetObjectPath(), 2) << __func__;
     64   proxy_->ScanAsync(base::Bind(&ChromeosModemModem3gppProxy::OnScanSuccess,
     65                                weak_factory_.GetWeakPtr(),
     66                                callback),
     67                     base::Bind(&ChromeosModemModem3gppProxy::OnScanFailure,
     68                                weak_factory_.GetWeakPtr(),
     69                                callback));
     70 }
     71 
     72 void ChromeosModemModem3gppProxy::OnRegisterSuccess(
     73     const ResultCallback& callback) {
     74   SLOG(&proxy_->GetObjectPath(), 2) << __func__;
     75   callback.Run(Error());
     76 }
     77 
     78 void ChromeosModemModem3gppProxy::OnRegisterFailure(
     79     const ResultCallback& callback, brillo::Error* dbus_error) {
     80   SLOG(&proxy_->GetObjectPath(), 2) << __func__;
     81   Error error;
     82   CellularError::FromMM1ChromeosDBusError(dbus_error, &error);
     83   callback.Run(error);
     84 }
     85 
     86 void ChromeosModemModem3gppProxy::OnScanSuccess(
     87     const KeyValueStoresCallback& callback,
     88     const std::vector<brillo::VariantDictionary>& results) {
     89   SLOG(&proxy_->GetObjectPath(), 2) << __func__;
     90   std::vector<KeyValueStore> result_stores;
     91   for (const auto& result : results) {
     92     KeyValueStore result_store;
     93     KeyValueStore::ConvertFromVariantDictionary(result, &result_store);
     94     result_stores.push_back(result_store);
     95   }
     96   callback.Run(result_stores, Error());
     97 }
     98 
     99 void ChromeosModemModem3gppProxy::OnScanFailure(
    100     const KeyValueStoresCallback& callback, brillo::Error* dbus_error) {
    101   SLOG(&proxy_->GetObjectPath(), 2) << __func__;
    102   Error error;
    103   CellularError::FromMM1ChromeosDBusError(dbus_error, &error);
    104   callback.Run(std::vector<KeyValueStore>(), error);
    105 }
    106 
    107 }  // namespace mm1
    108 }  // namespace shill
    109