%define tizen_feature_exif_support 1
%define tizen_feature_filesystem_support 1
%define tizen_feature_fm_radio_support 0
+%define tizen_feature_media_key_support 1
%define tizen_feature_message_port_support 1
%define tizen_feature_messaging_support 1
%define tizen_feature_nbs_support 1
%define tizen_feature_exif_support 0
%define tizen_feature_filesystem_support 0
%define tizen_feature_fm_radio_support 0
+%define tizen_feature_media_key_support 0
%define tizen_feature_message_port_support 0
%define tizen_feature_messaging_support 0
%define tizen_feature_nbs_support 0
%define tizen_feature_exif_support 1
%define tizen_feature_filesystem_support 1
%define tizen_feature_fm_radio_support 0
+%define tizen_feature_media_key_support 0
%define tizen_feature_message_port_support 1
%define tizen_feature_messaging_support 0
%define tizen_feature_nbs_support 0
%endif
+%if 0%{?tizen_feature_media_key_support}
+BuildRequires: pkgconfig(capi-system-media-key)
+%endif
+
%description
Tizen Web APIs implemented.
GYP_OPTIONS="$GYP_OPTIONS -Dtizen_feature_exif_support=%{?tizen_feature_exif_support}"
GYP_OPTIONS="$GYP_OPTIONS -Dtizen_feature_filesystem_support=%{?tizen_feature_filesystem_support}"
GYP_OPTIONS="$GYP_OPTIONS -Dtizen_feature_fm_radio_support=%{?tizen_feature_fm_radio_support}"
+GYP_OPTIONS="$GYP_OPTIONS -Dtizen_feature_media_key_support=%{?tizen_feature_media_key_support}"
GYP_OPTIONS="$GYP_OPTIONS -Dtizen_feature_message_port_support=%{?tizen_feature_message_port_support}"
GYP_OPTIONS="$GYP_OPTIONS -Dtizen_feature_messaging_support=%{?tizen_feature_messaging_support}"
GYP_OPTIONS="$GYP_OPTIONS -Dtizen_feature_nbs_support=%{?tizen_feature_nbs_support}"
--- /dev/null
+{
+ 'includes':[
+ '../common/common.gypi',
+ ],
+ 'targets': [
+ {
+ 'target_name': 'tizen_mediakey',
+ 'type': 'loadable_module',
+ 'sources': [
+ 'mediakey_api.js',
+ 'mediakey_extension.cc',
+ 'mediakey_extension.h',
+ 'mediakey_instance.cc',
+ 'mediakey_instance.h',
+ 'mediakey_manager.cc',
+ 'mediakey_manager.h'
+ ],
+ 'includes': [
+ '../common/pkg-config.gypi',
+ ],
+ 'conditions': [
+ ['tizen == 1', {
+ 'variables': {
+ 'packages': [
+ 'capi-system-media-key',
+ ]
+ },
+ }],
+ ],
+ },
+ ],
+}
--- /dev/null
+// Copyright 2015 Samsung Electronics Co, Ltd. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+var validator = xwalk.utils.validator;
+var type = xwalk.utils.type;
+var native = new xwalk.utils.NativeManager(extension);
+var converter_ = xwalk.utils.converter;
+
+var ON_PRESSED_MEDIA_KEY_EVENT_CALLBACK = 'onPressedMediaKeyEventCallback';
+var ON_RELEASED_MEDIA_KEY_EVENT_CALLBACK = 'onReleasedMediaKeyEventCallback';
+
+function MediaKeyManager() {
+ validator.isConstructorCall(this, MediaKeyManager);
+}
+
+MediaKeyManager.prototype.setMediaKeyEventListener = function(callback) {
+ var args = validator.validateArgs(arguments, [
+ {
+ name: 'callback',
+ type: validator.Types.LISTENER,
+ values: ['onpressed', 'onreleased']
+ }
+ ]);
+
+ var ret = native.callSync('MediaKeyManager_setMediaKeyEventListener', {});
+
+ if (native.isFailure(ret)) {
+ throw native.getErrorObject(ret);
+ }
+
+ native.removeListener(ON_PRESSED_MEDIA_KEY_EVENT_CALLBACK);
+ native.removeListener(ON_RELEASED_MEDIA_KEY_EVENT_CALLBACK);
+
+ native.addListener(ON_PRESSED_MEDIA_KEY_EVENT_CALLBACK, function(msg) {
+ native.callIfPossible(args.callback.onpressed, native.getResultObject(msg.type));
+ });
+ native.addListener(ON_RELEASED_MEDIA_KEY_EVENT_CALLBACK, function(msg) {
+ native.callIfPossible(args.callback.onpressed, native.getResultObject(msg.type));
+ });
+
+};
+
+MediaKeyManager.prototype.unsetMediaKeyEventListener = function() {
+ var ret = native.callSync('MediaKeyManager_unsetMediaKeyEventListener',{});
+
+ if (native.isFailure(ret)) {
+ throw native.getErrorObject(ret);
+ }
+
+ native.removeListener(ON_PRESSED_MEDIA_KEY_EVENT_CALLBACK);
+ native.removeListener(ON_RELEASED_MEDIA_KEY_EVENT_CALLBACK);
+};
+
+exports = new MediaKeyManager();
--- /dev/null
+// Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "mediakey/mediakey_extension.h"
+#include "mediakey/mediakey_instance.h"
+#include "mediakey/mediakey_manager.h"
+
+// This will be generated from mediakey_api.js.
+extern const char kSource_mediakey_api[];
+
+namespace extension {
+namespace mediakey {
+
+MediaKeyExtension::MediaKeyExtension() {
+ SetExtensionName("tizen.mediakey");
+ SetJavaScriptAPI(kSource_mediakey_api);
+}
+
+MediaKeyExtension::~MediaKeyExtension() {
+}
+
+common::Instance* MediaKeyExtension::CreateInstance() {
+ return new MediaKeyInstance();
+}
+
+} // namespace mediakey
+} // namespace extension
+
+// entry point
+common::Extension* CreateExtension() {
+ return new extension::mediakey::MediaKeyExtension();
+}
+
--- /dev/null
+// Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_MEDIAKEY_MEDIAKEY_EXTENSION_H_
+#define SRC_MEDIAKEY_MEDIAKEY_EXTENSION_H_
+
+#include "common/extension.h"
+
+namespace extension {
+namespace mediakey {
+
+class MediaKeyManager;
+
+class MediaKeyExtension : public common::Extension {
+ public:
+ MediaKeyExtension();
+ virtual ~MediaKeyExtension();
+
+ private:
+ virtual common::Instance* CreateInstance();
+};
+
+} // namespace mediakey
+} // namespace extension
+
+#endif // SRC_MEDIAKEY_MEDIAKEY_EXTENSION_H_
--- /dev/null
+// Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <functional>
+#include <map>
+#include "common/logger.h"
+#include "mediakey/mediakey_instance.h"
+#include "mediakey/mediakey_manager.h"
+
+namespace extension {
+namespace mediakey {
+
+const std::map<media_key_e, std::string> kMediaKeyTypeMap = {
+ { MEDIA_KEY_PLAY, "MEDIA_PLAY" },
+ { MEDIA_KEY_STOP, "MEDIA_STOP" },
+ { MEDIA_KEY_PAUSE, "MEDIA_PAUSE" },
+ { MEDIA_KEY_PREVIOUS, "MEDIA_PREVIOUS" },
+ { MEDIA_KEY_NEXT, "MEDIA_NEXT" },
+ { MEDIA_KEY_FASTFORWARD, "MEDIA_FAST_FORWARD" },
+ { MEDIA_KEY_REWIND, "MEDIA_REWIND" },
+ { MEDIA_KEY_PLAYPAUSE, "MEDIA_PLAY_PAUSE" } };
+
+MediaKeyInstance::MediaKeyInstance() {
+ LoggerD("Entered");
+ using std::placeholders::_1;
+ using std::placeholders::_2;
+#define REGISTER_SYNC(c, x) \
+ RegisterSyncHandler(c, std::bind(&MediaKeyInstance::x, this, _1, _2));
+ REGISTER_SYNC("MediaKeyManager_setMediaKeyEventListener",
+ SetMediaKeyEventListener);
+ REGISTER_SYNC("MediaKeyManager_unsetMediaKeyEventListener",
+ UnsetMediaKeyEventListener);
+#undef REGISTER_SYNC
+}
+
+MediaKeyInstance::~MediaKeyInstance() {
+ LoggerD("Entered");
+}
+
+void MediaKeyInstance::SetMediaKeyEventListener(const picojson::value& args,
+ picojson::object& out) {
+ common::PlatformResult result = MediaKeyManager::GetInstance()
+ .RegisterMediaKeyEventListener(this);
+ if (result.IsError()) {
+ LOGD("Error occured");
+ ReportError(result, &out);
+ } else {
+ ReportSuccess(out);
+ }
+}
+
+void MediaKeyInstance::UnsetMediaKeyEventListener(const picojson::value& args,
+ picojson::object& out) {
+ common::PlatformResult result = MediaKeyManager::GetInstance()
+ .UnregisterMediaKeyEventListener();
+ if (result.IsError()) {
+ LOGD("Error occured");
+ ReportError(result, &out);
+ } else {
+ ReportSuccess(out);
+ }
+}
+
+void MediaKeyInstance::OnPressedMediaKeyEventCallback(media_key_e type) {
+ LoggerD("Enter");
+ PostEvent("onPressedMediaKeyEventCallback", type);
+}
+
+void MediaKeyInstance::OnReleasedMediaKeyEventCallback(media_key_e type) {
+ LoggerD("Enter");
+ PostEvent("onReleasedMediaKeyEventCallback", type);
+}
+
+void MediaKeyInstance::PostEvent(const std::string& eventCallback,
+ media_key_e type) {
+ LoggerD("Enter");
+ auto k = kMediaKeyTypeMap.find(type);
+ if (k != kMediaKeyTypeMap.end()) {
+ picojson::value event = picojson::value(picojson::object());
+ picojson::object& obj = event.get<picojson::object>();
+ obj["listenerId"] = picojson::value(eventCallback);
+ obj["type"] = picojson::value(k->second);
+ PostMessage(event.serialize().c_str());
+ }
+ else {
+ LoggerD("Unsupported key");
+ }
+}
+
+} // namespace mediakey
+} // namespace extension
--- /dev/null
+// Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef SRC_MEDIAKEY_MEDIAKEY_INSTANCE_H_
+#define SRC_MEDIAKEY_MEDIAKEY_INSTANCE_H_
+
+#include <string>
+
+#include "common/extension.h"
+#include "common/picojson.h"
+
+#include "mediakey/mediakey_manager.h"
+
+namespace extension {
+namespace mediakey {
+
+class MediaKeyInstance : public common::ParsedInstance, public MediaKeyListener {
+ public:
+ MediaKeyInstance();
+ virtual ~MediaKeyInstance();
+
+ private:
+ void SetMediaKeyEventListener(const picojson::value& args,
+ picojson::object& out);
+ void UnsetMediaKeyEventListener(const picojson::value& args,
+ picojson::object& out);
+ virtual void OnPressedMediaKeyEventCallback(media_key_e type);
+ virtual void OnReleasedMediaKeyEventCallback(media_key_e type);
+ void PostEvent(const std::string& event, media_key_e type);
+};
+
+} // namespace mediakey
+} // namespace extension
+
+#endif // SRC_MEDIAKEY_MEDIAKEY_INSTANCE_H_
--- /dev/null
+// Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "mediakey/mediakey_manager.h"
+#include "common/logger.h"
+#include "common/platform_exception.h"
+
+namespace extension {
+namespace mediakey {
+
+using common::UnknownException;
+using common::ErrorCode;
+MediaKeyListener::~MediaKeyListener() {
+ LoggerD("Enter");
+}
+
+MediaKeyManager& MediaKeyManager::GetInstance() {
+ static MediaKeyManager manager;
+ return manager;
+}
+
+MediaKeyManager::MediaKeyManager()
+ : m_media_key_listener_registered(false) {
+ LoggerD("Enter");
+}
+
+common::PlatformResult MediaKeyManager::RegisterMediaKeyEventListener(
+ MediaKeyListener* listener) {
+ LoggerD("Enter");
+ if (!m_media_key_listener_registered) {
+ int ret = media_key_reserve(MediaKeyEventCallback, NULL);
+ if (MEDIA_KEY_ERROR_NONE != ret) {
+ LoggerD("Failed to register "
+ "a media keys change event callback: %d",
+ ret);
+ return common::PlatformResult(
+ ErrorCode::UNKNOWN_ERR,
+ "Failed to register a media keys change event callback");
+ }
+ m_media_key_listener = listener;
+ m_media_key_listener_registered = true;
+ LOGD("Added media keys change event callback");
+ }
+ return common::PlatformResult(ErrorCode::NO_ERROR);
+}
+common::PlatformResult MediaKeyManager::UnregisterMediaKeyEventListener() {
+ LoggerD("Enter");
+ if (m_media_key_listener_registered) {
+ int ret = media_key_release();
+ if (MEDIA_KEY_ERROR_NONE != ret) {
+ LoggerD("Failed to unregister "
+ "the change event callback function: %d",
+ ret);
+ return common::PlatformResult(
+ ErrorCode::UNKNOWN_ERR,
+ "Failed to unregister the change event callback function");
+ }
+ }
+ m_media_key_listener = NULL;
+ m_media_key_listener_registered = false;
+ return common::PlatformResult(ErrorCode::NO_ERROR);
+}
+
+void MediaKeyManager::MediaKeyEventCallback(media_key_e key,
+ media_key_event_e status,
+ void* user_data) {
+ LoggerD("Enter");
+ if (!GetInstance().m_media_key_listener) {
+ LOGD("Listener is null. Ignoring");
+ return;
+ }
+ if (MEDIA_KEY_STATUS_PRESSED == status) {
+ GetInstance().m_media_key_listener->OnPressedMediaKeyEventCallback(key);
+ } else if (MEDIA_KEY_STATUS_RELEASED == status) {
+ GetInstance().m_media_key_listener->OnReleasedMediaKeyEventCallback(key);
+ }
+}
+
+} // namespace mediakey
+} // namespace extension
--- /dev/null
+// Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <media_key.h>
+#include "common/platform_result.h"
+
+#ifndef SRC_MEDIAKEY_MEDIAKEY_MANAGER_H_
+#define SRC_MEDIAKEY_MEDIAKEY_MANAGER_H_
+
+namespace extension {
+namespace mediakey {
+
+class MediaKeyListener {
+ public:
+ virtual void OnPressedMediaKeyEventCallback(media_key_e type)= 0;
+ virtual void OnReleasedMediaKeyEventCallback(media_key_e type)= 0;
+ virtual ~MediaKeyListener();
+};
+
+class MediaKeyManager {
+ public:
+ common::PlatformResult RegisterMediaKeyEventListener(
+ MediaKeyListener* listener);
+ common::PlatformResult UnregisterMediaKeyEventListener();
+ static MediaKeyManager& GetInstance();
+ static void MediaKeyEventCallback(media_key_e key, media_key_event_e status,
+ void* user_data);
+
+ private:
+ // Not copyable, assignable, movable
+ MediaKeyManager(MediaKeyManager const&) = delete;
+ void operator=(MediaKeyManager const&) = delete;
+ MediaKeyManager(MediaKeyManager &&) = delete;
+
+ MediaKeyManager();
+ MediaKeyListener* m_media_key_listener;
+ bool m_media_key_listener_registered;
+};
+
+} // namespace mediakey
+} // namespace extension
+
+#endif // SRC_MEDIAKEY_MEDIAKEY_MANAGER_H_
],
},
],
+ [
+ 'tizen_feature_media_key_support==1', {
+ 'dependencies': [
+ 'mediakey/mediakey.gyp:*',
+ ],
+ },
+ ],
[
'tizen_feature_message_port_support==1', {
'dependencies': [
projects / platform / core / api / webapi-plugins.git / commitdiff