====== Objetos Complementarios ======
\\
/*
|< 65% - >|
^Elemento           ^Descripción ^
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:a.-vbscript:start| Modelo de Objetos en VBScript. ]]| Modelo de Objetos en **VBScript**. |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-javascript:start| Modelo de Objetos en JavaScript. ]]| Modelo de Objetos en **[[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:JavaScript]] **. |
*/

/*
{{indexmenu>:wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#}}
*/
\\

|< 65% - >|
^  Objetos                                                                                                                                                                                                                                                                       ||
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#amazonappstore|AmazonAppStore]]            | Sirve para hacer compras en el Amazon App Store. <wrap hi>Sólo disponible en dispositivos de Amazon</wrap>.                                |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#androidintent|AndroidIntent]]              | Exclusivo para Android. Sirve para instanciar otras aplicaciones o componentes del sistema.                                                |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#animation|Animation]]                      | Para hacer animaciones personalizadas a un control.                                                                                        |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#bluetoothserialport|BluetoothSerialPort]]  | Para conectarse por puerto serie a un dispositivo bluetooth.                                                                               |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#deviceinfo|Device Info]]                   | Retorna información actual del dispositivo.                                                                                                |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#DOMParser|DOMParser]]                      | Analiza gramaticalmente código XML o HTML almacenado en una cadena de texto y convertirlo en un Documento DOM.                             |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#gpstools|GPSTool]]                         | Objeto para controlar el GPS                                                                                                               |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#imagedrawing|ImageDrawing]]                | Objeto para editar de forma básica imágenes, añadiendole texto, imagenes y colores. Obtiene también metadatos e información de la imagen.  |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#iniparser|IniParser]]                      | Objeto para parsear ficheros ini y sacar valores o editarlos.                                                                              |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#pushmessage|PushMessage]]                  | Objeto para enviar mensajes push. Sólo para dispositivos Google.                                                                           |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#packagemanager|PackageManager]]            | Permite acceder a la información de las aplicaciones instaladas en el dispositivo.                                                         |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#sqlmanager|SqlManager]]                    | Control de SQL para gestionarlos a traves de script                                                                                        |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#debug_tools|DebugTools]]                   | Objeto para enviar información de depuración a un servidor remoto.                                                                         |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#filemanager|FileManager]]                  | Este objeto de script, disponible en Android e iOS, encapsula algunas funciones sencillas de manejo y descarga de ficheros.                |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#wifimanager|WifiManager]]                  | Permite obtener datos de la wifi, como manejar el estado de la misma.                                                                      |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#xonenfc|XOneNFC]]                          | Objeto para manejar los eventos de lectura y escritura NFC.                                                                                |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#pinpadpayment|PinPadPayment]]              | Objeto para comunicarse con hardware pasarela de pago con tarjeta. Se soportan varios pinpad de Itos e Ingenico.                           |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#xoneocr|XOneOCR]]                          | Objeto para reconocimiento de matrículas y texto genérico.                                                                                 |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#wificonfiguration|WiFiConfiguration]]      | Establece un objeto wifi, para poder usarlo en el objeto wifiManager.                                                                      |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#xoneprinter|XOnePrinter]]                  | Objeto para controlar hardware de impresora.                                                                                               |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#manejo_de_errores|Manejo de Errores]]      | El manejo de errores se realiza a través del objeto appData.Error                                                                          |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#barcode_generator|BarCodeGenerator]]       | Sirve para generar códigos de barra de varios tipos.                                                                                       |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#code_scanner|CodeScanner]]                 | Lector de código de barras. Objeto reservado del framework.                                                                                |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#start_scanner|StartScanner]]               | Método de UI que lanza el escáner en dispositivos que dispongan de él.                                                                     |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#xonepdf|XOnePDF]]                          | Objeto para crear documentos PDF desde el dispositivo                                                                                      |

\\
\\
|< 65% - >|
^  Singletons de Script sin %%CreateObject%%                                                                                                                                                                         ||
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#http|Http]]                              | Sirve para hacer llamadas http post y get a servicios web y retornar resultado.  |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#systemsettings|SystemSettings]]          | Devuelve distintos tipos de información del sistema.                             |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#payment|Payment]]                        | Para pagos con el Play Store.                                                    |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#fingerprintmanager|FingerPrintManager]]  | Manejador de Huella Dactilar.                                                    |
\\
\\

|< 65% - >|
^  Otros Objetos                                                                                                                                                                                                                                                  ||
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_BluetoothDeviceScript|Objeto BluetoothDeviceScript]]                      | Es el resultado de BluetoothSerialPort.getDiscoverableDevices()                       |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_FingerprintAuthenticationResult|Objeto FingerprintAuthenticationResult]]  | Es el objeto devuelto en el callback de la huella dactilar.                           |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_ImageInfo|Objeto ImageInfo]]                                              | Es el objeto resultado de ImageDrawing.getImageInfo()                                 |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_LiveSecureProvisioningResponse|Objeto LiveSecureProvisioningResponse]]    | Es el objeto devuelto en el callback del provisionamiento seguro                      |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_XoneXmlObjectWrapper|Objeto XoneXmlObjectWrapper]]                        | Es el objeto cursor resultado de las querys que tiran algunos métodos de SqlManager.  |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_XOneWifiInfo|Objeto XOneWifiInfo]]                                        | Objeto resultado de buscar redes wifi con WifiManager.                                |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_XoneDataObject|Objeto XoneDataObject]]                                    |                                                                                       |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_XoneDataCollection|Objeto XoneDataCollection]]                            |                                                                                       |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_XoneXmlNodeListWrapper|Objeto XoneXmlNodeListWrapper]]                    | Resultado de XoneDataCollection.getXmlNode()                                          |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_DnieReadResult|Objeto DnieReadResult]]                                    | Resultado del callback de leer un DNIe con XOneNFC.                                   |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_PrinterInfo|Objeto PrinterInfo]]                                          | Resultado de XOnePrinter.getStoredPrinterInfo()                                       |
| [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_ptvview|Mapas PTV]]                                                       | Para gestionar el Mapa externo de PTV                                                 |

/*
|[[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#objeto_printerinfo|“appData.error”]]||
*/


\\
\\
=====AmazonAppStore=====
\\
Sirve para hacer compras en el Amazon App Store. Sólo disponible en dispositivos de Amazon.
\\
|< 65% 30% - >|
^ Métodos ^ Descripción  ^
| **getUserData**                         | Retorna un objeto con información del usuario                        |
| **isAmazonAppStoreInstalled**           | Pregunta si la tienda de apps está instalada                         |
| **isSandboxMode**                       | Retorna si se está ejecutando en modo demo o no                      |
| **purchase**                            | Solicita la compra de un producto virtual. Parámetros: sProductSKU   |
| **requestAmazonAppStoreInstallation**   | Solicita la descarga e instalación de la tienda de apps de Amazon    |
| **validateSkus**                        | Retorna si un SKU de producto es válido                              |
\\ 

=====AndroidIntent=====
\\
Sirve para enviar intents de Android a otras aplicaciones o componentes del sistema. Su propósito variará según la implementación que se esté haciendo.\\
\\
|< 70% 20% - >|
^ Métodos ^ Descripción  ^
| **addCategory**                 | Añade una categoría para filtrar las aplicaciones que recibirán el intent                                                                                   |
| **addFlag**                     | Añade banderas extra al intent para modificar su comportamiento                                                                                             |
| **getLaunchIntentForPackage**   | Retorna un intent para lanzar la aplicación que se le pase por parámetro, su nombre de paquete. Equivale a pulsar su icono en el launcher de aplicaciones   |
| **getMyPackageName**            | Retorna el nombre de paquete de la aplicación que se está ejecutando. Generalmente es "com.xone.android.framework"                                          |
| **putBooleanExtra**             | Añade un booleano a los parámetros del intent                                                                                                               |
| **putDoubleExtra**              | Añade un double a los parámetros del intent                                                                                                                 |
| **putFloatExtra**               | Añade un float a los parámetros del intent                                                                                                                  |
| **putIntegerExtra**             | Añade un integer a los parámetros del intent                                                                                                                |
| **putStringExtra**              | Añade un string a los parámetros del intent                                                                                                                 |
| **sendBroadcast**               | Envía un intent broadcast                                                                                                                                   |
| **sendOrderedBroadcast**        | Envía un intent broadcast respetando el orden y dandole permiso para consumirlo                                                                             |
| **setAction**                   | Define la acción y el tipo de intent a realizar.                                                                                                            |
| **setClassName**                | Define la clase objetivo que recibirá el intent                                                                                                             |
| **setData**                     | Define los datos que se pasaran por el intent.                                                                                                              |
| **setDataAndType**              | Define los datos y el tipo de datos que se pasaran por el intent.                                                                                           |
| **setPackage**                  | Define la aplicación objetivo que recibirá el intent, con el nombre del paquete                                                                             |
| **setType**                     | Define un MIME type explícito para filtrar las aplicaciones que recibirán el intent                                                                         |
| **startActivity**               | Inicia la actividad.                                                                                                                                        |
| **startActivityForResult**      | Inicia la actividad y se queda esperando por un resultado, cuando lo recibe llama a la función que se le defina.                                            |
| **startService**                | Inicia el servicio.                                                                                                                                         |
| **stopService**                 | Detiene el servicio.                                                                                                                                        |

=== Ejemplo 1 - Lanzar la aplicación de youtube ===
<code javascript>
if (appData.getGlobalMacro("##DEVICE_OS##") != "android") {
	throw "Los intents sólo están disponibles en Android";
}
var intent = createObject("AndroidIntent");
intent.setAction("android.content.Intent", "ACTION_VIEW");
intent.setData("https://www.youtube.com/watch?v=SsYrJXy1c6M");
intent.startActivity();
</code>
\\

=== Ejemplo 2 - Lanzar aplicación de Facebook ===
<code javascript>
if (appData.getGlobalMacro("##DEVICE_OS##") != "android") {
	throw "Los intents sólo están disponibles en Android";
}

//  ¿Está instalada la aplicación del Facebook?

if (ui.isApplicationInstalled("com.facebook.katana") == 0) {
        /* 
         * Sí lo está. Usamos los intents de Android para lanzar una página
         * con la aplicación nativa.
         */
	var intent = createObject("AndroidIntent");
	if (intent == undefined) {
		throw "El objeto AndroidIntent no existe";
	} else {
		intent.setAction("android.content.Intent", "ACTION_VIEW");
		intent.setData("fb://page/994713583879307");
		intent.startActivity();
	}
} else {
	//No está instalada. Usamos el navegador.
	ui.openUrl("https://www.facebook.com/TheBestCatPage/");
}

</code>
\\

=== Ejemplo 3 - Lanzar una aplicación. ===
<code javascript>
var intent = createObject("AndroidIntent");
intent.getLaunchIntentForPackage("com.mcdonalds.android ");
intent.startActivity();
</code>
\\

=== Ejemplo 4 - Lanzar GPS. ===
<code javascript>
if  (appData.getGlobalMacro("##DEVICE_OS##") == "android") {
	var sw = ui.isApplicationInstalled("com.google.android.apps.maps");
	if (sw == 0) {
		var intent = createObject("AndroidIntent");
		intent.setPackage("com.google.android.apps.maps");
		intent.setAction("android.content.Intent", "ACTION_VIEW");
		intent.setData("geo:0,0?q=34.99,-106.61(Aquí está el POI)");
		intent.startActivity();
	} else {
		throw "Error, Google Maps no está instalado.";
	}
}
</code>
\\


=====Animation=====
\\
Sirve para hacer animaciones personalizadas a un control. \\ 

|< 90% 15% - >|
^  Métodos  ^ Definición ^
|**cancel**| Cancela la animación en curso.|
|**getDuration**| Obtiene la duración de la animaciones que se va a realizar.|
|**setAlpha**| Animación que modifica el alpha del control, se le pasa como parámetro el nivel de alpha que se le quiere dar al nodo, siendo 0 para ocultar completamente el nodo y 1 para hacerlo visible al 100%.|
|**setBackgroundColor**| <WRAP>
Define el nuevo <nowiki>BgColor</nowiki> que tendrá el control.
{| class="wikitable" style="width: 50%; align:center;"
|-
! scope="col" style="width:50%; | Parámetros 
! scope="col" style="width:50%; | Definición 
|-
|**fromColor** || Color del que parte para hacer la transición entre colores.
|-
|**toColor** || Color final de la transición de colores.
|-
|}
</WRAP>|
|**setDuration**| Define la duración de la animaciones que se va a realizar, se le pasa como parámetro el tiempo en milisegundos.|
|**setEndCallback**| Se define la función a la que llamará cuando la animación termine.  |
|**setHeight**| Define el nuevo height que tendrá el control.|
|**setInterpolation**| <WRAP>
Define la velocidad de cambio de una animación, esto permite  acelerar, desacelerar, repetir los efectos básicos de la animación.\\ 
(solo se aplica a las siguientes animaciones: **setWidth**, **setHeight**, **setBgcolor**).
{| class="wikitable" style="width: 50%; align:center;"
|-
! scope="col" style="width:50%; | Parámetros 
! scope="col" style="width:50%; | Definición 
|-
|**<nowiki>AccelerateDecelerateInterpolator</nowiki>** || La tasa de cambio comienza y termina lentamente, pero se acelera en medio.
|-
|**<nowiki>AccelerateInterpolator</nowiki>** || La tasa de cambio comienza lentamente y luego se acelera.
|-
|**<nowiki>AnticipateInterpolator</nowiki>** || El cambio comienza hacia atrás y  luego se desplaza hacia adelante.
|-
|**<nowiki>AnticipateOvershootInterpolator</nowiki>** || El cambio comienza hacia atrás, luego se desplaza hacia adelante y sobrepasa el valor objetivo y finalmente regresa al valor final.
|-
|**<nowiki>BaseInterpolator</nowiki>** ||           
|-
|**<nowiki>BounceInterpolator</nowiki>** || Rebota al final.   
|-
|**<nowiki>CycleInterpolator</nowiki>** || Repite la animación una serie de ciclos, en este caso 2 veces.  
|-
|**<nowiki>DecelerateInterpolator</nowiki>** || Comienza rápidamente y después se desacelera. 
|-
|**<nowiki>FastOutLinearInInterpolator</nowiki>** || Acelera rápido y sigue acelerando hasta el final. 
|-
|**<nowiki>FastOutSlowInInterpolator</nowiki>** || Acelera rápido y desacelera lentamente.
|-
|**<nowiki>LinearInterpolator</nowiki>**   || El cambio es constante. 
|-
|**<nowiki>LinearOutSlowInInterpolator</nowiki>** || Empieza con un cambio constantes y después desacelera. 
|-
|**<nowiki>OvershootInterpolator</nowiki>** || El cambio sobrepasa el valor objetivo y finalmente regresa al valor final.
|-
|}
</WRAP>|
|**setRelativeRotation**| Define los grados que quiere que se gire el nodo, la diferencia con el  setRotation, es que los grados se van sumando a los que ya tenga el control.|
|**setRelativeX**| Define la posición en el eje X a la que se quiere mover el nodo, la diferencia con setX,  es que el valor se va sumando a la posición en el eje X que ya tenga el nodo.|
|**setRelativeY**| Define la posición en el eje Y a la que se quiere mover el nodo, la diferencia con setY,  es que el valor se va sumando a la posición en el eje Y que ya tenga el nodo.|
|**setRelativeZ**| Define la posición en el eje Z a la que se quiere mover el nodo, la diferencia con setZ,  es que el valor se va sumando a la posición en el eje Z que ya tenga el nodo.|
|**setRotation**| Define los grados que quiere que se gire el nodo.   |
|**setRelativeScaleX**| Define la escala en el eje X que se le quiere dar al nodo, la diferencia con <nowiki>SetScaleX</nowiki>,  es que el valor se va sumando a la que ya tenga en el eje X que ya tenga el nodo.|
|**setRelativeScaleY**| Define la escala en el eje Y que se le quiere dar al nodo, la diferencia con <nowiki>SetScaleY</nowiki>,  es que el valor se va sumando a la que ya tenga en el eje Y que ya tenga el nodo.|
|**setRevealCircular** | <WRAP>
Revela el control con un efecto circular.
{| class="wikitable" style="width: 50%; align:center;"
|-
! scope="col" style="width:50%; | Parámetros 
! scope="col" style="width:50%; | Definición 
|-
| **reveal**   || esto define si se quiere que el efecto sea para revelar o para ocultar.      
|-
| **X**        || coordenada x donde empezara el circulo, siempre dentro de los límites del control. 
|-
| **Y**        || coordenada y donde empezara el circulo, siempre dentro de los límites del control.
|}
</WRAP>|
|**<nowiki>SetScaleX</nowiki>**| Define la escala en el eje X que se le quiere dar al nodo.|
|**<nowiki>SetScaleY</nowiki>**| Define la escala en el eje X que se le quiere dar al nodo.|
|**setStartCallback**| Se define la función a la que llamara cuando la animación empiece.  |
|**setTarget**| Define el nodo al que se le va a aplicar las animaciones, se le pasa como parámetro el nombre del nodo afectado.|
|**setWidth**| Define el nuevo width que tendrá el control. |
|**setX**| Define la posición en el eje X a la que se quiere mover el nodo.   |
|**setY**| Define la posición en el eje Y a la que se quiere mover el nodo.   |
|**setZ**| Define la posición en el eje Z a la que se quiere mover el nodo.  |
\\

<code javascript>
// Así creamos un objeto de animación

var anim = createObject("Animation");

// Así cogemos el objeto propiedad, para poder asignárselo con el setTarget

var window = ui.getView(self);
var property = window[“NOMBRE_DEL_PROP”];
</code>

=== Ejemplo de setAlpha === 
<code javascript>
var window = ui.getView(self);
var property = window[sProp];
var anim = createObject("Animation");
anim.setTarget(property); 
anim.setDuration(3000);   
anim.setAlpha(0);
ui.sleep(4);
anim.setAlpha(1);
anim.setEndCallback(function() {
	anim.setDuration(nOldDuration);
});
</code>
=== Ejemplo de setX y setY ===
<code javascript>
var window = ui.getView(self);
var property = window[sProp];
createObject("Animation").setTarget(property).setX(500).setY(400);
</code>

=== Ejemplo de setRelativeX y setRelativeY ===
<code javascript>
var window = ui.getView(self);
var property = window[sProp];
createObject("Animation").setTarget(property).setRelativeX(0).setRelativeY(50);
</code>
\\
===== BluetoothSerialPort =====

\\
Este es el método antiguo, para referencia al método para control del bluetooth del móvil implementado por XOne, ir a:[[wiki:2.-desarrollo-app:2.5.-controles-by-xone:start#|Controles by XOne]]
\\
Sirve para conectarse por puerto serie a un dispositivo bluetooth. Este objeto es de bajo nivel y el programador debe implementar su propio protocolo sobre éste para comunicarse con el dispositivo.\\
\\
|< 70% 20% - >|
^  Método                              ^  Descripción                                                                                                                    ^
| **connect**                          | Conecta a la dirección MAC especificada por parámetro, o a la guardada por %%BluetoothSerialPort%%.selectBluetoothDevice        |
| **disconnect**                       | Desconecta el socket bluetooth limpiamente                                                                                      |
| **getDiscoverableBluetoothDevices**  | Es el resultado de %%BluetoothSerialPort%%.getDiscoverableDevices                                                               |
| **read**                             | Lee X bytes del socket bluetooth. Devuelve el resultado convertido a cadena                                                     |
| **selectBluetoothDevice**            | Muestra una pantalla para seleccionar el dispositivo bluetooth                                                                  |
| **setTimeout**                       | Define un timeout para las operaciones de lectura/escritura                                                                     |
| **sleep**                            | Duerme durante X milisegundos                                                                                                   |
| **write**                            | Escribe una cadena en el socket bluetooth                                                                                       |
| **setMacAddress**                    | Devuelve MAC del dispositivo a conectar                                                                                         |
| **isDevicePaired**                   | Comprueba si un dispositivo está emparejado con el dispositivo (por medio de la MAC recibida a través de serial.setMacAddress)  |
| **pairDevice**                       | Para emparejar los dispositivos                                                                                                 |

==== Funcionalidades implementadas para Control de Bluetooth del móvil ====

|< 70% 20% - >|
^  Funcionalidades Implementadas                                 ^  Descripción                                                                                                                                                    ^
| **Buscar Dispositivos**                                        | Busca los dispositivos disponibles para conectar.                                                                                                               |
| **Seleccionar Dispositivo**                                    | Permite seleccionar dispositivo para conectar, devuelto por bluetoothSerial.getDiscoverableBluetoothDevices() y mostrado en lista de dispositivos disponibles.  |
| **Conectar y escribir en puerto serie.**                       | Permite escribir en puerto serie del dispositivo previamente conectado.                                                                                         |
| **Conectar y leer en puerto serie.**                           | Permite leer en puerto serie del dispositivo previamente conectado.                                                                                             |
| **Conectar y leer en puerto serie. Recordar dispositivo**      | Conecta sin parámetros, permite leer  y recordará el último dispositivo que se seleccionó.                                                                      |
| **Conectar y escribir en puerto serie. Recordar dispositivo**  | Conecta sin parámetros, permite escribir  y recordará el último dispositivo que se seleccionó.                                                                  |
| **Conectar Chat**                                              | Permite conexión simulando Chat entre dispositivos conectado por bluetooth                                                                                      |
| **Desconectar Chat**                                           | Cierra Chat previamente inicializado por bluetooth.                                                                                                             |
| **Enviar texto**                                               | Envía diálogo, cadena de texto entre dispositivos conectados por el bluetooth simulando Chat                                                                    |
\\

**Ejemplos de funciones y uso:**

<code javascript>

function buscarDispositivos() {
	ui.showWaitDialog();
	try {
		let lstDevices = bluetoothSerial.getDiscoverableBluetoothDevices();
		if (lstDevices === null) {
			ui.showToast("No se encontraron dispositivos Bluetooth visibles");
		} else {
			let sMessage = "";
			for (let i = 0; i < lstDevices.length;i++) {
				let bluetoothDevice = lstDevices[i];
				if (i !== 0) {
				    sMessage = sMessage + "\n";
				}
				sMessage = sMessage + bluetoothDevice.getDeviceName() + " " + bluetoothDevice.getMacAddress() + " " + bluetoothDevice.getRssi() + "dBm";
			}
			ui.msgBox(sMessage, "Mensaje", 0);
		}
	} finally {
		ui.hideWaitDialog();
	}
}

function seleccionarDispositivo() {
	ui.showWaitDialog();
	try {
		bluetoothSerial.selectBluetoothDevice();
	} finally {
		ui.hideWaitDialog();
	}
}

function escribirPuertoSerie() {
	ui.showWaitDialog();
	try {
		let bluetoothDevice = null;
		let lstDevices = bluetoothSerial.getDiscoverableBluetoothDevices();
		if (lstDevices === null) {
			ui.showToast("No se encontraron dispositivos Bluetooth visibles");
		} else {
			for (let i = 0; i < lstDevices.length;i++) {
				bluetoothDevice = lstDevices[i];
				if (bluetoothDevice.getDeviceName() == "zebramz") {
					break;
				} else {
					bluetoothDevice = null;
				}
			}
		}
		if (bluetoothDevice === null) {
			throw "No se encontró el dispositivo zebra";
		}
		bluetoothSerial.connect(bluetoothDevice.getMacAddress());
		bluetoothSerial.write("hola que tal");
		bluetoothSerial.disconnect();
	} finally {
		ui.hideWaitDialog();
	}
}

function leerPuertoSerie() {
	ui.showWaitDialog();
	try {
		let bluetoothDevice = null;
		let lstDevices = bluetoothSerial.getDiscoverableBluetoothDevices();
		if (lstDevices === null) {
			ui.showToast("No se encontraron dispositivos Bluetooth visibles");
		} else {
			for (let i = 0; i < lstDevices.length;i++) {
				bluetoothDevice = lstDevices[i];
				if (bluetoothDevice) {
					if (bluetoothDevice.getDeviceName() == "zebramz") {
						break;
					} else {
						bluetoothDevice = null;
					}
				}
			}
		}
		if (bluetoothDevice === null) {
			throw "No se encontró el dispositivo zebra";
		}
		bluetoothSerial.connect(bluetoothDevice.getMacAddress());
		bluetoothSerial.write("! U1 getvar \"appl.date\"\r\n");
		bluetoothSerial.sleep("300");
		let buffer = bluetoothSerial.read(10);
		bluetoothSerial.disconnect();
		ui.showToast("El buffer vale: " + buffer);
	} finally {
		ui.hideWaitDialog();
	}
}

function leerPuertoSerieRecordarDispositivo() {
	ui.showWaitDialog();
	try {
		//Connect sin parámetros recordará el último dispositivo que se seleccionó
		bluetoothSerial.connect();
		bluetoothSerial.write("! U1 getvar \"appl.date\"\r\n");
		bluetoothSerial.sleep("300");
		let buffer = bluetoothSerial.read(10);
		bluetoothSerial.disconnect();
		ui.showToast("El buffer vale: " + buffer);
	} finally {
		ui.hideWaitDialog();
	}
}

function escribirPuertoSerieRecordarDispositivo() {
	ui.showWaitDialog();
	try {
		//Connect sin parámetros recordará el último dispositivo que se seleccionó
		bluetoothSerial.connect();
		bluetoothSerial.write("hola que tal");
		bluetoothSerial.sleep("3000");
		bluetoothSerial.disconnect();
	} finally {
		ui.hideWaitDialog();
	}
}

function connectChat() {
    ui.showWaitDialog("Conectando...");
    try {
        bluetoothSerial.setTimeout(10000);
    	bluetoothSerial.connect();
    	ui.showSnackbar("Conectado");
    } finally {
		ui.hideWaitDialog();
	}
}

function disconnectChat() {
    ui.showWaitDialog("Desconectando...");
    try {
    	bluetoothSerial.disconnect();
    	ui.showSnackbar("Desconectado");
    } finally {
		ui.hideWaitDialog();
	}
}

function sendChat() {
    if (!self.MAP_TEXTO) {
        return;
    }
    ui.showWaitDialog("Enviando...");
    try {
        bluetoothSerial.write(self.MAP_TEXTO);
        let sResponse = bluetoothSerial.read();
        if (!sResponse) {
            throw "No hubo respuesta";
        }
        self.MAP_CHAT = self.MAP_CHAT + "\n" + sResponse;
        ui.refreshValue("MAP_CHAT");
    } finally {
		ui.hideWaitDialog();
	}
}

 var serial = new BluetoothSerialPort();
                    //Le paso la MAC para luego preguntar si está emparejado
                    serial.setMacAddress(self.MAP_MACADRESS);
                    //Pregunta si el dispositivo está emparejado
                    if (!serial.isDevicePaired())
                    {
                        //Si no está emparejado lo enlazamos y el S.O pedirá el pin tanto en impresora como en dispositivo
                        serial.pairDevice();
                    }
</code>

Otras referencias:[[wiki:2.-desarrollo-app:2.5.-controles-by-xone:#start:Método para Control de Bluetooth del móvil|Bluetooth]]

=====DeviceInfo=====
\\
Retorna información actual del dispositivo.\\
\\
\\
|< 70% 20% - >|
^  Método                            ^  Descripción                                                       ^
| **getBatteryLevel**                | Obtiene el nivel de batería.                                       |
| **getBatteryLevelPercentage**      | Obtiene el nivel de porcentaje de la batería.                      |
| **getBatteryMaxLevel**             | Obtiene el máximo nivel de batería.                                |
| **getBatteryTemperature**          | Obtiene la temperatura de la batería.                              |
| **getBatteryVoltage**              | Obtiene el voltaje de la batería.                                  |
| **getRxBytes**                     | Obtiene los bytes de Rx.                                           |
| **getThisApplicationTxBytes**      | Obtiene los bytes de Tx de esta aplicación.                        |
| **getThisApplicationRxBytes**      | Obtiene los bytes de Rx de esta aplicación.                        |
| **getTxBytes**                     | Obtiene los bytes de texto.                                        |
| **getMobileNetworkSignalStrengh**  | Obtiene nivel de señal móvil disponible para conectar. Valor devuelto en decibelios por milivatio.|
| **getConnectedMobileNetworkType**  | Devuelve tipo de red móvil a la que está conectado el dispositivo.Valores posibles: gsm, lte, wcdma, cdma, unknown.|
\\
Ejemplos:
\\
<code javascript>
  function getMobileNetworkSignalStrength() {
    ui.showToast("Señal red móvil: " + deviceInfo.getMobileNetworkSignalStrength() + " dBm");
} 
/**

  * Valor devuelto en decibelios por milivatio

 */
</code>
\\
<code javascript>
function getConnectedMobileNetworkType() {
    ui.showToast("Tipo de red móvil: " + deviceInfo.getConnectedMobileNetworkType());
}
/**

  * Valores posibles: gsm, lte, wcdma, cdma, unknown

 */
</code>
=====GPSTools=====
\\
Varias cosas para controlar el GPS.\\
\\
|< 70% 20% - >|
^            Método            ^             Descripción             ^
| **<nowiki>DistanceBetweenCoordinates</nowiki>**   | Mide la distancia entre coordenadas.   |
| **startGPS**                                      | Inicia el GPS.                         |
| **stopGPS**                                       | Detiene el GPS                         |
\\
\\
===Métodos para obtener datos de la última coordenada===
\\
Son métodos asociados al control del GPS pero son llamados por el U.I.
\\
|< 70% 20% - >|
^            Método            ^             Descripción             ^
| **getLastKnownLocation**            | obtiene la última localización (Latitud, Longitud).   |
| **getLastKnownLocationAccuracy**    | obtiene la última precisión.                          |
| **getLastKnownLocationAltitude**    | obtiene la última Altitud.                            |
| **getLastKnownLocationBearing**     | obtiene el último rumbo.                              |
| **getLastKnownLocationDateTime**    | obtiene la última fecha y hora.                       |
| **getLastKnownLocationLatitude**    | obtiene la última latitud.                            |
| **getLastKnownLocationLongitude**   | obtiene la última Longitud.                           |
| **getLastKnownLocationProvider**    | obtiene el último proveedor.                          |
| **getLastKnownLocationSpeed**       | obtiene la última Velocidad.                          |

Véase también: [[wiki:2.-desarrollo-app:2.5.-controles-by-xone:gps:start|Funcionalidades Gps]], [[wiki:2.-desarrollo-app:2.5.-controles-by-xone:mapas:start|Mapas by XOne]]
=====ImageDrawing=====
\\
Objeto para editar de forma básica imágenes, añadiendole texto, imagenes y colores. Obtiene también metadatos e información de la imagen.\\
Objeto ImageDrawing\\

\\
|< 70% 20% - >|
^  Método                 ^  Descripción                                                                                                                                                             ^
| **addImageSetXY**       | Añade una imagen                                                                                                                                                         |
| **addTextSetXY**        | Añade texto a una imagen                                                                                                                                                 |
| **copyExifMetadata**    | Copia data de imagen si existe (width, height y orientación).                                                                                                            |
| **create**              | Crear Imagen                                                                                                                                                             |
| **getImageInfo**        | Es el objeto resultado de %%ImageDrawing%%.getImageInfo().                                                                                                               |
| **save**                | Guardar                                                                                                                                                                  |
| **setBackground**       | Ajusta el tipo de fondo.                                                                                                                                                 |
| **setBackgroundColor**  | Ajusta el color de fondo.                                                                                                                                                |
| **setFont**             | Ajusta el tipo de fuente .                                                                                                                                               |
| **setFontSize**         | Ajusta el tamaño de la fuente.                                                                                                                                           |
| **setFontStyle**        | Ajusta el estilo de la fuente.                                                                                                                                           |
| **setFontColor**        | Establece el color de la fuente.                                                                                                                                         |
| **rotate**              | Permite rotación de la imagen y guarda nueva imagen rotada. (rotate(sImagenOriginal[ruta fichero], sImagenDestino[ruta fichero], nRotacion[0 - 360], nCalidad[0 - 100])  |
\\
<code javascript>
<!-- Función utilizada en un proyecto donde se requiere que las imágenes tengan un tamaño predefinido 
y además se requiere que si la foto original se tomó rotada, se corrija, de forma que se utilizó el siguiente código -->

function demoImageDrawing(sPath, newName) {

    var imageDrawing = new ImageDrawing();
    var imageInfo = imageDrawing.getImageInfo(appData.getFilesPath() + "/" + sPath);
    var exifMetadata = imageInfo.getExifMetadata();

    // Rotar segun exif (http://sylvana.net/jpegcrop/exif_orientation.html)
    
	if (!exifMetadata.Orientation) {
        exifMetadata.Orientation = -1;
    }
    var sPathRotated = appData.getFilesPath() + "/" + newName;
    imageDrawing = new ImageDrawing();
    
    if (self.CODEMPRESA.toString()=="4")
    {
        imageDrawing.create(480, 640);
    }    
    else
    {
    	imageDrawing.create(768, 1024);
    }   
    
    if (exifMetadata.Orientation == 6) {
        imageDrawing.rotate(sPath, sPathRotated, 90);
        imageDrawing.setBackground(sPathRotated);
    }
    else
    {
    	imageDrawing.setBackground(appData.getFilesPath() + "/" + sPath);
    }
    imageDrawing.save(sPathRotated);
    
    var objFile = createObject("FileManager");
    objFile.delete(sPath);
    objFile=null;
}
</code>
\\

<code javascript>
function addTimestamp(sFile) {
    if (!sFile) {
        throw "Haga una foto primero";
    }
    let sPath = appData.getFilesPath() + sFile;
    let sPathEdited = appData.getFilesPath() + "edited_" + sFile;
    let imageDrawing = new ImageDrawing();
    let imageInfo = imageDrawing.getImageInfo(sPath);
    imageDrawing.create(imageInfo.getWidth(), imageInfo.getHeight());
    imageDrawing.setBackground(sPath);
    imageDrawing.setFontSize(64);
    imageDrawing.setFontColor("#FF0000");
    imageDrawing.addTextSetXY(new Date().toString(), 100, 200, 0);
    imageDrawing.save(sPathEdited);
    ui.openFile(sPathEdited);
}
 </code>
\\
<code javascript>
 // Rotar segun exif (http://sylvana.net/jpegcrop/exif_orientation.html)
    let sPathRotated = appData.getFilesPath() + "/rotated.jpg";
    if (exifMetadata.Orientation == 6) {
        let jsRotateParams = {
            source       : sPath,
            target       : sPathRotated,
            degrees      : 90,
            targetQuality: 100
        };
        imageDrawing.rotate(jsRotateParams);
        // Mostrar width y height de la rotada
        imageInfo = imageDrawing.getImageInfo(sPathRotated);
        exifMetadata = imageInfo.getExifMetadata();
        if (!exifMetadata.Orientation) {
            exifMetadata.Orientation = -1;
        }
        ui.msgBox("Rotación de imagen reparada. Ancho: " + imageInfo.getWidth() + "\nAlto: " + imageInfo.getHeight() + "\nExif Orientation: " + exifMetadata.Orientation, "Mensaje", 0);
        ui.openFile(sPathRotated);
    } else {
        ui.msgBox("No está rotada. Ancho: " + imageInfo.getWidth() + "\nAlto: " + imageInfo.getHeight() + "\nExif Orientation: " + exifMetadata.Orientation, "Mensaje", 0);
        // Esto solo para que no explote el código de redimensionar
        sPathRotated = sPath;
    }
 </code>
=====IniParser=====
\\
Objeto para parsear ficheros ini y sacar valores o editarlos.\\
\\
|< 70% 20% - >|
^            Método            ^             Descripción             ^
| **getString**                 | Obtener cadena.            |
| **getValue**                  | Obtener valor.             |
| **getValueBySection**         | Obtener valor por sección. |
| **parseFromFile**             | Analizar desde archivo.    |
| **parseFromString**           | Analizar desde cadena.     |
| **save**                      | Guardar.                   |  
| **setValue**                  | Ajustar valor.             |
| **setValueBySection**         | Ajustar valor por sección. |
\\

=== Ejemplo IniParser ===

<code javascript>
function showLicenseIni() {
    let sLicenseIniPath = appData.getAppPath() + "license.ini";
    let licenseIni = new IniParser();
    licenseIni.parseFromFile(sLicenseIniPath);
    let sLicense = licenseIni.serialize();
    ui.msgBox(sLicense, "license.ini", 0);
}

 

function editLicenseIni() {
    let sLicenseIniPath = appData.getAppPath() + "license.ini";
    let licenseIni = new IniParser();
    licenseIni.parseFromFile(sLicenseIniPath);
    let sValue = licenseIni.getValue("UsePush");
    if (sValue == "true") {
        licenseIni.setValue("UsePush", false);
    }
    licenseIni.save(sLicenseIniPath);
    ui.showToast("OK!");
}
</code>
\\
\\
=====PushMessage=====
\\
Objeto para enviar mensajes push. Sólo Google.\\
\\
|< 70% 20% - >|
^            Método            ^             Descripción             ^
|**sendMessageGCM**| Enviar mensaje GCM.    |
\\
\\
===== PackageManager =====
\\
Permite acceder a la información de las aplicaciones instaladas en el dispositivo.\\
\\
|< 70% 20% - >|
^            Método            ^             Descripción             ^
| **getPackageInfo**            | <WRAP> 
Obtiene la información de una aplicación según su nombre de paquete
{| class="wikitable" style="width: 50%; align:center;"
|-
! scope="col" style="width:50%; | Parámetros
! scope="col" style="width:50%; | Definición 
|-
|**getPackageName**    || Obtiene el nombre de paquete. 
|-
|**getLabel**          || Obtiene el nombre de la aplicación. 
|-
|**getDescription**    || Obtiene la descripción de la aplicación. 
|-
|**getVersionName**    || Obtiene el nombre de la versión. 
|-
|**getVersionCode**    || Obtiene el código de versión. 
|-
|**isEnabled**         || Obtiene si la aplicación esta activa. 
|-
|**getIcon**           || Obtiene el icono de la aplicación. 
|-
|}
</WRAP> | 
| **getInstalledPackageNames**   | Obtiene una lista de nombre de paquetes de las aplicaciones instaladas en el dispositivo.  |
| **getInstalledPackages**      | Obtiene un listado las aplicaciones instaladas en el dispositivo. Devuelve un listado de <nowiki>PackageInfo</nowiki> [métodos].  |

=== Ejemplo getInstalledPackages ===
\\
<code javascript>
var installedPackages = packageManager.getInstalledPackages();
var i,packageInfo,sMessage = "";
var tot = installedPackages.length;

for ( i = 0; i < tot ; i++ ) {	    
	packageInfo = installedPackages[i];
	var sMessage = "Package name: " + packageInfo.getPackageName() + "\n";
	sMessage = sMessage + "Label: " + packageInfo.getLabel() + "\n";
	sMessage = sMessage + "Description: " + packageInfo.getDescription() + "\n";
	sMessage = sMessage + "Version name: " + packageInfo.getVersionName() + "\n";
	sMessage = sMessage + "Version code: " + packageInfo.getVersionCode() + "\n";
	sMessage = sMessage + "Enabled: " + packageInfo.isEnabled();
	self.MAP_TEXT = sMessage;
	self.MAP_ICON = packageInfo.getIcon("framework_icon.png");
	ui.refresh("MAP_TEXT", "MAP_ICON");
}	
</code>
\\

=== Ejemplo getPackageInfo ===
<code javascript>
var packageInfo = packageManager.getPackageInfo("com.xone.android.framework");
var sMessage = "Package name: " + packageInfo.getPackageName() + "\n";
sMessage = sMessage + "Label: " + packageInfo.getLabel() + "\n";
sMessage = sMessage + "Description: " + packageInfo.getDescription() + "\n";
sMessage = sMessage + "Version name: " + packageInfo.getVersionName() + "\n";
sMessage = sMessage + "Version code: " + packageInfo.getVersionCode() + "\n";
sMessage = sMessage + "Enabled: " + packageInfo.isEnabled();
self.MAP_TEXT = sMessage;
self.MAP_ICON = packageInfo.getIcon("framework_icon.png");
ui.refresh("MAP_TEXT", "MAP_ICON");
</code>
\\
\\
=== Ejemplo getInstalledPackageNames ===
<code javascript>
var sInstalledPackageNames = packageManager.getInstalledPackageNames();
var i;
var sMessage = "";

	for (i = 0;i < sInstalledPackageNames.length;i++) {
		sMessage = sMessage + "Package name: " + sInstalledPackageNames[i] + "\n";
	}

self.MAP_TEXT = sMessage;
ui.refreshValue("MAP_TEXT");
</code>

===== SqlManager =====
\\
|< 70% 20% - >|
^            Método            ^             Descripción             ^
|**<nowiki>ScriptCursorWrapper</nowiki>**| Es el objeto cursor resultado de las querys que tiran algunos métodos de <nowiki>SqlManager</nowiki>.|
\\
\\ 
===== Debug Tools =====
En Android, a partir del Framework 3.16.49, se pueden obtener por script las mismas funcionalidades del widget de depuración del <nowiki>XOneLive</nowiki> del dispositivo. Con esto se puede generar al usuario una pantalla más familiar dentro de la propia aplicación para monitorizar o realizar tareas de gestión o mantenimiento. 
\\
Objeto para enviar información de depuración a un servidor remoto.\\
\\
|< 70% 20% - >|
^  Método                           ^  Descripción                                                                  ^
| **%%GetDeviceID%%**               | Devuelve el IMEI del dispositivo.                                             |
| **%%GetLog%%**                    | Para obtener el Log del dispositivo.                                          |
| **%%SendDatabase%%**              | Para enviar la base de datos del dispositivo.                                 |
| **%%SendLog%%**                   | Para enviar el log de operaciones del dispositivo.                            |
| **%%SendReplicaDebugDatabase%%**  | Para enviar el log de réplica de la base de datos del dispositivo. Ver nota.  |
| **%%SendReplicaFilesDatabase%%**  | Para enviar la base de datos de réplica de ficheros.                          |
\\

Estos métodos devuelven 0 si el envío fue OK y -1 si se produjo algún error. 
<WRAP center round important 80%>
\\
El método <nowiki>SendReplicaDebugDatabase</nowiki> requiere que previamente se defina el atributo replica-debug="true" en el nodo <app> del mappings para que dicha base de datos se genere. Es importante desactivar este atributo cuando se haya solucionado el problema de réplica pues puede llegar a ser un verdadero desperdicio de espacio si se mantiene activo.
</WRAP>


=== Ejemplo DebugTools ===
<code xml>
<group name="General" id="1" align="center">
        <prop type="B" name="MAP_GETPIN" visible="1" width="80%" height="7%" onclick="getPin();" title="PIN dispositivo" />
        <prop type="B" name="MAP_SENDLOG" visible="1" width="80%" height="7%" onclick="sendLog();" title="Enviar log" />
        <prop type="B" name="MAP_GETLOG" visible="1" width="80%" height="7%" onclick="getLog();" title="Obtener log" />
        <prop type="B" name="MAP_SENDDB" visible="1" width="80%" height="7%" onclick="sendDatabase();" title="Enviar base de datos" />
        <prop type="B" name="MAP_SENDREPLICADEBUGDB" visible="1" width="80%" height="7%" onclick="sendReplicaDebugDatabase();" title="Enviar base de datos de debug de réplica" />
        <prop type="B" name="MAP_SENDREPLICAFILESDB" visible="1" width="80%" height="7%" onclick="sendReplicaFilesDatabase();" title="Enviar base de datos de debug de ficheros" />
    </group>
</code>
<code xml>
FUNCIONES
let debugTools = new DebugTools();

function getPin() {
	ui.msgBox("El PIN del dispositivo es: " + debugTools.getDeviceId(), "Mensaje", 0);
}

function sendLog() {
	let nResult = debugTools.sendLog();
	if (nResult === 0) {
		ui.showToast("Envío OK");
	} else {
		ui.showToast("Envío fallido");
	}
}

function getLog() {
	let sResult = debugTools.getLog();
	ui.msgBox(sResult, "Log", 0);
}

function sendDatabase() {
	let nResult = debugTools.sendDatabase();
	if (nResult === 0) {
		ui.showToast("Envío OK");
	} else {
		ui.showToast("Envío fallido");
	}
}

function sendReplicaDebugDatabase() {
	var nResult = debugTools.sendReplicaDebugDatabase();
	if (nResult === 0) {
		ui.showToast("Envío OK");
	} else {
		ui.showToast("Envío fallido");
	}
}

function sendReplicaFilesDatabase() {
	let nResult = debugTools.sendReplicaFilesDatabase();
	if (nResult === 0) {
		ui.showToast("Envío OK");
	} else {
		ui.showToast("Envío fallido");
	}
}
</code>
<WRAP center round info 80%>
NOTA: En los 4 últimos puede ponerse como parámetro la dirección a la que tiene que enviar, siempre que se tenga instalado en el servidor la web para recepcionar los datos. En el caso de que no se especifique ninguna dirección, será enviado al servidor habitual de CGSOFT. 
</WRAP>
\\
===== WriteString =====
\\
Escribe la cadena de texto, que se pasa por parámetro, a la pantalla de depuración. En el caso de Windows Mobile esta pantalla es la ventana de resultados de Visual Studio. \\
\\
^ Tipo		 	|Función|
^ Parámetros		| Cadena (in)El mensaje que se va a mostrar en pantalla.|
^ Sintaxis		|objeto.<nowiki>ChronoValue</nowiki> (string Cadena)|
^ Tipo de valor devuelto 	| No retorna valor.|
^ Plataforma		|Win32, Web, .NET, .NET CF, WM (2003, 2005, 6.0, 6.5) Blackberry (5.0), iPhone, Linux, MC+, Symbian (3ed, 5ed)|
\\
Ejemplo\\
\\
<code vb>
  set xcrn = CreateObject("System.Debug")
  xcrn.WriteString "INICIO CALCULOS"
  xcrn.ChronoStart
  REALIZAR TRABAJO 1 ...
  xcrn.WriteString "El tiempo trabajo 1: " + CStr(xcrn.ChronoValue)
  'REALIZAR TRABAJO 2 ...
  xcrn.ChronoStop
  xcrn.WriteString "El tiempo trabajo 2: " + CStr(xcrn.ChronoValue)
  xcrn.WriteString "FIN"
</code>
\\ 
\\ 
===== FileManager =====
\\
Este objeto de script, disponible en Android e iOS, encapsula algunas funciones sencillas de manejo y descarga de ficheros.\\ 
\\ 
Estos métodos devuelven 0 si OK, -1 en caso contrario.\\
\\
Si en los parámetros correspondientes NO se le especifica una ruta absoluta, estos métodos buscarán por defecto en la carpeta **files**, a excepción de los métodos **<nowiki>DownloadDatabase</nowiki>** y **<nowiki>DeleteDatabase</nowiki>** que tomarán por defecto la carpeta **bd** de la aplicación.

|< 75% 20% - >|
^ Operación                              ^  Método                                                                                                                                                    ^  Descripción                                                                                                                                                 ^
| Fichero Existe                         | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#fileExists|fileExists]]                                            | Comprueba si el fichero especificado en el primer parámetro existe.                                                                                          |
| Directorio Existe                      | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#directoryExists|directoryExists]]                                  | Comprueba si el directorio especificado en el primer parámetro existe.                                                                                       |
| Subir Fichero                          | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#uploadFile|uploadFile]]                                            | Permite subir ficheros.                                                                                                                                      |
| Descargar                              | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#download|download]]                                                | Descarga un fichero. Toma como primer parámetro la URL de descarga, como segundo parámetro la ruta donde debe guardar el fichero.                            |
| Descargar con callback                 | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#descargarConCallback|descargarConCallback]]                        | Descarga con callback                                                                                                                                        |
| Descargar si actualizado               | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#downloadIfUpdated|downloadIfUpdated]]                              | Descarga si fichero actualizado.                                                                                                                             |
| Descargar Asincrónico                  | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#asyncDownload|asyncDownload]]                                      | Descarga asincrónica.                                                                                                                                        |
| Descargar Asincrónico mimetype         | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#asyncDownloadMimeType|asyncDownloadMimeType]]                      | Descarga Asincrónica con MimeType                                                                                                                            |
| Descargar Base de Dato                 | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#DownloadDatabase|downloadDatabase]]                                | Igual que el método Download, pero éste sólo toma el primer parámetro.                                                                                       |
| Descargar Fichero grande               | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#downloadBigFileSyncWithProgress|downloadBigFileSyncWithProgress]]  | Permite descargar fichero y muestra progreso.                                                                                                                |
| Comprimir                              | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#Unzip|unzip]]                                                      | Descomprime                                                                                                                                                  |
| Descomprimir                           | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#Zip|zip]]                                                          | Comprime                                                                                                                                                     |
| Listar Ficheros                        | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#ListDirectories|listDirectories]]                                  | Devuelve un array con los nombres de las carpetas que haya encontrado. Un sólo parámetro, la carpeta a chequear.                                             |
| Listar Directorios                     | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#ListFiles|listFiles]]                                              | Devuelve un array con nombres de los ficheros. Un sólo parámetro, la carpeta donde están los ficheros a listar.                                              |
| Crear Directorio                       | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#CreateDirectory|createDirectory]]                                  | Crea un directorio.                                                                                                                                          |
| Copiar                                 | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#copy|copy]]                                                        | Copia un fichero, tomando como origen el primer parámetro y como destino el segundo parámetro.                                                               |
| Eliminar Fichero                       | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#delete|delete]]                                                    | Borra el fichero especificado en el primer parámetro.                                                                                                        |
| Eliminar Directorio                    | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#deleteDirectory|deleteDirectory]]                                  | Borra el directorio.                                                                                                                                         |
| Comprobación de Suma (Obtener CRC32)   | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#GetcheckSum CRC32|getcheckSum CRC32]]                              | Obtener comprobación de suma.                                                                                                                                |
| Comprobar Adler32                      | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#getcheckSum Adler32|comprobar Adler32]]                            | Obtener comprobación Adler32                                                                                                                                 |
| Comprobar SHA1                         | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#GetcheckSum SHA1|comprobar SHA1]]                                  | Obtener comprobación Sha1                                                                                                                                    |
| Vigilar cambios carpeta XOne           | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#startListeningForChanges|startListeningForChanges]]                | Inicio de chequeo de cambios de carpeta XOne                                                                                                                 |
| Dejar de Vigilar cambios carpeta XOne  | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#stopListeningForChanges|stopListeningForChanges]]                  | Detener chequeo de cambios de carpeta XOne                                                                                                                   |
| Obtener fecha de modificación          | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#GetLastModifiedDate|getLastModifiedDate]]                          | Obtener fecha de última modificación                                                                                                                         |
| Test SSL                               | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#testSsl|testSsl]]                                                  | Test de configuración de SSL                                                                                                                                 |
| Abrir Fichero                          | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#OpenFile|openFile]]                                                | Abre un fichero el fichero especificado en el primer parámetro. El sistema operativo se encargará de abrir el fichero con la aplicación que tenga asociada.  |
| Leer Fichero                           | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#ReadFile|readFile]]                                                | Leer archivo.                                                                                                                                                |
| Salvar Fichero                         | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#SaveFile|saveFile]]                                                | Guarda el fichero.                                                                                                                                           |
| Mover Fichero                          | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#Move|move]]                                                        | Mueve un fichero, tomando como origen el primer parámetro y como destino el segundo parámetro.                                                               |
| Renombrar Fichero                      | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#Rename|rename]]                                                    | Renombra un fichero, tomando como origen el primer parámetro y como destino el segundo parámetro.                                                            |
| Obtener Información del fichero        | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#getFileInfo|getFileInfo]]                                          | Obtener información detalles fichero.                                                                                                                        |
| Borrar APP                             | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#deleteApp|deleteApp]]                                              | Eliminar App                                                                                                                                                 |
| Devolver cadena a Base64               | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#ToBase64|ToBase64]]                                                | Devuelve una cadena en base64. Un sólo parámetro, el fichero a convertir.                                                                                    |
| De Base64 a Fichero                    | [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#ToFile|toFile]]                                                    | 2 parámetros, primero la cadena en base64 y segundo el fichero resultante.                                                                                   |

<WRAP center round info 60%>
A la hora de utilizar los métodos **<nowiki>ListDirectories</nowiki>** y **<nowiki>ListFiles</nowiki>** pueden sernos de utilizar los métodos <wrap hi>appData.appPath</wrap> y <wrap hi>appData.filesPath</wrap> que nos devuelven la ruta donde está instalada la aplicación en la memoria interna del teléfono y la ruta a la carpeta donde se encuentran los "files" (en sd externa), respectivamente.
</WRAP>
\\
=== Ejemplo FileManager  ===
\\
<code vb>
'En este ejemplo de uso en Android, comprobamos que el fichero .APK exista en la raíz de la tarjeta SD. 
'Si existe, mostramos un mensaje y procedemos a abrir el fichero .APK. 
'Android se encargará de preguntar al usuario si quiere instalar la aplicación.

Set obj01 = CreateObject("FileManager")
res = obj01.FileExists("/sdcard/x.apk")
if res = 0 then
	ui.MsgBox "Aviso", "El fichero existe, procedo a lanzarlo", 0
	obj01.OpenFile "/sdcard/x.apk"
else
	ui.MsgBox "Aviso", "El fichero no existe", 0
end if
Set obj01 = nothing

Function ListarDirectorios
      Set filemanager01 = CreateObject("FileManager")
      lst = filemanager01.ListDirectories(appData.appPath)

      If Not lst Is Nothing Then
            For i = 0 To UBound(lst)
            	ui.ShowToast "Estos son los directorios: " + lst(i)
            Next
      Else
            ui.ShowToast "No hay nada..."
      End If
End Function

Function ListarFicheros
      Set filemanager01 = CreateObject("FileManager")
      'Tambien se puede llamar a ListFiles a secas para que nos devuelva todo lo que haya.
      lst = filemanager01.ListFiles(appData.filesPath)

      If Not lst Is Nothing Then
            For i = 0 To UBound(lst)
            	ui.ShowToast "Estos son los ficheros: " + lst(i)
            Next
      Else
            ui.ShowToast "No hay nada..."
      End If
End Function
</code>
\\
==== asyncDownload ====
\\
|< 70% 20% - >|
^ Tipo        | Método                                                                       |
^ Sintáxis    | asyncDownload(origen de fichero de descarga, nombre fichero nueva descarga)  |
^ Plataforma  | Android, IOs                                                                 |
\\

Descarga de fichero de forma asincrónica.
\\
\\
**Ejemplo:**
\\
 <code javascript>
  var fm = createObject("FileManager");
  fm.asyncDownload("http://www.xoneisp.com/jc/png_demo.png", "png_demo.png")
 </code>
\\
<code javascript>

function descargarAsincronico() {
 let fm = new FileManager();
 fm.asyncDownload("https://www.cgsoft.es/XN/jc/png_demo.png", "png_demo.png");
}
 </code>
\\


==== asyncDownloadMimeType ====
\\
|< 70% 20% - >|
^ Tipo        | Método                                                                       |
^ Plataforma  | Android, IOs                                                                 |
\\

Descarga de fichero de forma asincrónica con MimeType.
\\
\\
**Ejemplo:**
\\
 <code javascript>
  
 function descargarAsincronicoMimeType() {
   var fm = createObject("FileManager");
   fm.asyncDownload("https://www.cgsoft.es/XN/jc/png_demo.png", "png_demo.png", "Hola qué tal, descargando un fichero...", "image/png");
}
 </code>
\\

==== FileExists====
\\
|< 70% 20% - >|
^ Tipo        | Método                                                                             |
^ Sintáxis    | fileExists (Nombre de fichero). Devuelve valor 0 o 1, según éxito de la búsqueda.  |
^ Plataforma  | Android, IOs                                                                       |
\\

Comprobar si fichero existe.
\\
\\
**Ejemplo:**
\\
 <code javascript>
function existe() {
 let fm = new FileManager();
    let nExists = fm.fileExists("/sdcard/xone/app_FileManager/files/.nomedia");
    if (nExists === 0) {
        ui.showToast("El fichero existe");
    } else {
        ui.showToast("El fichero no existe");
    }
}
 </code>
\\



==== DirectoryExists====
\\
|< 70% 20% - >|
^ Tipo        | Método                                                                             |
^ Sintáxis    | directoryExists (Nombre de carpeta). Devuelve valor 0 o 1, según éxito de la búsqueda.  |
^ Plataforma  | Android, IOs                                                                       |
\\

Comprobar si carpeta existe.
\\
\\
**Ejemplo:**
\\
 <code javascript>
function existe() {
  let sBadPath = appData.getAppPath() + "../app_FileManager/";
    let fm = new FileManager();
    if (fm.directoryExists(sBadPath) !== 0) {
        ui.showToast("La carpeta existe");
    } else {
        ui.showToast("La carpeta no existe");
    }
}
 </code>
\\
==== createDirectory====
\\
|< 70% 20% - >|
^ Tipo        | Método                                                            |
^ Sintáxis    | createDirectory(ruta donde se creará, nombre directorio a crear)  |
^ Plataforma  | Android, IOs                                                      |
\\

Crear Directorio.
\\
\\
**Ejemplo:**
\\
<code javascript>

function crearDirectorio() {
 let fm = new FileManager();
 fm.createDirectory("https://www.cgsoft.es/XN/jc/", "carpeta_demo");
}
 </code>
\\

==== listDirectories ====
\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Sintáxis    | .istDirectories(nombre directorio)  |
^ Plataforma  | Android, IOs                                   |
\\

Listar Directorio\\
\\
**Ejemplo:**\\
\\

<code javascript>
function listarDirectorios() {
        let fm = new FileManager();
	let list = fm.listDirectories("/sdcard/xone/FileManager");
	let message = "";
	let i;
	if(list) {
		for(i = 0;i < list.length;i++) {
			message = message + list[i] + "\n";
		}
		ui.msgBox(message, "Mensaje", 0);
	} else {
		ui.showToast("No hay nada...");
	}
}
</code>
\\
==== listFiles ====
\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Sintáxis    | listFiles (nombre directorio)  |
^ Plataforma  | Android, IOs                                   |
\\
\\
Listar Directorio
\\
\\
**Ejemplo:**\\
\\

<code javascript>
function listarFicheros() {
	let fm = new FileManager();
        let list = fm.listFiles("/sdcard/xone/FileManager");
	let message = "";
	let i;
	if(list) {
		for(i = 0;i < list.length;i++) {
			message = message + list[i] + "\n";
		}
		ui.msgBox(message, "Mensaje", 0);
	} else {
		ui.showToast("No hay nada...");
	}
}
</code>
==== zip ====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Sintáxis    | zip (fichero a comproimir)  |
^ Plataforma  | Android, IOs                                   |
\\
Comprimir fichero\\
\\
**Ejemplo:**\\
\\
<code javascript>

 function comprimir() {
        let fm = new FileManager();
	let nResult = fm.zip("apk.apk");
	ui.showToast("Respuesta zip(): " + nResult);
}
</code>

\\
==== unzip ====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Sintáxis    | unzip (fichero a descomprimir)  |
^ Plataforma  | Android, IOs                                   |
\\
Descomprimir fichero\\
\\
**Ejemplo:**\\
\\
<code javascript>
 function descomprimir() {
        let fm = new FileManager();
	let nResult = fm.unzip("apk.apk.zip");
	ui.showToast("Respuesta unzip(): " + nResult);
}
 </code>
\\
==== getCheckSum Crc32====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Obtener comprobación de suma.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
function comprobarCrc32() {
        let fm = new FileManager();
	let nResult = fm.getChecksum("apk.apk", "sha1");
	ui.showToast(nResult);
}
 </code>
\\

==== getCheckSum Adler32====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Obtener comprobación de suma.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
 function comprobarAdler32() {
        let fm = new FileManager();
	let nResult = fm.getChecksum("apk.apk", "adler32");
	ui.showToast("Adler32: " + nResult);
}
 </code>
\\
==== getCheckSum SHA1====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Obtener comprobación de suma.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
 function comprobarSha1() {
        let fm = new FileManager();
	let nResult = fm.getChecksum("foto_grande.jpg", "sha1");
	ui.showToast("SHA1: " + nResult);
}
 </code>
\\

==== startListeningForChanges====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Iniciar chequeo cambios de carpeta XOne
\\

\\
**Ejemplo**:\\
\\
<code javascript>
 function startListeningForChanges() {
      let fm = new FileManager();
      fm.addOnDirectoryChangedListener("/sdcard/xone/", function(event, sPath) {
		ui.showToast("Nuevo evento: " + event + " " + sPath);
	});
}
 </code>
\\

==== stopListeningForChanges====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Detener chequeo de cambios de carpeta XOne
\\

\\
**Ejemplo**:\\
\\
<code javascript>
 function stopListeningForChanges() {
        let fm = new FileManager();
	fm.removeOnDirectoryChangedListener("/sdcard/xone/");
}
 </code>
\\
==== getLastModifiedDate====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Obtener fecha de última modificación.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
function demoGetLastModifiedDate() {
	let fechaModificacion = fm.getLastModifiedDate("/sdcard/keystores/hotswap.bks");
	ui.showToast("Fecha: " + fechaModificacion.toString());
}
 </code>
\\

==== testSsl====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Realizar test de configuración SSL.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
function testSslConfig() {
	let fm = new FileManager();
	//let nResult = fm.download("https://margosl.com/wp-content/uploads/2018/01/estofado_pavo.jpg", "estofado_pavo.jpg");
	let nResult = fm.download("http://www.google.es/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png", "69.pdf");
	if (nResult === 0) {
		ui.showToast("Download OK");
	} else {
		ui.showToast("Download failed");
	}
}
 </code>
\\
==== readFile====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Realizar lectura de fichero.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
function readFile() {
    let fm = new FileManager();
    let str = fm.readFile("notas.txt", "UTF-8");
    ui.showToast(str);
}
 </code>
\\
==== saveFile====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Realizar salva de fichero.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
function saveFile() {
    let bResult = fm.saveFile("notas.txt", "\nNuevo valor. Hola qué tal.", true, "UTF-8");
    if (bResult) {
        ui.showToast("OK!");
    } else {
        ui.showToast("Error!");
    }
}
}
 </code>
\\
==== getFileInfo====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Obtener información detalle de fichero.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
function getFileInfo() {
    let fm = new FileManager();
    let info = fm.getFileInfo("/sdcard/keystores/hotswap.bks");
    let sMessage = "Tamaño: " + info.size + " bytes"
        + "\nCreación (Sólo Android >= 8.X.X): " + info.creationDate.toString()
        + "\nModificación: " + info.modificationDate.toString()
        + "\nOculto: " + info.isHidden
        + "\nLectura: " + info.canRead
        + "\nEscritura: " + info.canWrite
        + "\nEjecución (Sólo Android >= 2.3.X): " + info.canExecute;
    ui.msgBox(sMessage, "Mensaje", 0);
}
 </code>
\\
==== toBase64====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Devuelve una cadena en base64. Un sólo parámetro, el fichero a convertir.

\\
**Ejemplo**:\\
\\
<code javascript>
function toBase64() {
	let fm = new FileManager();
	self.MAP_TESTFICHERO_BASE64 = fm.toBase64(self.MAP_TESTFICHERO_NORMAL);
	ui.refresh("MAP_TESTFICHERO_BASE64", "MAP_TESTFICHERO_NORMAL");
}
 </code>
\\

==== toFile====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Devuelve de Base64 a fichero.

\\
**Ejemplo**:\\
\\
<code javascript>
function toFile() {
	let fm = new FileManager();
	let sDestino = "foto_normal.jpg";
	fm.toFile(self.MAP_TESTFICHERO_BASE64, sDestino);
	self.MAP_TESTFICHERO_NORMAL = sDestino;
	ui.refresh("MAP_TESTFICHERO_BASE64", "MAP_TESTFICHERO_NORMAL");
}
 </code>
\\
==== deleteApp====

\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Eliminar Aplicación.
\\

\\
**Ejemplo**:\\
\\
<code javascript>
function deleteApp() {
    let sBadPath = appData.getAppPath() + "../app_FileManager/";
    let fm = new FileManager();
    if (fm.directoryExists(sBadPath) !== 0) {
        ui.showToast("Nada que hacer");
        return;
    }
    let nResult = fm.delete(appData.getAppPath() + "../files/lastexecuted.ini");
    if (nResult !== 0) {
        ui.showToast("Error al borrar lastexecuted.ini");
        // Continuar
    }
    nResult = fm.deleteDirectory(sBadPath);
    if (nResult !== 0) {
        ui.showToast("Error!");
        return;
    }
    if (nResult === 0) {
        ui.showToast("OK!");
        appData.exit();
        return;
    }
}
 </code>
\\

==== delete ====

\\
|< 70% 20% - >|
^ Tipo        | Método                                                                       |
^ Sintáxis    | .delete(ruta de fichero a borrar)  |
^ Plataforma  | Android, IOs                                                                 |
\\

Eliminar fichero.
\\
\\
**Ejemplo:**\\
\\

<code javascript>
function borrarFichero() {
        let fm = new FileManager();
	let nResult = fm.delete("/sdcard/xone.zip");
	ui.showToast("Respuesta Delete(): " + nResult);
}
 </code>
\\
==== deleteDirectory ====

\\
|< 70% 20% - >|
^ Tipo        | Método                                                                       |
^ Sintáxis    | deleteDirectory(ruta de fichero a borrar)  |
^ Plataforma  | Android, IOs                                                                 |
\\

Eliminar Directorio.

\\
**Ejemplo:**\\
\\
<code javascript>
 function eliminarDirectorio() {
	let nResult = fm.deleteDirectory("/sdcard/xone/FileManager");
	ui.showToast("Respuesta DeleteDirectory(): " + nResult);
}

</code>
\\
==== download ====
\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Sintáxis    | .download(origen de descarga, nombre fichero)  |
^ Plataforma  | Android, IOs                                   |
\\

Descargar fichero.
\\
\\
**Ejemplo:**\\
\\

<code javascript>
function descargar() {
        let fm = new FileManager();
	let nResult = fm.download("https://www.cgsoft.es/XN/jc/test.jpg", "test.jpg");
	ui.showToast("Respuesta download(): " + nResult);
	if (nResult === 0) {
	    ui.openFile("test.jpg");
	}
}
</code>
==== download con callback ====
\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Descargar fichero con callback.
\\
\\
**Ejemplo:**\\
\\
**download con callback**
<code javascript>
function descargarConCallback() {
    let fm = new FileManager();
    let sFileName = "DEU_1506.zip";
    if (fm.fileExists(sFileName) === 0) {
        let nResult = ui.msgBox("¿Borrar fichero?", "Fichero previo encontrado", 4);
        if (nResult == 6) {
            if (fm.delete(sFileName) === 0) {
                ui.showToast("Fichero previo borrado");
            } else {
                ui.showToast("Error al borrar fichero");
            }
        }
    }
    </code>
\\    
  ==== downloadIfupdated ====
\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Descargar fichero si actualizado. 

\\
**Ejemplo:**\\
\\
<code javascript>
function descargarSiActualizado() {
        let fm = new FileManager();
	let callback = function(porcentaje) {
		//ID aleatorio
		ui.showNotification(123456, "Progreso: " + porcentaje, "Hola");
	};
	let nResult = fm.downloadIfUpdated("http://xonevalencia.com/SecurityBroker/Resource.ashx?remote=CacheFile1&tid=1234567&mapped=true&fn=ph_1400594610436.jpg", "/sdcard/ph_1400594610436.jpg", "", callback);
	ui.showToast("Respuesta download(): " + nResult);
}
</code>
\\
====downloadBigFileSyncWithProgress====
\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Plataforma  | Android, IOs                                   |
\\

Descargar fichero con progreso (para ficheros que sean grandes y demore la descarga).
\\

**Ejemplo:**\\
\\

<code javascript>
function downloadBigFileSyncWithProgress() { 
    let fm = new FileManager();
    let sUrl = "http://www.cgsoft.es/XN/jc/DEU_1506.zip"; 
    ui.setMaxWaitDialog(100); 
    ui.updateWaitDialog("Descargando " + sUrl, 0); 
    let callback = function(nPercent) { 
        ui.updateWaitDialog("Descargando " + sUrl, nPercent); 
    }; 
    let nResult = fm.download(sUrl, "fichero.zip", "", callback); 
    ui.showToast("Result: " + nResult);
} 
</code>
==== downloadDatabase ====
\\
|< 70% 20% - >|
^ Tipo        | Método                                         |
^ Sintáxis    | downloadDatabase(origen de descarga)           |
^ Plataforma  | Android, IOs                                   |
\\

Descargar Base de Datos.
\\
\\
**Ejemplo:**\\
\\

<code javascript>
function downloadDatabase() {
let fm = new FileManager();
    ui.showToast("User: " + user.NOMBRE);
    let nResult = fm.downloadDatabase("https://www.cgsoft.es/XN/jc/gestion.db");
    if (nResult === 0) {
        ui.showToast("Descarga OK!");
    } else {
        ui.showToast("Error en la descarga");
    }
}
</code>
\\


==== Objetos fileCtl.fileSystem y fileCtl.file ====
\\
Este objeto es antiguo. Para las últimas funcionalidades utilizar el objeto [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start|FileManager]] descrito anteriormente.


^ OBJETO | %%FileCtl.FileSystem%% |
^ MÉTODOS | %%Kill%%\\ %%Dir%%\\ %%FileLen%% |
 
^ OBJETO | %%FileCtl.File%% |
^ MÉTODOS | %%Open%%\\ %%LinePrint%%\\ %%LineInputString%%\\ %%Close%% |

    
=== Ejemplo fileCtl.fileSystem ===

<code vb>
function EliminaFicherosMDI
  'eliminamos toda la carpeta MDI
	on error resume next
	Set fso = CreateObject("FileCtl.FileSystem")
	fic = fso.dir("\My Documents\MDI\*.*")
	while len(fic)>0
		If Len(fic)>0 Then
			fso.kill "\My Documents\MDI\"+fic
		End If               
		fic=fso.dir
	Wend
	set fso=nothing
	set fic=nothing
	appdata.error.clear
End function
</code>

<code vb>
function EliminaFicheros

' eliminamos el fichero de documento escaneado de 
' los documentos anteriores a 2 dias 
' Hacemos uso de una colección que contiene el nombre y la fechas de los ficheros
	dim coll,fichero,salir
  
	On Error Resume Next    
	set fso=CreateObject("FileCtl.FileSystem")
	set coll=appdata.getcollection("BorraFicEscaneados")
	coll.filter="julianday('now') - julianday(t2.FECHA)>2"
	coll.startbrowse
	if not coll.currentitem is nothing then
		salir=0
		while salir=0
			set obj=coll.currentitem
			if len(cstr(obj("FOTO_ALBARAN")))>0 then
				fichero=appdata.AppPath+"files\"+cstr(obj("FOTO_ALBARAN"))  
				fic=fso.dir(fichero)
				if len(fic)>0 then
					fso.kill fichero
				end if
				set fic=nothing
			end if    
			set obj=nothing
			coll.movenext
			if coll.currentitem is nothing then
				salir=1
			end if    
		wend
	end if
	coll.endbrowse
	coll.clear
	set coll=nothing
	set fso=nothing
	appdata.error.clear
End function
</code>
\\
==== uploadFile ===
\\
Permite subir ficheros por HTTP POST con multipart.\\
\\
^ **Método uploadFile**  ^ Sube ficheros por HTTP POST con multipart.                                                                                                                                                                                                                                               ^
| **Parametros**         | Tiene 3 parametros: \\ -Se indica la URL a la que se va a llamar para subir el fichero. \\ -Nombre de fichero a subir. \\ -(Opcional) es una serie de parámetros opcional que se envía cada uno en el Content-Disposición de la cabecera http, separado por los dos puntos (Key:Value).  |
\\
=== Ejemplo uploadFile ===

<code javascript>
let fm = new FileManager();

 function subirFichero() {
	let jsParams = {
        url: "http://ptsv2.com/t/0kw53-1554974493/post",
        file: "notas.txt",
        allowUnsafeCertificates: true,
        parameters: {
            VERSIONAPP: "ONLINE"
        }
    };
    let sRespuesta = fm.uploadFile(jsParams);
    ui.msgBox(sRespuesta, "Respuesta", 0);
}

function subirFichero2() {
    let jsParams = {
        url: "http://mobility.bdn.msoft.es:8087/postfiles/index.php",
        file: "notas.txt",
        allowUnsafeCertificates: true,
        parameters: {
            VERSIONAPP: "ONLINE"
        },
        version: 1
    };
    let sRespuesta = fm.uploadFile(jsParams);
    ui.msgBox(sRespuesta, "Respuesta", 0);
    appData.writeConsoleString(sRespuesta);
}

function subirFichero3() {
	let jsParams = {
        url: "http://192.168.1.72:5000/api/files/PostFormData",
        file: "notas.txt",
        allowUnsafeCertificates: true,
        parameters: {
         	NNAMEFILE: "-",
        	KEEPFILENMAME: "true",
         	CATEGORIA: "FOTOINT_ENT"
        }
    };
	let sRespuesta = new FileManager().uploadFile(jsParams);
	ui.msgBox(sRespuesta, "Respuesta webservice", 0);
} 
</code>
===== WifiManager =====
\\
Permite obtener datos de la wifi, como manejar el estado de la misma.\\
\\
<code javascript>
      var wifiManager = createObject("WifiManager");
</code>
\\ 
Objeto para administrar y escanear redes wifi.\\
\\
^MÉTODOS^ DESCRIPCION ^
|**getAdapterMacAddress** | Obtiene la dirección MAC.|
|**getActiveWifiInfo** | Obtiene un objeto con la información de la wifi activa, en caso de no estar conectado a una wifi devuelve Null. \\  -Podemos obtener la siguiente información: \\ **getBssid**: Obtiene el BSSID. \\ **getFrequency**: Obtiene la frecuencia. \\ **getHiddenSsid**: Obtiene si el SSID está en oculto o no. \\ **getIpAddress**: Obtiene la dirección Ip. \\ **getLinkSpeed**: Obtiene la velocidad de enlace. \\ **getRssi**: Obtiene el RSSI. \\ **getSsid**: Obtiene el SSID.|
|**connect** | conecta el dispositivo a una wifi. \\  -Parámetros: \\ **SSID** de la wifi a la que queremos conectar.|
|**disconnect** | desconecta el dispositivo de la wifi.|
|**enableNetwork** | Habilita la conexión automática a una wifi. \\ -Parámetros: \\ **SSID** de la wifi. |
|**disableNetwork** | Deshabilita la conexión automática de una conexión wifi. \\ -Parámetros: \\ **SSID** de la wifi.|
|**removeNetwork** | Quita la wifi de la lista de netWork del dispositivo. \\ -Parámetros: \\ **SSID** de la wifi.|
|**addNetwork** | Agrega una wifi a la lista de netWork del dispositivo. \\ -Parámetros: \\ -Un objeto **<nowiki>WifiConfiguration</nowiki>**.|
|**listSavedNetworks** | Devuelve la lista de Wifis guardadas en la lista de Networks del dispositivo, (Devuelve un array de objetos **<nowiki>WifiConfiguration</nowiki>**).|
|**scanAvailableNetworks** | Devuelve una lista de Networks disponibles. \\ -Parámetros: \\ -Se define una función a la que se llamará cuando tenga esa lista de networks.|

==== WifiConfiguration ====
\\
Establece un objeto wifi, para poder usarlo en el objeto <nowiki>wifiManager</nowiki>.\\
\\
Objeto constructor para pasarle los parámetros de una red wifi al <nowiki>WifiManager</nowiki>.\\
\\
|< 70% 15% - >|
^ Método    ^ Descripción                     ^
| **getBssid**             | Obtiene el BSSID.                                                              |
| **getHiddenSsid**        | obtiene si el SSID está oculto.                                                |
| **getNetworkSecurity**   | Obtiene el Tipo de seguridad de la wifi.                                       |
| **getSsid**              | obtiene el SSID.                                                               |
| **setBssid**             | Establece el BSSID.                                                            |
| **setHiddenSsid**        | Establece si el SSID es oculto o no.                                           |
| **setNetworkSecurity**   | Establece el tipo de seguridad (OPEN,WPA2,WPA, WEB,EAP …)                      |
| **setPassword**          | Establece la contraseña de la wifi, en caso de que la seguridad no sea OPEN.   |
| **setSsid**              | Establece el SSID.                                                             |
\\
\\
=== Ejemplos WifiConfiguration ===
<code javascript>
// Ejemplo de creación de una WIFI Open

	var wifiConfiguration = createObject("WifiConfiguration");
	wifiConfiguration.setSsid("SSID DE LA WIFI ABIERTA");
	wifiConfiguration.setNetworkSecurity("OPEN");

// Ejemplo de creación de una wifi Con WPA2 ===

	var wifiConfiguration = createObject("WifiConfiguration");
	wifiConfiguration.setSsid("SSID DE LA WIFI");
	wifiConfiguration.setNetworkSecurity("WPA2");
	wifiConfiguration.setPassword("CONTRASEÑA DE LA WIFI");
</code>
\\
\\ 


=== Ejemplo de addNetwork(wifiConfiguration) ===
\\
<code javascript>
    var wifiManager = createObject("WifiManager");
    var wifiConfiguration = createObject("WifiConfiguration");
    wifiConfiguration.setSsid("XOneWireless5G");
    wifiConfiguration.setNetworkSecurity("WPA2");
    wifiConfiguration.setPassword("xone01CGSOFT02");
    wifiManager.addNetwork(wifiConfiguration);
</code>
\\
=== Ejemplo de listSavedNetworks() ===
\\
<code javascript>
    var wifiManager = createObject("WifiManager");
    var lstSaved = wifiManager.listSavedNetworks();
    var sMessage = "";
    for (var i = 0; i < lstSaved.length;i++) {
        sMessage = sMessage + "SSID: " + lstSaved[i].getSsid() + "\n";
    }
    ui.msgBox(sMessage, "Redes", 0);
</code>
\\
=== Ejemplo de scanAvailableNetworks ===
\\
<code javascript>
    var wifiManager = createObject("WifiManager");
    var lstAvailable = wifiManager.scanAvailableNetworks(function(wifiNetworks) {
    var sMessage = "";
    for (var i = 0;i < wifiNetworks.length;i++) {
    sMessage = sMessage + wifiNetworks[i].getSsid() + " " + wifiNetworks[i].getNetworkSecurity() + "\n";
    }
    ui.msgBox(sMessage, "Redes", 0);
    });
    ui.showToast("Escaneando redes WiFi...");
</code>
\\
=== Ejemplo de getActiveWifiInfo ===
\\
<code javascript>
  var wifiManager = createObject("WifiManager");
  var wifiInfo = wifiManager.getActiveWifiInfo();
</code>
\\
=== Ejemplo de getBssid ===
\\
<code javascript>
 var wifiInfo = wifiManager.getActiveWifiInfo();
 sMessage = sMessage + "BSSID: " + wifiInfo.getBssid()
</code>
\\
=== Ejemplo de getFrequency ===
\\
<code javascript>
 var wifiInfo = wifiManager.getActiveWifiInfo();
 sMessage = sMessage + "Frecuencia: " + wifiInfo.getFrequency();
</code>
\\
=== Ejemplo de getHiddenSsid ===
\\
<code javascript>
  var wifiInfo = wifiManager.getActiveWifiInfo();
  sMessage = sMessage + "SSID oculto: " + wifiInfo.getHiddenSsid()
</code>
\\
=== Ejemplo de getIpAddress ===
\\
<code javascript>
  var wifiInfo = wifiManager.getActiveWifiInfo();
  sMessage = sMessage + "Dirección IP: " + wifiInfo.getIpAddress()
</code>
\\
=== Ejemplo de getLinkSpeed ===
\\
<code javascript>
  var wifiInfo = wifiManager.getActiveWifiInfo();
  sMessage = sMessage + "Velocidad enlace: " + wifiInfo.getLinkSpeed();
</code>
\\
=== Ejemplo de getRssi ===
\\
<code javascript>
  var wifiInfo = wifiManager.getActiveWifiInfo();
  sMessage = sMessage + "RSSI: " + wifiInfo.getRssi();
</code>
\\
=== Ejemplo de getSsid ===
\\
<code javascript>
  var wifiInfo = wifiManager.getActiveWifiInfo();
  sMessage = sMessage + "SSID: " + wifiInfo.getSsid()
</code>
\\
=== Ejemplo de connect ===
\\
<code javascript>
  var wifiManager = createObject("WifiManager");
  wifiManager.connect("XOneWireless5G");
</code>
\\
=== Ejemplo de disconnect ===
\\
<code javascript>
  var wifiManager = createObject("WifiManager");
  wifiManager.disconnect();
</code>
\\
=== Ejemplo de enableNetwork ===
\\
<code javascript>
  var wifiManager = createObject("WifiManager");
  wifiManager.enableNetwork("XOneWireless5G");
</code>
\\
=== Ejemplo de disableNetwork ===
\\
<code javascript>
  var wifiManager = createObject("WifiManager");
  wifiManager.disableNetwork("XOneWireless5G");
</code>
\\
=== Ejemplo de removeNetwork ===
\\
<code javascript>
 var wifiManager = createObject("WifiManager");
 wifiManager.removeNetwork("XOneWireless5G");
</code>
\\
===== XOneNFC =====
\\
Objeto para manejar los eventos de lectura y escritura NFC.
Así es como se crea un objeto NFC:\\
\\
<code javascript>
    var nfc = createObject("XOneNFC");
</code>
\\
^MÉTODOS  ^ DESCRIPCIÓN ^
|**enableDnieReader ** | activa la lectura del DNI electrónico por NFC, se mantiene escuchando hasta que detecta algo para leer. \\ -PARÁMETROS: \\ -var options = {. \\ -Para que recupere la información del perfil. Con esta variable a true, tenemos acceso a los siguientes valores de la variable que devuelve el método onDnieRead en la variable que se pasa por parámetro: \\ **getDniNumber()**:NÚmero DNI. \\ **getDocumentType()**:Tipo de documento. \\ **getName()**:Nombre. \\ **getSurname()**:Apellidos. \\ **getDateOfBirth()**:Fecha de nacimiento. \\ **getDateOfExpiry()**:Fecha de expiración. \\ **getNationality()**:Nacionalidad. \\ **getIssuer()**:Emisor del DNI. \\ **getOptionalData()**:Obtener datos opcionales. \\ **getSex()**:Sexo. \\ **getBirthPlace()**:Lugar de nacimiento. \\ **getAddress()**:Dirección. \\ **getCustodyInfo()**:Obtener custodia de información. \\ **getIcaoName()**:Nombre Icao. \\ **getOtherInfo()**:Obtener otra información. \\ **getProfession()**:Obtener profesión. \\ **getPhone()**:Obtener teléfono. \\ **getTitle()**:Obtener título. \\ **getSummary()**:Obtener sumario.|
|**readProfileData : true** | Para que recupere la imagen del perfil. Con esta variable a true, tenemos acceso a los siguientes valores de la variable que devuelve el método onDnieRead en la variable que se pasa por parámetro: \\ -getUserImage(appData.getFilesPath() + "Nombredelficjero.png"): Debe indicarse la ruta absoluta “appData.getFilesPath()”, seguida del nombre de la imagen y extesión “png”.|
|**readUserImage : true** | Para que recupere la firma. Con esta variable a true, tenemos acceso a los siguientes valores de la variable que devuelve el método onDnieRead en la variable que se pasa por parámetro: \\ -getSignatureImage(appData.getFilesPath() + " Nombredelfichero.png"):Debe indicarse la ruta absoluta “appData.getFilesPath()”, seguida del nombre de la imagen y extesión “png”.|
|**readSignatureImage : true** | Para que recupere el  certificado de autenticación. (Requiere pin del DNI. Si se introduce un pin erróneo puede bloquear el DNI si se repite el proceso más de 3 veces).  |
|**readAuthenticationCertificate : false**  | Para que recupere la firma del certificado (Requiere pin del DNI. Si se introduce un pin erróneo puede bloquear el DNI si se repite el proceso más de 3 veces). Con esta variable a true, tenemos acceso a los siguientes valores de la variable que devuelve el método onDnieRead en la variable que se pasa por parametro: \\ **getSignatureKey()**. \\ **getSignatureCertificateChain()**.|
|**readSignatureCertificate : false**.|
|**canNumber** | Número CAN del DNIe. |
|**pin** | Número PIN del DNIe. |
|**onDnieRead** | **function ( dnieReadResult ){**: Define la función que se llamará cuando termine la lectura del DNIe. Aquí ponemos el código que queramos realizar cuando se termine de leer el DNI.|
|**dnieReadResult** | Nos devuelve un objeto con todas las variable que ha leído.|
|**onDnieReadError** | **function ( sReadError ){**: Define la función que se llamarÁ cuando falle la lectura del DNIe. Aquí ponemos el código que queramos realizar cuando ocurra algún tipo de error en la lectura del DNI. |
|**sReadError** | Nos indica el error que se ha producido durante la lectura del DNIe.|
|**onProgressUpdated** | **function ( sMessage, nProgress ){**. Define la función que se llamará cuando se esté leyendo el DNIe. Aquí ponemos el código que queramos realizar mientras se lee el DNIe, nos devuelve: \\ -sMessage: que nos indica el mensaje según el proceso de lectura en el que esté en ese momento. \\ -nProgress: Nos indica el porcentaje de lectura que lleva del DNIe.|
|**disableDnieReader** | Desactiva la lectura del DNI electrónico por NFC, para  que no se mantenga escuchando.|
|**writeMifareClassicAsync** | Escribe un tag MIFARE CLASSIC. \\ -PARÁMETROS: \\ -1.Array de numero bloques donde se va a escribir. \\ -2.Array de textos a escribir. \\ -3.Nodo que se llamará cuando se complete la escritura. |
|**writeNdefMessageAsync** | Escribe un tag NDEF. \\ -PARÁMETROS: \\ -1.Texto a escribir. \\ -2.Nodo que se llamará cuando se complete la escritura.|
|**readMifareClassicAsync** | Lee un tag MIFARE CLASSIC. \\ -PARÁMETROS: \\ -1.Array de número bloques que se va leer. \\ -2.Nodo que se llamará cuando se complete la Lectura.|
|**readNdefMessageAsync** | Lee un tag NDEF. \\ -PARÁMETROS: \\ -1.	Nodo que se llamará cuando se complete la Lectura.|
\\
=== Ejemplo de XOneNFC ===
<code javascript>
//firma de un PDF con el DNIe.
	var options = {
		readSignatureCertificate : true,
		canNumber : self.MAP_CAN_NUMBER,
		pin : self.MAP_PIN,
		onDnieRead : function(dnieReadResult) {
		    
			//readSignatureCertificate
			dnieReadResult.getSignatureKey()
			dnieReadResult.getSignatureCertificateChain()
		    
			var pdf = createObject("XOnePDF");
			var sSourcePdf = appData.getFilesPath() + "sample.pdf";
			var sSignedPdf = appData.getFilesPath() + "signed.pdf";
			
			pdf.signPdfWithKey(
				sSourcePdf, 
				sSignedPdf, 
				dnieReadResult.getSignatureKey(),
				dnieReadResult.getSignatureCertificateChain()
			);
			pdf.launchPDF(sSignedPdf);
		},

		onDnieReadError : function(sReadError) {
			self.MAP_TEXT = "Error: " + sReadError;
			ui.refreshValue("MAP_TEXT");
		},

		onProgressUpdated : function(sMessage, nProgress) {
			self.MAP_TEXT = "Reading DNIe.\nProgress: " + nProgress + "\n" + sMessage;
			ui.refreshValue("MAP_TEXT");
		}
	  };

var nfc = createObject("XOneNFC");
nfc.enableDnieReader(options);
</code>
\\
=== Ejemplo de writeMifareClassicAsync ===
<code javascript>
var blocks = new Array("1(1)");
var data = new Array("Hola");
var nfc = createObject("XoneNFC");
nfc.writeMifareClassicAsync(blocks, data, "write_mifare_callback");
self.MAP_TEXT = "Pase un tag Mifare por el lector para escribir";
ui.refreshValue("MAP_TEXT");
</code>
<code xml>
//    Nodo que llamará cuando se complete la escritura.

<write_mifare_callback refresh="false">
	<action name="runscript">
		<param name="writeerror" />
		<script language="javascript">
			<!-- Aquí ponemos el código que quedamos que se ejecute cuando se complete la escritura
			     si writeerror viene vacío significa que el tag se escribió correctamente, en caso contrario vendrá la descripción del error.  
			-->
		</script>
	</action>
</write_mifare_callback>
</code>
\\
=== Ejemplo de writeNdefMessageAsync ===
<code javascript>
var nfc = createObject("XoneNFC");
nfc.writeNdefMessageAsync("Hola que tal", "write_ndef_message_callback");
self.MAP_TEXT = "Pase un tag NDEF por el lector para escribir";
ui.refreshValue("MAP_TEXT");
</code>
<code xml>
<!-- Nodo que llamará cuando se complete la escritura. -->

<write_ndef_message_callback refresh="false">
	<action name="runscript">
		<param name="writeerror" />
		<script language="javascript">
			<!-- Aquí ponemos el código que quedamos que se ejecute cuando se complete la escritura. 
			     Si writeerror viene vacío significa que el tag se escribió correctamente, en caso contrario vendrá la descripción del error. 
			-->
		</script>
	</action>
</write_ndef_message_callback>
</code>
\\
=== Ejemplo de readMifareClassicAsync ===
<code javascript>
var blocks = new Array("1(1)");
var nfc = createObject("XoneNFC");
nfc.readMifareClassicAsync(blocks, "read_mifare_callback");
self.MAP_TEXT = "Pase un tag Mifare por el lector para leerlo";
ui.refreshValue("MAP_TEXT");
</code>
<code xml>
<!-- Nodo que se llamará cuando se complete la Lectura. -->

<read_mifare_callback refresh="false">
	<action name="runscript">
		<param name="readerror" />
		<param name="id" />
		<param name="data" />
		<script language="vbscript">
   			<!-- Aquí ponemos el código que quedamos que se ejecute cuando se complete la lectura. -->
			readerror:	"Viene la descripción del error"
			data: 		"Viene un array de textos guardado en el Tag nfc"
		</script>
	</action>
</read_mifare_callback>
</code>
\\
=== Ejemplo de readNdefMessageAsync ===
<code javascript>
var nfc = createObject("XOneNFC");
nfc.readNdefMessageAsync(“read_ndef_callback”);
self.MAP_TEXT = "Pase un tag NDEF por el lector";
ui.refreshValue("MAP_TEXT");
</code>
<code xml>
<!-- Nodo que se llamará cuando se complete la Lectura. -->

<read_ndef_callback refresh="false">
	<action name="runscript">
		<param name="readerror" />
		<param name="id" />
		<param name="data" />
		<script>
			<!-- Aquí ponemos el código que quedamos que se ejecute cuando se complete la lectura. -->
			readerror: 	Viene la descripción del error.
			data: 		Viene el texto guardado en el Tag nfc.
		</script>
	</action>
</read_ndef_callback> 
</code>

\\

/*
|Método 1|**writeNdefFormatableAsync**    |
|Método 2|**isAvailable**     | 
|Método 3|**readNdefMessageAsync**     |
|Método 4|**clearAllPendingOperations**: eliminar todas las operaciones pendientes.    |
|Método 5|**writeMdmTag**      |
|Método 6|**writeNdefMessageAsync**    |
|Método 7|**readMifareClassicAsync**    |
|Método 8|**readMifareUltralightAsync**    |
|Método 9|**installMdm**    |
|Método 10|**disableDnieReader**: deshabilitar lector de DNI electrónico.    |
|Método 11|**writeMifareUltralightAsync**    |
|Método 12|**isEnabled**: está activo.   |
|Método 13|**writeMifareClassicAsync **      |
|Método 15|**<nowiki>DnieReadResult</nowiki>**:  Es el resultado del callback de leer un DNI electrónico con <nowiki>XOneNFC</nowiki>|
*/
\\

====Como implementar el uso de los tags NFC fuera de las aplicaciones XOne====
\\
Los eventos relacionados con la lectura del tag NFC permiten:
  - Escribir
  - Leer con APP XOne abierta
  - Leer con App Cerrada
\\ 
Para controlar el uso de los TAGs NFC desde fuera de las apps XOne debe definirse el TAG por App asociado al generar el framework.\\
\\
<WRAP center round important 60%>
Tener en cuenta de que esto hay que hacerlo en combinación con la última versión del framework editor.
</WRAP>
\\
**Primero, escribir en un tag. Este método requiere de la última versión del framework**
<code javascript>
function writeNdefUriMessage(sUri) {
    let nfc = new XOneNFC();
    nfc.setOnTagDiscoveredCallback(function(tag) {
        tag.setType("ndef");
        tag.connect();
        tag.writeNdefUri(sUri);
        self.MAP_TEXT_JS = "Tag NDEF escrita correctamente. URI: " + sUri;
        ui.refreshValue("MAP_TEXT_JS");
    });
    self.MAP_TEXT_JS = "Pase un tag NDEF por el lector para escribir una URI";
    ui.refreshValue("MAP_TEXT_JS");
}
writeNdefUriMessage('controlfxp://hola_mundo');
</code>

Defines con esto un esquema personalizado, para que android te redirija a tu app.
\\
**Segundo, en la coll empresas, poner esto:**
\\
<code javascript>
    <onnfctagdiscovered show-wait-dialog="false" refresh="false">
        <action name="runscript">
            <param name="tag" />
            <script language="javascript">
                //ui.showToast("Hay tag: " + tag.getHexId());
                tag.setType("ndef");
                tag.connect();
                let dataArray = tag.readNdefText();
                let sText = dataArray[0];
                ui.showToast("Hay texto: " + sText);
            </script>
        </action>
    </onnfctagdiscovered>
</code>
\\
**Por último, se pasa el framework por el nuevo editor, y al leer el framework, donde pone "Esquema de enlaces profundos", cambiar "xone" por "nombre de la app".**

https://www.cgsoft.es/XN/jc/FrameworkEditor.rar\\
https://www.cgsoft.es/XN/jc/XOneAndroidFrameworkHypermedia%20-%20TargetSdkVersion29%20-%20Alpha%20-%20v4.8.9.55dev.apk

{{:wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:nfc1a.png?direct&900|}}
\\
<WRAP center round tip 60%>
La secuencia del uso de los Tags NFC tiene primero la llamada o lectura al TAG, q suele tardar entre 1 a 3 seg, tiempo en el cual no se debe separar el dispositivo del Tag, sino perdería la transmisión y llamada hecha por código. Si además tenemos instaladas en el dispositivo varias app XONe asociadas al Tag, la pantalla mostrará todas las apps relacionadas preguntando al usuario cual seleccionar para utilizar. Para controlar esta espera y errores posibles y si está usando para la implementación del NFC en javascript es conveniente hacerlo a través de **secuencia try-catch.**
</WRAP>
\\
<code javascript>
function startReadNfcTag(objSelf,msg,bHideWait) {
    try {
        let objParent=objSelf.getParent();
        if (isNothing(objParent)) {
            objParent=objSelf;
            objParent.MAP_ELEMENTOID=objSelf.ID;
        } else {
            objParent.MAP_ELEMENTOID=objSelf.ID;
        }
       
        if (isNothing(bHideWait)  || bHideWait!==true) {
            objParent.MAP_SHOWWAIT=1;
            objParent.MAP_WAITMESSAGE=msg;
        } else {
            ui.showToast("Puede acercar el terminal a un TAG para su lectura.");
        }
        var nfc = createObject("XoneNFC");
        nfc.readNdefMessageAsync("readndefcallback");
        ui.refresh("frmWait");
    } catch(err){
        showMsg("NFC no soportado","Su Dispositivo no tiene soporte para lectura NFC.", 1);
        ui.executeActionAfterDelay("cancelnfc",0);
    }
}
</code>
===Borrado de tags NFC===
<code javascript>
function cleanTagNfc(objSelf) {
    let objParent=objSelf.getParent();
    try {
        var nfc = new XOneNFC();
        nfc.writeNdefMessageAsync("##EMPTY_TAG##", "writendefcallback");
        ui.showToast("Aproxime el dispositivo al TAG para realizar el borrado.");
    } catch(err){
        showMsg("NFC no soportado","Su Dispositivo no tiene soporte para lectura NFC.", 1);
        objParent.MAP_ISINTRASAC=0;
        ui.executeActionAfterDelay("cancelnfc",0);
    }
}
</code>
====PinPadPayment====
\\
Objeto para comunicarse con hardware pasarela de pago con tarjeta. Se soportan varios pinpad de //Itos// e //Ingenico//.\\
\\
|< 70% 15% - >|
^ Método                     ^ Descripción                    ^
| **cancelTransaction**      | Ejecutar cancelar Transacción  |
| **connect**                |                                |
| **disconnect**             |                                |
| **flushPrinter**           |                                |
| **partialRefund**          |                                |
| **payment**                |                                |
| **printImage**             |                                |
| **printLine**              |                                |
| **refund**                 |                                |
| **returnLastTransaction**  |                                |
| **returnTransaction**      |                                |
| **sendCommand**            |                                |
| **setDebugMode**           |                                |
| **setFontSize**            |                                |
| **setFontStyle**           |                                |
| **setModel**               |                                |



====XOneOCR====
\\
Objeto para reconocimiento de matrículas y texto genérico.\\
\\
|< 70% 15% - >|
^ Método                ^ Descripción                    ^
| **scanLicensePlate**  | escanear matrículas.           |
| **scanText**          | escanear texto.                |
| **startscan**         | escanear matriculas con REGEX  |
\\
Véase también: [[wiki:2.-desarrollo-app:2.5.-controles-by-xone:ocr:start|Controles by XOne/OCR]]\\
\\
Ejemplo:

<code javascript>
function escanearMatricula(rutaImagen) {
	let ocr = getXOneOCR();
 
	let opciones = {
		//Common
		ocr_img_size_percent : 1.33333333,
		state_id_img_size_percent : 2.0,
		max_plate_width_percent : 100,
		max_plate_height_percent : 100,
		detection_iteration_increase : 1.5,
		detection_strictness : 2,
		max_detection_input_width : 4000,
		max_detection_input_height : 3000,
		opencl_enabled : 1,
		multithreading_cores : 8,
		max_plate_angle_degrees : 15,
		ocr_min_font_point : 6,
		postprocess_min_confidence : 65,
		postprocess_confidence_skip_level : 80,
		postprocess_max_substitutions : 2,
		postprocess_min_characters : 4,
		postprocess_max_characters : 8,
 
		//Debug
		general       : 0,
		timing        : 0,
		state_id      : 0,
		plate_lines   : 0,
		plate_corners : 0,
		char_regions  : 0,
		char_segment  : 0,
		char_analysis : 0,
		color_filter  : 0,
		ocr           : 0,
		postprocess   : 0,
		show_images   : 0,
		pause_on_frame : 0,
 
		//EU
		char_analysis_min_pct : 0.35,
		char_analysis_height_range : 0.15,
		char_analysis_height_step_size : 0.10,
		char_analysis_height_num_steps : 5,
		segmentation_min_box_width_px : 5,
		segmentation_min_charheight_percent : 0.4,
		segmentation_max_segment_width_percent_vs_average : 2.0,
		plate_width_mm : 520,
		plate_height_mm : 110,
		char_height_mm : 80,
		char_width_mm : 53,
		char_whitespace_top_mm : 10,
		char_whitespace_bot_mm : 10,
		template_max_width_px : 184,
		template_max_height_px : 46,
		plateline_sensitivity_vertical : 18,
		plateline_sensitivity_horizontal : 55,
		min_plate_size_width_px : 5,
		min_plate_size_height_px : 5,
		multiline : 1,
		ocr_language : "leu"
	};
	return ocr.scanLicensePlate(rutaImagen, opciones);
	//return ocr.scanLicensePlate(rutaImagen);
}
 
function escanearMatriculaCamara(rutaImagen) {
	let ocr = getXOneOCR();
	let opciones = {
		withCamera : true,
		mode: 1,
		onResult : function(sData) {
			ui.showToast("Result callback: " + sData);
			self.MAP_MATRICULA = sData;
			let ventana = ui.getView(self);
			ventana.refresh("MAP_MATRICULA");
		}
	};
	ocr.scanLicensePlate(rutaImagen, opciones);
}
 
function scanWithV3() {
    let ocr = new XOneOCR();
    let options = {
        mode : 3,
        detections: 5,
        regex:["[a-zA-Z0-9]"],
        onResult : function(sData) {
            ui.showToast("Result callback: " + sData);
			self.MAP_MATRICULA = sData;
			let ventana = ui.getView(self);
			ventana.refresh("MAP_MATRICULA");
        },
    };
    ocr.scanLicensePlate(appData.getFilesPath(), options);
}
 
const REGEX_MATRICULA_MODERNA = "^\\d{4} *[A-Z]{3}";
 
function scanWithRegex() {
    let ocr = new XOneOCR();
    let options = {
        // Pueden ser varias expresiones regulares
        regex    : [REGEX_MATRICULA_MODERNA],
        // Si detectar una matrícula y cerrar, o si continuar hasta que se diga
        oneShot  : false,
        onResult : function(jsResult) {
            self.MAP_MATRICULA = jsResult[REGEX_MATRICULA_MODERNA];
            //Usar jsResult[sLaRegexUsada] si se especificaron varias
			//self.MAP_MATRICULA = jsResult.alltext;
			ui.showToast("Result callback: " + self.MAP_MATRICULA);
        }
    };
    ocr.startScan(options);
}
 
function escanearTexto(rutaImagen) {
	let ocr = getXOneOCR();
	return ocr.scanText(rutaImagen, {
		characterWhitelist: '����������qwertyuiopasdfghjklzxcvbn�mQWERTYUIOPASDFGHJKLZXCVBN�M'
	});
}
 
function getXOneOCR() {
	//return createObject("XOneOCR");
	return new XOneOCR();
}
</code>
====DOMParser====
\\
Para analizar gramaticalmente código XML o HTML almacenado en una cadena de texto y convertirlo en un Documento DOM.\\
\\
|< 70% 15% - >|
^ Método    ^ Descripción                     ^
| ** DOMParser()**   | crear Objeto domParser. (direccion, request, function(sJson) |
| **parseFromString**           | Una vez creado el objeto parseador, puedes parsear XML desde una cadena de texto usando el método        |
| **JSON.parse(userNameNode)**           | parsear el JSON para luego crear un content        |
\\
Ejemplo:
<code javascript>
  // Crear objeto domParser
        var domParser = new DOMParser();

        //parseFromString: Una vez creado el objeto parseador, puedes parsear XML desde una cadena de texto usando el método
        var xmlDoc = domParser.parseFromString(sJson);
        
        //getElementsByTagName: devuelve un lista de todos los elementos con el nombre especificado
        var userNameNodeList=xmlDoc.getElementsByTagName("Get_LineasResult");

        //Si hay algo
        if (userNameNodeList.length>0)
        {
            //Obtener el valor del primer elemento (en mi caso viene un json que luego parseo)
            var userNameNode = userNameNodeList[0].getTextContent();

            // parsear el JSON para luego crear un content
            var objRespuesta = JSON.parse(userNameNode);
           
            if (objRespuesta)
            {
                if (objRespuesta.length>0)
                {
                    let coll=objself.getContents("ContentLineas");
                    coll.unlock();
                    coll.loadAll();
                   
                    for (var i=0; i<objRespuesta.length; i++)
                    {
                        //ui.msgBox("RUTA: "+objRespuesta[i].route_id ,"Aviso",0);
                        let obj=coll.createObject();
                        coll.addItem(obj);
                        obj.ID_RUTA=objRespuesta[i].route_id;
                        obj.NOMBRE_CORTO=objRespuesta[i].route_short_name;
                        obj.NOMBRE_LARGO=objRespuesta[i].route_long_name;
                        obj.DESCRIPCION_LARGA=objRespuesta[i].descripcionlarga;
                        obj.TOKEN=token;

                    }
                    coll.lock();
                    ui.refresh("ContentLineas");
                }
              
    }, function() {
        //ui.hideWaitDialog();
        msgBox("Error de conexión","Aviso",0);
    });


</code>

====XOnePrinter====
Objeto para controlar hardware de impresora.\\
\\
|< 70% 15% - >|
^ Método                               ^ Descripción                                     ^
| **beginFooter**                      | Inicio Footer                                   |
| **beginHeader**                      | Inicio Header                                   |
| **checkPrinterStatus**               | Chequea status de la Impresora                  |
| **connect**                          | Conectar                                        |
| **cutPaper**                         | Truncar página                                  |
| **disableBluetooth**                 | Deshabilitar Bluetooth Impresora                |
| **disableWiFi**                      | Deshabilitar Wifi Impresora                     |
| **disconnect**                       | Desconectar Impresora                           |
| **enableBluetooth**                  | Habilitar Bluetooth Impresora                   |
| **enableWiFi**                       | Habilitar Wifi Impresora                        |
| **endFooter**                        | Fin del Footer impresión                        |
| **endHeader**                        | Fin del Header impresión                        |
| **getAddress**                       | Obtener dirección IP Printer                    |
| **getDiscoverableBluetoothDevices**  | Obtener dispositivos dipsonibles por Bluetooth  |
| **getMode**                          | Obtener Modo printer                            |
| **getStoredPrinterInfo**             | Ontener Info Printer en Memoria                 |
| **lineFeed**                         | Salto de página                                 |
| **print**                            | Imprimir                                        |
| **printBarcode**                     | Imprimir código de barra                        |
| **printImage**                       | Imprimir imagen                                 |
| **printLine**                        | Imprimir línea                                  |
| **printLineCentered**                | Imprimir línea centrada                         |
| **printLineRight**                   | Imprimir línea alineada a la derecha            |
| **printPDF**                         | Imprimir PDF                                    |
| **reset**                            | Resetear Impresora                              |
| **selectBluetoothPrinter**           | Seleccionar Impresora por Bluetooth             |
| **selectNetworkedPrinter**           | Seleccionar Impresora por Red                   |
| **sendCommands**                     | Enviar Comando                                  |
| **setBluetoothAuthentication**       | Establecer Autenticación por Bluetooth          |
| **setCustomPaperHeight**             | Personalizar Alto papel Impresora               |
| **setCustomPaperWidth**              | Personalizar Ancho papel Impresora              |
| **setDebugMode**                     | Establecer Modo para Debug                      |
| **setDelay**                         | Establecer espera                               |
| **setDiscoverable**                  | Establecer Disponible                           |
| **setDriver**                        | Definir driver                                  |
| **setEncoding**                      | Definir Modo Encoding                           |
| **setFeedMode**                      | Definir Modo de Retorno Errores                 |
| **setFont**                          | Definir Fuente Impresión                        |
| **setFontColor**                     | Definir Color Fuente Impresión                  |
| **setFontSize**                      | Definir Tamaño Fuente Impresión                 |
| **setFontStyle**                     | Definir Estilo Fuente Impresión                 |
| **setIPAddress**                     | Definir Dirección IP Impresora                  |
| **setMACAddress**                    | Definir Dirección de MAC Impresora              |
| **setMaxCharacterWidth**             | Definir Ancho Max de Caracteres                 |
| **setMaxLinesPerPage**               | Definir Máximo de líneas por páginas            |
| **setModel**                         | Definir Modelo                                  |
| **setPaperSize**                     | Definir Tamaño de Hoja                          |
| **setPIN**                           | Establecer PIN Impresión                        |
| **setPort**                          | Definir puerto                                  |
| **useStoredPrinter**                 | Usar Almacenamiento Printer                     |
\\
===== Ejemplo XOnePrinter =====
\\
<code javascript>
 var mPrinter = createObject("XOnePrinter");
 mPrinter.setDebugMode(false);
 mPrinter.setDelay(0);
</code>
\\


==== connect ====
\\
Función para conectar la impresora
\\
<code javascript>
var printer01 = createObject("XOnePrinter");
printer01.connect();
</code>
\\
==== setDriver====
\\
Establece el driver de la impresora. Valores admitidos: datecs, zebra, epson, brother, serial.
\\
<code javascript>
var printer01 = createObject("XOnePrinter");
printer01.setDriver("datecs");
</code>
\\

==== print====

^ Tipo                   | Función|
^ Acceso                 | Escritura|
^ Parámetros             | string: Texto a imprimir.|
^ Tipo de Dato devuelto  | Ninguno|
\\
Imprime la cadena de texto que se le pasa como parámetro. Al finalizar se mantiene en la posición en que terminó de imprimir, no hace cambio de línea. Útil si se desea imprimir más de un campo en la misma línea.\\
\\
**Ejemplo de Uso:**
<code javascript>
printer01.print("Observaciones: ");
printer01.print(self.OBSERVACIONES);
</code>
\\

==== printLine====

^ Tipo                   | Función|
^ Acceso                 | Escritura|
^ Parámetros             | string: Texto a imprimir.|
^ Tipo de Dato devuelto  | Ninguno|
\\
Imprime la cadena de texto que se le pasa como parámetro en una línea. Al finalizar se posiciona en la siguiente línea.\\
\\
**Ejemplo de Uso:**
<code javascript>
printer01.printLine("Texto a imprimir");
</code>
\\


==== printLineCentered====

^ Tipo                   | Función|
^ Acceso                 | Escritura|
^ Parámetros             | string: Texto a imprimir.|
^ Tipo de Dato devuelto  | Ninguno|
\\
Imprime la cadena de texto que se le pasa como parámetro en una línea centrada. Al finalizar se posiciona en la siguiente línea.\\
\\
**Ejemplo de Uso:**
<code javascript>
printer01.printLineCentered("Texto a imprimir");
</code>
\\
===== Manejo de Errores  =====
\\
El manejo de errores se realiza a través del objeto **appData.Error** que describimos a continuación de forma independiente, debido a su importancia. Los valores que pueda tomar este objeto error pueden ser manejados durante la ejecución de la aplicación. Las funciones disponibles son las siguientes:\\
\\
==== getNumber ====
\\
^ Tipo		 	|Propiedad|
^ Acceso		|Lectura|
^ Tipo de Dato devuelto |Entero|
^ Plataforma		|Win32, Web, .NET, .NET CF, WM (2003, 2005, 6.0, 6.5) Blackberry (5.0), iPhone, Linux, MC+, Symbian (3ed, 5ed)|

\\
Contiene el código del último error ocurrido en la maquinaria. Cero indica que no hay error.\\
\\
Valores negativos suelen indicar errores, códigos positivos suelen indicar situaciones “anormales” pero que no representan errores fatales. \\
\\
<code javascript>
var coll=appData.getCollection("ArticulosBuscar");
var filtro=coll.getFilter();
coll.setFilter("CODARTICULO="+vb.cstr(articulo));
coll.startBrowse();
if (appData.error().getNumber()!=0 )
{
	appData.getUserInterface().msgBox("Error " + appData.error().getDescription(),"ERROR",0);
	appData.error().clear();
}
else
{
.....
}	
 
coll.setFilter(filtro);
coll.endBrowse();
</code>
\\
==== getDescription ====
\\
^ Tipo		 	|Propiedad|
^ Acceso		|Lectura|
^ Tipo de Dato devuelto |Texto|
^ Plataforma		|Win32, Web, .NET, .NET CF, WM (2003, 2005, 6.0, 6.5) Blackberry (5.0), iPhone, Linux, MC+, Symbian (3ed, 5ed)|
\\
Descripción del último error ocurrido en la maquinaria.\\
\\
<code javascript>
var coll=appData.getCollection("ArticulosBuscar");
var filtro=coll.getFilter();
coll.setFilter("CODARTICULO="+vb.cstr(articulo));
coll.startBrowse();
if (appData.error().getNumber()!=0 )
{
	appData.getUserInterface().msgBox("Error " + appData.error().getDescription(),"ERROR",0);
	appData.error().clear();
}
else
{
.....
}	
 
coll.setFilter(filtro);
coll.endBrowse();
</code>
\\
====getFailedSql====
\\
^ Tipo		 	|Propiedad|
^ Acceso		|Lectura|
^ Tipo de Dato devuelto |Texto|
^ Plataforma		|Win32, Web, .NET, .NET CF, WM (2003, 2005, 6.0, 6.5) Blackberry (5.0), iPhone, Linux, MC+, Symbian (3ed, 5ed)|
\\

Si el error de la última operación se debe a un SQL que ha fallado, la sentencia en cuestión está en esta propiedad del objeto de error.\\
\\
Algunos métodos pueden optar también por dejar información en esta propiedad, pero lo normal es que si no hay SQLs implicados en el error, esta propiedad esté vacía.\\
\\
<code javascript>
var coll=appData.getCollection("ArticulosBuscar");
var filtro=coll.getFilter();
coll.setFilter("CODARTICULO="+vb.cstr(articulo));
coll.startBrowse();
if (appData.error().getNumber()!=0 )
{
	appData.getUserInterface().msgBox("Error " + appData.error().getDescription(),"ERROR",0);
	appData.getUserInterface().msgBox("SQL fallida " + appData.error().getFailedSql(),"SQL",0);
	appData.error().clear();
}
else
{
.....
}	
 
coll.setFilter(filtro);
coll.endBrowse();
</code>
\\
==== clear ====
Limpia las variables del objeto de error, dejándolo listo para la siguiente operación.\\
\\
<code javascript>
var coll=appData.getCollection("ArticulosBuscar");
var filtro=coll.getFilter();
coll.setFilter("CODARTICULO="+vb.cstr(articulo));
coll.startBrowse();
if (appData.error().getNumber()!=0 )
{
	appData.getUserInterface().msgBox("Error " + appData.error().getDescription(),"ERROR",0);
	appData.getUserInterface().msgBox("SQL fallida " + appData.error().getFailedSql(),"SQL",0);
	appData.error().clear();
}
else
{
.....
}	
 
coll.setFilter(filtro);
coll.endBrowse();
</code>
\\
===== BarCode Generator =====
\\
Sirve para generar códigos de barra de varios tipos.\\
\\
|< 65% 25% - >|
^ Métodos                                                                                                                          ^ Descripción                                                                                                                        ^
| **Generate**                                                                                                                     | Genera el código de barras del texto que se indique por parámetro.                                                                 |
| **setDestinationFile**                                                                                                           | Define la ruta de destino. (Si no se le pone la ruta física, el framework lo buscará en files).                                    |
| **setResolution**                                                                                                                | Indica la resolución a la que se va a generar la imagen con el código de barras. (Parámetros: ancho y alto de la imagen).          |
| **setRotation**                                                                                                                  | Indica el grado de rotación de la imagen.                                                                                          |
| **setType**                                                                                                                      | Indica el tipo de código de barra que generará: \\  -codabar,code128,code39,code93,datamatrix,qrcode,upca,upce,ean13,ean8,pdf417.  |
^ Funciones implementadas para Barcode                                                                                                                                                                                                                                 ||
| **Generar Código**                                                                                                               | generateBarcode(sTargetFile, sType, nRotation, sText)                                                                              |
| **Lanzar Cámara**                                                                                                                | lanzarCamara()                                                                                                                     |
| **Leer de Fichero**                                                                                                              | leerDeFichero()                                                                                                                    |
| **Leer de Cámara**                                                                                                               | leerDeCamara                                                                                                                       |
| **Leer de Cámara (marco)**                                                                                                       | leerDeCamaraMarco(objeto)                                                                                                          |
| **Leer de Hardware (manual)**                                                                                                    | manual()                                                                                                                           |
| **Leer de Hardware (continuo)**                                                                                                  | continuous()                                                                                                                       |
| **Leer de Hardware (detener)**                                                                                                   | stop()                                                                                                                             |
| **Añadir Perfil [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:start#datawedge|Datawedge]]**  | addDataWedgeProfile()                                                                                                              |
| **Generar QRCode**                                                                                                               | generateQrCode(sText)                                                                                                              |
\\
==== Ejemplos Métodos Barcode ====

\\
<code javascript>
var tipoCodigo,attachFile,rotation,text;
tipoCodigo = “code128”;
attachFile = “barcode.png”;
rotation = 0;
text = “Xone Prueba”;
if(!tipoCodigo) {
 	throw "Seleccione un tipo de código";
} else {
 	ui.showToast("Generando código de tipo " + tipoCodigo + "...");
}
var generator = createObject("BarcodeGenerator");
generator.setType(tipoCodigo);
generator.setResolution(640, 480);
generator.setDestinationFile(attachFile);
if (rotation != 0) {
 	generator.setRotation(rotation);
}
generator.generate(text);
ui.openFile(attachFile);
</code>
\\

==== Ejemplos Funciones Barcode ====

\\
<code javascript>
function lanzarCamara() {
	ui.startCamera("MAP_ATTACH", "photo");
}

function generarCodigo() {
	if (!self.MAP_TIPOCODIGO) {
		throw "Seleccione un tipo de código";
	} else {
		ui.showToast("Generando código de tipo " + self.MAP_TIPOCODIGO + "...");
	}
	let generator = new BarcodeGenerator();
	generator.setType(self.MAP_TIPOCODIGO);
	generator.setResolution(640, 480);
	generator.setDestinationFile(self.MAP_ATTACH);
	if (self.MAP_ROTACION !== 0) {
		generator.setRotation(self.MAP_ROTACION);
	}
	generator.generate(self.MAP_TEXTO);
	ui.openFile(self.MAP_ATTACH);
}

function generateBarcode(sTargetFile, sType, nRotation, sText) {
	if (!sType) {
		throw "Seleccione un tipo de código";
	} else {
		ui.showToast("Generando código de tipo " + sType + "...");
	}
	let generator = new BarcodeGenerator();
	generator.setType(sType);
	generator.setResolution(640, 480);
	generator.setDestinationFile(sTargetFile);
	if (nRotation > 0) {
		generator.setRotation(nRotation);
	}
	generator.generate(sText);
	ui.openFile(sTargetFile);
}

/**
 * BarcodeGenerator pone por defecto los siguientes valores:
 * generator.setType("qrcode");
 * generator.setResolution(300, 300);
 * generator.setDestinationFile("code_[UUID aleatorio].png");
 * 
 * Luego algo así sirve para un QRCode básico
 */
function generateQrCode(sText) {
	let sFile = new BarcodeGenerator().generate(sText);
	ui.openFile(sFile);
}

/**
 * Primer parámetro: Función callback que recibirá los resultados
 * Segundo parámetro: Limitar a este tipo de código para mejorar la velocidad
 * de escaneo (null o vacío para escanear todos, es menos eficiente)
 * Tercer parámetro: Dejar que el usuario confirme si el código y la foto
 * resultante es correcta o no
 */
function leerDeCamara() {
	if (codeScanner === undefined) {
  		throw "El objeto CodeScanner no está disponible";
  	}
  	codeScanner.startCamera(function callbackScanner(codigo, fichero) {
  		ui.msgBox("Función callback: El código es: " + codigo + " y el fichero: " + fichero, "", 0);
  		self.MAP_ATTACH = fichero;
  		self.MAP_IMAGEN = fichero;
  		ui.refresh("MAP_ATTACH", "MAP_IMAGEN");
  	}, self.MAP_TIPOCODIGO, true);
}

function leerDeCamaraMarco(objeto) {
	if (codeScanner === undefined) {
  		throw "El objeto CodeScanner no está disponible";
  	}
  	let options = {
  		codeType : objeto.MAP_TIPOCODIGO,
  		confirmPicture : false,
  		useScanRectangle : true,
  		saveFile : false,
  		callback : function callbackScanner(codigo, fichero) {
	  		ui.msgBox("Función callback: El código es: " + codigo + " y el fichero: " + fichero, "", 0);
	  		objeto.MAP_ATTACH = fichero;
	  		objeto.MAP_IMAGEN = fichero;
	  		ui.refresh("MAP_ATTACH", "MAP_IMAGEN");
	  	}
  	};
  	codeScanner.startCamera(options);
}

function leerDeFichero() {
	if (codeScanner === undefined) {
		throw "El objeto CodeScanner no está disponible";
	}
	let sResult = codeScanner.scanFromFile(self.MAP_ATTACH, self.MAP_TIPOCODIGO);
	ui.showToast("El valor escaneado es: " + sResult);
}
  
function manual() {
	let params = {
		mode: "manual",
		onCodeScanned: function(sCode) {
			ui.showToast("Código: " + sCode);
		}
	};
	ui.startScanner(params);
}

function continuous() {
	let params = {
		mode: "continuous",
		onCodeScanned: function(sCode) {
			ui.showToast("Código: " + sCode);
		}
	};
	ui.startScanner(params);
}
  
function stop() {
	let params = {
		mode: "stop",
	};
	ui.startScanner(params);
}


</code>

==== Datawedge ====
Para añadir perfil Datawedge por script usaremos la función addDataWedgeProfile() ejemplificada a continuación, pero en ciertos dispositivos se necesita configurar manualmente para lograr la integración con aplicaciones XOne. [[wiki:2.-desarrollo-app:2.4.-scripting-modelo-objetos:b.-objetos-complementarios:configurar_scanner:start|Configurar Scanner Códigos Barra SYMBOL Android]]
\\
<code javascript>
function addDataWedgeProfile() {
    let sDeviceOs = appData.getGlobalMacro("##DEVICE_OS##");
    if (sDeviceOs != "android") {
        return;
    }
    let mainBundle = new Bundle();
    mainBundle.PROFILE_NAME = "XOne";
    mainBundle.PROFILE_ENABLED = "true";
    mainBundle.CONFIG_MODE = "CREATE_IF_NOT_EXIST";
    mainBundle.RESET_CONFIG = "true";
    let appBundle = new Bundle();
    appBundle.PACKAGE_NAME = systemSettings.getPackageName();
    appBundle.ACTIVITY_LIST = ["*"];
    mainBundle.APP_LIST = [appBundle];
    let pluginConfig = new Bundle();
    pluginConfig.PLUGIN_NAME = "BDF";
    pluginConfig.RESET_CONFIG = "true";
    pluginConfig.OUTPUT_PLUGIN_NAME = "KEYSTROKE";
    let paramBundle = new Bundle();
    paramBundle.bdf_enabled = "true";
    paramBundle.bdf_send_enter = "true";
    pluginConfig.PARAM_LIST = paramBundle;
    mainBundle.PLUGIN_CONFIG = pluginConfig;
    let intent = new AndroidIntent();
    intent.setAction("com.symbol.datawedge.api.ACTION");
    intent.putBundleExtra("com.symbol.datawedge.api.SET_CONFIG", mainBundle);
    intent.sendBroadcast();
}

</code>
===== Code Scanner =====
\\
Lector de código de barras. Objeto reservado del framework.\\
\\
|< 70% 15% - >|
^ Métodos    ^ Descripción                     ^
|**scanFromFile**:| <WRAP>
Lee el código de barras a partir de un fichero. 
{| class="wikitable" style="width: 60%; align:center;"
|-
! scope="col" style="width:50%; | Parámetro 
! scope="col" style="width:50%; | Descripción  
|-
| **Fichero** || Ruta del fichero a leer destino (Si no se le pone la ruta física, el framework lo buscara en files).
|- 
| **Código** || Tipo de código que va a interpretar.
|}
</WRAP>|
|**startCamera**| <WRAP>
Lanza la cámara para leer el código de barras. 
{| class="wikitable" style="width: 60%; align:center;"
|-
! scope="col" style="width:50%; | Parámetro 
! scope="col" style="width:50%; | Descripción  
|-
| **Callback** || Se define una función a la que se llamará cuando le de a Ok en la cámara.
|- 
| **Código** || Tipo de código que va a interpretar.
|}
</WRAP>|
\\
=== Ejemplo scanFromFile ===
<code javascript>
   var sResult = codeScanner.scanFromFile(“barcode.png”, “code128”);
</code>
\\
=== Ejemplo startCamera ===
<code javascript>
codeScanner.startCamera(function callbackScanner(codigo, fichero) {
	// El parámetro código, es el código detectado en  la imagen.
 	// El parámetro fichero, es la ruta del ficheros que se guarda. 
 }, “code128”);
</code>
\\
==== startScanner ====
\\
Método de UI que lanza el escáner en dispositivos que dispongan de él.\\

|< 70% 15% - >|
^ Métodos    ^ Descripción                     ^
|**startScanner**| <WRAP>
Lanza el escáner disponible en el dispositivo. 
{| class="wikitable" style="width: 70%; align:center;"
|-
! scope="col" style="width:20%; | Parámetros 
! scope="col" style="width:80%; | Definición 
|-
|**mode**|| define el modo de lanzamiento del escáner.\\ <wrap hi>Valores: manual, continuous ó stop</wrap>.
|-
|**onCodeScanned**|| función callback a la que se llamará cuando se detecte el código con el escáner.
|-
|}
</WRAP>|
\\
**Ejemplo**:\\
<code javascript>
var params = {
	mode: "manual",
	onCodeScanned: function(sCode) {
		ui.showToast("Código: " + sCode);
	}
};

ui.startScanner(params);
</code>
\\

===== Control Chronometer =====

|< 70% 15% - >|
^ Métodos    ^ Descripción                                                         ^
| **start**  | Inicializa el chronómetro del dispositivo                           |
| **stop**   | Detiene el chronómetro del dispositivo, anteriormente inicializado  |
Lanza el chronómetro disponible en el dispositivo. 

Ejemplo:

<code javascript>

<coll name="Menu" notab="true" special="true">
    <group name="General" id="1" align="center">
        <prop name="MAP_T"     type="T" visible="7" labelwidth="0"  width="80%" height="10%" />
        <prop name="MAP_START" type="B" visible="7" labelwidth="10" width="80%" height="10%" title="Start" onclick="start('MAP_T');" />
        <prop name="MAP_STOP"  type="B" visible="7" labelwidth="10" width="80%" height="10%" title="Stop"  onclick="stop('MAP_T');" />
    </group>
</coll>


function start(sPropName) {
    let control = getControl(sPropName);
    if (!control) {
        return;
    }
    /**
     * Los parámetros son opcionales.
     */
    let jsOptions = {
        fromDate  : new Date(),
        dateFormat: "mm:ss"
    };
    control.startChronometer(jsOptions);
}

/**
 * Importante parar el cronómetro cuando ya no se use o se salga de la ventana.
 */
function stop(sPropName) {
    let control = getControl(sPropName);
    if (!control) {
        return;
    }
    control.stopChronometer();
}

</code>

=====XOnePDF=====
\\
<code javascript>
var pdf = createObject("XOnePDF");
</code>
\\
|< 65% - >|
^ Métodos    ^ Descripción                     ^
|**signPdfWithKey()** | para firmar el PDF con DNIe.|
|**Parámetros para la firma Con DNIe** | -Path del fichero pdf que se va a firmar. \\ -Path del fichero final cuando se firme. \\ -Clave de la firma del DNIe. \\ -Certificado del DNIe.|
\\
\\
|< 65% - >|
^ PARÁMETROS PARA LA FIRMA CON KEYSTORE ^
|Path del fichero PDF que se va a firmar.
|Path del fichero final cuando se firme.|
|Path del fichero <nowiki>KeyStore</nowiki>. (keyStore).|
|Password del <nowiki>KeyStore</nowiki>. (keyStorePassword).|
|Alias de la clave <nowiki>(KeyAlias)</nowiki>.|
|Password del alias <nowiki>(KeyPassword)</nowiki>.|

\\
Véase También: [[wiki:2.-desarrollo-app:2.5.-controles-by-xone:generacion-de-pdfs-mediante-xonescript:start|Generación de PDFs mediante XOneScript]]

=====Singletons de script sin createObject=====
\\
====HttpRuntimeObject====
\\
Sirve para hacer llamadas http **post** y **get** a servicios web y retornar resultado.\\
\\
|< 65% - >|
^ Métodos    ^ Descripción                     ^
| **post**   | Llamada POST a una página web   |
| **get**    | Llamada GET a una página web    |
\\
===Ejemplo1:===
\\
<code javascript>
$http.post("URL", function(sJson) {    /*función que se llama cuando la respuesta es correcta.*/
		var objRespuesta = JSON.parse(sJson);
		ui.showToast("OK! " + sJson);
	}, function() {    /*función que se llama cuando la respuesta no es correcta.*/
		ui.showToast("No OK!");
	}
);
</code>                
\\ 

===Ejemplo 2===
<code javascript>
$http.post("https://maps.googleapis.com/maps/api/geocode/json?address=Cardenal%20Cisneros", function(sJson) {
	var objRespuesta = JSON.parse(sJson);
	ui.showToast("OK! " + sJson);
    }, function() {
	ui.showToast("No OK!");
});
</code>
\\ 
====SystemSettings====
\\
Devuelve distintos tipos de información del sistema.\\
Objeto **systemSettings**\\
\\
|< 70% 20% - >|
^  Método                                  ^  Descripción                                                                                                                                                                         ^
| **setBrightness**                        | Establece el valor del brillo de la pantalla del dispositivo.                                                                                                                        |
| **getBrightness**                        | Obtiene el valor del brillo de la pantalla del dispositivo.                                                                                                                          |
| **setWallpaper**                         | Establece una imagen de fondo en el dispositivo                                                                                                                                      |
| **getWallpaper**                         | Obtiene el valor de la imagen establecida como fondo del dispositivo                                                                                                                 |
| **setBrightnessMode**                    | Establece el modo del brillo en el dispositivo, manual o automático (Android). En el caso de automático es a través de la iluminación solar o artificial que recibe el dispositivo.  |
| **getBrightnessMode**                    | Obtiene el valor del Modo para brillo establecido en el dispositivo.                                                                                                                 |
| **isPasswordSecured**                    | Devuelve true o false si password es segura                                                                                                                                          |
| **getnetworktime**                       | Devuelve tiempo real de conexión al server                                                                                                                                           |
| **ispermissiongranted**                  | Devuelve si han sido concedidos los permisos solicitados                                                                                                                             |
| **getGrantedPermissions**                | Devuelve los permisos concedidos                                                                                                                                                     |
| **getNotGrantedPermissions**             | Devuelve los permisos denegados                                                                                                                                                      |
| **requestPermissions**                   | Permite solicitar permisos al dispositivo                                                                                                                                            |
| **isIgnoringBatteryOptimazations**       | Devuelve true o false si no está habilitada la opción de optimizar batería del dispositivo                                                                                           |
| **requestIgnoringBatteryOptimazations**  | Devuelve true o false si se ha concedido la optimización de batería del dispositivo                                                                                                  |
| **isAirplaneMode**                       | Devuelve true o false si el modo avión está habilitado                                                                                                                               |
| **clearJavascriptCache**                 | Devuelve true si limpia cache                                                                                                                                                        |
| **clearBitmapCache**                     | Devuelve true si limpia bitmap cache                                                                                                                                                 |
| **clearApplicationData**                 | Devuelve true si limpia cache de datos de la aplicación                                                                                                                              |
| **checkMarketUpdate**                    | Verifica si existe nueva versión del Market (Android)                                                                                                                                |
| **getSharedUserId**                      | Devuelve el ID de usuario que se ha compartido                                                                                                                                       |
| **getAndroidVersion**                    | Devuelve la versión de Android del Dispositivo                                                                                                                                       |
| **getApiLevel**                          | Devuelve API del Dispositivo                                                                                                                                                         |
| **getExternalStoragePath**               | Obtiene ruta de almacenamiento externo del dispositivo                                                                                                                               |
| **getGalleryPath**                       | Obtiene Ruta de la Galería del Dispositivo                                                                                                                                           |
| **getDownloadsPath**                     | Obtiene Ruta de descarga del Dispositivo                                                                                                                                             |
| **getHardwareIds**                       | Obtiene el Ids del Hardware del Dispositivo                                                                                                                                          |
\\
<code javascript>
//Para recoger el valor:

self.MAP_BRILLO = systemSettings.getBrightness();

//Para asignar el valor:

systemSettings.setBrightness(self.MAP_BRILLO);
</code>
\\
<code javascript>

function getHardwareIds() {
    let ids = systemSettings.getHardwareIds();
    let sMessage = "Device ID count: " + ids.deviceIdCount + "\n";
    for (let i = 0;i < ids.deviceIdCount;i++) {
        sMessage = sMessage + "Device ID " + i + ": " + ids["deviceId" + i] + "\n";
    }
    sMessage = sMessage + "Wifi MAC address: " + ids.wifiMacAddress + "\n";
    sMessage = sMessage + "Android ID: " + ids.androidId;
    ui.msgBox(sMessage, "Mensaje", 0);
}
</code>
\\
<code javascript>

function checkMarketUpdate() {
    let bResult = systemSettings.checkMarketUpdate();
    ui.showToast("Update: " + bResult);
}
</code>
\\

|< 70% 20% - >|
^        Variable         ^    Descripción    ^
|**GMT_OFFSET** | devuelve la zona horaria.|
|Y todas las que se definen en la siguiente página: https://developer.android.com/reference/android/provider/Settings.Global.html ||
\\
<code javascript>
var tZ = systemSettings.GMY_OFFSET;
var adb = systemSettings.AIRPLANE_MODE_ON;
</code>
\\ 



====Payment====
\\
Para pagos con el Play Store.\\
Objeto XonePayment\\
\\
|< 70% 20% - >|
^        Método         ^    Descripción    ^
| **requestPayment**:   | solicitar pago.   |
\\ 
====FingerPrintManager====
\\
**Manejador de Huella Dactilar.**
\\
Objeto XOneFingerprintManager\\

\\

Este objeto te permite controlar los eventos que provoca el lector de Huellas dactilares, funciona en versiones 6.x.x o superior.
\\
|< 70% 20% - >|
^  Método                        ^  Descripción                                                                                                                        ^
| **hasenrolledfingerprint**     | Habilita login por huella dactilar para la App                                                                                      |
| **ishardwareavailable**        | Chequear si el dispositivo tiene lector de huella disponible                                                                        |
| **launchFingerprintSettings**  | Lanza la ventana de seguridad donde se encuentra la opción de registrar las huellas dactilares.                                     |
| **listen**                     | Ponemos al objeto en escucha de un posible evento que lance el lector de Huellas dactilares. Ejemplo: fingerprintManager.listen();  |
| **setCallback**                | Para registrar La configuración de eventos. Ejemplo: fingerprintManager.setCallback(params);                                        |
| **stoplistening**              | Detenemos la escucha.                                                                                                               |

\\
Ejemplo:
\\
<code javascript>
//	1.	En primer lugar definimos lo que queremos hacer dependiendo de los eventos que se disparen.
//		Definimos los diferentes eventos que pueden ocurrir en el objeto fingerprintManager.

var params = {

	// Este evento se llamara cuando la huella exista en el telefono.
	onSuccess: function(result) {
		// Esto significa que la huella existe en el dispositivo

		// result.getPublicKey(); esto nos devuelve la clave de la huella dactilar, 
		// para que nosotros la podamos usar donde sea , por ejemplo asociarla a un usuario para hacer el Login con huella dactilar.

		var sPublicKey = result.getPublicKey();

		/* Aquí ponemos lo que queramos hacer … */

	},

	// Este evento se llamara cuando la huella no exista en el telefono o cuando ocurra algun tipo de error.
	onFailure: function(nError, sErrorMessage) {

		// nError: Numero de error
		// sErrorMessage: Descripción del error.
		// Si no existe nError o no está definido quiere decir que no ha ocurrido un error, 
		// simplemente no ha encontrado registrada la huella dactilar en el dispositivo.

		/* Aquí ponemos lo que queramos hacer … */

	}
};

//	2.	Después registramos la configuración de los eventos en el objeto:

	fingerprintManager.setCallback(params);

//	3.	Por último ponemos al objeto en escucha de un posible evento con el lector de huellas dactilares.

	fingerprintManager.listen();
</code>
 
\\

<WRAP box>
<code javascript>
<coll name="LoginColl" title="login" filter="" sort="" special="true">
    <group name="General" id="1" class="xnFondoGropoLoginC">
        <frame name="frmGeneral" class="xnBackground2C">
            <frame name="frmImage" tmargin="242p" class="xnImageFrameLoginC">
                <prop name="MAP_IMG_IMAGE" type="IMG" visible="1" class="xnImageLoginC" />
                <prop name="MAP_NUMALUMNOS" type="TL" class="" visible="1" title="Cantidad de Alumnos" bgcolor="#00000000" forecolor="#333333" width="96%" height="80p" lmargin="2%" tmargin="0" bmargin="0" rmargin="2%" align="center" />
            </frame>
            <frame name="frmError" disablevisible="MAP_T_ERROR=''" floating="true" width="100%" left="0" top="0" align="center|top">
                <prop name="MAP_T_ERROR" type="T" tooltip="Email" visible="1" tmargin="55p" class="xnTituloErrorC"/>
            </frame>
            <prop name="MAP_T_USUARIO" type="T" expanded-hint-color-focus="#ffffff" expanded-hint-color="#ffffff" tooltip-forecolor="#111111" floating-tooltip="true" tooltip="Usuario" visible="1" tmargin="12p" class="xnTextoEditableC"/>
            <prop name="MAP_T_CONTRASENNA" type="X" expanded-hint-color-focus="#ffffff" expanded-hint-color="#ffffff" tooltip-forecolor="#111111" floating-tooltip="true" tmargin="15p" tooltip="Contraseña" visible="1"  class="xnTextoEditableC"/>
            <prop name="MAP_BT_CANCELAR"  method="executenode(onback)" tmargin="45p" type="B" title="Cancelar" visible="1" class="xnBotonCancelarC" />
            <frame name="frmHuella" disablevisible="MAP_HUELLADACTILAR=0" tmargin="45p"  lmargin="10p" bgcolor="#F7F7F7" width="127p" height="127p" newline="false"  border-corner-radius="30">
                <prop name="MAP_BT_HUELLA"  method="executenode(aceptarHuella)" type="B" labelwidth="0" width="96%" height="96%" tmargin="2%" lmargin="2%" visible="1" img="huelladactilar_black.png"/>    
            </frame>
            <prop name="MAP_BT_ACEPTAR"  method="executenode(aceptar)" tmargin="45p" lmargin="10p" type="B" title="Aceptar" visible="1" newline="false" class="xnBotonAceptarC"/>
            <prop name="MAP_BT_OLVIDAR_CONTRASENNA" tmargin="17p" height="82p" type="B" title="¿Has olvidado tu contraseña?" method="executenode(irGrupo(2))" visible="1" class="xnBotonOlvidarContrasennaC" />
            <prop name="MAP_T_VERSIONES" type="T" tmargin="54p" visible="1" text-align="center" class="xnTituloVersionesC"/>    
        </frame>
    </group>
    <group name="OlvidarContrasenna" id="2" class="xnFondoGropoLoginC">
        <frame name="frmGeneral2" class="xnBackground2C">
            <frame name="frmImage2" tmargin="242p" class="xnImageFrameLoginC">
                <prop name="MAP_IMG_IMAGE_OC" type="IMG" visible="1" class="xnImageLoginC"  />
            </frame>
            <prop name="MAP_T_DESCIPCION_OC" type="T" tmargin="54p" visible="1" lines="2" class="xnTituloTLoginC" text-align="center" />    
            <frame name="frmErrorOC" floating="true" width="100%" left="0" top="0" align="center|top">
                <prop name="MAP_T_ERROR_OC" disablevisible="MAP_T_ERROR_OC=''" type="T" tmargin="55p" visible="1" class="xnTituloErrorC" />
            </frame>
            <prop name="MAP_T_USUARIO_OC" type="T" tmargin="24p" expanded-hint-color-focus="#ffffff" expanded-hint-color="#ffffff" tooltip-forecolor="#111111" floating-tooltip="true" tooltip="Usuario" visible="1" class="xnTextoEditableC" />
            <prop name="MAP_BT_VOLVER_OC" method="executenode(irGrupo(1))" tmargin="125p" type="B" bgcolor="#FF7680" title="Cancelar" visible="1" class="xnBotonCancelarC" />
            <prop name="MAP_BT_ACEPTAR_OC" method="executenode(comprobarUsuario)" tmargin="125p" lmargin="10p" type="B" title="Aceptar" visible="1" newline="false" class="xnBotonAceptarC" />
        </frame>
    </group>
    <prop name="MAP_HUELLADACTILAR" visible="0" type="N" />
    <create>
        <!--<action name="setval" field="MAP_T_VERSIONES" value="Versión de la aplicación ##VERSION##, framework ##FRAME_VERSION##" />-->
        <!--<action name="setval" field="MAP_T_DESCIPCION_OC" value="Indíquenos un nombre de usuario válido para poder resetear la contraseña ." />-->
        <action name="runscript">
            <script language="javascript">                
                self.MAP_HUELLADACTILAR = 0;
                // self.MAP_T_VERSIONES = "Versión de la aplicación 0.0.0.1, framework 4.8.1.34dev";
                self.MAP_T_VERSIONES = "Versión de la aplicación " + appData.getGlobalMacro("##VERSION##") + ", framework " + appData.getGlobalMacro("##FRAME_VERSION##");
				self.MAP_T_DESCIPCION_OC = "Indíquenos un nombre de usuario válido para poder resetear la contraseña .";
				try{
        			if(fingerprintManager !== "undefined"){
        				if(fingerprintManager != null){
				if (fingerprintManager.isHardwareAvailable()){
    				if (fingerprintManager.hasEnrolledFingerprints()){
						self.MAP_HUELLADACTILAR = 1;
						doFingerprintAuth(); 
					}
            				}
        				}
        			}
				}catch( ex ){
				    
				}
                
				self.MAP_T_USUARIO = self.getOwnerCollection().getVariables("##LOGIN_LASTUSER##");
				ui.startReplica();
            </script>
        </action>
    </create>
    <aceptarHuella>
        <action name="runscript">
            <script language="javascript">
                if(getOS() == "IOS"){
			        doFingerprintAuthIOS();    
				}
			</script>
        </action>
    </aceptarHuella>
    <irGrupo show-wait-dialog="false" >
        <action name="runscript">
            <param name="grupo"/>
            <script language="javascript">
                irGrupo(grupo);
			</script>
        </action>
    </irGrupo>
    <comprobarUsuario>
         <action name="runscript">
            <script language="javascript">
                EjecutarOnvidarContrasenna(self.MAP_T_USUARIO_OC);
			</script>
        </action>
    </comprobarUsuario>
    <aceptar>
         <action name="runscript">
            <script language="javascript">
                hacerLogin(self.MAP_T_USUARIO,self.MAP_T_CONTRASENNA);
			</script>
        </action>
    </aceptar>    
    <onback>
         <action name="runscript">
            <script language="javascript">
                appData.failWithMessage(-11888,"##EXITAPP##");
			</script>
        </action>
    </onback>
</coll>



<coll name="EntradaApp" title="Entrada de la aplicacion" notab="true" editmask="0" special="true">
    <group name="Drawer" id="999" drawer-orientation="left" class="xnFondoDrawerC" >
        <prop name="MAP_IMAGE_DRAWER" type="IMG" visible="1" class="xnDrawarImageC"/>
        <prop name="MAP_BT_OPCION1_DR" tmargin="15p" title="Opcion 1" type="B" visible="1" onclick="javascript:irOpcion(0,5,'fmrOpcion',1);ocultarGrupo(999);" class="xnTituloDrawerC"/>
        <prop name="MAP_BT_OPCION2_DR" title="Opcion 2" type="B" visible="1" onclick="javascript:irOpcion(1,5,'fmrOpcion',1);ocultarGrupo(999);" class="xnTituloDrawerC"/>
        <prop name="MAP_BT_OPCION3_DR" title="Opcion 3" type="B" visible="1" onclick="javascript:irOpcion(2,5,'fmrOpcion',1);ocultarGrupo(999);" class="xnTituloDrawerC"/> 
        <prop name="MAP_BT_OPCION4_DR" title="Opcion 4" type="B" visible="1" onclick="javascript:irOpcion(3,5,'fmrOpcion',1);ocultarGrupo(999);" class="xnTituloDrawerC"/>
        <prop name="MAP_BT_OPCION5_DR" title="Opcion 5" type="B" visible="1" onclick="javascript:irOpcion(4,5,'fmrOpcion',1);ocultarGrupo(999);" class="xnTituloDrawerC"/>
        <prop name="MAP_BT_SALIR_DR" title="Salir" type="B" visible="1" method="executenode(onback)" class="xnTituloDrawerC"/>
    </group>
    
    <group name="Menu" id="1" class="xnFondoGroupC">
        <frame name="frmGeneral" class="xnBackgroundC">
            <frame name="frmTop" class="xnHeaderC" >
                <prop name="MAP_BT_MENU" type="B" visible="1" method="ExecuteNode(abrirDrawer(999))" class="xnButtonMenuHeaderC" />
                <prop name="MAP_TLTOP" type="TL" visible="1" title="PORTADA" class="xnTituloHeaderC" newline="false" xtmargin="30p" />
                <prop name="MAP_BT_INFO" type="B" visible="1" method="ExecuteNode(abrirColl('ConsolaReplica'))" class="xnButtonInfoHeaderC" newline="false" />
            </frame>
            <frame name="frmMidle" class="xnBodyC" >
                <frame name="fmrOpcion1" disablevisible="MAP_SELECCION&lt;&gt;0" width="100%" align="center|top" >
                    <prop name="MAP_T_HUELLADACTILAR_IFO" type="T" visible="1" lines="2" class="xnTituloTNoFixedHeightAjustesC" align="center"  />    
                    <prop name="MAP_BT_HUELLADACTILAR" disablevisible="MAP_HUELLADACTILAR=0" type="B" method="ExecuteNode(assignarHuella)" title="Asociar Huella dactilar" visible="1" class="xnBotonC"/>    
                </frame>
                <frame name="fmrOpcion2" disablevisible="MAP_SELECCION&lt;&gt;1" width="100%" align="center|top" >
                    <prop name="BTPDF_12" type="B" visible="1" method="executeNode(pdf1)" forecolor="#000000" bgcolor="#CCCCCC" labelwidth="1" width="580p" height="100p" title="Crear PDF" />    
                </frame>
                <frame name="fmrOpcion3" disablevisible="MAP_SELECCION&lt;&gt;2" width="100%" align="center|top" >
                    <prop name="MAP_TLTOP23" type="TL" labelbox="false" forecolor="#333333" visible="1" class="xnLightTitle font42" title="3" width="78%" align="center"  />    
                </frame>
                <frame name="fmrOpcion4" disablevisible="MAP_SELECCION&lt;&gt;3" width="100%" align="center|top" >
                    <prop name="MAP_TLTOP24" type="TL" labelbox="false" forecolor="#333333" visible="1" class="xnLightTitle font42" title="4" width="78%" align="center"/>    
                </frame>
                <frame name="fmrOpcion5" disablevisible="MAP_SELECCION&lt;&gt;4" width="100%" align="center|top" >
                    <prop name="MAP_TLTOP2" type="TL" labelbox="false" forecolor="#333333" visible="1" class="xnLightTitle font42" title="5" width="78%" align="center" />    
                </frame>
            </frame>
            <frame name="frmBottom" class="xnFooterC">
                <prop name="MAP_TL_SELECTOR" bgcolor="##FLD_MAP_SELECTOR_BGCOLOR##" type="B" visible="1" class="xnSelectorC" />
                <prop name="MAP_TL_SELECTOR2" bgcolor="##FLD_MAP_SELECTOR_BGCOLOR2##" type="B" visible="1" class="xnSelectorC" newline="false" />
                <prop name="MAP_TL_SELECTOR3" bgcolor="##FLD_MAP_SELECTOR_BGCOLOR3##" type="B" visible="1" class="xnSelectorC" newline="false" />
                <prop name="MAP_TL_SELECTOR4" bgcolor="##FLD_MAP_SELECTOR_BGCOLOR4##" type="B" visible="1" class="xnSelectorC" newline="false" />
                <prop name="MAP_TL_SELECTOR5" bgcolor="##FLD_MAP_SELECTOR_BGCOLOR5##" type="B" visible="1" class="xnSelectorC" newline="false" />
                <prop name="MAP_BT_OPCION1" type="B" visible="1" method="executenode(irOpcion(0,5,'fmrOpcion',1))" class="xnButtonFooterOpcion1"/>
                <prop name="MAP_BT_OPCION2" type="B" visible="1" method="executenode(irOpcion(1,5,'fmrOpcion',1))" class="xnButtonFooterOpcion2" newline="false" />
                <prop name="MAP_BT_OPCION3" type="B" visible="1" method="executenode(irOpcion(2,5,'fmrOpcion',1))" class="xnButtonFooterOpcion3" newline="false" /> 
                <prop name="MAP_BT_OPCION4" type="B" visible="1" method="executenode(irOpcion(3,5,'fmrOpcion',1))" class="xnButtonFooterOpcion4" newline="false" />
                <prop name="MAP_BT_OPCION5" type="B" visible="1" method="executenode(irOpcion(4,5,'fmrOpcion',1))" class="xnButtonFooterOpcion5" newline="false" />
            </frame>
        </frame>
        <prop name="MAP_SHOWMENU" visible="0" type="N" />
        <prop name="MAP_SELECCION" visible="0" type="N" />
        <prop name="MAP_SELECTORS_VISIBLE" visible="0" type="N" />
        <prop name="MAP_SELECTOR_BGCOLOR" visible="0" type="T" />
        <prop name="MAP_SELECTOR_BGCOLOR2" visible="0" type="T" />
        <prop name="MAP_SELECTOR_BGCOLOR3" visible="0" type="T" />
        <prop name="MAP_SELECTOR_BGCOLOR4" visible="0" type="T" />
        <prop name="MAP_SELECTOR_BGCOLOR5" visible="0" type="T" />
        <prop name="MAP_HUELLADACTILAR" visible="0" type="N" />
        <prop name="MAP_DOPDF" visible="0" type="N" />
    </group>
    
    <before-edit>
        <action name="runscript">
            <script language="javascript"> 
                self.MAP_DOPDF = 0;
                self.MAP_SELECTOR_BGCOLOR = "#ffffff";
                self.MAP_SELECTOR_BGCOLOR2 = "#00000000";
                self.MAP_SELECTOR_BGCOLOR3 = "#00000000";
                self.MAP_SELECTOR_BGCOLOR4 = "#00000000";
                self.MAP_SELECTOR_BGCOLOR5 = "#00000000";
                self.MAP_HUELLADACTILAR = 0;                
                
                try{
    				if(!isWatch() &amp;&amp; fingerprintManager !== "undefined"){
        				if(fingerprintManager != null){
                            if (fingerprintManager.isHardwareAvailable())
                            {
                          		self.MAP_T_HUELLADACTILAR_IFO = "Su dispositivo soporta la lectura de huella dactiar, pulse el boton para asignar una huella al usuario actual.";
                          		self.MAP_HUELLADACTILAR = 1;
                            }else{
                            self.MAP_T_HUELLADACTILAR_IFO = "Su dispositivo no soporta la lectura de huella dactilar.";
                            }
        				}
    				}
                }catch(ex){
                    self.MAP_T_HUELLADACTILAR_IFO = "Su dispositivo no soporta la lectura de huella dactilar.";
				}
                
            </script>
        </action>
    </before-edit>
    
    <assignarHuella>
        <action name="runscript" >
            <script language="javascript">
                if(getOS() == "IOS"){
                    doRegisterNewFingerprintIOS();
                }else{
        		    doRegisterNewFingerprint();
                }
            </script>
        </action>
    </assignarHuella>
    
    <onback show-wait-dialog="false" refresh="false">
        <action name="runscript" >
            <script language="javascript">
        		appData.failWithMessage(-11888, "##EXITAPP##");
            </script>
        </action>
    </onback>
    
    <irOpcion show-wait-dialog="false" refresh="false">
        <action name="runscript">
            <param name="opcion" />
            <param name="numeroOpciones" />
            <param name="frame" />
            <param name="haveSelector" />
            <script language="javascript">
				ui.startReplica();
                irOpcion(opcion,numeroOpciones,frame,haveSelector);
            </script>
        </action>
    </irOpcion>
    
    <abrirDrawer show-wait-dialog="false" refresh="false">
        <action name="runscript">
            <param name="grupo"/>
            <script language="javascript">
				ui.startReplica();
                irGrupo(grupo);
                ui.refresh("MAP_IMAGE_DRAWER");
            </script>
        </action>
    </abrirDrawer>
    
    <menu show-wait-dialog="false" refresh="false">
        <action name="runscript">
            <param name="parametro" />
            <script language="javascript">
      		    ui.showToast("Ha seleccionado la opción " + parametro);
		    </script>
        </action>
    </menu>
    
    <abrirColl show-wait-dialog="false" refresh="false">
        <action name="runscript">
            <param name="coll"/>
            <script language="javascript">
				ui.startReplica();
                irColl(coll);
            </script>
        </action>
    </abrirColl>
   
</coll>
</code>
</WRAP>
  

===== Otros =====
\\
==== BluetoothDeviceScript ====
\\
Es el resultado de <nowiki>BluetoothSerialPort</nowiki>.getDiscoverableDevices()\\
\\

|< 70% 20% - >|
^        Método        ^             Descripción              ^
| **getBondState**     | obtener el estado del vínculo.       |
| **getDeviceClass**   | obtener la clase del dispositivo.    |
| **getMacAddress**    | obtener la dirección de la Mac.      |
| **getDeviceName**    | obtener el nombre del dispositivo.   |

\\
==== FingerprintAuthenticationResult ====
\\
Es el objeto devuelto en el callback de la huella dactilar.\\
\\
|< 70% 20% - >|
^           Método            ^              Descripción              ^
| **getPublicKey**            | obtener clave pública.                |
| **getPublicKeyAlgorithm**   | obtener algoritmo de clave pública.   |
| **getPublicKeyFormat**      | obtener formato de clave pública.     |
| **signWithPrivateKey**      | firmar con clave pública.             |
| **verify**                  | verificar.                            |
\\

====Objeto ImageInfo====
\\
Es el objeto resultado de <nowiki>ImageDrawing</nowiki>.getImageInfo()\\
\\
|< 70% 20% - >|
^      Método       ^       Descripción       ^
| **getHeight**     | obtener altura.         |
| **getMimeType**   | obtener el tipo MIME.   |
| **getWidth**      | obtener anchura.        |
\\
====Objeto LiveSecureProvisioningResponse====
\\
Es el objeto devuelto en el callback del provisionamiento seguro\\
\\

====Objeto ScriptCursorWrapper====
\\
Es el objeto cursor resultado de las querys que tiran algunos métodos de <nowiki>SqlManager</nowiki>.\\
\\
TODO EXPERIMENTAL
\\

====Objeto XOneWifiInfo====
\\
Objeto resultado de buscar redes wifi con <nowiki>WifiManager</nowiki>.\\
\\

|< 70% 20% - >|
^       Método        ^         Descripción          ^
| **getBssid**        | obtener Bssid.               |
| **getFrequency**    | obtener frecuencia.          |
| **getHiddenSsid**   | obtener el Ssid oculto.      |
| **getIpAddress**    | obtener la dirección IP.     |
| **getLinkSpeed**    | obtener velocidad de link.   |
| **getRssi**         | obtener Rssi.                |
| **getSsid**         | obtener el Ssid.             |

\\
====Objeto XoneDataObject====
\\
|< 70% 20% - >|
^           Método            ^                  Descripción                  ^
| **bind**                    | enlazar.                                      |
| **clone**                   | clonar.                                       |
| **contents**                | contents.                                     |
| **deleteObject**            | borrar objeto.                                |
| **executeNode**             | ejecutar nodo.                                |
| **fieldPropertyValue**      | valor propiedad del campo.                    |
| **get**                     | obtener.                                      |
| **getContents**             | obtener contents.                             |
| **getContentsCount**        | obtener recuento de contents.                 |
| **getDirty**                | indica si hubo cambios.                       |
| **getFieldPropertyValue**   | obtener el valor de la propiedad del campo.   |
| **getObjectIndex**          | obtener índice del objeto.                    |
| **getObjectItem**           | obtener item de objeto.                       |
| **getOwnerApp**             | obtener aplicación propietaria.               |
| **getOwnerCollection**      | obtener propietario de la colección.          |
| **getPropertyGroup**        | obtener propiedad de grupo.                   |
| **getPropertyTitle**        | obtener titulo de propiedad.                  |
| **getValue**                | obtener valor.                                |
| **getVariables**            | obtener variables.                            |
| **isNew**                   | nuevo.                                        |
| **loadFromJson**            | cargar de Json.                               |
| **save**                    | guardar.                                      |
| **setFieldPropertyValue**   | ajustar valor de la propiedad del campo.      |
| **setOwnerCollection**      | ajustar colección propietaria.                |
| **setValue**                | ajustar valor.                                |
| **setVariables**            | ajustar variables.                            |
| **toString**                | cadena.                                       |
\\


/*
====appData.error====
\\

Objeto XoneError\\
\\
|< 50% 20% - >|
^        Método        ^       Descripción        ^
| **getFailedSql**     | obtener Sql con fallo.   |
| **getNumber**        | obtener número.          |
| **setFailedSql**     | ajustar Sql con fallo.   |
| **clear**            | limpiar.                 |
| **setDescription**   | ajustar descripción.     |
| **getDescription**   | obtener descripción.     |
| **setNumber**        | ajustar número.          |
\\
*/

====Objeto XoneXmlObjectWrapper====
\\
Resultado de <nowiki>XoneDataCollection</nowiki>.getXmlNode()\\
\\
|< 50% 20% - >|
^         Método          ^         Descripción         ^
| **appendChild**         | añadir hijo.                |
| **clone**:              | clonar.                     |
| **getAttribute**        | obtener atributo.           |
| **insertAfterChild**    | insertar después de hijo.   |
| **insertBeforeChild**   | insertar antes de hijo.     |\\
| **removeChild**         | quitar hijo.                |
| **setAttribute**        | ajustar atributo.           |
| **selectNodes**         | seleccionar nodos.          |
| **selectSingleNode**    | seleccionar nodo único.     |

====Objeto XoneXmlNodeListWrapper====
\\
Resultado de <nowiki>XoneXmlObjectWrapper</nowiki>.selectNodes()\\
\\
|< 50% 20% - >|
^     Método     ^  Descripción  ^
| **count**      ||
| **get**        ||
| **getCount**   ||
\\

====Objeto DnieReadResult====
\\
Resultado del callback de leer un DNIe con <nowiki>XOneNFC</nowiki>.\\

\\
|< 50% 20% - >|
^ Método ^ Descripción ^
|TODO ||
\\

====Objeto PtvView====
\\
Se obtiene con ui.getView(self)[“MAP_MAPAPTV”]\\
\\
|< 50% 20% - >|
^      Método      ^    Descripción    ^
| **drawRoute**    | dibujar ruta.     |
| **setProfile**   | ajustar perfil.   |
\\

====Objeto PrinterInfo====
\\
Resultado de <nowiki>XOnePrinter</nowiki>.getStoredPrinterInfo()\\
\\
|< 50% 20% - >|
^      Método      ^     Descripción      ^
| **getAddress**   | obtener dirección.   |
| **getName**      | obtener nombre.      |
| **getType**      | obtener tipo.        |