public void ActivateDisplayDelegate(string objectIdentifier, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out StarPrinter nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.DisplayDelegate.Connected += (sender, e) =>
{
var parameter = new Dictionary <string, JSValue>();
parameter.Add(EventParameter.KeyIdentifier, objectIdentifier);
DisplayConnected(parameter);
};
nativeObject.DisplayDelegate.Disconnected += (sender, e) =>
{
var parameter = new Dictionary <string, JSValue>();
parameter.Add(EventParameter.KeyIdentifier, objectIdentifier);
DisplayDisconnected(parameter);
};
promise.Resolve();
}
public async void GetStatus(string objectIdentifier, int timeout, IReactPromise <string> promise)
{
if (!GetObject(objectIdentifier, out StarPrinter nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.GetStatusTimeout = timeout;
try
{
StarPrinterStatus status = await nativeObject.GetStatusAsync();
StarPrinterStatusWrapper.SetObject(status, out string statusIdentifier);
promise.Resolve(statusIdentifier);
}
catch (StarIO10Exception e)
{
StarIO10ErrorWrapper.SetObject(e, out string exceptionIdentifier);
promise.Reject(new ReactError()
{
Code = exceptionIdentifier, Exception = e
});
}
}
public void ActivateInputDeviceDelegate(string objectIdentifier, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out StarPrinter nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.InputDeviceDelegate.Connected += (sender, e) =>
{
var parameter = new Dictionary <string, JSValue>();
parameter.Add(EventParameter.KeyIdentifier, objectIdentifier);
InputDeviceConnected(parameter);
};
nativeObject.InputDeviceDelegate.Disconnected += (sender, e) =>
{
var parameter = new Dictionary <string, JSValue>();
parameter.Add(EventParameter.KeyIdentifier, objectIdentifier);
InputDeviceDisconnected(parameter);
};
nativeObject.InputDeviceDelegate.DataReceived += (sender, e) =>
{
var parameter = new Dictionary <string, JSValue>();
parameter.Add(EventParameter.KeyIdentifier, objectIdentifier);
parameter.Add(EventParameter.KeyInputDeviceData, StarIO10ValueConverter.ToJSValue(e.Data.ToArray()));
InputDeviceDataReceived(parameter);
};
promise.Resolve();
}
public void getItem(string key, JSValue options, IReactPromise <string> promise)
{
if (string.IsNullOrEmpty(key))
{
promise.Reject(new ReactError {
Exception = new ArgumentNullException("KEY IS REQUIRED")
});
return;
}
try
{
string name = sharedPreferences(options);
var credential = prefs(name, key);
if (credential != null)
{
promise.Resolve(credential.Password);
}
else
{
throw new Exception("credential NOT FOUND");
}
}
catch (Exception ex)
{
promise.Reject(new ReactError {
Message = "ERROR GET : " + ex.Message
});
}
}
public void deleteItem(string key, JSValue options, IReactPromise <string> promise)
{
if (string.IsNullOrEmpty(key))
{
promise.Reject(new ReactError {
Exception = new ArgumentNullException("KEY IS REQUIRED")
});
return;
}
try
{
string name = sharedPreferences(options);
var vault = new PasswordVault();
var credential = vault.Retrieve(name, key);
vault.Remove(credential);
promise.Resolve(key);
}
catch (Exception ex)
{
promise.Reject(new ReactError {
Message = "ERROR DELETE : " + ex.Message
});
}
}
public async void SendMessageAsync(string name, string surname, IReactPromise <string> promise)
{
HttpClient client = new HttpClient();
var result = await client.GetStringAsync($"http://localhost:5000/api/sdk?name={name}&surname={surname}");
promise.Resolve(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
});
}
}
public void Init(IReactPromise <string> promise)
{
StarPrinter nativeObject = new StarPrinter(new StarConnectionSettings());
SetObject(nativeObject, out string objectIdentifier);
nativeObject.PrinterDelegate.CommunicationError += (sender, e) =>
{
StarIO10ErrorWrapper.SetObject(e.Exception, out string exceptionIdentifier);
PrinterCommunicationError(new CommunicationErrorEventParameter()
{
identifier = objectIdentifier, errorIdentifier = exceptionIdentifier
});
};
nativeObject.DrawerDelegate.CommunicationError += (sender, e) =>
{
StarIO10ErrorWrapper.SetObject(e.Exception, out string exceptionIdentifier);
DrawerCommunicationError(new CommunicationErrorEventParameter()
{
identifier = objectIdentifier, errorIdentifier = exceptionIdentifier
});
};
nativeObject.InputDeviceDelegate.CommunicationError += (sender, e) =>
{
StarIO10ErrorWrapper.SetObject(e.Exception, out string exceptionIdentifier);
InputDeviceCommunicationError(new CommunicationErrorEventParameter()
{
identifier = objectIdentifier, errorIdentifier = exceptionIdentifier
});
};
promise.Resolve(objectIdentifier);
}
public void ActivateInputDeviceDelegate(string objectIdentifier, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out StarPrinter nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.InputDeviceDelegate.Connected += (sender, e) =>
{
InputDeviceConnected(new EventParameter()
{
identifier = objectIdentifier
});
};
nativeObject.InputDeviceDelegate.Disconnected += (sender, e) =>
{
InputDeviceDisconnected(new EventParameter()
{
identifier = objectIdentifier
});
};
nativeObject.InputDeviceDelegate.DataReceived += (sender, e) =>
{
InputDeviceDataReceived(new InputDeviceDataReceivedEventParameter()
{
identifier = objectIdentifier, data = e.Data.ToArray()
});
};
promise.Resolve();
}
/// <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);
}
public async void captureRef(int tag, JSValue options, IReactPromise <string> promise)
{
string format = options["format"].IsNull ? "png" : options["format"].AsString();
double quality = options["quality"].IsNull ? 1.0 : options["quality"].AsDouble();
int width = options["width"].IsNull ? 0 : options["width"].AsInt16();
int height = options["height"].IsNull ? 0 : options["height"].AsInt16();
string result = options["result"].IsNull ? "tmpfile" : options["result"].AsString();
string path = options["path"].IsNull ? null : options["path"].AsString();
if (format != "png" && format != "jpg" && format != "jpeg")
{
promise.Reject(new ReactError {
Code = ViewShot.ErrorUnableToSnapshot, Message = "Unsupported image format: " + format + ". Try one of: png | jpg | jpeg"
});
return;
}
try
{
var control = XamlUIService.FromContext(_context.Handle).ElementFromReactTag(tag) as FrameworkElement;
ViewShot view = new ViewShot();
var output = await view.Execute(control, format, quality, width, height, path, result);
promise.Resolve(output);
}
catch (Exception exc)
{
promise.Reject(new ReactError {
Message = exc.Message, Exception = exc
});
}
}
public void Init(string[] interfaceTypes, IReactPromise <string> promise)
{
List <InterfaceType> nativeInterfaceTypes = new List <InterfaceType>();
foreach (string interfaceType in interfaceTypes)
{
if (!StarIO10ValueConverter.ToInterfaceType(interfaceType, out InterfaceType nativeInterfaceType))
{
promise.Reject(new ReactError());
return;
}
nativeInterfaceTypes.Add(nativeInterfaceType);
}
try
{
IStarDeviceDiscoveryManager nativeObject = StarDeviceDiscoveryManagerFactory.Create(nativeInterfaceTypes);
SetObject(nativeObject, out string objectIdentifier);
nativeObject.PrinterFound += (sender, e) =>
{
if (!StarIO10ValueConverter.ToString(e.Printer.ConnectionSettings.InterfaceType, out string interfaceTypeString) ||
!StarIO10ValueConverter.ToString(e.Printer.Information.Model, out string modelString) ||
!StarIO10ValueConverter.ToString(e.Printer.Information.Emulation, out string emulationString))
{
return;
}
var parameter = new Dictionary <string, JSValue>();
parameter.Add(EventParameter.KeyIdentifier, objectIdentifier);
parameter.Add(EventParameter.KeyInterfaceType, interfaceTypeString);
parameter.Add(EventParameter.KeyConnectionIdentifier, e.Printer.ConnectionSettings.Identifier);
parameter.Add(EventParameter.KeyModel, modelString);
parameter.Add(EventParameter.KeyEmulation, emulationString);
parameter.Add(EventParameter.KeyReserved, StarIO10ValueConverter.ToJSValue(e.Printer.Information.Reserved));
PrinterFound(parameter);
};
nativeObject.DiscoveryFinished += (sender, e) =>
{
var parameter = new Dictionary <string, JSValue>();
parameter.Add(EventParameter.KeyIdentifier, objectIdentifier);
DiscoveryFinished(parameter);
};
promise.Resolve(objectIdentifier);
}
catch (StarIO10Exception e)
{
StarIO10ErrorWrapper.SetObject(e, out string exceptionIdentifier);
promise.Reject(new ReactError()
{
Code = exceptionIdentifier, Exception = e
});
}
}
public void Init(IReactPromise <string> promise)
{
DisplayBuilder nativeObject = new DisplayBuilder();
SetObject(nativeObject, out string objectIdentifier);
promise.Resolve(objectIdentifier);
}
public void Init(IReactPromise <string> promise)
{
PresenterSettingBuilder nativeObject = new PresenterSettingBuilder();
SetObject(nativeObject, out string objectIdentifier);
promise.Resolve(objectIdentifier);
}
public void Init(IReactPromise <string> promise)
{
StarXpandCommandBuilder nativeObject = new StarXpandCommandBuilder();
SetObject(nativeObject, out string objectIdentifier);
promise.Resolve(objectIdentifier);
}
public void Init(IReactPromise <string> promise)
{
MelodySpeakerBuilder nativeObject = new MelodySpeakerBuilder();
SetObject(nativeObject, out string objectIdentifier);
promise.Resolve(objectIdentifier);
}
public void GetCommands(string objectIdentifier, IReactPromise <string> promise)
{
if (!GetObject(objectIdentifier, out StarXpandCommandBuilder nativeObject))
{
promise.Reject(new ReactError());
return;
}
promise.Resolve(nativeObject.GetCommand());
}
public void GetReserved(string objectIdentifier, IReactPromise <IReadOnlyDictionary <string, JSValue> > promise)
{
if (!GetObject(objectIdentifier, out StarPrinter nativeObject))
{
promise.Reject(new ReactError());
return;
}
promise.Resolve(StarIO10ValueConverter.ToJSDictionary(nativeObject.Information.Reserved));
}
public void GetErrorCode(string objectIdentifier, IReactPromise <int> promise)
{
if (!GetObject(objectIdentifier, out StarIO10Exception nativeObject))
{
promise.Reject(new ReactError());
return;
}
promise.Resolve(nativeObject.ErrorCode);
}
public void GetPaperNearEmpty(string objectIdentifier, IReactPromise <bool> promise)
{
if (!GetObject(objectIdentifier, out StarPrinterStatus nativeObject) ||
nativeObject == null)
{
promise.Reject(new ReactError());
return;
}
promise.Resolve(nativeObject.PaperNearEmpty);
}
public void GetDrawerOpenCloseSignal(string objectIdentifier, IReactPromise <bool> promise)
{
if (!GetObject(objectIdentifier, out StarPrinterStatus nativeObject) ||
nativeObject == null)
{
promise.Reject(new ReactError());
return;
}
promise.Resolve(nativeObject.DrawerOpenCloseSignal);
}
public void GetType(string objectIdentifier, IReactPromise <string> promise)
{
if (!GetObject(objectIdentifier, out StarIO10Exception nativeObject))
{
promise.Reject(new ReactError());
return;
}
string type;
if (nativeObject is StarIO10ArgumentException)
{
type = "Argument";
}
else if (nativeObject is StarIO10BadResponseException)
{
type = "BadResponse";
}
else if (nativeObject is StarIO10CommunicationException)
{
type = "Communication";
}
else if (nativeObject is StarIO10IllegalDeviceStateException)
{
type = "IllegalDeviceState";
}
else if (nativeObject is StarIO10InUseException)
{
type = "InUse";
}
else if (nativeObject is StarIO10InvalidOperationException)
{
type = "InvalidOperation";
}
else if (nativeObject is StarIO10NotFoundException)
{
type = "NotFound";
}
else if (nativeObject is StarIO10UnknownException)
{
type = "Unknown";
}
else if (nativeObject is StarIO10UnprintableException)
{
type = "Unprintable";
}
else
{
promise.Reject(new ReactError());
return;
}
promise.Resolve(type);
}
public void GetEmulation(string objectIdentifier, IReactPromise <string> promise)
{
if (!GetObject(objectIdentifier, out StarPrinter nativeObject) ||
!StarIO10ValueConverter.ToString(nativeObject.Information.Emulation, out string emulationString))
{
promise.Reject(new ReactError());
return;
}
promise.Resolve(emulationString);
}
public void ActionClearAll(string objectIdentifier, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out DisplayBuilder nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.ActionClearAll();
promise.Resolve();
}
public void SettingPrintableArea(string objectIdentifier, double width, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out DocumentBuilder nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.SettingPrintableArea(width);
promise.Resolve();
}
public void ActionSetBackLightState(string objectIdentifier, bool on, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out DisplayBuilder nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.ActionSetBackLightState(on);
promise.Resolve();
}
public void StyleLineSpace(string objectIdentifier, double height, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out PrinterBuilder nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.StyleLineSpace(height);
promise.Resolve();
}
public void ActionFeedLine(string objectIdentifier, int lines, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out PrinterBuilder nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.ActionFeedLine(lines);
promise.Resolve();
}
public void ActionPrintText(string objectIdentifier, string content, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out PrinterBuilder nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.ActionPrintText(content);
promise.Resolve();
}
public void StyleInvert(string objectIdentifier, bool enable, IReactPromise <JSValue.Void> promise)
{
if (!GetObject(objectIdentifier, out PrinterBuilder nativeObject))
{
promise.Reject(new ReactError());
return;
}
nativeObject.StyleInvert(enable);
promise.Resolve();
}
