chromeos/dbus/ibus/ibus_engine_factory_service.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/dbus/ibus/ibus_engine_factory_service.h"
   6
   7 #include <map>
   8 #include <string>
   9
  10 #include "base/string_number_conversions.h"
  11 #include "chromeos/dbus/ibus/ibus_constants.h"
  12 #include "chromeos/ime/ibus_bridge.h"
  13 #include "dbus/bus.h"
  14 #include "dbus/message.h"
  15 #include "dbus/exported_object.h"
  16
  17 namespace chromeos {
  18
  19 class IBusEngineFactoryServiceImpl : public IBusEngineFactoryService {
  20  public:
  21   explicit IBusEngineFactoryServiceImpl(dbus::Bus* bus)
  22       : bus_(bus),
  23         weak_ptr_factory_(this) {
  24     exported_object_ = bus_->GetExportedObject(
  25         dbus::ObjectPath(ibus::engine_factory::kServicePath));
  26
  27     exported_object_->ExportMethod(
  28         ibus::engine_factory::kServiceInterface,
  29         ibus::engine_factory::kCreateEngineMethod,
  30         base::Bind(&IBusEngineFactoryServiceImpl::CreateEngine,
  31                    weak_ptr_factory_.GetWeakPtr()),
  32         base::Bind(&IBusEngineFactoryServiceImpl::CreateEngineExported,
  33                    weak_ptr_factory_.GetWeakPtr()));
  34   }
  35
  36   virtual ~IBusEngineFactoryServiceImpl() {
  37     bus_->UnregisterExportedObject(dbus::ObjectPath(
  38         ibus::engine_factory::kServicePath));
  39   }
  40
  41   // IBusEngineFactoryService override.
  42   virtual void SetCreateEngineHandler(
  43       const std::string& engine_id,
  44       const CreateEngineHandler& create_engine_handler) OVERRIDE {
  45     DCHECK(create_engine_callback_map_[engine_id].is_null());
  46     create_engine_callback_map_[engine_id] = create_engine_handler;
  47   }
  48
  49   // IBusEngineFactoryService override.
  50   virtual void UnsetCreateEngineHandler(
  51       const std::string& engine_id) OVERRIDE {
  52     create_engine_callback_map_[engine_id].Reset();
  53   }
  54
  55  private:
  56   // Called when the ibus-daemon requires new engine instance.
  57   void CreateEngine(dbus::MethodCall* method_call,
  58                     dbus::ExportedObject::ResponseSender response_sender) {
  59     if (!method_call) {
  60       LOG(ERROR) << "method call does not have any arguments.";
  61       return;
  62     }
  63     dbus::MessageReader reader(method_call);
  64     std::string engine_name;
  65
  66     if (!reader.PopString(&engine_name)) {
  67       LOG(ERROR) << "Expected argument is string.";
  68       return;
  69     }
  70     if (create_engine_callback_map_[engine_name].is_null()) {
  71       LOG(WARNING) << "The CreateEngine handler for " << engine_name
  72                    << " is NULL.";
  73     } else {
  74       create_engine_callback_map_[engine_name].Run(
  75           base::Bind(&IBusEngineFactoryServiceImpl::CreateEngineSendReply,
  76                      weak_ptr_factory_.GetWeakPtr(),
  77                      base::Passed(dbus::Response::FromMethodCall(method_call)),
  78                      response_sender));
  79     }
  80   }
  81
  82   // Sends reply message for CreateEngine method call.
  83   void CreateEngineSendReply(
  84       scoped_ptr<dbus::Response> response,
  85       const dbus::ExportedObject::ResponseSender response_sender,
  86       const dbus::ObjectPath& path) {
  87     dbus::MessageWriter writer(response.get());
  88     writer.AppendObjectPath(path);
  89     response_sender.Run(response.Pass());
  90   }
  91
  92   // Called when the CreateEngine method is exported.
  93   void CreateEngineExported(const std::string& interface_name,
  94                             const std::string& method_name,
  95                             bool success) {
  96     DCHECK(success) << "Failed to export: "
  97                     << interface_name << "." << method_name;
  98   }
  99
 100   // CreateEngine method call handler.
 101   std::map<std::string, CreateEngineHandler> create_engine_callback_map_;
 102
 103   dbus::Bus* bus_;
 104   scoped_refptr<dbus::ExportedObject> exported_object_;
 105   base::WeakPtrFactory<IBusEngineFactoryServiceImpl> weak_ptr_factory_;
 106
 107   DISALLOW_COPY_AND_ASSIGN(IBusEngineFactoryServiceImpl);
 108 };
 109
 110 // An implementation of IBusEngineFactoryService without ibus-daemon
 111 // interaction. Currently this class is used only on linux desktop.
 112 // TODO(nona): Use this on ChromeOS device once crbug.com/171351 is fixed.
 113 class IBusEngineFactoryServiceDaemonlessImpl : public IBusEngineFactoryService {
 114  public:
 115   IBusEngineFactoryServiceDaemonlessImpl() {}
 116   virtual ~IBusEngineFactoryServiceDaemonlessImpl() {}
 117
 118   // IBusEngineFactoryService override.
 119   virtual void SetCreateEngineHandler(
 120       const std::string& engine_id,
 121       const CreateEngineHandler& create_engine_handler) OVERRIDE {
 122     IBusBridge::Get()->SetCreateEngineHandler(engine_id, create_engine_handler);
 123   }
 124
 125   // IBusEngineFactoryService override.
 126   virtual void UnsetCreateEngineHandler(
 127       const std::string& engine_id) OVERRIDE {
 128     IBusBridge::Get()->UnsetCreateEngineHandler(engine_id);
 129   }
 130
 131  private:
 132   DISALLOW_COPY_AND_ASSIGN(IBusEngineFactoryServiceDaemonlessImpl);
 133 };
 134
 135 IBusEngineFactoryService::IBusEngineFactoryService() {
 136 }
 137
 138 IBusEngineFactoryService::~IBusEngineFactoryService() {
 139 }
 140
 141 // static
 142 IBusEngineFactoryService* IBusEngineFactoryService::Create(
 143     dbus::Bus* bus,
 144     DBusClientImplementationType type) {
 145   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
 146     return new IBusEngineFactoryServiceImpl(bus);
 147   else
 148     return new IBusEngineFactoryServiceDaemonlessImpl();
 149 }
 150
 151 }  // namespace chromeos