666 lines
24 KiB
C++
666 lines
24 KiB
C++
/**
|
|
* Copyright (c) 2017-present, Status Research and Development GmbH.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD-style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*
|
|
*/
|
|
|
|
#include "rctstatus.h"
|
|
#include "bridge.h"
|
|
#include "eventdispatcher.h"
|
|
|
|
#include <QByteArray>
|
|
#include <QDebug>
|
|
#include <QDir>
|
|
#include <QJsonDocument>
|
|
#include <QMessageBox>
|
|
#include <QStandardPaths>
|
|
#include <QStorageInfo>
|
|
#include <QVariantMap>
|
|
#include <QtConcurrent>
|
|
|
|
#include "libstatus.h"
|
|
|
|
extern QString getDataStoragePath();
|
|
extern QString getLogFilePath();
|
|
|
|
namespace {
|
|
struct RegisterQMLMetaType {
|
|
RegisterQMLMetaType() { qRegisterMetaType<RCTStatus *>(); }
|
|
} registerMetaType;
|
|
} // namespace
|
|
|
|
class RCTStatusPrivate {
|
|
public:
|
|
static Bridge *bridge;
|
|
static RCTStatus *rctStatus;
|
|
};
|
|
|
|
Bridge *RCTStatusPrivate::bridge = nullptr;
|
|
RCTStatus *RCTStatusPrivate::rctStatus = nullptr;
|
|
|
|
Q_LOGGING_CATEGORY(RCTSTATUS, "RCTStatus")
|
|
|
|
RCTStatus::RCTStatus(QObject *parent)
|
|
: QObject(parent), d_ptr(new RCTStatusPrivate) {
|
|
RCTStatusPrivate::rctStatus = this;
|
|
SetSignalEventCallback((void *)&RCTStatus::statusGoEventCallback);
|
|
connect(this, &RCTStatus::statusGoEvent, this, &RCTStatus::onStatusGoEvent);
|
|
}
|
|
|
|
RCTStatus::~RCTStatus() {}
|
|
|
|
void RCTStatus::setBridge(Bridge *bridge) {
|
|
Q_D(RCTStatus);
|
|
d->bridge = bridge;
|
|
}
|
|
|
|
QString RCTStatus::moduleName() { return "Status"; }
|
|
|
|
QList<ModuleMethod *> RCTStatus::methodsToExport() {
|
|
return QList<ModuleMethod *>{};
|
|
}
|
|
|
|
QVariantMap RCTStatus::constantsToExport() { return QVariantMap(); }
|
|
|
|
void RCTStatus::shouldMoveToInternalStorage(double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::shouldMoveToInternalStorage call";
|
|
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{QVariant()});
|
|
}
|
|
|
|
void RCTStatus::moveToInternalStorage(double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::moveToInternalStorage call";
|
|
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{QVariant()});
|
|
}
|
|
|
|
QString RCTStatus::prepareDirAndUpdateConfig(QString configString) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::prepareDirAndUpdateConfig call - configString:"
|
|
<< configString;
|
|
|
|
QJsonParseError jsonError;
|
|
const QJsonDocument &jsonDoc =
|
|
QJsonDocument::fromJson(configString.toUtf8(), &jsonError);
|
|
if (jsonError.error != QJsonParseError::NoError) {
|
|
qCWarning(RCTSTATUS) << jsonError.errorString();
|
|
}
|
|
|
|
QVariantMap configJSON = jsonDoc.toVariant().toMap();
|
|
QVariantMap shhextConfig = configJSON["ShhextConfig"].toMap();
|
|
qCDebug(RCTSTATUS) << "::startNode configString: " << configJSON;
|
|
|
|
int networkId = configJSON["NetworkId"].toInt();
|
|
QString relativeDataDirPath = configJSON["DataDir"].toString();
|
|
if (!relativeDataDirPath.startsWith("/"))
|
|
relativeDataDirPath.prepend("/");
|
|
|
|
QString rootDirPath = getDataStoragePath();
|
|
QDir rootDir(rootDirPath);
|
|
QString absDataDirPath = rootDirPath + relativeDataDirPath;
|
|
QDir dataDir(absDataDirPath);
|
|
if (!dataDir.exists()) {
|
|
dataDir.mkpath(".");
|
|
}
|
|
|
|
d_gethLogFilePath = dataDir.absoluteFilePath("geth.log");
|
|
configJSON["DataDir"] = absDataDirPath;
|
|
configJSON["KeyStoreDir"] = rootDir.absoluteFilePath("keystore");
|
|
configJSON["LogFile"] = d_gethLogFilePath;
|
|
|
|
shhextConfig["BackupDisabledDataDir"] = rootDirPath;
|
|
|
|
configJSON["ShhExtConfig"] = shhextConfig;
|
|
|
|
const QJsonDocument &updatedJsonDoc = QJsonDocument::fromVariant(configJSON);
|
|
qCInfo(RCTSTATUS) << "::startNode updated configString: "
|
|
<< updatedJsonDoc.toVariant().toMap();
|
|
return QString(updatedJsonDoc.toJson(QJsonDocument::Compact));
|
|
}
|
|
|
|
void RCTStatus::prepareDirAndUpdateConfig(QString configString,
|
|
double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCInfo(RCTSTATUS) << "::prepareDirAndUpdateConfig call - callbackId:"
|
|
<< callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString configString, double callbackId) {
|
|
QString updatedConfig = prepareDirAndUpdateConfig(configString);
|
|
d->bridge->invokePromiseCallback(
|
|
callbackId, QVariantList{updatedConfig.toUtf8().data()});
|
|
},
|
|
configString, callbackId);
|
|
}
|
|
|
|
void RCTStatus::initKeystore() {
|
|
qCInfo(RCTSTATUS) << "::initKeystore call";
|
|
QString rootDir = getDataStoragePath();
|
|
const char *result = InitKeystore(rootDir.toUtf8().data());
|
|
logStatusGoResult("::initKeystore InitKeystore", result);
|
|
}
|
|
|
|
#include <QApplication>
|
|
#include <QMessageBox>
|
|
#include <QProcess>
|
|
#include <QStandardPaths>
|
|
#include <QtGui/private/qzipwriter_p.h>
|
|
|
|
void showFileInGraphicalShell(QWidget *parent, const QFileInfo &fileInfo) {
|
|
// Mac, Windows support folder or file.
|
|
#ifdef Q_OS_WIN
|
|
const QString explorer =
|
|
QStandardPaths::findExecutable(QLatin1String("explorer.exe"));
|
|
if (explorer.isEmpty()) {
|
|
QMessageBox::warning(
|
|
parent, QApplication::translate("Core::Internal",
|
|
"Launching Windows Explorer Failed"),
|
|
QApplication::translate(
|
|
"Core::Internal",
|
|
"Could not find explorer.exe in path to launch Windows Explorer."));
|
|
return;
|
|
}
|
|
QStringList param;
|
|
if (!fileInfo.isDir())
|
|
param += QLatin1String("/select,");
|
|
param += QDir::toNativeSeparators(fileInfo.canonicalFilePath());
|
|
QProcess::startDetached(explorer, param);
|
|
#elif defined(Q_OS_MAC)
|
|
QStringList scriptArgs;
|
|
scriptArgs << QLatin1String("-e")
|
|
<< QString::fromLatin1(
|
|
"tell application \"Finder\" to reveal POSIX file \"%1\"")
|
|
.arg(fileInfo.canonicalFilePath());
|
|
QProcess::execute(QLatin1String("/usr/bin/osascript"), scriptArgs);
|
|
scriptArgs.clear();
|
|
scriptArgs << QLatin1String("-e")
|
|
<< QLatin1String("tell application \"Finder\" to activate");
|
|
QProcess::execute(QLatin1String("/usr/bin/osascript"), scriptArgs);
|
|
#else
|
|
// we cannot select a file here, because no file browser really supports it...
|
|
const QString folder = fileInfo.isDir() ? fileInfo.absoluteFilePath()
|
|
: fileInfo.dir().absolutePath();
|
|
QProcess browserProc;
|
|
browserProc.setProgram("xdg-open");
|
|
browserProc.setArguments(QStringList(folder));
|
|
bool success = browserProc.startDetached();
|
|
const QString error =
|
|
QString::fromLocal8Bit(browserProc.readAllStandardError());
|
|
success = success && error.isEmpty();
|
|
if (!success) {
|
|
QMessageBox::warning(parent, "Launching Explorer Failed", error);
|
|
return;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void RCTStatus::sendLogs(QString dbJSON, QString jsLogs, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
|
|
qCDebug(RCTSTATUS) << "::sendLogs call - logFilePath:" << getLogFilePath()
|
|
<< "d_gethLogFilePath:" << d_gethLogFilePath
|
|
<< "dbJSON:" << dbJSON;
|
|
|
|
QString tmpDirName("Status.im");
|
|
QDir tmpDir(QStandardPaths::writableLocation(QStandardPaths::TempLocation));
|
|
if (!tmpDir.mkpath(tmpDirName)) {
|
|
qCWarning(RCTSTATUS) << "::sendLogs could not create temp dir:"
|
|
<< tmpDirName;
|
|
return;
|
|
}
|
|
|
|
// Check that at least 20MB are available for log generation
|
|
QStorageInfo storage(tmpDir);
|
|
if (storage.bytesAvailable() < 20 * 1024 * 1024) {
|
|
QMessageBox dlg;
|
|
dlg.warning(QApplication::activeWindow(), "Error",
|
|
QString("Insufficient storage space available in %1 for log "
|
|
"generation. Please free up some space.")
|
|
.arg(storage.rootPath()),
|
|
QMessageBox::Close);
|
|
return;
|
|
}
|
|
|
|
QFile zipFile(tmpDir.absoluteFilePath(tmpDirName + QDir::separator() +
|
|
"Status-debug-logs.zip"));
|
|
QZipWriter zipWriter(&zipFile);
|
|
QFile gethLogFile(d_gethLogFilePath);
|
|
QFile logFile(getLogFilePath());
|
|
zipWriter.addFile("db.json", dbJSON.toUtf8());
|
|
zipWriter.addFile("js_logs.log", jsLogs.toUtf8());
|
|
if (gethLogFile.exists()) {
|
|
zipWriter.addFile(QFileInfo(gethLogFile).fileName(), &gethLogFile);
|
|
}
|
|
if (logFile.exists()) {
|
|
zipWriter.addFile(QFileInfo(logFile).fileName(), &logFile);
|
|
}
|
|
zipWriter.close();
|
|
|
|
showFileInGraphicalShell(QApplication::activeWindow(), QFileInfo(zipFile));
|
|
}
|
|
|
|
void RCTStatus::exportLogs(double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](double callbackId) {
|
|
const char *result = ExportNodeLogs();
|
|
logStatusGoResult("::exportLogs", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
callbackId);
|
|
}
|
|
|
|
void RCTStatus::addPeer(QString enode, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::addPeer call - callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString enode, double callbackId) {
|
|
const char *result = AddPeer(enode.toUtf8().data());
|
|
logStatusGoResult("::addPeer AddPeer", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
enode, callbackId);
|
|
}
|
|
|
|
void RCTStatus::saveAccountAndLogin(QString accountData, QString password,
|
|
QString config, QString subAccountsData) {
|
|
|
|
Q_D(RCTStatus);
|
|
QString finalConfig = prepareDirAndUpdateConfig(config);
|
|
QtConcurrent::run(
|
|
[&](QString accountData, QString password, QString finalConfig,
|
|
QString subAccountsData) {
|
|
const char *result = SaveAccountAndLogin(
|
|
accountData.toUtf8().data(), password.toUtf8().data(),
|
|
finalConfig.toUtf8().data(), subAccountsData.toUtf8().data());
|
|
logStatusGoResult("::saveAccountAndLogin", result);
|
|
},
|
|
accountData, password, finalConfig, subAccountsData);
|
|
}
|
|
|
|
// void RCTStatus::saveAccountAndLoginWithKeycard(QString accountData,
|
|
// QString password, QString
|
|
// config,
|
|
// QString chatKey) {
|
|
// Q_D(RCTStatus);
|
|
// QString finalConfig = prepareDirAndUpdateConfig(config);
|
|
// QtConcurrent::run(
|
|
// [&](QString accountData, QString password, QString finalConfig,
|
|
// QString chatKey) {
|
|
// const char *result = SaveAccountAndLoginWithKeycard(
|
|
// accountData.toUtf8().data(), password.toUtf8().data(),
|
|
// finalConfig.toUtf8().data(), chatKey.toUtf8().data());
|
|
// logStatusGoResult("::saveAccountAndLoginWithKeycard", result);
|
|
// },
|
|
// accountData, password, finalConfig, chatKey);
|
|
//}
|
|
|
|
void RCTStatus::login(QString accountData, QString password) {
|
|
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString accountData, QString password) {
|
|
const char *result =
|
|
Login(accountData.toUtf8().data(), password.toUtf8().data());
|
|
logStatusGoResult("::login", result);
|
|
},
|
|
accountData, password);
|
|
}
|
|
|
|
// void RCTStatus::loginWithKeycard(QString accountData, QString password,
|
|
// QString chatKey) {
|
|
//
|
|
// Q_D(RCTStatus);
|
|
// QtConcurrent::run(
|
|
// [&](QString accountData, QString password, QString chatKey) {
|
|
// const char *result =
|
|
// LoginWithKeycard(accountData.toUtf8().data(),
|
|
// password.toUtf8().data(),
|
|
// chatKey.toUtf8().data());
|
|
// logStatusGoResult("::loginWithKeycard", result);
|
|
// },
|
|
// accountData, password, chatKey);
|
|
//}
|
|
|
|
void RCTStatus::logout() {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run([&]() {
|
|
const char *result = Logout();
|
|
logStatusGoResult("::logout", result);
|
|
});
|
|
}
|
|
|
|
void RCTStatus::openAccounts(double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](double callbackId) {
|
|
QString rootDir = getDataStoragePath();
|
|
const char *result = OpenAccounts(rootDir.toUtf8().data());
|
|
logStatusGoResult("::openAccounts", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
callbackId);
|
|
}
|
|
|
|
void RCTStatus::multiAccountStoreAccount(QString json, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString json, double callbackId) {
|
|
const char *result = MultiAccountStoreAccount(json.toUtf8().data());
|
|
logStatusGoResult("::multiAccountStoreAccount", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
json, callbackId);
|
|
}
|
|
|
|
void RCTStatus::multiAccountLoadAccount(QString json, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString json, double callbackId) {
|
|
const char *result = MultiAccountLoadAccount(json.toUtf8().data());
|
|
logStatusGoResult("::multiAccountLoadAccount", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
json, callbackId);
|
|
}
|
|
|
|
void RCTStatus::multiAccountReset(double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](double callbackId) {
|
|
const char *result = MultiAccountReset();
|
|
logStatusGoResult("::multiAccountReset", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
callbackId);
|
|
}
|
|
|
|
void RCTStatus::multiAccountDeriveAddresses(QString json, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString json, double callbackId) {
|
|
const char *result = MultiAccountDeriveAddresses(json.toUtf8().data());
|
|
logStatusGoResult("::multiAccountDeriveAddresses", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
json, callbackId);
|
|
}
|
|
|
|
void RCTStatus::multiAccountStoreDerived(QString json, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString json, double callbackId) {
|
|
const char *result =
|
|
MultiAccountStoreDerivedAccounts(json.toUtf8().data());
|
|
logStatusGoResult("::multiAccountStoreDerived", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
json, callbackId);
|
|
}
|
|
|
|
void RCTStatus::multiAccountGenerateAndDeriveAddresses(QString json,
|
|
double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString json, double callbackId) {
|
|
const char *result =
|
|
MultiAccountGenerateAndDeriveAddresses(json.toUtf8().data());
|
|
logStatusGoResult("::multiAccountGenerateAndDeriveAddresses", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
json, callbackId);
|
|
}
|
|
|
|
void RCTStatus::multiAccountImportMnemonic(QString json, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString json, double callbackId) {
|
|
const char *result = MultiAccountImportMnemonic(json.toUtf8().data());
|
|
logStatusGoResult("::multiAccountImportMnemonic", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
json, callbackId);
|
|
}
|
|
|
|
void RCTStatus::verify(QString address, QString password, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCInfo(RCTSTATUS) << "::verify call - callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString address, QString password, double callbackId) {
|
|
QDir rootDir(getDataStoragePath());
|
|
QString keystorePath = rootDir.absoluteFilePath("keystore");
|
|
const char *result = VerifyAccountPassword(keystorePath.toUtf8().data(),
|
|
address.toUtf8().data(),
|
|
password.toUtf8().data());
|
|
logStatusGoResult("::verify VerifyAccountPassword", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
address, password, callbackId);
|
|
}
|
|
|
|
void RCTStatus::sendTransaction(QString txArgsJSON, QString password,
|
|
double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::sendTransaction call - callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString txArgsJSON, QString password, double callbackId) {
|
|
const char *result = SendTransaction(txArgsJSON.toUtf8().data(),
|
|
password.toUtf8().data());
|
|
logStatusGoResult("::sendTransaction SendTransaction", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
txArgsJSON, password, callbackId);
|
|
}
|
|
|
|
void RCTStatus::signMessage(QString rpcParams, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::signMessage call - callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString rpcParams, double callbackId) {
|
|
const char *result = SignMessage(rpcParams.toUtf8().data());
|
|
logStatusGoResult("::signMessage SignMessage", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
rpcParams, callbackId);
|
|
}
|
|
|
|
void RCTStatus::signTypedData(QString data, QString account, QString password,
|
|
double callbackId) {
|
|
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::signMessage call - callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString data, QString account, QString password, double callbackId) {
|
|
const char *result =
|
|
SignTypedData(data.toUtf8().data(), account.toUtf8().data(),
|
|
password.toUtf8().data());
|
|
logStatusGoResult("::signTypedData signTypedData", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
data, account, password, callbackId);
|
|
}
|
|
void RCTStatus::signGroupMembership(QString content, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::signGroupMembership - callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString content, double callbackId) {
|
|
const char *result = SignGroupMembership(content.toUtf8().data());
|
|
logStatusGoResult("::signGroupMembership SignGroupMembership", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
content, callbackId);
|
|
}
|
|
|
|
void RCTStatus::extractGroupMembershipSignatures(QString signatures,
|
|
double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::extractGroupMembershipSignatures - callbackId:"
|
|
<< callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString signatures, double callbackId) {
|
|
const char *result =
|
|
ExtractGroupMembershipSignatures(signatures.toUtf8().data());
|
|
logStatusGoResult("::extractGroupMembershipSignatures "
|
|
"ExtractGroupMembershipSignatures",
|
|
result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
signatures, callbackId);
|
|
}
|
|
|
|
void RCTStatus::setAdjustResize() {}
|
|
|
|
void RCTStatus::setAdjustPan() {}
|
|
|
|
void RCTStatus::setSoftInputMode(int i) {}
|
|
|
|
void RCTStatus::clearCookies() {}
|
|
|
|
void RCTStatus::clearStorageAPIs() {}
|
|
|
|
void RCTStatus::callRPC(QString payload, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::callRPC call - payload:" << payload.left(128)
|
|
<< "callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString payload, double callbackId) {
|
|
const char *result = CallRPC(payload.toUtf8().data());
|
|
logStatusGoResult("::callRPC CallRPC", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
payload, callbackId);
|
|
}
|
|
|
|
void RCTStatus::callPrivateRPC(QString payload, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::callPrivateRPC call - payload:" << payload.left(128)
|
|
<< "callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString payload, double callbackId) {
|
|
const char *result = CallPrivateRPC(payload.toUtf8().data());
|
|
logStatusGoResult("::callPrivateRPC CallPrivateRPC", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
payload, callbackId);
|
|
}
|
|
|
|
void RCTStatus::closeApplication() {}
|
|
|
|
void RCTStatus::connectionChange(QString type, bool isExpensive) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString type, bool isExpensive) {
|
|
ConnectionChange(type.toUtf8().data(), isExpensive ? 1 : 0);
|
|
qCWarning(RCTSTATUS) << "::connectionChange";
|
|
},
|
|
type, isExpensive);
|
|
}
|
|
|
|
void RCTStatus::appStateChange(QString type) {
|
|
Q_D(RCTStatus);
|
|
QtConcurrent::run(
|
|
[&](QString type) {
|
|
AppStateChange(type.toUtf8().data());
|
|
qCWarning(RCTSTATUS) << "::appStateChange";
|
|
},
|
|
type);
|
|
}
|
|
|
|
bool RCTStatus::JSCEnabled() {
|
|
qCDebug(RCTSTATUS) << "::JSCEnabled call";
|
|
return false;
|
|
}
|
|
|
|
void RCTStatus::statusGoEventCallback(const char *event) {
|
|
qCDebug(RCTSTATUS) << "::statusGoEventCallback call - event: " << event;
|
|
RCTStatusPrivate::rctStatus->emitStatusGoEvent(event);
|
|
}
|
|
|
|
void RCTStatus::emitStatusGoEvent(QString event) {
|
|
qCDebug(RCTSTATUS) << "::emitStatusGoEvent call - event: " << event;
|
|
Q_EMIT statusGoEvent(event);
|
|
}
|
|
|
|
void RCTStatus::onStatusGoEvent(QString event) {
|
|
qCDebug(RCTSTATUS) << "::onStatusGoEvent call - event: "
|
|
<< event.toUtf8().data();
|
|
RCTStatusPrivate::bridge->eventDispatcher()->sendDeviceEvent(
|
|
"gethEvent", QVariantMap{{"jsonEvent", event.toUtf8().data()}});
|
|
}
|
|
|
|
void RCTStatus::logStatusGoResult(const char *methodName, const char *result) {
|
|
QJsonParseError jsonError;
|
|
QJsonDocument jsonDoc =
|
|
QJsonDocument::fromJson(QString(result).toUtf8(), &jsonError);
|
|
if (jsonError.error != QJsonParseError::NoError) {
|
|
qCWarning(RCTSTATUS) << qUtf8Printable(jsonError.errorString());
|
|
return;
|
|
}
|
|
|
|
QString error = jsonDoc.toVariant().toMap().value("error").toString();
|
|
if (error.isEmpty()) {
|
|
qCDebug(RCTSTATUS) << methodName << "succeeded";
|
|
} else {
|
|
qCWarning(RCTSTATUS) << methodName << "- error:" << qUtf8Printable(error);
|
|
}
|
|
}
|
|
|
|
void RCTStatus::updateMailservers(QString enodes, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::updateMailservers call - callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString enodes, double callbackId) {
|
|
const char *result = UpdateMailservers(enodes.toUtf8().data());
|
|
logStatusGoResult("::updateMailservers UpdateMailservers", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
enodes, callbackId);
|
|
}
|
|
|
|
void RCTStatus::getNodesFromContract(QString url, QString address,
|
|
double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::getNodesFromContract call - callbackId:"
|
|
<< callbackId;
|
|
QtConcurrent::run(
|
|
[&](QString url, QString address, double callbackId) {
|
|
const char *result =
|
|
GetNodesFromContract(url.toUtf8().data(), address.toUtf8().data());
|
|
logStatusGoResult("::getNodesFromContract GetNodesFromContract",
|
|
result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
url, address, callbackId);
|
|
}
|
|
|
|
void RCTStatus::chaosModeUpdate(bool on, double callbackId) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::chaosModeUpdate call - callbackId:" << callbackId;
|
|
QtConcurrent::run(
|
|
[&](bool on, double callbackId) {
|
|
const char *result = ChaosModeUpdate(on);
|
|
logStatusGoResult("::chaosModeUpdate ChaosModeUpdate", result);
|
|
d->bridge->invokePromiseCallback(callbackId, QVariantList{result});
|
|
},
|
|
on, callbackId);
|
|
}
|
|
|
|
QString RCTStatus::generateAlias(QString publicKey) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::generateAlias call";
|
|
// return GenerateGfycat(publicKey.toUtf8().data());
|
|
return "test";
|
|
}
|
|
|
|
QString RCTStatus::identicon(QString publicKey) {
|
|
Q_D(RCTStatus);
|
|
qCDebug(RCTSTATUS) << "::identicon call";
|
|
// return Identicon(publicKey.toUtf8().data());
|
|
return "test";
|
|
}
|