public static Task <List <List <byte> > > MDataKeysForEachAsync(ulong entKeysH)
{
var tcs = new TaskCompletionSource <List <List <byte> > >();
var keys = new List <List <byte> >();
MDataKeysForEachCb forEachCb = null;
forEachCb = (pVoid, bytePtr, len) => {
var key = bytePtr.ToList <byte>(len);
keys.Add(key);
};
CallbackManager.Register(forEachCb);
MDataKeysForEachResCb forEachResCb = null;
forEachResCb = (ptr, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(forEachCb);
CallbackManager.Unregister(forEachResCb);
return;
}
tcs.SetResult(keys);
CallbackManager.Unregister(forEachCb);
CallbackManager.Unregister(forEachResCb);
};
CallbackManager.Register(forEachResCb);
NativeBindings.MDataKeysForEach(Session.AppPtr, entKeysH, forEachCb, Session.UserData, forEachResCb);
return(tcs.Task);
}
public static Task <ulong> MDataInfoNewPublicAsync(List <byte> xorName, ulong typeTag)
{
var tcs = new TaskCompletionSource <ulong>();
MDataInfoNewPublicCb callback = null;
callback = (pVoid, result, pubMDataInfoH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(pubMDataInfoH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
var xorNamePtr = xorName.ToIntPtr();
NativeBindings.MDataInfoNewPublic(Session.AppPtr, xorNamePtr, typeTag, Session.UserData, callback);
Marshal.FreeHGlobal(xorNamePtr);
return(tcs.Task);
}
public static Task <List <Tuple <List <byte>, List <byte>, ulong> > > MDataEntriesForEachAsync(ulong entH)
{
var tcs = new TaskCompletionSource <List <Tuple <List <byte>, List <byte>, ulong> > >();
var entries = new List <Tuple <List <byte>, List <byte>, ulong> >();
MDataEntriesForEachCb forEachCb = null;
forEachCb = (pVoid, entryKeyPtr, entryKeyLen, entryValPtr, entryValLen, entryVersion) => {
var entryKey = entryKeyPtr.ToList <byte>(entryKeyLen);
var entryVal = entryValPtr.ToList <byte>(entryValLen);
entries.Add(Tuple.Create(entryKey, entryVal, entryVersion));
};
CallbackManager.Register(forEachCb);
MDataEntriesForEachResCb forEachResCb = null;
forEachResCb = (ptr, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(forEachCb);
CallbackManager.Unregister(forEachResCb);
return;
}
tcs.SetResult(entries);
CallbackManager.Unregister(forEachCb);
CallbackManager.Unregister(forEachResCb);
};
CallbackManager.Register(forEachResCb);
NativeBindings.MDataEntriesForEach(Session.AppPtr, entH, forEachCb, Session.UserData, forEachResCb);
return(tcs.Task);
}
public static Task <bool> AppRegisteredAsync(string appId, AuthGranted authGranted)
{
return(Task.Run(
() => {
var tcs = new TaskCompletionSource <bool>();
var authGrantedFfi = new AuthGrantedFfi {
AccessContainer = authGranted.AccessContainer,
AppKeys = authGranted.AppKeys,
BootStrapConfigPtr = authGranted.BootStrapConfig.ToIntPtr(),
BootStrapConfigLen = (IntPtr)authGranted.BootStrapConfig.Count
};
var authGrantedFfiPtr = CommonUtils.Helpers.StructToPtr(authGrantedFfi);
AppRegisteredCallback callback = null;
callback = (ptr, result, appPtr) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
AppPtr = appPtr;
tcs.SetResult(true);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.AppRegistered(appId, authGrantedFfiPtr, IntPtr.Zero, UserData, NetObs, callback);
Marshal.FreeHGlobal(authGrantedFfi.BootStrapConfigPtr);
Marshal.FreeHGlobal(authGrantedFfiPtr);
return tcs.Task;
}));
}
public static Task <ulong> MDataInfoDeserialiseAsync(List <byte> serialisedData)
{
var tcs = new TaskCompletionSource <ulong>();
MDataInfoDeserialiseCb callback = null;
callback = (pVoid, result, mdataInfoH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(mdataInfoH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
var serialisedDataPtr = serialisedData.ToIntPtr();
NativeBindings.MDataInfoDeserialise(Session.AppPtr, serialisedDataPtr, (IntPtr)serialisedData.Count, Session.UserData, callback);
Marshal.FreeHGlobal(serialisedDataPtr);
return(tcs.Task);
}
public static Task <string> EncodeAuthReqAsync(AuthReq authReq)
{
return(Task.Run(
() => {
var tcs = new TaskCompletionSource <string>();
var authReqFfi = new AuthReqFfi {
AppContainer = authReq.AppContainer,
AppExchangeInfo = authReq.AppExchangeInfo,
ContainersLen = (IntPtr)authReq.Containers.Count,
ContainersArrayPtr = authReq.Containers.ToIntPtr()
};
var authReqFfiPtr = CommonUtils.Helpers.StructToPtr(authReqFfi);
EncodeAuthReqCb callback = null;
callback = (ptr, result, id, req) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(req);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.EncodeAuthReq(authReqFfiPtr, UserData, callback);
Marshal.FreeHGlobal(authReqFfi.ContainersArrayPtr);
Marshal.FreeHGlobal(authReqFfiPtr);
return tcs.Task;
}));
}
public static Task <Tuple <List <byte>, ulong> > MDataGetValueAsync(ulong infoHandle, List <byte> key)
{
var tcs = new TaskCompletionSource <Tuple <List <byte>, ulong> >();
var keyPtr = key.ToIntPtr();
MDataGetValueCb callback = null;
callback = (self, result, dataPtr, dataLen, entryVersion) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var data = dataPtr.ToList <byte>(dataLen);
tcs.SetResult(Tuple.Create(data, entryVersion));
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataGetValue(Session.AppPtr, infoHandle, keyPtr, (IntPtr)key.Count, Session.UserData, callback);
Marshal.FreeHGlobal(keyPtr);
return(tcs.Task);
}
public static Task <List <byte> > DecryptSealedBoxAsync(List <byte> cipherText, ulong pkHandle, ulong skHandle)
{
var tcs = new TaskCompletionSource <List <byte> >();
var cipherPtr = cipherText.ToIntPtr();
DecryptSealedBoxCb callback = null;
callback = (self, result, dataPtr, dataLen) => {
// Marshal.FreeHGlobal(cipherPtr); // TODO: Temp soln
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var data = dataPtr.ToList <byte>(dataLen);
tcs.SetResult(data);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.DecryptSealedBox(Session.AppPtr, cipherPtr, (IntPtr)cipherText.Count, pkHandle, skHandle, Session.UserData, callback);
// Marshal.FreeHGlobal(cipherPtr);
return(tcs.Task);
}
public static Task <List <byte> > MDataInfoDecryptAsync(ulong mDataInfoH, List <byte> cipherText)
{
var tcs = new TaskCompletionSource <List <byte> >();
var cipherPtr = cipherText.ToIntPtr();
var cipherLen = (IntPtr)cipherText.Count;
MDataInfoDecryptCb callback = null;
callback = (pVoid, result, plainText, len) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var byteList = plainText.ToList <byte>(len);
tcs.SetResult(byteList);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataInfoDecrypt(Session.AppPtr, mDataInfoH, cipherPtr, cipherLen, Session.UserData, callback);
Marshal.FreeHGlobal(cipherPtr);
return(tcs.Task);
}
/// <summary>
/// Dispose of the game client.
/// </summary>
public void Dispose()
{
Disconnect();
foreach (var cb in _registeredCallbacks)
{
Callbacks.Unregister(cb);
}
_registeredCallbacks.Clear();
}
public static Task <bool> InitLoggingAsync()
{
return(Task.Run(
() => {
var tcs = new TaskCompletionSource <bool>();
InitLoggingCb cb2 = null;
cb2 = (ptr, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(cb2);
return;
}
tcs.SetResult(true);
CallbackManager.Unregister(cb2);
};
CallbackManager.Register(cb2);
AppOutputLogPathCallback cb1 = null;
cb1 = async(ptr, result, path) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(cb1);
CallbackManager.Unregister(cb2);
return;
}
var appPath = Path.GetDirectoryName(path);
var fileList = new List <Tuple <string, string> > {
Tuple.Create("log.toml", Path.Combine(appPath, "log.toml"))
};
var fileOps = DependencyService.Get <IFileOps>();
await fileOps.TransferAssetsAsync(fileList);
Debug.WriteLine("Assets Transferred");
NativeBindings.AppInitLogging(null, UserData, cb2);
CallbackManager.Unregister(cb1);
};
CallbackManager.Register(cb1);
NativeBindings.AppOutputLogPath("test_file", UserData, cb1);
return tcs.Task;
}));
}
public static Task <ulong> MDataEntriesLenAsync(ulong entriesHandle)
{
var tcs = new TaskCompletionSource <ulong>();
MDataEntriesLenCb callback = null;
callback = (self, len) => {
// TODO: no result?
tcs.SetResult(len);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataEntriesLen(Session.AppPtr, entriesHandle, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> IDataSizeAsync(ulong seHandle)
{
var tcs = new TaskCompletionSource <ulong>();
IDataSizeCb callback = null;
callback = (self, result, len) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(len);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.IDataSize(Session.AppPtr, seHandle, Session.UserData, callback);
return(tcs.Task);
}
public static Task MDataMutateEntriesAsync(ulong mDataInfoH, ulong entryActionsH)
{
var tcs = new TaskCompletionSource <object>();
MDataMutateEntriesCb callback = null;
callback = (pVoid, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(null);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataMutateEntries(Session.AppPtr, mDataInfoH, entryActionsH, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> MDataListKeysAsync(ulong mDataInfoH)
{
var tcs = new TaskCompletionSource <ulong>();
MDataListKeysCb callback = null;
callback = (pVoid, result, mDataEntKeysH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(mDataEntKeysH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataListKeys(Session.AppPtr, mDataInfoH, Session.UserData, callback);
return(tcs.Task);
}
public static Task <List <byte> > IDataReadFromSelfEncryptorAsync(ulong seHandle, ulong fromPos, ulong len)
{
var tcs = new TaskCompletionSource <List <byte> >();
IDataReadFromSelfEncryptorCb callback = null;
callback = (self, result, dataPtr, dataLen) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var data = dataPtr.ToList <byte>(dataLen);
tcs.SetResult(data);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.IDataReadFromSelfEncryptor(Session.AppPtr, seHandle, fromPos, len, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> IDataNewSelfEncryptorAsync()
{
var tcs = new TaskCompletionSource <ulong>();
IDataNewSelfEncryptorCb callback = null;
callback = (self, result, sEWriterHandle) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(sEWriterHandle);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.IDataNewSelfEncryptor(Session.AppPtr, Session.UserData, callback);
return(tcs.Task);
}
public static Task EncPubKeyFreeAsync(ulong encPubKeyH)
{
var tcs = new TaskCompletionSource <object>();
EncPubKeyFreeCb callback = null;
callback = (pVoid, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(null);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.EncPubKeyFree(Session.AppPtr, encPubKeyH, Session.UserData, callback);
return(tcs.Task);
}
public static Task <Tuple <ulong, ulong> > EncGenerateKeyPairAsync()
{
var tcs = new TaskCompletionSource <Tuple <ulong, ulong> >();
EncGenerateKeyPairCb callback = null;
callback = (pVoid, result, encPubKeyH, encSecKeyH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(Tuple.Create(encPubKeyH, encSecKeyH));
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.EncGenerateKeyPair(Session.AppPtr, Session.UserData, callback);
return(tcs.Task);
}
public static Task <List <byte> > EncSecretKeyGetAsync(ulong encSecKeyH)
{
var tcs = new TaskCompletionSource <List <byte> >();
EncSecretKeyGetCb callback = null;
callback = (pVoid, result, encSecKeyPtr) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(encSecKeyPtr.ToList <byte>((IntPtr)KeyLen));
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.EncSecretKeyGet(Session.AppPtr, encSecKeyH, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> AppPubSignKeyAsync()
{
var tcs = new TaskCompletionSource <ulong>();
AppPubSignKeyCb callback = null;
callback = (pVoid, result, appPubSignKeyH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(appPubSignKeyH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.AppPubSignKey(Session.AppPtr, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> MDataListEntriesAsync(ulong infoHandle)
{
var tcs = new TaskCompletionSource <ulong>();
MDataListEntriesCb callback = null;
callback = (self, result, mDataEntriesHandle) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(mDataEntriesHandle);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataListEntries(Session.AppPtr, infoHandle, Session.UserData, callback);
return(tcs.Task);
}
public static Task MDataPermissionsSetAllowAsync(ulong permissionSetH, MDataAction allowAction)
{
var tcs = new TaskCompletionSource <object>();
MDataPermissionsSetAllowCb callback = null;
callback = (pVoid, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(null);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataPermissionsSetAllow(Session.AppPtr, permissionSetH, allowAction, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> CipherOptNewPlaintextAsync()
{
var tcs = new TaskCompletionSource <ulong>();
CipherOptNewPlaintextCb callback = null;
callback = (self, result, cipherOptHandle) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(cipherOptHandle);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.CipherOptNewPlaintext(Session.AppPtr, Session.UserData, callback);
return(tcs.Task);
}
public static Task <List <byte> > MDataInfoSerialiseAsync(ulong mdataInfoH)
{
var tcs = new TaskCompletionSource <List <byte> >();
MDataInfoSerialiseCb callback = null;
callback = (pVoid, result, bytesPtr, len) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(bytesPtr.ToList <byte>(len));
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataInfoSerialise(Session.AppPtr, mdataInfoH, Session.UserData, callback);
return(tcs.Task);
}
public static Task CipherOptFreeAsync(ulong cipherOptHandle)
{
var tcs = new TaskCompletionSource <object>();
CipherOptFreeCb callback = null;
callback = (self, result) => {
if (result.ErrorCode != 0)
{
CallbackManager.Unregister(callback);
tcs.SetException(result.ToException());
return;
}
tcs.SetResult(null);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.CipherOptFree(Session.AppPtr, cipherOptHandle, Session.UserData, callback);
return(tcs.Task);
}
public static Task MDataEntriesInsertAsync(ulong entriesH, List <byte> entKey, List <byte> entVal)
{
var tcs = new TaskCompletionSource <object>();
MDataEntriesInsertCb callback = null;
callback = (pVoid, result) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(null);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
var entKeyPtr = entKey.ToIntPtr();
var entValPtr = entVal.ToIntPtr();
NativeBindings.MDataEntriesInsert(
Session.AppPtr,
entriesH,
entKeyPtr,
(IntPtr)entKey.Count,
entValPtr,
(IntPtr)entVal.Count,
Session.UserData,
callback);
Marshal.FreeHGlobal(entKeyPtr);
Marshal.FreeHGlobal(entValPtr);
return(tcs.Task);
}
public static Task <ulong> MDataInfoRandomPublicAsync(ulong typeTag)
{
var tcs = new TaskCompletionSource <ulong>();
MDataInfoRandomPublicCb callback = null;
callback = (pVoid, result, pubMDataInfoH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(pubMDataInfoH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.MDataInfoRandomPublic(Session.AppPtr, typeTag, Session.UserData, callback);
return(tcs.Task);
}
public static Task <List <byte> > IDataCloseSelfEncryptorAsync(ulong seH, ulong cipherOptH)
{
var tcs = new TaskCompletionSource <List <byte> >();
IDataCloseSelfEncryptorCb callback = null;
callback = (self, result, xorNamePtr) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
var xorNameList = xorNamePtr.ToList <byte>((IntPtr)32);
tcs.SetResult(xorNameList);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.IDataCloseSelfEncryptor(Session.AppPtr, seH, cipherOptH, Session.UserData, callback);
return(tcs.Task);
}
public static Task <ulong> GetContainerMDataInfoAsync(string appId)
{
var tcs = new TaskCompletionSource <ulong>();
AccessContainerGetContainerMDataInfoCb callback = null;
callback = (pVoid, result, mdataInfoH) => {
if (result.ErrorCode != 0)
{
tcs.SetException(result.ToException());
CallbackManager.Unregister(callback);
return;
}
tcs.SetResult(mdataInfoH);
CallbackManager.Unregister(callback);
};
CallbackManager.Register(callback);
NativeBindings.AccessContainerGetContainerMDataInfo(Session.AppPtr, appId, Session.UserData, callback);
return(tcs.Task);
}