Name: wrt-plugins-tizen
Summary: JavaScript plugins for WebRuntime
-Version: 0.4.38
+Version: 0.4.39
Release: 0
Group: Development/Libraries
License: Apache License, Version 2.0
namespace DeviceAPI {
namespace Application {
-using namespace DPL;
+
using namespace WrtDeviceApis;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
-using namespace DPL;
+
namespace DeviceAPI {
namespace CallHistory {
#include "CallHistoryAsyncCallbackManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::CallHistory::CallHistoryAsyncCallbackManager)
using namespace DeviceAPI::Tizen;
using namespace WrtDeviceApis;
using namespace WrtDeviceApis::Commons;
-using namespace DPL;
+
namespace DeviceAPI {
namespace CallHistory {
#include "CallHistoryListenerManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::CallHistory::CallHistoryListenerManager)
using namespace std;
-using namespace DPL;
+
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace DeviceAPI::Tizen;
EventFindCallHistoryPtr event(new EventFindCallHistory());
ICallHistoryPtr callHistory(priv->getObject());
- event->setPrivateData(StaticPointerCast<IEventPrivateData> (cbm));
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData> (cbm));
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
if (argumentCount >= 3) {
EventRemoveBatchPtr event(new EventRemoveBatch());
ICallHistoryPtr callHistory(priv->getObject());
- event->setPrivateData(StaticPointerCast<IEventPrivateData> (cbm));
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData> (cbm));
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
CallHistoryEntryList entryList;
EventRemoveAllPtr event(new EventRemoveAll());
ICallHistoryPtr callHistory(priv->getObject());
- event->setPrivateData(StaticPointerCast<IEventPrivateData> (cbm));
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData> (cbm));
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
callHistory->removeAll(event);
CallHistoryAsyncCallbackManagerSingleton::Instance().registerCallbackManager(cbm, gContext);
#define _LOGGER(prio, fmt, args...) \
do { \
std::ostringstream platformLog; \
+ platformLog << "%s: %s(%d) > "; \
platformLog << fmt; \
- print_log(prio, LOG_TAG, "%s: %s(%d) > %s", __MODULE__, __func__, __LINE__, platformLog.str().c_str(), ##args); \
+ print_log(prio, LOG_TAG, platformLog.str().c_str(), __MODULE__, __func__, __LINE__, ##args); \
} while(0)
#define LoggerD(fmt, args...) _LOGGER(DLOG_DEBUG, fmt, ##args)
#define LoggerW(fmt, args...) _LOGGER(DLOG_WARN, fmt, ##args)
#define LoggerE(fmt, args...) _LOGGER(DLOG_ERROR, fmt, ##args)
+#ifdef _SECURE_LOG
+#define _SLOGGER(prio, fmt, args...) \
+ do { \
+ std::ostringstream platformLog; \
+ platformLog << "%s: %s(%d) > [SECURE_LOG] "; \
+ platformLog << fmt; \
+ print_log(prio, LOG_TAG, platformLog.str().c_str(), __MODULE__, __func__, __LINE__, ##args); \
+ } while(0)
+#else
+#define _SLOGGER(prio,fmt,args....) (0)
+#endif
+
+
+#define SLoggerD(fmt, args...) _SLOGGER(DLOG_DEBUG, fmt, ##args)
+#define SLoggerI(fmt, args...) _SLOGGER(DLOG_INFO, fmt, ##args)
+#define SLoggerE(fmt, args...) _SLOGGER(DLOG_ERROR, fmt, ##args)
+
#endif // __TIZEN_COMMON_LOGGER_H__
g_items[i]->last_timestamp - g_first_time, //end timestamp
g_items[i]->mismatch_count ); // # of mismatch (begin - end mismatch)
-#if 0
- LOGE("[%%3d] %%-%ds |\tTotal:%%ld,\tCnt:%%ld,\tAvg:%%ld,\tMin:%%ld,\tMax:%%ld,\tStart:%%lu,\tEnd:%%lu,\tMismatch:%%ld",
- i,g_items[i]->name, g_items[i]->total_elapsed_time, g_items[i]->invoke_count, (g_items[i]->total_elapsed_time == 0)?0:(int)(g_items[i]->total_elapsed_time / g_items[i]->invoke_count), g_items[i]->min_elapsed_time, g_items[i]->max_elapsed_time, g_items[i]->first_timestamp - g_first_time, g_items[i]->last_timestamp - g_first_time, g_items[i]->mismatch_count );
-#endif
+ print_log(DLOG_ERROR, LOG_TAG, format,i,g_items[i]->name, g_items[i]->total_elapsed_time, g_items[i]->invoke_count, (g_items[i]->total_elapsed_time == 0)?0:(int)(g_items[i]->total_elapsed_time / g_items[i]->invoke_count), g_items[i]->min_elapsed_time, g_items[i]->max_elapsed_time, g_items[i]->first_timestamp - g_first_time, g_items[i]->last_timestamp - g_first_time, g_items[i]->mismatch_count );
+
}
fprintf(fp, "TIME TRACER REPORT [END] ============================\n");
LOGE("TIME TRACER REPORT [END] ============================");
#include <dpl/singleton_impl.h>
#include <Logger.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::Contact::ContactQueueManager)
#include <metadata_extractor.h>
#include <Logger.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::Content::MediaLyricsUtil)
#include "ContentAsyncCallbackManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::Content::MediaContentAsyncCallbackManager)
#include "DataControlAsyncCallbackManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::DataControl::DataControlAsyncCallbackManager)
#include "MessagePortListenerManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::MessagePort::MessagePortListenerManager)
SET(DESTINATION_NAME ${messaging_dest})
SET(TARGET_IMPL_NAME ${messaging_impl})
-PKG_CHECK_MODULES(platform_pkgs_messaging REQUIRED msg-service email-service dbus-1)
+PKG_CHECK_MODULES(platform_pkgs_messaging REQUIRED msg-service email-service dbus-1 capi-system-info)
ADD_DEFINITIONS("-fvisibility=hidden")
namespace DeviceAPI {
namespace Messaging {
- const std::string ConversationQueryGenerator::QUERY_PREFIX_SMS = "WHERE (B.SMS_CNT > 0 OR B.MMS_CNT > 0) AND A.CONV_ID = B.CONV_ID AND (B.MAIN_TYPE=1) AND (";
- const std::string ConversationQueryGenerator::QUERY_PREFIX_MMS = "WHERE (B.SMS_CNT > 0 OR B.MMS_CNT > 0 ) AND A.CONV_ID = B.CONV_ID AND (B.MAIN_TYPE=2) AND (";
+ const std::string ConversationQueryGenerator::QUERY_PREFIX_SMS = "WHERE B.SMS_CNT > 0 AND A.CONV_ID = B.CONV_ID AND (";
+ const std::string ConversationQueryGenerator::QUERY_PREFIX_MMS = "WHERE B.MMS_CNT > 0 AND A.CONV_ID = B.CONV_ID AND (";
const std::string ConversationQueryGenerator::QUERY_PREFIX_EMAIL = "WHERE ";
const std::string ConversationQueryGenerator::QUERY_SUFFIX_SMS_MMS = ") ";
const std::string ConversationQueryGenerator::QUERY_SUFFIX_EMAIL = "";
attributeMap.insert(
std::pair<std::string, std::string>(
ConversationFilterValidatorFactory::ATTRIBUTE_ID, "A.ADDRESS_ID"));
- attributeMap.insert(
+ if(getMode() == MODE_SMS)
+ {
+ attributeMap.insert(
+ std::pair<std::string, std::string>(
+ ConversationFilterValidatorFactory::ATTRIBUTE_TYPE, "B.SMS_CNT"));
+ }
+ else{
+ attributeMap.insert(
std::pair<std::string, std::string>(
- ConversationFilterValidatorFactory::ATTRIBUTE_TYPE, "B.MAIN_TYPE"));
+ ConversationFilterValidatorFactory::ATTRIBUTE_TYPE, "B.MMS_CNT"));
+ }
attributeMap.insert(
std::pair<std::string, std::string>(
ConversationFilterValidatorFactory::ATTRIBUTE_TIMESTAMP, "B.DISPLAY_TIME"));
if(attrName.compare(ConversationFilterValidatorFactory::ATTRIBUTE_MESSAGE_COUNT)==0){
retClause = emfAttributeName + "=" + value->toString();
return retClause;
+ }else if(attrName.compare(ConversationFilterValidatorFactory::ATTRIBUTE_TYPE)==0){
+ retClause = emfAttributeName + " > 0";
+ LoggerD(">retClause>> " << retClause);
+ return retClause;
}else if(attrName.compare(ConversationFilterValidatorFactory::ATTRIBUTE_PREVIEW)==0){
retClause = emfAttributeName + " LIKE '" + value->toString() + "'";
return retClause;
#include <email-types.h>
#include <email-api.h>
+#include <set>
#include <Commons/Exception.h>
#include <Commons/StringUtils.h>
vector<IMessagePtr> retVal;
int tempInt;
- int tempPreviousId = -1;
+ set<int> alreadyCreated;
// int l_msgId = 0;
MessageType webApiMsgType;
{
ThrowMsg(WrtDeviceApis::Commons::UnknownException, "get message id fail");
}
- if( tempPreviousId != tempInt)
+ if(alreadyCreated.find(tempInt) == alreadyCreated.end())
{
IMessagePtr msg;
msg = MessageFactory::createMessage(webApiMsgType, tempInt);
- tempPreviousId = tempInt;
+ alreadyCreated.insert(tempInt);
retVal.push_back(msg);
}
} //for
LoggerD(">>>");
return retVal;
}
-
vector<IMessagePtr> Messaging::querySmsMmsMessages(const std::string& queryString, const std::string& orderLimitString){
// LOGD("<<< queryString:[%s]", queryString.c_str());
// LOGD("<<< orderLimitString:[%s]", orderLimitString.c_str());
printErrorMessage(errCode);
}else{
LoggerD("message found mailListCount:" << mailListCount);
- std::map<int, int> checkUnique;
+ std::set<int> checkUnique;
for(int i=0; i<mailListCount; i++){
if (checkUnique.find(mailList[i].thread_id) == checkUnique.end()){
- checkUnique[mailList[i].thread_id] = mailList[i].thread_id;
+ checkUnique.insert(mailList[i].thread_id);
IConversationPtr convPtr(new Conversation(mailList[i].thread_id, EMAIL));
//TODO for debug
#include <email-api.h>
#include <Logger.h>
+//for mms support
+#include <system_info.h>
+#include <PlatformException.h>
+
using namespace std;
using namespace DPL;
+using namespace DeviceAPI::Common;
namespace DeviceAPI {
namespace Messaging {
initialize();
}
+ if( event->getMessagingServiceType() == MMS)
+ {
+ bool isSupported = false;
+ if(system_info_get_value_bool(SYSTEM_INFO_KEY_MMS_SUPPORTED, &isSupported) != SYSTEM_INFO_ERROR_NONE) {
+ LoggerE("Can't know whether mms is supported or not");
+ }
+ LoggerD("isSupported " << isSupported);
+ if(isSupported == false)
+ {
+ LoggerE("mms is not supported");
+ throw DeviceAPI::Common::NotSupportedException("Unsupported message type");
+ }
+ }
+
EventRequestReceiver<EventGetMessagingService>::PostRequest(event);
LoggerD(">>>");
{
LoggerE("Sending Message (submit request) failed!!! err=" << err);
setMessageStatus(MESSAGE_STATUS_FAILED);
- goto ERROR;
+ Throw(WrtDeviceApis::Commons::PlatformException);
}
setMessageStatus(MESSAGE_STATUS_SENDING);
}
Catch(WrtDeviceApis::Commons::PlatformException) {
LoggerE("message is not send, manually run callback");
- goto ERROR;
+ ReqReceiverMessage *requestReceiver = getRequestReceiver();
+ if (requestReceiver) {
+ LoggerE("send Error");
+ EventMessagingServicePtr event = getMessagingServiceEvent();
+ event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
+ requestReceiver->WrtDeviceApis::Commons::EventRequestReceiver< EventMessagingService>::ManualAnswer(event);
+ }
}
return 0;
-
- ERROR:
- ReqReceiverMessage *requestReceiver = getRequestReceiver();
- if (requestReceiver) {
- LoggerE("send Error");
- EventMessagingServicePtr event = getMessagingServiceEvent();
- event->setExceptionCode(WrtDeviceApis::Commons::ExceptionCodes::UnknownException);
- requestReceiver->WrtDeviceApis::Commons::EventRequestReceiver< EventMessagingService>::ManualAnswer(event);
- }
- return 0;
}
void Mms::sendingCallback(msg_struct_t sent_status)
#include <Logger.h>
using namespace std;
-using namespace DPL;
+
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
);
EventNFCChangedEmitterPtr emitter(new EventNFCChangedEmitter);
emitter->setListener(&NFCStaticController::getInstance());
- emitter->setEventPrivateData(StaticPointerCast<EventNFCChanged::PrivateDataType>(privateData));
+ emitter->setEventPrivateData(DPL::StaticPointerCast<EventNFCChanged::PrivateDataType>(privateData));
if (nfcAdapter->setTagListener(emitter, tagFilter) != 0)
Throw(WrtDeviceApis::Commons::UnknownException);
NFCListenerCancellerPtr canceller = NFCListenerCancellerPtr(new NFCListenerCanceller(global_context, thisObject, static_cast<long>(ID_NFCADAPTER_TAG_LISTENER)));
- IListenerItemPtr listenerItem = StaticPointerCast<IListenerItem>(canceller);
+ IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
NFCListenerManagerSingleton::Instance().registerListener(listenerItem, global_context);
return JSValueMakeUndefined(context);
EventNFCChangedEmitterPtr emitter(new EventNFCChangedEmitter);
emitter->setListener(&NFCStaticController::getInstance());
- emitter->setEventPrivateData(StaticPointerCast<EventNFCChanged::PrivateDataType>(privateData));
+ emitter->setEventPrivateData(DPL::StaticPointerCast<EventNFCChanged::PrivateDataType>(privateData));
if (nfcAdapter->setPeerListener(emitter) != 0)
Throw(WrtDeviceApis::Commons::UnknownException);
NFCListenerCancellerPtr canceller = NFCListenerCancellerPtr(new NFCListenerCanceller(global_context, thisObject, static_cast<long>(ID_NFCADAPTER_PEER_LISTENER)));
- IListenerItemPtr listenerItem = StaticPointerCast<IListenerItem>(canceller);
+ IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
NFCListenerManagerSingleton::Instance().registerListener(listenerItem, global_context);
return JSValueMakeUndefined(context);
nfcAdapter->unsetTagListener();
NFCListenerCancellerPtr canceller = NFCListenerCancellerPtr(new NFCListenerCanceller(privateObject->getContext(), thisObject, static_cast<long>(ID_NFCADAPTER_TAG_LISTENER)));
- IListenerItemPtr listenerItem = StaticPointerCast<IListenerItem>(canceller);
+ IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
NFCListenerManagerSingleton::Instance().unregisterListener(listenerItem);
return JSValueMakeUndefined(context);
nfcAdapter->unsetPeerListener();
NFCListenerCancellerPtr canceller = NFCListenerCancellerPtr(new NFCListenerCanceller(privateObject->getContext(), thisObject, static_cast<long>(ID_NFCADAPTER_PEER_LISTENER)));
- IListenerItemPtr listenerItem = StaticPointerCast<IListenerItem>(canceller);
+ IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
NFCListenerManagerSingleton::Instance().unregisterListener(listenerItem);
return JSValueMakeUndefined(context);
NFCConverter nfcConverter(context);
EventNFCChangedSetPoweredPtr event(new EventNFCChangedSetPowered(state));
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&NFCStaticController::getInstance());
nfcAdapter->setPowered(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
#include <Logger.h>
using namespace std;
-using namespace DPL;
+
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
-using namespace DPL;
+
#define TIZEN_NFCTAG_ATTRIBUTENAME "NFCTag"
callbackManager->setOnError(arguments[1]);
EventTagActionReadPtr event(new EventTagActionRead());
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
nfcTag->readNdef(event);
NFCConverter convert(context);
void *messageHandle = convert.copiedMessage(ndefMessageObj);
event->writeNdef(messageHandle);
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager));
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
nfcTag->writeNdef(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
if (dataObj)
data= convert.toVectorOfUChars(arguments[0]);
event->transceive(data);
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
nfcTag->transceive(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
-using namespace DPL;
+
#define TIZEN_NFCTARGET_ATTRIBUTENAME "NFCTarget"
EventTargetActionReceiveEmitterPtr emitter(new EventTargetActionReceiveEmitter);
emitter->setListener(&NFCResponseDispatcher::getInstance());
- emitter->setEventPrivateData(StaticPointerCast<EventTargetActionReceive::PrivateDataType>(callbackManager));
+ emitter->setEventPrivateData(DPL::StaticPointerCast<EventTargetActionReceive::PrivateDataType>(callbackManager));
nfcTarget->setReceiveNDEFListener(emitter);
NFCListenerCancellerPtr canceller = NFCListenerCancellerPtr(new NFCListenerCanceller(global_context, thisObject, static_cast<long>(ID_NFCPEER_RECEIVENDEF_LISTENER)));
- IListenerItemPtr listenerItem = StaticPointerCast<IListenerItem>(canceller);
+ IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
NFCListenerManagerSingleton::Instance().registerListener(listenerItem, global_context);
return JSValueMakeUndefined(context);
nfcTarget->unsetReceiveNDEFListener();
NFCListenerCancellerPtr canceller = NFCListenerCancellerPtr(new NFCListenerCanceller(global_context, thisObject, static_cast<long>(ID_NFCPEER_RECEIVENDEF_LISTENER)));
- IListenerItemPtr listenerItem = StaticPointerCast<IListenerItem>(canceller);
+ IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
NFCListenerManagerSingleton::Instance().unregisterListener(listenerItem);
return JSValueMakeUndefined(context);
void *messageHandle = convert.copiedMessage(ndefMessageObj);
EventTargetActionSendPtr event(new EventTargetActionSend(messageHandle));
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager));
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
event->setForAsynchronousCall(&NFCResponseDispatcher::getInstance());
nfcTarget->sendNDEF(event);
NFCAsyncCallbackManagerSingleton::Instance().registerCallbackManager(callbackManager, global_context);
#include "NFCUtil.h"
#include <Logger.h>
-using namespace DPL;
+
namespace DeviceAPI {
namespace NFC {
#include "NFCAsyncCallbackManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::NFC::NFCAsyncCallbackManager)
#include "NFCUtil.h"
#include <Logger.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::NFC::NFCDefaultAdapter)
namespace DeviceAPI {
#include "NFCListenerManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::NFC::NFCListenerManager)
namespace DeviceAPI {
namespace NetworkBearerSelection {
using namespace std;
-using namespace DPL;
+
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace WrtDeviceApis::Commons;
using namespace DeviceAPI::Common;
EventNetworkBearerReleasePtr dplEvent(new EventNetworkBearerRelease());
dplEvent->setNetworkType(networkType);
dplEvent->setDomainName(domainName);
- dplEvent->setPrivateData(StaticPointerCast<IEventPrivateData>(callbackManager));
+ dplEvent->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
dplEvent->setForAsynchronousCall(&NetworkBearerSelectionResponseDispatcher::getInstance());
NetworkBearerSelections->releaseRouteToHost(dplEvent);
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace WrtDeviceApis::Commons;
-using namespace DPL;
+
namespace DeviceAPI {
namespace NetworkBearerSelection {
{
public:
- StatusNotification(NotificationType type); //type.
- StatusNotification(void* noti); // notification
- StatusNotification(int privID); //private ID of Notification.
+ explicit StatusNotification(NotificationType type); //type.
+ explicit StatusNotification(void* noti); // notification
+ explicit StatusNotification(int privID); //private ID of Notification.
~StatusNotification();
} // Notification
} // DeviceAPI
-#endif // __TIZEN_STATUS_NOTIFICATION_H__
\ No newline at end of file
+#endif // __TIZEN_STATUS_NOTIFICATION_H__
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
-using namespace DPL;
+
#define TIZEN_SECHANNEL_ATTRIBUTENAME "Channel"
#define TIZEN_SECHANNEL_ISBASICCHANNEL "isBasicChannel"
Try {
EventSEChannelTransmitPtr event(new EventSEChannelTransmit(convert.toVectorOfUChars(arguments[0])));
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&SEResponseDispatcher::getInstance());
seChannel->transmit(event);
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
-using namespace DPL;
+
#define TIZEN_SEREADER_ATTRIBUTENAME "Reader"
#define TIZEN_SEREADER_ISPRESENT "isPresent"
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
Try {
EventSEOpenSessionPtr event(new EventSEOpenSession());
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&SEResponseDispatcher::getInstance());
seReader->openSession(event);
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
-using namespace DPL;
+
#define TIZEN_SESERVICE_ATTRIBUTENAME "SEService"
JSCallbackManagerPtr callbackManager = JSCallbackManager::createObject(privateObject->getContext(), onSuccessForCbm, onErrorForCbm, true, true);
Try {
EventListSEsPtr event(new EventListSEs());
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&SEResponseDispatcher::getInstance());
seService->getReaders(event);
Try {
EventSEStateChangedEmitterPtr emitter(new EventSEStateChangedEmitter);
emitter->setListener(&SEResponseDispatcher::getInstance());
- emitter->setEventPrivateData(StaticPointerCast<EventSEStateChanged::PrivateDataType>(callbackManager));
+ emitter->setEventPrivateData(DPL::StaticPointerCast<EventSEStateChanged::PrivateDataType>(callbackManager));
seService->registerSEListener(emitter);
SEListenerCancellerPtr canceller = SEListenerCancellerPtr(new SEListenerCanceller(privateObject->getContext(), thisObject, static_cast<long>(emitter->getId())));
- IListenerItemPtr listenerItem = StaticPointerCast<IListenerItem>(canceller);
+ IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
SEListenerManagerSingleton::Instance().registerListener(listenerItem, privateObject->getContext());
return convert.toJSValueRef(static_cast<unsigned long>(emitter->getId()));
seService->unregisterSEListener(value);
SEListenerCancellerPtr canceller = SEListenerCancellerPtr(new SEListenerCanceller(privateObject->getContext(), thisObject, value));
- IListenerItemPtr listenerItem = StaticPointerCast<IListenerItem>(canceller);
+ IListenerItemPtr listenerItem = DPL::StaticPointerCast<IListenerItem>(canceller);
SEListenerManagerSingleton::Instance().unregisterListener(listenerItem);
return JSValueMakeUndefined(context);
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
-using namespace DPL;
+
#define TIZEN_SESESSION_ATTRIBUTENAME "Session"
#define TIZEN_SESESSION_ISCLOSED "isClosed"
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Wrong AID length");
}
EventSEOpenChannelPtr event(new EventSEOpenChannel(aid, true));
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&SEResponseDispatcher::getInstance());
seSession->openChannel(event);
return JSWebAPIErrorFactory::postException(context, exception, JSWebAPIErrorFactory::INVALID_VALUES_ERROR, "Wrong AID length");
}
EventSEOpenChannelPtr event(new EventSEOpenChannel(aid, false));
- event->setPrivateData( StaticPointerCast<IEventPrivateData>(callbackManager) );
+ event->setPrivateData( DPL::StaticPointerCast<IEventPrivateData>(callbackManager) );
event->setForAsynchronousCall(&SEResponseDispatcher::getInstance());
seSession->openChannel(event);
#include "SEAsyncCallbackManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::SecureElement::SEAsyncCallbackManager)
#include "SEListenerManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::SecureElement::SEListenerManager)
#include <Logger.h>
using namespace std;
-using namespace DPL;
+
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace WrtDeviceApis::Commons;
using namespace DeviceAPI::Common;
EventSetSettingPtr dplEvent(new EventSetSetting());
dplEvent->setSettingType(settingType);
dplEvent->setSettingValue(settingValue);
- dplEvent->setPrivateData(StaticPointerCast<IEventPrivateData>(callbackManager));
+ dplEvent->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
dplEvent->setForAsynchronousCall(&SystemSettingResponseDispatcher::getInstance());
SystemSettings->setProperty(dplEvent);
ISystemSettingPtr SystemSettings(priv->getObject());
EventGetSettingPtr dplEvent(new EventGetSetting());
dplEvent->setSettingType(settingType);
- dplEvent->setPrivateData(StaticPointerCast<IEventPrivateData>(callbackManager));
+ dplEvent->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(callbackManager));
dplEvent->setForAsynchronousCall(&SystemSettingResponseDispatcher::getInstance());
SystemSettings->getProperty(dplEvent);
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace WrtDeviceApis::Commons;
-using namespace DPL;
+
namespace DeviceAPI {
namespace SystemSetting {
#include "SystemSettingAsyncCallbackManager.h"
#include <dpl/singleton_impl.h>
-using namespace DPL;
+
IMPLEMENT_SINGLETON(DeviceAPI::SystemSetting::SystemSettingAsyncCallbackManager)
capi-system-runtime-info
capi-system-sensor
sensor
+ pkgmgr-info
+ tapi
)
ADD_DEFINITIONS("-fvisibility=hidden")
#include <memory>
#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
-#include <system_info.h>
+#include <tapi_common.h>
+#include <ITapiModem.h>
#include "JSCellularNetworkInfo.h"
#include "plugin_config.h"
#include <Logger.h>
AceSecurityStatus status = SYSTEMINFO_CHECK_ACCESS(SYSTEMINFO_FUNCTION_API_GET_PROPERTY_PARTNER_VALUE);
TIZEN_SYNC_ACCESS_HANDLER(status, context, exception);
+ TapiHandle *handle = NULL;
char* imei = NULL;
- if (system_info_get_value_string(SYSTEM_INFO_KEY_MOBILE_DEVICE_ID, &imei) == SYSTEM_INFO_ERROR_NONE) {
- if (imei) {
- LoggerD("imei : " << imei);
- cellularNetworkInfo->imei = imei;
- free(imei);
- }
+ handle = tel_init(0);
+
+ if (handle == NULL) {
+ return convert.toJSValueRef(cellularNetworkInfo->imei);
}
+ imei = tel_get_misc_me_imei_sync(handle);
+
+ if (imei == NULL) {
+ tel_deinit(handle);
+ return convert.toJSValueRef(cellularNetworkInfo->imei);
+ }
+
+ cellularNetworkInfo->imei = imei;
+ free(imei);
+ tel_deinit(handle);
+
return convert.toJSValueRef(cellularNetworkInfo->imei);
}
}
#include <fstream>
#include <pcrecpp.h>
#include <memory>
+#include <dlfcn.h>
+#include <unistd.h>
#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
-#include <sensor.h>
#include <sensors.h>
#include <system_info.h>
+#include <pkgmgr-info.h>
#include "JSDeviceCapabilitiesInfo.h"
#include "plugin_config.h"
#include <Logger.h>
}
return convert.toJSValueRef(deviceCapabilitiesInfo->nfc);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_NFC_RESERVED_PUSH)) {
+ bool nfcReservedPush = false;
+ if (system_info_get_value_bool(SYSTEM_INFO_KEY_NFC_RESERVED_PUSH_SUPPORTED, &nfcReservedPush) == SYSTEM_INFO_ERROR_NONE) {
+ LoggerD("nfcReservedPush : " << nfcReservedPush);
+ deviceCapabilitiesInfo->nfcReservedPush = nfcReservedPush;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->nfcReservedPush);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_MULTITOUCHCOUNT)) {
int multiTouchCount = 0;
}
return convert.toJSValueRef(deviceCapabilitiesInfo->inputKeyboard);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_INPUTKEYBOARD_LAYOUT)) {
+ char* inputKeyboard = NULL;
+ if (system_info_get_value_string(SYSTEM_INFO_KEY_KEYBOARD_TYPE, &inputKeyboard) == SYSTEM_INFO_ERROR_NONE) {
+ if (inputKeyboard != NULL) {
+ LoggerD("inputKeyboard : " << inputKeyboard);
+ if (strcmp(inputKeyboard, "NULL") == 0) {
+ deviceCapabilitiesInfo->inputKeyboard = false;
+ } else {
+ deviceCapabilitiesInfo->inputKeyboard = true;
+ }
+ free(inputKeyboard);
+ }
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->inputKeyboardLayout);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_WIFI)) {
bool wifi = false;
}
return convert.toJSValueRef(deviceCapabilitiesInfo->wifiDirect);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_OPENGLES)) {
+ char* openglesVersion = NULL;
+ if (system_info_get_value_string(SYSTEM_INFO_KEY_OPENGLES_VERSION, &openglesVersion) == SYSTEM_INFO_ERROR_NONE) {
+ if (openglesVersion!= NULL) {
+ LoggerD("openglesVersion : " << openglesVersion);
+ deviceCapabilitiesInfo->opengles = true;
+ free(openglesVersion);
+ }
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->opengles);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_OPENGLES_TEXTURE_FORMAT)) {
+ char* textureFormat = NULL;
+ if (system_info_get_value_string(SYSTEM_INFO_KEY_OPENGLES_TEXTURE_FORMAT, &textureFormat) == SYSTEM_INFO_ERROR_NONE) {
+ if (textureFormat!= NULL) {
+ LoggerD("textureFormat : " << textureFormat);
+ deviceCapabilitiesInfo->openglestextureFormat = textureFormat;
+ free(textureFormat);
+ }
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->openglestextureFormat);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_OPENGLESVERSION1_1)) {
char* openglesVersion = NULL;
if (system_info_get_value_string(SYSTEM_INFO_KEY_OPENGLES_VERSION, &openglesVersion) == SYSTEM_INFO_ERROR_NONE) {
if (openglesVersion!= NULL) {
LoggerD("openglesVersion : " << openglesVersion);
- if (strcmp(openglesVersion, "1.0") == 0) {
+ if (strcmp(openglesVersion, "1.1") == 0) {
deviceCapabilitiesInfo->openglesVersion1_1 = true;
- } else if (strcmp(openglesVersion, "1.0/2.0") == 0) {
+ } else if (strcmp(openglesVersion, "1.1/2.0") == 0) {
deviceCapabilitiesInfo->openglesVersion1_1 = true;
}
free(openglesVersion);
LoggerD("openglesVersion : " << openglesVersion);
if (strcmp(openglesVersion, "2.0") == 0) {
deviceCapabilitiesInfo->openglesVersion2_0 = true;
- } else if (strcmp(openglesVersion, "1.0/2.0") == 0) {
+ } else if (strcmp(openglesVersion, "1.1/2.0") == 0) {
deviceCapabilitiesInfo->openglesVersion2_0 = true;
}
free(openglesVersion);
}
return convert.toJSValueRef(deviceCapabilitiesInfo->cameraFront);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_CAMERA)) {
+ int cameraCount = 0;
+ if (system_info_get_value_int(SYSTEM_INFO_KEY_CAMERA_COUNT, &cameraCount) == SYSTEM_INFO_ERROR_NONE) {
+ LoggerD("cameraCount : " << cameraCount);
+ if (cameraCount > 0) {
+ deviceCapabilitiesInfo->camera = true;
+ } else {
+ deviceCapabilitiesInfo->camera = false;
+ }
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->camera);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_CAMERAFRONTFLASH)) {
bool cameraFrontFlash = false;
}
return convert.toJSValueRef(deviceCapabilitiesInfo->speechRecognition);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SPEECH_SYNTHESIS)) {
+ void* handle = dlopen("/usr/lib/libtts.so",RTLD_NOW);
+ if(handle!=NULL) {
+ deviceCapabilitiesInfo->speechSynthesis = true;
+ } else {
+ deviceCapabilitiesInfo->speechSynthesis = false;
+ }
+ LoggerD("speechSynthesis : " << deviceCapabilitiesInfo->speechSynthesis);
return convert.toJSValueRef(deviceCapabilitiesInfo->speechSynthesis);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_ACCELEROMETER)) {
bool isAccelerometer = false;
}
return convert.toJSValueRef(deviceCapabilitiesInfo->accelerometer);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_ACCELEROMETER_WAKEUP)) {
+ bool isAccelerometerWakeup = false;
+ if (sensor_awake_is_supported(SENSOR_ACCELEROMETER, &isAccelerometerWakeup) == SENSOR_ERROR_NONE) {
+ LoggerD("isAccelerometerWakeup : " << isAccelerometerWakeup);
+ deviceCapabilitiesInfo->accelerometerWakeup = isAccelerometerWakeup;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->accelerometerWakeup);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_BAROMETER)) {
bool isBarometer = false;
}
return convert.toJSValueRef(deviceCapabilitiesInfo->gyroscope);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_GYROSCOPE_WAKEUP)) {
+ bool isGyroscopeWakeup = false;
+ if (sensor_awake_is_supported(SENSOR_GYROSCOPE, &isGyroscopeWakeup) == SENSOR_ERROR_NONE) {
+ LoggerD("isGyroscopeWakeup : " << isGyroscopeWakeup);
+ deviceCapabilitiesInfo->gyroscopeWakeup = isGyroscopeWakeup;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->gyroscopeWakeup);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_MAGNETOMETER)) {
bool isMagnetometer = false;
}
return convert.toJSValueRef(deviceCapabilitiesInfo->magnetometer);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_MAGNETOMETER_WAKEUP)) {
+ bool isMagnetometerWakeup = false;
+ if (sensor_awake_is_supported(SENSOR_MAGNETIC, &isMagnetometerWakeup) == SENSOR_ERROR_NONE) {
+ LoggerD("isMagnetometerWakeup : " << isMagnetometerWakeup);
+ deviceCapabilitiesInfo->magnetometerWakeup = isMagnetometerWakeup;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->magnetometerWakeup);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PHOTOMETER)) {
+ bool isPhotometer = false;
+ if (sensor_is_supported(SENSOR_LIGHT, &isPhotometer) == SENSOR_ERROR_NONE) {
+ LoggerD("isPhotometer : " << isPhotometer);
+ deviceCapabilitiesInfo->photometer = isPhotometer;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->photometer);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PHOTOMETER_WAKEUP)) {
+ bool isphotometerWakeup = false;
+ if (sensor_awake_is_supported(SENSOR_LIGHT, &isphotometerWakeup) == SENSOR_ERROR_NONE) {
+ LoggerD("isphotometerWakeup : " << isphotometerWakeup);
+ deviceCapabilitiesInfo->photometerWakeup = isphotometerWakeup;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->photometerWakeup);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PROXIMITY)) {
bool isProximity = false;
}
return convert.toJSValueRef(deviceCapabilitiesInfo->proximity);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PROXIMITY_WAKEUP)) {
+ bool isProximityWakeup = false;
+ if (sensor_awake_is_supported(SENSOR_PROXIMITY, &isProximityWakeup) == SENSOR_ERROR_NONE) {
+ LoggerD("isProximityWakeup : " << isProximityWakeup);
+ deviceCapabilitiesInfo->proximityWakeup = isProximityWakeup;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->proximityWakeup);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TILTMETER)) {
+ bool isTiltmeter = false;
+ if (sensor_is_supported(SENSOR_MOTION_TILT, &isTiltmeter) == SENSOR_ERROR_NONE) {
+ LoggerD("isTiltmeter : " << isTiltmeter);
+ deviceCapabilitiesInfo->tiltmeter = isTiltmeter;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->tiltmeter);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TILTMETER_WAKEUP)) {
+ bool isTiltmeterWakeup = false;
+ if (sensor_awake_is_supported(SENSOR_MOTION_TILT, &isTiltmeterWakeup) == SENSOR_ERROR_NONE) {
+ LoggerD("isTiltmeterWakeup : " << isTiltmeterWakeup);
+ deviceCapabilitiesInfo->tiltmeterWakeup = isTiltmeterWakeup;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->tiltmeterWakeup);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_DATA_ENCRYPTION)) {
+ void* handle = dlopen("/usr/lib/libsqlite3.so.0",RTLD_NOW);
+ if(handle != NULL) {
+ deviceCapabilitiesInfo->dataEncryption = true;
+ } else {
+ deviceCapabilitiesInfo->dataEncryption = false;
+ }
+ LoggerD("dataEncryption : " << deviceCapabilitiesInfo->dataEncryption);
return convert.toJSValueRef(deviceCapabilitiesInfo->dataEncryption);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_GRAPHICS_ACCELERATION)) {
+ bool isGraphicsAccelerationSupported = false;
+ if (system_info_get_value_bool(SYSTEM_INFO_KEY_GRAPHICS_HWACCEL_SUPPORTED , &isGraphicsAccelerationSupported) == SYSTEM_INFO_ERROR_NONE) {
+ LoggerD("graphicsAcceleration : " << isGraphicsAccelerationSupported);
+ deviceCapabilitiesInfo->graphicsAcceleration = isGraphicsAccelerationSupported;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->graphicsAcceleration);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_PUSH)) {
+ deviceCapabilitiesInfo->push = isExist("/usr/bin/pushd");
+ LoggerD("push : " << deviceCapabilitiesInfo->push);
return convert.toJSValueRef(deviceCapabilitiesInfo->push);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TELEPHONY)) {
+ deviceCapabilitiesInfo->telephony = isExist("/usr/bin/telephony-daemon");
+ LoggerD("telephony : " << deviceCapabilitiesInfo->telephony);
return convert.toJSValueRef(deviceCapabilitiesInfo->telephony);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TELEPHONY_MMS)) {
+ bool telephonyMms = false;
+ if (system_info_get_value_bool(SYSTEM_INFO_KEY_MMS_SUPPORTED, &telephonyMms) == SYSTEM_INFO_ERROR_NONE) {
+ LoggerD("telephonyMms : " << telephonyMms);
+ deviceCapabilitiesInfo->telephonyMms = telephonyMms;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->telephonyMms);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_TELEPHONY_SMS)) {
+ bool telephonySms = false;
+ if (system_info_get_value_bool(SYSTEM_INFO_KEY_SMS_SUPPORTED, &telephonySms) == SYSTEM_INFO_ERROR_NONE) {
+ LoggerD("telephonySms : " << telephonySms);
+ deviceCapabilitiesInfo->telephonySms = telephonySms;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->telephonySms);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SCREENSIZE_NORMAL)) {
+ deviceCapabilitiesInfo->screenSizeNormal = getRegistry("screen.coordinate_system.size.normal");
+ LoggerD("screenSizeNormal : " << deviceCapabilitiesInfo->screenSizeNormal);
return convert.toJSValueRef(deviceCapabilitiesInfo->screenSizeNormal);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SCREENSIZE_480_800)) {
+ deviceCapabilitiesInfo->screenSize480_800 = getRegistry("screen.coordinate_system.physical.normal_480x800");
+ LoggerD("screenSize480_800 : " << deviceCapabilitiesInfo->screenSize480_800);
return convert.toJSValueRef(deviceCapabilitiesInfo->screenSize480_800);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SCREENSIZE_720_1280)) {
+ deviceCapabilitiesInfo->screenSize720_1280 = getRegistry("screen.coordinate_system.physical.normal_720x1280");
+ LoggerD("screenSize720_1280 : " << deviceCapabilitiesInfo->screenSize720_1280);
return convert.toJSValueRef(deviceCapabilitiesInfo->screenSize720_1280);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_AUTO_ROTATION)) {
+ bool isAutoRotation = false;
+ if (system_info_get_value_bool(SYSTEM_INFO_KEY_FEATURE_AUTO_ROTATION_SUPPORTED, &isAutoRotation) == SYSTEM_INFO_ERROR_NONE) {
+ LoggerD("auto rotation : " << isAutoRotation);
+ deviceCapabilitiesInfo->autoRotation = isAutoRotation;
+ }
return convert.toJSValueRef(deviceCapabilitiesInfo->autoRotation);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SHELL_APP_WIDGET)) {
+ bool isShellAppWidgetSupported = false;
+ pkgmgrinfo_pkginfo_h handle;
+ if (pkgmgrinfo_pkginfo_get_pkginfo("gi2qxenosh",&handle) == PMINFO_R_OK) {
+ isShellAppWidgetSupported = true;
+ pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
+ LoggerD("shellAppWidget : " << isShellAppWidgetSupported);
+ }
+ deviceCapabilitiesInfo->shellAppWidget = isShellAppWidgetSupported;
return convert.toJSValueRef(deviceCapabilitiesInfo->shellAppWidget);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_VISION_IMAGE_RECOGNITION)) {
+ deviceCapabilitiesInfo->visionImageRecognition = isExist("/usr/lib/osp/libarengine.so");
+ LoggerD("visionImageRecognition : " << deviceCapabilitiesInfo->visionImageRecognition);
return convert.toJSValueRef(deviceCapabilitiesInfo->visionImageRecognition);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_VISION_QRCODE_GENERATION)) {
+ deviceCapabilitiesInfo->visionQrcodeGeneration = isExist("/usr/lib/osp/libarengine.so");
+ LoggerD("visionQrcodeGeneration : " << deviceCapabilitiesInfo->visionQrcodeGeneration);
return convert.toJSValueRef(deviceCapabilitiesInfo->visionQrcodeGeneration);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_VISION_QRCODE_RECOGNITION)) {
+ deviceCapabilitiesInfo->visionQrcodeRecognition = isExist("/usr/lib/osp/libarengine.so");
+ LoggerD("visionQrcodeRecognition : " << deviceCapabilitiesInfo->visionQrcodeRecognition);
return convert.toJSValueRef(deviceCapabilitiesInfo->visionQrcodeRecognition);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_VISION_FACE_RECOGNITION)) {
+ deviceCapabilitiesInfo->visionFaceRecognition = isExist("/usr/lib/osp/libarengine.so");
+ LoggerD("visionFaceRecognition : " << deviceCapabilitiesInfo->visionFaceRecognition);
return convert.toJSValueRef(deviceCapabilitiesInfo->visionFaceRecognition);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_SECURE_ELEMENT)) {
+ deviceCapabilitiesInfo->secureElement = isExist("/usr/bin/smartcard-daemon");
+ LoggerD("secureElement : " << deviceCapabilitiesInfo->secureElement);
return convert.toJSValueRef(deviceCapabilitiesInfo->secureElement);
} else if (JSStringIsEqualToUTF8CString(propertyName, DEVICE_CAPABILITIES_NATIVE_OSP_COMPATIBLE)) {
+ deviceCapabilitiesInfo->nativeOspCompatible = getRegistry("platform.native.osp_compatible");
+ LoggerD("nativeOspCompatible : " << deviceCapabilitiesInfo->nativeOspCompatible);
return convert.toJSValueRef(deviceCapabilitiesInfo->nativeOspCompatible);
}
}
}
return JSValueMakeUndefined(context);
}
+
+bool JSDeviceCapabilitiesInfo::isExist(const char* path)
+{
+ if (0 == access(path ,F_OK))
+ return true;
+ return false;
+}
+
+bool JSDeviceCapabilitiesInfo::getRegistry(std::string key)
+{
+ std::ifstream file("/usr/etc/system-info.ini");
+ std::string line;
+ std::string _key;
+ _key.append(key);
+ _key.append("=(\\w+)");
+ std::string value = "";
+ bool ret = false;
+
+ if(!file) {
+ LoggerD("Registry file not found");
+ } else {
+ while ((std::getline(file, line).rdstate() & (std::ifstream::failbit | std::ifstream::eofbit)) == 0) {
+ if (pcrecpp::RE(_key).PartialMatch(line, &value)) {
+ LoggerD("Key[" << key << "] : " << value; );
+ if(0==value.compare("true")) {
+ ret = true;
+ } else {
+ ret = false;
+ }
+ break;
+ }
+ }
+ file.close();
+ }
+ return ret;
+}
+
}
}
static void Finalize(JSObjectRef object);
static bool hasProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName);
static JSValueRef getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef* exception);
+ static bool isExist(const char* path);
+ static bool getRegistry(std::string key);
+
static JSStaticValue m_properties[];
static JSClassRef m_classRef;
namespace Systeminfo {
using namespace std;
-using namespace DPL;
+
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace WrtDeviceApis::Commons;
using namespace DeviceAPI::Common;
EventGetSysteminfoPtr event(new EventGetSysteminfo());
event->setBasePropertyPtr(baseProperty);
TIME_TRACER_ITEM_BEGIN(event->getProperty(), 0);
- event->setPrivateData(StaticPointerCast<IEventPrivateData>(cbm));
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(cbm));
SysteminfoListener& listener = SysteminfoListener::getInstance();
event->setForAsynchronousCall(&listener);
EventWatchSysteminfoPtr event(new EventWatchSysteminfo);
event->setWatchOption(option);
event->setBasePropertyPtr(baseProperty);
- event->setPrivateData(StaticPointerCast<IEventPrivateData>(cbm));
+ event->setPrivateData(DPL::StaticPointerCast<IEventPrivateData>(cbm));
SysteminfoListener& listener = SysteminfoListener::getInstance();
event->setForAsynchronousCall(&listener);
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace WrtDeviceApis::Commons;
-using namespace DPL;
+
namespace DeviceAPI {
namespace Systeminfo {
namespace DeviceAPI {
namespace Time {
-using namespace DPL;
+
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
namespace DeviceAPI {
namespace Time {
-using namespace DPL;
+
using namespace DeviceAPI::Common;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
projects / framework / web / wrt-plugins-tizen.git / commitdiff