get: function() {
var callArgs = {};
callArgs.id = this[kIdKey];
- var result = native.callSync('IotconResource_getObserverIds', callArgs);
+ var result = native.callSync('IotconResourceGetObserverIds', callArgs);
return native.getResultObject(result);
}.bind(this),
set: function() {},
callArgs.observerIds = args.observerIds;
callArgs.attributes = attributes;
- var result = native.callSync('IotconResource_notify', callArgs);
+ var result = native.callSync('IotconResourceNotify', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
callArgs.id = this[kIdKey];
callArgs.types = args.types;
- var result = native.callSync('IotconResource_addResourceTypes', callArgs);
+ var result = native.callSync('IotconResourceAddResourceTypes', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
callArgs.id = this[kIdKey];
callArgs.iface = args.iface;
- var result = native.callSync('IotconResource_addResourceInterface', callArgs);
+ var result = native.callSync('IotconResourceAddResourceInterface', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
callArgs.id = this[kIdKey];
callArgs.childId = args.resource[kIdKey];
- var result = native.callSync('IotconResource_addChildResource', callArgs);
+ var result = native.callSync('IotconResourceAddChildResource', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
callArgs.id = this[kIdKey];
callArgs.childId = args.resource[kIdKey];
- var result = native.callSync('IotconResource_removeChildResource', callArgs);
+ var result = native.callSync('IotconResourceRemoveChildResource', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
};
- var result = native.callSync('IotconResource_setRequestListener', callArgs);
+ var result = native.callSync('IotconResourceSetRequestListener', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
var callArgs = {};
callArgs.id = this[kIdKey];
- var result = native.callSync('IotconResource_unsetRequestListener', callArgs);
+ var result = native.callSync('IotconResourceUnsetRequestListener', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
callArgs.representation = this.representation;
callArgs.options = this.options;
- var result = native.callSync('IotconResponse_send', callArgs);
+ var result = native.callSync('IotconResponseSend', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
get: function() {
var callArgs = prepareResourceInfo(this);
var result = native.callSync(
- 'IotconRemoteResource_getCachedRepresentation',
+ 'IotconRemoteResourceGetCachedRepresentation',
callArgs
);
if (native.isSuccess(result)) {
get: function() {
var options_ = null;
var callArgs = prepareResourceInfo(this, true);
- var result = native.callSync('IotconRemoteResource_getOptions', callArgs);
+ var result = native.callSync('IotconRemoteResourceGetOptions', callArgs);
if (native.isSuccess(result)) {
var data = native.getResultObject(result);
options_ = [];
var callArgs = prepareResourceInfo(this, true);
callArgs['options'] = val;
- var result = native.callSync('IotconRemoteResource_setOptions', callArgs);
+ var result = native.callSync('IotconRemoteResourceSetOptions', callArgs);
if (native.isSuccess(result)) {
manageId(this, native.getResultObject(result));
}
var callArgs = prepareResourceInfo(this, true);
var result = native.callSync(
- 'IotconRemoteResource_getTimeInterval',
+ 'IotconRemoteResourceGetTimeInterval',
callArgs
);
if (native.isSuccess(result)) {
var callArgs = prepareResourceInfo(this, true);
callArgs[timeInterval] = converter.toLong(val);
- native.callSync('IotconRemoteResource_setTimeInterval', callArgs);
+ native.callSync('IotconRemoteResourceSetTimeInterval', callArgs);
}.bind(this),
enumerable: true
}
}
}.bind(this);
- var result = native.call('IotconRemoteResource_methodGet', callArgs, callback);
+ var result = native.call('IotconRemoteResourceMethodGet', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
}.bind(this);
- var result = native.call('IotconRemoteResource_methodPut', callArgs, callback);
+ var result = native.call('IotconRemoteResourceMethodPut', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
}.bind(this);
- var result = native.call('IotconRemoteResource_methodPost', callArgs, callback);
+ var result = native.call('IotconRemoteResourceMethodPost', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
}.bind(this);
- var result = native.call('IotconRemoteResource_methodDelete', callArgs, callback);
+ var result = native.call('IotconRemoteResourceMethodDelete', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
args.successCallback(new RemoteResponse(result.data));
};
- var result = native.callSync('IotconRemoteResource_startObserving', callArgs);
+ var result = native.callSync('IotconRemoteResourceStartObserving', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
RemoteResource.prototype.stopObserving = function() {
var callArgs = prepareResourceInfo(this);
- var result = native.callSync('IotconRemoteResource_stopObserving', callArgs);
+ var result = native.callSync('IotconRemoteResourceStopObserving', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
native.callIfPossible(args.successCallback(createRepresentation(result.data)));
};
- var result = native.callSync('IotconRemoteResource_startCaching', callArgs);
+ var result = native.callSync('IotconRemoteResourceStartCaching', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
RemoteResource.prototype.stopCaching = function() {
var callArgs = prepareResourceInfo(this);
- var result = native.callSync('IotconRemoteResource_stopCaching', callArgs);
+ var result = native.callSync('IotconRemoteResourceStopCaching', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
};
var result = native.callSync(
- 'IotconRemoteResource_setResourceStateChangeListener',
+ 'IotconRemoteResourceSetResourceStateChangeListener',
callArgs
);
var callArgs = prepareResourceInfo(this);
var result = native.callSync(
- 'IotconRemoteResource_unsetResourceStateChangeListener',
+ 'IotconRemoteResourceUnsetResourceStateChangeListener',
callArgs
);
}
};
- var result = native.callSync('IotconClient_findResource', callArgs);
+ var result = native.callSync('IotconClientFindResource', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
} else {
callArgs.resourceType = args.resourceType;
callArgs.connectivityType = args.connectivityType;
- var result = native.callSync('IotconClient_addPresenceEventListener', callArgs);
+ var result = native.callSync('IotconClientAddPresenceEventListener', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
var callArgs = {};
callArgs.id = args.watchId;
- var result = native.callSync('IotconClient_removePresenceEventListener', callArgs);
+ var result = native.callSync('IotconClientRemovePresenceEventListener', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
};
- var result = native.call('IotconClient_findDeviceInfo', callArgs);
+ var result = native.call('IotconClientFindDeviceInfo', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
};
- var result = native.call('IotconClient_findPlatformInfo', callArgs);
+ var result = native.call('IotconClientFindPlatformInfo', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
callArgs.resourceTypes = args.resourceTypes;
callArgs.resourceInterfaces = args.resourceInterfaces;
- var result = native.callSync('IotconServer_createResource', callArgs);
+ var result = native.callSync('IotconServerCreateResource', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
var callArgs = {};
callArgs.id = args.resource[kIdKey];
- var result = native.callSync('IotconServer_removeResource', callArgs);
+ var result = native.callSync('IotconServerRemoveResource', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
timeToLive: args.timeToLive
};
- var result = native.callSync('IotconServer_startPresence', callArgs);
+ var result = native.callSync('IotconServerStartPresence', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
};
Server.prototype.stopPresence = function() {
- var result = native.callSync('IotconServer_stopPresence', {});
+ var result = native.callSync('IotconServerStopPresence', {});
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
deviceName: deviceName
};
- var result = native.callSync('Iotcon_setDeviceName', callArgs);
+ var result = native.callSync('IotconSetDeviceName', callArgs);
if (native.isSuccess(result)) {
_deviceName = deviceName;
}
filePath: args.filePath
};
- var result = native.callSync('Iotcon_initialize', data);
+ var result = native.callSync('IotconInitialize', data);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
};
Iotcon.prototype.getTimeout = function() {
- var result = native.callSync('Iotcon_getTimeout', {});
+ var result = native.callSync('IotconGetTimeout', {});
if (native.isFailure(result)) {
throw native.getErrorObject(result);
var callArgs = {};
callArgs.timeout = args.timeout;
- var result = native.callSync('Iotcon_setTimeout', callArgs);
+ var result = native.callSync('IotconSetTimeout', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
]);
- var result = native.callSync('Iotcon_addGeneratedPinListener', {});
+ var result = native.callSync('IotconAddGeneratedPinListener', {});
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
]);
- var result = native.callSync('Iotcon_removeGeneratedPinListener', {
+ var result = native.callSync('IotconRemoveGeneratedPinListener', {
watchId: args.watchId
});
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&IotconInstance::x, this, _1))
-
- REGISTER_SYNC("IotconResource_getObserverIds", ResourceGetObserverIds);
- REGISTER_SYNC("IotconResource_notify", ResourceNotify);
- REGISTER_SYNC("IotconResource_addResourceTypes", ResourceAddResourceTypes);
- REGISTER_SYNC("IotconResource_addResourceInterface", ResourceAddResourceInterface);
- REGISTER_SYNC("IotconResource_addChildResource", ResourceAddChildResource);
- REGISTER_SYNC("IotconResource_removeChildResource", ResourceRemoveChildResource);
- REGISTER_SYNC("IotconResource_setRequestListener", ResourceSetRequestListener);
- REGISTER_SYNC("IotconResource_unsetRequestListener", ResourceUnsetRequestListener);
- REGISTER_SYNC("IotconResponse_send", ResponseSend);
- REGISTER_SYNC("IotconRemoteResource_getCachedRepresentation",
- RemoteResourceGetCachedRepresentation);
- REGISTER_SYNC("IotconRemoteResource_getOptions", RemoteResourceGetOptions);
- REGISTER_SYNC("IotconRemoteResource_setOptions", RemoteResourceSetOptions);
- REGISTER_SYNC("IotconRemoteResource_startObserving", RemoteResourceStartObserving);
- REGISTER_SYNC("IotconRemoteResource_stopObserving", RemoteResourceStopObserving);
- REGISTER_SYNC("IotconRemoteResource_startCaching", RemoteResourceStartCaching);
- REGISTER_SYNC("IotconRemoteResource_stopCaching", RemoteResourceStopCaching);
- REGISTER_SYNC("IotconRemoteResource_setResourceStateChangeListener",
- RemoteResourceSetResourceStateChangeListener);
- REGISTER_SYNC("IotconRemoteResource_unsetResourceStateChangeListener",
- RemoteResourceUnsetResourceStateChangeListener);
- REGISTER_SYNC("IotconRemoteResource_getTimeInterval", RemoteResourceGetTimeInterval);
- REGISTER_SYNC("IotconRemoteResource_setTimeInterval", RemoteResourceSetTimeInterval);
- REGISTER_SYNC("IotconClient_addPresenceEventListener", ClientAddPresenceEventListener);
- REGISTER_SYNC("IotconClient_removePresenceEventListener", ClientRemovePresenceEventListener);
- REGISTER_SYNC("Iotcon_initialize", Initialize);
- REGISTER_SYNC("Iotcon_getTimeout", GetTimeout);
- REGISTER_SYNC("Iotcon_setTimeout", SetTimeout);
- REGISTER_SYNC("Iotcon_addGeneratedPinListener", AddGeneratedPinListener);
- REGISTER_SYNC("Iotcon_removeGeneratedPinListener", RemoveGeneratedPinListener);
- REGISTER_SYNC("IotconServer_createResource", ServerCreateResource);
- REGISTER_SYNC("IotconServer_removeResource", ServerRemoveResource);
- REGISTER_SYNC("IotconServer_startPresence", ServerStartPresence);
- REGISTER_SYNC("IotconServer_stopPresence", ServerStopPresence);
- REGISTER_SYNC("Iotcon_setDeviceName", SetDeviceName);
- REGISTER_SYNC("IotconClient_findResource", ClientFindResource);
- REGISTER_SYNC("IotconClient_findDeviceInfo", ClientFindDeviceInfo);
- REGISTER_SYNC("IotconClient_findPlatformInfo", ClientFindPlatformInfo);
-#undef REGISTER_SYNC
-
-#define REGISTER_ASYNC(c, x) RegisterHandler(c, std::bind(&IotconInstance::x, this, _1, _2));
-
- REGISTER_ASYNC("IotconRemoteResource_methodGet", RemoteResourceMethodGet);
- REGISTER_ASYNC("IotconRemoteResource_methodPut", RemoteResourceMethodPut);
- REGISTER_ASYNC("IotconRemoteResource_methodPost", RemoteResourceMethodPost);
- REGISTER_ASYNC("IotconRemoteResource_methodDelete", RemoteResourceMethodDelete);
-
-#undef REGISTER_ASYNC
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&IotconInstance::M, this, _1))
+
+ REGISTER_METHOD(IotconResourceGetObserverIds);
+ REGISTER_METHOD(IotconResourceNotify);
+ REGISTER_METHOD(IotconResourceAddResourceTypes);
+ REGISTER_METHOD(IotconResourceAddResourceInterface);
+ REGISTER_METHOD(IotconResourceAddChildResource);
+ REGISTER_METHOD(IotconResourceRemoveChildResource);
+ REGISTER_METHOD(IotconResourceSetRequestListener);
+ REGISTER_METHOD(IotconResourceUnsetRequestListener);
+ REGISTER_METHOD(IotconResponseSend);
+ REGISTER_METHOD(IotconRemoteResourceGetCachedRepresentation);
+ REGISTER_METHOD(IotconRemoteResourceGetOptions);
+ REGISTER_METHOD(IotconRemoteResourceSetOptions);
+ REGISTER_METHOD(IotconRemoteResourceStartObserving);
+ REGISTER_METHOD(IotconRemoteResourceStopObserving);
+ REGISTER_METHOD(IotconRemoteResourceStartCaching);
+ REGISTER_METHOD(IotconRemoteResourceStopCaching);
+ REGISTER_METHOD(IotconRemoteResourceSetResourceStateChangeListener);
+ REGISTER_METHOD(IotconRemoteResourceUnsetResourceStateChangeListener);
+ REGISTER_METHOD(IotconRemoteResourceGetTimeInterval);
+ REGISTER_METHOD(IotconRemoteResourceSetTimeInterval);
+ REGISTER_METHOD(IotconClientAddPresenceEventListener);
+ REGISTER_METHOD(IotconClientRemovePresenceEventListener);
+ REGISTER_METHOD(IotconInitialize);
+ REGISTER_METHOD(IotconGetTimeout);
+ REGISTER_METHOD(IotconSetTimeout);
+ REGISTER_METHOD(IotconAddGeneratedPinListener);
+ REGISTER_METHOD(IotconRemoveGeneratedPinListener);
+ REGISTER_METHOD(IotconServerCreateResource);
+ REGISTER_METHOD(IotconServerRemoveResource);
+ REGISTER_METHOD(IotconServerStartPresence);
+ REGISTER_METHOD(IotconServerStopPresence);
+ REGISTER_METHOD(IotconSetDeviceName);
+ REGISTER_METHOD(IotconClientFindResource);
+ REGISTER_METHOD(IotconClientFindDeviceInfo);
+ REGISTER_METHOD(IotconClientFindPlatformInfo);
+#undef REGISTER_METHOD
+
+#define REGISTER_METHOD(M) \
+ RegisterHandler(#M, std::bind(&IotconInstance::M, this, _1, _2))
+
+ REGISTER_METHOD(IotconRemoteResourceMethodGet);
+ REGISTER_METHOD(IotconRemoteResourceMethodPut);
+ REGISTER_METHOD(IotconRemoteResourceMethodPost);
+ REGISTER_METHOD(IotconRemoteResourceMethodDelete);
+
+#undef REGISTER_METHOD
}
IotconInstance::~IotconInstance() {
}
}
-common::TizenResult IotconInstance::ResourceGetObserverIds(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResourceGetObserverIds(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kId);
return common::TizenSuccess(value);
}
-common::TizenResult IotconInstance::ResourceNotify(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResourceNotify(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ResourceAddResourceTypes(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResourceAddResourceTypes(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ResourceAddResourceInterface(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResourceAddResourceInterface(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ResourceAddChildResource(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResourceAddChildResource(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ResourceRemoveChildResource(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResourceRemoveChildResource(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ResourceSetRequestListener(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResourceSetRequestListener(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kId);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ResourceUnsetRequestListener(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResourceUnsetRequestListener(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kId);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ResponseSend(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconResponseSend(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kId);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::RemoteResourceGetCachedRepresentation(
+common::TizenResult IotconInstance::IotconRemoteResourceGetCachedRepresentation(
const picojson::object& args) {
ScopeLogger();
return common::AbortError("Failed to gather cached representation");
}
-common::TizenResult IotconInstance::RemoteResourceGetOptions(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoteResourceGetOptions(const picojson::object& args) {
ScopeLogger();
FoundRemoteInfoPtr ptr;
return common::AbortError("Failed to gather options");
}
-common::TizenResult IotconInstance::RemoteResourceSetOptions(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoteResourceSetOptions(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kOptions);
return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(ptr)};
}
-common::TizenResult IotconInstance::RemoteResourceMethodGet(const picojson::object& args,
+common::TizenResult IotconInstance::IotconRemoteResourceMethodGet(const picojson::object& args,
const common::AsyncToken& token) {
ScopeLogger();
return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(resource)};
}
-common::TizenResult IotconInstance::RemoteResourceMethodPut(const picojson::object& args,
+common::TizenResult IotconInstance::IotconRemoteResourceMethodPut(const picojson::object& args,
const common::AsyncToken& token) {
ScopeLogger();
return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(resource)};
}
-common::TizenResult IotconInstance::RemoteResourceMethodPost(const picojson::object& args,
+common::TizenResult IotconInstance::IotconRemoteResourceMethodPost(const picojson::object& args,
const common::AsyncToken& token) {
ScopeLogger();
return common::TizenSuccess{IotconClientManager::GetInstance().StoreRemoteResource(resource)};
}
-common::TizenResult IotconInstance::RemoteResourceMethodDelete(const picojson::object& args,
+common::TizenResult IotconInstance::IotconRemoteResourceMethodDelete(const picojson::object& args,
const common::AsyncToken& token) {
ScopeLogger();
}
}
-common::TizenResult IotconInstance::RemoteResourceStartObserving(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoteResourceStartObserving(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess{ret};
}
-common::TizenResult IotconInstance::RemoteResourceStopObserving(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoteResourceStopObserving(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
}
}
-common::TizenResult IotconInstance::RemoteResourceStartCaching(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoteResourceStartCaching(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess{ret};
}
-common::TizenResult IotconInstance::RemoteResourceStopCaching(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoteResourceStopCaching(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
}
}
-common::TizenResult IotconInstance::RemoteResourceSetResourceStateChangeListener(
+common::TizenResult IotconInstance::IotconRemoteResourceSetResourceStateChangeListener(
const picojson::object& args) {
ScopeLogger();
return common::TizenSuccess{ret};
}
-common::TizenResult IotconInstance::RemoteResourceUnsetResourceStateChangeListener(
+common::TizenResult IotconInstance::IotconRemoteResourceUnsetResourceStateChangeListener(
const picojson::object& args) {
ScopeLogger();
return common::TizenSuccess{IotconClientManager::GetInstance().RemoveRemoteResource(ptr)};
}
-common::TizenResult IotconInstance::RemoteResourceGetTimeInterval(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoteResourceGetTimeInterval(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess{picojson::value(static_cast<double>(time_interval))};
}
-common::TizenResult IotconInstance::RemoteResourceSetTimeInterval(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoteResourceSetTimeInterval(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
if (data->was_called) {
return IOTCON_FUNC_STOP;
}
+ break;
default:
ret = IotconUtils::ConvertIotconError(result);
}
return IOTCON_FUNC_CONTINUE;
}
-common::TizenResult IotconInstance::ClientFindResource(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconClientFindResource(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ClientAddPresenceEventListener(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconClientAddPresenceEventListener(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess(picojson::value{static_cast<double>(id)});
}
-common::TizenResult IotconInstance::ClientRemovePresenceEventListener(
+common::TizenResult IotconInstance::IotconClientRemovePresenceEventListener(
const picojson::object& args) {
ScopeLogger();
return IOTCON_FUNC_CONTINUE;
}
-common::TizenResult IotconInstance::ClientFindDeviceInfo(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconClientFindDeviceInfo(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return IOTCON_FUNC_CONTINUE;
}
-common::TizenResult IotconInstance::ClientFindPlatformInfo(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconClientFindPlatformInfo(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::ServerCreateResource(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconServerCreateResource(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return common::TizenSuccess{result};
}
-common::TizenResult IotconInstance::ServerRemoveResource(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconServerRemoveResource(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return IotconServerManager::GetInstance().DestroyResource(GetId(args));
}
-common::TizenResult IotconInstance::ServerStartPresence(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconServerStartPresence(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return result;
}
-common::TizenResult IotconInstance::ServerStopPresence(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconServerStopPresence(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return result;
}
-common::TizenResult IotconInstance::SetDeviceName(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconSetDeviceName(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return result;
}
-common::TizenResult IotconInstance::Initialize(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconInitialize(const picojson::object& args) {
ScopeLogger();
CHECK_PRIVILEGE(kPrivilegeIotcon);
return result;
}
-common::TizenResult IotconInstance::GetTimeout(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconGetTimeout(const picojson::object& args) {
ScopeLogger();
int timeout = 0;
return common::TizenSuccess{picojson::value{static_cast<double>(timeout)}};
}
-common::TizenResult IotconInstance::SetTimeout(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconSetTimeout(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, kTimeout);
return common::TizenSuccess();
}
-common::TizenResult IotconInstance::AddGeneratedPinListener(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconAddGeneratedPinListener(const picojson::object& args) {
ScopeLogger();
auto listener = [this](const char* pin, long watchId) {
return IotconManager::GetInstance().addGeneratedPinListener(listener);
}
-common::TizenResult IotconInstance::RemoveGeneratedPinListener(const picojson::object& args) {
+common::TizenResult IotconInstance::IotconRemoveGeneratedPinListener(const picojson::object& args) {
ScopeLogger();
CHECK_EXIST(args, "watchId");
static bool ResourceFoundCallback(iotcon_remote_resource_h resource, iotcon_error_e result,
void* user_data);
- common::TizenResult ResourceGetObserverIds(const picojson::object& args);
- common::TizenResult ResourceNotify(const picojson::object& args);
- common::TizenResult ResourceAddResourceTypes(const picojson::object& args);
- common::TizenResult ResourceAddResourceInterface(const picojson::object& args);
- common::TizenResult ResourceAddChildResource(const picojson::object& args);
- common::TizenResult ResourceRemoveChildResource(const picojson::object& args);
- common::TizenResult ResourceSetRequestListener(const picojson::object& args);
- common::TizenResult ResourceUnsetRequestListener(const picojson::object& args);
- common::TizenResult ResponseSend(const picojson::object& args);
- common::TizenResult RemoteResourceGetCachedRepresentation(const picojson::object& args);
- common::TizenResult RemoteResourceGetOptions(const picojson::object& args);
- common::TizenResult RemoteResourceSetOptions(const picojson::object& args);
- common::TizenResult RemoteResourceMethodGet(const picojson::object& args,
+ common::TizenResult IotconResourceGetObserverIds(const picojson::object& args);
+ common::TizenResult IotconResourceNotify(const picojson::object& args);
+ common::TizenResult IotconResourceAddResourceTypes(const picojson::object& args);
+ common::TizenResult IotconResourceAddResourceInterface(const picojson::object& args);
+ common::TizenResult IotconResourceAddChildResource(const picojson::object& args);
+ common::TizenResult IotconResourceRemoveChildResource(const picojson::object& args);
+ common::TizenResult IotconResourceSetRequestListener(const picojson::object& args);
+ common::TizenResult IotconResourceUnsetRequestListener(const picojson::object& args);
+ common::TizenResult IotconResponseSend(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceGetCachedRepresentation(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceGetOptions(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceSetOptions(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceMethodGet(const picojson::object& args,
const common::AsyncToken& token);
- common::TizenResult RemoteResourceMethodPut(const picojson::object& args,
+ common::TizenResult IotconRemoteResourceMethodPut(const picojson::object& args,
const common::AsyncToken& token);
- common::TizenResult RemoteResourceMethodPost(const picojson::object& args,
+ common::TizenResult IotconRemoteResourceMethodPost(const picojson::object& args,
const common::AsyncToken& token);
- common::TizenResult RemoteResourceMethodDelete(const picojson::object& args,
+ common::TizenResult IotconRemoteResourceMethodDelete(const picojson::object& args,
const common::AsyncToken& token);
- common::TizenResult RemoteResourceStartObserving(const picojson::object& args);
- common::TizenResult RemoteResourceStopObserving(const picojson::object& args);
- common::TizenResult RemoteResourceStartCaching(const picojson::object& args);
- common::TizenResult RemoteResourceStopCaching(const picojson::object& args);
- common::TizenResult RemoteResourceSetResourceStateChangeListener(const picojson::object& args);
- common::TizenResult RemoteResourceUnsetResourceStateChangeListener(const picojson::object& args);
- common::TizenResult RemoteResourceGetTimeInterval(const picojson::object& args);
- common::TizenResult RemoteResourceSetTimeInterval(const picojson::object& args);
- common::TizenResult ClientFindResource(const picojson::object& args);
- common::TizenResult ClientAddPresenceEventListener(const picojson::object& args);
- common::TizenResult ClientRemovePresenceEventListener(const picojson::object& args);
- common::TizenResult ClientFindDeviceInfo(const picojson::object& args);
- common::TizenResult ClientFindPlatformInfo(const picojson::object& args);
- common::TizenResult ServerCreateResource(const picojson::object& args);
- common::TizenResult ServerRemoveResource(const picojson::object& args);
- common::TizenResult ServerStartPresence(const picojson::object& args);
- common::TizenResult ServerStopPresence(const picojson::object& args);
- common::TizenResult SetDeviceName(const picojson::object& args);
- common::TizenResult Initialize(const picojson::object& args);
- common::TizenResult GetTimeout(const picojson::object& args);
- common::TizenResult SetTimeout(const picojson::object& args);
- common::TizenResult AddGeneratedPinListener(const picojson::object& args);
- common::TizenResult RemoveGeneratedPinListener(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceStartObserving(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceStopObserving(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceStartCaching(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceStopCaching(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceSetResourceStateChangeListener(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceUnsetResourceStateChangeListener(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceGetTimeInterval(const picojson::object& args);
+ common::TizenResult IotconRemoteResourceSetTimeInterval(const picojson::object& args);
+ common::TizenResult IotconClientFindResource(const picojson::object& args);
+ common::TizenResult IotconClientAddPresenceEventListener(const picojson::object& args);
+ common::TizenResult IotconClientRemovePresenceEventListener(const picojson::object& args);
+ common::TizenResult IotconClientFindDeviceInfo(const picojson::object& args);
+ common::TizenResult IotconClientFindPlatformInfo(const picojson::object& args);
+ common::TizenResult IotconServerCreateResource(const picojson::object& args);
+ common::TizenResult IotconServerRemoveResource(const picojson::object& args);
+ common::TizenResult IotconServerStartPresence(const picojson::object& args);
+ common::TizenResult IotconServerStopPresence(const picojson::object& args);
+ common::TizenResult IotconSetDeviceName(const picojson::object& args);
+ common::TizenResult IotconInitialize(const picojson::object& args);
+ common::TizenResult IotconGetTimeout(const picojson::object& args);
+ common::TizenResult IotconSetTimeout(const picojson::object& args);
+ common::TizenResult IotconAddGeneratedPinListener(const picojson::object& args);
+ common::TizenResult IotconRemoveGeneratedPinListener(const picojson::object& args);
common::PostCallback PostForMethodCall(const common::AsyncToken& token,
const FoundRemoteInfoPtr& resource);
]);
var result = native.call(
- 'KeyManager_saveData',
+ 'KeyManagerSaveData',
{
aliasName: _trim(args.aliasName),
rawData: args.rawData,
data_alias = args.dataAlias.packageId + ' ' + data_alias;
}
- var ret = native.callSync('KeyManager_removeAlias', {
+ var ret = native.callSync('KeyManagerRemoveAlias', {
aliasName: data_alias
});
if (native.isFailure(ret)) {
data_alias = args.dataAlias.packageId + ' ' + data_alias;
}
- var ret = native.callSync('KeyManager_getData', {
+ var ret = native.callSync('KeyManagerGetData', {
name: data_alias,
password: args.password
});
};
KeyManager.prototype.getDataAliasList = function() {
- var ret = native.callSync('KeyManager_getDataAliasList', {});
+ var ret = native.callSync('KeyManagerGetDataAliasList', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
}
}
var result = native.call(
- 'KeyManager_setPermissions',
+ 'KeyManagerSetPermissions',
{
aliasName: data_alias,
packageId: args.packageId,
using std::placeholders::_1;
using std::placeholders::_2;
- RegisterSyncHandler("KeyManager_getDataAliasList",
- std::bind(&KeyManagerInstance::GetDataAliasList, this, _1, _2));
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&KeyManagerInstance::M, this, _1, _2))
- RegisterSyncHandler("KeyManager_saveData",
- std::bind(&KeyManagerInstance::SaveData, this, _1, _2));
+ REGISTER_METHOD(KeyManagerGetDataAliasList);
+ REGISTER_METHOD(KeyManagerSaveData);
+ REGISTER_METHOD(KeyManagerGetData);
+ REGISTER_METHOD(KeyManagerRemoveAlias);
+ REGISTER_METHOD(KeyManagerSetPermissions);
- RegisterSyncHandler("KeyManager_getData", std::bind(&KeyManagerInstance::GetData, this, _1, _2));
-
- RegisterSyncHandler("KeyManager_removeAlias",
- std::bind(&KeyManagerInstance::RemoveAlias, this, _1, _2));
-
- RegisterSyncHandler("KeyManager_setPermissions",
- std::bind(&KeyManagerInstance::SetPermission, this, _1, _2));
+#undef REGISTER_METHOD
}
-void KeyManagerInstance::GetDataAliasList(const picojson::value& args, picojson::object& out) {
+void KeyManagerInstance::KeyManagerGetDataAliasList(const picojson::value& args, picojson::object& out) {
ScopeLogger();
picojson::value result = picojson::value(picojson::array());
}
}
-void KeyManagerInstance::SaveData(const picojson::value& args, picojson::object& out) {
+void KeyManagerInstance::KeyManagerSaveData(const picojson::value& args, picojson::object& out) {
ScopeLogger();
std::string data_raw = args.get("rawData").get<std::string>();
ReportSuccess(out);
}
-void KeyManagerInstance::GetData(const picojson::value& args, picojson::object& out) {
+void KeyManagerInstance::KeyManagerGetData(const picojson::value& args, picojson::object& out) {
ScopeLogger();
const auto& data_alias = args.get("name").get<std::string>();
ScopeLogger();
}
-void KeyManagerInstance::RemoveAlias(const picojson::value& args, picojson::object& out) {
+void KeyManagerInstance::KeyManagerRemoveAlias(const picojson::value& args, picojson::object& out) {
ScopeLogger();
const std::string& alias = args.get("aliasName").get<std::string>();
}
}
-void KeyManagerInstance::SetPermission(const picojson::value& args, picojson::object& out) {
+void KeyManagerInstance::KeyManagerSetPermissions(const picojson::value& args, picojson::object& out) {
ScopeLogger();
const std::string& data_name = args.get("aliasName").get<std::string>();
virtual ~KeyManagerInstance();
private:
- void GetDataAliasList(picojson::value const& args, picojson::object& out);
+ void KeyManagerGetDataAliasList(picojson::value const& args, picojson::object& out);
- void SaveData(const picojson::value& args, picojson::object& out);
- void GetData(const picojson::value& args, picojson::object& out);
- void RemoveAlias(const picojson::value& args, picojson::object& out);
+ void KeyManagerSaveData(const picojson::value& args, picojson::object& out);
+ void KeyManagerGetData(const picojson::value& args, picojson::object& out);
+ void KeyManagerRemoveAlias(const picojson::value& args, picojson::object& out);
- void SetPermission(const picojson::value& args, picojson::object& out);
+ void KeyManagerSetPermissions(const picojson::value& args, picojson::object& out);
static common::PlatformResult GetError(int ret);
};
}
]);
- var ret = native.callSync('MediaKeyManager_setMediaKeyEventListener', {});
+ var ret = native.callSync('SetMediaKeyEventListener', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
};
MediaKeyManager.prototype.unsetMediaKeyEventListener = function() {
- var ret = native.callSync('MediaKeyManager_unsetMediaKeyEventListener', {});
+ var ret = native.callSync('UnsetMediaKeyEventListener', {});
if (native.isFailure(ret)) {
throw native.getErrorObject(ret);
ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&MediaKeyInstance::x, this, _1, _2));
- REGISTER_SYNC("MediaKeyManager_setMediaKeyEventListener", SetMediaKeyEventListener);
- REGISTER_SYNC("MediaKeyManager_unsetMediaKeyEventListener", UnsetMediaKeyEventListener);
-#undef REGISTER_SYNC
+
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&MediaKeyInstance::M, this, _1, _2))
+ REGISTER_METHOD(SetMediaKeyEventListener);
+ REGISTER_METHOD(UnsetMediaKeyEventListener);
+#undef REGISTER_METHOD
}
MediaKeyInstance::~MediaKeyInstance() {
};
var result = native_.callSync(
- 'MessagePortManager_requestLocalMessagePort',
+ 'MessagePortManagerRequestLocalMessagePort',
nativeParam
);
};
var result = native_.callSync(
- 'MessagePortManager_requestTrustedLocalMessagePort',
+ 'MessagePortManagerRequestTrustedLocalMessagePort',
nativeParam
);
};
var result = native_.callSync(
- 'MessagePortManager_requestRemoteMessagePort',
+ 'MessagePortManagerRequestRemoteMessagePort',
nativeParam
);
};
var result = native_.callSync(
- 'MessagePortManager_requestTrustedRemoteMessagePort',
+ 'MessagePortManagerRequestTrustedRemoteMessagePort',
nativeParam
);
: -1
};
- var result = native_.callSync('RemoteMessagePort_sendMessage', nativeParam);
+ var result = native_.callSync('RemoteMessagePortSendMessage', nativeParam);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) \
- RegisterSyncHandler(c, std::bind(&MessageportInstance::x, this, _1, _2));
- REGISTER_SYNC("MessagePortManager_requestTrustedRemoteMessagePort",
- MessagePortManagerRequesttrustedremotemessageport);
- REGISTER_SYNC("MessagePortManager_requestLocalMessagePort",
- MessagePortManagerRequestlocalmessageport);
- REGISTER_SYNC("MessagePortManager_requestTrustedLocalMessagePort",
- MessagePortManagerRequesttrustedlocalmessageport);
- REGISTER_SYNC("MessagePortManager_requestRemoteMessagePort",
- MessagePortManagerRequestremotemessageport);
- REGISTER_SYNC("RemoteMessagePort_sendMessage", RemoteMessagePortSendmessage);
-#undef REGISTER_SYNC
+
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&MessageportInstance::M, this, _1, _2))
+ REGISTER_METHOD(MessagePortManagerRequestTrustedRemoteMessagePort);
+ REGISTER_METHOD(MessagePortManagerRequestLocalMessagePort);
+ REGISTER_METHOD(MessagePortManagerRequestTrustedLocalMessagePort);
+ REGISTER_METHOD(MessagePortManagerRequestRemoteMessagePort);
+ REGISTER_METHOD(RemoteMessagePortSendMessage);
+#undef REGISTER_METHOD
}
MessageportInstance::~MessageportInstance() {
common::Instance::PostMessage(object, picojson::value(o).serialize().c_str());
}
-void MessageportInstance::MessagePortManagerRequestlocalmessageport(const picojson::value& args,
+void MessageportInstance::MessagePortManagerRequestLocalMessagePort(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_EXIST(args, "localMessagePortName", out)
}
}
-void MessageportInstance::MessagePortManagerRequesttrustedlocalmessageport(
+void MessageportInstance::MessagePortManagerRequestTrustedLocalMessagePort(
const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_EXIST(args, "localMessagePortName", out)
}
}
-void MessageportInstance::MessagePortManagerRequestremotemessageport(const picojson::value& args,
+void MessageportInstance::MessagePortManagerRequestRemoteMessagePort(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_EXIST(args, "remoteMessagePortName", out)
}
}
-void MessageportInstance::MessagePortManagerRequesttrustedremotemessageport(
+void MessageportInstance::MessagePortManagerRequestTrustedRemoteMessagePort(
const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_EXIST(args, "remoteMessagePortName", out)
}
}
-void MessageportInstance::RemoteMessagePortSendmessage(const picojson::value& args,
+void MessageportInstance::RemoteMessagePortSendMessage(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
const std::string& appId = args.get("appId").get<std::string>();
virtual ~MessageportInstance();
private:
- void MessagePortManagerRequestlocalmessageport(const picojson::value& args,
+ void MessagePortManagerRequestLocalMessagePort(const picojson::value& args,
picojson::object& out);
- void MessagePortManagerRequesttrustedlocalmessageport(const picojson::value& args,
+ void MessagePortManagerRequestTrustedLocalMessagePort(const picojson::value& args,
picojson::object& out);
- void MessagePortManagerRequestremotemessageport(const picojson::value& args,
+ void MessagePortManagerRequestRemoteMessagePort(const picojson::value& args,
picojson::object& out);
- void MessagePortManagerRequesttrustedremotemessageport(const picojson::value& args,
+ void MessagePortManagerRequestTrustedRemoteMessagePort(const picojson::value& args,
picojson::object& out);
- void RemoteMessagePortSendmessage(const picojson::value& args, picojson::object& out);
+ void RemoteMessagePortSendMessage(const picojson::value& args, picojson::object& out);
};
} // namespace messageport
id: _internal.id,
type: _internal.type
};
- var result = native.callSync('Message_messageStatus', callArgs);
+ var result = native.callSync('MessageGetMessageStatus', callArgs);
if (native.isSuccess(result)) {
return native.getResultObject(result);
}
args.successCallback(servicesArr);
}
};
- var result = native.call('Messaging_getMessageServices', callArgs, callback);
+ var result = native.call('GetMessageServices', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
native.callIfPossible(args.successCallback, data.recipients);
}
};
- var result = native.call('MessageService_sendMessage', callArgs, callback);
+ var result = native.call('MessageServiceSendMessage', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
}
};
- var result = native.call('MessageService_loadMessageBody', callArgs, callback);
+ var result = native.call('MessageServiceLoadMessageBody', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
};
- var result = native.call('MessageService_loadMessageAttachment', callArgs, callback);
+ var result = native.call('MessageServiceLoadMessageAttachment', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
};
- var result = native.call('MessageService_sync', callArgs, callback);
+ var result = native.call('MessageServiceSync', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
};
- var result = native.call('MessageService_syncFolder', callArgs, callback);
+ var result = native.call('MessageServiceSyncFolder', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
id: self.id,
opId: args.opId
};
- var result = native.callSync('MessageService_stopSync', callArgs);
+ var result = native.callSync('MessageServiceStopSync', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
native.callIfPossible(args.successCallback, data.recipients);
}
};
- var result = native.call('MessageStorage_addDraftMessage', callArgs, callback);
+ var result = native.call('MessageStorageAddDraftMessage', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
native.callIfPossible(args.successCallback, messages);
}
};
- var result = native.call('MessageStorage_findMessages', callArgs, callback);
+ var result = native.call('MessageStorageFindMessages', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
native.callIfPossible(args.successCallback);
}
};
- var result = native.call('MessageStorage_removeMessages', callArgs, callback);
+ var result = native.call('MessageStorageRemoveMessages', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
native.callIfPossible(args.successCallback);
}
};
- var result = native.call('MessageStorage_updateMessages', callArgs, callback);
+ var result = native.call('MessageStorageUpdateMessages', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
args.successCallback(conversations);
}
};
- var result = native.call('MessageStorage_findConversations', callArgs, callback);
+ var result = native.call('MessageStorageFindConversations', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
native.callIfPossible(args.successCallback);
}
};
- var result = native.call('MessageStorage_removeConversations', callArgs, callback);
+ var result = native.call('MessageStorageRemoveConversations', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
args.successCallback(folders);
}
};
- var result = native.call('MessageStorage_findFolders', callArgs, callback);
+ var result = native.call('MessageStorageFindFolders', callArgs, callback);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
}
filter: args.filter ? addTypeToFilter_(args.filter) : null,
serviceId: self.service.id
};
- var result = native.callSync('MessageStorage_addMessagesChangeListener', callArgs);
+ var result = native.callSync('MessageStorageAddMessagesChangeListener', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
} else {
serviceId: self.service.id
};
var result = native.callSync(
- 'MessageStorage_addConversationsChangeListener',
+ 'MessageStorageAddConversationsChangeListener',
callArgs
);
if (native.isFailure(result)) {
filter: args.filter ? addTypeToFilter_(args.filter) : null,
serviceId: self.service.id
};
- var result = native.callSync('MessageStorage_addFoldersChangeListener', callArgs);
+ var result = native.callSync('MessageStorageAddFolderChangeListener', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
} else {
watchId: args.watchId,
serviceId: self.service.id
};
- var result = native.callSync('MessageStorage_removeChangeListener', callArgs);
+ var result = native.callSync('MessageStorageRemoveChangeListener', callArgs);
if (native.isFailure(result)) {
throw native.getErrorObject(result);
} else {
namespace messaging {
namespace {
-const char* FUN_GET_MESSAGE_SERVICES = "Messaging_getMessageServices";
const char* GET_MESSAGE_SERVICES_ARGS_MESSAGE_SERVICE_TYPE = "messageServiceType";
-
-const char* FUN_MESSAGE_SERVICE_SEND_MESSAGE = "MessageService_sendMessage";
const char* SEND_MESSAGE_ARGS_MESSAGE = "message";
const char* SEND_MESSAGE_ARGS_SIMINDEX = "simIndex";
-
-const char* FUN_MESSAGE_SERVICE_LOAD_MESSAGE_BODY = "MessageService_loadMessageBody";
-
-const char* FUN_MESSAGE_SERVICE_LOAD_MESSAGE_ATTACHMENT = "MessageService_loadMessageAttachment";
const char* LOAD_MESSAGE_ATTACHMENT_ARGS_ATTACHMENT = "attachment";
-
-const char* FUN_MESSAGE_SERVICE_SYNC = "MessageService_sync";
const char* SYNC_ARGS_ID = "id";
const char* SYNC_ARGS_LIMIT = "limit";
-
-const char* FUN_MESSAGE_SERVICE_SYNC_FOLDER = "MessageService_syncFolder";
const char* SYNC_FOLDER_ARGS_ID = "id";
const char* SYNC_FOLDER_ARGS_FOLDER = "folder";
const char* SYNC_FOLDER_ARGS_LIMIT = "limit";
-
-const char* FUN_MESSAGE_SERVICE_STOP_SYNC = "MessageService_stopSync";
const char* STOP_SYNC_ARGS_ID = "id";
const char* STOP_SYNC_ARGS_OPID = "opId";
-
-const char* FUN_MESSAGE_STORAGE_ADD_DRAFT_MESSAGE = "MessageStorage_addDraftMessage";
const char* ADD_DRAFT_MESSAGE_ARGS_MESSAGE = "message";
-
-const char* FUN_MESSAGE_STORAGE_FIND_MESSAGES = "MessageStorage_findMessages";
-
-const char* FUN_MESSAGE_STORAGE_REMOVE_MESSAGES = "MessageStorage_removeMessages";
const char* REMOVE_MESSAGES_ARGS_MESSAGES = "messages";
-
-const char* FUN_MESSAGE_STORAGE_UPDATE_MESSAGES = "MessageStorage_updateMessages";
const char* UPDATE_MESSAGES_ARGS_MESSAGES = "messages";
-
-const char* FUN_MESSAGE_STORAGE_FIND_CONVERSATIONS = "MessageStorage_findConversations";
const char* FIND_CONVERSATIONS_ARGS_LIMIT = "limit";
const char* FIND_CONVERSATIONS_ARGS_OFFSET = "offset";
-
-const char* FUN_MESSAGE_STORAGE_REMOVE_CONVERSATIONS = "MessageStorage_removeConversations";
const char* REMOVE_CONVERSATIONS_ARGS_CONVERSATIONS = "conversations";
-
-const char* FUN_MESSAGE_STORAGE_FIND_FOLDERS = "MessageStorage_findFolders";
const char* FIND_FOLDERS_ARGS_LIMIT = "limit";
const char* FIND_FOLDERS_ARGS_OFFSET = "offset";
-
-const char* FUN_MESSAGE_STORAGE_ADD_MESSAGES_CHANGE_LISTENER =
- "MessageStorage_addMessagesChangeListener";
-
-const char* FUN_MESSAGE_STORAGE_ADD_CONVERSATIONS_CHANGE_LISTENER =
- "MessageStorage_addConversationsChangeListener";
-
-const char* FUN_MESSAGE_STORAGE_ADD_FOLDER_CHANGE_LISTENER =
- "MessageStorage_addFoldersChangeListener";
-
-const char* FUN_MESSAGE_STORAGE_REMOVE_CHANGE_LISTENER = "MessageStorage_removeChangeListener";
const char* REMOVE_CHANGE_LISTENER_ARGS_WATCHID = "watchId";
-
const char* FUNCTIONS_HIDDEN_ARGS_SERVICE_ID = "serviceId";
-const char* FUN_MESSAGE_GET_MESSAGE_STATUS = "Message_messageStatus";
const char* FUN_MESSAGE_MESSAGING_EMAIL = "messaging.email";
auto getServiceIdFromJSON = [](picojson::object& data) -> int {
ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_ASYNC(c, x) RegisterSyncHandler(c, std::bind(&MessagingInstance::x, this, _1, _2));
- REGISTER_ASYNC(FUN_GET_MESSAGE_SERVICES, GetMessageServices);
- REGISTER_ASYNC(FUN_MESSAGE_SERVICE_SEND_MESSAGE, MessageServiceSendMessage);
- REGISTER_ASYNC(FUN_MESSAGE_SERVICE_LOAD_MESSAGE_BODY, MessageServiceLoadMessageBody);
- REGISTER_ASYNC(FUN_MESSAGE_SERVICE_LOAD_MESSAGE_ATTACHMENT, MessageServiceLoadMessageAttachment);
- REGISTER_ASYNC(FUN_MESSAGE_STORAGE_ADD_DRAFT_MESSAGE, MessageStorageAddDraft);
- REGISTER_ASYNC(FUN_MESSAGE_STORAGE_FIND_MESSAGES, MessageStorageFindMessages);
- REGISTER_ASYNC(FUN_MESSAGE_STORAGE_REMOVE_MESSAGES, MessageStorageRemoveMessages);
- REGISTER_ASYNC(FUN_MESSAGE_STORAGE_UPDATE_MESSAGES, MessageStorageUpdateMessages);
- REGISTER_ASYNC(FUN_MESSAGE_STORAGE_FIND_CONVERSATIONS, MessageStorageFindConversations);
- REGISTER_ASYNC(FUN_MESSAGE_STORAGE_REMOVE_CONVERSATIONS, MessageStorageRemoveConversations);
- REGISTER_ASYNC(FUN_MESSAGE_STORAGE_FIND_FOLDERS, MessageStorageFindFolders);
-#undef REGISTER_ASYNC
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&MessagingInstance::x, this, _1, _2));
- REGISTER_SYNC(FUN_MESSAGE_SERVICE_SYNC, MessageServiceSync);
- REGISTER_SYNC(FUN_MESSAGE_SERVICE_STOP_SYNC, MessageServiceStopSync);
- REGISTER_SYNC(FUN_MESSAGE_SERVICE_SYNC_FOLDER, MessageServiceSyncFolder);
- REGISTER_SYNC(FUN_MESSAGE_STORAGE_ADD_MESSAGES_CHANGE_LISTENER,
- MessageStorageAddMessagesChangeListener);
- REGISTER_SYNC(FUN_MESSAGE_STORAGE_ADD_CONVERSATIONS_CHANGE_LISTENER,
- MessageStorageAddConversationsChangeListener);
- REGISTER_SYNC(FUN_MESSAGE_STORAGE_ADD_FOLDER_CHANGE_LISTENER,
- MessageStorageAddFolderChangeListener);
- REGISTER_SYNC(FUN_MESSAGE_STORAGE_REMOVE_CHANGE_LISTENER, MessageStorageRemoveChangeListener);
- REGISTER_SYNC(FUN_MESSAGE_GET_MESSAGE_STATUS, MessageGetMessageStatus);
-#undef REGISTER_SYNC
+
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&MessagingInstance::M, this, _1, _2))
+ REGISTER_METHOD(GetMessageServices);
+ REGISTER_METHOD(MessageServiceSendMessage);
+ REGISTER_METHOD(MessageServiceLoadMessageBody);
+ REGISTER_METHOD(MessageServiceLoadMessageAttachment);
+ REGISTER_METHOD(MessageStorageAddDraftMessage);
+ REGISTER_METHOD(MessageStorageFindMessages);
+ REGISTER_METHOD(MessageStorageRemoveMessages);
+ REGISTER_METHOD(MessageStorageUpdateMessages);
+ REGISTER_METHOD(MessageStorageFindConversations);
+ REGISTER_METHOD(MessageStorageRemoveConversations);
+ REGISTER_METHOD(MessageStorageFindFolders);
+
+
+ REGISTER_METHOD(MessageServiceSync);
+ REGISTER_METHOD(MessageServiceStopSync);
+ REGISTER_METHOD(MessageServiceSyncFolder);
+ REGISTER_METHOD(MessageStorageAddMessagesChangeListener);
+ REGISTER_METHOD(MessageStorageAddConversationsChangeListener);
+ REGISTER_METHOD(MessageStorageAddFolderChangeListener);
+ REGISTER_METHOD(MessageStorageRemoveChangeListener);
+ REGISTER_METHOD(MessageGetMessageStatus);
+#undef REGISTER_METHOD
}
MessagingInstance::~MessagingInstance() {
}
}
-void MessagingInstance::MessageStorageAddDraft(const picojson::value& args, picojson::object& out) {
+void MessagingInstance::MessageStorageAddDraftMessage(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
void MessageServiceSyncFolder(const picojson::value& args, picojson::object& out);
void MessageServiceStopSync(const picojson::value& args, picojson::object& out);
- void MessageStorageAddDraft(const picojson::value& args, picojson::object& out);
+ void MessageStorageAddDraftMessage(const picojson::value& args, picojson::object& out);
void MessageStorageFindMessages(const picojson::value& args, picojson::object& out);
void MessageStorageRemoveMessages(const picojson::value& args, picojson::object& out);
void MessageStorageUpdateMessages(const picojson::value& args, picojson::object& out);
_networkBearerSelectionCallback
);
var result = native_.callSync(
- 'NetworkBearerSelection_requestRouteToHost',
+ 'NetworkBearerSelectionRequestRouteToHost',
nativeParam
);
};
var result = native_.call(
- 'NetworkBearerSelection_releaseRouteToHost',
+ 'NetworkBearerSelectionReleaseRouteToHost',
nativeParam,
callback
);
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_SYNC(c, x) \
- RegisterSyncHandler(c, std::bind(&NetworkBearerSelectionInstance::x, this, _1, _2));
-#define REGISTER_ASYNC(c, x) \
- RegisterSyncHandler(c, std::bind(&NetworkBearerSelectionInstance::x, this, _1, _2));
- REGISTER_SYNC("NetworkBearerSelection_requestRouteToHost",
- NetworkBearerSelectionRequestRouteToHost);
- REGISTER_ASYNC("NetworkBearerSelection_releaseRouteToHost",
- NetworkBearerSelectionReleaseRouteToHost);
-#undef REGISTER_SYNC
-#undef REGISTER_ASYNC
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&NetworkBearerSelectionInstance::M, this, _1, _2))
+ REGISTER_METHOD(NetworkBearerSelectionRequestRouteToHost);
+ REGISTER_METHOD(NetworkBearerSelectionReleaseRouteToHost);
+#undef REGISTER_METHOD
NetworkBearerSelectionManager::GetInstance()->AddListener(this);
}
NFCManager.prototype.getDefaultAdapter = function() {
// First check NFC suppor on C++ level
- var result = native_.callSync('NFCManager_getDefaultAdapter', {});
+ var result = native_.callSync('NFCManagerGetDefaultAdapter', {});
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
{ name: 'exclusiveMode', type: types_.BOOLEAN }
]);
- var result = native_.callSync('NFCManager_setExclusiveMode', {
+ var result = native_.callSync('NFCManagerSetExclusiveMode', {
exclusiveMode: args.exclusiveMode
});
function NFCAdapter() {
function poweredGetter() {
- var ret = native_.callSync('NFCAdapter_getPowered');
+ var ret = native_.callSync('NFCAdapterGetPowered');
if (native_.isFailure(ret)) {
return false;
}
function cardEmulationModeGetter() {
- var result = native_.callSync('NFCAdapter_cardEmulationModeGetter');
+ var result = native_.callSync('NFCAdapterCardEmulationModeGetter');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
{ name: 'emulationMode', type: types_.STRING }
]);
- var result = native_.callSync('NFCAdapter_cardEmulationModeSetter', {
+ var result = native_.callSync('NFCAdapterCardEmulationModeSetter', {
emulationMode: args.emulationMode
});
}
function activeSecureElementGetter() {
- var result = native_.callSync('NFCAdapter_activeSecureElementGetter');
+ var result = native_.callSync('NFCAdapterActiveSecureElementGetter');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
{ name: 'secureElement', type: types_.STRING }
]);
- var result = native_.callSync('NFCAdapter_activeSecureElementSetter', {
+ var result = native_.callSync('NFCAdapterActiveSecureElementSetter', {
secureElement: args.secureElement
});
]);
var result = native_.call(
- 'NFCAdapter_setPowered',
+ 'NFCAdapterSetPowered',
{
powered: args.powered
},
// Register (acivate) core listener if not done yet
if (!native_.isListenerSet(TAG_LISTENER)) {
- var result = native_.callSync('NFCAdapter_setTagListener');
+ var result = native_.callSync('NFCAdapterSetTagListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
};
if (!native_.isListenerSet(PEER_LISTENER)) {
- var result = native_.callSync('NFCAdapter_setPeerListener');
+ var result = native_.callSync('NFCAdapterSetPeerListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
NFCAdapter.prototype.unsetTagListener = function() {
native_.removeListener(TAG_LISTENER);
- var result = native_.callSync('NFCAdapter_unsetTagListener');
+ var result = native_.callSync('NFCAdapterUnsetTagListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
NFCAdapter.prototype.unsetPeerListener = function() {
native_.removeListener(PEER_LISTENER);
- var result = native_.callSync('NFCAdapter_unsetPeerListener');
+ var result = native_.callSync('NFCAdapterUnsetPeerListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
type_.isEmptyObject(cardEmulationModeListener.listeners) &&
type_.isEmptyObject(activeSecureElementChangeListener.listeners)
) {
- var result = native_.callSync('NFCAdapter_addCardEmulationModeChangeListener');
+ var result = native_.callSync('NFCAdapterAddCardEmulationModeChangeListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
type_.isEmptyObject(cardEmulationModeListener.listeners) &&
type_.isEmptyObject(activeSecureElementChangeListener.listeners)
) {
- var result = native_.callSync('NFCAdapter_removeCardEmulationModeChangeListener');
+ var result = native_.callSync('NFCAdapterRemoveCardEmulationModeChangeListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
if (SecureElementType.ESE === args.type) {
if (type_.isEmptyObject(transactionEventListenerEse.listeners)) {
- result = native_.callSync('NFCAdapter_addTransactionEventListener', {
+ result = native_.callSync('NFCAdapterAddTransactionEventListener', {
type: args.type
});
if (native_.isFailure(result)) {
return transactionEventListenerEse.addListener(args.callback);
} else {
if (type_.isEmptyObject(transactionEventListenerUicc.listeners)) {
- result = native_.callSync('NFCAdapter_addTransactionEventListener', {
+ result = native_.callSync('NFCAdapterAddTransactionEventListener', {
type: args.type
});
if (native_.isFailure(result)) {
transactionEventListenerUicc.removeListener(args.watchId);
if (type_.isEmptyObject(transactionEventListenerEse.listeners) && !ese_empty) {
- var result = native_.callSync('NFCAdapter_removeTransactionEventListener', {
+ var result = native_.callSync('NFCAdapterRemoveTransactionEventListener', {
type: SecureElementType.ESE
});
}
if (type_.isEmptyObject(transactionEventListenerUicc.listeners) && !uicc_empty) {
- var result = native_.callSync('NFCAdapter_removeTransactionEventListener', {
+ var result = native_.callSync('NFCAdapterRemoveTransactionEventListener', {
type: SecureElementType.UICC
});
type_.isEmptyObject(cardEmulationModeListener.listeners) &&
type_.isEmptyObject(activeSecureElementChangeListener.listeners)
) {
- var result = native_.callSync('NFCAdapter_addActiveSecureElementChangeListener');
+ var result = native_.callSync('NFCAdapterAddActiveSecureElementChangeListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
type_.isEmptyObject(cardEmulationModeListener.listeners) &&
type_.isEmptyObject(activeSecureElementChangeListener.listeners)
) {
- var result = native_.callSync('NFCAdapter_removeCardEmulationModeChangeListener');
+ var result = native_.callSync('NFCAdapterRemoveCardEmulationModeChangeListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
};
NFCAdapter.prototype.getCachedMessage = function() {
- var result = native_.callSync('NFCAdapter_getCachedMessage');
+ var result = native_.callSync('NFCAdapterGetCachedMessage');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
]);
- var result = native_.callSync('NFCAdapter_setExclusiveModeForTransaction', {
+ var result = native_.callSync('NFCAdapterSetExclusiveModeForTransaction', {
transactionMode: args.transactionMode
});
}
if (type_.isEmptyObject(HCEEventListener.listeners)) {
- var result = native_.callSync('NFCAdapter_addHCEEventListener');
+ var result = native_.callSync('NFCAdapterAddHCEEventListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
HCEEventListener.removeListener(args.watchId);
if (type_.isEmptyObject(HCEEventListener.listeners)) {
- var result = native_.callSync('NFCAdapter_removeHCEEventListener');
+ var result = native_.callSync('NFCAdapterRemoveHCEEventListener');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
native_.callIfPossible(args.successCallback);
};
- var result = native_.call('NFCAdapter_sendHostAPDUResponse', data, callback);
+ var result = native_.call('NFCAdapterSendHostAPDUResponse', data, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
aid: args.aid
};
- var result = native_.callSync('NFCAdapter_isActivatedHandlerForAID', data);
+ var result = native_.callSync('NFCAdapterIsActivatedHandlerForAID', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
category: args.category
};
- var result = native_.callSync('NFCAdapter_isActivatedHandlerForCategory', data);
+ var result = native_.callSync('NFCAdapterIsActivatedHandlerForCategory', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
category: args.category
};
- var result = native_.callSync('NFCAdapter_registerAID', data);
+ var result = native_.callSync('NFCAdapterRegisterAID', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
category: args.category
};
- var result = native_.callSync('NFCAdapter_unregisterAID', data);
+ var result = native_.callSync('NFCAdapterUnregisterAID', data);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
native_.callIfPossible(args.successCallback, aids);
};
- var result = native_.call('NFCAdapter_getAIDsForCategory', data, callback);
+ var result = native_.call('NFCAdapterGetAIDsForCategory', data, callback);
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
function WebkitVisibilityChangeListener() {
var result;
if (true === privUtils_.global.document.hidden) {
- result = native_.call('NFCAdapter_unsetPreferredApp');
+ result = native_.call('NFCAdapterUnsetPreferredApp');
} else if (false === privUtils_.global.document.hidden) {
- result = native_.call('NFCAdapter_setPreferredApp');
+ result = native_.call('NFCAdapterSetPreferredApp');
}
if (native_.isFailure(result)) {
}
NFCAdapter.prototype.setPreferredApp = function() {
- var result = native_.call('NFCAdapter_setPreferredApp');
+ var result = native_.call('NFCAdapterSetPreferredApp');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
};
NFCAdapter.prototype.unsetPreferredApp = function() {
- var result = native_.call('NFCAdapter_unsetPreferredApp');
+ var result = native_.call('NFCAdapterUnsetPreferredApp');
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
var _my_id = tagid;
function TypeGetter() {
- var result = native_.callSync('NFCTag_typeGetter', { id: _my_id });
+ var result = native_.callSync('NFCTagTypeGetter', { id: _my_id });
if (native_.isFailure(result)) {
return;
}
function IsSupportedNDEFGetter() {
- var result = native_.callSync('NFCTag_isSupportedNDEFGetter', { id: _my_id });
+ var result = native_.callSync('NFCTagIsSupportedNDEFGetter', { id: _my_id });
if (native_.isFailure(result)) {
return;
}
function NDEFSizeGetter() {
- var result = native_.callSync('NFCTag_NDEFSizeGetter', { id: _my_id });
+ var result = native_.callSync('NFCTagNDEFSizeGetter', { id: _my_id });
if (native_.isFailure(result)) {
return;
}
function PropertiesGetter() {
- var result = native_.callSync('NFCTag_propertiesGetter', { id: _my_id });
+ var result = native_.callSync('NFCTagPropertiesGetter', { id: _my_id });
if (native_.isFailure(result)) {
return;
}
function IsConnectedGetter() {
- var result = native_.callSync('NFCTag_isConnectedGetter', { id: _my_id });
+ var result = native_.callSync('NFCTagIsConnectedGetter', { id: _my_id });
if (native_.isFailure(result)) {
return;
}
]);
- var result = native_.call('NFCTag_readNDEF', { id: _my_id }, function(result) {
+ var result = native_.call('NFCTagReadNDEF', { id: _my_id }, function(result) {
if (native_.isFailure(result)) {
if (!type_.isNullOrUndefined(args.errorCallback)) {
args.errorCallback(native_.getErrorObject(result));
]);
var result = native_.call(
- 'NFCTag_writeNDEF',
+ 'NFCTagWriteNDEF',
{
id: _my_id,
records: args.message.records,
]);
var result = native_.call(
- 'NFCTag_transceive',
+ 'NFCTagTransceive',
{
id: _my_id,
data: args.data
var _my_id = peerid;
function isConnectedGetter() {
- var ret = native_.callSync('NFCAdapter_PeerIsConnectedGetter', { id: _my_id });
+ var ret = native_.callSync('NFCAdapterPeerIsConnectedGetter', { id: _my_id });
if (native_.isFailure(ret)) {
return false;
}
]);
var result = native_.call(
- 'NFCPeer_sendNDEF',
+ 'NFCPeerSendNDEF',
{
id: _my_id,
records: args.message.records,
args.listener(data);
};
- var result = native_.callSync('NFCPeer_setReceiveNDEFListener', { id: _my_id });
+ var result = native_.callSync('NFCPeerSetReceiveNDEFListener', { id: _my_id });
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
native_.removeListener(RECEIVE_NDEF_LISTENER);
- var result = native_.callSync('NFCPeer_unsetReceiveNDEFListener', { id: _my_id });
+ var result = native_.callSync('NFCPeerUnsetReceiveNDEFListener', { id: _my_id });
if (native_.isFailure(result)) {
throw native_.getErrorObject(result);
}
records_ = data;
} else {
var raw_data_ = toByteArray(data);
- var result = native_.callSync('NDEFMessage_constructor', {
+ var result = native_.callSync('NDEFMessageConstructor', {
rawData: raw_data_,
rawDataSize: raw_data_.length
});
};
tizen.NDEFMessage.prototype.toByte = function() {
- var result = native_.callSync('NDEFMessage_toByte', {
+ var result = native_.callSync('NDEFMessageToByte', {
records: this.records,
recordsSize: this.recordCount
});
if (arguments.length >= 1) {
if (type_.isArray(first)) {
var raw_data_ = toByteArray(first);
- var result = native_.callSync('NDEFRecord_constructor', {
+ var result = native_.callSync('NDEFRecordConstructor', {
rawData: raw_data_,
rawDataSize: raw_data_.length
});
internal_.id
);
} else {
- var result = native_.callSync('NDEFRecordText_constructor', {
+ var result = native_.callSync('NDEFRecordTextConstructor', {
text: text_,
languageCode: languageCode_,
encoding: encoding_
internal_.id
);
} else {
- var result = native_.callSync('NDEFRecordURI_constructor', {
+ var result = native_.callSync('NDEFRecordURIConstructor', {
uri: uri_
});
if (native_.isFailure(result)) {
);
} else {
data_ = toByteArray(data, Math.pow(2, 32) - 1);
- var result = native_.callSync('NDEFRecordMedia_constructor', {
+ var result = native_.callSync('NDEFRecordMediaConstructor', {
mimeType: mimeType_,
data: data_,
dataSize: data_.length
ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
-#define REGISTER_ASYNC(c, x) RegisterSyncHandler(c, std::bind(&NFCInstance::x, this, _1, _2));
-#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&NFCInstance::x, this, _1, _2));
- REGISTER_SYNC("NFCManager_getDefaultAdapter", GetDefaultAdapter);
- REGISTER_SYNC("NFCManager_setExclusiveMode", SetExclusiveMode);
- REGISTER_ASYNC("NFCAdapter_setPowered", SetPowered);
- REGISTER_SYNC("NFCAdapter_getPowered", GetPowered);
- REGISTER_SYNC("NFCAdapter_cardEmulationModeSetter", CardEmulationModeSetter);
- REGISTER_SYNC("NFCAdapter_cardEmulationModeGetter", CardEmulationModeGetter);
- REGISTER_SYNC("NFCAdapter_activeSecureElementSetter", ActiveSecureElementSetter);
- REGISTER_SYNC("NFCAdapter_activeSecureElementGetter", ActiveSecureElementGetter);
- REGISTER_SYNC("NFCAdapter_setPeerListener", SetPeerListener);
- REGISTER_SYNC("NFCAdapter_setTagListener", SetTagListener);
- REGISTER_SYNC("NFCAdapter_PeerIsConnectedGetter", PeerIsConnectedGetter);
- REGISTER_SYNC("NFCAdapter_unsetTagListener", UnsetTagListener);
- REGISTER_SYNC("NFCAdapter_unsetPeerListener", UnsetPeerListener);
- REGISTER_SYNC("NFCAdapter_addCardEmulationModeChangeListener",
- AddCardEmulationModeChangeListener);
- REGISTER_SYNC("NFCAdapter_removeCardEmulationModeChangeListener",
- RemoveCardEmulationModeChangeListener);
- REGISTER_SYNC("NFCAdapter_addTransactionEventListener", AddTransactionEventListener);
- REGISTER_SYNC("NFCAdapter_removeTransactionEventListener", RemoveTransactionEventListener);
- REGISTER_SYNC("NFCAdapter_addActiveSecureElementChangeListener",
- AddActiveSecureElementChangeListener);
- REGISTER_SYNC("NFCAdapter_removeActiveSecureElementChangeListener",
- RemoveActiveSecureElementChangeListener);
- REGISTER_SYNC("NFCAdapter_getCachedMessage", GetCachedMessage);
- REGISTER_SYNC("NFCAdapter_setExclusiveModeForTransaction", SetExclusiveModeForTransaction);
+
+#define REGISTER_METHOD(M) \
+ RegisterSyncHandler(#M, std::bind(&NFCInstance::M, this, _1, _2))
+ REGISTER_METHOD(NFCManagerGetDefaultAdapter);
+ REGISTER_METHOD(NFCManagerSetExclusiveMode);
+ REGISTER_METHOD(NFCAdapterSetPowered);
+ REGISTER_METHOD(NFCAdapterGetPowered);
+ REGISTER_METHOD(NFCAdapterCardEmulationModeSetter);
+ REGISTER_METHOD(NFCAdapterCardEmulationModeGetter);
+ REGISTER_METHOD(NFCAdapterActiveSecureElementSetter);
+ REGISTER_METHOD(NFCAdapterActiveSecureElementGetter);
+ REGISTER_METHOD(NFCAdapterSetPeerListener);
+ REGISTER_METHOD(NFCAdapterSetTagListener);
+ REGISTER_METHOD(NFCAdapterPeerIsConnectedGetter);
+ REGISTER_METHOD(NFCAdapterUnsetTagListener);
+ REGISTER_METHOD(NFCAdapterUnsetPeerListener);
+ REGISTER_METHOD(NFCAdapterAddCardEmulationModeChangeListener);
+ REGISTER_METHOD(NFCAdapterRemoveCardEmulationModeChangeListener);
+ REGISTER_METHOD(NFCAdapterAddTransactionEventListener);
+ REGISTER_METHOD(NFCAdapterRemoveTransactionEventListener);
+ REGISTER_METHOD(NFCAdapterAddActiveSecureElementChangeListener);
+ REGISTER_METHOD(NFCAdapterRemoveActiveSecureElementChangeListener);
+ REGISTER_METHOD(NFCAdapterGetCachedMessage);
+ REGISTER_METHOD(NFCAdapterSetExclusiveModeForTransaction);
// HCE related methods
- REGISTER_SYNC("NFCAdapter_addHCEEventListener", AddHCEEventListener);
- REGISTER_SYNC("NFCAdapter_removeHCEEventListener", RemoveHCEEventListener);
- REGISTER_ASYNC("NFCAdapter_sendHostAPDUResponse", SendHostAPDUResponse);
- REGISTER_SYNC("NFCAdapter_isActivatedHandlerForAID", IsActivatedHandlerForAID);
- REGISTER_SYNC("NFCAdapter_isActivatedHandlerForCategory", IsActivatedHandlerForCategory);
- REGISTER_SYNC("NFCAdapter_registerAID", RegisterAID);
- REGISTER_SYNC("NFCAdapter_unregisterAID", UnregisterAID);
- REGISTER_ASYNC("NFCAdapter_getAIDsForCategory", GetAIDsForCategory);
- REGISTER_SYNC("NFCAdapter_setPreferredApp", SetPreferredApp);
- REGISTER_SYNC("NFCAdapter_unsetPreferredApp", UnsetPreferredApp);
-
- REGISTER_SYNC("NFCPeer_setReceiveNDEFListener", SetReceiveNDEFListener);
- REGISTER_SYNC("NFCPeer_unsetReceiveNDEFListener", UnsetReceiveNDEFListener);
- REGISTER_SYNC("NDEFMessage_toByte", ToByte);
+ REGISTER_METHOD(NFCAdapterAddHCEEventListener);
+ REGISTER_METHOD(NFCAdapterRemoveHCEEventListener);
+ REGISTER_METHOD(NFCAdapterSendHostAPDUResponse);
+ REGISTER_METHOD(NFCAdapterIsActivatedHandlerForAID);
+ REGISTER_METHOD(NFCAdapterIsActivatedHandlerForCategory);
+ REGISTER_METHOD(NFCAdapterRegisterAID);
+ REGISTER_METHOD(NFCAdapterUnregisterAID);
+ REGISTER_METHOD(NFCAdapterGetAIDsForCategory);
+ REGISTER_METHOD(NFCAdapterSetPreferredApp);
+ REGISTER_METHOD(NFCAdapterUnsetPreferredApp);
+
+ REGISTER_METHOD(NFCPeerSetReceiveNDEFListener);
+ REGISTER_METHOD(NFCPeerUnsetReceiveNDEFListener);
+
// Message related methods
- REGISTER_SYNC("NDEFMessage_constructor", NDEFMessageContructor);
- REGISTER_SYNC("NDEFRecord_constructor", NDEFRecordContructor);
- REGISTER_SYNC("NDEFRecordText_constructor", NDEFRecordTextContructor);
- REGISTER_SYNC("NDEFRecordURI_constructor", NDEFRecordURIContructor);
- REGISTER_SYNC("NDEFRecordMedia_constructor", NDEFRecordMediaContructor);
+ REGISTER_METHOD(NDEFMessageToByte);
+ REGISTER_METHOD(NDEFMessageConstructor);
+ REGISTER_METHOD(NDEFRecordConstructor);
+ REGISTER_METHOD(NDEFRecordTextConstructor);
+ REGISTER_METHOD(NDEFRecordURIConstructor);
+ REGISTER_METHOD(NDEFRecordMediaConstructor);
// NFCTag attributes getters
- REGISTER_SYNC("NFCTag_typeGetter", TagTypeGetter);
- REGISTER_SYNC("NFCTag_isSupportedNDEFGetter", TagIsSupportedNDEFGetter);
- REGISTER_SYNC("NFCTag_NDEFSizeGetter", TagNDEFSizeGetter);
- REGISTER_SYNC("NFCTag_propertiesGetter", TagPropertiesGetter);
- REGISTER_SYNC("NFCTag_isConnectedGetter", TagIsConnectedGetter);
-
- REGISTER_ASYNC("NFCTag_readNDEF", ReadNDEF);
- REGISTER_ASYNC("NFCTag_writeNDEF", WriteNDEF);
- REGISTER_ASYNC("NFCTag_transceive", Transceive);
- REGISTER_ASYNC("NFCPeer_sendNDEF", SendNDEF);
-#undef REGISTER_SYNC
-#undef REGISTER_ASYNC
+ REGISTER_METHOD(NFCTagTypeGetter);
+ REGISTER_METHOD(NFCTagIsSupportedNDEFGetter);
+ REGISTER_METHOD(NFCTagNDEFSizeGetter);
+ REGISTER_METHOD(NFCTagPropertiesGetter);
+ REGISTER_METHOD(NFCTagIsConnectedGetter);
+
+ REGISTER_METHOD(NFCTagReadNDEF);
+ REGISTER_METHOD(NFCTagWriteNDEF);
+ REGISTER_METHOD(NFCTagTransceive);
+ REGISTER_METHOD(NFCPeerSendNDEF);
+#undef REGISTER_METHOD
// Set a PostMessageHandler at NFCAdapter to provide mechanizm of returning
// asynchronous response
NFCAdapter::GetInstance()->SetResponder(nullptr);
}
-void NFCInstance::GetDefaultAdapter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCManagerGetDefaultAdapter(const picojson::value& args, picojson::object& out) {
// Default NFC adapter is created at JS level
// Here there's only check for NFC support
ScopeLogger();
}
}
-void NFCInstance::SetExclusiveMode(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCManagerSetExclusiveMode(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCommon, &out);
}
// TODO(g.rynkowski): Rewrite to asynchronous approach
-void NFCInstance::SetPowered(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterSetPowered(const picojson::value& args, picojson::object& out) {
ScopeLogger();
LoggerW(
"DEPRECATION WARNING: setPowered() is deprecated and will be removed from next release. Let "
}
}
-void NFCInstance::GetPowered(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterGetPowered(const picojson::value& args, picojson::object& out) {
ScopeLogger();
bool ret = NFCAdapter::GetInstance()->GetPowered();
ReportSuccess(picojson::value(ret), out);
}
-void NFCInstance::CardEmulationModeSetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterCardEmulationModeSetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::CardEmulationModeGetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterCardEmulationModeGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::ActiveSecureElementSetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterActiveSecureElementSetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::ActiveSecureElementGetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterActiveSecureElementGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::SetTagListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterSetTagListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
bool supported = isTagSupported();
}
}
-void NFCInstance::PeerIsConnectedGetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterPeerIsConnectedGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_EXIST(args, "id", out);
}
}
-void NFCInstance::SetPeerListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterSetPeerListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
bool supported = isP2PSupported();
}
}
-void NFCInstance::UnsetTagListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterUnsetTagListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
bool supported = isTagSupported();
ReportSuccess(out);
}
-void NFCInstance::UnsetPeerListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterUnsetPeerListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
bool supported = isP2PSupported();
}
}
-void NFCInstance::AddCardEmulationModeChangeListener(const picojson::value& args,
+void NFCInstance::NFCAdapterAddCardEmulationModeChangeListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::RemoveCardEmulationModeChangeListener(const picojson::value& args,
+void NFCInstance::NFCAdapterRemoveCardEmulationModeChangeListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::AddTransactionEventListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterAddTransactionEventListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::RemoveTransactionEventListener(const picojson::value& args,
+void NFCInstance::NFCAdapterRemoveTransactionEventListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::AddActiveSecureElementChangeListener(const picojson::value& args,
+void NFCInstance::NFCAdapterAddActiveSecureElementChangeListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::RemoveActiveSecureElementChangeListener(const picojson::value& args,
+void NFCInstance::NFCAdapterRemoveActiveSecureElementChangeListener(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::GetCachedMessage(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterGetCachedMessage(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCommon, &out);
}
}
-void NFCInstance::SetExclusiveModeForTransaction(const picojson::value& args,
+void NFCInstance::NFCAdapterSetExclusiveModeForTransaction(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
// TODO(g.rynkowski): Rewrite to asynchronous approach
-void NFCInstance::ReadNDEF(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCTagReadNDEF(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
}
// TODO(g.rynkowski): Rewrite to asynchronous approach
-void NFCInstance::WriteNDEF(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCTagWriteNDEF(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
}
// TODO(g.rynkowski): Rewrite to asynchronous approach
-void NFCInstance::Transceive(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCTagTransceive(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
}
}
-void NFCInstance::SetReceiveNDEFListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCPeerSetReceiveNDEFListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
}
}
-void NFCInstance::UnsetReceiveNDEFListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCPeerUnsetReceiveNDEFListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
}
// TODO(g.rynkowski): Rewrite to asynchronous approach
-void NFCInstance::SendNDEF(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCPeerSendNDEF(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
}
}
-void NFCInstance::ToByte(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NDEFMessageToByte(const picojson::value& args, picojson::object& out) {
ScopeLogger();
picojson::value result = picojson::value(picojson::object());
}
// Message related methods
-void NFCInstance::NDEFMessageContructor(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NDEFMessageConstructor(const picojson::value& args, picojson::object& out) {
ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
}
-void NFCInstance::NDEFRecordContructor(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NDEFRecordConstructor(const picojson::value& args, picojson::object& out) {
ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
}
-void NFCInstance::NDEFRecordTextContructor(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NDEFRecordTextConstructor(const picojson::value& args, picojson::object& out) {
ScopeLogger();
picojson::value result = picojson::value(picojson::object());
}
}
-void NFCInstance::NDEFRecordURIContructor(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NDEFRecordURIConstructor(const picojson::value& args, picojson::object& out) {
ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
}
-void NFCInstance::NDEFRecordMediaContructor(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NDEFRecordMediaConstructor(const picojson::value& args, picojson::object& out) {
ScopeLogger();
picojson::value result = picojson::value(picojson::object());
}
// NFCTag attributes getters
-void NFCInstance::TagTypeGetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCTagTypeGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_EXIST(args, "id", out);
}
}
-void NFCInstance::TagIsSupportedNDEFGetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCTagIsSupportedNDEFGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
int tag_id = (int)args.get("id").get<double>();
}
}
-void NFCInstance::TagNDEFSizeGetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCTagNDEFSizeGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
int tag_id = (int)args.get("id").get<double>();
}
}
-void NFCInstance::TagPropertiesGetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCTagPropertiesGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
int tag_id = (int)args.get("id").get<double>();
}
}
-void NFCInstance::TagIsConnectedGetter(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCTagIsConnectedGetter(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_EXIST(args, "id", out);
}
}
-void NFCInstance::AddHCEEventListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterAddHCEEventListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::RemoveHCEEventListener(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterRemoveHCEEventListener(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::SendHostAPDUResponse(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterSendHostAPDUResponse(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
&NFCAdapter::SendHostAPDUResponse, NFCAdapter::GetInstance(), apdu, success_cb, error_cb));
}
-void NFCInstance::IsActivatedHandlerForAID(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterIsActivatedHandlerForAID(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::IsActivatedHandlerForCategory(const picojson::value& args,
+void NFCInstance::NFCAdapterIsActivatedHandlerForCategory(const picojson::value& args,
picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::RegisterAID(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterRegisterAID(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::UnregisterAID(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterUnregisterAID(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::GetAIDsForCategory(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterGetAIDsForCategory(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
required_category, success_cb, error_cb));
}
-void NFCInstance::SetPreferredApp(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterSetPreferredApp(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
}
}
-void NFCInstance::UnsetPreferredApp(const picojson::value& args, picojson::object& out) {
+void NFCInstance::NFCAdapterUnsetPreferredApp(const picojson::value& args, picojson::object& out) {
ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
void RespondAsync(const char* msg);
private:
- void GetDefaultAdapter(const picojson::value& args, picojson::object& out);
- void SetExclusiveMode(const picojson::value& args, picojson::object& out);
- void SetPowered(const picojson::value& args, picojson::object& out);
- void GetPowered(const picojson::value& args, picojson::object& out);
- void CardEmulationModeSetter(const picojson::value& args, picojson::object& out);
- void CardEmulationModeGetter(const picojson::value& args, picojson::object& out);
- void ActiveSecureElementSetter(const picojson::value& args, picojson::object& out);
- void ActiveSecureElementGetter(const picojson::value& args, picojson::object& out);
- void SetTagListener(const picojson::value& args, picojson::object& out);
- void PeerIsConnectedGetter(const picojson::value& args, picojson::object& out);
- void SetPeerListener(const picojson::value& args, picojson::object& out);
- void UnsetTagListener(const picojson::value& args, picojson::object& out);
- void UnsetPeerListener(const picojson::value& args, picojson::object& out);
- void AddCardEmulationModeChangeListener(const picojson::value& args, picojson::object& out);
- void RemoveCardEmulationModeChangeListener(const picojson::value& args, picojson::object& out);
- void AddTransactionEventListener(const picojson::value& args, picojson::object& out);
- void RemoveTransactionEventListener(const picojson::value& args, picojson::object& out);
- void AddActiveSecureElementChangeListener(const picojson::value& args, picojson::object& out);
- void RemoveActiveSecureElementChangeListener(const picojson::value& args, picojson::object& out);
- void GetCachedMessage(const picojson::value& args, picojson::object& out);
- void SetExclusiveModeForTransaction(const picojson::value& args, picojson::object& out);
- void ReadNDEF(const picojson::value& args, picojson::object& out);
- void WriteNDEF(const picojson::value& args, picojson::object& out);
- void Transceive(const picojson::value& args, picojson::object& out);
- void SetReceiveNDEFListener(const picojson::value& args, picojson::object& out);
- void UnsetReceiveNDEFListener(const picojson::value& args, picojson::object& out);
- void SendNDEF(const picojson::value& args, picojson::object& out);
- void ToByte(const picojson::value& args, picojson::object& out);
+ void NFCManagerGetDefaultAdapter(const picojson::value& args, picojson::object& out);
+ void NFCManagerSetExclusiveMode(const picojson::value& args, picojson::object& out);
+ void NFCAdapterSetPowered(const picojson::value& args, picojson::object& out);
+ void NFCAdapterGetPowered(const picojson::value& args, picojson::object& out);
+ void NFCAdapterCardEmulationModeSetter(const picojson::value& args, picojson::object& out);
+ void NFCAdapterCardEmulationModeGetter(const picojson::value& args, picojson::object& out);
+ void NFCAdapterActiveSecureElementSetter(const picojson::value& args, picojson::object& out);
+ void NFCAdapterActiveSecureElementGetter(const picojson::value& args, picojson::object& out);
+ void NFCAdapterSetTagListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterPeerIsConnectedGetter(const picojson::value& args, picojson::object& out);
+ void NFCAdapterSetPeerListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterUnsetTagListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterUnsetPeerListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterAddCardEmulationModeChangeListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterRemoveCardEmulationModeChangeListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterAddTransactionEventListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterRemoveTransactionEventListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterAddActiveSecureElementChangeListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterRemoveActiveSecureElementChangeListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterGetCachedMessage(const picojson::value& args, picojson::object& out);
+ void NFCAdapterSetExclusiveModeForTransaction(const picojson::value& args, picojson::object& out);
+ void NFCTagReadNDEF(const picojson::value& args, picojson::object& out);
+ void NFCTagWriteNDEF(const picojson::value& args, picojson::object& out);
+ void NFCTagTransceive(const picojson::value& args, picojson::object& out);
+ void NFCPeerSetReceiveNDEFListener(const picojson::value& args, picojson::object& out);
+ void NFCPeerUnsetReceiveNDEFListener(const picojson::value& args, picojson::object& out);
+ void NFCPeerSendNDEF(const picojson::value& args, picojson::object& out);
// Message related methods
- void NDEFMessageContructor(const picojson::value& args, picojson::object& out);
+ void NDEFMessageConstructor(const picojson::value& args, picojson::object& out);
void NDEFMessageToByte(const picojson::value& args, picojson::object& out);
- void NDEFRecordContructor(const picojson::value& args, picojson::object& out);
- void NDEFRecordTextContructor(const picojson::value& args, picojson::object& out);
- void NDEFRecordURIContructor(const picojson::value& args, picojson::object& out);
- void NDEFRecordMediaContructor(const picojson::value& args, picojson::object& out);
+ void NDEFRecordConstructor(const picojson::value& args, picojson::object& out);
+ void NDEFRecordTextConstructor(const picojson::value& args, picojson::object& out);
+ void NDEFRecordURIConstructor(const picojson::value& args, picojson::object& out);
+ void NDEFRecordMediaConstructor(const picojson::value& args, picojson::object& out);
// NFCTag attributes getters
- void TagTypeGetter(const picojson::value& args, picojson::object& out);
- void TagIsSupportedNDEFGetter(const picojson::value& args, picojson::object& out);
- void TagNDEFSizeGetter(const picojson::value& args, picojson::object& out);
- void TagPropertiesGetter(const picojson::value& args, picojson::object& out);
- void TagIsConnectedGetter(const picojson::value& args, picojson::object& out);
+ void NFCTagTypeGetter(const picojson::value& args, picojson::object& out);
+ void NFCTagIsSupportedNDEFGetter(const picojson::value& args, picojson::object& out);
+ void NFCTagNDEFSizeGetter(const picojson::value& args, picojson::object& out);
+ void NFCTagPropertiesGetter(const picojson::value& args, picojson::object& out);
+ void NFCTagIsConnectedGetter(const picojson::value& args, picojson::object& out);
// HCE related methods
- void AddHCEEventListener(const picojson::value& args, picojson::object& out);
- void RemoveHCEEventListener(const picojson::value& args, picojson::object& out);
- void SendHostAPDUResponse(const picojson::value& args, picojson::object& out);
- void IsActivatedHandlerForAID(const picojson::value& args, picojson::object& out);
- void IsActivatedHandlerForCategory(const picojson::value& args, picojson::object& out);
- void RegisterAID(const picojson::value& args, picojson::object& out);
- void UnregisterAID(const picojson::value& args, picojson::object& out);
- void GetAIDsForCategory(const picojson::value& args, picojson::object& out);
- void SetPreferredApp(const picojson::value& args, picojson::object& out);
- void UnsetPreferredApp(const picojson::value& args, picojson::object& out);
+ void NFCAdapterAddHCEEventListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterRemoveHCEEventListener(const picojson::value& args, picojson::object& out);
+ void NFCAdapterSendHostAPDUResponse(const picojson::value& args, picojson::object& out);
+ void NFCAdapterIsActivatedHandlerForAID(const picojson::value& args, picojson::object& out);
+ void NFCAdapterIsActivatedHandlerForCategory(const picojson::value& args, picojson::object& out);
+ void NFCAdapterRegisterAID(const picojson::value& args, picojson::object& out);
+ void NFCAdapterUnregisterAID(const picojson::value& args, picojson::object& out);
+ void NFCAdapterGetAIDsForCategory(const picojson::value& args, picojson::object& out);
+ void NFCAdapterSetPreferredApp(const picojson::value& args, picojson::object& out);
+ void NFCAdapterUnsetPreferredApp(const picojson::value& args, picojson::object& out);
};
} // namespace nfc
projects / platform / core / api / webapi-plugins.git / commitdiff