Name: wrt-plugins-tizen
Summary: JavaScript plugins for WebRuntime
-Version: 0.4.32
-Release: 1
+Version: 0.4.33
+Release: 0
Group: Development/Libraries
License: Apache License, Version 2.0
Source0: %{name}-%{version}.tar.gz
throw TypeMismatchException("Value is POSITIVE_INFINITY");
if( doublevalue == -std::numeric_limits<double>::infinity() )
throw TypeMismatchException("Value is NEGATIVE_INFINITY");
- if( isnan(doublevalue)){
+ if( std::isnan(doublevalue)){
throw TypeMismatchException("Value is not number");
}
return doublevalue;
public:
DataControlAsyncCallbackManager()
{
+ m_sqlDataControlGC = false;
+ m_mappedDataControlGC = false;
}
virtual ~DataControlAsyncCallbackManager()
{
}
-
+ bool isSQLDataControlGC() { return m_sqlDataControlGC;}
+ bool isMappedDataControlGC() { return m_mappedDataControlGC;}
+ void setSQLDataControlGC(bool gc) { m_sqlDataControlGC = gc;}
+ void setMappedDataControlGC(bool gc) { m_mappedDataControlGC = gc;}
friend class DPL::Singleton<DataControlAsyncCallbackManager>;
+private:
+ bool m_sqlDataControlGC;
+ bool m_mappedDataControlGC;
};
typedef DPL::Singleton<DataControlAsyncCallbackManager> DataControlAsyncCallbackManagerSingleton;
void JSMappedDataControlConsumer::finalize(JSObjectRef object)
{
JSMappedDataControlConsumerPriv *priv = static_cast<JSMappedDataControlConsumerPriv*>(JSObjectGetPrivate(object));
+ LoggerD("finalize");
if (!priv) {
LoggerE("Private object is null");
}
delete priv;
+ priv = NULL;
}
void JSSQLDataControlConsumer::finalize(JSObjectRef object)
{
JSSQLDataControlConsumerPriv *priv = static_cast<JSSQLDataControlConsumerPriv*>(JSObjectGetPrivate(object));
+ LoggerD("finalize");
+
if (!priv) {
LoggerE("Private object is null");
}
delete priv;
-
+ priv = NULL;
}
bool JSSQLDataControlConsumer::hasInstance(JSContextRef context, JSObjectRef constructor, JSValueRef possibleInstance, JSValueRef* exception)
#include <sstream>
#include <iostream>
#include <package-manager.h>
+#include "DataControlAsyncCallbackManager.h"
namespace DeviceAPI {
LoggerD("data null, can not send result to JS Layer");
return;
}
+
+ if (DataControlAsyncCallbackManagerSingleton::Instance().isMappedDataControlGC())
+ {
+ LoggerD("private object is garbage collected");
+ return;
+ }
pendingEvent = (EventGetValuePendingEvent *)data;
consumer = (MappedDataControlConsumer*)pendingEvent->getThisObject();
return;
}
+ if (DataControlAsyncCallbackManagerSingleton::Instance().isMappedDataControlGC())
+ {
+ LoggerD("private object is garbage collected");
+ return;
+ }
+
+
pendingEvent = (EventAddValuePendingEvent *)data;
consumer = (MappedDataControlConsumer*)pendingEvent->getThisObject();
event = pendingEvent->getEvent();
return;
}
+
+ if (DataControlAsyncCallbackManagerSingleton::Instance().isMappedDataControlGC())
+ {
+ LoggerD("private object is garbage collected");
+ return;
+ }
+
pendingEvent = (EventRemoveValuePendingEvent *)data;
consumer = (MappedDataControlConsumer*)pendingEvent->getThisObject();
event = pendingEvent->getEvent();
LoggerD("data null, can not send result to JS Layer");
return;
}
+
+ if (DataControlAsyncCallbackManagerSingleton::Instance().isMappedDataControlGC())
+ {
+ LoggerD("private object is garbage collected");
+ return;
+ }
pendingEvent = (EventUpdateValuePendingEvent *)data;
consumer = (MappedDataControlConsumer*)pendingEvent->getThisObject();
m_type = type;;
m_dataId = dataId;
m_providerId = provId;
+ DataControlAsyncCallbackManagerSingleton::Instance().setMappedDataControlGC(false);
}
MappedDataControlConsumer::~MappedDataControlConsumer()
{
LoggerD("Enter");
+ DataControlAsyncCallbackManagerSingleton::Instance().setMappedDataControlGC(true);
+
}
DPL::Mutex MappedDataControlConsumer::m_mutex;
+
std::string MappedDataControlConsumer::getDataId()
{
return m_dataId;
if (m_istream.is_open())
{
- LoggerD("load header");
+ //LoggerD("load header");
loadHeader();
- LoggerD("print header"); // debug
- printHeader();
+// LoggerD("print header"); // debug
+// printHeader();
}
else
{
m_istream.read((char*)&type, sizeof(type)); // skip type
m_istream.read((char*)&size, sizeof(int)); // read size
- LoggerD(type << " - " << size << " ");
+// LoggerD(type << " - " << size << " ");
if (memorizedSize < size)
{
size = 0;
m_istream.seekg(sizeof(int), std::ios::cur); // skip type
m_istream.read((char*)&size, sizeof(int)); // read size
- LoggerD(size << " ");
+// LoggerD(size << " ");
m_istream.seekg(size, std::ios::cur); // skip data
}
// To get ppid
#include <unistd.h>
#include <security-server.h>
+#include "DataControlAsyncCallbackManager.h"
namespace DeviceAPI {
namespace DataControl {
return;
}
+ if (DataControlAsyncCallbackManagerSingleton::Instance().isSQLDataControlGC())
+ {
+ LoggerD("private object is garbage collected");
+ return;
+ }
+
pendingEvent = (EventSelectPendingEvent *)data;
consumer = (SQLDataControlConsumer*)pendingEvent->getThisObject();
event = pendingEvent->getEvent();
return;
}
+ if (DataControlAsyncCallbackManagerSingleton::Instance().isSQLDataControlGC())
+ {
+ LoggerD("private object is garbage collected");
+ return;
+ }
+
+
pendingEvent = (EventInsertPendingEvent *)data;
consumer = (SQLDataControlConsumer*)pendingEvent->getThisObject();
event = pendingEvent->getEvent();
return;
}
+ if (DataControlAsyncCallbackManagerSingleton::Instance().isSQLDataControlGC())
+ {
+ LoggerD("private object is garbage collected");
+ return;
+ }
+
EventDeletePendingEvent* pendingEvent = NULL;
SQLDataControlConsumer *consumer = NULL;
EventDeletePtr event;
return;
}
+ if (DataControlAsyncCallbackManagerSingleton::Instance().isSQLDataControlGC())
+ {
+ LoggerD("private object is garbage collected");
+ return;
+ }
+
+
pendingEvent = (EventUpdatePendingEvent *)data;
consumer = (SQLDataControlConsumer*)pendingEvent->getThisObject();
event = pendingEvent->getEvent();
m_currentAppId = getCurrentApplicationId();
createResultDir();
+ DataControlAsyncCallbackManagerSingleton::Instance().setSQLDataControlGC(false);
}
SQLDataControlConsumer::~SQLDataControlConsumer()
{
LoggerD("Enter");
+ DataControlAsyncCallbackManagerSingleton::Instance().setSQLDataControlGC(true);
}
DPL::Mutex SQLDataControlConsumer::m_mutex;
namespace {
const char* PATH_DOWNLOADS = "/opt/usr/media/Downloads";
const char* PATH_DOCUMENTS = "/opt/usr/media/Documents";
-const char* PATH_SOUNDS = "/opt/usr/media/Music";
+const char* PATH_SOUNDS = "/opt/usr/media/Sounds";
const char* PATH_IMAGES = "/opt/usr/media/Images";
const char* PATH_VIDEOS = "/opt/usr/media/Videos";
const char* VPATH_DOWNLOADS = "download";
const char* VPATH_DOCUMENTS = "documents";
-const char* VPATH_SOUNDS = "music";
+const char* VPATH_SOUNDS = "sounds";
const char* VPATH_IMAGES = "images";
const char* VPATH_VIDEOS = "videos";
const char* VPATH_WGT_PACKAGE = "wgt-package";
if (m_mail->full_address_from) {
Recipients from;
- from.setRecipients(m_mail->full_address_from);
+ from.setRecipients(EmailUtils::stripAddress(m_mail->full_address_from));
setSourceAddress(from);
setSourceAddressValidity(true); //not needed to update in platform
}
setConvId(m_mail->thread_id);
setPriority( EmailConverter::toMessagePriority( m_mail->priority ) );
setSize(m_mail->mail_size);
+ setCurrentFolderId(m_mail->mailbox_id);
LOG_EXIT
}
updateBody();
updateSubject();
updateRecipients();
- updateFrom();
- updateAttachments();
+// updateFrom();
+// updateAttachments();
updatePriority();
}
updateReadStatus();
LoggerW("Nothing to update or error. [" << error << "]");
}
+ if(getCurrentFolder() == DRAFTBOX)
+ {
+
+ updateAttachments();
+
+ email_mail_data_t* result = NULL;
+
+ error = email_get_mail_data(m_mail->mail_id, &result);
+ if (EMAIL_ERROR_NONE != error) {
+ LoggerW("email_get_mail_data error. [" << error << "]");
+ }
+ else
+ {
+ if(result->body_download_status != 1)
+ {
+ LoggerD("result->body_download_status " << result->body_download_status);
+ int mail_id_count = 1;
+ int mail_id_array[1];
+ email_mail_attribute_type attribute_type;
+ email_mail_attribute_value_t attribute_value;
+
+ mail_id_array[0] = result->mail_id;
+ LoggerD("result->mail_id " << result->mail_id);
+ attribute_type = EMAIL_MAIL_ATTRIBUTE_BODY_DOWNLOAD_STATUS;
+ attribute_value.integer_type_value = 1;
+
+ error = email_update_mail_attribute(m_accountId, mail_id_array, 1, EMAIL_MAIL_ATTRIBUTE_BODY_DOWNLOAD_STATUS, attribute_value);
+ if (EMAIL_ERROR_NONE != error) {
+ LoggerW("email_update_mail_attribute error. [" << error << "]");
+ }
+ }
+ }
+ if(result != NULL)
+ {
+ error = email_free_mail_data(&result, 1);
+ if (EMAIL_ERROR_NONE != error) {
+ LoggerW("email_free_mail_data error. [" << error << "]");
+ }
+ }
+ }
+
if(meeting_req) {
email_free_meeting_request(&meeting_req, 1);
}
m_mail->file_path_html = strdup(result->file_path_html);
}
+ if (result->full_address_from) {
+ Recipients from;
+ from.setRecipients(EmailUtils::stripAddress(result->full_address_from));
+ setSourceAddress(from);
+ setSourceAddressValidity(true); //not needed to update in platform
+ }
+ setCurrentFolderId(result->mailbox_id);
+
error = email_free_mail_data(&result, 1);
if (EMAIL_ERROR_NONE != error) {
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
error = email_add_mail(m_mail.Get(), NULL, 0, NULL, 0);
if (EMAIL_ERROR_NONE != error) {
+ LoggerE("Couldn't add message to mailbox");
ThrowMsg(WrtDeviceApis::Commons::PlatformException,
"Couldn't add message to mailbox. [" << error << "]");
}
LOG_ENTER
email_mail_data_t* result = NULL;
- std::string from;
int error = email_get_mail_data(m_mail->mail_id, &result);
if (EMAIL_ERROR_NONE != error) {
setConvId(result->thread_id);
setPriority( EmailConverter::toMessagePriority( result->priority ) );
setSize(result->mail_size);
+ setCurrentFolderId(result->mailbox_id);
if (m_mail->file_path_plain)
+ {
free(m_mail->file_path_plain);
- m_mail->file_path_plain = strdup(result->file_path_plain);
+ }
+ if(result->file_path_plain)
+ {
+ m_mail->file_path_plain = strdup(result->file_path_plain);
+ }
if ( m_mail->file_path_html)
{
{
m_mail->file_path_html = strdup(result->file_path_html);
}
- from = EmailUtils::stripAddress(result->full_address_from);
- setFrom(from);
+
+ if (result->full_address_from) {
+ Recipients from;
+ from.setRecipients(EmailUtils::stripAddress(result->full_address_from));
+ setSourceAddress(from);
+ setSourceAddressValidity(true); //not needed to update in platform
+ setFrom(result->full_address_from);
+ }
+ m_mail->save_status = result->save_status;
error = email_free_mail_data(&result, 1);
if (EMAIL_ERROR_NONE != error) {
m_isReadChangeStatus(false),
m_validisReadChangeStatus(true),
m_folder(DRAFTBOX),
+ m_folderId(-1),
m_requestReceiver(NULL),
m_sendMessageEvent(NULL)
{
m_userFolderName = arg;
}
+int IMessage::getCurrentFolderId() const
+{
+ return m_folderId;
+}
+
+void IMessage::setCurrentFolderId(int folderId)
+{
+ m_folderId = folderId;
+}
+
+
bool IMessage::validatePhoneNumber(std::string& number)
{
LoggerD("testing number=" << number);
FolderType m_folder;
/**
+ * Message current folder id for email
+ */
+ int m_folderId;
+
+
+ /**
* User folder name
*/
std::string m_userFolderName;
MessageStatus getMessageStatus() const;
+ void setCurrentFolderId(int folderId);
+
+ int getCurrentFolderId() const;
+
+
/**
* Remove message
* @throw PlatformException Thrown when remove message fail
try {
ConverterMessageFactory::ConverterType converter = ConverterMessageFactory::getConverter(context);
IMessagePtr msg = converter->toIMessage(object);
- FolderType folder = msg->getCurrentFolder();
+ MessageType msgType = msg->getMessageType();
int tmpInt = msg->getMessageStatus();
- LoggerE("folder : " << folder);
- LoggerE("msg->getMessageStatus() : " << tmpInt);
-
if(tmpInt == MESSAGE_STATUS_CREATED)
{
return JSValueMakeNull(context);
}
- tmpInt = (int)folder;
+
+ switch (msgType) {
+ case SMS:
+ case MMS:
+ {
+ FolderType folder = msg->getCurrentFolder();
+ tmpInt = (int)folder;
+ break;
+ }
+ case EMAIL:
+ {
+ tmpInt = msg->getCurrentFolderId();
+ break;
+ }
+ default:
+ LoggerE("message not support subject");
+ /* unsupported type -> type is integral message attribute
+ * so error at this place means internal api error*/
+ throw DeviceAPI::Common::NotSupportedException("Unsupported message type");
+ break;
+ }
return converter->toJSValueRef(converter->convertIntToString(tmpInt));
}
catch(BasePlatformException &bex) {
while ( noti_list_iter != NULL)
{
noti = notification_list_get_data(noti_list_iter);
- if (noti != NULL /* && notification_package_equal(noti)*/)
+ if (noti != NULL && notification_package_equal(noti))
{
int noti_priv = -1;
notification_get_id(noti, NULL, ¬i_priv);
}
stream >> privID;
- StatusNotification* notification = new StatusNotification(privID);
- return notification;
+ LoggerI("priv ID : " << privID);
+
+ notification_h notification = notification_load( NULL, privID); //load notification.
+ LoggerI(" notification " << notification);
+
+ if (notification != NULL && notification_package_equal(notification))
+ {
+ StatusNotification* noti = new StatusNotification(notification);
+ return noti;
+ }
+ else
+ {
+ throw NotFoundException("It is not notification ID or removed notification");
+ }
+
+ return NULL;
}
std::vector<StatusNotification*> NotificationManager::getAll()
{
LoggerD("loaded notification id = " << noti_priv);
data.push_back(notification);
-
}
noti_list_iter = notification_list_get_next(noti_list_iter);
ret = app_info_get_package(handle, &_pkg_id);
if ((ret != APP_MANAGER_ERROR_NONE) || (_pkg_id == NULL)) {
- LOGW("Fail to get pkg_id by %s", appId.c_str());
+ LOGW("Fail to get pkg id");
}
ret = app_info_destroy(handle);
PKG_CHECK_MODULES(platform_pkgs_systemsetting REQUIRED capi-system-system-settings)
+ADD_DEFINITIONS("-fvisibility=hidden")
+
INCLUDE_DIRECTORIES(
${INCLUDE_COMMON}
${TOP}/Filesystem
static WrtDeviceApis::Commons::FunctionMapping SystemSettingFunctions =
createSystemSettingFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(SystemSetting, SystemSettingFunctions);
-#pragma GCC visibility pop
-
static WrtDeviceApis::Commons::FunctionMapping createSystemSettingFunctions()
{
using namespace WrtDeviceApis::Commons;
sensor
)
+ADD_DEFINITIONS("-fvisibility=hidden")
+
INCLUDE_DIRECTORIES(
${INCLUDE_COMMON}
${platform_pkgs_systeminfo_INCLUDE_DIRS}
#include <JSWebAPIErrorFactory.h>
#include <SecurityExceptions.h>
#include <TimeTracer.h>
+#include <Export.h>
#include "SysteminfoListener.h"
#include "SysteminfoAsyncCallbackManager.h"
#include "SysteminfoListenerManager.h"
{ 0, 0, 0 }
};
-const JSClassRef JSSysteminfo::getClassRef()
+const JSClassRef DLL_EXPORT JSSysteminfo::getClassRef()
{
if (!m_jsClassRef) {
m_jsClassRef = JSClassCreate(&m_classInfo);
//
#include "SysteminfoAsyncCallbackManager.h"
-#include <dpl/singleton_impl.h>
-using namespace DPL;
+namespace DeviceAPI {
+namespace Systeminfo {
-IMPLEMENT_SINGLETON(DeviceAPI::Systeminfo::SysteminfoAsyncCallbackManager)
+SINGLETON_IMPLEMENTATION(SysteminfoAsyncCallbackManager)
+
+} // Systeminfo
+} // DeviceAPI
#ifndef _TIZEN_SYSTEMINFO_ASYNC_CALLBACK_MANAGER_H_
#define _TIZEN_SYSTEMINFO_ASYNC_CALLBACK_MANAGER_H_
-#include <dpl/singleton.h>
#include <AsyncCallbackManager.h>
namespace DeviceAPI {
class SysteminfoAsyncCallbackManager : public DeviceAPI::Common::AsyncCallbackManager
{
-public:
+private:
SysteminfoAsyncCallbackManager()
{
}
+public:
virtual ~SysteminfoAsyncCallbackManager()
{
}
- friend class DPL::Singleton<SysteminfoAsyncCallbackManager>;
+ friend class SysteminfoAsyncCallbackManagerSingleton;
};
-typedef DPL::Singleton<SysteminfoAsyncCallbackManager> SysteminfoAsyncCallbackManagerSingleton;
+SINGLETON_DEFINITION(SysteminfoAsyncCallbackManager)
}
}
//
#include "SysteminfoListenerManager.h"
-#include <dpl/singleton_impl.h>
-using namespace DPL;
+namespace DeviceAPI {
+namespace Systeminfo {
-IMPLEMENT_SINGLETON(DeviceAPI::Systeminfo::SysteminfoListenerManager)
+SINGLETON_IMPLEMENTATION(SysteminfoListenerManager)
+
+} // Systeminfo
+} // DeviceAPI
#include <map>
#include <JavaScriptCore/JavaScript.h>
#include <dpl/shared_ptr.h>
-#include <dpl/singleton.h>
#include <IListenerManager.h>
#include "JSSysteminfo.h"
#include <Logger.h>
class SysteminfoListenerManager : public DeviceAPI::Common::IListenerController
{
-public:
+private:
SysteminfoListenerManager()
{
}
+public:
virtual ~SysteminfoListenerManager()
{
}
+
+ friend class SysteminfoListenerManagerSingleton;
};
-typedef DPL::Singleton<SysteminfoListenerManager> SysteminfoListenerManagerSingleton;
+SINGLETON_DEFINITION(SysteminfoListenerManager)
class SysteminfoListenerCanceller : public DeviceAPI::Common::IListenerItem
{
namespace DeviceAPI {
namespace Systeminfo {
+#pragma GCC visibility push(default)
+
const char* SYSTEMINFO_FUNCTION_API_GET_CAPABILITIES = "getCapabilities";
const char* SYSTEMINFO_FUNCTION_API_GET_PROPERTY_PARTNER_VALUE = "getPropertyPartnerValue";
const char* SYSTEMINFO_FUNCTION_API_GET_PROPERTY_SIM_VALUE = "getPropertySimValue";
static WrtDeviceApis::Commons::FunctionMapping SysteminfoFunctions =
createSysteminfoFunctions();
-#pragma GCC visibility push(default)
-
DEFINE_FUNCTION_GETTER(Systeminfo, SysteminfoFunctions);
#pragma GCC visibility pop