Page MenuHomePhabricator
Differential D14406

[native] Remove position from overlay navigator
ClosedPublic
Actions

Authored by angelika on Feb 25 2025, 3:01 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Apr 7, 7:42 PM
Unknown Object (File)
Sun, Apr 6, 2:04 PM
Unknown Object (File)
Sun, Apr 6, 1:35 PM
Unknown Object (File)
Sun, Apr 6, 8:31 AM
Unknown Object (File)
Sun, Apr 6, 2:35 AM
Unknown Object (File)
Sat, Apr 5, 3:21 PM
Unknown Object (File)
Wed, Mar 26, 6:26 AM
Unknown Object (File)
Mar 23 2025, 2:07 AM
View All 33 Files
Subscribers
ashoat

Details

Reviewers
tomek
Commits
rCOMMe99d6d2a3732: [native] Remove position from overlay navigator
Summary

https://linear.app/comm/issue/ENG-10006/rename-positionv2-variables-in-overlaynavigator-to-position

The position variable in OverlayNavigator is deprecated and no longer used anywhere, so we can delete it.

Test Plan

flow & run the app

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
native/
navigation/
5 lines
27 lines

Diff 47330

View Options

native/navigation/overlay-context.js

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines
View Options

native/navigation/overlay-navigator.react.js

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines