--- /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 "tvchannel/channel_info.h"
+#include <stdint.h>
+#include <string>
+#include "tvchannel/tvchannel_manager.h"
+#include "common/logger.h"
+
+namespace extension {
+namespace tvchannel {
+
+ChannelInfo::ChannelInfo() :
+ m_major(0), m_minor(0), m_channelName(""), m_programNumber(0), m_ptc(0),
+ m_lcn(0), m_sourceID(0), m_transportStreamID(0), m_originalNetworkID(0),
+ m_serviceName(""), m_serviceID(0) {
+}
+
+ChannelInfo::~ChannelInfo() {
+}
+
+void ChannelInfo::fromApiData(const TCServiceData &channelData) {
+ LOGD("Enter");
+ m_ptc = channelData.Get<u_int16_t>(CHANNEL_NUMBER);
+ m_major = channelData.Get<u_int16_t>(MAJOR);
+ m_minor = channelData.Get<u_int16_t>(MINOR);
+ m_lcn = channelData.Get<u_int16_t>(LCN);
+ m_sourceID = channelData.Get<u_int16_t>(SOURCE_ID);
+ m_programNumber = channelData.Get<u_int16_t>(PROGRAM_NUMBER);
+ m_transportStreamID = channelData.Get<u_int16_t>(TRANSPORT_STREAM_ID);
+ m_originalNetworkID = channelData.Get<u_int16_t>(ORIGINAL_NETWORK_ID);
+ m_serviceID = channelData.Get < TCServiceId > (SERVICE_ID);
+
+ setChannelName(channelData);
+ setServiceName(channelData);
+}
+
+int64_t ChannelInfo::getMajor() const {
+ return m_major;
+}
+
+void ChannelInfo::setMajor(int64_t major) {
+ m_major = major;
+}
+
+int64_t ChannelInfo::getMinor() const {
+ return m_minor;
+}
+
+void ChannelInfo::setMinor(int64_t minor) {
+ m_minor = minor;
+}
+
+std::string ChannelInfo::getChannelName() const {
+ return m_channelName;
+}
+
+void ChannelInfo::setChannelName(std::string channelName) {
+ m_channelName = channelName;
+}
+
+void ChannelInfo::setChannelName(const TCServiceData &channelData) {
+ LOGD("Enter");
+ size_t len = channelData.GetLength(SERVICE_NAME);
+ if (len) {
+ LOGD("ServiceName length %d", len);
+ size_t c_len = len * sizeof(t_wchar_t) / sizeof(char);
+ t_wchar_t svc_name[len + 1];
+ channelData.Get(SERVICE_NAME, svc_name);
+ char name[CHANNEL_NAME_MAX_SIZE];
+ TVChannelManager::ucs2utf8(name, sizeof(name),
+ reinterpret_cast<char *>(svc_name), c_len);
+ m_channelName = name;
+ } else {
+ m_channelName = "";
+ }
+}
+
+int64_t ChannelInfo::getProgramNumber() const {
+ return m_programNumber;
+}
+
+void ChannelInfo::setProgramNumber(int64_t programNumber) {
+ m_programNumber = programNumber;
+}
+
+int64_t ChannelInfo::getPtc() const {
+ return m_ptc;
+}
+
+void ChannelInfo::setPtc(int64_t ptc) {
+ m_ptc = ptc;
+}
+
+int64_t ChannelInfo::getLcn() const {
+ return m_lcn;
+}
+
+void ChannelInfo::setLcn(int64_t lcn) {
+ m_lcn = lcn;
+}
+
+int64_t ChannelInfo::getSourceID() const {
+ return m_sourceID;
+}
+
+void ChannelInfo::setSourceID(int64_t sourceID) {
+ m_sourceID = sourceID;
+}
+
+int64_t ChannelInfo::getTransportStreamID() const {
+ return m_transportStreamID;
+}
+
+void ChannelInfo::setTransportStreamID(int64_t transportStreamID) {
+ m_transportStreamID = transportStreamID;
+}
+
+int64_t ChannelInfo::getOriginalNetworkID() const {
+ return m_originalNetworkID;
+}
+
+void ChannelInfo::setOriginalNetworkID(int64_t originalNetworkID) {
+ m_originalNetworkID = originalNetworkID;
+}
+
+std::string ChannelInfo::getServiceName() const {
+ return getChannelName();
+}
+
+void ChannelInfo::setServiceName(std::string serviceName) {
+ setChannelName(serviceName);
+}
+
+void ChannelInfo::setServiceName(const TCServiceData &data) {
+ setChannelName(data);
+}
+
+TCServiceId ChannelInfo::getServiceID() const {
+ return m_serviceID;
+}
+
+void ChannelInfo::setServiceID(TCServiceId serviceID) {
+ m_serviceID = serviceID;
+}
+
+} // namespace tvchannel
+} // 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_TVCHANNEL_CHANNEL_INFO_H_
+#define SRC_TVCHANNEL_CHANNEL_INFO_H_
+
+#include <ServiceData.h>
+#include <string>
+#include "tvchannel/types.h"
+
+namespace extension {
+namespace tvchannel {
+
+class ChannelInfo {
+ public:
+ ChannelInfo();
+ virtual ~ChannelInfo();
+
+ void fromApiData(const TCServiceData &channelData);
+
+ int64_t getMajor() const;
+ void setMajor(int64_t major);
+
+ int64_t getMinor() const;
+ void setMinor(int64_t minor);
+
+ std::string getChannelName() const;
+ void setChannelName(std::string channelName);
+ void setChannelName(const TCServiceData &channelData);
+
+ int64_t getProgramNumber() const;
+ void setProgramNumber(int64_t programNumber);
+
+ int64_t getPtc() const;
+ void setPtc(int64_t ptc);
+
+ int64_t getLcn() const;
+ void setLcn(int64_t lcn);
+
+ int64_t getSourceID() const;
+ void setSourceID(int64_t sourceID);
+
+ int64_t getTransportStreamID() const;
+ void setTransportStreamID(int64_t transportStreamID);
+
+ int64_t getOriginalNetworkID() const;
+ void setOriginalNetworkID(int64_t originalNetworkID);
+
+ std::string getServiceName() const;
+ void setServiceName(std::string serviceName);
+ void setServiceName(const TCServiceData &channelData);
+
+ TCServiceId getServiceID() const;
+ void setServiceID(TCServiceId serviceID);
+
+ private:
+ int64_t m_major;
+ int64_t m_minor;
+ std::string m_channelName;
+ int64_t m_programNumber;
+ int64_t m_ptc;
+ int64_t m_lcn;
+ int64_t m_sourceID;
+ int64_t m_transportStreamID;
+ int64_t m_originalNetworkID;
+ std::string m_serviceName;
+ TCServiceId m_serviceID;
+
+ static const int CHANNEL_NAME_MAX_SIZE = 128;
+};
+
+} // namespace tvchannel
+} // namespace extension
+
+#endif // SRC_TVCHANNEL_CHANNEL_INFO_H_
'includes': [
'../common/pkg-config.gypi',
],
+ 'conditions': [
+ ['tizen == 1', {
+ 'variables': {
+ 'packages': [
+ 'tvs-api'
+ ],
+ },
+ },
+ ],
+ ],
'sources': [
'tvchannel_api.js',
'tvchannel_error.h',
'tvchannel_extension.h',
'tvchannel_instance.cc',
'tvchannel_instance.h',
+ 'channel_info.cc',
+ 'channel_info.h',
+ 'tvchannel_manager.h',
+ 'tvchannel_manager.cc',
+ 'types.h',
+ 'types.cc'
],
},
],
// This will be generated from datasync_api.js.
extern const char kSource_tvchannel_api[];
-namespace tvchannel {
-
TVChannelExtension::TVChannelExtension() {
- SetExtensionName("tizen.tvchannel");
- SetJavaScriptAPI(kSource_tvchannel_api);
+ SetExtensionName("tizen.tvchannel");
+ SetJavaScriptAPI(kSource_tvchannel_api);
}
-TVChannelExtension::~TVChannelExtension() {}
-
-TVChannelManager& TVChannelExtension::manager() {
- // Initialize API on first request
- return TVChannelManager::getInstance();
+TVChannelExtension::~TVChannelExtension() {
}
common::Instance* TVChannelExtension::CreateInstance() {
- return new TVChannelInstance(*this);
+ return new extension::tvchannel::TVChannelInstance();
}
-} // namespace tvchannel
-
// entry point
common::Extension* CreateExtension() {
- return new tvchannel::TVChannelExtension;
+ return new TVChannelExtension();
}
+
#define SRC_TVCHANNEL_TVCHANNEL_EXTENSION_H_
#include "common/extension.h"
-#include "tvchannel/tvchannel_manager.h"
-namespace tvchannel {
-
-class TVChannelExtension : public common::Extension {
+class TVChannelExtension: public common::Extension {
public:
TVChannelExtension();
virtual ~TVChannelExtension();
-
- TVChannelManager& manager();
-
private:
- // common::Extension implementation.
virtual common::Instance* CreateInstance();
};
-} // namespace tvchannel
-
#endif // SRC_TVCHANNEL_TVCHANNEL_EXTENSION_H_
// found in the LICENSE file.
#include "tvchannel/tvchannel_instance.h"
+#include <functional>
+#include <memory>
#include "common/logger.h"
#include "tizen/tizen.h"
#include "common/picojson.h"
+#include "tvchannel/tvchannel_manager.h"
+#include "tvchannel/channel_info.h"
+namespace extension {
namespace tvchannel {
-TVChannelInstance::TVChannelInstance(TVChannelExtension const& extension) {
- LoggerE("Entered");
+TVChannelInstance::TVChannelInstance() {
+ LOGE("Entered");
+ RegisterSyncHandler("TVChannelManager_getCurrentChannel",
+ std::bind(&TVChannelInstance::getCurrentChannel, this,
+ std::placeholders::_1,
+ std::placeholders::_2));
}
TVChannelInstance::~TVChannelInstance() {
- LoggerE("Entered");
+ LOGE("Entered");
}
-void TVChannelInstance::HandleMessage(const char* msg) {
- // this is stub, no async messages
- LoggerE("Entered");
-}
+void TVChannelInstance::getCurrentChannel(picojson::value const& args,
+ picojson::object& out) {
+ std::unique_ptr< ChannelInfo > pChannel = TVChannelManager::getInstance()->getCurrentChannel(
+ args.get("windowType").get<std::string>());
+
+ picojson::value::object channel;
+ channel.insert(
+ std::make_pair("major",
+ picojson::value(static_cast<double>(pChannel->getMajor()))));
+ channel.insert(
+ std::make_pair("minor",
+ picojson::value(static_cast<double>(pChannel->getMinor()))));
+ channel.insert(
+ std::make_pair("channelName",
+ picojson::value(pChannel->getChannelName())));
+ channel.insert(
+ std::make_pair("programNumber",
+ picojson::value(
+ static_cast<double>(pChannel->getProgramNumber()))));
+ channel.insert(
+ std::make_pair("ptc",
+ picojson::value(static_cast<double>(pChannel->getPtc()))));
+ channel.insert(
+ std::make_pair("lcn",
+ picojson::value(static_cast<double>(pChannel->getLcn()))));
+ channel.insert(
+ std::make_pair("sourceID",
+ picojson::value(static_cast<double>(pChannel->getSourceID()))));
+ channel.insert(
+ std::make_pair("transportStreamID",
+ picojson::value(
+ static_cast<double>(pChannel->getTransportStreamID()))));
+ channel.insert(
+ std::make_pair("originalNetworkID",
+ picojson::value(
+ static_cast<double>(pChannel->getOriginalNetworkID()))));
+ channel.insert(
+ std::make_pair("serviceName",
+ picojson::value(pChannel->getServiceName())));
-void TVChannelInstance::HandleSyncMessage(const char* msg) {
- LoggerE("Entered %s", msg);
- picojson::object answer;
- answer["answer"] = picojson::value(true);
+ picojson::value v(channel);
- SendSyncReply(picojson::value(answer).serialize().c_str());
+ ReportSuccess(v, out);
}
} // namespace tvchannel
+} // namespace extension
#include "tvchannel/tvchannel_extension.h"
+namespace extension {
namespace tvchannel {
-class TVChannelInstance : public common::Instance {
+class TVChannelInstance: public common::ParsedInstance {
public:
- explicit TVChannelInstance(TVChannelExtension const& extension);
- virtual ~TVChannelInstance();
+ TVChannelInstance();
+ virtual ~TVChannelInstance();
private:
- virtual void HandleMessage(const char* msg);
- virtual void HandleSyncMessage(const char* msg);
+ void getCurrentChannel(const picojson::value& args, picojson::object& out);
};
} // namespace tvchannel
+} // namespace extension
#endif // SRC_TVCHANNEL_TVCHANNEL_INSTANCE_H_
// found in the LICENSE file.
#include "tvchannel/tvchannel_manager.h"
+#include <iconv.h>
+#include "tvchannel/channel_info.h"
+#include "common/logger.h"
+#include "common/platform_exception.h"
+namespace extension {
namespace tvchannel {
-TVChannelManager& TVChannelManager::getInstance() {
+TVChannelManager* TVChannelManager::getInstance() {
static TVChannelManager manager;
- return manager;
+ return &manager;
}
+std::unique_ptr<ChannelInfo> TVChannelManager::getCurrentChannel(
+ std::string const& _windowType) {
+ LOGE("Entered %s", _windowType.c_str());
+
+ TCServiceData serviceData;
+ TCCriteriaHelper criteria;
+ criteria.Fetch(SERVICE_ID);
+ criteria.Fetch(MAJOR);
+ criteria.Fetch(MINOR);
+ criteria.Fetch(PROGRAM_NUMBER);
+ criteria.Fetch(CHANNEL_NUMBER);
+ criteria.Fetch(CHANNEL_TYPE);
+ criteria.Fetch(SERVICE_NAME);
+ criteria.Fetch(SOURCE_ID);
+ criteria.Fetch(TRANSPORT_STREAM_ID);
+ criteria.Fetch(ORIGINAL_NETWORK_ID);
+ criteria.Fetch(LCN);
+
+ // Navigation
+ IServiceNavigation* navigation;
+ int ret = TVServiceAPI::CreateServiceNavigation(
+ getProfile(stringToWindowType(_windowType)), 0, &navigation);
+ if (TV_SERVICE_API_SUCCESS != ret) {
+ LoggerE("Failed to create service navigation: %d", ret);
+ throw common::UnknownException("Failed to create service navigation");
+ }
+
+ struct TSTvMode tvMode;
+ ret = navigation->GetTvMode(tvMode);
+ if (TV_SERVICE_API_METHOD_SUCCESS != ret) {
+ LoggerE("Failed to get current tv mode: %d", ret);
+ throw common::UnknownException("Failed to get current tv mode");
+ }
+ LOGE("tvMode : antenna - %d, service - %d", tvMode.antennaMode,
+ tvMode.serviceMode);
+
+ ret = navigation->GetCurrentServiceInfo(tvMode, criteria, serviceData);
+ if (TV_SERVICE_API_METHOD_SUCCESS != ret) {
+ LOGE("Failed to get current service info: %d", ret);
+ throw common::UnknownException("Failed to get current service info");
+ }
+ LoggerE("Current channel id: %llu",
+ serviceData.Get < TCServiceId > (SERVICE_ID));
+ std::unique_ptr<ChannelInfo> pChannel( new ChannelInfo() );
+ pChannel->fromApiData(serviceData);
+ return pChannel;
+}
+
+EProfile TVChannelManager::getProfile(WindowType windowType) {
+ LOGE("Enter");
+ switch (windowType) {
+ case MAIN:
+ return PROFILE_TYPE_MAIN;
+// PIP is not supported - j.h.lim
+// case PIP:
+// return PROFILE_TYPE_PIP;
+ default:
+ LOGE("Unsupported window type: %d", windowType);
+ }
}
+
+void TVChannelManager::ucs2utf8(char *out, size_t out_len, char *in,
+ size_t in_len) {
+ iconv_t cd;
+ size_t r;
+
+ cd = iconv_open("UTF-8", "UCS-2BE");
+ if (cd == (iconv_t) - 1) {
+ LOGE("Failed to open iconv");
+ }
+
+ r = iconv(cd, &in, &in_len, &out, &out_len);
+ if (r == (size_t) - 1) {
+ LOGE("Failed convert string to utf8");
+ }
+
+ iconv_close(cd);
+}
+
+} // namespace tvchannel
+} // namespace extension
#ifndef SRC_TVCHANNEL_TVCHANNEL_MANAGER_H_
#define SRC_TVCHANNEL_TVCHANNEL_MANAGER_H_
+#include <string>
+#include <memory>
+#include <TVServiceAPI.h>
+#include "tvchannel/types.h"
+
+namespace extension {
namespace tvchannel {
+class ChannelInfo;
+// TVServiceAPI static methods returns 0 on success
+static const int TV_SERVICE_API_SUCCESS = 0;
+// TVServiceAPI object methods return 1 on success
+static const int TV_SERVICE_API_METHOD_SUCCESS = 1;
+// TVServiceAPI object methods return -1 on failure
+static const int TV_SERVICE_API_METHOD_FAILURE = -1;
+// You need to check error return in function/method docs and use correct
+// constant
+
class TVChannelManager {
public:
- static TVChannelManager& getInstance();
-
+ static TVChannelManager* getInstance();
+ std::unique_ptr<ChannelInfo> getCurrentChannel(std::string const& _windowType);
+ static void ucs2utf8(char *out, size_t out_len, char *in, size_t in_len);
private:
- // Not copyable, assignable, movable
- TVChannelManager(TVChannelManager const&);
- void operator=(TVChannelManager const&);
- TVChannelManager(TVChannelManager &&);
+ // Not copyable, assignable, movable
+ TVChannelManager() {
+ }
+ TVChannelManager(TVChannelManager const&) = delete;
+ void operator=(TVChannelManager const&) = delete;
+ TVChannelManager(TVChannelManager &&) = delete;
+
+ EProfile getProfile(WindowType windowType);
};
} // namespace tvchannel
+} // namespace extension
#endif // SRC_TVCHANNEL_TVCHANNEL_MANAGER_H_
--- /dev/null
+//
+// Tizen Web Device API
+// Copyright (c) 2012 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "tvchannel/types.h"
+#include "common/logger.h"
+#include "common/platform_exception.h"
+
+namespace extension {
+namespace tvchannel {
+
+const char* NAVIGATOR_MODE_ALL = "ALL";
+const char* NAVIGATOR_MODE_DIGITAL = "DIGITAL";
+const char* NAVIGATOR_MODE_ANALOG = "ANALOG";
+const char* NAVIGATOR_MODE_FAVORITE = "FAVORITE";
+
+NavigatorMode stringToNavigatorMode(const std::string &mode) {
+ if (mode == NAVIGATOR_MODE_ALL) {
+ return NavigatorMode::ALL;
+ }
+ if (mode == NAVIGATOR_MODE_DIGITAL) {
+ return NavigatorMode::DIGITAL;
+ }
+ if (mode == NAVIGATOR_MODE_ANALOG) {
+ return NavigatorMode::ANALOG;
+ }
+ if (mode == NAVIGATOR_MODE_FAVORITE) {
+ return NavigatorMode::FAVORITE;
+ }
+ LOGE("Unrecognized mode");
+ throw common::UnknownException("Unrecognized mode");
+}
+
+const char* TIZEN_TV_WINDOW_TYPE_MAIN = "MAIN";
+// PIP is not supported - j.h.lim
+// const char* TIZEN_TV_WINDOW_TYPE_PIP = "PIP";
+
+std::string windowTypeToString(WindowType type) {
+ switch (type) {
+ case MAIN:
+ return TIZEN_TV_WINDOW_TYPE_MAIN;
+ break;
+// PIP is not supported - j.h.lim
+// case PIP:
+// return TIZEN_TV_WINDOW_TYPE_PIP;
+// break;
+ default:
+ LOGE("Unrecognized window type: %d", type);
+ throw common::UnknownException("Unrecognized window type");
+ }
+}
+
+WindowType stringToWindowType(std::string type) {
+ if (type == TIZEN_TV_WINDOW_TYPE_MAIN) {
+ return MAIN;
+// PIP is not supported - j.h.lim
+// } else if (type == TIZEN_TV_WINDOW_TYPE_PIP) {
+// return PIP;
+ } else {
+ LOGE("Unrecognized window type: %s", type.c_str());
+ throw common::UnknownException("Unrecognized window type");
+ }
+}
+
+} // namespace tvchannel
+} // namespace extension
+
--- /dev/null
+//
+// Tizen Web Device API
+// Copyright (c) 2012 Samsung Electronics Co., Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the License);
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef SRC_TVCHANNEL_TYPES_H_
+#define SRC_TVCHANNEL_TYPES_H_
+
+#include <string>
+
+namespace extension {
+namespace tvchannel {
+
+enum NavigatorMode {
+ NOT_DEFINED,
+ ALL,
+ DIGITAL,
+ ANALOG,
+ FAVORITE
+};
+
+enum WindowType {
+ MAIN = 0,
+// PIP is not supported - j.h.lim
+// PIP
+};
+
+extern const char* TIZEN_TV_WINDOW_TYPE_MAIN;
+
+enum class SourceType {
+ TV,
+ AV,
+ SVIDEO,
+ COMP,
+ PC,
+ HDMI,
+ SCART,
+ DVI,
+ MEDIA,
+ IPTV,
+ UNKNOWN
+};
+
+extern const char* NAVIGATOR_MODE_ALL;
+extern const char* NAVIGATOR_MODE_DIGITAL;
+extern const char* NAVIGATOR_MODE_ANALOG;
+extern const char* NAVIGATOR_MODE_FAVORITE;
+
+NavigatorMode stringToNavigatorMode(std::string const& mode);
+std::string windowTypeToString(WindowType type);
+WindowType stringToWindowType(std::string type);
+
+} // namespace tvchannel
+} // namespace extension
+
+#endif // SRC_TVCHANNEL_TYPES_H_
projects / platform / core / api / webapi-plugins.git / commitdiff