public async Task <JSValueObject> PickDirectory()
{
TaskCompletionSource <JSValueObject> tcs = new TaskCompletionSource <JSValueObject>();
await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() =>
{
var openFolderPicker = new FolderPicker();
openFolderPicker.ViewMode = PickerViewMode.List;
openFolderPicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary;
openFolderPicker.FileTypeFilter.Add("*");
var folder = await openFolderPicker.PickSingleFolderAsync();
if (folder != null)
{
JSValueObject obj = new JSValueObject
{
{ "uri", folder.Path }
};
tcs.SetResult(obj);
}
else
{
tcs.SetResult(new JSValueObject());
}
});
var result = await tcs.Task;
return(result);
}
public void getAllItems(JSValue options, IReactPromise <JSValue> promise)
{
try
{
string name = sharedPreferences(options);
JSValueObject ret = new JSValueObject();
var vault = new PasswordVault();
var credentialList = vault.FindAllByResource(name);
if (credentialList.Count > 0)
{
credentialList.ToList().ForEach(item =>
{
var credential = prefs(name, item.UserName);
ret[item.UserName] = credential.Password;
});
}
promise.Resolve(ret);
}
catch (Exception ex)
{
promise.Reject(new ReactError {
Message = "ERROR GET ALL : " + ex.Message
});
}
}
/// <summary>
/// Returns latest ir or color frame in base64 format.
/// </summary>
/// <param name="type">Frame type. Either Color or Infrared</param>
/// <param name="promise"></param>
/// <returns></returns>
public async Task TakePictureAsync(MediaFrameSourceKind type, IReactPromise <JSValueObject> promise)
{
var base64Frame = "";
if (type == MediaFrameSourceKind.Color && colorFrame != null)
{
base64Frame = await ConvertToBase64(colorFrame);
}
if (type == MediaFrameSourceKind.Infrared && irFrame != null)
{
base64Frame = await ConvertToBase64(irFrame);
}
if (string.IsNullOrEmpty(base64Frame))
{
var err = new ReactError();
err.Message = "Error taking picture.";
promise.Reject(err);
}
var obj = new JSValueObject();
obj.Add("base64", base64Frame);
promise.Resolve(obj);
}
private async Task <JSValueObject> PrepareFile(StorageFile file, bool cache, bool readContent)
{
string base64Content = null;
if (readContent)
{
var fileStream = await file.OpenReadAsync();
using (StreamReader reader = new StreamReader(fileStream.AsStream()))
{
using (var memstream = new MemoryStream())
{
await reader.BaseStream.CopyToAsync(memstream);
var bytes = memstream.ToArray();
base64Content = Convert.ToBase64String(bytes);
}
}
}
if (cache == true)
{
var fileInCache = await file.CopyAsync(ApplicationData.Current.TemporaryFolder, file.Name.ToString(), NameCollisionOption.ReplaceExisting);
var basicProperties = await fileInCache.GetBasicPropertiesAsync();
JSValueObject result = new JSValueObject
{
{ FIELD_URI, file.Path },
{ FIELD_FILE_COPY_URI, file.Path },
{ FIELD_TYPE, file.ContentType },
{ FIELD_NAME, file.Name },
{ FIELD_SIZE, basicProperties.Size },
{ FIELD_CONTENT, base64Content }
};
return(result);
}
else
{
var basicProperties = await file.GetBasicPropertiesAsync();
JSValueObject result = new JSValueObject
{
{ FIELD_URI, file.Path },
{ FIELD_FILE_COPY_URI, file.Path },
{ FIELD_TYPE, file.ContentType },
{ FIELD_NAME, file.Name },
{ FIELD_SIZE, basicProperties.Size },
{ FIELD_CONTENT, base64Content }
};
return(result);
}
}
public JSValue GetMidpointByJSValue(JSValue p1, JSValue p2)
{
double midX = 0.5 * (p1["x"].AsDouble() + p2["x"].AsDouble());
double midY = 0.5 * (p1["y"].AsDouble() + p2["y"].AsDouble());
JSValue midpoint = new JSValueObject()
{
{ "x", midX },
{ "y", midY },
};
return(midpoint);
}
// An example asynchronous method which uses asynchronous Windows APIs to make a
// http request to the given url and resolve the given promise with the result
static async Task GetHttpResponseAsync(string uri, ReactPromise <JSValue> promise)
{
// Create an HttpClient object
var httpClient = new HttpClient();
// Send the GET request asynchronously
var httpResponseMessage = await httpClient.GetAsync(new Uri(uri));
var statusCode = httpResponseMessage.StatusCode;
var content = await httpResponseMessage.Content.ReadAsStringAsync();
// Build result object
var resultObject = new JSValueObject();
resultObject["statusCode"] = (int)statusCode;
resultObject["content"] = content;
promise.Resolve(resultObject);
}
public void LoadReact()
{
ReactNativeHost host = new ReactNativeHost();
host.InstanceSettings.MainComponentName = JSFileName;
host.InstanceSettings.JavaScriptMainModuleName = JSFileName;
host.InstanceSettings.UseLiveReload = true;
host.InstanceSettings.UseWebDebugger = true;
host.InstanceSettings.EnableDeveloperMenu = true;
host.ReloadInstance();
RootElement.ComponentName = JSComponentName;
JSValue initialProps = new JSValueObject {
["one"] = "1", ["two"] = "2"
};
RootElement.InitialProps = (IJSValueWriter writer) => writer.WriteValue(initialProps);
RootElement.ReactNativeHost = host;
}
