public ZebraZC3(DiscoveredPrinter discoveredPrinter) : this()
{
_discoveredPrinter = discoveredPrinter ?? throw new ArgumentNullException(nameof(discoveredPrinter));
_errorFactory = new Error.ZebraErrorFactory();
// Set Properties from dicovered printer
string model;
if (_discoveredPrinter.DiscoveryDataMap.TryGetValue("MODEL", out model))
{
Model = model;
}
string mfg;
if (_discoveredPrinter.DiscoveryDataMap.TryGetValue("MFG", out mfg))
{
Manufacturer = mfg;
}
string serial;
if (_discoveredPrinter.DiscoveryDataMap.TryGetValue("SERIAL_NUMBER", out serial))
{
DeviceId = serial;
}
Name = string.Format("{0}[{1}]", model, serial);
}
private void DiscoverPrinters(string message)
{
try {
UrlPrinterDiscoveryHandler urlDiscoHandler = new UrlPrinterDiscoveryHandler();
UrlPrinterDiscoverer.FindPrinters(message, urlDiscoHandler);
while (!urlDiscoHandler.IsDiscoveryFinsished)
{
Thread.Sleep(100);
}
CloseScanDialogWindow();
DiscoveredPrinter discoveredPrinter = urlDiscoHandler.PreferredPrinter;
if (discoveredPrinter != null)
{
UpdateSelectedPrinter(discoveredPrinter);
}
else
{
ShowErrorDialogWindow("Discovery Error: No printers found.");
}
} catch (Exception e) {
ShowErrorDialogWindow($"Connection Error: {e.Message}");
} finally {
CloseScanDialogWindow();
}
}
public void basicPrint(string zplbarcode, string lbl_one, string lbl_two, string lbl_three, string lbl_four, string lbl_five, string lbl_six)
{
List <DiscoveredPrinter> printerList = GetUSBPrinters();
string zpl_string = "^XA"
+ "^FX^FWr^CI28^CFA,40^FO100,50^A0B^FD" + lbl_one + "^FS^FO150,50^A0B^FD" + lbl_two + "^FS^FO200,50^A0B^FD" + lbl_three + "^FS^FO250,50^A0B^FD4MM^FS"
+ "^FX fifth^FO595,320^A0B^FD" + lbl_four + "^FS"
+ "^FXfifth formulation^FO510,30^A0B^FD" + lbl_five + "^FS"
+ "^FXfourthsection with barcode."
+ "^BY2,2.5,123^FO380,730^BCB,,N,N,N,A^FD" + zplbarcode + "^FS^CFA,40^FO320,730^A0B,0,0^FD" + zplbarcode + "^FS"
+ "^FX fifth section"
+ "^CF0,90^FO275,1145^A0B^FD" + lbl_six + "^FS"
+ "^XZ";
if (printerList.Count > 0)
{
// in this case, we arbitrarily are printing to the first found printer
DiscoveredPrinter discoveredPrinter = printerList[0];
Connection connection = discoveredPrinter.GetConnection();
connection.Open();
connection.Write(Encoding.UTF8.GetBytes(zpl_string));
}
else
{
Console.WriteLine("No Printers found to print to.");
}
}
private void UpdateSelectedPrinter(DiscoveredPrinter discoveredPrinter)
{
PrinterInfo discoveredPrinterInfo = new PrinterInfo {
Address = discoveredPrinter.Address,
FriendlyName = discoveredPrinter.DiscoveryDataMap.ContainsKey("FRIENDLY_NAME") ? discoveredPrinter.DiscoveryDataMap["FRIENDLY_NAME"] : discoveredPrinter.DiscoveryDataMap["SYSTEM_NAME"]
};
if (discoveredPrinterInfo.Address != null && discoveredPrinterInfo.FriendlyName != null)
{
LinkedListNode <PrinterInfo> node = myMainWindow.recentlySelectedPrinters.First;
while (node != null)
{
PrinterInfo printerInfo = node.Value;
if (printerInfo.Address.Equals(discoveredPrinterInfo.Address))
{
Application.Current.Dispatcher.Invoke(() => {
selectedPrinterComboBox.SelectedItem = printerInfo;
});
return;
}
node = node.Next;
}
string previousPrinterIp = Properties.Settings.Default.IpAddress;
if (previousPrinterIp.Length > 0)
{
myMainWindow.previousPrinters.Add(previousPrinterIp, Properties.Settings.Default.FriendlyName);
}
myMainWindow.printerIpAddress = discoveredPrinterInfo.Address;
myMainWindow.printerFriendlyName = discoveredPrinterInfo.FriendlyName;
myMainWindow.SetSelectedPrinter(myMainWindow.printerFriendlyName, myMainWindow.printerIpAddress);
}
}
public void FoundPrinter(DiscoveredPrinter printer)
{
Device.BeginInvokeOnMainThread(() =>
{
_discoveredPrinters.Add(printer); // ListView view model operations must be done on UI thread due to iOS issues when clearing list while item is selected: https://forums.xamarin.com/discussion/19114/invalid-number-of-rows-in-section
});
}
public void FoundPrinter(DiscoveredPrinter printer)
{
if (PreferredPrinter == null || (DependencyService.Get <IConnectionManager>().IsBluetoothPrinter(PreferredPrinter) && printer is DiscoveredPrinterNetwork))
{
PreferredPrinter = printer;
}
}
private void PrinterManager_PrinterSelected(DiscoveredPrinter printer)
{
Application.Current.Dispatcher.Invoke(() => {
DemoContentControl.Content = noDemoSelectedControl;
viewModel.SelectedPrinter = printer;
});
}
public void PrinterOnline(ZebraCardPrinter zebraCardPrinter, string firmwareVersion)
{
Connection newConnection = null;
try {
DiscoveredPrinter newPrinter = null;
newConnection = zebraCardPrinter.Connection;
newConnection.Open();
Dictionary <string, string> discoveryData = DiscoveryUtilCard.GetDiscoveryDataMap(newConnection);
if (oldPrinter is DiscoveredUsbPrinter)
{
newPrinter = new DiscoveredUsbPrinter((newConnection as UsbConnection).SimpleConnectionName, discoveryData);
}
else if (oldPrinter is DiscoveredCardPrinterNetwork)
{
newPrinter = new DiscoveredCardPrinterNetwork(discoveryData);
}
else
{
throw new ArgumentException("Not a reconnectable printer type");
}
ReconnectionFinished(newPrinter);
} catch (Exception e) {
MessageBoxHelper.ShowError("Could not reconnect to printer: " + e.Message);
} finally {
ConnectionHelper.CleanUpQuietly(zebraCardPrinter, newConnection);
}
}
public async Task StartPolling(DiscoveredPrinter printer, JobInfo jobInfo)
{
List <JobInfo> jobInfoList = new List <JobInfo> {
jobInfo
};
await StartPolling(printer, jobInfoList);
}
private void FoundNetworkPrinter(DiscoveredPrinter printer)
{
string imageSource = "/Resources/network.png";
Application.Current.Dispatcher.Invoke(() => {
printerDiscoveryWindow.PrinterDiscoverListView.Items.Add(new { ConnectionImageSource = imageSource, FriendlyName = printer.DiscoveryDataMap["SYSTEM_NAME"], IpAddress = printer.Address });
});
}
public void FoundPrinter(DiscoveredPrinter printer)
{
Device.BeginInvokeOnMainThread(() =>
{
if (printer.Address == Settings.PrinterAddress)
{
ConstantManager.PrinterSetting = printer;
}
});
}
public void FoundPrinter(DiscoveredPrinter printer)
{
if (preferredPrinter == null)
{
preferredPrinter = printer;
}
else if ((preferredPrinter is DiscoveredPrinterBluetooth) && printer is DiscoveredPrinterNetwork)
{
preferredPrinter = printer;
}
}
public void FoundPrinter(DiscoveredPrinter printer)
{
if (printer is DiscoveredPrinterNetwork)
{
FoundNetworkPrinter(printer);
}
else if (printer is DiscoveredPrinterBluetooth)
{
FoundBluetoothPrinter(printer);
}
}
public static Connection Create(DiscoveredPrinter printer)
{
if (DependencyService.Get <IPrinterHelper>().IsBluetoothPrinter(printer))
{
return(DependencyService.Get <IConnectionManager>().GetBluetoothConnection(printer.Address));
}
else
{
return(new TcpConnection(printer.Address, 9100));
}
}
public PrintFormatPage(DiscoveredPrinter selectedPrinter, FormatViewModel format)
{
InitializeComponent();
this.selectedPrinter = selectedPrinter;
this.format = format;
BindingContext = viewModel;
Device.BeginInvokeOnMainThread(async() => {
await PopulateVariableFieldListAsync();
});
}
public async void SendZplPalletAsync(string header, string ipAddr)
{
Connection connection = null;
try
{
if (!string.IsNullOrEmpty(ipAddr))
{
connection = new TcpConnection(ipAddr, 9100);
}
else
{
myPrinter = ConstantManager.PrinterSetting;
connection = myPrinter.GetConnection();
}
await Task.Run(async() => {
try
{
connection.Open();
PrinterLanguage printerLanguage = ZebraPrinterFactory.GetInstance(connection).PrinterControlLanguage;
connection.Write(GetTestLabelBytes(printerLanguage, header));
await Task.Delay(1000);
}
catch (Exception e)
{
// Connection Exceptions and issues are caught here
Device.BeginInvokeOnMainThread(async() =>
{
await _dialogService.DisplayAlertAsync("Error", $"Error: {e.Message}", "Ok");
});
}
finally
{
try
{
connection?.Close();
}
catch (ConnectionException) { }
}
});
}
catch (Exception ex)
{
// Connection Exceptions and issues are caught here
Device.BeginInvokeOnMainThread(async() =>
{
await _dialogService.DisplayAlertAsync("Error", "Could not connect to printer", "Ok");
});
Crashes.TrackError(ex);
}
}
public static DiscoveredPrinter DiscoverPrinter(string nfcData)
{
DiscoveredPrinter printer = null;
try {
NfcDiscoveryHandler nfcDiscoveryHandler = new NfcDiscoveryHandler();
DependencyService.Get <IConnectionManager>().FindUrlPrinters(nfcData, nfcDiscoveryHandler);
while (!nfcDiscoveryHandler.IsFinished)
{
Thread.Sleep(100);
}
printer = nfcDiscoveryHandler.PreferredPrinter;
} catch (Exception) { }
return(printer);
}
private static String GetPrinterDisplayName(DiscoveredPrinter printer)
{
String printerName = printer.Address;
if (printer is DiscoveredPrinterBluetooth)
{
printerName += " (" + ((DiscoveredPrinterBluetooth)printer).FriendlyName + ")";
}
else if (printer is DiscoveredPrinterNetwork)
{
DiscoveredPrinterNetwork thisDiscoveredPrinterNetwork = (DiscoveredPrinterNetwork)printer;
if (false == thisDiscoveredPrinterNetwork.Address.Equals(thisDiscoveredPrinterNetwork.DnsName))
{
printerName += " (" + thisDiscoveredPrinterNetwork.DnsName + ")";
}
}
return(printerName);
}
private DiscoveredPrinter DiscoveryUSB()
{
DiscoveredPrinter discoveredPrinter = null;
try
{
foreach (DiscoveredUsbPrinter usbPrinter in UsbDiscoverer.GetZebraUsbPrinters())
{
discoveredPrinter = usbPrinter;
}
}
catch (DiscoveryException e)
{
Debug.WriteLine("DiscoveryException Exception: " + e.ToString());
}
return(discoveredPrinter);
}
private async void SelectButton_Clicked(object sender, EventArgs eventArgs)
{
if (!viewModel.IsSelectingPrinter && Navigation.NavigationStack.Count > 0 && Navigation.NavigationStack.Last().GetType() == typeof(SelectPrinterPage))
{
await Task.Factory.StartNew(() => {
viewModel.IsSelectingPrinter = true;
});
try {
DiscoveredPrinter selectedPrinter = (DiscoveredPrinter)PrinterList.SelectedItem;
Connection connection = null;
try {
await Task.Factory.StartNew(() => {
connection = ConnectionCreator.Create(selectedPrinter);
connection.Open();
});
} catch (Exception e) {
await AlertCreator.ShowErrorAsync(this, e.Message);
return;
} finally {
await Task.Factory.StartNew(() => {
try {
connection?.Close();
} catch (ConnectionException) { }
});
}
await Task.Factory.StartNew(() => {
mainPage.ViewModel.SelectedPrinter = selectedPrinter;
});
mainPage.RefreshFormatLists();
await Navigation.PopAsync();
} finally {
await Task.Factory.StartNew(() => {
viewModel.IsSelectingPrinter = false;
});
}
}
}
private void DiscoveredPrintersListView_ItemSelected(object sender, SelectedItemChangedEventArgs e)
{
DiscoveredPrinterEditor.Text = "";
var selectedItem = DiscoveredPrintersListView.SelectedItem;
if (selectedItem != null)
{
DiscoveredPrinter discoveredPrinter = (DiscoveredPrinter)selectedItem;
Dictionary <string, string> settings = discoveredPrinter.DiscoveryDataMap;
StringBuilder sb = new StringBuilder();
foreach (string key in settings.Keys)
{
sb.AppendLine($"{key}: {settings[key]}");
}
DiscoveredPrinterEditor.Text = sb.ToString();
}
}
public static DiscoveredPrinter GetUSBPrinter()
{
DiscoveredPrinter discoveredPrinter = null;
try
{
foreach (var usbPrinter in UsbDiscoverer.GetZebraUsbPrinters())
{
discoveredPrinter = usbPrinter;
Console.WriteLine(usbPrinter);
}
}
catch (ConnectionException e)
{
Console.WriteLine($"Error discovering local printers: {e.Message}");
}
Console.WriteLine("Done discovering local printers.");
return(discoveredPrinter);
}
private void ConnectButton_Click(object sender, RoutedEventArgs e)
{
DiscoveredPrinter printer = viewModel.SelectedPrinter;
string address = printer.Address;
IndeterminateProgressDialog indeterminateProgressDialog = new IndeterminateProgressDialog($"Connecting to {address}...");
Task.Run(() => {
Application.Current.Dispatcher.Invoke(() => {
indeterminateProgressDialog.ShowDialog();
});
});
Task.Run(() => {
Connection connection = null;
ZebraCardPrinter zebraCardPrinter = null;
try {
connection = printer.GetConnection();
connection.Open();
zebraCardPrinter = ZebraCardPrinterFactory.GetInstance(connection);
printerManager.Printer = printer;
Application.Current.Dispatcher.Invoke(() => {
Close();
});
} catch (Exception exception) {
Application.Current.Dispatcher.Invoke(() => {
MessageBoxHelper.ShowError($"Error connecting to printer {address}: {exception.Message}");
});
} finally {
ConnectionHelper.CleanUpQuietly(zebraCardPrinter, connection);
Application.Current.Dispatcher.Invoke(() => {
indeterminateProgressDialog.Close();
});
}
});
}
public static DiscoveredPrinter GetNetworkPrinter()
{
DiscoveredPrinter discoveredPrinter = null;
var networkHandler = new NetworkDiscoveryHandler();
try
{
//foreach (var usbPrinter in NetworkDiscoverer.FindPrinters(networkHandler))
//{
// discoveredPrinter = usbPrinter;
// Console.WriteLine(usbPrinter);
//}
//discoveredPrinter = NetworkDiscoverer.FindPrinters(networkHandler);
}
catch (ConnectionException e)
{
Console.WriteLine($"Error discovering local printers: {e.Message}");
}
Console.WriteLine("Done discovering local printers.");
return(discoveredPrinter);
}
private void DiscoveredPrintersList_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ListBox discoveredPrintersList = sender as ListBox;
viewModel.DiscoveredPrinterInfo = "";
var selectedItem = discoveredPrintersList.SelectedItem;
if (selectedItem != null)
{
DiscoveredPrinter printer = (DiscoveredPrinter)selectedItem;
Dictionary <string, string> settings = printer.DiscoveryDataMap;
StringBuilder sb = new StringBuilder();
foreach (string key in settings.Keys)
{
sb.AppendLine($"{key}: {settings[key]}");
}
viewModel.DiscoveredPrinterInfo = sb.ToString();
}
}
public static ZebraPrinter Connect(DiscoveredPrinter discoveredPrinter, PrinterLanguage language)
{
ZebraPrinter printer = null;
try
{
Connection connection = discoveredPrinter.GetConnection();
printer = ZebraPrinterFactory.GetInstance(language, connection);
printer.Connection.Open();
if (printer.Connection.Connected)
{
Console.WriteLine($"Printer Connected");
}
else
{
Console.WriteLine($"Printer Not Connected!");
}
}
catch (ConnectionException e)
{
Console.WriteLine($"Error connecting to printer: {e.Message}");
}
return(printer);
}
private void LogDiscoveryPrinters(DiscoveredPrinter[] printers)
{
Logger.Write("Found " + printers.Length.ToString() + " printers");
foreach (DiscoveredPrinter printer in printers)
{
Logger.Write("\t- " + printer.Address);
}
}
public bool IsUsbDriverPrinter(DiscoveredPrinter printer)
{
return(false); // No implementation for USB driver printers in iOS portion of Xamarin SDK
}
public bool IsBluetoothPrinter(DiscoveredPrinter printer)
{
return(printer is DiscoveredPrinterBluetooth);
}
public bool IsUsbDirectPrinter(DiscoveredPrinter printer)
{
return(printer is DiscoveredPrinterUsb);
}
public MainPage()
{
InitializeComponent();
BindingContext = ViewModel;
if (Device.RuntimePlatform != Device.WPF || !DependencyService.Get <IPlatformHelper>().IsWindows10())
{
ToolbarItems.Remove(BluetoothHelpButton); // Bluetooth help dialog is specific to Windows 10
}
try {
if (DependencyService.Get <INfcManager>().IsNfcAvailable())
{
DependencyService.Get <INfcManager>().TagScanned += async(object sender, string nfcData) => {
Device.BeginInvokeOnMainThread(async() => {
await Navigation.PopToRootAsync(); // Must call Navigation.PopToRootAsync() on UI thread on Windows tablets
});
await Task.Factory.StartNew(() => {
ViewModel.IsSelectingNfcPrinter = true;
ViewModel.SelectedPrinter = null;
try {
ViewModel.StoredFormatList.Clear();
} catch (NotImplementedException) {
ViewModel.StoredFormatList.Clear(); // Workaround for Xamarin.Forms.Platform.WPF issue: https://github.com/xamarin/Xamarin.Forms/issues/3648
}
try {
ViewModel.PrinterFormatList.Clear();
} catch (NotImplementedException) {
ViewModel.PrinterFormatList.Clear(); // Workaround for Xamarin.Forms.Platform.WPF issue: https://github.com/xamarin/Xamarin.Forms/issues/3648
}
});
Connection connection = null;
DiscoveredPrinter printer = null;
bool success = false;
try {
await Task.Factory.StartNew(() => {
printer = NfcDiscoverer.DiscoverPrinter(nfcData);
connection = printer.GetConnection();
try {
connection.Open(); // Test connection
} catch (Exception e) {
throw new ConnectionException("Could not open connection. Please check your printer and device settings and try again.", e);
}
success = true;
});
} catch (Exception e) {
await AlertCreator.ShowErrorAsync(this, e.Message);
} finally {
await Task.Factory.StartNew(() => {
try {
connection?.Close();
} catch (Exception) { }
if (success)
{
ViewModel.SelectedPrinter = printer;
ViewModel.IsSelectingNfcPrinter = false;
RefreshFormatLists();
}
else
{
ViewModel.IsSelectingNfcPrinter = false;
}
});
}
};
}
} catch (TypeLoadException) { } // NFC is not supported on Windows 7
InitializeStoredFormats();
}
