notification: args.notification
};
- var result = native_.callSync('NotificationManager_post', data);
+ var result = native_.callSync('NotificationManagerPost', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
notification: args.notification
};
- var result = native_.callSync('NotificationManager_update', data);
+ var result = native_.callSync('NotificationManagerUpdate', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
id: args.id
};
- var result = native_.callSync('NotificationManager_remove', data);
+ var result = native_.callSync('NotificationManagerRemove', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
};
NotificationManager.prototype.removeAll = function() {
- var result = native_.callSync('NotificationManager_removeAll', {});
+ var result = native_.callSync('NotificationManagerRemoveAll', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
id: args.id
};
- var result = native_.callSync('NotificationManager_get', data);
+ var result = native_.callSync('NotificationManagerGet', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
id: args.id
};
- var result = native_.callSync('NotificationManager_get', data);
+ var result = native_.callSync('NotificationManagerGet', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
'Use getAllNotifications() instead.'
);
- var result = native_.callSync('NotificationManager_getAll', {});
+ var result = native_.callSync('NotificationManagerGetAll', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
};
NotificationManager.prototype.getAllNotifications = function() {
- var result = native_.callSync('NotificationManager_getAll', {
+ var result = native_.callSync('NotificationManagerGetAll', {
//add marker for UserNotification implementation
newImpl: true
});
}
args.color = convertColorToInt(args.color);
- var result = native_.callSync('NotificationManager_playLEDCustomEffect', args);
+ var result = native_.callSync('NotificationManagerPlayLEDCustomEffect', args);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
* Stops the custom effect of the service LED that is located to the front of a device.
*/
NotificationManager.prototype.stopLEDCustomEffect = function() {
- var result = native_.callSync('NotificationManager_stopLEDCustomEffect');
+ var result = native_.callSync('NotificationManagerStopLEDCustomEffect');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
//add marker for UserNotification implementation
args.newImpl = args.notification instanceof tizen.UserNotification;
- var result = native_.callSync('NotificationManager_saveNotificationAsTemplate', args);
+ var result = native_.callSync('NotificationManagerSaveNotificationAsTemplate', args);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
var result = native_.callSync(
- 'NotificationManager_createNotificationFromTemplate',
+ 'NotificationManagerCreateNotificationFromTemplate',
args
);
ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) \
- RegisterSyncHandler(c, std::bind(&NotificationInstance::x, this, _1, _2));
- REGISTER_SYNC("NotificationManager_get", NotificationManagerGet);
- REGISTER_SYNC("NotificationManager_update", NotificationManagerUpdate);
- REGISTER_SYNC("NotificationManager_remove", NotificationManagerRemove);
- REGISTER_SYNC("NotificationManager_getAll", NotificationManagerGetAll);
- REGISTER_SYNC("NotificationManager_post", NotificationManagerPost);
- REGISTER_SYNC("NotificationManager_removeAll", NotificationManagerRemoveAll);
- REGISTER_SYNC("NotificationManager_playLEDCustomEffect", NotificationManagerPlayLEDCustomEffect);
- REGISTER_SYNC("NotificationManager_stopLEDCustomEffect", NotificationManagerStopLEDCustomEffect);
- REGISTER_SYNC("NotificationManager_saveNotificationAsTemplate", NotificationManagerSaveTemplate);
- REGISTER_SYNC("NotificationManager_createNotificationFromTemplate",
- NotificationManagerCreateFromTemplate);
-#undef REGISTER_SYNC
+
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&NotificationInstance::M, this, _1, _2))
+ REGISTER_METHOD(NotificationManagerGet);
+ REGISTER_METHOD(NotificationManagerUpdate);
+ REGISTER_METHOD(NotificationManagerRemove);
+ REGISTER_METHOD(NotificationManagerGetAll);
+ REGISTER_METHOD(NotificationManagerPost);
+ REGISTER_METHOD(NotificationManagerRemoveAll);
+ REGISTER_METHOD(NotificationManagerPlayLEDCustomEffect);
+ REGISTER_METHOD(NotificationManagerStopLEDCustomEffect);
+ REGISTER_METHOD(NotificationManagerSaveNotificationAsTemplate);
+ REGISTER_METHOD(NotificationManagerCreateNotificationFromTemplate);
+#undef REGISTER_METHOD
manager_ = NotificationManager::GetInstance();
}
}
}
-void NotificationInstance::NotificationManagerSaveTemplate(const picojson::value& args,
+void NotificationInstance::NotificationManagerSaveNotificationAsTemplate(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
}
}
-void NotificationInstance::NotificationManagerCreateFromTemplate(const picojson::value& args,
+void NotificationInstance::NotificationManagerCreateNotificationFromTemplate(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
void NotificationManagerPlayLEDCustomEffect(const picojson::value& args, picojson::object& out);
void NotificationManagerStopLEDCustomEffect(const picojson::value& args, picojson::object& out);
- void NotificationManagerSaveTemplate(const picojson::value& args, picojson::object& out);
- void NotificationManagerCreateFromTemplate(const picojson::value& args, picojson::object& out);
+ void NotificationManagerSaveNotificationAsTemplate(const picojson::value& args, picojson::object& out);
+ void NotificationManagerCreateNotificationFromTemplate(const picojson::value& args, picojson::object& out);
};
} // namespace notification
set: function() {},
get: function() {
if (undefined === totalSize) {
- var result = native_.callSync('PackageManager_getTotalSize', {
+ var result = native_.callSync('PackageManagerGetTotalSize', {
id: this.id
});
if (native_.isSuccess(result)) {
set: function() {},
get: function() {
if (undefined === dataSize) {
- var result = native_.callSync('PackageManager_getDataSize', {
+ var result = native_.callSync('PackageManagerGetDataSize', {
id: this.id
});
if (native_.isSuccess(result)) {
progressCallbackId: progressCallbackId
};
- var result = native_.call('PackageManager_install', nativeParam, function(result) {
+ var result = native_.call('PackageManagerInstall', nativeParam, function(result) {
if (native_.isFailure(result)) {
native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
delete callbacks[result['progressCallbackId']];
var nativeParam = { id: args.id, progressCallbackId: progressCallbackId };
- var result = native_.call('PackageManager_uninstall', nativeParam, function(result) {
+ var result = native_.call('PackageManagerUninstall', nativeParam, function(result) {
if (native_.isFailure(result)) {
native_.callIfPossible(args.errorCallback, native_.getErrorObject(result));
delete callbacks[result['progressCallbackId']];
}
]);
- var result = native_.call('PackageManager_getPackagesInfo', {}, function(result) {
+ var result = native_.call('PackageManagerGetPackagesInfo', {}, function(result) {
if (native_.isSuccess(result)) {
for (var i = 0; i < result.informationArray.length; i++) {
result.informationArray[i] = new PackageInformation(
nativeParam['id'] = args.id;
}
- var result = native_.callSync('PackageManager_getPackageInfo', nativeParam);
+ var result = native_.callSync('PackageManagerGetPackageInfo', nativeParam);
if (native_.isSuccess(result)) {
return new PackageInformation(native_.getResultObject(result));
} else {
}
]);
- var result = native_.callSync('PackageManager_setPackageInfoEventListener', {});
+ var result = native_.callSync('PackageManagerSetPackageInfoEventListener', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
var nativeParam = {};
var result = native_.callSync(
- 'PackageManager_unsetPackageInfoEventListener',
+ 'PackageManagerUnsetPackageInfoEventListener',
nativeParam
);
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&PackageInstance::x, this, _1, _2));
- REGISTER_SYNC("PackageManager_setPackageInfoEventListener",
- PackageManagerSetpackageinfoeventlistener);
- REGISTER_SYNC("PackageManager_install", PackageManagerInstall);
- REGISTER_SYNC("PackageManager_getPackagesInfo", PackageManagerGetpackagesinfo);
- REGISTER_SYNC("PackageManager_uninstall", PackageManagerUninstall);
- REGISTER_SYNC("PackageManager_unsetPackageInfoEventListener",
- PackageManagerUnsetpackageinfoeventlistener);
- REGISTER_SYNC("PackageManager_getPackageInfo", PackageManagerGetpackageinfo);
- REGISTER_SYNC("PackageManager_getTotalSize", PackageManagerGetTotalSize);
- REGISTER_SYNC("PackageManager_getDataSize", PackageManagerGetDataSize);
-#undef REGISTER_SYNC
+
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&PackageInstance::M, this, _1, _2))
+ REGISTER_METHOD(PackageManagerSetPackageInfoEventListener);
+ REGISTER_METHOD(PackageManagerInstall);
+ REGISTER_METHOD(PackageManagerGetPackagesInfo);
+ REGISTER_METHOD(PackageManagerUninstall);
+ REGISTER_METHOD(PackageManagerUnsetPackageInfoEventListener);
+ REGISTER_METHOD(PackageManagerGetPackageInfo);
+ REGISTER_METHOD(PackageManagerGetTotalSize);
+ REGISTER_METHOD(PackageManagerGetDataSize);
+#undef REGISTER_METHOD
}
PackageInstance::~PackageInstance() {
ReportSuccess(out);
}
-void PackageInstance::PackageManagerGetpackagesinfo(const picojson::value& args,
+void PackageInstance::PackageManagerGetPackagesInfo(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
TaskQueue::GetInstance().Queue<PackageUserData>(PackageThreadWork, PackageAfterWork, userData);
ReportSuccess(out);
}
-void PackageInstance::PackageManagerGetpackageinfo(const picojson::value& args,
+void PackageInstance::PackageManagerGetPackageInfo(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
Instance::PostMessage(this, result.serialize().c_str());
}
-void PackageInstance::PackageManagerSetpackageinfoeventlistener(const picojson::value& args,
+void PackageInstance::PackageManagerSetPackageInfoEventListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
ReportSuccess(out);
}
-void PackageInstance::PackageManagerUnsetpackageinfoeventlistener(const picojson::value& args,
+void PackageInstance::PackageManagerUnsetPackageInfoEventListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
void PackageManagerInstall(const picojson::value& args, picojson::object& out);
void PackageManagerUninstall(const picojson::value& args, picojson::object& out);
- void PackageManagerGetpackagesinfo(const picojson::value& args, picojson::object& out);
- void PackageManagerGetpackageinfo(const picojson::value& args, picojson::object& out);
+ void PackageManagerGetPackagesInfo(const picojson::value& args, picojson::object& out);
+ void PackageManagerGetPackageInfo(const picojson::value& args, picojson::object& out);
void PackageManagerGetTotalSize(const picojson::value& args, picojson::object& out);
void PackageManagerGetDataSize(const picojson::value& args, picojson::object& out);
- void PackageManagerSetpackageinfoeventlistener(const picojson::value& args,
+ void PackageManagerSetPackageInfoEventListener(const picojson::value& args,
picojson::object& out);
- void PackageManagerUnsetpackageinfoeventlistener(const picojson::value& args,
+ void PackageManagerUnsetPackageInfoEventListener(const picojson::value& args,
picojson::object& out);
};
function PlayerUtil() {}
PlayerUtil.prototype.getLatencyMode = function() {
- var result = native.callSync('PlayerUtil_getLatencyMode', {});
+ var result = native.callSync('PlayerUtilGetLatencyMode', {});
if (native.isSuccess(result)) {
return native.getResultObject(result);
var callArgs = {};
callArgs.latencyMode = args.latencyMode;
- var result = native.callSync('PlayerUtil_setLatencyMode', callArgs);
+ var result = native.callSync('PlayerUtilSetLatencyMode', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&PlayerUtilInstance::x, this, _1))
- REGISTER_SYNC("PlayerUtil_getLatencyMode", GetLatencyMode);
- REGISTER_SYNC("PlayerUtil_setLatencyMode", SetLatencyMode);
-#undef REGISTER_SYNC
+
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&PlayerUtilInstance::M, this, _1))
+ REGISTER_METHOD(PlayerUtilGetLatencyMode);
+ REGISTER_METHOD(PlayerUtilSetLatencyMode);
+#undef REGISTER_METHOD
}
PlayerUtilInstance::~PlayerUtilInstance() {
ScopeLogger();
}
-common::TizenResult PlayerUtilInstance::GetLatencyMode(const picojson::object& args) {
+common::TizenResult PlayerUtilInstance::PlayerUtilGetLatencyMode(const picojson::object& args) {
ScopeLogger();
Ewk_Context* context = ewk_context_default_get();
return common::TizenSuccess{picojson::value{PlayerUtilUtils::FromLatencyMode(latency_mode)}};
}
-common::TizenResult PlayerUtilInstance::SetLatencyMode(const picojson::object& args) {
+common::TizenResult PlayerUtilInstance::PlayerUtilSetLatencyMode(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kLatencyMode);
virtual ~PlayerUtilInstance();
private:
- common::TizenResult GetLatencyMode(const picojson::object& args);
- common::TizenResult SetLatencyMode(const picojson::object& args);
+ common::TizenResult PlayerUtilGetLatencyMode(const picojson::object& args);
+ common::TizenResult PlayerUtilSetLatencyMode(const picojson::object& args);
};
} // namespace playerutil
state: args.state
};
- var ret = native_.callSync('PowerManager_request', nativeParam);
+ var ret = native_.callSync('PowerManagerRequest', nativeParam);
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
resource: args.resource
};
- var ret = native_.callSync('PowerManager_release', nativeParam);
+ var ret = native_.callSync('PowerManagerRelease', nativeParam);
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
]);
if (!screenStateChangeListener.isListenerSet()) {
- var ret = native_.callSync('PowerManager_setScreenStateChangeListener', {});
+ var ret = native_.callSync('PowerManagerSetScreenStateChangeListener', {});
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
*/
PowerManager.prototype.unsetScreenStateChangeListener = function() {
if (screenStateChangeListener.isListenerSet()) {
- var ret = native_.callSync('PowerManager_unsetScreenStateChangeListener', {});
+ var ret = native_.callSync('PowerManagerUnsetScreenStateChangeListener', {});
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
* @return {number} Current screen brightness value.
*/
PowerManager.prototype.getScreenBrightness = function() {
- var ret = native_.callSync('PowerManager_getScreenBrightness', {});
+ var ret = native_.callSync('PowerManagerGetScreenBrightness', {});
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
} else {
throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
}
- var ret = native_.callSync('PowerManager_setScreenBrightness', {
+ var ret = native_.callSync('PowerManagerSetScreenBrightness', {
brightness: args.brightness
});
if (native_.isFailure(ret)) {
* @return {boolean} true if screen is on.
*/
PowerManager.prototype.isScreenOn = function() {
- var ret = native_.callSync('PowerManager_isScreenOn', {});
+ var ret = native_.callSync('PowerManagerIsScreenOn', {});
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
} else {
* Restores the screen brightness to the system default setting value.
*/
PowerManager.prototype.restoreScreenBrightness = function() {
- var ret = native_.callSync('PowerManager_restoreScreenBrightness', {});
+ var ret = native_.callSync('PowerManagerRestoreScreenBrightness', {});
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
'next release. Use request() instead.'
);
- var ret = native_.callSync('PowerManager_turnScreenOn', {});
+ var ret = native_.callSync('PowerManagerTurnScreenOn', {});
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
'next release. Use release() instead.'
);
- var ret = native_.callSync('PowerManager_turnScreenOff', {});
+ var ret = native_.callSync('PowerManagerTurnScreenOff', {});
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&PowerInstance::x, this, _1, _2));
- REGISTER_SYNC("PowerManager_request", Request);
- REGISTER_SYNC("PowerManager_release", Release);
- REGISTER_SYNC("PowerManager_setScreenStateChangeListener", SetScreenStateChangeListener);
- REGISTER_SYNC("PowerManager_unsetScreenStateChangeListener", UnsetScreenStateChangeListener);
- REGISTER_SYNC("PowerManager_getScreenBrightness", GetScreenBrightness);
- REGISTER_SYNC("PowerManager_setScreenBrightness", SetScreenBrightness);
- REGISTER_SYNC("PowerManager_isScreenOn", IsScreenOn);
- REGISTER_SYNC("PowerManager_restoreScreenBrightness", RestoreScreenBrightness);
- REGISTER_SYNC("PowerManager_turnScreenOn", TurnScreenOn);
- REGISTER_SYNC("PowerManager_turnScreenOff", TurnScreenOff);
-#undef REGISTER_SYNC
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&PowerInstance::M, this, _1, _2))
+ REGISTER_METHOD(PowerManagerRequest);
+ REGISTER_METHOD(PowerManagerRelease);
+ REGISTER_METHOD(PowerManagerSetScreenStateChangeListener);
+ REGISTER_METHOD(PowerManagerUnsetScreenStateChangeListener);
+ REGISTER_METHOD(PowerManagerGetScreenBrightness);
+ REGISTER_METHOD(PowerManagerSetScreenBrightness);
+ REGISTER_METHOD(PowerManagerIsScreenOn);
+ REGISTER_METHOD(PowerManagerRestoreScreenBrightness);
+ REGISTER_METHOD(PowerManagerTurnScreenOn);
+ REGISTER_METHOD(PowerManagerTurnScreenOff);
+#undef REGISTER_METHOD
}
PowerInstance::~PowerInstance() {
return; \
}
-void PowerInstance::Request(const picojson::value& args, picojson::object& out) {
+void PowerInstance::PowerManagerRequest(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePower, &out);
}
}
-void PowerInstance::Release(const picojson::value& args, picojson::object& out) {
+void PowerInstance::PowerManagerRelease(const picojson::value& args, picojson::object& out) {
ScopeLogger();
const std::string& resource = args.get("resource").get<std::string>();
PlatformResult result = manager_.Release(kPowerResourceMap.at(resource));
}
}
-void PowerInstance::SetScreenStateChangeListener(const picojson::value& args,
+void PowerInstance::PowerManagerSetScreenStateChangeListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
PlatformResult result = manager_.SetScreenStateChangeListener();
}
}
-void PowerInstance::UnsetScreenStateChangeListener(const picojson::value& args,
+void PowerInstance::PowerManagerUnsetScreenStateChangeListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
PlatformResult result = manager_.UnsetScreenStateChangeListener();
}
}
-void PowerInstance::GetScreenBrightness(const picojson::value& args, picojson::object& out) {
+void PowerInstance::PowerManagerGetScreenBrightness(const picojson::value& args, picojson::object& out) {
ScopeLogger();
double brightness;
PlatformResult result = manager_.GetScreenBrightness(&brightness);
}
}
-void PowerInstance::SetScreenBrightness(const picojson::value& args, picojson::object& out) {
+void PowerInstance::PowerManagerSetScreenBrightness(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePower, &out);
}
}
-void PowerInstance::IsScreenOn(const picojson::value& args, picojson::object& out) {
+void PowerInstance::PowerManagerIsScreenOn(const picojson::value& args, picojson::object& out) {
ScopeLogger();
bool state = false;
PlatformResult result = manager_.IsScreenOn(&state);
}
}
-void PowerInstance::RestoreScreenBrightness(const picojson::value& args, picojson::object& out) {
+void PowerInstance::PowerManagerRestoreScreenBrightness(const picojson::value& args, picojson::object& out) {
ScopeLogger();
PlatformResult result = manager_.RestoreScreenBrightness();
if (result.IsError()) {
}
}
-void PowerInstance::TurnScreenOn(const picojson::value& args, picojson::object& out) {
+void PowerInstance::PowerManagerTurnScreenOn(const picojson::value& args, picojson::object& out) {
ScopeLogger();
LoggerW(
"DEPRECATION WARNING: turnScreenOn() is deprecated and will be removed from next release. "
}
}
-void PowerInstance::TurnScreenOff(const picojson::value& args, picojson::object& out) {
+void PowerInstance::PowerManagerTurnScreenOff(const picojson::value& args, picojson::object& out) {
ScopeLogger();
LoggerW(
"DEPRECATION WARNING: turnScreenOff() is deprecated and will be removed from next release. "
virtual ~PowerInstance();
private:
- void Request(const picojson::value& args, picojson::object& out);
- void Release(const picojson::value& args, picojson::object& out);
- void SetScreenStateChangeListener(const picojson::value& args, picojson::object& out);
- void UnsetScreenStateChangeListener(const picojson::value& args, picojson::object& out);
- void GetScreenBrightness(const picojson::value& args, picojson::object& out);
- void SetScreenBrightness(const picojson::value& args, picojson::object& out);
- void IsScreenOn(const picojson::value& args, picojson::object& out);
- void RestoreScreenBrightness(const picojson::value& args, picojson::object& out);
- void TurnScreenOn(const picojson::value& args, picojson::object& out);
- void TurnScreenOff(const picojson::value& args, picojson::object& out);
+ void PowerManagerRequest(const picojson::value& args, picojson::object& out);
+ void PowerManagerRelease(const picojson::value& args, picojson::object& out);
+ void PowerManagerSetScreenStateChangeListener(const picojson::value& args, picojson::object& out);
+ void PowerManagerUnsetScreenStateChangeListener(const picojson::value& args, picojson::object& out);
+ void PowerManagerGetScreenBrightness(const picojson::value& args, picojson::object& out);
+ void PowerManagerSetScreenBrightness(const picojson::value& args, picojson::object& out);
+ void PowerManagerIsScreenOn(const picojson::value& args, picojson::object& out);
+ void PowerManagerRestoreScreenBrightness(const picojson::value& args, picojson::object& out);
+ void PowerManagerTurnScreenOn(const picojson::value& args, picojson::object& out);
+ void PowerManagerTurnScreenOff(const picojson::value& args, picojson::object& out);
PowerManager manager_;
};
privilege: args.privilege
};
- var result = native_.callSync('PPMManager_checkPermission', callArgs);
+ var result = native_.callSync('PPMManagerCheckPermission', callArgs);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
privileges: args.privileges
};
- var result = native_.callSync('PPMManager_checkPermissions', callArgs);
+ var result = native_.callSync('PPMManagerCheckPermissions', callArgs);
var data = [];
privilege: args.privilege
};
- var result = native_.call('PPMManager_requestPermission', callArgs, callback);
+ var result = native_.call('PPMManagerRequestPermission', callArgs, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
privileges: args.privileges
};
- var result = native_.call('PPMManager_requestPermissions', callArgs, callback);
+ var result = native_.call('PPMManagerRequestPermissions', callArgs, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER(c, x) RegisterSyncHandler(c, std::bind(&PPMInstance::x, this, _1, _2));
- REGISTER("PPMManager_checkPermission", checkPermission);
- REGISTER("PPMManager_checkPermissions", checkPermissions);
- REGISTER("PPMManager_requestPermission", requestPermission);
- REGISTER("PPMManager_requestPermissions", requestPermissions);
-#undef REGISTER
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&PPMInstance::M, this, _1, _2))
+ REGISTER_METHOD(PPMManagerCheckPermission);
+ REGISTER_METHOD(PPMManagerCheckPermissions);
+ REGISTER_METHOD(PPMManagerRequestPermission);
+ REGISTER_METHOD(PPMManagerRequestPermissions);
+#undef REGISTER_METHOD
+
}
PPMInstance::~PPMInstance() {
common::Instance::PostMessage(data->_instance, event.serialize().c_str());
}
-void PPMInstance::checkPermission(const picojson::value& args, picojson::object& out) {
+void PPMInstance::PPMManagerCheckPermission(const picojson::value& args, picojson::object& out) {
ScopeLogger();
const std::string& privilege = args.get("privilege").get<std::string>();
LoggerD("Checking privilege: %s ", privilege.c_str());
ReportSuccess(picojson::value(CheckResultToString(result)), out);
}
-void PPMInstance::checkPermissions(const picojson::value& args, picojson::object& out) {
+void PPMInstance::PPMManagerCheckPermissions(const picojson::value& args, picojson::object& out) {
ScopeLogger();
const picojson::array& privileges = args.get("privileges").get<picojson::array>();
ReportSuccess(result_array, out);
}
-void PPMInstance::requestPermission(const picojson::value& args, picojson::object& out) {
+void PPMInstance::PPMManagerRequestPermission(const picojson::value& args, picojson::object& out) {
ScopeLogger();
const double callback_id = args.get("callbackId").get<double>();
ReportSuccess(out);
}
-void PPMInstance::requestPermissions(const picojson::value& args, picojson::object& out) {
+void PPMInstance::PPMManagerRequestPermissions(const picojson::value& args, picojson::object& out) {
ScopeLogger();
const double callback_id = args.get("callbackId").get<double>();
virtual ~PPMInstance();
private:
- void checkPermission(const picojson::value& args, picojson::object& out);
- void checkPermissions(const picojson::value& args, picojson::object& out);
- void requestPermission(const picojson::value& args, picojson::object& out);
- void requestPermissions(const picojson::value& args, picojson::object& out);
+ void PPMManagerCheckPermission(const picojson::value& args, picojson::object& out);
+ void PPMManagerCheckPermissions(const picojson::value& args, picojson::object& out);
+ void PPMManagerRequestPermission(const picojson::value& args, picojson::object& out);
+ void PPMManagerRequestPermissions(const picojson::value& args, picojson::object& out);
static common::PlatformResult convertError(int err, const std::string& message = "");
static std::string CheckResultToString(ppm_check_result_e result);
}
};
- var result = native_.call('PreferenceManager_getAll', {}, callback);
+ var result = native_.call('PreferenceManagerGetAll', {}, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
{ name: 'value', type: types_.SIMPLE_TYPE }
]);
- var result = native_.callSync('PreferenceManager_setValue', {
+ var result = native_.callSync('PreferenceManagerSetValue', {
key: args.key,
value: args.value
});
PreferenceManager.prototype.getValue = function() {
var args = validator_.validateArgs(arguments, [{ name: 'key', type: types_.STRING }]);
- var result = native_.callSync('PreferenceManager_getValue', { key: args.key });
+ var result = native_.callSync('PreferenceManagerGetValue', { key: args.key });
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
PreferenceManager.prototype.remove = function() {
var args = validator_.validateArgs(arguments, [{ name: 'key', type: types_.STRING }]);
- var result = native_.callSync('PreferenceManager_remove', { key: args.key });
+ var result = native_.callSync('PreferenceManagerRemove', { key: args.key });
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
};
PreferenceManager.prototype.removeAll = function() {
- var result = native_.callSync('PreferenceManager_removeAll', {});
+ var result = native_.callSync('PreferenceManagerRemoveAll', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
PreferenceManager.prototype.exists = function() {
var args = validator_.validateArgs(arguments, [{ name: 'key', type: types_.STRING }]);
- var result = native_.callSync('PreferenceManager_exists', { key: args.key });
+ var result = native_.callSync('PreferenceManagerExists', { key: args.key });
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
{ name: 'listener', type: types_.FUNCTION }
]);
- var result = native_.callSync('PreferenceManager_setChangeListener', {
+ var result = native_.callSync('PreferenceManagerSetChangeListener', {
key: args.key
});
if (native_.isFailure(result)) {
PreferenceManager.prototype.unsetChangeListener = function() {
var args = validator_.validateArgs(arguments, [{ name: 'key', type: types_.STRING }]);
- var result = native_.callSync('PreferenceManager_unsetChangeListener', {
+ var result = native_.callSync('PreferenceManagerUnsetChangeListener', {
key: args.key
});
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER(c, x) RegisterSyncHandler(c, std::bind(&PreferenceInstance::x, this, _1));
- REGISTER("PreferenceManager_setValue", SetValue);
- REGISTER("PreferenceManager_getValue", GetValue);
- REGISTER("PreferenceManager_remove", Remove);
- REGISTER("PreferenceManager_removeAll", RemoveAll);
- REGISTER("PreferenceManager_exists", Exists);
- REGISTER("PreferenceManager_setChangeListener", SetChangeListener);
- REGISTER("PreferenceManager_unsetChangeListener", UnsetChangeListener);
-#undef REGISTER
-#define REGISTER_ASYNC(c, x) RegisterHandler(c, std::bind(&PreferenceInstance::x, this, _1, _2));
- REGISTER_ASYNC("PreferenceManager_getAll", GetAll);
-#undef REGISTER_ASYNC
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&PreferenceInstance::M, this, _1))
+ REGISTER_METHOD(PreferenceManagerSetValue);
+ REGISTER_METHOD(PreferenceManagerGetValue);
+ REGISTER_METHOD(PreferenceManagerRemove);
+ REGISTER_METHOD(PreferenceManagerRemoveAll);
+ REGISTER_METHOD(PreferenceManagerExists);
+ REGISTER_METHOD(PreferenceManagerSetChangeListener);
+ REGISTER_METHOD(PreferenceManagerUnsetChangeListener);
+#undef REGISTER_METHOD
+
+#define REGISTER_METHOD(M) \
+ RegisterHandler(#M, std::bind(&PreferenceInstance::M, this, _1, _2))
+ REGISTER_METHOD(PreferenceManagerGetAll);
+#undef REGISTER_METHOD
}
PreferenceInstance::~PreferenceInstance() {
ScopeLogger();
}
-common::TizenResult PreferenceInstance::GetAll(const picojson::object& args,
+common::TizenResult PreferenceInstance::PreferenceManagerGetAll(const picojson::object& args,
const common::AsyncToken& token) {
ScopeLogger();
return manager_.GetAll(SimplePost(token));
}
-common::TizenResult PreferenceInstance::SetValue(const picojson::object& args) {
+common::TizenResult PreferenceInstance::PreferenceManagerSetValue(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kKey)
return manager_.SetValue(key, value);
}
-common::TizenResult PreferenceInstance::GetValue(const picojson::object& args) {
+common::TizenResult PreferenceInstance::PreferenceManagerGetValue(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kKey)
return manager_.GetValue(key);
}
-common::TizenResult PreferenceInstance::Remove(const picojson::object& args) {
+common::TizenResult PreferenceInstance::PreferenceManagerRemove(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kKey)
return manager_.Remove(key);
}
-common::TizenResult PreferenceInstance::RemoveAll(const picojson::object& args) {
+common::TizenResult PreferenceInstance::PreferenceManagerRemoveAll(const picojson::object& args) {
ScopeLogger();
return manager_.RemoveAll();
}
-common::TizenResult PreferenceInstance::Exists(const picojson::object& args) {
+common::TizenResult PreferenceInstance::PreferenceManagerExists(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kKey)
return manager_.Exists(key);
}
-common::TizenResult PreferenceInstance::SetChangeListener(const picojson::object& args) {
+common::TizenResult PreferenceInstance::PreferenceManagerSetChangeListener(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kKey)
const auto& key = args.find(kKey)->second.get<std::string>();
return manager_.SetChangeListener(key, callback);
}
-common::TizenResult PreferenceInstance::UnsetChangeListener(const picojson::object& args) {
+common::TizenResult PreferenceInstance::PreferenceManagerUnsetChangeListener(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kKey)
virtual ~PreferenceInstance();
private:
- common::TizenResult GetAll(const picojson::object& args, const common::AsyncToken& token);
- common::TizenResult SetValue(const picojson::object& args);
- common::TizenResult GetValue(const picojson::object& args);
- common::TizenResult Remove(const picojson::object& args);
- common::TizenResult RemoveAll(const picojson::object& args);
- common::TizenResult Exists(const picojson::object& args);
- common::TizenResult SetChangeListener(const picojson::object& args);
- common::TizenResult UnsetChangeListener(const picojson::object& args);
+ common::TizenResult PreferenceManagerGetAll(const picojson::object& args, const common::AsyncToken& token);
+ common::TizenResult PreferenceManagerSetValue(const picojson::object& args);
+ common::TizenResult PreferenceManagerGetValue(const picojson::object& args);
+ common::TizenResult PreferenceManagerRemove(const picojson::object& args);
+ common::TizenResult PreferenceManagerRemoveAll(const picojson::object& args);
+ common::TizenResult PreferenceManagerExists(const picojson::object& args);
+ common::TizenResult PreferenceManagerSetChangeListener(const picojson::object& args);
+ common::TizenResult PreferenceManagerUnsetChangeListener(const picojson::object& args);
PreferenceManager manager_;
};
}
]);
- var ret = native.call('Push_registerService', {}, function(msg) {
+ var ret = native.call('PushRegisterService', {}, function(msg) {
if (msg.error) {
if (validatorType.isFunction(data.errorCallback)) {
data.errorCallback(native.getErrorObject(msg));
}
]);
- var ret = native.call('Push_registerApplication', {}, function(msg) {
+ var ret = native.call('PushRegisterApplication', {}, function(msg) {
if (msg.error) {
if (validatorType.isFunction(data.errorCallback)) {
data.errorCallback(native.getErrorObject(msg));
nullable: true
}
]);
- var result = native.call('Push_unregisterService', {}, function(msg) {
+ var result = native.call('PushUnregisterService', {}, function(msg) {
if (msg.error) {
if (validatorType.isFunction(data.errorCallback)) {
data.errorCallback(native.getErrorObject(msg));
nullable: true
}
]);
- var result = native.call('Push_unregisterApplication', {}, function(msg) {
+ var result = native.call('PushUnregisterApplication', {}, function(msg) {
if (msg.error) {
if (validatorType.isFunction(data.errorCallback)) {
data.errorCallback(native.getErrorObject(msg));
type: validator.Types.FUNCTION
}
]);
- var ret = native.callSync('Push_connectService', {});
+ var ret = native.callSync('PushConnectService', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
}
nullable: true
}
]);
- var result = native.call('Push_connect', {}, function(msg) {
+ var result = native.call('PushConnect', {}, function(msg) {
// in case of error, call errorCallback
if (msg.error) {
if (validatorType.isFunction(data.errorCallback)) {
'DEPRECATION WARNING: disconnectService() is deprecated and will be removed' +
'from next release. Use disconnect() instead.'
);
- var ret = native.callSync('Push_disconnectService', {});
+ var ret = native.callSync('PushDisconnectService', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
}
};
PushManager.prototype.disconnect = function() {
- var ret = native.callSync('Push_disconnect', {});
+ var ret = native.callSync('PushDisconnect', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
}
};
PushManager.prototype.getRegistrationId = function() {
- var ret = native.callSync('Push_getRegistrationId', {});
+ var ret = native.callSync('PushGetRegistrationId', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
}
};
PushManager.prototype.getUnreadNotifications = function() {
- var ret = native.callSync('Push_getUnreadNotifications', {});
+ var ret = native.callSync('PushGetUnreadNotifications', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
}
};
PushManager.prototype.getPushMessage = function() {
- var ret = native.callSync('Push_getPushMessage', {});
+ var ret = native.callSync('PushGetPushMessage', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
} else {
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_ASYNC(c, func) RegisterSyncHandler(c, func);
-#define REGISTER_SYNC(c, func) RegisterSyncHandler(c, func);
-
- REGISTER_ASYNC("Push_registerService", std::bind(&PushInstance::registerService, this, _1, _2));
- REGISTER_ASYNC("Push_registerApplication",
- std::bind(&PushInstance::registerApplication, this, _1, _2));
- REGISTER_ASYNC("Push_unregisterService",
- std::bind(&PushInstance::unregisterService, this, _1, _2));
- REGISTER_ASYNC("Push_unregisterApplication",
- std::bind(&PushInstance::unregisterApplication, this, _1, _2));
- REGISTER_SYNC("Push_connectService", std::bind(&PushInstance::connectService, this, _1, _2));
- REGISTER_SYNC("Push_connect", std::bind(&PushInstance::connect, this, _1, _2));
- REGISTER_SYNC("Push_disconnectService",
- std::bind(&PushInstance::disconnectService, this, _1, _2));
- REGISTER_SYNC("Push_disconnect", std::bind(&PushInstance::disconnect, this, _1, _2));
- REGISTER_SYNC("Push_getRegistrationId",
- std::bind(&PushInstance::getRegistrationId, this, _1, _2));
- REGISTER_SYNC("Push_getUnreadNotifications",
- std::bind(&PushInstance::getUnreadNotifications, this, _1, _2));
- REGISTER_SYNC("Push_getPushMessage", std::bind(&PushInstance::getPushMessage, this, _1, _2));
-
-#undef REGISTER_ASYNC
-#undef REGISTER_SYNC
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&PushInstance::M, this, _1, _2))
+ REGISTER_METHOD(PushRegisterService);
+ REGISTER_METHOD(PushRegisterApplication);
+ REGISTER_METHOD(PushUnregisterService);
+ REGISTER_METHOD(PushUnregisterApplication);
+ REGISTER_METHOD(PushConnectService);
+ REGISTER_METHOD(PushConnect);
+ REGISTER_METHOD(PushDisconnectService);
+ REGISTER_METHOD(PushDisconnect);
+ REGISTER_METHOD(PushGetRegistrationId);
+ REGISTER_METHOD(PushGetUnreadNotifications);
+ REGISTER_METHOD(PushGetPushMessage);
+#undef REGISTER_METHOD
impl = new PushManager(this);
}
-void PushInstance::registerService(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushRegisterService(const picojson::value& args, picojson::object& out) {
ScopeLogger();
LoggerW(
"DEPRECATION WARNING: registerService() is deprecated and will be removed from next release. "
}
}
-void PushInstance::registerApplication(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushRegisterApplication(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
}
-void PushInstance::unregisterService(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushUnregisterService(const picojson::value& args, picojson::object& out) {
ScopeLogger();
LoggerW(
"DEPRECATION WARNING: unregisterService() is deprecated and will be removed from next "
}
}
-void PushInstance::unregisterApplication(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushUnregisterApplication(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
}
-void PushInstance::connectService(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushConnectService(const picojson::value& args, picojson::object& out) {
ScopeLogger();
LoggerW(
"DEPRECATION WARNING: connectService() is deprecated and will be removed from next release. "
}
}
-void PushInstance::connect(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushConnect(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
}
-void PushInstance::disconnectService(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushDisconnectService(const picojson::value& args, picojson::object& out) {
ScopeLogger();
LoggerW(
"DEPRECATION WARNING: disconnectService() is deprecated and will be removed from next "
}
}
-void PushInstance::disconnect(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushDisconnect(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
}
-void PushInstance::getRegistrationId(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushGetRegistrationId(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
}
-void PushInstance::getUnreadNotifications(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushGetUnreadNotifications(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
}
-void PushInstance::getPushMessage(const picojson::value& args, picojson::object& out) {
+void PushInstance::PushGetPushMessage(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
virtual void onDeregister(double callbackId, common::PlatformResult result);
private:
- void registerService(const picojson::value& args, picojson::object& out);
- void registerApplication(const picojson::value& args, picojson::object& out);
- void unregisterService(const picojson::value& args, picojson::object& out);
- void unregisterApplication(const picojson::value& args, picojson::object& out);
- void connectService(const picojson::value& args, picojson::object& out);
- void connect(const picojson::value& args, picojson::object& out);
- void disconnectService(const picojson::value& args, picojson::object& out);
- void disconnect(const picojson::value& args, picojson::object& out);
- void getRegistrationId(const picojson::value& args, picojson::object& out);
- void getUnreadNotifications(const picojson::value& args, picojson::object& out);
- void getPushMessage(const picojson::value& args, picojson::object& out);
+ void PushRegisterService(const picojson::value& args, picojson::object& out);
+ void PushRegisterApplication(const picojson::value& args, picojson::object& out);
+ void PushUnregisterService(const picojson::value& args, picojson::object& out);
+ void PushUnregisterApplication(const picojson::value& args, picojson::object& out);
+ void PushConnectService(const picojson::value& args, picojson::object& out);
+ void PushConnect(const picojson::value& args, picojson::object& out);
+ void PushDisconnectService(const picojson::value& args, picojson::object& out);
+ void PushDisconnect(const picojson::value& args, picojson::object& out);
+ void PushGetRegistrationId(const picojson::value& args, picojson::object& out);
+ void PushGetUnreadNotifications(const picojson::value& args, picojson::object& out);
+ void PushGetPushMessage(const picojson::value& args, picojson::object& out);
PushManager* impl;
};
});
function muteGetter() {
- var ret = native_.callSync('FMRadio_MuteGetter');
+ var ret = native_.callSync('FMRadioMuteGetter');
return native_.getResultObject(ret);
}
type: types_.BOOLEAN
}
]);
- native_.callSync('FMRadio_MuteSetter', args);
+ native_.callSync('FMRadioMuteSetter', args);
}
function radioStateGetter() {
- var ret = native_.callSync('FMRadio_RadioStateGetter');
+ var ret = native_.callSync('FMRadioRadioStateGetter');
return native_.getResultObject(ret);
}
function isAntennaConnectedGetter() {
- var ret = native_.callSync('FMRadio_IsAntennaConnectedGetter');
+ var ret = native_.callSync('FMRadioIsAntennaConnectedGetter');
return native_.getResultObject(ret);
}
function signalStrengthGetter() {
- var ret = native_.callSync('FMRadio_SignalStrengthGetter');
+ var ret = native_.callSync('FMRadioSignalStrengthGetter');
return native_.getResultObject(ret);
}
function frequencyGetter() {
- var ret = native_.callSync('FMRadio_FrequencyGetter');
+ var ret = native_.callSync('FMRadioFrequencyGetter');
return native_.getResultObject(ret);
}
}
]);
- native_.call('FMRadio_SeekUp', {}, function(result) {
+ native_.call('FMRadioSeekUp', {}, function(result) {
if (native_.isFailure(result)) {
if (args.errorCallback) args.errorCallback(native_.getErrorObject(result));
} else {
'Frequency out of bounds'
);
}
- var result = native_.callSync('FMRadio_Start', {
+ var result = native_.callSync('FMRadioStart', {
frequency: args.frequency ? args.frequency : this.frequencyLowerBound
});
if (native_.isFailure(result)) {
}
]);
- native_.call('FMRadio_SeekDown', {}, function(result) {
+ native_.call('FMRadioSeekDown', {}, function(result) {
if (native_.isFailure(result)) {
if (args.errorCallback) args.errorCallback(native_.getErrorObject(result));
} else {
scanCBmanager.FMRadioScanSet(args.radioScanCallback.onfrequencyfound);
- native_.call('FMRadio_ScanStart', {}, function(result) {
+ native_.call('FMRadioScanStart', {}, function(result) {
if (native_.isFailure(result)) {
if (args.errorCallback) args.errorCallback(native_.getErrorObject(result));
} else {
};
FMRadioManager.prototype.stop = function() {
- var ret = native_.callSync('FMRadio_Stop');
+ var ret = native_.callSync('FMRadioStop');
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
}
]);
- native_.call('FMRadio_ScanStop', {}, function(result) {
+ native_.call('FMRadioScanStop', {}, function(result) {
if (native_.isFailure(result)) {
if (args.errorCallback) args.errorCallback(native_.getErrorObject(result));
} else {
args.interruptCallback.oninterruptfinished
);
- var ret = native_.callSync('FMRadio_SetFMRadioInterruptedListener');
+ var ret = native_.callSync('SetFMRadioInterruptedListener');
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
FMRadioManager.prototype.unsetFMRadioInterruptedListener = function() {
interruptedCBmanager.FMRadioInterruptedUnset();
- var ret = native_.callSync('FMRadio_UnsetFMRadioInterruptedListener');
+ var ret = native_.callSync('UnsetFMRadioInterruptedListener');
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
]);
antennaCBmanager.FMRadioAntennaChangeSet(args.changeCallback);
- var ret = native_.callSync('FMRadio_SetAntennaChangeListener');
+ var ret = native_.callSync('FMRadioSetAntennaChangeListener');
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
FMRadioManager.prototype.unsetAntennaChangeListener = function() {
antennaCBmanager.FMRadioAntennaUnset();
- var ret = native_.callSync('FMRadio_UnsetAntennaChangeListener');
+ var ret = native_.callSync('FMRadioUnsetAntennaChangeListener');
if (native_.isFailure(ret)) {
throw native_.getErrorObject(ret);
}
*/
#include "radio/radio_instance.h"
-
#include <functional>
-
#include <radio.h>
-
#include "common/logger.h"
namespace extension {
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&RadioInstance::x, this, _1, _2));
-
- REGISTER_SYNC("FMRadio_Start", Start);
- REGISTER_SYNC("FMRadio_Stop", Stop);
- REGISTER_SYNC("FMRadio_SetFMRadioInterruptedListener", SetFMRadioInterruptedListener);
- REGISTER_SYNC("FMRadio_UnsetFMRadioInterruptedListener", UnsetFMRadioInterruptedListener);
- REGISTER_SYNC("FMRadio_SetAntennaChangeListener", SetAntennaChangeListener);
- REGISTER_SYNC("FMRadio_UnsetAntennaChangeListener", UnsetAntennaChangeListener);
- REGISTER_SYNC("FMRadio_FrequencyGetter", FrequencyGetter);
- REGISTER_SYNC("FMRadio_SignalStrengthGetter", SignalStrengthGetter);
- REGISTER_SYNC("FMRadio_IsAntennaConnectedGetter", AntennaGetter);
- REGISTER_SYNC("FMRadio_RadioStateGetter", StateGetter);
- REGISTER_SYNC("FMRadio_MuteSetter", MuteSetter);
- REGISTER_SYNC("FMRadio_MuteGetter", MuteGetter);
-#undef REGISTER_SYNC
-#define REGISTER_ASYNC(c, x) RegisterSyncHandler(c, std::bind(&RadioInstance::x, this, _1, _2));
- REGISTER_ASYNC("FMRadio_SeekUp", SeekUp);
- REGISTER_ASYNC("FMRadio_SeekDown", SeekDown);
- REGISTER_ASYNC("FMRadio_ScanStart", ScanStart);
- REGISTER_ASYNC("FMRadio_ScanStop", ScanStop);
-#undef REGISTER_ASYNC
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&RadioInstance::M, this, _1, _2))
+ REGISTER_METHOD(FMRadioStart);
+ REGISTER_METHOD(FMRadioStop);
+ REGISTER_METHOD(SetFMRadioInterruptedListener);
+ REGISTER_METHOD(UnsetFMRadioInterruptedListener);
+ REGISTER_METHOD(FMRadioSetAntennaChangeListener);
+ REGISTER_METHOD(FMRadioUnsetAntennaChangeListener);
+ REGISTER_METHOD(FMRadioFrequencyGetter);
+ REGISTER_METHOD(FMRadioSignalStrengthGetter);
+ REGISTER_METHOD(FMRadioIsAntennaConnectedGetter);
+ REGISTER_METHOD(FMRadioRadioStateGetter);
+ REGISTER_METHOD(FMRadioMuteSetter);
+ REGISTER_METHOD(FMRadioMuteGetter);
+
+ REGISTER_METHOD(FMRadioSeekUp);
+ REGISTER_METHOD(FMRadioSeekDown);
+ REGISTER_METHOD(FMRadioScanStart);
+ REGISTER_METHOD(FMRadioScanStop);
+#undef REGISTER_METHOD
}
RadioInstance::~RadioInstance() {
ScopeLogger();
}
-void RadioInstance::MuteGetter(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioMuteGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
ReportSuccess(picojson::value(manager_.IsMuted()), out);
}
-void RadioInstance::MuteSetter(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioMuteSetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
manager_.SetMute(args.get("mute").get<bool>());
ReportSuccess(out);
}
-void RadioInstance::AntennaGetter(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioIsAntennaConnectedGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
ReportSuccess(picojson::value(manager_.HasAntenna()), out);
}
-void RadioInstance::StateGetter(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioRadioStateGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
ReportSuccess(picojson::value(manager_.GetState()), out);
}
-void RadioInstance::FrequencyGetter(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioFrequencyGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
ReportSuccess(picojson::value(manager_.GetFrequency()), out);
}
-void RadioInstance::SignalStrengthGetter(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioSignalStrengthGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
ReportSuccess(picojson::value(manager_.GetSignalStrength()), out);
}
-void RadioInstance::SeekUp(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioSeekUp(const picojson::value& args, picojson::object& out) {
ScopeLogger();
manager_.SeekUp(args.get("callbackId").get<double>());
ReportSuccess(out);
}
-void RadioInstance::SeekDown(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioSeekDown(const picojson::value& args, picojson::object& out) {
ScopeLogger();
manager_.SeekDown(args.get("callbackId").get<double>());
ReportSuccess(out);
}
-void RadioInstance::Start(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioStart(const picojson::value& args, picojson::object& out) {
ScopeLogger();
PlatformResult result = manager_.Start(args.get("frequency").get<double>());
}
}
-void RadioInstance::Stop(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioStop(const picojson::value& args, picojson::object& out) {
ScopeLogger();
PlatformResult result = manager_.Stop();
}
}
-void RadioInstance::ScanStart(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioScanStart(const picojson::value& args, picojson::object& out) {
ScopeLogger();
manager_.ScanStart(args.get("callbackId").get<double>());
ReportSuccess(out);
}
-void RadioInstance::ScanStop(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioScanStop(const picojson::value& args, picojson::object& out) {
ScopeLogger();
manager_.ScanStop(args.get("callbackId").get<double>());
ReportSuccess(out);
}
}
-void RadioInstance::SetAntennaChangeListener(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioSetAntennaChangeListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
PlatformResult result = manager_.SetAntennaChangeListener();
}
}
-void RadioInstance::UnsetAntennaChangeListener(const picojson::value& args, picojson::object& out) {
+void RadioInstance::FMRadioUnsetAntennaChangeListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
PlatformResult result = manager_.UnsetAntennaChangeListener();
virtual ~RadioInstance();
private:
- void MuteGetter(const picojson::value& args, picojson::object& out);
- void MuteSetter(const picojson::value& args, picojson::object& out);
- void FrequencyGetter(const picojson::value& args, picojson::object& out);
- void SignalStrengthGetter(const picojson::value& args, picojson::object& out);
- void AntennaGetter(const picojson::value& args, picojson::object& out);
- void StateGetter(const picojson::value& args, picojson::object& out);
- void SeekUp(const picojson::value& args, picojson::object& out);
- void SeekDown(const picojson::value& args, picojson::object& out);
- void ScanStart(const picojson::value& args, picojson::object& out);
- void ScanStop(const picojson::value& args, picojson::object& out);
- void Start(const picojson::value& args, picojson::object& out);
- void Stop(const picojson::value& args, picojson::object& out);
+ void FMRadioMuteGetter(const picojson::value& args, picojson::object& out);
+ void FMRadioMuteSetter(const picojson::value& args, picojson::object& out);
+ void FMRadioFrequencyGetter(const picojson::value& args, picojson::object& out);
+ void FMRadioSignalStrengthGetter(const picojson::value& args, picojson::object& out);
+ void FMRadioIsAntennaConnectedGetter(const picojson::value& args, picojson::object& out);
+ void FMRadioRadioStateGetter(const picojson::value& args, picojson::object& out);
+ void FMRadioSeekUp(const picojson::value& args, picojson::object& out);
+ void FMRadioSeekDown(const picojson::value& args, picojson::object& out);
+ void FMRadioScanStart(const picojson::value& args, picojson::object& out);
+ void FMRadioScanStop(const picojson::value& args, picojson::object& out);
+ void FMRadioStart(const picojson::value& args, picojson::object& out);
+ void FMRadioStop(const picojson::value& args, picojson::object& out);
void SetFMRadioInterruptedListener(const picojson::value& args, picojson::object& out);
void UnsetFMRadioInterruptedListener(const picojson::value& args, picojson::object& out);
- void SetAntennaChangeListener(const picojson::value& args, picojson::object& out);
- void UnsetAntennaChangeListener(const picojson::value& args, picojson::object& out);
+ void FMRadioSetAntennaChangeListener(const picojson::value& args, picojson::object& out);
+ void FMRadioUnsetAntennaChangeListener(const picojson::value& args, picojson::object& out);
FMRadioManager manager_;
};
var id = this.nextId;
if (!this.nativeSet) {
this.native.addListener(this.listenerName, this.onListenerCalled.bind(this));
- var result = this.native.callSync('SEService_registerSEListener');
+ var result = this.native.callSync('SEServiceRegisterSEListener');
if (this.native.isFailure(result)) {
throw this.native.getErrorObject(result);
}
}
if (this.nativeSet && type_utils.isEmptyObject(this.listeners)) {
- var result = this.native.callSync('SEService_unregisterSEListener');
+ var result = this.native.callSync('SEServiceUnregisterSEListener');
if (this.native.isFailure(result)) {
throw this.native.getErrorObject(result);
}
}
};
- var result = native_.call('SEService_getReaders', {}, callback);
+ var result = native_.call('SEServiceGetReaders', {}, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
var SEServiceShutdown = function() {
xwalk.utils.checkPrivilegeAccess(xwalk.utils.privilege.SECUREELEMENT);
- var result = native_.callSync('SEService_shutdown', {});
+ var result = native_.callSync('SEServiceShutdown', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
set: function() {},
get: function() {
var callArgs = { handle: reader_handle };
- var result = native_.callSync('SEReader_isPresent', callArgs);
+ var result = native_.callSync('SEReaderIsPresent', callArgs);
if (native_.isFailure(result)) {
privUtils_.log(
'SEReader_isPresent error: ' + native_.getErrorObject(result)
Reader.prototype.getName = function() {
var callArgs = { handle: this._handle };
- var result = native_.callSync('SEReader_getName', callArgs);
+ var result = native_.callSync('SEReaderGetName', callArgs);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
var callArgs = { handle: this._handle };
- var result = native_.call('SEReader_openSession', callArgs, callback);
+ var result = native_.call('SEReaderOpenSession', callArgs, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
Reader.prototype.closeSessions = function() {
var callArgs = { handle: this._handle };
- var result = native_.callSync('SEReader_closeSessions', callArgs);
+ var result = native_.callSync('SEReaderCloseSessions', callArgs);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
Channel.prototype.close = function() {
var callArgs = { handle: this._handle };
- var result = native_.callSync('SEChannel_close', callArgs);
+ var result = native_.callSync('SEChannelClose', callArgs);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
command: args.command
};
- var result = native_.call('SEChannel_transmit', callArgs, callback);
+ var result = native_.call('SEChannelTransmit', callArgs, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
Channel.prototype.getSelectResponse = function() {
var callArgs = { handle: this._handle };
- var result = native_.callSync('SEChannel_getSelectResponse', callArgs);
+ var result = native_.callSync('SEChannelGetSelectResponse', callArgs);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
set: function() {},
get: function() {
var callArgs = { handle: session_handle };
- var result = native_.callSync('SESession_isClosed', callArgs);
+ var result = native_.callSync('SESessionIsClosed', callArgs);
if (native_.isFailure(result)) {
privUtils_.log(
'SESession_isClosed error: ' + native_.getErrorObject(result)
aid: args.aid
};
- var result = native_.call('SESession_openBasicChannel', callArgs, callback);
+ var result = native_.call('SESessionOpenBasicChannel', callArgs, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
aid: args.aid
};
- var result = native_.call('SESession_openLogicalChannel', callArgs, callback);
+ var result = native_.call('SESessionOpenLogicalChannel', callArgs, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
Session.prototype.getATR = function() {
var callArgs = { handle: this._handle };
- var result = native_.callSync('SESession_getATR', callArgs);
+ var result = native_.callSync('SESessionGetATR', callArgs);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
} else {
Session.prototype.close = function() {
var callArgs = { handle: this._handle };
- var result = native_.callSync('SESession_close', callArgs);
+ var result = native_.callSync('SESessionClose', callArgs);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
Session.prototype.closeChannels = function() {
var callArgs = { handle: this._handle };
- var result = native_.callSync('SESession_closeChannels', callArgs);
+ var result = native_.callSync('SESessionCloseChannels', callArgs);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&SecureElementInstance::x, this, _1));
-
- REGISTER_SYNC("SEService_registerSEListener", RegisterSEListener);
- REGISTER_SYNC("SEService_unregisterSEListener", UnregisterSEListener);
- REGISTER_SYNC("SEService_shutdown", Shutdown);
- REGISTER_SYNC("SEReader_getName", GetName);
- REGISTER_SYNC("SEReader_isPresent", IsPresent);
- REGISTER_SYNC("SEReader_closeSessions", CloseSessions);
- REGISTER_SYNC("SESession_getATR", GetATR);
- REGISTER_SYNC("SESession_isClosed", IsSessionClosed);
- REGISTER_SYNC("SESession_close", CloseSession);
- REGISTER_SYNC("SESession_closeChannels", CloseChannels);
- REGISTER_SYNC("SEChannel_close", CloseChannel);
- REGISTER_SYNC("SEChannel_getSelectResponse", GetSelectResponse);
-#undef REGISTER_SYNC
-
-#define REGISTER(c, x) RegisterHandler(c, std::bind(&SecureElementInstance::x, this, _1, _2));
-
- REGISTER("SEService_getReaders", GetReaders);
- REGISTER("SEReader_openSession", OpenSession);
- REGISTER("SESession_openBasicChannel", OpenBasicChannel);
- REGISTER("SESession_openLogicalChannel", OpenLogicalChannel);
- REGISTER("SEChannel_transmit", Transmit);
-#undef REGISTER
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&SecureElementInstance::M, this, _1))
+ REGISTER_METHOD(SEServiceRegisterSEListener);
+ REGISTER_METHOD(SEServiceUnregisterSEListener);
+ REGISTER_METHOD(SEServiceShutdown);
+ REGISTER_METHOD(SEReaderGetName);
+ REGISTER_METHOD(SEReaderIsPresent);
+ REGISTER_METHOD(SEReaderCloseSessions);
+ REGISTER_METHOD(SESessionGetATR);
+ REGISTER_METHOD(SESessionIsClosed);
+ REGISTER_METHOD(SESessionClose);
+ REGISTER_METHOD(SESessionCloseChannels);
+ REGISTER_METHOD(SEChannelClose);
+ REGISTER_METHOD(SEChannelGetSelectResponse);
+#undef REGISTER_METHOD
+
+#define REGISTER_METHOD(M) \
+ RegisterHandler(#M, std::bind(&SecureElementInstance::M, this, _1, _2))
+ REGISTER_METHOD(SEServiceGetReaders);
+ REGISTER_METHOD(SEReaderOpenSession);
+ REGISTER_METHOD(SESessionOpenBasicChannel);
+ REGISTER_METHOD(SESessionOpenLogicalChannel);
+ REGISTER_METHOD(SEChannelTransmit);
+#undef REGISTER_METHOD
if (SMARTCARD_ERROR_NONE == smartcard_initialize()) {
is_initialized_ = true;
}
// Service methods
-TizenResult SecureElementInstance::GetReaders(picojson::object const& args,
+TizenResult SecureElementInstance::SEServiceGetReaders(picojson::object const& args,
const common::AsyncToken& token) {
ScopeLogger();
return TizenSuccess();
}
-TizenResult SecureElementInstance::RegisterSEListener(picojson::object const& args) {
+TizenResult SecureElementInstance::SEServiceRegisterSEListener(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
return TizenSuccess();
}
-TizenResult SecureElementInstance::UnregisterSEListener(picojson::object const& args) {
+TizenResult SecureElementInstance::SEServiceUnregisterSEListener(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
return TizenSuccess();
}
-TizenResult SecureElementInstance::Shutdown(picojson::object const& args) {
+TizenResult SecureElementInstance::SEServiceShutdown(picojson::object const& args) {
ScopeLogger();
UnregisterListener();
}
// Reader methods
-TizenResult SecureElementInstance::GetName(picojson::object const& args) {
+TizenResult SecureElementInstance::SEReaderGetName(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
return TizenSuccess(picojson::value(name));
}
-TizenResult SecureElementInstance::IsPresent(picojson::object const& args) {
+TizenResult SecureElementInstance::SEReaderIsPresent(picojson::object const& args) {
ScopeLogger();
int reader = static_cast<int>(args.find(kHandle)->second.get<double>());
return TizenSuccess(picojson::value(is_present));
}
-TizenResult SecureElementInstance::OpenSession(picojson::object const& args,
+TizenResult SecureElementInstance::SEReaderOpenSession(picojson::object const& args,
const common::AsyncToken& token) {
ScopeLogger();
return TizenSuccess();
}
-TizenResult SecureElementInstance::CloseSessions(picojson::object const& args) {
+TizenResult SecureElementInstance::SEReaderCloseSessions(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
return TizenSuccess(val);
}
-TizenResult SecureElementInstance::OpenBasicChannel(picojson::object const& args,
+TizenResult SecureElementInstance::SESessionOpenBasicChannel(picojson::object const& args,
const common::AsyncToken& token) {
ScopeLogger();
return TizenSuccess();
}
-TizenResult SecureElementInstance::OpenLogicalChannel(picojson::object const& args,
+TizenResult SecureElementInstance::SESessionOpenLogicalChannel(picojson::object const& args,
const common::AsyncToken& token) {
ScopeLogger();
return TizenSuccess();
}
-TizenResult SecureElementInstance::GetATR(picojson::object const& args) {
+TizenResult SecureElementInstance::SESessionGetATR(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
return TizenSuccess(response);
}
-TizenResult SecureElementInstance::IsSessionClosed(picojson::object const& args) {
+TizenResult SecureElementInstance::SESessionIsClosed(picojson::object const& args) {
ScopeLogger();
int session = static_cast<int>(args.find(kHandle)->second.get<double>());
return TizenSuccess(picojson::value(is_closed));
}
-TizenResult SecureElementInstance::CloseSession(picojson::object const& args) {
+TizenResult SecureElementInstance::SESessionClose(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
return TizenSuccess();
}
-TizenResult SecureElementInstance::CloseChannels(picojson::object const& args) {
+TizenResult SecureElementInstance::SESessionCloseChannels(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
}
// Channel methods
-TizenResult SecureElementInstance::CloseChannel(picojson::object const& args) {
+TizenResult SecureElementInstance::SEChannelClose(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
return TizenSuccess();
}
-TizenResult SecureElementInstance::Transmit(picojson::object const& args,
+TizenResult SecureElementInstance::SEChannelTransmit(picojson::object const& args,
const common::AsyncToken& token) {
ScopeLogger();
return TizenSuccess();
}
-TizenResult SecureElementInstance::GetSelectResponse(picojson::object const& args) {
+TizenResult SecureElementInstance::SEChannelGetSelectResponse(picojson::object const& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
private:
/* Service methods */
- common::TizenResult GetReaders(picojson::object const& args, const common::AsyncToken& token);
- common::TizenResult RegisterSEListener(picojson::object const& args);
- common::TizenResult UnregisterSEListener(picojson::object const& args);
- common::TizenResult Shutdown(picojson::object const& args);
+ common::TizenResult SEServiceGetReaders(picojson::object const& args, const common::AsyncToken& token);
+ common::TizenResult SEServiceRegisterSEListener(picojson::object const& args);
+ common::TizenResult SEServiceUnregisterSEListener(picojson::object const& args);
+ common::TizenResult SEServiceShutdown(picojson::object const& args);
/* Reader methods */
- common::TizenResult GetName(picojson::object const& args);
- common::TizenResult IsPresent(picojson::object const& args);
- common::TizenResult OpenSession(picojson::object const& args, const common::AsyncToken& token);
- common::TizenResult CloseSessions(picojson::object const& args);
+ common::TizenResult SEReaderGetName(picojson::object const& args);
+ common::TizenResult SEReaderIsPresent(picojson::object const& args);
+ common::TizenResult SEReaderOpenSession(picojson::object const& args, const common::AsyncToken& token);
+ common::TizenResult SEReaderCloseSessions(picojson::object const& args);
/* Session methods */
common::TizenResult IsBasicChannel(int channel, picojson::value& val);
- common::TizenResult OpenBasicChannel(picojson::object const& args,
+ common::TizenResult SESessionOpenBasicChannel(picojson::object const& args,
const common::AsyncToken& token);
- common::TizenResult OpenLogicalChannel(picojson::object const& args,
+ common::TizenResult SESessionOpenLogicalChannel(picojson::object const& args,
const common::AsyncToken& token);
- common::TizenResult GetATR(picojson::object const& args);
- common::TizenResult IsSessionClosed(picojson::object const& args);
- common::TizenResult CloseSession(picojson::object const& args);
- common::TizenResult CloseChannels(picojson::object const& args);
+ common::TizenResult SESessionGetATR(picojson::object const& args);
+ common::TizenResult SESessionIsClosed(picojson::object const& args);
+ common::TizenResult SESessionClose(picojson::object const& args);
+ common::TizenResult SESessionCloseChannels(picojson::object const& args);
/* Channel methods */
- common::TizenResult CloseChannel(picojson::object const& args);
- common::TizenResult Transmit(picojson::object const& args, const common::AsyncToken& token);
- common::TizenResult GetSelectResponse(picojson::object const& args);
+ common::TizenResult SEChannelClose(picojson::object const& args);
+ common::TizenResult SEChannelTransmit(picojson::object const& args, const common::AsyncToken& token);
+ common::TizenResult SEChannelGetSelectResponse(picojson::object const& args);
common::TizenResult Deinitialize();
common::TizenResult UnregisterListener();
projects / platform / core / api / webapi-plugins.git / commitdiff