ADD_DEFINITIONS("-DPROJECT_TAG=\"CAPMGR\"")
## Find all needed packages once
+PKG_CHECK_MODULES(AUL_DEPS REQUIRED aul)
+PKG_CHECK_MODULES(BUNDLE_DEPS REQUIRED bundle)
PKG_CHECK_MODULES(DLOG_DEPS REQUIRED dlog)
PKG_CHECK_MODULES(GIO_DEPS REQUIRED gio-2.0)
PKG_CHECK_MODULES(GLIB_DEPS REQUIRED glib-2.0)
BuildRequires: boost-devel
BuildRequires: cmake
BuildRequires: gtest-devel
+BuildRequires: pkgconfig(aul)
+BuildRequires: pkgconfig(bundle)
BuildRequires: pkgconfig(dlog)
BuildRequires: pkgconfig(gio-2.0)
BuildRequires: pkgconfig(glib-2.0)
#include <functional>
+#include "common/capability.h"
#include "common/capability_manager.h"
#include "common/connection_manager.h"
#include "common/dbus_service.h"
DBusService::RegisterMethodHandler("ExchangeCapabilities", std::bind(
&ConnectionManager::ExchangeCapabilities, connmgr_.get()));
+ DBusService::RegisterSendAppcontrolHandler("SendRemoteAppControl", std::bind(
+ &ConnectionManager::SendCapability, connmgr_.get(),
+ std::placeholders::_1,
+ std::placeholders::_2));
+
return true;
}
)
APPLY_PKG_CONFIG(${TARGET_LIB_COMMON} PUBLIC
+ AUL_DEPS
+ BUNDLE_DEPS
DLOG_DEPS
GIO_DEPS
GLIB_DEPS
--- /dev/null
+// Copyright (c) 2018 Samsung Electronics Co., Ltd All Rights Reserved
+// Use of this source code is governed by a apache 2.0 license that can be
+// found in the LICENSE file.
+
+#include "appcontrol_manager.h"
+
+#include <aul.h>
+#include <aul_svc.h>
+#include <bundle.h>
+
+#include "common/utils/logging.h"
+
+namespace capmgr {
+ int AppControlManager::LaunchApplication(const Capability& capability) {
+ int ret;
+
+ bundle* b = bundle_create();
+ aul_svc_set_operation(b, capability.name().c_str());
+
+ ret = aul_launch_app(capability.pkgid().c_str(), b);
+ if (ret < AUL_R_OK) {
+ LOG(ERROR) << "launch failed : " << ret;
+ bundle_free(b);
+ return ret;
+ }
+
+ bundle_free(b);
+ return 0;
+ }
+} // namespace capmgr
#include <glib.h>
+#include "common/capability.h"
+
namespace capmgr {
class AppControlManager {
public:
AppControlManager();
~AppControlManager();
+
+ static int LaunchApplication(const Capability& capability);
private:
};
#include <iostream>
#include "common/capability.h"
+#include "common/dbus_service.h"
#include "common/package_event_listener.h"
#include "common/utils/logging.h"
namespace capmgr {
-CapabilityManager::CapabilityManager() {}
+CapabilityManager::CapabilityManager() {
+ DBusService::RegisterGetRemoteCapsHandler("GetRemoteCapabilities", std::bind(
+ &CapabilityManager::GetList, this, std::placeholders::_1));
+}
CapabilityManager::~CapabilityManager() {}
const std::vector<Capability>& CapabilityManager::GetCapabilities() const {
return list_;
}
+void CapabilityManager::GetList(GVariant **params) {
+ GVariantBuilder* builder;
+
+ builder = g_variant_builder_new (G_VARIANT_TYPE ("a(sss)"));
+ for (const auto& cap : list_) {
+ g_variant_builder_add (builder, "(sss)",
+ cap.name().c_str(),
+ cap.pkgid().c_str(),
+ cap.appid().c_str());
+ }
+ *params = g_variant_new ("a(sss)", builder);
+ g_variant_builder_unref (builder);
+}
+
bool CapabilityManager::AddCapability(const Capability& capability) {
list_.push_back(std::move(capability));
return true;
~CapabilityManager();
const std::vector<Capability>& GetCapabilities() const;
bool AddCapability(const Capability& capability);
+ void GetList(GVariant **params);
bool ListCapabilities();
bool LoadCapabilities();
std::string PackCapabilities();
namespace capmgr {
class CapabilityManager;
+class Capability;
class ConnectionManager {
public:
virtual void FindDevices() = 0;
virtual void RegisterEndpoint() = 0;
virtual void ExchangeCapabilities() = 0;
+ virtual bool SendCapability(
+ Capability* cap,
+ std::function<void(Capability, int)> reply) = 0;
protected:
CapabilityManager* capmgr_;
#include <vector>
#include "common/utils/logging.h"
+#include "common/capability.h"
namespace {
" <method name='ExchangeCapabilities'>"
" <arg type='b' name='result' direction='out'/>"
" </method>"
+ " <method name='GetRemoteCapabilities'>"
+ " <arg type='v' name='result' direction='out'/>"
+ " </method>"
" <method name='SendRemoteAppControl'>"
+ " <arg type='(sss)' name='appcontrol' direction='in'/>"
" <arg type='b' name='result' direction='out'/>"
" </method>"
" </interface>"
EventHandler().on_event.connect(handler);
else if (method == "ExchangeCapabilities")
EventHandler().on_event2.connect(handler);
- else if (method == "SendRemoteAppControl")
- EventHandler().on_event3.connect(handler);
+}
+
+void DBusService::RegisterSendAppcontrolHandler(const std::string& method,
+ std::function<bool(Capability*, std::function<void(Capability, int)>)> handler) {
+ if (method == "SendRemoteAppControl")
+ EventHandler().send_app_control_event.connect(handler);
+}
+
+void DBusService::RegisterGetRemoteCapsHandler(const std::string& method,
+ std::function<void(GVariant**)> handler) {
+ if (method == "GetRemoteCapabilities")
+ EventHandler().get_remote_caps_event.connect(handler);
}
bool DBusService::HandleDiscoverUnownedDevices(GVariant* params,
bool DBusService::HandleSendRemoteAppControl(GVariant* params,
GDBusMethodInvocation* invocation) {
- EventHandler().on_event3();
+ LOG(INFO) << "HandleGetRemoteCapabilities ";
+ gchar* name;
+ gchar* appid;
+ gchar* pkgid;
+ g_variant_get(params, "((sss))", &name, &appid, &pkgid);
+
+ Capability cap(name, pkgid, appid);
+ LOG(INFO) << "From: " << cap.name();
+
+ EventHandler().send_app_control_event(&cap,
+ [=](Capability cap, int ret) {
+ LOG(INFO) << "RET: " << ret;
+
+ LOG(INFO) << "Success launch: " << cap.name();
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(b)", ret));
+ });
return true;
}
+void DBusService::HandleGetRemoteCapabilities(GVariant* params,
+ GDBusMethodInvocation* invocation) {
+ GVariant* temp;
+ EventHandler().get_remote_caps_event(&temp);
+
+ g_dbus_method_invocation_return_value(invocation, g_variant_new("(v)", temp));
+}
+
void DBusService::HandleMethodCall(GDBusConnection* /* connection */,
const gchar* /* sender */, const gchar* /* object_path */,
const gchar* /* interface_name */, const gchar* method_name,
bool r = false;
LOG(INFO) << "Incomming method call: " << method_name;
- if (g_strcmp0("DiscoverUnownedDevices", method_name) == 0)
+ if (g_strcmp0("DiscoverUnownedDevices", method_name) == 0) {
r = HandleDiscoverUnownedDevices(parameters, invocation);
- else if (g_strcmp0("ExchangeCapabilities", method_name) == 0)
+ }
+ else if (g_strcmp0("ExchangeCapabilities", method_name) == 0) {
r = HandleExchangeCapabilities(parameters, invocation);
- else if (g_strcmp0("SendRemoteAppControl", method_name) == 0)
- r = HandleSendRemoteAppControl(parameters, invocation);
+ }
+ else if (g_strcmp0("GetRemoteCapabilities", method_name) == 0) {
+ HandleGetRemoteCapabilities(parameters, invocation);
+ return;
+ }
+ else if (g_strcmp0("SendRemoteAppControl", method_name) == 0) {
+ LOG(INFO) << " method call: " << method_name;
+ HandleSendRemoteAppControl(parameters, invocation);
+ return;
+ }
g_dbus_method_invocation_return_value(invocation, g_variant_new("(b)", r));
}
namespace capmgr {
+class Capability;
+
class DBusService {
public:
DBusService();
static void RegisterMethodHandler(const std::string& method,
std::function<void()> handler);
+ static void RegisterSendAppcontrolHandler(const std::string& method,
+ std::function<bool(Capability*, std::function<void(Capability, int)>)> handler);
+ static void RegisterGetRemoteCapsHandler(const std::string& method,
+ std::function<void(GVariant**)> handler);
private:
class DBusMethodHandler {
public:
boost::signals2::signal<void()> on_event;
boost::signals2::signal<void()> on_event2;
- boost::signals2::signal<void()> on_event3;
+ boost::signals2::signal<bool(Capability*, std::function<void(Capability, int)>)> send_app_control_event;
+ boost::signals2::signal<void(GVariant**)> get_remote_caps_event;
};
static DBusMethodHandler& EventHandler() {
GDBusMethodInvocation* invocation);
bool HandleExchangeCapabilities(GVariant* params,
GDBusMethodInvocation* invocation);
+ void HandleGetRemoteCapabilities(GVariant* params,
+ GDBusMethodInvocation* invocation);
bool HandleSendRemoteAppControl(GVariant* params,
GDBusMethodInvocation* invocation);
#include "common/capability.h"
#include "common/capability_manager.h"
+#include "common/appcontrol_manager.h"
#include "common/utils/logging.h"
namespace {
result = OCPlatform::registerPlatformInfo(platformInfo);
*/
}
-
Iotivity::~Iotivity() {
}
GetResource(it.second);
}
+bool Iotivity::SendCapability(Capability* cap, std::function<void(Capability, int)> reply) {
+ PutResource(cap, reply);
+ return 0;
+}
+
+void Iotivity::PutResource(Capability* cap, std::function<void(Capability, int)> putCallback) {
+ LOG(INFO) << "Put Resource";
+ for (std::map<OC::OCResourceIdentifier, std::shared_ptr<OC::OCResource>>::iterator it=resource_list_.begin(); it!=resource_list_.end(); ++it) {
+ std::shared_ptr<OC::OCResource> resource;
+ resource = it->second;
+ OC::OCRepresentation rep;
+
+ LOG(INFO) << "Putting.." << resource->uri();
+ rep.setValue("capability", cap->Serialize());
+
+ Capability dup(cap->name(), cap->pkgid(), cap->appid());
+ OC::QueryParamsMap queryParamsMap;
+ OCStackResult res = resource->put(rep, queryParamsMap,
+ [=](const OC::HeaderOptions& opts, const OC::OCRepresentation& rep,
+ const int ec) {
+ LOG(INFO) << "From: " << rep.getUri() << " of " << rep.getHost();
+ LOG(INFO) << "PUT RESULT data: " << ec;
+
+ putCallback(dup, ec);
+
+ });
+
+ LOG(INFO) << "res: " << res;
+ }
+}
+
void Iotivity::RegisterResource() {
std::string uri = "/capmgr/capabilities";
uint8_t property = OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE;
sec_rsc->doOwnershipTransfer(
[this, devaddr](OC::PMResultList_t* result, int hasError) {
if (hasError) {
- LOG(ERROR) << "Failed to ownership transfer";
+ LOG(ERROR) << "Failed to ownership transfer :: " << hasError;
return;
}
LOG(INFO) << "Ownership transferred: "
}
std::string req_type = request->getRequestType();
- if (req_type != "GET") {
- LOG(WARNING) << "The request is not GET";
+ if (req_type == "GET") {
+ LOG(WARNING) << "The request is GET";
+
+ // OC::QueryParamsMap qmap = request->getQueryParameters();
+
+ OC::OCRepresentation rep;
+ rep.setUri("/capmgr/capabilities");
+ std::string capabilities = capmgr_->PackCapabilities();
+ rep.setValue("data", capabilities);
+
+ auto response = std::make_shared<OC::OCResourceResponse>();
+ response->setErrorCode(200); // ??
+ response->setResponseResult(OC_EH_OK);
+ response->setResourceRepresentation(rep);
+ response->setRequestHandle(request->getRequestHandle());
+ response->setResourceHandle(request->getResourceHandle());
+
+ OCStackResult result = OC::OCPlatform::sendResponse(response);
+ if (result != OC_STACK_OK)
+ LOG(ERROR) << "OCPlatform::sendResponse() error: " << result;
+ else
+ LOG(INFO) << "Sending response done";
+
return OC_EH_OK;
}
- // OC::QueryParamsMap qmap = request->getQueryParameters();
+ if (req_type == "PUT") {
+ LOG(WARNING) << "The request is PUT";
+ OC::OCRepresentation rep = request->getResourceRepresentation();
+ int ret;
- OC::OCRepresentation rep;
- rep.setUri("/capmgr/capabilities");
- std::string capabilities = capmgr_->PackCapabilities();
- rep.setValue("data", capabilities);
+ std::string cap_data;
+ rep.getValue("capability", cap_data);
+ LOG(INFO) << "capability : " << cap_data;
- auto response = std::make_shared<OC::OCResourceResponse>();
- response->setErrorCode(200); // ??
- response->setResponseResult(OC_EH_OK);
- response->setResourceRepresentation(rep);
- response->setRequestHandle(request->getRequestHandle());
- response->setResourceHandle(request->getResourceHandle());
+ Capability cap(cap_data);
- OCStackResult result = OC::OCPlatform::sendResponse(response);
- if (result != OC_STACK_OK)
- LOG(ERROR) << "OCPlatform::sendResponse() error: " << result;
- else
- LOG(INFO) << "Sending response done";
+ ret = AppControlManager::LaunchApplication(cap);
+ if (ret != 0) {
+ return OC_EH_ERROR;
+ }
+
+ return OC_EH_OK;
+ }
return OC_EH_OK;
}
void FindDevices() override;
void RegisterEndpoint() override;
void ExchangeCapabilities() override;
+ bool SendCapability(Capability* cap, std::function<void(Capability, int)> reply) override;
private:
void RegisterResource();
void FindResource(const std::string& addr);
+ void PutResource(Capability* cap, std::function<void(Capability, int)> putCallback);
void DiscoverUnownedDevices();
void OwnershipTransfer();
void GetResource(std::shared_ptr<OC::OCResource> resource);
projects / platform / core / appfw / capmgr.git / commitdiff