759 lines
27 KiB
Plaintext
759 lines
27 KiB
Plaintext
#include "JcWallet.h"
|
|
#include "WalletEvent.h"
|
|
#include <atomic>
|
|
#include <iostream>
|
|
#include "stdarg.h"
|
|
#include <string>
|
|
#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
|
|
#include "cocos/scripting/js-bindings/manual/jsb_global.h"
|
|
#include "scripting/js-bindings/event/EventDispatcher.h"
|
|
#include "scripting/js-bindings/manual/jsb_conversions.hpp"
|
|
#include "platform/CCApplication.h"
|
|
#include "base/CCScheduler.h"
|
|
#include "scrypt/native-crypto.h"
|
|
|
|
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC)
|
|
#include "AppDelegate.h"
|
|
#import "UIViewController+Wallet.h"
|
|
#import "UIViewController+QR.h"
|
|
#import "UIViewController+Purchase.h"
|
|
#import "GlobalData.h"
|
|
#endif
|
|
|
|
#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
|
|
|
|
cocos2d::Application *cocos_android_app_init(int width, int height);
|
|
|
|
#endif
|
|
using namespace cocos2d;
|
|
NS_CC_BEGIN
|
|
|
|
cocos2d::Application *g_app = nullptr;
|
|
JcWallet *JcWallet::_instance = nullptr;
|
|
uv_loop_t *loop = nullptr;
|
|
bool _isStarted = false;
|
|
uv_async_t gasync = {0};
|
|
|
|
struct AsyncTaskData {
|
|
std::mutex mtx;
|
|
std::list<std::function<void()> > tasks;
|
|
};
|
|
|
|
// run in server thread loop
|
|
void flush_tasks_in_server_loop_cb(uv_async_t *asyn) {
|
|
AsyncTaskData *data = (AsyncTaskData *) asyn->data;
|
|
std::lock_guard<std::mutex> guard(data->mtx);
|
|
while (!data->tasks.empty()) {
|
|
// fetch task, run task
|
|
data->tasks.front()();
|
|
// drop task
|
|
data->tasks.pop_front();
|
|
}
|
|
|
|
}
|
|
|
|
void init_libuv_async_handle(uv_async_t *async) {
|
|
memset(async, 0, sizeof(uv_async_t));
|
|
// uv_loop_t *loop = uv_default_loop();
|
|
loop = (uv_loop_t*)malloc(sizeof(uv_loop_t));
|
|
uv_loop_init(loop);
|
|
uv_async_init(loop, async, cocos2d::flush_tasks_in_server_loop_cb);
|
|
async->data = new AsyncTaskData();
|
|
uv_run(loop, UV_RUN_DEFAULT);
|
|
}
|
|
|
|
// run in game thread, dispatch runnable object into server loop
|
|
int schedule_task_into_server_thread_task_queue(uv_async_t *asyn, std::function<void()> func) {
|
|
|
|
AsyncTaskData *data = (AsyncTaskData *) asyn->data;
|
|
{
|
|
std::lock_guard<std::mutex> guard(data->mtx);
|
|
data->tasks.emplace_back(func);
|
|
}
|
|
//notify server thread to invoke `flush_tasks_in_server_loop_cb()`
|
|
return uv_async_send(asyn);
|
|
}
|
|
#define RUN_IN_GAMETHREAD(task) \
|
|
do { \
|
|
JcWallet::getInstance()->performFunctionInCocosThread([=]() { \
|
|
task; \
|
|
});\
|
|
} while(0)
|
|
#define RUN_IN_SERVERTHREAD(task) do { \
|
|
schedule_task_into_server_thread_task_queue(&gasync, [=](){ \
|
|
task; \
|
|
}); \
|
|
} while(0)
|
|
|
|
bool runGlobalMethod(const char *name, se::ValueArray args, se::Value *value) {
|
|
se::AutoHandleScope scope;
|
|
bool ok = false;
|
|
auto global = se::ScriptEngine::getInstance()->getGlobalObject();
|
|
se::Value func;
|
|
if (global->getProperty(name, &func) && func.isObject()) {
|
|
ok = func.toObject()->call(args, global, value);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
bool addToArgArray(se::ValueArray *args, const char *valChar) {
|
|
std::string strVal(valChar);
|
|
se::Value tmpVal;
|
|
bool ok = true;
|
|
ok &= std_string_to_seval(strVal, &tmpVal);
|
|
args->push_back(tmpVal);
|
|
return ok;
|
|
}
|
|
|
|
JcWallet::JcWallet() {
|
|
JcWallet::_instance = this;
|
|
_functionsToPerform.reserve(30);
|
|
std::unique_lock<std::mutex> lock(_performMutex);
|
|
}
|
|
|
|
void JcWallet::initEnv() {
|
|
if (!_isStarted) {
|
|
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC)
|
|
g_app = new AppDelegate(1, 1);
|
|
#elif (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
|
|
g_app = cocos_android_app_init(1, 1);
|
|
#endif
|
|
EventDispatcher::init();
|
|
g_app->start();
|
|
_isStarted = true;
|
|
WalletEvent::Emit("wallet_init_event", "{}");
|
|
// RUN_IN_GAMETHREAD(JcWallet::getInstance()->jsToUnity("wallet_init_event", "{}"));
|
|
cocos2d::init_libuv_async_handle(&gasync);
|
|
}
|
|
}
|
|
|
|
void JcWallet::initJSThread(std::shared_ptr<JcWallet> wallet) {
|
|
wallet->initEnv();
|
|
}
|
|
|
|
void JcWallet::tick(float dt) {
|
|
g_app->getScheduler()->update(dt);
|
|
EventDispatcher::dispatchTickEvent(0);
|
|
}
|
|
|
|
JcWallet::~JcWallet() {
|
|
EventDispatcher::destroy();
|
|
se::ScriptEngine::destroyInstance();
|
|
uv_loop_close(loop);
|
|
JcWallet::_instance = nullptr;
|
|
}
|
|
|
|
char *JcWallet::runJsMethod(std::shared_ptr<JSMethodParam> data) {
|
|
cocos2d::log("thread: %p call method %s params: %lu", uv_thread_self(), data->methodName.c_str(), data->args.size());
|
|
se::Value value;
|
|
bool ok = cocos2d::runGlobalMethod(data->methodName.c_str(), data->args, &value);
|
|
static std::string result;
|
|
if (value.isString()) {
|
|
if (ok && !value.isNullOrUndefined()) {
|
|
result = value.toString();
|
|
} else {
|
|
result = "";
|
|
}
|
|
cocos2d::log("method: %s ::result: %s", data->methodName.c_str(), result.c_str());
|
|
RUN_IN_GAMETHREAD(JcWallet::getInstance()->jsToUnity(data->funId, result));
|
|
// WalletEvent::Emit(data->funId.c_str(), result.c_str());
|
|
}
|
|
return const_cast<char *>(result.c_str());
|
|
}
|
|
|
|
void JcWallet::performFunctionInCocosThread( const std::function<void()> &function) {
|
|
_performMutex.lock();
|
|
_functionsToPerform.push_back(function);
|
|
_performMutex.unlock();
|
|
}
|
|
|
|
void JcWallet::tickRun() {
|
|
_performMutex.lock();
|
|
if( !_functionsToPerform.empty() ) {
|
|
// fixed #4123: Save the callback functions, they must be invoked after '_performMutex.unlock()', otherwise if new functions are added in callback, it will cause thread deadlock.
|
|
auto temp = _functionsToPerform;
|
|
for( const auto &function : temp ) {
|
|
function();
|
|
}
|
|
_functionsToPerform.clear();
|
|
}
|
|
_performMutex.unlock();
|
|
}
|
|
|
|
void JcWallet::jsToUnity(std::string funId, std::string msg) {
|
|
WalletEvent::Emit(funId.c_str(), msg.c_str());
|
|
}
|
|
|
|
extern "C" {
|
|
void initEnv() {
|
|
if (!_isStarted) {
|
|
new JcWallet();
|
|
std::shared_ptr<JcWallet> wallet(JcWallet::getInstance());
|
|
std::thread([=]() {
|
|
JcWallet::initJSThread(wallet);
|
|
}).detach();
|
|
}
|
|
}
|
|
void tick(float dt) {
|
|
if (_isStarted) {
|
|
schedule_task_into_server_thread_task_queue(&gasync, [=](){
|
|
JcWallet::getInstance()->tick(dt);
|
|
});
|
|
JcWallet::getInstance()->tickRun();
|
|
}
|
|
}
|
|
|
|
int runWalletMethod(const char *funId, const char *methodName, int paramCount, char **paramList) {
|
|
if (!_isStarted) {
|
|
return 0;
|
|
}
|
|
JSMethodParam *data = new JSMethodParam();
|
|
std::string methodNameStr(methodName);
|
|
data->methodName = methodNameStr;
|
|
data->funId = funId;
|
|
data->paramCount = paramCount;
|
|
addToArgArray(&data->args, funId);
|
|
for (int i = 0; i < paramCount; i++) {
|
|
char *arg = *(paramList + i);
|
|
addToArgArray(&data->args, arg);
|
|
}
|
|
std::shared_ptr<JSMethodParam> params(data);
|
|
int result = schedule_task_into_server_thread_task_queue(&gasync, [=](){
|
|
JcWallet::getInstance()->runJsMethod(params);
|
|
});
|
|
return result == 0 ? 1 : 0;
|
|
}
|
|
}
|
|
|
|
int nativeCallJS(std::string funId, std::string methodName, std::vector<std::string> sparams) {
|
|
if (!_isStarted) {
|
|
return 0;
|
|
}
|
|
JSMethodParam *data = new JSMethodParam();
|
|
data->methodName = methodName;
|
|
data->funId = funId;
|
|
data->paramCount = sparams.size();
|
|
addToArgArray(&data->args, funId.c_str());
|
|
for (int i = 0; i < sparams.size(); i++) {
|
|
addToArgArray(&data->args, sparams[i].c_str());
|
|
}
|
|
|
|
std::shared_ptr<JSMethodParam> params(data);
|
|
int result = schedule_task_into_server_thread_task_queue(&gasync, [=](){
|
|
JcWallet::getInstance()->runJsMethod(params);
|
|
});
|
|
return result == 0 ? 1 : 0;
|
|
}
|
|
|
|
NS_CC_END
|
|
|
|
static bool getOrCreatePlainObject_r(const char* name, se::Object* parent, se::Object** outObj)
|
|
{
|
|
assert(parent != nullptr);
|
|
assert(outObj != nullptr);
|
|
se::Value tmp;
|
|
|
|
if (parent->getProperty(name, &tmp) && tmp.isObject())
|
|
{
|
|
*outObj = tmp.toObject();
|
|
(*outObj)->incRef();
|
|
}
|
|
else
|
|
{
|
|
*outObj = se::Object::createPlainObject();
|
|
parent->setProperty(name, se::Value(*outObj));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool jsb_wallet_callback(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 2) {
|
|
bool ok;
|
|
std::string funId;
|
|
ok = seval_to_std_string(args[0], &funId);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
std::string msg;
|
|
ok = seval_to_std_string(args[1], &msg);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
// if funId begin with "webpage_" then call webview callback
|
|
if (funId.find("webpage_") == 0) {
|
|
NSMutableDictionary *userInfo = [[NSMutableDictionary alloc] init];
|
|
userInfo[@"funid"] = [NSString stringWithCString:funId.c_str() encoding:NSUTF8StringEncoding];
|
|
userInfo[@"data"] = [NSString stringWithCString:msg.c_str() encoding:NSUTF8StringEncoding];
|
|
[[NSNotificationCenter defaultCenter]
|
|
postNotificationName:@"ProxyCBNotification"
|
|
object: nil userInfo:userInfo];
|
|
} else {
|
|
RUN_IN_GAMETHREAD(JcWallet::getInstance()->jsToUnity(funId, msg));
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_wallet_callback)
|
|
|
|
bool jsb_scanQRCode(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 2) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
std::string title;
|
|
ok = seval_to_std_string(args[1], &title);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
NSString *ntitle = [NSString stringWithCString:title.c_str() encoding:NSUTF8StringEncoding];
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController scanQRCode:nfunid title:ntitle];
|
|
// [window.rootViewController loadRestoreKey:nfunid oid: ntitle];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_scanQRCode)
|
|
|
|
bool jsb_signWithGoogle(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 1) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController signWithGoogle:nfunid];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_signWithGoogle)
|
|
|
|
bool jsb_signWithApple(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 1) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController signWithApple:nfunid];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_signWithApple)
|
|
|
|
bool jsb_signWithTikTok(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 1) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController signWithTikTok:nfunid];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_signWithTikTok)
|
|
|
|
bool jsb_signWithFacebook(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 1) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController signWithFacebook:nfunid];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_signWithFacebook)
|
|
|
|
bool jsb_signWithTwitter(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 1) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController signWithTwitter:nfunid];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_signWithTwitter)
|
|
|
|
bool jsb_signWithOAuth(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 2) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
std::string jsondata;
|
|
ok = seval_to_std_string(args[1], &jsondata);
|
|
SE_PRECONDITION2(ok, false, "jsondata is invalid!");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding:NSUTF8StringEncoding];
|
|
NSString *njsondata = [NSString stringWithCString:jsondata.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController signWithOAuth:nfunid jsondata:njsondata ];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_signWithOAuth)
|
|
|
|
bool jsb_signOutGoogle(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 1) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController signOutGoogle:nfunid];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_signOutGoogle)
|
|
bool JSB_showQRCode(se::State& s){
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc >= 2) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
std::string text;
|
|
ok = seval_to_std_string(args[1], &text);
|
|
SE_PRECONDITION2(ok, false, "content is invalid!");
|
|
NSString *ncontent = [NSString stringWithCString:text.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController showQRCode:ncontent];
|
|
});
|
|
return true;
|
|
}
|
|
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_showQRCode)
|
|
|
|
bool jsb_showWebPage(se::State& s) {
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc >= 2) {
|
|
bool ok;
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
std::string url;
|
|
ok = seval_to_std_string(args[1], &url);
|
|
SE_PRECONDITION2(ok, false, "Error processing arguments");
|
|
NSString *nurl = [NSString stringWithCString:url.c_str() encoding:NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController showPage:nurl];
|
|
});
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(jsb_showWebPage)
|
|
|
|
static bool JSB_queryProducts(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 1) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
std::string param0;
|
|
ok = seval_to_std_string(args[1], ¶m0);
|
|
SE_PRECONDITION2(ok, false, "param0 is invalid!");
|
|
NSString *nParams = [NSString stringWithCString:param0.c_str() encoding: NSUTF8StringEncoding];
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding: NSUTF8StringEncoding];
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController queryProducts:nfunid products: nParams];
|
|
});
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_queryProducts)
|
|
|
|
static bool JSB_queryPurchase(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 0) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding: NSUTF8StringEncoding];
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController queryPurchase:nfunid ];
|
|
});
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_queryPurchase)
|
|
|
|
static bool JSB_finishTransaction(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 1) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
std::string transactionid;
|
|
ok = seval_to_std_string(args[1], &transactionid);
|
|
SE_PRECONDITION2(ok, false, "transactionid is invalid!");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding: NSUTF8StringEncoding];
|
|
NSString *ntransactionid = [NSString stringWithCString:transactionid.c_str() encoding: NSUTF8StringEncoding];
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController finishTransaction:nfunid transactionId:ntransactionid ];
|
|
});
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_finishTransaction)
|
|
|
|
static bool JSB_beginBuy(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 2) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
std::string param0;
|
|
ok = seval_to_std_string(args[1], ¶m0);
|
|
SE_PRECONDITION2(ok, false, "param0 is invalid!");
|
|
std::string param1;
|
|
ok = seval_to_std_string(args[2], ¶m1);
|
|
SE_PRECONDITION2(ok, false, "param1 is invalid!");
|
|
NSString *nParam0 = [NSString stringWithCString:param0.c_str() encoding: NSUTF8StringEncoding];
|
|
NSString *nParam1 = [NSString stringWithCString:param1.c_str() encoding: NSUTF8StringEncoding];
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding: NSUTF8StringEncoding];
|
|
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController beginBuy:nfunid productId: nParam0 orderId:nParam1];
|
|
});
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_beginBuy)
|
|
|
|
static bool JSB_passStorageState(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 1) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
std::string param0;
|
|
ok = seval_to_std_string(args[1], ¶m0);
|
|
SE_PRECONDITION2(ok, false, "param0 is invalid!");
|
|
NSString *nParam0 = [NSString stringWithCString:param0.c_str() encoding: NSUTF8StringEncoding];
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding: NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController passStorageState:nfunid account: nParam0 ];
|
|
});
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_passStorageState)
|
|
|
|
static bool JSB_storagePass(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 2) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
std::string param0;
|
|
ok = seval_to_std_string(args[1], ¶m0);
|
|
SE_PRECONDITION2(ok, false, "param0 is invalid!");
|
|
std::string pass;
|
|
ok = seval_to_std_string(args[2], &pass);
|
|
SE_PRECONDITION2(ok, false, "param1 is invalid!");
|
|
NSString *nParam0 = [NSString stringWithCString:param0.c_str() encoding: NSUTF8StringEncoding];
|
|
NSString *nPass = [NSString stringWithCString:pass.c_str() encoding: NSUTF8StringEncoding];
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding: NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController storagePass:nfunid account: nParam0 pass:nPass ];
|
|
});
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_storagePass)
|
|
|
|
|
|
static bool JSB_storageGameInfo(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 1) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
std::string param0;
|
|
ok = seval_to_std_string(args[1], ¶m0);
|
|
SE_PRECONDITION2(ok, false, "param0 is invalid!");
|
|
NSString *nParam0 = [NSString stringWithCString:param0.c_str() encoding: NSUTF8StringEncoding];
|
|
[[GlobalData shareInstance] setGameData:nParam0];
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_storageGameInfo)
|
|
|
|
static bool JSB_authGetStoragePass(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 1) {
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "funid is invalid!");
|
|
std::string param0;
|
|
ok = seval_to_std_string(args[1], ¶m0);
|
|
SE_PRECONDITION2(ok, false, "param0 is invalid!");
|
|
NSString *nParam0 = [NSString stringWithCString:param0.c_str() encoding: NSUTF8StringEncoding];
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding: NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController authGetStoragePass:nfunid account: nParam0 ];
|
|
});
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_authGetStoragePass)
|
|
|
|
static bool JSB_getClientId(se::State &s)
|
|
{
|
|
const auto &args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc > 0)
|
|
{
|
|
std::string funid;
|
|
ok = seval_to_std_string(args[0], &funid);
|
|
SE_PRECONDITION2(ok, false, "Error processing funid");
|
|
NSString *nfunid = [NSString stringWithCString:funid.c_str() encoding: NSUTF8StringEncoding];
|
|
dispatch_async(dispatch_get_main_queue(), ^{
|
|
UIWindow* window = [[[UIApplication sharedApplication] delegate] window];
|
|
[window.rootViewController clientLogin:nfunid ];
|
|
});
|
|
return true;
|
|
}
|
|
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(JSB_getClientId)
|
|
|
|
bool jsb_register_walletevent_modules(se::Object* global) {
|
|
getOrCreatePlainObject_r("jsb", global, &__jsbObj);
|
|
__jsbObj->defineFunction("jcCallback", _SE(jsb_wallet_callback));
|
|
__jsbObj->defineFunction("scanQRCode", _SE(jsb_scanQRCode));
|
|
__jsbObj->defineFunction("signWithGoogle", _SE(jsb_signWithGoogle));
|
|
__jsbObj->defineFunction("signWithApple", _SE(jsb_signWithApple));
|
|
__jsbObj->defineFunction("signWithTikTok", _SE(jsb_signWithTikTok));
|
|
__jsbObj->defineFunction("signWithFacebook", _SE(jsb_signWithFacebook));
|
|
__jsbObj->defineFunction("signWithTwitter", _SE(jsb_signWithTwitter));
|
|
__jsbObj->defineFunction("signWithOAuth", _SE(jsb_signWithOAuth));
|
|
__jsbObj->defineFunction("signOutGoogle", _SE(jsb_signOutGoogle));
|
|
__jsbObj->defineFunction("showQRCode", _SE(JSB_showQRCode));
|
|
__jsbObj->defineFunction("showWebPage", _SE(jsb_showWebPage));
|
|
__jsbObj->defineFunction("queryProducts", _SE(JSB_queryProducts));
|
|
__jsbObj->defineFunction("queryPurchase", _SE(JSB_queryPurchase));
|
|
__jsbObj->defineFunction("finishTransaction", _SE(JSB_finishTransaction));
|
|
__jsbObj->defineFunction("beginBuy", _SE(JSB_beginBuy));
|
|
__jsbObj->defineFunction("authGetStoragePass", _SE(JSB_authGetStoragePass));
|
|
__jsbObj->defineFunction("storagePass", _SE(JSB_storagePass));
|
|
__jsbObj->defineFunction("getClientId", _SE(JSB_getClientId));
|
|
__jsbObj->defineFunction("passStorageState", _SE(JSB_passStorageState));
|
|
__jsbObj->defineFunction("updateGameInfo", _SE(JSB_storageGameInfo));
|
|
// JSB_signWithEmail
|
|
// JSB_beginBuyJNI
|
|
return true;
|
|
}
|
|
|