Result ActiveCall::prepare(cm_call_data_h callData)
{
- m_callInfo = CallInfo::newInstance(m_cm->getCallClient(), callData);
+ m_callInfo = CallInfo::newInstance(m_cm->getCallClient(),
+ callData,
+ m_cm->getContactInfoProvider());
if (!m_callInfo) {
LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
}
#include <glib/gtypes.h>
#include <sys/sysinfo.h>
-#include "ContactInfo.h"
#include "CallClient.h"
+#include "ContactInfoProvider.h"
+#include "ContactInfo.h"
#include "ConferenceCallInfo.h"
#include "common.h"
{
}
- CallInfoSRef CallInfo::newInstance(CallClient &client, cm_call_data_h callData)
+ CallInfoSRef CallInfo::newInstance(CallClient &client,
+ cm_call_data_h callData,
+ ContactInfoProviderSRef callInfoProvider)
{
if (!client) {
LOG_RETURN_VALUE(RES_FAIL, {}, "client is NULL");
}
auto result = makeShared<CallInfo>();
- FAIL_RETURN_VALUE(result->prepare(client, callData), {}, "result->prepare() failed!");
+ FAIL_RETURN_VALUE(result->prepare(client,
+ callData,
+ callInfoProvider),
+ {}, "result->prepare() failed!");
return result;
}
- Result CallInfo::prepare(CallClient &client, cm_call_data_h callData)
+ Result CallInfo::prepare(CallClient &client,
+ cm_call_data_h callData,
+ ContactInfoProviderSRef callInfoProvider)
{
Result res = convertCMResult(
cm_call_data_get_call_id(callData, &m_callId));
cm_call_data_get_person_id(callData, &personId));
FAIL_RETURN(res, "cm_call_data_get_person_id() failed!");
- if (personId >= 0) {
- m_contactInfo = ContactInfo::newInstance(personId);
+ if (personId >= 0 && callInfoProvider) {
+ m_contactInfo = callInfoProvider->createContactInfo(personId);
if (!m_contactInfo) {
- LOG_RETURN(RES_FAIL, "ContactInfo::newInstance() failed!");
+ LOG_RETURN(RES_FAIL, "createContactInfo() failed!");
}
}
FAIL_RETURN(res, "cm_call_data_get_call_member_count() failed!");
if (m_confMemberCount > 1) {
- res = initConferenceCallInfoList(client);
+ res = initConferenceCallInfoList(client, callInfoProvider);
FAIL_RETURN(res, "initConferenceCallInfoList() failed!");
}
return RES_OK;
}
- Result CallInfo::initConferenceCallInfoList(CallClient &client)
+ Result CallInfo::initConferenceCallInfoList(CallClient &client,
+ ContactInfoProviderSRef callInfoProvider)
{
// XXX: must be initialized with nullptr. If not an there is no conference calls
// cm_get_conference_callList return CM_ERROR_NONE and pointer will be not changed.
res = RES_OK;
GSList *l = callList;
for (; l != nullptr; l = g_slist_next(l)) {
- auto confCallInfo = ConferenceCallInfo::newInstance(static_cast<cm_conf_call_data_t *>(l->data));
+ auto confCallInfo = ConferenceCallInfo::newInstance(
+ static_cast<cm_conf_call_data_t *>(l->data),
+ callInfoProvider);
if (!confCallInfo) {
LOG_BREAK(res = RES_OUT_OF_MEMORY, "ConferenceCallInfo::newInstance() failed!");
}
class CallInfo final : public ICallInfo {
public:
- static CallInfoSRef newInstance(CallClient &client, cm_call_data_h callData);
+ static CallInfoSRef newInstance(CallClient &client,
+ cm_call_data_h callData,
+ ContactInfoProviderSRef callInfoProvider);
virtual ~CallInfo();
// ICallInfo
friend class ucl::RefCountObj<CallInfo>;
CallInfo();
- ucl::Result prepare(CallClient &client, cm_call_data_h callData);
- ucl::Result initConferenceCallInfoList(CallClient &client);
+ ucl::Result prepare(CallClient &client,
+ cm_call_data_h callData,
+ ContactInfoProviderSRef callInfoProvider);
+ ucl::Result initConferenceCallInfoList(CallClient &client,
+ ContactInfoProviderSRef callInfoProvider);
private:
unsigned int m_callId;
#include "HeldCall.h"
#include "EndCall.h"
+#include "ContactInfoProvider.h"
+
#include "CallInfo.h"
#include "ConferenceCallInfo.h"
Result CallManager::prepare()
{
+ m_contactInfoProvider = ContactInfoProvider::newInstance();
+ if (!m_contactInfoProvider) {
+ ELOG("ContactInfoProvider::newInstance() failed");
+ }
+
FAIL_RETURN(initCalls(), "initCalls() failed!");
FAIL_RETURN(convertCMResult(
return endCall((*iter)->getCallId(), CallReleaseType::BY_CALL_HANDLE);
}
+ ContactInfoProviderSRef CallManager::getContactInfoProvider()
+ {
+ return m_contactInfoProvider;
+ }
+
RejectMsgProviderSRef CallManager::getRejectMsgProvider()
{
if (!m_rejectMsgProvider) {
ucl::Result endCall(unsigned int callId, CallReleaseType type);
ucl::Result splitCalls(CallInfoSRef callInfo,
const IConferenceCallInfoSCRef &confCallInfo);
+ ContactInfoProviderSRef getContactInfoProvider();
RejectMsgProviderSRef getRejectMsgProvider();
ucl::Result processOutgoingCall(const std::string &telNum);
private:
CallClientSRef m_callClient;
RejectMsgProviderSRef m_rejectMsgProvider;
+ ContactInfoProviderSRef m_contactInfoProvider;
ICallManagerListenerWRef m_listener;
IncomingCallSRef m_incomingCall;
ActiveCallSRef m_activeCall;
#include <call-manager-ext.h>
+#include "ContactInfoProvider.h"
#include "ContactInfo.h"
#include "common.h"
{
}
- ConferenceCallInfoSRef ConferenceCallInfo::newInstance(cm_conf_call_data_t *confCallData)
+ ConferenceCallInfoSRef ConferenceCallInfo::newInstance(
+ cm_conf_call_data_t *confCallData,
+ ContactInfoProviderSRef callInfoProvider)
{
if (!confCallData) {
LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
}
auto result = makeShared<ConferenceCallInfo>();
- FAIL_RETURN_VALUE(result->prepare(confCallData), {}, "result->prepare() failed!");
+ FAIL_RETURN_VALUE(result->prepare(confCallData, callInfoProvider), {}, "result->prepare() failed!");
return result;
}
- Result ConferenceCallInfo::prepare(cm_conf_call_data_t *confCallData)
+ Result ConferenceCallInfo::prepare(
+ cm_conf_call_data_t *confCallData,
+ ContactInfoProviderSRef callInfoProvider)
{
- Result res = convertCMResult(cm_conf_call_data_get_call_id(confCallData, &m_callId));
+ Result res = convertCMResult(
+ cm_conf_call_data_get_call_id(confCallData, &m_callId));
FAIL_RETURN(res, "cm_conf_call_data_get_call_id() failed!");
char *number = nullptr;
- res = convertCMResult(cm_conf_call_data_get_call_number(confCallData, &number));
+ res = convertCMResult(
+ cm_conf_call_data_get_call_number(confCallData, &number));
FAIL_RETURN(res, "cm_conf_call_data_get_call_number() failed!");
m_phoneNum = nz(number);
// XXX: According to documentation it must be free, but it leads to crash
// free(number);
int personId = -1;
- res = convertCMResult(cm_conf_call_data_get_person_id(confCallData, &personId));
+ res = convertCMResult(
+ cm_conf_call_data_get_person_id(confCallData, &personId));
FAIL_RETURN(res, "cm_conf_call_data_get_person_id() failed!");
- if (personId >= 0) {
- m_contactInfo = ContactInfo::newInstance(personId);
+ if (personId >= 0 && callInfoProvider) {
+ m_contactInfo = callInfoProvider->createContactInfo(personId);
if (!m_contactInfo) {
- LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "ContactInfo::newInstance() failed!");
+ LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "createContactInfo() failed!");
}
}
return RES_OK;
class ConferenceCallInfo final : public IConferenceCallInfo {
public:
- static ConferenceCallInfoSRef newInstance(cm_conf_call_data_t *confCallData);
+ static ConferenceCallInfoSRef newInstance(
+ cm_conf_call_data_t *confCallData,
+ ContactInfoProviderSRef callInfoProvider);
virtual ~ConferenceCallInfo();
// IConferenceCallInfo
friend class ucl::RefCountObj<ConferenceCallInfo>;
ConferenceCallInfo();
- ucl::Result prepare(cm_conf_call_data_t *confCallData);
+ ucl::Result prepare(cm_conf_call_data_t *confCallData,
+ ContactInfoProviderSRef callInfoProvider);
private:
unsigned int m_callId;
std::string m_phoneNum;
*/
#include <call-manager-extension.h>
-#include <contacts.h>
#include "ContactInfo.h"
using namespace ucl;
- ContactInfo::ContactInfo(int personId):
+ ContactInfo::ContactInfo(int personId,
+ const std::string &name,
+ const std::string &imagePath,
+ ContactNameSourceType type):
m_personId(personId),
- m_nameSource(ContactNameSourceType::INVALID)
+ m_name(name),
+ m_imagePath(imagePath),
+ m_nameSource(type)
{
}
{
}
- ContactInfoSRef ContactInfo::newInstance(int personId)
+ ContactInfoSRef ContactInfo::newInstance(int personId,
+ const std::string &name,
+ const std::string &imagePath,
+ ContactNameSourceType type)
{
- auto result = makeShared<ContactInfo>(personId);
- FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
- return result;
- }
-
- inline ContactNameSourceType ContactInfo::convertContactNameSourceType(contacts_display_name_source_type_e cdbType)
- {
- switch (cdbType) {
- case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_INVALID: return ContactNameSourceType::INVALID;
- case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_EMAIL: return ContactNameSourceType::EMAIL;
- case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NUMBER: return ContactNameSourceType::NUMBER;
- case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NICKNAME: return ContactNameSourceType::NICKNAME;
- case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_COMPANY: return ContactNameSourceType::COMPANY;
- case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NAME: return ContactNameSourceType::NAME;
- default:
- return ContactNameSourceType::INVALID;
- }
- }
-
- Result ContactInfo::prepare()
- {
- DLOG("Contact exists with index [%d]", m_personId);
-
- contacts_filter_h filter = nullptr;
- contacts_list_h list = nullptr;
- contacts_query_h query = nullptr;
- contacts_record_h record = nullptr;
-
- contacts_filter_create(_contacts_contact._uri, &filter);
- contacts_filter_add_int(filter, _contacts_contact.person_id, CONTACTS_MATCH_EQUAL, m_personId);
- contacts_query_create(_contacts_contact._uri, &query);
- contacts_query_set_filter(query, filter);
-
- contacts_db_get_records_with_query(query, 0, 1, &list);
- contacts_list_get_current_record_p(list, &record);
-
- if (record) {
- char *name = nullptr;
- contacts_record_get_str_p(record, _contacts_contact.display_name, &name);
- m_name = nz(name);
-
- int type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_INVALID;
- contacts_record_get_int(record, _contacts_contact.display_source_type, &type);
- m_nameSource = convertContactNameSourceType(static_cast<contacts_display_name_source_type_e>(type));
-
- int count = 0;
- contacts_record_get_child_record_count(record, _contacts_contact.image, &count);
- if (count > 0) {
- char *imgPath = nullptr;
- contacts_record_h childRecord = NULL;
- contacts_record_get_child_record_at_p(record, _contacts_contact.image, 0, &childRecord);
- contacts_record_get_str_p(childRecord, _contacts_image.path, &imgPath);
- m_imagePath = nz(imgPath);
- }
- }
- contacts_list_destroy(list, true);
- contacts_filter_destroy(filter);
- contacts_query_destroy(query);
-
- DLOG("PersonID [%d]", m_personId);
- DLOG("Contact name [%s]", m_name.c_str());
- DLOG("Contact image path [%s]", m_imagePath.c_str());
-
- return RES_OK;
- }
-
- int ContactInfo::getPersonId() const
- {
- return m_personId;
- }
-
- void ContactInfo::setName(const std::string &name)
- {
- m_name = name;
- }
-
- void ContactInfo::setImagePath(const std::string &imagePath)
- {
- m_imagePath = imagePath;
- }
-
- void ContactInfo::setContactNameSourceType(ContactNameSourceType type)
- {
- m_nameSource = type;
+ return makeShared<ContactInfo>(personId, name, imagePath, type);
}
const std::string &ContactInfo::getName() const
class ContactInfo final : public IContactInfo {
public:
- static ContactInfoSRef newInstance(int personId);
+ static ContactInfoSRef newInstance(int personId,
+ const std::string &name,
+ const std::string &imagePath,
+ ContactNameSourceType type);
virtual ~ContactInfo();
- int getPersonId() const;
- void setName(const std::string &name);
- void setImagePath(const std::string &imagePath);
- void setContactNameSourceType(ContactNameSourceType type);
-
// IContactInfo
virtual const std::string &getName() const override final;
private:
friend class ucl::RefCountObj<ContactInfo>;
- ContactInfo(int personId);
-
- ucl::Result prepare();
- ContactNameSourceType convertContactNameSourceType(contacts_display_name_source_type_e cdbType);
+ ContactInfo(int personId,
+ const std::string &name,
+ const std::string &imagePath,
+ ContactNameSourceType type);
private:
int m_personId;
--- /dev/null
+/*
+ * Copyright 2017 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ContactInfoProvider.h"
+
+#include <contacts.h>
+#include <contacts_service.h>
+#include <contacts_errors.h>
+
+#include "ContactInfo.h"
+
+#include "common.h"
+
+namespace callui { namespace { namespace impl {
+
+ using namespace ucl;
+
+ inline ContactNameSourceType convertContactNameSourceType(contacts_display_name_source_type_e cdbType)
+ {
+ switch (cdbType) {
+ case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_INVALID: return ContactNameSourceType::INVALID;
+ case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_EMAIL: return ContactNameSourceType::EMAIL;
+ case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NUMBER: return ContactNameSourceType::NUMBER;
+ case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NICKNAME: return ContactNameSourceType::NICKNAME;
+ case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_COMPANY: return ContactNameSourceType::COMPANY;
+ case CONTACTS_DISPLAY_NAME_SOURCE_TYPE_NAME: return ContactNameSourceType::NAME;
+ default:
+ return ContactNameSourceType::INVALID;
+ }
+ }
+
+}}}
+
+namespace callui {
+
+ using namespace ucl;
+
+ ContactInfoProvider::ContactInfoProvider():
+ m_isConnected(false)
+ {
+
+ }
+
+ ContactInfoProvider::~ContactInfoProvider()
+ {
+ if (m_isConnected) {
+ contacts_disconnect();
+ }
+ }
+
+ ContactInfoProviderSRef ContactInfoProvider::newInstance()
+ {
+ auto result = makeShared<ContactInfoProvider>();
+ FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
+ return result;
+ }
+
+ Result ContactInfoProvider::prepare()
+ {
+ auto res = contacts_connect();
+ if (res != CONTACTS_ERROR_NONE) {
+ LOG_RETURN(RES_FAIL, "contacts_connect() failed! res[%d] msg[%s]",
+ res, get_error_message(res));
+ }
+ m_isConnected = true;
+
+ return RES_OK;
+ }
+
+ ContactInfoSRef ContactInfoProvider::createContactInfo(int contactId)
+ {
+ DLOG("Try create contact info for ID [%d]", contactId);
+
+ std::string contactName;
+ std::string contactImagePath;
+ ContactNameSourceType contactNameSource;
+
+ contacts_filter_h filter = nullptr;
+ contacts_list_h list = nullptr;
+ contacts_query_h query = nullptr;
+ contacts_record_h record = nullptr;
+
+ int ret = CONTACTS_ERROR_NONE;
+ do {
+ ret = contacts_filter_create(_contacts_contact._uri,
+ &filter);
+ if (ret != CONTACTS_ERROR_NONE) {
+ LOG_BREAK(RES_FAIL,
+ "contacts_filter_create() failed!"
+ "res[%d] res_msg[%s]",
+ ret, get_error_message(ret));
+ }
+
+ ret = contacts_filter_add_int(filter,
+ _contacts_contact.person_id,
+ CONTACTS_MATCH_EQUAL, contactId);
+ if (ret != CONTACTS_ERROR_NONE) {
+ LOG_BREAK(RES_FAIL,
+ "contacts_filter_add_int() failed!"
+ "res[%d] res_msg[%s]",
+ ret, get_error_message(ret));
+ }
+
+ ret = contacts_query_create(_contacts_contact._uri, &query);
+ if (ret != CONTACTS_ERROR_NONE) {
+ LOG_BREAK(RES_FAIL,
+ "contacts_query_create() failed!"
+ "res[%d] res_msg[%s]",
+ ret, get_error_message(ret));
+ }
+
+ ret = contacts_query_set_filter(query, filter);
+ if (ret != CONTACTS_ERROR_NONE) {
+ LOG_BREAK(RES_FAIL,
+ "contacts_query_set_filter() failed!"
+ "res[%d] res_msg[%s]",
+ ret, get_error_message(ret));
+ }
+
+ ret = contacts_db_get_records_with_query(query, 0, 1, &list);
+ if (ret != CONTACTS_ERROR_NONE) {
+ LOG_BREAK(RES_FAIL,
+ "contacts_db_get_records_with_query() failed!"
+ "res[%d] res_msg[%s]",
+ ret, get_error_message(ret));
+ }
+
+ ret = contacts_list_get_current_record_p(list, &record);
+ if (ret != CONTACTS_ERROR_NONE) {
+ LOG_BREAK(RES_FAIL,
+ "contacts_list_get_current_record_p() failed!"
+ "res[%d] res_msg[%s]",
+ ret, get_error_message(ret));
+ }
+
+ if (record) {
+ char *name = nullptr;
+ contacts_record_get_str_p(record,
+ _contacts_contact.display_name, &name);
+ contactName = nz(name);
+
+ int type = CONTACTS_DISPLAY_NAME_SOURCE_TYPE_INVALID;
+ contacts_record_get_int(record,
+ _contacts_contact.display_source_type, &type);
+ contactNameSource = impl::convertContactNameSourceType(
+ static_cast<contacts_display_name_source_type_e>(type));
+
+ int count = 0;
+ contacts_record_get_child_record_count(record,
+ _contacts_contact.image, &count);
+ if (count > 0) {
+ char *imgPath = nullptr;
+ contacts_record_h childRecord = NULL;
+ contacts_record_get_child_record_at_p(record,
+ _contacts_contact.image, 0, &childRecord);
+ contacts_record_get_str_p(childRecord,
+ _contacts_image.path, &imgPath);
+ contactImagePath = nz(imgPath);
+ }
+ }
+ } while (false);
+
+ contacts_list_destroy(list, true);
+ contacts_filter_destroy(filter);
+ contacts_query_destroy(query);
+
+ if (ret != CONTACTS_ERROR_NONE) {
+ return {};
+ }
+
+ DLOG("Contact ID [%d]", contactId);
+ DLOG("Contact name [%s]", contactName.c_str());
+ DLOG("Contact image path [%s]", contactImagePath.c_str());
+
+ return ContactInfo::newInstance(contactId,
+ contactName,
+ contactImagePath,
+ contactNameSource);
+ }
+
+}
+
--- /dev/null
+/*
+ * Copyright 2017 Samsung Electronics Co., Ltd
+ *
+ * Licensed under the Flora License, Version 1.1 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://floralicense.org/license/
+ *
+ * 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 __CALLUI_MODEL_CONTACT_INFO_PROVIDER_H__
+#define __CALLUI_MODEL_CONTACT_INFO_PROVIDER_H__
+
+#include "implTypes.h"
+
+namespace callui {
+
+ class ContactInfoProvider {
+ public:
+ static ContactInfoProviderSRef newInstance();
+ virtual ~ContactInfoProvider();
+
+ ContactInfoSRef createContactInfo(int contactId);
+
+ private:
+ friend class ucl::RefCountObj<ContactInfoProvider>;
+ ContactInfoProvider();
+
+ ucl::Result prepare();
+
+ private:
+ bool m_isConnected;
+ };
+}
+
+#endif // __CALLUI_MODEL_CONTACT_INFO_PROVIDER_H__
Result HeldCall::prepare(cm_call_data_h callData)
{
- m_callInfo = CallInfo::newInstance(m_cm->getCallClient(), callData);
+ m_callInfo = CallInfo::newInstance(m_cm->getCallClient(),
+ callData,
+ m_cm->getContactInfoProvider());
if (!m_callInfo) {
LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
}
Result IncomingCall::prepare(cm_call_data_h callData)
{
- m_callInfo = CallInfo::newInstance(m_cm->getCallClient(), callData);
+ m_callInfo = CallInfo::newInstance(m_cm->getCallClient(),
+ callData,
+ m_cm->getContactInfoProvider());
if (!m_callInfo) {
LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
}
ret = sound_manager_get_next_device(deviceList, &device);
if (ret == SOUND_MANAGER_ERROR_NO_DATA) {
res = RES_OK;
- LOG_BREAK(res, "No more device to check");
+ ILOG("No more device to check");
+ break;
} else if (ret != SOUND_MANAGER_ERROR_NONE) {
- LOG_BREAK(res, "sound_manager_get_next_device() failed. [%d][%s]",
+ UCL_FAIL_BREAK(res, "sound_manager_get_next_device() failed. [%d][%s]",
ret, get_error_message(ret));
}
if (!device) {
- LOG_BREAK(res, "device is NULL");
+ UCL_FAIL_BREAK(res, "device is NULL");
}
sound_manager_get_device_type(device, &type);
if (searchType == type) {
UCL_DECLARE_REF_ALIASES(SimSlotStateSource);
UCL_DECLARE_REF_ALIASES(HdVoiceStateSource);
+ UCL_DECLARE_REF_ALIASES(ContactInfoProvider);
+
UCL_DECLARE_REF_ALIASES(BluetoothVolume);
using AudioStateEvent = ucl::Event<AudioStateHandler>;
case callui::RES_NOT_REGISTERED: return {"RES_NOT_REGISTERED", DLOG_FATAL};
case callui::RES_ALREADY_REGISTERED: return {"RES_ALREADY_REGISTERED", DLOG_FATAL};
case callui::RES_OPERATION_FAILED: return {"RES_OPERATION_FAILED", DLOG_FATAL};
+ case callui::RES_NOT_CONNECTED: return {"RES_NOT_CONNECTED", DLOG_FATAL};
default:
return ucl::getResultData(result);
}
</ui-application>
<privileges>
<privilege>http://tizen.org/privilege/telephony</privilege>
- <privilege>http://tizen.org/privilege/telephony.admin</privilege>
- <privilege>http://tizen.org/privilege/appmanager.launch</privilege>
+ <privilege>http://tizen.org/privilege/keygrab</privilege>
<privilege>http://tizen.org/privilege/window.priority.set</privilege>
<privilege>http://tizen.org/privilege/systemsettings.admin</privilege>
<privilege>http://tizen.org/privilege/contact.read</privilege>
+ <privilege>http://tizen.org/privilege/display</privilege>
+ <privilege>http://tizen.org/privilege/telephony.admin</privilege>
+ <privilege>http://tizen.org/privilege/appmanager.launch</privilege>
<privilege>http://tizen.org/privilege/volume.set</privilege>
<privilege>http://tizen.org/privilege/message.write</privilege>
<privilege>http://tizen.org/privilege/notification</privilege>
- <privilege>http://tizen.org/privilege/display</privilege>
<privilege>http://tizen.org/privilege/message.read</privilege>
- <privilege>http://tizen.org/privilege/keygrab</privilege>
+ <privilege>http://tizen.org/privilege/callhistory.read</privilege>
</privileges>
</manifest>
projects / profile / wearable / apps / native / call-ui.git / commitdiff