+wrt-plugins-tizen (0.2.0-3) unstable; urgency=low
+
+ * update call api
+ * Git : slp/pkgs/w/wrt-plugins-tizen
+ * Tag : wrt-plugins-tizen_0.2.0-3
+
+
+ -- Sangtai Kim <sangtai.kim@samsung.com> Fri, 17 Feb 2012 20:31:20 +0900
+
wrt-plugins-tizen (0.2.0-2) unstable; urgency=low
* Add new Mediacontents APIs, Change createJSObject function to public
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * 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 TIZENAPIS_API_CALL_DEFINE_H_
+#define TIZENAPIS_API_CALL_DEFINE_H_
+
+namespace {
+
+#define STR_TIZEN_TEL "tizen.tel"
+#define STR_TIZEN_XMPP "tizen.xmpp"
+#define STR_TIZEN_SIP "tizen.sip"
+
+#define STR_CALL "call"
+#define STR_CALL_VOICE "call.voice"
+#define STR_CALL_VIDEO "call.video"
+#define STR_CALL_EMERGENCY "call.emergency"
+
+#define STR_DIALED "dialed"
+#define STR_RECEIVED "received"
+#define STR_MISSED_NEW "missed-new"
+#define STR_MISSED "missed"
+#define STR_REJECTED "rejected"
+#define STR_BLOCKED "blocked"
+
+#define STR_BASE_QUERY "SELECT id, log_type, related_id, number, log_time, data1 FROM phonelogs"
+
+#define STR_ENTRY_ID "entryId"
+#define STR_SERVICE_ID "serviceId"
+#define STR_CALL_TYPE "callType"
+#define STR_TAGS "tags"
+#define STR_REMOTE_PARTIES "remoteParties"
+#define STR_FORWARDEDFROM "forwardedFrom"
+#define STR_START_TIME "startTime"
+#define STR_DURATION "duration"
+#define STR_END_REASON "endReason"
+#define STR_DIRECTION "direction"
+#define STR_RECORDING "recording"
+#define STR_COST "cost"
+#define STR_CURRENCY "currency"
+
+#define STR_REMOTE_PARTY "remoteParty"
+#define STR_DISPLAY_NAME "displayName"
+#define STR_CONTACT_ID "contactId"
+
+#define STR_RP_REMOTEPARTY "remoteParties.remoteParty"
+#define STR_RP_CONTACTID "remoteParties.contactId"
+
+#define STR_NUMBER "number"
+#define STR_LOG_TIME "log_time"
+#define STR_LOG_TYPE "log_type"
+#define STR_DATA1 "data1"
+#define STR_RELATED_ID "related_id"
+
+#define STR_TEL_URI "tel://"
+#define STR_TIZEN_DIALER "com.samsung.phone" //org.tizen.phone
+
+#define STR_SERVICE_NAME "serviceName"
+#define STR_PROVIDER_ID "providerId"
+
+#define STR_HISTORY "history"
+#define STR_SERVICE_NAME "serviceName"
+#define STR_SERVICE "service"
+#define STR_VOICEMAIL_NUMBERS "voicemailNumbers"
+#define STR_SUBSCRIBER_NUMBERS "subscriberNumbers"
+#define STR_EMERGENCY_NUMBERS "emergencyNumbers"
+}
+
+#endif
\ No newline at end of file
namespace Api {
namespace Call {
CallServiceFilter::CallServiceFilter() :
- m_serviceTypeId(""),
+ m_callType(""),
m_serviceName(""),
m_providerId("")
{
m_tags = StringArrayPtr(new StringArray());
}
-void CallServiceFilter::setServiceTypeId(const std::string serviceTypeId)
+void CallServiceFilter::setCallType(const std::string callType)
{
- m_serviceTypeId = serviceTypeId;
+ m_callType = callType;
}
void CallServiceFilter::setTags(const StringArrayPtr tags)
m_providerId = providerId;
}
-std::string CallServiceFilter::getServiceTypeId() const
+std::string CallServiceFilter::getCallType() const
{
- return m_serviceTypeId;
+ return m_callType;
}
StringArrayPtr CallServiceFilter::getTags() const
class CallServiceFilter
{
private:
- std::string m_serviceTypeId;
+ std::string m_callType;
StringArrayPtr m_tags;
std::string m_serviceName;
std::string m_providerId;
public:
- void setServiceTypeId(const std::string serviceTypeId);
+ void setCallType(const std::string callType);
void setTags(const StringArrayPtr tags);
void setServiceName(const std::string serviceName);
void setProviderId(const std::string providerId);
- std::string getServiceTypeId() const;
+ std::string getCallType() const;
StringArrayPtr getTags() const;
std::string getServiceName() const;
std::string getProviderId() const;
m_extension = extension;
}
+void EventLaunchDialer::setAppId(const std::string appId)
+{
+ m_appId = appId;
+}
std::string EventLaunchDialer::getRemoteParty() const
{
return m_extension;
}
+std::string EventLaunchDialer::getAppId() const
+{
+ return m_appId;
+}
+
}
}
}
private:
std::string m_remoteParty;
std::string m_extension;
+ std::string m_appId;
public:
void setRemoteParty(const std::string remoteParty);
void setExtension(const std::string extension);
+ void setAppId(const std::string appId);
std::string getRemoteParty() const;
std::string getExtension() const;
+ std::string getAppId() const;
EventLaunchDialer();
};
return m_categories->size();
}
+void IContact::copy(const ContactPtr &contact)
+{
+ m_id = contact->m_id;
+ m_lastUpdated = contact->m_lastUpdated;
+
+ m_name = contact->m_name->clone();
+ m_account = contact->m_account->clone();
+ m_addresses = ContactAddressArrayPtr(new ContactAddressArray());
+ ContactAddressArray::iterator contactAddressIter;
+ for(contactAddressIter = contact->m_addresses->begin(); contactAddressIter != contact->m_addresses->end(); contactAddressIter++)
+ m_addresses->push_back((*contactAddressIter)->clone());
+
+ m_photoURI = contact->m_photoURI;
+ m_phoneNumbers = ContactPhoneNumberArrayPtr(new ContactPhoneNumberArray());
+ ContactPhoneNumberArray::iterator contactPhoneNumberIter;
+ for(contactPhoneNumberIter = contact->m_phoneNumbers->begin(); contactPhoneNumberIter != contact->m_phoneNumbers->end(); contactPhoneNumberIter++)
+ m_phoneNumbers->push_back((*contactPhoneNumberIter)->clone());
+
+ m_emails = ContactEmailAddressArrayPtr(new ContactEmailAddressArray());
+ ContactEmailAddressArray::iterator contactEmailAddressIter;
+ for(contactEmailAddressIter = contact->m_emails->begin(); contactEmailAddressIter != contact->m_emails->end(); contactEmailAddressIter++)
+ m_emails->push_back((*contactEmailAddressIter)->clone());
+
+ m_birthday = contact->m_birthday;
+ m_anniversaries = ContactAnniversaryArrayPtr(new ContactAnniversaryArray());
+ ContactAnniversaryArray::iterator contactAnniversaryIter;
+ for(contactAnniversaryIter = contact->m_anniversaries->begin(); contactAnniversaryIter != contact->m_anniversaries->end(); contactAnniversaryIter++)
+ m_anniversaries->push_back((*contactAnniversaryIter)->clone());
+
+ m_organization = contact->m_organization->clone();
+ m_notes = StringArrayPtr(new StringArray());
+ StringArray::iterator noteIter;
+ for(noteIter = contact->m_notes->begin(); noteIter != contact->m_notes->end(); noteIter++)
+ {
+ std::string note = *noteIter;
+ m_notes->push_back(note);
+ }
+
+ m_urls = ContactWebSiteArrayPtr(new ContactWebSiteArray());
+ ContactWebSiteArray::iterator contactWebSiteIter;
+ for(contactWebSiteIter = contact->m_urls->begin(); contactWebSiteIter != contact->m_urls->end(); contactWebSiteIter++)
+ m_urls->push_back((*contactWebSiteIter)->clone());
+
+ m_isFavorite = contact->m_isFavorite;
+ m_ringtoneURI = contact->m_ringtoneURI;
+ m_categories = StringArrayPtr(new StringArray());
+ StringArray::iterator categoryIter;
+ for(categoryIter = contact->m_categories->begin(); categoryIter != contact->m_categories->end(); categoryIter++)
+ {
+ std::string category = *categoryIter;
+ m_categories->push_back(category);
+ }
+
+ m_idIsSet = contact->m_idIsSet;
+ m_lastUpdatedIsSet = contact->m_lastUpdatedIsSet;
+ m_nameIsSet = contact->m_nameIsSet;
+ m_accountIsSet = contact->m_accountIsSet;
+ m_photoURIIsSet = contact->m_photoURIIsSet;
+ m_birthdayIsSet = contact->m_birthdayIsSet;
+ m_organizationIsSet = contact->m_organizationIsSet;
+ m_ringtoneURIIsSet = contact->m_ringtoneURIIsSet;
+}
+
void IContact::clear()
{
m_id = "";
void addCategory(const std::string &value);
int getCategoriesNum() const;
+ virtual void copy(const ContactPtr &contact);
virtual void clear();
virtual ContactPtr clone() const;
#include <dpl/log/log.h>
#include <API/Filter/IFilter.h>
#include <API/Filter/IFilterVisitor.h>
+#include <API/Call/CallDefine.h>
#include <calllog.h>
#include <contacts-svc.h>
std::string CallHistory::convertAttrName(std::string &name)
{
std::string attrName("");
- if (name.compare("remoteParty") == 0) {
- return attrName.append("number");
- } else if (name.compare("startTime") == 0) {
- return attrName.append("log_time");
- } else if (name.compare("duration") == 0) {
- return attrName.append("data1");
- } else if (name.compare("direction") == 0) {
- return attrName.append("log_type");
+ if (name.compare(STR_RP_REMOTEPARTY) == 0) {
+ return attrName.append(STR_NUMBER);
+ } else if (name.compare(STR_START_TIME) == 0) {
+ return attrName.append(STR_LOG_TIME);
+ } else if (name.compare(STR_DURATION) == 0) {
+ return attrName.append(STR_DATA1);
+ } else if (name.compare(STR_DIRECTION) == 0) {
+ return attrName.append(STR_LOG_TYPE);
} else {
return attrName;
}
#include <dpl/log/log.h>
#include <iomanip>
+#include <API/Call/CallDefine.h>
#include "CallHistoryFilter.h"
#include "CallHistoryQuery.h"
using namespace TizenApis::Api::Call;
namespace {
-const std::string STR_LOG_TYPE ("log_type");
-const std::string STR_CONTACT_ID ("contact_id");
-const std::string STR_NUMBER ("number");
-const std::string STR_LOG_TIME ("log_time");
-const std::string STR_DURATION ("data1");
-const std::string STR_VOICE_ANSWERED ("1");
-const std::string STR_VOICE_OUTGOING ("2");
-const std::string STR_VOICE_MISSED_UNCHECKED ("5");
-const std::string STR_VOICE_MISSED_CHECKED ("6");
-const std::string STR_VOICE_REJECTED ("9");
-const std::string STR_VOICE_BLOCKED ("11");
-const std::string STR_VIDEO_ANSWERED ("3");
-const std::string STR_VIDEO_OUTGOING ("4");
-const std::string STR_VIDEO_MISSED_UNCHECKED ("7");
-const std::string STR_VIDEO_MISSED_CHECKED ("8");
-const std::string STR_VIDEO_REJECTED ("10");
-const std::string STR_VIDEO_BLOCKED ("12");
-const std::string STR_LEFT_BRACKET(" (");
-const std::string STR_RIGHT_BRACKET(")");
-const std::string STR_AND(" AND ");
-const std::string STR_OR(" OR ");
-const std::string STR_GREATER_THAN (">");
-const std::string STR_LESS_THAN ("<");
-const std::string STR_EQUAL ("=");
-const std::string STR_S_QUOTATION ("'");
+const std::string F_LOG_TYPE (STR_LOG_TYPE);
+const std::string F_RELATED_ID (STR_RELATED_ID);
+const std::string F_NUMBER (STR_NUMBER);
+const std::string F_LOG_TIME (STR_LOG_TIME);
+const std::string F_DURATION (STR_DATA1);
+const std::string F_VOICE_ANSWERED ("1");
+const std::string F_VOICE_OUTGOING ("2");
+const std::string F_VOICE_MISSED_UNCHECKED ("5");
+const std::string F_VOICE_MISSED_CHECKED ("6");
+const std::string F_VOICE_REJECTED ("9");
+const std::string F_VOICE_BLOCKED ("11");
+const std::string F_VIDEO_ANSWERED ("3");
+const std::string F_VIDEO_OUTGOING ("4");
+const std::string F_VIDEO_MISSED_UNCHECKED ("7");
+const std::string F_VIDEO_MISSED_CHECKED ("8");
+const std::string F_VIDEO_REJECTED ("10");
+const std::string F_VIDEO_BLOCKED ("12");
+const std::string F_LEFT_BRACKET(" (");
+const std::string F_RIGHT_BRACKET(")");
+const std::string F_AND(" AND ");
+const std::string F_OR(" OR ");
+const std::string F_GREATER_THAN (">");
+const std::string F_LESS_THAN ("<");
+const std::string F_EQUAL ("=");
+const std::string F_S_QUOTATION ("'");
}
namespace TizenApis {
namespace Platform {
void CallHistoryFilter::visitPreComposite(FilterType& type, int depth)
{
- m_query = m_query + STR_LEFT_BRACKET;
+ m_query = m_query + F_LEFT_BRACKET;
}
void CallHistoryFilter::visitInComposite(FilterType& type, int depth)
{
if(type == Api::Tizen::UNION_FILTER)
- m_query = m_query + STR_OR;
+ m_query = m_query + F_OR;
else if(type == Api::Tizen::INTERSECTION_FILTER)
- m_query = m_query + STR_AND;
+ m_query = m_query + F_AND;
}
void CallHistoryFilter::visitPostComposite(FilterType& type, int depth)
{
- m_query = m_query + STR_RIGHT_BRACKET;
+ m_query = m_query + F_RIGHT_BRACKET;
}
void CallHistoryFilter::visitAttribute(std::string& attrName, MatchFlag& matchFlag, Api::Tizen::AnyPtr& matchValue, int depth)
string initialValueStr ("");
string endValueStr ("");
- if (attrName.compare("remoteParties.remoteParty") == 0) {
- name = STR_NUMBER;
- } else if (attrName.compare("remoteParties.contactId") == 0) {
- name = STR_CONTACT_ID;
- } else if (attrName.compare("startTime") == 0) {
- name = STR_LOG_TIME;
- } else if (attrName.compare("duration") == 0) {
- name = STR_DURATION;
+ if (attrName.compare(STR_RP_REMOTEPARTY) == 0) {
+ name = F_NUMBER;
+ } else if (attrName.compare(STR_RP_CONTACTID) == 0) {
+ name = F_RELATED_ID;
+ } else if (attrName.compare(STR_START_TIME) == 0) {
+ name = F_LOG_TIME;
+ } else if (attrName.compare(F_DURATION) == 0) {
+ name = F_DURATION;
} else {
name = attrName;
}
}
if (!initialValue->isNullOrUndefined() && endValue->isNullOrUndefined()) {
- str = STR_LEFT_BRACKET + name + STR_GREATER_THAN + STR_EQUAL + STR_S_QUOTATION + initialValueStr + STR_S_QUOTATION + STR_RIGHT_BRACKET;
+ str = F_LEFT_BRACKET + name + F_GREATER_THAN + F_EQUAL + F_S_QUOTATION + initialValueStr + F_S_QUOTATION + F_RIGHT_BRACKET;
} else if (initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
- str = STR_LEFT_BRACKET + name + STR_LESS_THAN + STR_S_QUOTATION + endValueStr + STR_S_QUOTATION + STR_RIGHT_BRACKET;
+ str = F_LEFT_BRACKET + name + F_LESS_THAN + F_S_QUOTATION + endValueStr + F_S_QUOTATION + F_RIGHT_BRACKET;
} else if (!initialValue->isNullOrUndefined() && !endValue->isNullOrUndefined()) {
- str = STR_LEFT_BRACKET + name + STR_GREATER_THAN + STR_EQUAL + STR_S_QUOTATION + initialValueStr + STR_S_QUOTATION + STR_AND + name + STR_LESS_THAN + STR_S_QUOTATION + endValueStr + STR_S_QUOTATION + STR_RIGHT_BRACKET;
+ str = F_LEFT_BRACKET + name + F_GREATER_THAN + F_EQUAL + F_S_QUOTATION + initialValueStr + F_S_QUOTATION + F_AND + name + F_LESS_THAN + F_S_QUOTATION + endValueStr + F_S_QUOTATION + F_RIGHT_BRACKET;
}
m_query = m_query + str;
{
std::string query("");
AnyArray::iterator it = values->begin();
- query.append(STR_LEFT_BRACKET);
+ query.append(F_LEFT_BRACKET);
do {
if (it != values->begin()) {
- query.append(STR_OR);
+ query.append(F_OR);
}
query.append(convertAttribute(name, *it));
it++;
} while(it != values->end());
- query.append(STR_RIGHT_BRACKET);
+ query.append(F_RIGHT_BRACKET);
return query;
}
std::string CallHistoryFilter::convertAttribute(std::string &name, AnyPtr& value)
{
std::string query("");
- if (name.compare("direction") == 0) {
+ if (name.compare(STR_DIRECTION) == 0) {
if (value->toString().compare(STR_RECEIVED) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_ANSWERED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_ANSWERED + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_ANSWERED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_ANSWERED + F_RIGHT_BRACKET;
} else if (value->toString().compare(STR_DIALED) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_OUTGOING + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_OUTGOING + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_OUTGOING + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_OUTGOING + F_RIGHT_BRACKET;
} else if (value->toString().compare(STR_MISSED) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_MISSED_CHECKED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_MISSED_CHECKED + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_MISSED_CHECKED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_MISSED_CHECKED + F_RIGHT_BRACKET;
} else if (value->toString().compare(STR_MISSED_NEW) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_MISSED_UNCHECKED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_MISSED_UNCHECKED + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_MISSED_UNCHECKED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_MISSED_UNCHECKED + F_RIGHT_BRACKET;
} else if (value->toString().compare(STR_REJECTED) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_REJECTED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_REJECTED + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_REJECTED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_REJECTED + F_RIGHT_BRACKET;
} else if (value->toString().compare(STR_BLOCKED) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_BLOCKED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_BLOCKED + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_BLOCKED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_BLOCKED + F_RIGHT_BRACKET;
} else {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + "=0" + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + "=0" + F_RIGHT_BRACKET;
}
- } else if (name.compare("tags") == 0) {
+ } else if (name.compare(STR_TAGS) == 0) {
if (value->toString().compare(STR_CALL) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_GREATER_THAN + STR_EQUAL + STR_VOICE_ANSWERED + STR_AND
- + STR_LOG_TYPE + STR_LESS_THAN + STR_EQUAL + STR_VIDEO_BLOCKED + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_GREATER_THAN + F_EQUAL + F_VOICE_ANSWERED + F_AND
+ + F_LOG_TYPE + F_LESS_THAN + F_EQUAL + F_VIDEO_BLOCKED + F_RIGHT_BRACKET;
} else if (value->toString().compare(STR_CALL_VOICE) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_ANSWERED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_OUTGOING + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_MISSED_UNCHECKED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_MISSED_CHECKED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_REJECTED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VOICE_BLOCKED + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VOICE_ANSWERED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VOICE_OUTGOING + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VOICE_MISSED_UNCHECKED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VOICE_MISSED_CHECKED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VOICE_REJECTED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VOICE_BLOCKED + F_RIGHT_BRACKET;
} else if (value->toString().compare(STR_CALL_VIDEO) == 0) {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_ANSWERED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_OUTGOING + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_MISSED_UNCHECKED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_MISSED_CHECKED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_REJECTED + STR_OR
- + STR_LOG_TYPE + STR_EQUAL + STR_VIDEO_BLOCKED + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + F_EQUAL + F_VIDEO_ANSWERED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_OUTGOING + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_MISSED_UNCHECKED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_MISSED_CHECKED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_REJECTED + F_OR
+ + F_LOG_TYPE + F_EQUAL + F_VIDEO_BLOCKED + F_RIGHT_BRACKET;
} else {
- query = STR_LEFT_BRACKET + STR_LOG_TYPE + "=0" + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TYPE + "=0" + F_RIGHT_BRACKET;
}
- } else if (name.compare("remoteParties.remoteParty") == 0) {
- query = STR_LEFT_BRACKET + STR_NUMBER + STR_EQUAL + STR_S_QUOTATION + value->toString() + STR_S_QUOTATION + STR_RIGHT_BRACKET;
- } else if (name.compare("remoteParties.contactId") == 0) {
- query = STR_LEFT_BRACKET + STR_CONTACT_ID + STR_EQUAL + STR_S_QUOTATION + value->toString() + STR_S_QUOTATION + STR_RIGHT_BRACKET;
- } else if (name.compare("startTime") == 0) {
+ } else if (name.compare(STR_RP_REMOTEPARTY) == 0) {
+ query = F_LEFT_BRACKET + F_NUMBER + F_EQUAL + F_S_QUOTATION + value->toString() + F_S_QUOTATION + F_RIGHT_BRACKET;
+ } else if (name.compare(STR_RP_CONTACTID) == 0) {
+ query = F_LEFT_BRACKET + F_RELATED_ID + F_EQUAL + F_S_QUOTATION + value->toString() + F_S_QUOTATION + F_RIGHT_BRACKET;
+ } else if (name.compare(STR_START_TIME) == 0) {
std::string dateStr ("");
if(value->getType() == PrimitiveType_Time) {
tm date = value->getDateTm();
} else {
return query;
}
- query = STR_LEFT_BRACKET + STR_LOG_TIME + STR_EQUAL + STR_S_QUOTATION + dateStr + STR_S_QUOTATION + STR_RIGHT_BRACKET;
- } else if (name.compare("duration") == 0) {
- query = STR_LEFT_BRACKET + STR_DURATION + STR_EQUAL + STR_S_QUOTATION + value->toString() + STR_S_QUOTATION + STR_RIGHT_BRACKET;
+ query = F_LEFT_BRACKET + F_LOG_TIME + F_EQUAL + F_S_QUOTATION + dateStr + F_S_QUOTATION + F_RIGHT_BRACKET;
+ } else if (name.compare(F_DURATION) == 0) {
+ query = F_LEFT_BRACKET + F_DURATION + F_EQUAL + F_S_QUOTATION + value->toString() + F_S_QUOTATION + F_RIGHT_BRACKET;
}
return query;
#include <API/Filter/IFilterVisitor.h>
#include <API/Call/CallHistoryEntryProperties.h>
+#include <API/Call/CallDefine.h>
namespace TizenApis {
namespace Platform {
namespace Call {
-#define STR_TIZEN_TEL "tizen.tel"
-#define STR_TIZEN_XMPP "tizen.xmpp"
-#define STR_TIZEN_SIP "tizen.sip"
-
-#define STR_CALL "call"
-#define STR_CALL_VOICE "call.voice"
-#define STR_CALL_VIDEO "call.video"
-#define STR_TIZEN_EMERGENCY "call.emergency"
-
-#define STR_DIALED "dialed"
-#define STR_RECEIVED "received"
-#define STR_MISSED_NEW "missed-new"
-#define STR_MISSED "missed"
-#define STR_REJECTED "rejected"
-#define STR_BLOCKED "blocked"
-
-#define STR_BASE_QUERY "SELECT id, log_type, related_id, number, log_time, data1 FROM phonelogs"
class CallHistoryFilter: public Api::Tizen::IFilterVisitor
{
#include <call.h>
#include <dpl/log/log.h>
#include <API/Account/AccountServices.h>
+#include <API/Call/CallDefine.h>
#include "CallManager.h"
using namespace WrtDeviceApis::Commons;
ThrowMsg(UnsupportedException, "Not supported filter : providerId");
}
- std::string typeId(filter->getServiceTypeId());
+ std::string typeId(filter->getCallType());
StringArrayPtr tags(filter->getTags());
- if (typeId.compare("tizen.tel") != 0) {
- ThrowMsg(UnsupportedException, "Not supported value : serviceTypeId");
+ if (typeId.compare(STR_TIZEN_TEL) != 0
+ && typeId.compare(STR_TIZEN_XMPP) != 0
+ && typeId.compare(STR_TIZEN_SIP) != 0
+ && typeId.compare("") != 0) {
+ ThrowMsg(InvalidArgumentException, "Invalid value : ServiceTypeId");
}
- for (size_t cnt = 0; cnt < tags->size(); cnt++) {
- if (((*tags)[cnt]).compare("call") == 0
- ||((*tags)[cnt]).compare("call.voice") == 0
- || ((*tags)[cnt]).compare("call.video") == 0
- || ((*tags)[cnt]).compare("call.emergency") == 0) {
- continue;
- } else {
- ThrowMsg(UnsupportedException, "Not supported value : tags");
+ size_t cnt = 0;
+ for (; cnt < tags->size(); cnt++) {
+ if (((*tags)[cnt]).compare(STR_CALL) != 0
+ &&((*tags)[cnt]).compare(STR_CALL_VOICE) != 0
+ && ((*tags)[cnt]).compare(STR_CALL_VIDEO) != 0
+ && ((*tags)[cnt]).compare(STR_CALL_EMERGENCY) != 0) {
+ ThrowMsg(InvalidArgumentException, "Invalid value : tags");
}
}
AccountServicesArrayPtr accountServicesList(new AccountServicesArray());
AccountServicesPtr callServices(new AccountServices());
- callServices->setServiceTypeId("tizen.tel");
+ if (typeId.compare(STR_TIZEN_XMPP) == 0
+ || typeId.compare(STR_TIZEN_SIP) == 0) {
+ event->setResult(accountServicesList);
+ EventRequestReceiver<EventGetCallService>::ManualAnswer(event);
+ }
+
+ callServices->setServiceTypeId(STR_TIZEN_TEL);
StringArrayPtr supportTags(new StringArray());
- supportTags->push_back("call.voice");
- supportTags->push_back("call.video");
- supportTags->push_back("call.emergency");
+ supportTags->push_back(STR_CALL_VOICE);
+ supportTags->push_back(STR_CALL_VIDEO);
+ supportTags->push_back(STR_CALL_EMERGENCY);
callServices->setTags(*supportTags);
+ callServices->setApplicationId(STR_TIZEN_DIALER);
accountServicesList->push_back(callServices);
event->setResult(accountServicesList);
EventRequestReceiver<EventGetCallService>::ManualAnswer(event);
- } catch (const UnsupportedException& ex) {
+ } catch (const InvalidArgumentException& ex) {
LogError("Exception: " << ex.GetMessage());
- event->setExceptionCode(ExceptionCodes::UnsupportedException);
+ event->setExceptionCode(ExceptionCodes::InvalidArgumentException);
EventRequestReceiver<EventGetCallService>::ManualAnswer(event);
} catch (const PlatformException& ex) {
LogError("Exception: " << ex.GetMessage());
#include <ITapiSim.h>
#include <call.h>
#include <dpl/log/log.h>
+#include <API/Call/CallDefine.h>
#include "CallService.h"
using namespace WrtDeviceApis::Commons;
try {
event->switchToManualAnswer();
- std::string remoteParty("tel://");
+ std::string remoteParty(STR_TEL_URI);
remoteParty.append(event->getRemoteParty());
remoteParty.append(event->getExtension());
service_create(&service);
service_set_operation(service, SERVICE_OPERATION_DEFAULT);
- service_set_package(service, "com.samsung.phone"); //org.tizen.phone
+ service_set_package(service, event->getAppId().c_str());
service_set_uri(service, remoteParty.c_str());
ContactPtr AddressBook::get(const std::string &contactId)
{
LogDebug("entered");
- if(contactId == "")
- ThrowMsg(InvalidArgumentException, "contactId argument is wrong");
- ContactSearchEnginePtr searchEngine(new ContactSearchEngine(ContactSearchEngine::CONTACT_QUERY));
-
- searchEngine->setCondition(contactId);
- searchEngine->setAttributeOfInterest();
- searchEngine->setSortMode();
-
- ContactArrayPtr contacts = searchEngine->getContactSearchResult();
-
- if(contacts->size() == 0)
- ThrowMsg(NotFoundException, "No contact with ID:" << contactId);
-
- return contacts->at(0);
+ return internalGetById(contactId);
}
void AddressBook::add(const ContactPtr &contact)
LogError("error code " << id);
ThrowMsg(PlatformException, "Error during executing contacts_svc_insert_contact()");
}
- newContact->setId(id);
+
+ std::stringstream oss;
+ oss << id;
+ std::string idStr = oss.str();
+ ContactPtr insertedContact = internalGetById(idStr);
+
+ newContact->copy(insertedContact);
}
}
ThrowMsg(PlatformException, "Error during executing contacts_svc_delete_contact()");
}
+ContactPtr AddressBook::internalGetById(const std::string &contactId)
+{
+ if(contactId == "")
+ ThrowMsg(InvalidArgumentException, "contactId argument is wrong");
+
+ ContactSearchEnginePtr searchEngine(new ContactSearchEngine(ContactSearchEngine::CONTACT_QUERY));
+
+ searchEngine->setCondition(contactId);
+ searchEngine->setAttributeOfInterest();
+ searchEngine->setSortMode();
+
+ ContactArrayPtr contacts = searchEngine->getContactSearchResult();
+
+ if(contacts->size() == 0)
+ ThrowMsg(NotFoundException, "No contact with ID:" << contactId);
+
+ return contacts->at(0);
+}
+
void AddressBook::contactsSvcContactChangedCallback(void *data)
{
AddressBook *addressBook = static_cast<AddressBook *>(data);
private:
int m_latestVersion;
+ TizenApis::Api::Contact::ContactPtr internalGetById(const std::string &contactId);
+
void internalAddContact(const TizenApis::Api::Contact::ContactPtr &newContact);
void internalDeleteContactById(int id);
DPL::Mutex m_contactEditingMutex;
str = query_get_attribute(m_contact_query_service, CONTACT_RINGTONE, &err);
if( str )
- contact->setRingtoneURI(str);
+ contact->setRingtoneURI(std::string("file://") + str);
str = query_get_attribute(m_contact_query_service, CONTACT_NOTE, &err);
if( str )
str = query_get_attribute(m_contact_query_service, CONTACT_PHOTO_URI, &err);
if( str )
- contact->setPhotoURI(str);
+ contact->setPhotoURI(std::string("file://") + str);
str = query_get_attribute(m_contact_query_service, CONTACT_LAST_UPDATED_TIME_STAMP, &err);
if( str )
contact->setLastUpdated(time_stamp);
}
- ContactNamePtr contactName = contact->getName();
+ char *firstName = query_get_attribute(m_contact_query_service, NAME_FIRST, &err);
+ char *lastName = query_get_attribute(m_contact_query_service, NAME_LAST, &err);
+ char *middleName = query_get_attribute(m_contact_query_service, NAME_MIDDLE, &err);
+ char *displayName = query_get_attribute(m_contact_query_service, NAME_DISPLAY, &err);
+ char *prefix = query_get_attribute(m_contact_query_service, NAME_PREFIX, &err);
+ char *phoneticName = query_get_attribute(m_contact_query_service, NAME_PHONETIC, &err);
- str = query_get_attribute(m_contact_query_service, NAME_FIRST, &err);
- if( str )
- contactName->setFirstName(str);
-
- str = query_get_attribute(m_contact_query_service, NAME_LAST, &err);
- if( str )
- contactName->setLastName(str);
-
- str = query_get_attribute(m_contact_query_service, NAME_MIDDLE, &err);
- if( str )
- contactName->setMiddleName(str);
-
- str = query_get_attribute(m_contact_query_service, NAME_DISPLAY, &err);
- if( str )
- contactName->setDisplayName(str);
-
- str = query_get_attribute(m_contact_query_service, NAME_PREFIX, &err);
- if( str )
- contactName->setPrefix(str);
-
- str = query_get_attribute(m_contact_query_service, NAME_PHONETIC, &err);
- if( str )
- contactName->setPhoneticName(str);
+ setName(contact, prefix, firstName, middleName, lastName, phoneticName, displayName);
nameAlreadyChecked = true;
}
}
else if (!nicknameAlreadyChecked && (pattr == NICKNAME_NAME))
{
+ ContactNamePtr contactName(NULL);
+
+ if(!contact->getNameIsSet())
+ contactName = ContactNamePtr(new ContactName());
+ else
+ contactName = contact->getName();
+
do
{
char *nickname = query_get_attribute(m_contact_query_service, NICKNAME_NAME, &err);
if(nickname)
- contact->getName()->addNickname(string(nickname));
+ contactName->addNickname(string(nickname));
} while ( fetch_next_row(m_contact_query_service) == QUERY_SUCCESS );
+ if(!contact->getNameIsSet())
+ contact->setName(contactName);
+
nicknameAlreadyChecked = true;
}
else if (!categoryAlreadyChecked && (pattr == CATEGORY_INFO))
}
#endif
+void ContactSearchEngine::setName(ContactPtr& contact,
+ char *prefix, char *firstName, char *middleName,
+ char *lastName, char *phoneticName, char *displayName)
+{
+ if(prefix == NULL && firstName == NULL && middleName == NULL
+ && lastName == NULL && phoneticName == NULL && displayName == NULL)
+ return;
+
+ ContactNamePtr contactName(NULL);
+
+ if(!contact->getNameIsSet())
+ contactName = ContactNamePtr(new ContactName);
+ else
+ contactName = contact->getName();
+
+ if( prefix )
+ contactName->setFirstName(prefix);
+
+ if( firstName )
+ contactName->setLastName(firstName);
+
+ if( middleName )
+ contactName->setMiddleName(middleName);
+
+ if( lastName )
+ contactName->setDisplayName(lastName);
+
+ if( phoneticName )
+ contactName->setPrefix(phoneticName);
+
+ if( phoneticName )
+ contactName->setPhoneticName(phoneticName);
+
+ if(!contact->getNameIsSet())
+ contact->setName(contactName);
+}
+
void ContactSearchEngine::setPhoneNumber(ContactPtr& contact, char *number, char *type)
{
if(number == NULL)
void ContactSearchEngine::setOrganization(ContactPtr& contact,
char* org_name, char* org_dept, char* org_title, char* org_role)
{
+ if(org_name == NULL && org_dept == NULL && org_title == NULL && org_role == NULL)
+ return;
+
ContactOrganizationPtr org = ContactOrganizationPtr(new ContactOrganization());
if(org_name)
void setPlatformAttrValue(TizenApis::Api::Contact::Contact& contact, contact_attribute_e attr, char* val);
#endif
+ void setName(TizenApis::Api::Contact::ContactPtr& contact, char *prefix, char *firstName, char *middleName, char *lastName, char *phoneticName, char *displayName);
void setPhoneNumber(TizenApis::Api::Contact::ContactPtr& contact, char *number, char *type);
void setEmailAddresses(TizenApis::Api::Contact::ContactPtr& contact, char *email, char *type);
void setUrlAddresses(TizenApis::Api::Contact::ContactPtr& contact, char *url, char *type);
#include <pcrecpp.h>
#include <dpl/log/log.h>
#include <Commons/Exception.h>
+#include <Commons/Regex.h>
#include "ContactWrapper.h"
#include "AddressBook.h"
#include "Contact.h"
charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_IMG_PATH_STR);
if (charValue)
- m_abstractContact->setPhotoURI(charValue);
+ m_abstractContact->setPhotoURI(convertPathToUri(charValue));
charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_RINGTONE_PATH_STR);
if (charValue)
- m_abstractContact->setRingtoneURI(charValue);
+ m_abstractContact->setRingtoneURI(convertPathToUri(charValue));
charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_NOTE_STR);
if (charValue)
if (charValue)
contactName->setPrefix(charValue);
- charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_SUFFIX_STR);
- if (charValue)
- contactName->setPhoneticName(charValue);
+ //charValue = contacts_svc_value_get_str(value, CTS_NAME_VAL_SUFFIX_STR);
+ //if (charValue)
+ // contactName->setPhoneticName(charValue);
}
else if (errorCode != CTS_ERR_NO_DATA || value == NULL)
return false;
}
+// errorCode = contacts_svc_struct_get_value(m_platformContact, CTS_CF_BASE_INFO_VALUE, &value);
+// if (CTS_SUCCESS == errorCode && value != NULL)
+// {
+// const char *charValue = NULL;
+//
+// charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_IMG_PATH_STR);
+// if (charValue)
+// m_abstractContact->setPhotoURI(convertPathToUri(charValue));
+//
+// charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_RINGTONE_PATH_STR);
+// if (charValue)
+// m_abstractContact->setRingtoneURI(convertPathToUri(charValue));
+//
+// bool boolValue = contacts_svc_value_get_bool(value, CTS_BASE_VAL_FAVORITE_BOOL);
+// if (boolValue)
+// m_abstractContact->setIsFavorite(boolValue);
+//
+// charValue = contacts_svc_value_get_str(value, CTS_BASE_VAL_NOTE_STR);
+// if (charValue)
+// m_abstractContact->addNote(charValue);
+// }
+// else if (errorCode != CTS_ERR_NO_DATA || value == NULL)
+// {
+// return false;
+// }
+
return true;
}
addresses->push_back(address);
int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(addressList->data), CTS_POSTAL_VAL_TYPE_INT);
- switch (type)
- {
- case CTS_ADDR_TYPE_NONE:
+ if(type & CTS_ADDR_TYPE_POSTAL) // TODO to be checked
address->addType(CONTACT_ADDRESS_TYPE_PREF);
- break;
- case CTS_ADDR_TYPE_HOME:
+ if(type & CTS_ADDR_TYPE_HOME)
address->addType(CONTACT_ADDRESS_TYPE_HOME);
- break;
- case CTS_ADDR_TYPE_WORK:
+ if(type & CTS_ADDR_TYPE_WORK)
address->addType(CONTACT_ADDRESS_TYPE_WORK);
- break;
- default:
- LogError("invalid address type");
- address->addType(CONTACT_ADDRESS_TYPE_PREF);
- break;
- }
const char *charValue = NULL;
emailAddresses->push_back(email);
int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(emailList->data), CTS_EMAIL_VAL_TYPE_INT);
- switch (type)
- {
- case CTS_EMAIL_TYPE_NONE:
+
+ if(type | CTS_EMAIL_TYPE_NONE)
email->addType(CONTACT_EMAIL_TYPE_PREF);
- break;
- case CTS_EMAIL_TYPE_HOME:
+ if(type | CTS_EMAIL_TYPE_HOME)
email->addType(CONTACT_EMAIL_TYPE_HOME);
- break;
- case CTS_EMAIL_TYPE_WORK:
+ if(type | CTS_EMAIL_TYPE_WORK)
email->addType(CONTACT_EMAIL_TYPE_WORK);
- break;
- default:
- LogError("invalid phone type");
- email->addType(CONTACT_EMAIL_TYPE_PREF);
- break;
- }
const char *charValue = NULL;
phoneNumbers->push_back(phoneNumber);
int type = contacts_svc_value_get_int(static_cast<CTSvalue*>(phoneList->data), CTS_NUM_VAL_TYPE_INT);
- switch (type)
- {
- case CTS_NUM_TYPE_WORK:
+ if(type & CTS_NUM_TYPE_WORK)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_WORK);
- break;
- case CTS_NUM_TYPE_NONE:
+ if(type & CTS_NUM_TYPE_NONE)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PREF);
- break;
- case CTS_NUM_TYPE_HOME:
+ if(type & CTS_NUM_TYPE_HOME)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_HOME);
- break;
- case CTS_NUM_TYPE_FAX:
+ if(type & CTS_NUM_TYPE_FAX)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_FAX);
- break;
- case CTS_NUM_TYPE_CELL:
+ if(type & CTS_NUM_TYPE_CELL)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_CELL);
- break;
- case CTS_NUM_TYPE_PAGER:
+ if(type & CTS_NUM_TYPE_PAGER)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PAGER);
- break;
- case CTS_NUM_TYPE_CAR:
+ if(type & CTS_NUM_TYPE_CAR)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_CAR);
- break;
- case CTS_NUM_TYPE_VOICE:
+ if(type & CTS_NUM_TYPE_VOICE)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_VOICE);
- break;
- case CTS_NUM_TYPE_MSG:
+ if(type & CTS_NUM_TYPE_MSG)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_MSG);
- break;
- case CTS_NUM_TYPE_BBS:
+ if(type & CTS_NUM_TYPE_BBS)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_BBS);
- break;
- case CTS_NUM_TYPE_MODEM:
- phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_MODEM);
- break;
- case CTS_NUM_TYPE_ISDN:
+ if(type & CTS_NUM_TYPE_ISDN)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_ISDN);
- break;
- case CTS_NUM_TYPE_VIDEO:
+ if(type & CTS_NUM_TYPE_VIDEO)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_VIDEO);
- break;
- case CTS_NUM_TYPE_PCS:
+ if(type & CTS_NUM_TYPE_PCS)
phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PCS);
- break;
- default:
- LogError("invalid phone type");
- phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_PREF);
- break;
- }
+ if(type & CTS_NUM_TYPE_WORK)
+ phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_WORK);
+ if(type & CTS_NUM_TYPE_WORK)
+ phoneNumber->addType(CONTACT_PHONE_NUMBER_TYPE_WORK);
const char *charValue = NULL;
switch (types->at(j))
{
case CONTACT_ADDRESS_TYPE_PREF:
- type = CTS_ADDR_TYPE_NONE;
+ type |= CTS_ADDR_TYPE_POSTAL; // TODO To be checked
break;
case CONTACT_ADDRESS_TYPE_WORK:
- type = CTS_ADDR_TYPE_WORK;
+ type |= CTS_ADDR_TYPE_WORK;
break;
case CONTACT_ADDRESS_TYPE_HOME:
- type = CTS_ADDR_TYPE_HOME;
+ type |= CTS_ADDR_TYPE_HOME;
break;
default:
LogError("invalid address type");
- type = CTS_EMAIL_TYPE_NONE;
+ type |= CTS_EMAIL_TYPE_NONE;
break;
}
}
|| CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_ADDITION_STR, contactName->getMiddleName().c_str())
|| CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_DISPLAY_STR, contactName->getDisplayName().c_str())
|| CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_PREFIX_STR, contactName->getPrefix().c_str())
- || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_SUFFIX_STR, contactName->getPhoneticName().c_str())
+ // || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_SUFFIX_STR, contactName->getPhoneticName().c_str())
|| CTS_SUCCESS != contacts_svc_struct_store_value(m_platformContact, CTS_CF_NAME_VALUE, value))
{
contacts_svc_value_free(value);
|| CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_LAST_STR, contactName->getLastName().c_str())
|| CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_ADDITION_STR, contactName->getMiddleName().c_str())
|| CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_DISPLAY_STR, contactName->getDisplayName().c_str())
- || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_SUFFIX_STR, contactName->getPhoneticName().c_str())
+ // || CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_SUFFIX_STR, contactName->getPhoneticName().c_str())
|| CTS_SUCCESS != contacts_svc_value_set_str(value, CTS_NAME_VAL_PREFIX_STR, contactName->getPrefix().c_str()))
{
contacts_svc_value_free(value);
{
if (m_abstractContact->getPhotoURIIsSet())
{
- if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR, m_abstractContact->getPhotoURI().c_str()))
+ if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR, convertUriToPath(m_abstractContact->getPhotoURI()).c_str()))
{
contacts_svc_value_free(baseinfo);
return false;
}
}
- if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_RINGTONE_PATH_STR, m_abstractContact->getRingtoneURI().c_str()))
+ if (m_abstractContact->getRingtoneURIIsSet())
{
- contacts_svc_value_free(baseinfo);
- return false;
+ if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_RINGTONE_PATH_STR, convertUriToPath(m_abstractContact->getRingtoneURI()).c_str()))
+ {
+ contacts_svc_value_free(baseinfo);
+ return false;
+ }
}
if (CTS_SUCCESS != contacts_svc_value_set_bool(baseinfo, CTS_BASE_VAL_FAVORITE_BOOL, m_abstractContact->getIsFavorite()))
strOldImagePath = static_cast<string>(oldimgpath);
}
- string strNewImagePath = m_abstractContact->getPhotoURI();
+ string strNewImagePath = convertUriToPath(m_abstractContact->getPhotoURI());
if (strOldImagePath != strNewImagePath)
{
if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR, strNewImagePath.c_str()))
{
- contacts_svc_value_free(value);
+ contacts_svc_value_free(baseinfo);
return false;
}
}
- if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_RINGTONE_PATH_STR, m_abstractContact->getRingtoneURI().c_str()))
+ const char * oldringtonepath = NULL;
+ oldringtonepath = contacts_svc_value_get_str(baseinfo, CTS_BASE_VAL_IMG_PATH_STR);
+
+ string strOldRingtonePath = "";
+ if (NULL != oldringtonepath)
+ {
+ strOldRingtonePath = static_cast<string>(oldringtonepath);
+ }
+
+ string strNewRingtonePath = convertUriToPath(m_abstractContact->getRingtoneURI());
+ if (strOldRingtonePath != strNewRingtonePath)
{
- return false;
+ if (CTS_SUCCESS != contacts_svc_value_set_str(baseinfo, CTS_BASE_VAL_RINGTONE_PATH_STR, strNewRingtonePath.c_str()))
+ {
+ contacts_svc_value_free(baseinfo);
+ return false;
+ }
}
if(m_abstractContact->getNotesNum() > 0)
}
contacts_svc_struct_store_value(m_platformContact, CTS_CF_BASE_INFO_VALUE, baseinfo);
- contacts_svc_value_free(value);
+ contacts_svc_value_free(baseinfo);
}
/*
//save company information
{
}
+string ContactWrapper::convertUriToPath(string str) const
+{
+ string result;
+
+ if(validate("^file\\:///[a-zA-Z]{2,3}(/\\S*)?$", str, VALIDATE_MATCH_CASELESS))
+ result = str.substr(string("file://").size());
+ else if(validate("^/[a-zA-Z]{2,3}(/\\S*)?$", str, VALIDATE_MATCH_CASELESS))
+ result = str;
+
+ return result;
+}
+
+string ContactWrapper::convertPathToUri(string str) const
+{
+ string result;
+
+ if(validate("^/[a-zA-Z]{2,3}(/\\S*)?$", str, VALIDATE_MATCH_CASELESS))
+ result = "file://" + str;
+ else if(validate("^file\\:///[a-zA-Z]{2,3}(/\\S*)?$", str, VALIDATE_MATCH_CASELESS))
+ result = str;
+
+ return result;
+}
+
} // Contact
} // Platform
} // TizenApis
void printPlatformObject();
//for debug purpose only
void printAbstractObject();
+
+ std::string convertUriToPath(std::string str) const;
+ std::string convertPathToUri(std::string str) const;
};
typedef DPL::SharedPtr<ContactWrapper> ContactWrapperPtr;
string result;
Try
{
- if ( validate("^(http(s)?://)?\\w+.*$", path, VALIDATE_MATCH_CASELESS) )
+ if(validate("^http(s)?\\://[a-zA-Z0-9\\-\\.]+\\.[a-zA-Z]{2,3}(/\\S*)?$", path, VALIDATE_MATCH_CASELESS))
{
// if path is URL then Image will be downloaded.
result = downloadImage(path);
}
- else
+ else if(validate("^file\\:///[a-zA-Z]{2,3}(/\\S*)?$", path, VALIDATE_MATCH_CASELESS))
{
- result = path;
+ result = path;
+ }
+ else if(validate("^/[a-zA-Z]{2,3}(/\\S*)?$", path, VALIDATE_MATCH_CASELESS))
+ {
+ result = "file://" + path;
}
}
Catch(Exception)
#include <CommonsJavaScript/ScopedJSStringRef.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSCallbackManager.h>
+#include <API/Call/CallDefine.h>
#include "JSCallHistoryEntry.h"
#include "JSRemoteParty.h"
#include "JSCallService.h"
#include "JSCellularCallService.h"
-#define CH_ENTRY_ID "entryId"
-#define CH_SERVICE_ID "serviceId"
-#define CH_CALL_TYPE "callType"
-#define CH_TAGS "tags"
-#define CH_REMOTE_PARTIES "remoteParties"
-#define CH_FORWARDEDFROM "forwardedFrom"
-#define CH_START_TIME "startTime"
-#define CH_DURATION "duration"
-#define CH_END_REASON "endReason"
-#define CH_DIRECTION "direction"
-#define CH_RECORDING "recording"
-#define CH_COST "cost"
-#define CH_CURRENCY "currency"
-
-#define CH_REMOTE_PARTY "remoteParty"
-#define CH_DISPLAY_NAME "displayName"
-#define CH_CONTACT_ID "contactId"
-
-#define CH_SERVICETYPE_ID "serviceTypeId"
-#define CH_SERVICENAME "serviceName"
-#define CH_PROVIDER_ID "providerId"
-
using namespace WrtDeviceApis;
using namespace WrtDeviceApis::Commons;
using namespace WrtDeviceApis::CommonsJavaScript;
ThrowMsg(Commons::InvalidArgumentException, "Wrong attribute of RemoteParty");
}
- const ScopedJSStringRef remotePartyStr(JSStringCreateWithUTF8CString(CH_REMOTE_PARTY));
- const ScopedJSStringRef displayNameStr(JSStringCreateWithUTF8CString(CH_DISPLAY_NAME));
- const ScopedJSStringRef contactIdStr(JSStringCreateWithUTF8CString(CH_CONTACT_ID));
+ const ScopedJSStringRef remotePartyStr(JSStringCreateWithUTF8CString(STR_REMOTE_PARTY));
+ const ScopedJSStringRef displayNameStr(JSStringCreateWithUTF8CString(STR_DISPLAY_NAME));
+ const ScopedJSStringRef contactIdStr(JSStringCreateWithUTF8CString(STR_CONTACT_ID));
JSObjectRef jsObject = toJSObjectRef(jsValue);
{
Validator validator(m_context);
if (!validator.checkArrayKeys(m_allowedCallServiceFilter, jsValue)) {
- ThrowMsg(Commons::InvalidArgumentException, "Wrong attribute of RemoteParty");
+ ThrowMsg(Commons::InvalidArgumentException, "Wrong attribute of call service filter");
}
- const ScopedJSStringRef serviceTypeIdStr(JSStringCreateWithUTF8CString(CH_SERVICETYPE_ID));
- const ScopedJSStringRef tagsStr(JSStringCreateWithUTF8CString(CH_TAGS));
- const ScopedJSStringRef serviceNameStr(JSStringCreateWithUTF8CString(CH_SERVICENAME));
- const ScopedJSStringRef providerIdStr(JSStringCreateWithUTF8CString(CH_PROVIDER_ID));
+ const ScopedJSStringRef callTypeStr(JSStringCreateWithUTF8CString(STR_CALL_TYPE));
+ const ScopedJSStringRef tagsStr(JSStringCreateWithUTF8CString(STR_TAGS));
+ const ScopedJSStringRef serviceNameStr(JSStringCreateWithUTF8CString(STR_SERVICE_NAME));
+ const ScopedJSStringRef providerIdStr(JSStringCreateWithUTF8CString(STR_PROVIDER_ID));
JSObjectRef jsObject = toJSObjectRef(jsValue);
- JSValueRef jServiceTypeId = JSObjectGetProperty(m_context, jsObject, serviceTypeIdStr.get(), NULL);
+ JSValueRef jCallType = JSObjectGetProperty(m_context, jsObject, callTypeStr.get(), NULL);
JSValueRef jTags = JSObjectGetProperty(m_context, jsObject, tagsStr.get(), NULL);
JSValueRef jServiceName = JSObjectGetProperty(m_context, jsObject, serviceNameStr.get(), NULL);
JSValueRef jProviderId = JSObjectGetProperty(m_context, jsObject, providerIdStr.get(), NULL);
- std::string serviceTypeId;
- StringArrayPtr tags;
+ std::string callType;
+ StringArrayPtr tags(new StringArray());
std::string serviceName;
std::string providerId;
Throw(Commons::ConversionException);
}
- if (!JSValueIsUndefined(m_context, jServiceTypeId)) {
- serviceTypeId = toString(jServiceTypeId);
- result->setServiceTypeId(serviceTypeId);
- }
-
- if (!JSValueIsUndefined(m_context, jTags)) {
- tags = toStringArray(jProviderId);
- result->setTags(tags);
- }
-
- if (!JSValueIsUndefined(m_context, jServiceName)) {
- serviceName = toString(jServiceName);
- result->setServiceName(serviceName);
+ if (!JSValueIsUndefined(m_context, jCallType)) {
+ callType = toString(jCallType);
+ result->setCallType(callType);
}
if (!JSValueIsUndefined(m_context, jProviderId)) {
ThrowMsg(Commons::InvalidArgumentException, "Wrong attribute of call history entry");
}
- const ScopedJSStringRef entryIdStr(JSStringCreateWithUTF8CString(CH_ENTRY_ID));
- const ScopedJSStringRef serviceIdStr(JSStringCreateWithUTF8CString(CH_SERVICE_ID));
- const ScopedJSStringRef callTypeStr(JSStringCreateWithUTF8CString(CH_CALL_TYPE));
- const ScopedJSStringRef tagsStr(JSStringCreateWithUTF8CString(CH_TAGS));
- const ScopedJSStringRef remotePartiesStr(JSStringCreateWithUTF8CString(CH_REMOTE_PARTIES));
- const ScopedJSStringRef forwardedFromStr(JSStringCreateWithUTF8CString(CH_FORWARDEDFROM));
- const ScopedJSStringRef startTimeStr(JSStringCreateWithUTF8CString(CH_START_TIME));
- const ScopedJSStringRef durationStr(JSStringCreateWithUTF8CString(CH_DURATION));
- const ScopedJSStringRef endReasonStr(JSStringCreateWithUTF8CString(CH_END_REASON));
- const ScopedJSStringRef directionStr(JSStringCreateWithUTF8CString(CH_DIRECTION));
- const ScopedJSStringRef recordingStr(JSStringCreateWithUTF8CString(CH_RECORDING));
- const ScopedJSStringRef costStr(JSStringCreateWithUTF8CString(CH_COST));
- const ScopedJSStringRef currencyStr(JSStringCreateWithUTF8CString(CH_CURRENCY));
+ const ScopedJSStringRef entryIdStr(JSStringCreateWithUTF8CString(STR_ENTRY_ID));
+ const ScopedJSStringRef serviceIdStr(JSStringCreateWithUTF8CString(STR_SERVICE_ID));
+ const ScopedJSStringRef callTypeStr(JSStringCreateWithUTF8CString(STR_CALL_TYPE));
+ const ScopedJSStringRef tagsStr(JSStringCreateWithUTF8CString(STR_TAGS));
+ const ScopedJSStringRef remotePartiesStr(JSStringCreateWithUTF8CString(STR_REMOTE_PARTIES));
+ const ScopedJSStringRef forwardedFromStr(JSStringCreateWithUTF8CString(STR_FORWARDEDFROM));
+ const ScopedJSStringRef startTimeStr(JSStringCreateWithUTF8CString(STR_START_TIME));
+ const ScopedJSStringRef durationStr(JSStringCreateWithUTF8CString(STR_DURATION));
+ const ScopedJSStringRef endReasonStr(JSStringCreateWithUTF8CString(STR_END_REASON));
+ const ScopedJSStringRef directionStr(JSStringCreateWithUTF8CString(STR_DIRECTION));
+ const ScopedJSStringRef recordingStr(JSStringCreateWithUTF8CString(STR_RECORDING));
+ const ScopedJSStringRef costStr(JSStringCreateWithUTF8CString(STR_COST));
+ const ScopedJSStringRef currencyStr(JSStringCreateWithUTF8CString(STR_CURRENCY));
JSObjectRef jsObject = toJSObjectRef(jsValue);
{
std::vector<JSValueRef> callServiceList;
- Api::Account::AccountServices tmpAccountServices;
+ Api::Account::AccountServices tmpService;
for (size_t i = 0; i < (*arg).size(); i++) {
- tmpAccountServices = *((*arg)[i]);
+ tmpService = *((*arg)[i]);
- if (tmpAccountServices.getServiceTypeId().compare("tizen.tel") == 0) {
- callServiceList.push_back(JSCellularCallService::createJSObject(context, tmpAccountServices));
+ if (tmpService.getServiceTypeId().compare(STR_TIZEN_TEL) == 0) {
+ callServiceList.push_back(JSCellularCallService::createJSObject(context, tmpService));
} else {
- callServiceList.push_back(JSCallService::createJSObject(context, tmpAccountServices));
+ callServiceList.push_back(JSCallService::createJSObject(context, tmpService));
}
}
bool Converter::initializeAllowedProperties()
{
- m_allowedCallHistoryEntryProperties.push_back(CH_ENTRY_ID);
- m_allowedCallHistoryEntryProperties.push_back(CH_SERVICE_ID);
- m_allowedCallHistoryEntryProperties.push_back(CH_CALL_TYPE);
- m_allowedCallHistoryEntryProperties.push_back(CH_TAGS);
- m_allowedCallHistoryEntryProperties.push_back(CH_REMOTE_PARTIES);
- m_allowedCallHistoryEntryProperties.push_back(CH_FORWARDEDFROM);
- m_allowedCallHistoryEntryProperties.push_back(CH_START_TIME);
- m_allowedCallHistoryEntryProperties.push_back(CH_DURATION);
- m_allowedCallHistoryEntryProperties.push_back(CH_END_REASON);
- m_allowedCallHistoryEntryProperties.push_back(CH_DIRECTION);
- m_allowedCallHistoryEntryProperties.push_back(CH_RECORDING);
- m_allowedCallHistoryEntryProperties.push_back(CH_COST);
- m_allowedCallHistoryEntryProperties.push_back(CH_CURRENCY);
- m_allowedRemoteParty.push_back(CH_REMOTE_PARTY);
- m_allowedRemoteParty.push_back(CH_DISPLAY_NAME);
- m_allowedRemoteParty.push_back(CH_CONTACT_ID);
- m_allowedCallServiceFilter.push_back(CH_SERVICETYPE_ID);
- m_allowedCallServiceFilter.push_back(CH_TAGS);
- m_allowedCallServiceFilter.push_back(CH_SERVICENAME);
- m_allowedCallServiceFilter.push_back(CH_PROVIDER_ID);
+ m_allowedCallHistoryEntryProperties.push_back(STR_ENTRY_ID);
+ m_allowedCallHistoryEntryProperties.push_back(STR_SERVICE_ID);
+ m_allowedCallHistoryEntryProperties.push_back(STR_CALL_TYPE);
+ m_allowedCallHistoryEntryProperties.push_back(STR_TAGS);
+ m_allowedCallHistoryEntryProperties.push_back(STR_REMOTE_PARTIES);
+ m_allowedCallHistoryEntryProperties.push_back(STR_FORWARDEDFROM);
+ m_allowedCallHistoryEntryProperties.push_back(STR_START_TIME);
+ m_allowedCallHistoryEntryProperties.push_back(STR_DURATION);
+ m_allowedCallHistoryEntryProperties.push_back(STR_END_REASON);
+ m_allowedCallHistoryEntryProperties.push_back(STR_DIRECTION);
+ m_allowedCallHistoryEntryProperties.push_back(STR_RECORDING);
+ m_allowedCallHistoryEntryProperties.push_back(STR_COST);
+ m_allowedCallHistoryEntryProperties.push_back(STR_CURRENCY);
+ m_allowedRemoteParty.push_back(STR_REMOTE_PARTY);
+ m_allowedRemoteParty.push_back(STR_DISPLAY_NAME);
+ m_allowedRemoteParty.push_back(STR_CONTACT_ID);
+ m_allowedCallServiceFilter.push_back(STR_CALL_TYPE);
+ m_allowedCallServiceFilter.push_back(STR_TAGS);
+ m_allowedCallServiceFilter.push_back(STR_SERVICE_NAME);
+ m_allowedCallServiceFilter.push_back(STR_PROVIDER_ID);
return true;
}
#include <API/Call/CallHistoryEntryProperties.h>
#include <API/Call/CallHistoryFactory.h>
#include <API/Call/ICallHistoryEntry.h>
+#include <API/Call/CallDefine.h>
#include <Tizen/Common/JSTizenException.h>
#include <Tizen/Common/JSTizenExceptionFactory.h>
#include <Tizen/Common/SecurityExceptions.h>
using namespace Api::Call;
using namespace TizenApis::Commons;
-#define STR_ENTRY_ID "entryId"
-#define STR_SERVICE_ID "serviceId"
-#define STR_CALL_TYPE "callType"
-#define STR_TAGS "tags"
-#define STR_REMOTE_PARTIES "remoteParties"
-#define STR_FORWARDEDFROM "forwardedFrom"
-#define STR_START_TIME "startTime"
-#define STR_DURATION "duration"
-#define STR_END_REASON "endReason"
-#define STR_DIRECTION "direction"
-#define STR_RECORDING "recording"
-#define STR_COST "cost"
-#define STR_CURRENCY "currency"
-
JSClassDefinition JSCallHistoryEntry::m_classInfo = {
0,
kJSClassAttributeNone,
std::string direction(converter.toString(value));
if (callHistoryEntry != NULL) {
- if((entryInfo->getDirection().compare("missed-new") == 0) && (direction.compare("missed") == 0)) {
+ if((entryInfo->getDirection().compare(STR_MISSED_NEW) == 0) && (direction.compare(STR_MISSED) == 0)) {
callHistoryEntry->setMarkSeen(entryInfo->getEntryId());
- entryInfo->setDirection("missed");
+ entryInfo->setDirection(STR_MISSED);
} else {
Throw(WrtDeviceApis::Commons::UnsupportedException);
}
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
#include <API/Call/ICallManager.h>
#include <API/Call/CallFactory.h>
+#include <API/Call/CallDefine.h>
#include <API/Call/EventGetCallService.h>
#include <Tizen/Common/JSTizenExceptionFactory.h>
#include <Tizen/Common/JSTizenException.h>
};
JSStaticValue JSCallManager::m_property[] = {
- { "history", getProperty, NULL, kJSPropertyAttributeReadOnly },
+ { STR_HISTORY, getProperty, NULL, kJSPropertyAttributeReadOnly },
{ 0, 0, 0, 0 }
};
JSContextRef globalContext = priv->getContext();
try {
Converter convert(context);
- if(JSStringIsEqualToUTF8CString(propertyName, "history")) {
+ if(JSStringIsEqualToUTF8CString(propertyName, STR_HISTORY)) {
return JSCallHistory::createJSObject(globalContext, object);
}
} catch(const WrtDeviceApis::Commons::Exception& ex) {
if (argumentCount == 0) {
StringArrayPtr tags(new StringArray());
- tags->push_back("call");
+ tags->push_back(STR_CALL);
filter->setTags(tags);
} else {
if (!JSValueIsObject(context, arguments[0])) {
if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::None) {
return converter.toJSValueRef(event->getResult(), gContext);
} else {
- if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::UnsupportedException) {
- return JSTizenExceptionFactory::postException(context, exception, JSTizenException::NOT_SUPPORTED_ERROR, "Not supported value");
+ if (event->getExceptionCode() == WrtDeviceApis::Commons::ExceptionCodes::InvalidArgumentException) {
+ return JSTizenExceptionFactory::postException(context, exception, JSTizenException::INVALID_VALUES_ERROR, "Invalid values error : CallServiceFilter");
} else {
return JSTizenExceptionFactory::postException(context, exception, JSTizenException::UNKNOWN_ERROR, "Unknown error");
}
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
+#include <API/Call/CallDefine.h>
#include <API/Call/CallFactory.h>
#include <API/Call/ICallService.h>
#include <API/Call/EventLaunchDialer.h>
};
JSStaticValue JSCallService::m_property[] = {
- { "voicemailNumbers", getProperty, NULL, kJSPropertyAttributeReadOnly },
+ { STR_VOICEMAIL_NUMBERS, getProperty, NULL, kJSPropertyAttributeReadOnly },
{ 0, 0, 0, 0 }
};
try {
Converter convert(context);
- if(JSStringIsEqualToUTF8CString(propertyName, "voicemailNumbers")) {
+ if(JSStringIsEqualToUTF8CString(propertyName, STR_VOICEMAIL_NUMBERS)) {
return convert.toJSValueRef(callService->getVoicemailNumbers(), globalContext);
}
} catch(WrtDeviceApis::Commons::Exception) {
if (argumentCount >= 4) {
event ->setExtension(converter.toString(arguments[3]));
}
+ event->setAppId(privateData->getApplicationId());
event->setPrivateData(StaticPointerCast<IEventPrivateData> (cbm));
event->setForAsynchronousCall(&ResponseDispatcher::getInstance());
#include <CommonsJavaScript/JSCallbackManager.h>
#include <CommonsJavaScript/Utils.h>
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
+#include <API/Call/CallDefine.h>
#include <API/Call/CallFactory.h>
#include <API/Call/ICallManager.h>
#include <API/Call/EventSendUSSD.h>
};
JSStaticValue JSCellularCallService::m_property[] = {
- { "subscriberNumbers", getProperty, NULL, kJSPropertyAttributeReadOnly },
- { "emergencyNumbers", getProperty, NULL, kJSPropertyAttributeReadOnly },
+ { STR_SUBSCRIBER_NUMBERS, getProperty, NULL, kJSPropertyAttributeReadOnly },
+ { STR_EMERGENCY_NUMBERS, getProperty, NULL, kJSPropertyAttributeReadOnly },
{ 0, 0, 0, 0 }
};
try {
Converter convert(context);
- if(JSStringIsEqualToUTF8CString(propertyName, "subscriberNumbers")) {
+ if(JSStringIsEqualToUTF8CString(propertyName, STR_SUBSCRIBER_NUMBERS)) {
return convert.toJSValueRef(callService->getSubscriberNumbers(), globalContext);
- } else if(JSStringIsEqualToUTF8CString(propertyName, "emergencyNumbers")) {
+ } else if(JSStringIsEqualToUTF8CString(propertyName, STR_EMERGENCY_NUMBERS)) {
return convert.toJSValueRef(callService->getEmergencyNumbers(), globalContext);
}
} catch(WrtDeviceApis::Commons::Exception) {
#include <dpl/shared_ptr.h>
#include <CommonsJavaScript/JSUtils.h>
#include <CommonsJavaScript/JSDOMExceptionFactory.h>
+#include <API/Call/CallDefine.h>
#include <API/Call/RemoteParty.h>
#include "JSRemoteParty.h"
#include "Converter.h"
using namespace WrtDeviceApis::CommonsJavaScript;
using namespace Api::Call;
-#define STR_REMOTE_PARTY "remoteParty"
-#define STR_DISPLAY_NAME "displayName"
-#define STR_CONTACT_ID "contactId"
-
JSClassDefinition JSRemoteParty::m_classInfo = {
0,
kJSClassAttributeNone,
ThrowMsg(WrtDeviceApis::Commons::ConversionException, "Wrong attribute");
}
+ // NOTE: Currently not support office and logoURI fields
const ScopedJSStringRef nameStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_NAME));
const ScopedJSStringRef departmentStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_DEPARTMENT));
const ScopedJSStringRef titleStr(JSStringCreateWithUTF8CString(CONTACT_ATTRIBUTE_TITLE));
ContactAnniversaryPtr contactAnniversary(new ContactAnniversary());
contactAnniversary->setDate(date);
- if(labelIsSet)
- contactAnniversary->setLabel(label);
+
+ // NOTE: Currently not support label field
+ //if(labelIsSet)
+ // contactAnniversary->setLabel(label);
JSObjectRef jsobject;
{
Try
{
- ContactAnniversaryPtr anniversary = getPrivData(object);
- ContactConverterFactory::ConverterType converter =
- ContactConverterFactory::getConverter(context);
- anniversary->setLabel(converter->toString(value));
+ // NOTE: Currently not support this field
+ //ContactAnniversaryPtr anniversary = getPrivData(object);
+ //ContactConverterFactory::ConverterType converter =
+ // ContactConverterFactory::getConverter(context);
+ //anniversary->setLabel(converter->toString(value));
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
Try
{
- ContactOrganizationPtr organization = getPrivData(object);
- ContactConverterFactory::ConverterType converter =
- ContactConverterFactory::getConverter(context);
- organization->setOffice(converter->toString(value));
+ // NOTE: Currently not support this field
+ //ContactOrganizationPtr organization = getPrivData(object);
+ //ContactConverterFactory::ConverterType converter =
+ // ContactConverterFactory::getConverter(context);
+ //organization->setOffice(converter->toString(value));
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
{
Try
{
- ContactOrganizationPtr organization = getPrivData(object);
- ContactConverterFactory::ConverterType converter =
- ContactConverterFactory::getConverter(context);
- organization->setLogoURI(converter->toString(value));
+ // NOTE: Currently not support this field
+ //ContactOrganizationPtr organization = getPrivData(object);
+ //ContactConverterFactory::ConverterType converter =
+ // ContactConverterFactory::getConverter(context);
+ //organization->setLogoURI(converter->toString(value));
return true;
}
Catch(WrtDeviceApis::Commons::Exception)
projects / profile / ivi / wrt-plugins-tizen.git / commitdiff