Basic Android 4 - Guía para Principiantes PDF

Guía para principiantes
Copyright: © 2011 cualquier Software Edición 2.1

Tabla de contenido 2 Basic4Android Guía del principiante
1 Getting started.........................................................................................................................7
1.1 Instalación de Basic4Android y Android SDK....................................................................7
1.1.1 Instalar y configurar Basic4Android........................................................................9
1.2 Instalar emulador Android.......................................................................................... 10
2 Mi primer programa (MyFirstProgram.b4a)............................................................................... 15
3 Segundo programa (SecondProgram.b4a)................................................................................. 33
4 The IDE ................................................................................................................................ 47
4.1 Menu and Toolbar.......................................................................................................... 48
4.1.1 Toolbar .................................................................................................................. 48
4.1.2 File menu ............................................................................................................... 49
4.1.3 Edit menu............................................................................................................... 49
4.1.4 Project menu .......................................................................................................... 50
4.1.5 Tools menu ............................................................................................................ 51
4.2 Code area....................................................................................................................... 53
4.2.1 Deshacer – rehacer ............................................................................................. 53
4.2.2 Collapse a subroutine ............................................................................................. 53
4.2.3 Collapse a Region ..................................................................................................54
4.2.4 Collapse the whole code......................................................................................... 55
4.2.5 Código comentario y uncommenting ...................................................... 56
4.2.6 Marcadores .................................................................................. 56
4.2.7 Sangría ............................................................................................... 57
4.2.8 Autocompletar .................................................................................................59
4.2.9 Jump to a subroutine .............................................................................................. 61
4.2.10 Destacando las ocurrencias de palabras................................................... 62
4.2.11 Debugging ............................................................................................................. 63
4.2.12 Breakpoints............................................................................................................ 65
4.3 Tabs............................................................................................................................... 68
4.3.1 Listas de módulo y subrutina ............................................................... 68
4.3.2 Archivos ....................................................................................................... 69
4.3.3 Registros ...................................................................................................... 70
4.3.4 Libs ........................................................................................................ 71
5 Screen sizes and resolutions................................................................................................... 72
5.1 Funciones especiales como 50% x, 50dip................................................ 77
5.1.1 PerXToCurrent, PerYToCurrent - 50% x...................77
5.1.2 DipToCurrent - 50dip............................................................................................. 77
5.2 Trabajar con diferentes tamaños de pantalla \/ número de diseños.................................... 78
5.3 Screen orientations......................................................................................................... 84
6 The Emulator......................................................................................................................... 85
6.1 Launch an Emulator....................................................................................................... 85
6.2 Create a new Emulator................................................................................................... 87
6.3 Emulator problems......................................................................................................... 89
6.3.1 Process timeout...................................................................................................... 90
6.4 Intercambio de archivos con el PC......................................................................................... 91
7 B4A Bridge ........................................................................................................................... 94
8 The Designer ......................................................................................................................... 97
8.1 The menu....................................................................................................................... 98
8.1.1 File menu ............................................................................................................... 98
8.1.2 AddView menu ...................................................................................................... 98
8.1.3 The Tools menu ..................................................................................................... 99
8.2 Tools ........................................................................................................................... 100

8.2.1 Generate Members ............................................................................................... 100
8.2.2 BringTo Front ...................................................................................................... 101
8.2.3 Send To Back....................................................................................................... 101
8.2.4 Duplicate Selected View ...................................................................................... 101
8.2.5 Remove Selected View ........................................................................................ 102
8.2.6 Change grid.......................................................................................................... 102
8.2.7 Conecte el dispositivo o el emulador.................................................................................. 103
8.3 General settings ........................................................................................................... 103
8.4 Image files................................................................................................................... 104
8.5 Properties list............................................................................................................... 105
8.6 Layout variants ............................................................................................................ 107
8.7 The Abstract Designer ................................................................................................. 112
8.7.1 The menu ............................................................................................................. 113
8.7.2 Example............................................................................................................... 114
8.8 Adding views by code.................................................................................................. 117
8.9 Designer Scripts........................................................................................................... 120
9 Actividad y proceso de ciclo de vida............................................................................................. 126
9.1 ¿Cómo maneja? ................................................................................................. 127
9.2 Process global variables............................................................................................... 128
9.3 Activity variables......................................................................................................... 128
9.4 Sub Activity_Create (cumshot As Boolean)............................................................ 128
9.5 Globals versus FirstTime ............................................................................................. 129
9.6 Sub Activity_Resume Sub Activity_Pause (UserClosed As Boolean)...................... 129
10 Variables and objects....................................................................................................... 130
10.1 Variable Types............................................................................................................. 130
10.2 Names of variables ...................................................................................................... 132
10.3 Declaring variables ...................................................................................................... 132
10.3.1 Simple variables................................................................................................... 132
10.3.2 Array variables..................................................................................................... 133
10.3.3 Array of views (objects)....................................................................................... 135
10.3.4 Type variables...................................................................................................... 136
10.4 Casting ........................................................................................................................ 137
10.5 Scope........................................................................................................................... 138
10.5.1 Process variables.................................................................................................. 138
10.5.2 Activity variables................................................................................................. 138
10.5.3 Local variables..................................................................................................... 138
10.6 Tips ............................................................................................................................. 139
11 Modules........................................................................................................................... 140
11.1 Activity modules.......................................................................................................... 141
11.2 Code modules .............................................................................................................. 142
11.3 Service modules........................................................................................................... 143
12 Example programs........................................................................................................... 144
12.1 User interfaces............................................................................................................. 144
12.1.1 Ejemplo de menú (UserInterfaceMenu.b4a).................................................... 145
12.1.2 Ejemplo de TabHost (UserInterfaceTabHost.b4a)............................................... 146
12.1.3 Ejemplo de cuadro de herramientas (UserInterfaceButtonToolbox.b4a) el botón........................... 147
12.2 Programa con 3 actividades (ThreeActivityExample.b4a)................................ 148
12.3 ScrollView examples ................................................................................................... 155
12.3.1 Programa de ejemplo ScrollView............................................................................... 156
13 Basic language................................................................................................................. 167
13.1 Program flow............................................................................................................... 167
13.1.1 Process_Globals routine....................................................................................... 167
13.1.2 Globals routine..................................................................................................... 168

13.1.3 Rutina de Activity_Create (cumshot As Boolean).................................................. 168
13.1.4 Activity_Resume routine...................................................................................... 168
13.1.5 Rutina de Activity_Pause (UserClosed As Boolean)........................................... 168
13.2 Expressions.................................................................................................................. 170
13.2.1 Expresiones matemáticas............................................................................................ 170
13.2.2 Relational expressions.......................................................................................... 171
13.2.3 Boolean expressions............................................................................................. 171
13.3 Conditional statements................................................................................................. 172
13.3.1 If – Then – End If................................................................................................. 172
13.3.2 Select – Case........................................................................................................ 173
13.4 Loop structures ............................................................................................................ 175
13.4.1 For – Next............................................................................................................ 175
13.4.2 Do - Loop ............................................................................................................ 176
13.5 Subs............................................................................................................................. 177
13.5.1 Declaring ............................................................................................................. 177
13.5.2 Calling a Sub........................................................................................................ 177
13.5.3 Llamar a un Sub desde otro módulo......................... 177
13.5.4 Naming ................................................................................................................ 178
13.5.5 Parameters ........................................................................................................... 178
13.5.6 Returned value ..................................................................................................... 178
13.6 Events.......................................................................................................................... 179
13.7 Libraries ...................................................................................................................... 182
13.7.1 Standard libraries ................................................................................................. 182
13.7.2 Carpeta de bibliotecas adicionales............................................................................................ 182
13.7.3 Mensaje de error \"falta una referencia de la biblioteca?\".......................................... 183
13.8 String manipulation ..................................................................................................... 184
13.9 Timers ......................................................................................................................... 185
13.10 Files......................................................................................................................... 186
13.10.1 File object ........................................................................................................ 186
13.10.2 Filenames......................................................................................................... 188
13.10.3 Subfolders........................................................................................................ 188
13.10.4 TextWriter........................................................................................................ 189
13.10.5 TextReader....................................................................................................... 190
13.10.6 Text encoding................................................................................................... 191
13.11 Lists......................................................................................................................... 193
13.12 Maps........................................................................................................................ 195
14 Graphics \/ Drawing.......................................................................................................... 197
14.1 Overview..................................................................................................................... 197
14.2 Drawing test programs................................................................................................. 199
14.2.1 Plano de rotación de mapas de bits \/ RotatingNeedle............................................ 199
14.2.2 Simple draw functions.......................................................................................... 204
15 B4A Keywords................................................................................................................ 213
15.1 Bit ............................................................................................................................... 213
15.2 DateTime..................................................................................................................... 214
15.3 Exception..................................................................................................................... 217
15.4 Keywords .................................................................................................................... 218
15.5 LayoutValues............................................................................................................... 230
15.6 String........................................................................................................................... 231
15.7 StringBuilder ............................................................................................................... 233
15.8 Timer........................................................................................................................... 235
16 Views .............................................................................................................................. 237
16.1 Activity........................................................................................................................ 237
16.2 Button.......................................................................................................................... 241

16.3 CheckBox.................................................................................................................... 244
16.4 EditText....................................................................................................................... 247
16.5 ImageView .................................................................................................................. 252
16.6 Label ........................................................................................................................... 255
16.7 ListView...................................................................................................................... 258
16.8 Panel............................................................................................................................ 263
16.9 ProgressBar ................................................................................................................. 266
16.10 RadioButton............................................................................................................. 268
16.11 ScrollView............................................................................................................... 271
16.12 SeekBar ................................................................................................................... 274
16.13 Spinner .................................................................................................................... 277
16.14 TabHost ................................................................................................................... 281
16.15 ToggleButton........................................................................................................... 285
16.16 View ........................................................................................................................ 288
16.17 WebView................................................................................................................. 290
17 Collections ...................................................................................................................... 294
17.1 List .............................................................................................................................. 294
17.2 Map ............................................................................................................................. 298
18 VB6 versus B4A.............................................................................................................. 10s
19 FAQ ................................................................................................................................ 306
19.1 \"Por favor Guardar proyecto primero\" mensaje............................................................................ 306
19.2 \"Le falta una referencia de la biblioteca\" mensaje............. 306
19.3 Cómo cargar \/ actualizar una biblioteca.................................................................................. 307
19.4 Cuando necesitamos 'Initialize' y cuando no..................................................................... 307
19.5 Dividir una línea larga en dos o más líneas................................................... 308
19.6 Evitar cerrar una aplicación \/ captura códigos de tecla como Back \/ menú............................... 308
19.7 Eventos no deseados como clic, toque u otros............................................................ 309
19,8 Adding a Menu item .................................................................................................... 309
19.9 ¿Cómo elimino una vista con el diseñador........................................................... 310
19.10 \"El proceso tiene tiempo de espera\" mensaje............................................................................... 310
19.11 Obtener una imagen de la Galería............................................................................ 311
19.12 Cómo eliminar archivos de x.bal u otros archivos de un proyecto............................................. 311
19.13 Block a screen orientation ........................................................................................ 312
19.14 Close second Activity .............................................................................................. 313
19.15 Tomar una captura de pantalla programaticaly................................................... 313
19.16 Después de compilar, donde están los archivos................................................... 313
19.17 Ejecutar una aplicación desde otra........................................................................ 314
19.18 How to pass an Array to a Sub ................................................................................. 314
19.19 Obtención de idioma y país de dispositivo............................................................ 315
19,20 Where is the apk file ................................................................................................ 315
19.21 ¿Por qué es mi result.apk de nombre de archivo apk................................................. 315
19,22 ¿Por qué es mi xxx_DEBUG.apk de nombre de archivo apk.......................................................... 316
19.23 Select True \/ Case trick ............................................................................................ 316
19.24 Llenar una matriz con números aleatorios sin repeticiones................................ 316
19.25 Detect screen orientation.......................................................................................... 317
19.26 Algunas funciones no funcionan en Activity_Pause........................................................... 317
19.27 Llamar a la calculadora interna.................................................................................. 317
19,28 Obtenga la Alpha \/ rojo \/ verde \/ azul. 318
20 Glossary .......................................................................................................................... 319
Colaboradores principales:
Erel Uziel (Erel)

Klaus Christl (klaus)
nfordbscndrd
Todo el código fuente y archivos necesarios (diseños, imágenes, etc.) de los proyectos de ejemplo en esta guía son
incluido en la carpeta de código fuente.
1 Procedimientos iniciales 7 Basic4Android Guía del principiante
1 Introducción
Basic4android es un entorno de desarrollo sencillo y potente orientado a dispositivos Android.
Basic4android lenguaje es similar al lenguaje de Visual Basic con soporte adicional para los objetos.
Basic4android compilado de aplicaciones son aplicaciones nativas para Android, no hay runtimes adicionales o
dependencias.
A diferencia de otros Basic4android IDEs es 100% focalizada en desarrollo Android.
Basic4android incluye un potente diseñador de GUI con soporte integrado para múltiples pantallas y
orientaciones. No escribir XML es requerido.
Usted puede desarrollar y depurar con el emulador de Android o con un dispositivo real
(USB conectado o a través de la red local).
Basic4android tiene un rico conjunto de librerías que facilitan el desarrollo de aplicaciones avanzadas.
Esto incluye: SQL bases de datos, GPS, puertos serie (Bluetooth), cámara, análisis, servicios Web XML
(HTTP), servicios (tareas en segundo plano), JSON, animaciones, red (TCP y UDP), texto a voz
(TTS), reconocimiento de voz, vista Web, AdMob (ads), gráficos, OpenGL, gráficos y más.
Android 1.6 y por encima son compatibles (incluyendo tabletas como Motorola Xoom).
1.1 Instalación de Basic4Android y Android SDK
Basic4android depende de dos componentes adicionales (libres):

-Java JDK
-Android SDK
Instrucciones de instalación:
Debe ser el primer paso instalar el JDK de Java como Android SDK, así lo requiere.
Tenga en cuenta que no hay ningún problema con tener varias versiones de Java instalado en el mismo equipo.
-Abrir la Link de descarga de Java JDK 7.

-Marque el botón de radio de aceptar el acuerdo de licencia.
-Seleccione \"Windows x 86\" en la lista de plataformas (para máquinas de 64 bits así).
Android SDK no funciona con Java JDK de 64 bits.
Debe instalar el JDK regular para equipos de 64 bits así.
-Descargar el archivo e instalarlo.
Siguiente paso es instalar el SDK de Android y una plataforma:
-Instalar el SDK. El SDK de siempre no comportarse correctamente cuando se instala en un trazado con
espacios (como archivos de programa). Se recomienda instalarlo en una carpeta personalizada similar a
C:\\Android.
-Ahora debe instalar las herramientas de la plataforma y la imagen de al menos una plataforma. Puede utilizar API 8 o
anteriormente. Se recomienda utilizar API 10.
También puede instalar el controlador USB de Google si necesita conectarse a un dispositivo real con USB.
Tenga en cuenta que puede instalar más paquetes más tarde.
-Presione en instalar seleccionado e instalar ambos paquetes.

1.1.1 Instalar y configurar Basic4Android
- Descargar e instalar Basic4android .
-Basic4android abierto.
-Seleccionar el menú de herramientas - configurar rutas de acceso.
-Utilice los botones de navegación para localizar \"javac.exe\" y \"android.jar\"

javac se encuentra bajo < carpeta java > \\bin.
Android.jar se encuentra bajo <android-sdk-windows> \\platforms\\android-8

Depende de la carpeta donde instaló el SDK de Android,
debe ser C:\\Android\\android-sdk-windows\\platforms\\android-8\\android.jar.
En Windows de 64 bits, Java probablemente se instalará en C:\\Program Files (x 86).
Errores comunes
- Windows XP-\"aplicación de Basic4Android.exe no podía ser inicializado correctamente error
0xc0000135 \"al inicio. Basic4android requiere .net Framework 2.0 o superior. Usuarios de Windows XP
quien no instalarlo antes debe instalar primero el marco.
1.2 Instalación de emulador Android 10 Basic4Android Guía del principiante
1.2 Instalar emulador Android
Por favor siga las instrucciones de instalación (y configuración) si no lo ha hecho todavía:

http:\/\/www.Basic4ppc.com\/Forum\/Basic...Droid-SDK.html.
En este capítulo, vamos a crear un nuevo AVD (Android Virtual Device) que es una instancia de emulador.
A continuación, vamos a crear un sencillo programa que muestra un cuadro de mensaje de texto y escribe un mensaje a
el registro.
También puede conectar un dispositivo real para el IDE:
Conectar el dispositivo con ADB
Conectar el dispositivo con B4A-puente
Crear nueva AVD
-Ejecutar Basic4android.
-Seleccionar el menú de herramientas - Run AVD Manager.

Espere unos segundos.
-El SDK Manager pueden aparecer dependiendo de la versión y la configuración. Debe elegir
Herramientas - administrar AVDs.
-El Manager de AVD debería aparecer:
-Haga clic en y llene los campos relacionados de la siguiente imagen (se recomienda elegir
HVGA):
-Haga clic en .
-Tenga en cuenta que puede crear más de una

AVD. Cada uno puede tener una resolución diferente
o puede destinar una versión diferente de la API (usted
será necesario instalar plataformas adicionales
primero).
-Ahora, haga clic en con el fin de iniciar el emulador.
-Verá esta pantalla.
-Haga clic en para iniciar el emulador
-Verá varias ventanas apareciendo y desapareciendo. Esto está bien.

-El emulador debe arrancar:
Espere... por primera vez puede tardar varios minutos hasta que esté listo el emulador.
El emulador está listo cuando se pone a

Esta pantalla:
Puede ver esta pantalla, que es la pantalla de bloqueo,

en su lugar:
Arrastre el icono de bloqueo a la derecha para desbloquear la

dispositivo.
Tenga en cuenta que no es necesario reiniciar el emulador

cada vez que se implemente un programa. El emulador
puede ser mantenido funcionando todo el tiempo.
Si no estás familiarizado con Android puede reproducir

con el emulador. Pulse sobre el botón con el
cuadrados pequeños para llegar a la página de la aplicación.
Solución de problemas: Si aparece un mensaje de error

similares a:
parámetro de línea de comandos no válido:
Files\\Android\\android-sdk\\tools\/emulador-
ARM.exe.
Sugerencia: use '@ foo' para lanzar un dispositivo virtual denominad
'foo'.
2. Mi primer programa 15 Basic4Android Guía del principiante
2 Mi primer programa (MyFirstProgram.b4a)

Debemos escribir nuestro primer programa.
El programa propuesto es un entrenador de matemáticas para niños.
El proyecto está disponible en la carpeta de código fuente:

SourceCode\\MyFirstProgram\\ MyFirstProgram.b4a
En la pantalla, tendremos:
-2 Etiquetas mostrando aleatoriamente generan números
-1 Etiqueta con el signo de matemáticas
-1 Vista EditText donde el usuario debe introducir el resultado
-1 Botón, se utiliza para confirmar cuando el usuario ha terminado de introducir el resultado o generar un nuevo
cálculo.
-1 Etiqueta con un comentario sobre el resultado.
Vamos al diseño de la interfaz de usuario con el diseñador en el emulador y vaya paso

paso a través de todo el proceso.
Ejecute el IDE
Guarde el proyecto.
Debe guardar el proyecto antes de ejecutar el diseñador.
Crear una carpeta nueva MyFirstProgram y guardar

el proyecto con el nombre MyFirstProgram.
Ejecutar el emulador.
Seleccione el emulador.
El retrato emulador, en este caso. Haga clic en
Haga clic en
Espere hasta que esté listo el emulador, esto tomará bastante tiempo.
Ejecutar el diseñador.
Espere hasta que el diseñador está listo.

Conecte el emulador al diseñador.
Espere hasta que el diseñador y el emulador

conectado, esto puede tomar algún tiempo, ser paciente.
Podrá ver el estado del diseñador aquí:
La parte superior del emulador tenga este aspecto.

Ahora agregaremos las 2 etiquetas para los números.

En el diseñador de añadir una etiqueta.
La etiqueta aparecerá en el emulador, y sus parámetros por defecto aparecen en el diseñador.
Cambiar el tamaño y mover la etiqueta con el rojo

plazas like this.
Los nuevos parámetros Left, Top, Width y

Altura se actualizan directamente en el diseñador.
También puede modificar la izquierda, Top, Width
y los parámetros de altura directamente en el
Diseñador.
Cambiemos los parámetros de esta primera etiqueta

según nuestras necesidades.
De forma predeterminada, el nombre es la etiqueta con un númer
aquí Label1, nos permiten cambiar su nombre a
lblNumber1.
Las tres letras lbl al principio para
Etiqueta y número 1 para el primer número.
Se recomienda usar nombres significativos para
vistas directamente sabemos qué tipo de verlo
es y su propósito.
Presionar retorno o haciendo clic en otro lugar que también

cambiar el parámetro del nombre del evento.
Ahora tenemos:
Principal: módulo principal

Nombre: nombre de la vista
Tipo: tipo de la vista, etiqueta, este parámetro no puede cambiarse por supuesto
Nombre del evento: nombre de la rutina que controla los eventos de la etiqueta
Padre de familia:
la vista padre la etiqueta pertenece a.
Comprobar y modificar los otros parámetros:
A la izquierda, parte superior, la anchura y la altura son OK.

Habilitado, Visible son OK
Etiqueta que dejamos vacía.
Texto, establecemos un número predeterminado, decir 5
Tipo de letra, estilo son OK

Alineación horizontal: póngalo en
CENTER_HORIZONTAL
Alineación vertical: dejamos
CENTER_VERTICAL.
Tamaño: ajústelo a 36
Dejamos todos los otros parámetros como son.
Los nuevos parámetros.
Necesitamos una segunda etiqueta similar a la primera. En lugar de agregar uno nuevo, copiamos el primero de ellos
con los mismos parámetros. Sólo los parámetros de nombre, de izquierda y de arriba va a cambiar.
Coloque la etiqueta nueva y cambiar su nombre a lblNumber2.
Ahora agreguemos una tercera etiqueta para el signo de matemáticas. Copiamos nuevamente lblNumber1.
Haga clic en lblNumber1 en el emulador y en el click del diseñador en el menú 'Herramientas' en ' duplicar
Vista seleccionada '.
Colocarla entre las dos etiquetas primeras y cambiar su nombre a lblMathSign y su parámetro de texto
a '+'.
Ahora agreguemos una vista EditText. En haga clic en diseñador de
Colóquelo debajo de los tres rótulos y cambiar su nombre a edtResult. 'EDP' EditText y el 'Resultado'
para su propósito.
Cambiemos estos parámetros.

Nombre a edtResult
Alineación horizontal Para

CENTER_HORIZONTAL
Tamaño del texto
a 30
Tipo de entrada a los números

Texto de sugerencia
a 'Entrar resultado'
Agreguemos el botón para confirmar el resultado o para generar un nuevo cálculo.
Colóquelo debajo de la vista EditText; cambiar el tamaño y cambiar siguiendo los parámetros:
Nombre: a 'btnAction'
Texto: a 'O K' y
Tamaño del texto

a 24.
Añadir la última etiqueta por los comentarios, colóquelo debajo del botón y cambiar su tamaño.
Cambiar los siguientes parámetros:

Nombre a lblComments
Alineación horizontal:
CENTER_HORIZONTAL
Color del texto a negro
Color a blanco
Alpha a 255
De forma predeterminada, el color de fondo de la etiqueta es de c

y transparente. Lo fijamos al blanco y opaco
Alfa = 255.
Establecemos el color del texto a negro.
Salvemos el diseño en un archivo.
Haga clic en y guardarlo con el nombre 'Main'.
Haga clic en .
Para escribir las rutinas para el proyecto que tenemos que hacer referencia a las opiniones expresadas en el código.
Esto puede hacerse con la herramienta de generar miembros en el diseñador.
La herramienta de generar miembros permite para generar automáticamente referencias y marcos de subrutina.
Haga clic en para abrir el generador.
Aquí encontramos todas las vistas en el diseño actual.

Verificamos todas las vistas y controlar el evento Click para el botón de btnAction.
Comprobación de una vista genera su referencia en la Globals Sub en el código. Esto es
necesarios para que la vista reconoce y permite la función de Autocompletar.
Al hacer clic en el evento en de una vista genera el marco Sub para este evento.
Haga clic en para generar las referencias y sub marco y .

Ahora volvemos al IDE para introducir el código.
En primer lugar, tenemos que cargar nuestro archivo de diseño a la actividad en el Sub Activity_Create.
-Entrar en 'Actividad'
-Introduzca un punto
-La función de Autocompletar muestra automáticamente todos los parámetros posibles de la vista.
-Entrar en 'L', la muestra de la función de Autocompletar los parámetros empezando con 'L'
-Pulse la tecla de flecha abajo, aparecerá LoadLayout con la ayuda en línea para el parámetro determinado o
método.
-Pulsar 'Return', se añade LoadLayout.
-Entrar ' (', la ayuda en línea se mostrará los parámetros necesarios para el método.
-Introduzca ' \"Principal\") '
Queremos generar un nuevo problema directamente al iniciar el programa. Por lo tanto, agregamos una llamada a
la subrutina nueva.
Para generar un nuevo problema, que significa generar números aleatorios dos Número1 y número2
entre 1 y 9 y espectáculo en la lblNumber1 y la lblNumber2 etiquetas.
Para ello nos Introduzca el siguiente código:

En Sub Globals añadimos dos variables para los dos números.
Y la 'Nueva' subrutina:
RND (1, 10) Generador de números aleatorios, '1' número de minutos inclusivo y max '10'. número exclusivo.
lblComments.Text = \"Escriba el resultado\"
Muestra el comentario de lblComments. CRLF es el carácter de salto de línea.
Ahora añadimos el código para el evento de clic de botón.
Tenemos dos casos:

-Cuando el texto del botón es igual a \"O K\" Esto significa que se propone un nuevo problema y la
programa esperará al usuario ingresar un resultado y, a continuación, pulsando el botón.
-Cuando el texto del botón es igual a \"Nuevo\" Esto significa que el usuario ha introducido una respuesta correcta y
Cuando el usuario hace clic en el botón se generará un nuevo problema.
Si btnAction.Text = \"O K\" Then comprueba si el texto del botón es igual a \"O K\"
Si comprobamos si el EditText está vacía.
Si sí, nos mostrará un cuadro de mensaje que indica al usuario que no existe ningún resultado en la vista EditText.
Si no, se comprueba si el resultado es correcto o si es falsa.
Si no que entonces generamos un nuevo problema, establezca el texto del botón de \"OK\" y borrar la vista EditText.
La última rutina es la comprobación del resultado.
Con Si edtResult.Text = número1 + número2 luego comprobamos si el resultado es correcto.
En caso afirmativo, exhibimos en la etiqueta de lblComments el texto a continuación:

'Resultado de G O O D'
'Haga clic en nuevo'
y cambiar el texto del botón a «N E W».
Si no, nos muestra en la etiqueta de lblComments el texto a continuación:
Resultado W R O N G
Introduzca un nuevo resultado
y haga clic en Aceptar
Permítanos ahora compilar el programa y transferirlo al emulador.

En el IDE en superior, haga clic en :
Todavía no hemos puesto el nombre del paquete para que el IDE lo pide. Escriba B4A.MyFirstProgram.
Android necesita el paquete nombre beeing minúsculas. Desde B4A esto es obligatorio!
Haga clic en .
También tenemos que entrar en la

Nombre de la etiqueta
Haga clic en .
Estos dos parámetros también pueden cambiarse en el IDE en el menú proyecto.
El programa va a ser compilado.
Cuando veas \"Ha completado con éxito.\" por encima del cuadro de mensaje, la compilación y la transferencia es
terminado.
Mira el emulador, debería ver algo similar a la imagen a continuación, con diferentes números.
Por supuesto, podríamos hacer estéticas

mejoras en el diseño, pero este no era el
cuestión principal para el primer programa.
Una desventaja del diseño actual es el

cobertura de la etiqueta de comentario por la virtual
teclado.
Esto mejorará en el próximo capítulo

'Segundo programa'.
Vamos a agregar un teclado específico.

3 Segundo programa 33 Basic4Android Guía del principiante
3 Segundo programa (SecondProgram.b4a)

El proyecto está disponible en la carpeta de código fuente:
SourceCode\\SecondProgram\\SecondProgram.b4a
Mejoras de mi primer programa.
Crear una carpeta nueva SecondProgram. Copiar todos los archivos y carpetas de MyFirstProgram a la
Nueva carpeta de SecondProgram y renombrar el programa file MyFirstProgram.b4a a
SecondProgram.b4a.
Cargar este programa nuevo en el IDE.
Ejecuta el diseñador y conéctelo a la

Emulador.
Agreguemos un teclado numérico para el diseño

para evitar el uso del teclado virtual.
Necesitamos cambiar el nombre del paquete.
En el menú Proyecto de IDE.
Haga clic en '

Nombre '
del proyecto
Cambiar el nombre a
B4A.secondprogram, atención minúsculas!
Haga clic en .
Y cambiar la etiqueta de la aplicación.

Haga clic en '
Etiqueta ' en el mismo menú.
de aplicación
Cambiar el nombre a
SecondProgram.
Haga clic en .
Queremos sustituir la edtResult EditText vista por una nueva etiqueta.
En el emulador y el diseñador.
Haga clic en la vista edtResult.
Haga clic en
Haga clic en lblNumber1 para seleccionarlo.
Duplicar
Moverlo entre las etiquetas superiores y la

botón y cambiar su tamaño.
Modificar siguiendo los parámetros:
Nombre a lblResult
Texto para \"\" en blanco de carácter
Color del texto a negro
Radio de esquina 5
Color a blanco
Alpha a 255
Agreguemos un Panel de los botones del teclado.
Posición y cambiar su tamaño como en la imagen.
Cambiar su nombre a pnlKeyboard

\"pnl\" para el Panel, el tipo de vista.
Radio de esquina de cambio 0

Vamos a pasar el botón K O de la

Actividad para el Panel de pnlKeyboard.
Haga clic en
El botón pertenece ahora al Panel
Mover lblComments etiqueta etiqueta cerca

lblResult y aumento de la altura del Panel
pnlKeyboard como en la imagen.
Haga clic en el panel de pnlKeyboard para seleccionarlo.
Haga clic en
para agregar un nuevo botón.
Se agrega el botón nuevo.
Cambiar siguiendo los parámetros.
Nombre a btn0
Nombre del evento
a btnEvent
Izquierda a 10
Arriba a 120
Ancho a 55
Altura a 55
Etiqueta 0
Texto 0
Tamaño a 24
Ahora queremos cambiar los colores de los botones.
Haga clic en StatelistDrawable.
Haga clic en GradientDrawable

Cambiar los siguientes parámetros.
Orientación a Alto_Bajo
Primer Color
Segundo Color
Presiona dibujable a GradientDrawable
Orientación a Alto_Bajo
Primer Color
Segundo Color
El botón ahora este aspecto.
Duplicar btn0 y colóquelo aparte

botón btn0.
Cambiar siguiendo los parámetros.
Nombre a btn1
Etiqueta 1
Texto 1
Permítanos agregar 8 botones más y colóquelas

como en la imagen.
Cambiar siguiendo los parámetros:

Nombre btn2, btn3, btn4 etc.
Etiqueta2 , 3 etc. 4
Texto 2 , 3 etc. 4
Duplicar uno de los botones de número, y

colocarlo como en la imagen.
BtnOK de cambio de tamaño y posición.
Cambiar el pnlKeyboard Color negro.
Cambiar su nombre, etiqueta, texto y Color

parámetros siguientes.
btnBS < btnOK Ok

El nuevo diseño terminado.
Ahora actualizamos el código.

En primer lugar, debemos reemplazar la edtResult por lblResult porque hemos reemplazado la vista EditText por una etiqueta.
Haga clic en edtResult para seleccionarlo.
Haga clic en Find(F3)

Haga clic en
Haga clic en y .
También tenemos que cambiar su forma de tipo de vista EditText etiqueta.
Ahora escribimos la rutina, controla los eventos de clic de los botones.

El nombre del evento para todos los botones, salvo btnAction, es \"btnEvent\".
El nombre de rutina será convertido en btnEvent_Click, nos Introduzca el siguiente código:
Necesitamos saber qué botón provocó el evento. Para ello, utilizamos el objeto remitente que es especial
objeto que contiene la referencia de objeto de la vista que generó el evento en el evento de rutinario.
Para tener acceso a los parámetros de la vista que planteó la

evento declaramos una variable local vista Dim enviar como botón.
Y conjunto
Enviar = Sender.
Luego a hacer la diferencia entre el botón de retroceso y

el teclado NUMERICO usamos un Select \/ carcasa \/ finalizar Seleccione
estructura y uso el parámetro de la etiqueta de los botones. Recuerde,
Cuando agregamos los diferentes botones establecemos su parámetro de etiqueta
a BS, 0, 1, 2, etc..
Seleccione Send.Tag establece la variable para probar.

Caso \"BS\" comprueba si es el botón con el valor de la etiqueta de \"BS\".
Otro caso maneja todos los botones.
Ahora añadimos el código para el teclado NUMERICO.

Queremos agregar el valor del botón al texto en la etiqueta de lblResult.
Esto se hace en línea 75 con

lblResult.Text = lblResult.Text
El\"
el botón que provocó el evento.
Ahora añadimos el código para el botón de retroceso.
Al hacer clic en el botón de BS en que debemos eliminar el último carácter del texto existente
lblResult.
Sin embargo, esto sólo es válido si la longitud del texto es mayor que 0. Esto se comprueba con:
Si lblResult.Text.Length > 0 Then
Para quitar el último carácter utilizamos la función SubString2.

lblResult.Text = lblResult.Text.SubString2 (0,lblResult.Text.Length - 1)
SubString2 (BeginIndex, EndIndex) extrae un nuevo comienzo de la cadena en BeginIndex (inclusive) hasta
EndIndex (exclucive).
Ahora la rutina toda está terminada.

Podemos intentar mejorar la interfaz de usuario del programa en agregar algunos colores a la lblComments
Etiqueta.
Debemos definir:
-Amarillo para un nuevo problema
-Luz verde para una buena respuesta
-Luz roja para una respuesta equivocada.
Permítanos primero modificar la nueva rutina, donde agregamos línea 55.
Y en la rutina CheckResult agregamos líneas 62 y 66.

Otra mejora sería ocultar el botón '0' para evitar entrar en un líder '0'.
Para ello, podremos ocultar el botón en la subrutina nuevo en línea 57.
Además, en la subrutina btnEvent_Click, podremos ocultar el botón si la longitud del texto en

lblResult es igual a cero y mostrarlo si la longitud es mayor que cero, las líneas de 85 a 89.
Cuando nosotros estamos accediendo a btn0 en el código que hay que declararlo en la rutina de Globals.
Modificar línea 12 como a continuación:

4 El IDE 47 Basic4Android Guía del principiante
4 El IDE
El entorno de desarrollo integrado.
Al ejecutar el IDE obtendrá un formulario similar a la siguiente imagen:

Ejemplo: SecondProgram.b4a.
4.1 Menú y barra de herramientas
4.1.1 Toolbar
Genera un nuevo proyecto vacío.

Carga un proyecto.
Guarda el proyecto actual.
Copia el texto seleccionado al Portapapeles.
Corta el texto seleccionado y lo copia en el Portapapeles.
Pega el texto en el Portapapeles en la posición del cursor.
Deshace la última operación.
Rehace la operación anterior.
Activa la función Buscar y reemplazar.
Establece las líneas seleccionadas como comentarios.
Uncomments las líneas seleccionadas.
Navegar hacia atrás
Navegar hacia delante
Agrega un marcador.
Elimina un marcador.
Volver al marcador anterior.
Avanzar al siguiente marcador.
Función de Autocompletar Ctrl + espacio.
Disminuir la sangría de las líneas seleccionadas.
Aumentar la sangría de las líneas seleccionadas.
Se ejecuta el compilador.
Lista de opciones del compilador y depuración
Lista de rutina
4.1.2 Menú de archivo
Nuevo Genera un nuevo vacío

proyecto.
Open Source Carga un proyecto.
Guardar Guarda el proyecto actual.
Exportar como Zip exporta todo el proyecto
en un archivo zip.
Configuración de Configuración
página de las páginas para impre
Imprimir vista previa muestra una vista previa de imp
Impresión Imprime el código.
Lista de los últimos programas cargados.
4.1.3 Editar menú
Corte Corta el texto seleccionado y lo copia a la

Portapapeles.
Línea de corte Cortes de la línea de la posición del cursor.
Copia Copia el texto seleccionado al Portapapeles.
Pasta Pega el texto en el Portapapeles en la posición del cursor
posición.
Deshacer Deshace la última operación.

Rehacer Rehace la operación anterior.
Encontrar Activa la función Buscar y reemplazar.
Comentario en bloque Establece las líneas seleccionadas como comentarios.

Bloque sin comentariosUncomments las líneas seleccionadas.
Eliminar todos los marcadores Marcadores.

Puntos de interrupción.
Quitar todos los puntos de interrupción
Contraer el código entero.

Esquematización
4.1.4 Menú de proyecto
Agrega un nuevo módulo

Añadir un módulo existente
Cambia el nombre del módulo

Quita el módulo actual
Oculta el módulo actual
Propiedades de la actividad, ver abajo.
Elige un icono para el programa.

Cambia el nombre del paquete.
Cambia el nombre de la aplicación.
Cambia la versión de la aplicación.
Está activada, el programa se instala en externo

almacenamiento de información.
No sobrescribir el archivo de manifiesto
Orientaciones compatibles, vea abajo.
Editor de manifiesto
Diferentes modos de compilación.
Agregar un nuevo módulo
Módulo de actividad
Módulo de código
Módulo de servicio
Propiedades de la actividad
El programa puede ser a pantalla completa o no

El programa puede incluir la barra de título o no.
Orientaciones compatibles
Ambos modos.
Retrato sólo.
Paisaje sólo.
4.1.5 Menú de herramientas
Opciones de IDE Vea a continuación
Limpiar la carpeta de archivos (archivosVea

no utilizados)
la página siguiente
Proyecto limpio Vea la página siguiente
Ejecutar el administrador de AVD
Configure Paths
Realizar captura de pantalla

Vea la página siguiente
Cambiar tamaño de tabulación.

Cambiar fuente.,
no se recomienda.
Word wrap, ver abajo.
Guardado automático, ver abajo.

Mostrar información sobre herramientas, vea
a continuación.
Configurar el tiempo de espera de proceso
Word wrap
Sin ajuste de texto. El final de la línea está oculto.
Con ajuste de texto. El final de la línea se envuelve a la línea siguiente.
Guardado automático
Guarda el programa al ejecutarlo.
Mostrar información sobre herramientas en escribir
Mostrar información sobre herramientas comprobado.
Mostrar información sobre herramientas desactivada.

Realizar captura de pantalla
El función puede llamarse desde el:

 Menú de herramientas cuando el IDE está en modo de edición
 Menú de depuración cuando el IDE está en modo de depuración
Haga clic en
muestra esta ventana.
Haga clic en para realizar la captura de pantalla

Foto desde el dispositivo o el emulador.
Puede guardar la imagen con

como un archivo PNG.
Y puede cambiar la orientación

de la imagen.
Limpiar la carpeta de archivos (archivos no utilizados)

Elimina los archivos que se encuentran en la carpeta de archivos pero no son utilizados por el proyecto (no eliminará
cualquier referencia de archivo por cualquiera de los diseños de proyecto). Se mostrará una lista de archivos no utilizados an
eliminación (y permite cancelar la operación).
Proyecto limpio Elimina todos los genera los archivos que se generan durante la compilación.
4 El IDE \/ 4.2 Código área 53 Basic4Android Guía del principiante
4.2 Código de área

El código del módulo seleccionado se mostrará en esta área y puede editarse.
Los ejemplos siguientes se basan en el código de la SecondProgram.
4.2.1 Deshacer – rehacer

En el IDE es posible deshacer las operaciones anteriores y rehacer operaciones de deshacer.
Haga clic en deshacer y para rehacer.
4.2.2 Contraer una subrutina

En el IDE se puede contraer una subrutina para minimizar el número de líneas que se muestran.
La rutina de btnAction_Click expandido.
Haga clic en la pequeña plaza de izquierda a

Sub para contraer la subrutina.
La rutina de btnAction_Click se derrumbó.
Flotando con el ratón sobre el nombre de rutina contraído muestra su contenido.

4.2.3 Contraer una región
En el código puede definir regiones y er estos.
Ejemplo:
# Region GPS establece el principio de una región y

Región # end Fin
A continuación, puede agregar las subrutinas entre los dos límites:
A continuación, haga clic en
se derrumba toda la región.
Flotando sobre GPS
muestra el comienzo del código, no todas las rutinas en la región.

4.2.4 Contraer el código completo
En el menú Edición existen tres

funciones:
-Cambiar todo
Se expande el colapsado
las rutinas y se derrumba el
rutinas extendidas y regiones.
-Se expande todos

Se expande el código completo
-Contraer todo
Contrae el código entero.
Haga clic en All ER.
El código de todo se derrumbó.
Flotando con el ratón sobre un

subrutina muestra todavía la
a partir de su contenido.
4.2.5 Comentando y uncommenting código
Una parte seleccionada del código puede ser establezca líneas de comentario o a la normalidad.
Código original
Seleccione el código.
Haga clic en .
Líneas de ajuste como comentarios.
Para definir las líneas a la normalidad.

Seleccione las líneas y haga clic en .
4.2.6 Marcadores
Puede configurar 'Favoritos' en todas partes en el código y saltar hacia delante y hacia atrás entre estos
marcadores.
Para definir un marcador, coloque el cursor en el

línea deseada, 12 en este ejemplo.
Haga clic en .
El signo del marcador se muestra en la izquierda

margen.
Para eliminar un marcador, coloque el cursor
en la línea y haga clic en .
Haga clic en para avanzar al siguiente marcador.
Haga clic en para saltar hacia atrás al marcador anterior.
En menú puede eliminar todos los marcadores

4.2.7 Sangría
Una buena práctica es usar la sangría de las piezas de código.

Por ejemplo para subrutinas, bucles, estructuras, etc..
Este código es difícil de leer porque el

estructura del código no es obvia.
Este código es mucho más fácil de leer,

la estructura del código es de
evidencia.
Un valor de tabulación de 2 para la

sangría es un buen valor.
Ejemplo con un
sangría de 4
Personalmente, prefiero un valor

2.
Todo bloques de código pueden aplicarse sangría hacia adelante y hacia atrás a la vez.
Código original
Seleccione el bloque de código.
Haga clic en .
Todo el bloque ha movido una tabulación a la

derecho.
Para mover un bloque a la izquierda.

Seleccione el código y haga clic en .
El valor de la sangría puede cambiarse en el menú Herramientas.
Introduzca el valor y haga clic en .

4.2.8 Autocompletar
Una herramienta muy útil es la función de Autocompletar.

Ejemplo:
Déjenos escribir lblN
Pulse Ctrl + espacio o haga clic en .
Todas las variables, opiniones y nombres de parámetro

comienzo con las cartas ya escritas son
se muestra en un menú emergente con la ayuda en línea
para la variable resaltada, ver o
nombre del parámetro.
Elegir lblNumber1 Presione retorno.
Para elegir lblNumber2 Oprima la tecla menos

flecha y presione retorno.
Se completa el nombre seleccionado.
Después de presionar \".\" todos los parámetros y métodos son

muestra en un menú emergente.
Al seleccionar un elemento, el
ayuda interna se muestra
Pulsando arriba o abajo

las flechas selecciona la anterior
o procede con su ayuda.
Presionando un personaje actualiza

la lista y muestra la
a partir de parámetros
ese carácter.
La mejor forma de aprenderlo es 'jugar' con ella.

Una segunda función de Autocompletar permite crear subrutinas de evento.
Ingrese la palabra Sub + un carácter en blanco.
Presiona Tab.
Seleccione el tipo de botón en nuestro ejemplo.
Seleccione el tipo, haga clic en nuestro ejemplo.
Se genera el marco de la subrutina.
Modificar 'EventName' a la EventName del botón, 'bntOK' en nuestro caso.
La rutina está lista.

4.2.9 Saltar a una subrutina
A veces resulta útil pasar de una llamada de subrutina a la definición de subrutina.

Esto puede realizarse fácilmente:
 Seleccione el texto de la llamada de subrutina.
 Haga clic con el botón derecho sobre el texto selecciona
 Haga clic en declaración Goto Sub
 Y tú estás allí.
4.2.10 Destacando las ocurrencias de palabras
Al seleccionar una palabra, ésta se resalta en azul oscuro y son todas las ocurrencias en el código
resaltado en azul claro y en el scrollview del lado derecho.
Con el deslizador puede subir o bajar el código para ir a las otras ocurrencias.
Lo mismo ocurre con los puntos de interrupción.

4.2.11 Depuración
Para permitir la depuración le debe activar la opción de depuración en la parte superior del IDE.
Si se selecciona esta opción el código compilado contendrá código de depuración.

El código de depuración permite el IDE conectar con el programa y revísela mientras se ejecuta.
Cuando se inicia el programa, esperará hasta 10 segundos para el IDE conectar. Generalmente el IDE
se conectará inmediatamente. Sin embargo, si ejecuta el programa manualmente desde el teléfono, verá
se espera.
El nombre del archivo compilado APK terminará con _DEBUG.apk. Usted no debe distribuir esta apk
archivo que contiene el código de depuración que añade una sobrecarga significativa. Para distribuir archivos
debe seleccionar la opción de liberación.
Cuando ejecutamos el programa con la opción de depuración, el IDE abrirá el módulo de depurador en la
parte inferior de la pantalla:
Notas sobre el depurador:

 Se omitirán los puntos de interrupción en los siguientes subs: Globals, Process_Globals y
Activity_Pause.
 Servicios - puntos de interrupción que aparecen después de una llamada a StartService será ignorada. Puntos de inter
en Service_Create y Service_Start se pone en pausa el programa para un tiempo específico
(aproximadamente 12 segundos). Esto es para evitar el OS desde matando el servicio.
 Eventos que se ejecutará el fuego cuando el programa está en pausa. Puntos de interrupción del código en el evento
se omitirá (sólo cuando el programa ya está en pausa).
 Los datos enviados desde el dispositivo al IDE está limitados en tamaño. Cadenas largas pueden truncarse.
 Cuando se ejecuta el depurador, el IDE es de sólo lectura. El usuario no puede cambiar cualquiera de los
texto del programa.
Las dos utilidades principales para la depuración son:
Puntos de interrupción - puede marcar líneas de códigos como los puntos de interrupción. Esto se hace pulsando sobre la zona
izquierda de la línea.
El programa se detendrá cuando llegue a un punto de interrupción y le permitirá inspeccionar el estado actual.
Registro - la ficha de registros en el panel de la derecha es muy útil. Muestra mensajes relacionados con la
ciclo de vida de componentes y también pueden mostrar los mensajes que se imprimen con la palabra clave de registro. Usted
debe pulsar en el botón Conectar para conectarse a los registros del dispositivo. Tenga en cuenta que hay un filtro
casilla de verificación. Cuando se registra sólo verá mensajes relacionados con su programa. Cuando es
que verá todos los mensajes que se ejecutan en el sistema. Si le surgen un error y
no veo ningún mensaje relevante en el registro, vale desmarcar la opción de filtro y buscando
un mensaje de error.
Tenga en cuenta que el registro es mantenido por el dispositivo. Cuando se conecte a un dispositivo también verá
mensajes anteriores.
Para distribuir el proyecto se debe compilar con:

 Relase
El código de depurador no se agregará al archivo apk.
 Liberación (ofuscado)
El código de depurador no se agregará al archivo apk.
Pero el archivo de programa será modificado, ver abajo.
Basic4android v1.8 incluye una nueva característica de ofuscación de código.

Durante la compilación Basic4android genera código Java que luego se compila con Java
compilador y convertir en Dalvik (formato de código de bytes de Android).
Existen herramientas que permiten la descompilación del código de bytes de Dalvik en código Java.
El propósito de ofuscación es hacer que el código descompilado menos legible, más difícil de entender y
hacen más difícil extraer cadenas como desarrollador cuenta claves.
Es importante entender cómo funciona el Ofuscador.

El Ofuscador hace dos cosas:
Ofuscación de cadenas
Cualquier cadena escrita en Process_Globals sub (y sólo en este sub) será ofuscado, haciéndola mucho
más difícil de extraer claves importantes. Las cadenas son defuscated en tiempo de ejecución.
Tenga en cuenta que varias teclas se utilizan durante la ofuscación, incluyendo el nombre del paquete, el nombre de la versión
Código de versión. Modificar estos valores con el editor de manifiesto se romperá el proceso de defuscation.
Cambiar el nombre de variables

Los nombres de las variables globales y subs se convierten en cadenas sin sentido. Las variables locales
no se ven afectados, como sus nombres se pierden de todas formas durante la compilación.
No se cambia el nombre de los siguientes identificadores:
-Identificadores que contienen un carácter de subrayado (requiere para los controladores de eventos).
-Subs que aparecen en las declaraciones de CallSub. Sólo si el nombre de sub aparece como una cadena estática y luego la
identificador se mantendrá como está.
-Nombres diseñador de vistas.
Consejo: Si, por alguna razón, necesita evitar el Ofuscador para cambiar el nombre de un identificador debe agregar
un guión bajo en el nombre del identificador.
Se creará un archivo llamado ObfuscatorMap.txt en la carpeta de objetos. Este archivo asigna el

originales nombres de identificadores para los nombres ofuscados. Esta asignación puede ser útil para analizar accidente
informes.
Activar el Ofuscador
Basic4android versión 1.8 hace más simple elegir el modo de compilación.
4.2.12 Puntos de interrupción
Haciendo clic en una línea en el margen izquierdo, agrega un punto de interrupción. Cuando se ejecuta el programa se deteng
primer punto de interrupción.
Ejecutar el programa, el programa se detiene en el punto de interrupción y el IDE se parece a continuación. El punto de interr
línea es resaltada en amarillo.
En la parte inferior del IDE encontrará otra información.
Depurador está conectado.

Haga doble clic para soltar el Debuger.
Nombre de la rutina donde se detuvo el programa.

Nueva rutina en línea 52.
Llamar a la rutina de la rutina de nueva.

Rutina de Activity_Create en la línea 24.
Al hacer clic en estos enlaces salta el cursor a la línea dada.

Continuar con la ejecución de código

equivalente a F5.
Continúa la ejecución hasta el final o el siguiente punto de quiebre.
Paso a la siguiente línea equivalente a F8.

Continúa la ejecución a la línea siguiente, muy interesante durante la depuración para ver la
flujo del programa real y la evolución de los valores de las variables.
Pausa el código tan pronto como sea posible.
Detener el programa actual equivalente a F11.

También detiene el programa en el emulador.
Detener el programa en el emulador no termina en el IDE!
Variables globales.
Lista de la global
objetos y variables
utilizado por el programa
con sus valores y
parámetros.
Ejemplos:
btnAction: tipo = botón izquierdo = Top 190 = 0 Width = altura 115 = 55 Tag = texto vacío = OK
Número1 = 6
Variables locales.
Ninguno en este ejemplo.
Flotando con el ratón sobre una variable muestra

su valor.
Flotando con el ratón sobre una vista, sus parámetros como muestra en la lista.
Debemos ejecutar el programa paso a paso:
Establecer un punto de interrupción en la línea de 50.
Haga clic en para ejecutar el programa o presione F5.
El programa se detendrá en la línea de 50.
Los valores de los dos números en el

Ventana de variables globales,
ha sido reducido para mostrar sólo los dos números.
Haga clic en F8.

El programa ejecuta la siguiente línea de código.
Ha cambiado el valor de Número1!
Haga clic en F8.

El programa ejecuta la siguiente línea de código.
El valor de número2 ha cambiado!

4 El IDE \/ 4.3 fichas 68 Basic4Android Guía del principiante
4.3 Fichas
Hay 4 fichas en la parte inferior derecha del IDE que

mostrar la siguiente información.
4.3.1 Módulo de y subrutina listas

Todos los módulos del proyecto y todas las subrutinas del módulo seleccionado aparecen en dos listas en el
derecho del IDE.
Lista de módulos
Al hacer clic en un módulo muestra su código en el área de código.
Lista de subrutina del módulo seleccionado

Al hacer clic en una subrutina muestra su código en medio de
el área de código.
En el IDE, en la esquina inferior derecha.

4.3.2 Archivos
Esta ventana muestra todos los archivos que se han agregado al proyecto.
Estos archivos se guardan en la carpeta Files.DirAssets.
Estos pueden ser cualquier tipo de archivos: diseños, imágenes, textos, etc..
Haga clic en para agregar archivos a la lista.

Se accede a los archivos de esa carpeta con
File.DirAssets.
Verificación de uno o más archivos permite la
botón.
Al hacer clic en este botón elimina los archivos seleccionados de la

lista de la carpeta de archivos del proyecto.
Asegúrese de tener una copia de los archivos que quitar, porque ellos se quitan los archivos
carpeta, pero no se transfieren a la papelera de reciclaje, que significa que son definitivamente perdidos si no
tener una copia.
Ver capítulo archivos para manejo de archivos.

4.3.3 Registros
Visualización de comentarios de registro generado por el programa cuando se está ejecutando.
Añadimos las dos líneas 51 y 53 en el programa 'SecondProgram' en la rutina del 'Nuevo'.
Ejecute el programa.
Haga clic en para conectar el registrador.
En la ventana vemos el flujo de la

programa.
Crear actividad (principal), isFirst = true

Primero mensaje de registro
Segundo mensaje de registro
Reanudación de la actividad (principal)
Cuando se activa el filtro sólo verá mensajes relacionados con su programa. Cuando se
no está marcada, verá todos los mensajes que se ejecutan en el sistema. Si le surgen un error
y no ve ningún mensaje relevante en el registro, merece la pena desmarcar la opción de filtro y mirando
para un mensaje de error
Haga clic en limpiar la ventana de registros.
Si todavía se está ejecutando el depurador, seleccione depuración > Stop en el menú IDE, presione F11 o haga clic en
por lo que se puede editar el código.
4.3.4 Libs
Lista de las bibliotecas disponibles que se pueden utilizar en el proyecto.
Compruebe las bibliotecas que usted necesita para su proyecto.

Asegúrese de que tiene la última versión de las bibliotecas.
La documentación de las bibliotecas puede encontrarse aquí:

Basic4android - Android programación con el diseñador de Gui
5 Tamaños de pantalla y resoluciones 72 Basic4Android Guía del principiante
5 Tamaños de pantalla y resoluciones

Existen muchos tamaños de pantalla diferentes con diferentes resoluciones y densidades de pixel.
Debemos hacer la diferencia entre los siguientes parámetros.
-Tamaño de pantalla física Ex: 3,6 '' diagonal
-Resolución en píxeles Ex: 320 \/ 480
-Píxeles densidad por pulgada Ex: 160
La pantalla estándar es 320 \/ 480 píxeles, densidad 160 píxeles\/pulgada.

Existen otras pantallas con casi el mismo tamaño físico, pero con una mayor resolución para
ejemplo 480 \/ 640 píxeles con una densidad de 240 píxeles\/pulgada.
Tabletas tienen mayor tamaño físico pero pueden tener una densidad similar a la pantalla estándar.
Ejemplo: 7.2 '' pantalla diagonal, 640 \/ 960 píxeles y una densidad de 160 píxeles\/pulgada.
Una lista no exhaustiva de las pantallas:
Diagonal Resolución Densidad Escala W \/ H Ratio

3.6 320 \/ 480 160 1 3 \/ 2
3.6 480 \/ 720 240 1.5 3 \/ 2
3.9 480 \/ 800 240 1.5 5 \/ 3
3.6 240 \/ 320 120 0.75 4 \/ 3
7.2 640 \/ 960 160 1 3 \/ 2
10 720 \/ 1280 160 1 16 \/ 9
Comparemos las siguientes resoluciones:

1) 320 \/ 480 \/ 160 pantalla ~3.5'' densidad estándar 160
2) 480 \/ 800 \/ 240 pantalla ~3.5'' densidad 240
3) 640 \/ 960 \/ 320 pantalla ~3.5'' densidad 320
4) 640 \/ 960 \/ 160 ~ 7'' pantalla densidad estándar 160
En los casos 1) 2) y 3) el tamaño físico de las pantallas es iguales pero la densidad de los píxeles es
diferentes.
En los casos 1) y 4) las densidades son los mismos pero las dimensiones físicas de la pantalla en el caso 4)
son el doble de los de la pantalla en el caso 1) dando así una superficie cuatro veces mayor.
Veamos ahora el tamaño de un botón con 80 \/ 80 dip, su tamaño físico.

dips píxeles pulgadas
1) 80 80 0.5
2) 80 120 0.5
2) -- 80 0,375 dimensión en píxeles no en dips
3) 80 160 0.5
3) -- 80 0.25 dimensión en píxeles no en dips
4) 80 80 0.5
DIP = píxel de densidad independiente
Es posible generar especiales emuladores con tallas especiales, densidades y resoluciones.

Un mismo archivo de diseño puede encajar en diferentes resoluciones de pantalla, pero con algunas restricciones.
Utilizaremos el programa TestLayouts para probar el mismo diseño con diferentes resoluciones de pantalla.
El código fuente se encuentra en el directorio de \\SourceCode\\TestLayouts de <Guide>.
Las diferentes resoluciones son:
Pantalla Densidad H \/ W ratio Altura de Eqivalent Píxel diff.

resolución píxeles
240 \/ 320 120 4 \/ 3 360 -40
320 \/ 480 160 3 \/ 2 480 0
480 \/ 800 240 5 \/ 3 720 + 80
La resolución de referencia es de 320 \/ 480 con una densidad de 160.

Si calculamos, para las otras dos resoluciones, la altura equivalente utilizando la misma proporción de H\/W obtenemos
la altura equivalente en píxeles y la diferencia en píxeles.
Esto significa que con el mismo archivo de diseño para todas las tres resoluciones habrá 40 píxeles que faltan
con la resolución 240\/320 y 80 píxeles adicionales con la resolución de 480\/800.
El diseño original de la densidad estándar de 320\/480 píxeles 160

Emulador es el siguiente.
Para realizar las pruebas necesitamos tres emuladores:

-320 \/ 480 densidad 160
-240 \/ 320 densidad 120
-480 \/ 800 densidad 240
Si no tienes estos emuladores, debe crear en la AVD

Manager. Busque aquí para generar un emulador.
Y el código es:
Tenga en cuenta que las líneas 23 y 24 son comentadas!

Pruebas con los tres emuladores con diferentes resoluciones y diferentes densidades.
480 \/ 800 240 320 \/ 160 480 240 \/ 120 320
Los tamaños de imagen son reducidos por un factor de 0,5 para fácil comparación.
Lo que vemos:
- con la resolución estándar, la imagen en el emulador es igual al diseño original.
- con la resolución 240\/320 vemos que hay los 'esperados' 40 píxeles que faltan.
- con la resolución de 480\/800, vemos que hay el píxel extra 80 'esperado'.
Los números de los elementos de ListView son las mismas para todos los tres resoluciones.
Segunda prueba con líneas 23 y 24 activado.
En la línea 23 calculamos la parte superior del panel pnlToolBox según la altura de la pantalla.
En línea 24 calculamos la altura de ListView según la parte superior de la pnlToolBox.
Lo que vemos:
- con la resolución estándar, la imagen en el emulador es todavía igual al diseño original.
- con la resolución 240\/320, vemos que los botones están en la parte inferior de la pantalla, pero la
Altura de ListView se acorta.
- con la resolución de 480\/800 vemos que los botones están en la parte inferior y ListView
mayor.
Los números de los elementos de ListView son diferente en los tres diseños porque la altura de ListView
se ha adaptado a la altura de la pantalla relativa diferente.
En la primera prueba, el número de elementos en el control ListView eran iguales!
Estos ejemplos muestran que no es fácil tener un diseño para diferentes resoluciones de pantalla.
En el ejemplo anterior era relativamente fácil porque la vista en el medio es fácilmente ajustable.
Incluso cuando carga el archivo de diseño en los emuladores de tres resoluciones de 480 \/ 800, 320 \/ 480 y
240 \/ 320 píxeles el diseño está estirada o reducido según el tamaño de la pantalla, pero vemos naturalmente
también los extras y faltantes píxeles dependiendo de la altura de la pantalla relativa diferente.
El sistema de Android OS autoscale ajusta la izquierda, arriba, anchura, altura, FontSize y otros
los parámetros con la escala de factor, pero no cambia de tamaño las posiciones verticales ni las alturas de la
vistas proporcionales a la altura de la pantalla. Lo mismo es válido para el ancho en el modo paisaje.
5.1 Funciones especiales como 50% x, 50dip
Hay funciones especiales para accomode diferentes tamaños de pantalla y resolución.
5.1.1 PerXToCurrent, PerYToCurrent - 50% x
PerXToCurrent (porcentaje como Float) o 50% x
PerXToCurrent(50) significa el 50% del ancho de la actividad.

Puede escribirse como un acceso directo: 50% x.
50% x es igual a Activity.Width * 0.5
PerYToCurrent(30) significa el 30% de la altura de la actividad.

Puede escribirse como un acceso directo: 30% y.
30% y es igual a Activity.Height * 0,3
5.1.2 DipToCurrent - 50dip
DipToCurrent (longitud como Int) o 50dip
DipToCurrent calcula una dimensión con la longitud dada según la escala de la actual
dispositivo.
DipToCurrent(50) es igual a 50 * DeviceScale

Puede escribirse como un acceso directo: 50dip píxeles independientes de densidad
La resolución 'estándar' es 160 dpi (puntos por pulgada) y escala 1.

Sin espacios entre el número y dip!
Si tenemos un botón con una dimensión de escala estándar de 50 * 50 píxeles, para definir sus dimensiones nos
debe set Button1.Width = 50dip y Button1.Height = 50dip.
Dependiendo de la escala, la dimensión del botón será:
Escala Píxeles
1 50 * 50
1.5 75 * 75
Ejemplo:
Dim Button1 As botón
Button1.Initialize(\"Button1\")
Activity.AddView (Button1, 20% x, 30% y, 100dip, 50dip)
Los valores de las propiedades en el diseñador de izquierda, superior, ancho y altura son considerados como
valores de la DIP.
5.2 Trabajar con diferentes tamaños de pantalla \/ número de diseños
Con el gran número de dispositivos, con diferentes tamaños de pantalla y resoluciones, disponibles en el mercado
resulta más complicado diseñar un proyecto que se ve bonito en todos los dispositivos disponibles.
No hay ninguna regla universal para manejar este problema, depende de:
 ¿Qué tipo de proyecto está diseñando.
 ¿Qué dispositivos y la pantalla le tamaños son certero.
 Lo que desea mostrar en las pantallas diferentes.
 Un mismo diseño pero estirada según los tamaños de pantalla.
 Variantes de diseño diferente para los diferentes tamaños, en una pantalla grande que pueden ser más vistas
muestra al mismo tiempo.
Resumen de los tamaños de pantalla físico diferente, cada tamaño puede tener diferentes resoluciones, densidades
escalas y proporciones.
resolución escala de densidad relación de aspecto
 ~ 3.0'' - 4.0 ''
 320 \/ 240 120 0.75 4 \/ 3 1,333
 480 \/ 320 160 1 3 \/ 2 1.5
 640 \/ 480 240 1.5 4 \/ 3 1,333
 800 \/ 480 240 1.5 5 \/ 3 1.667
 854 \/ 480 240 1.5 16 \/ 9 1,78
 960 \/ 540 240 1.5 16 \/ 9 1,78
 960 \/ 640 240 1.5 3 \/ 2 1.5
 1280 \/ 720 320 2 16 \/ 9 1,78
 ~ 5.5 ''
 1280 \/ 800 240 1.5 8 \/ 5 1.6
 ~ 7 ''
 1024 \/ 600 160 1 1.71
 1280 \/ 800 160 1 8 \/ 5 1.6
 ~ 10 ''
 1024 \/ 600 160 1 1.71
 1024 \/ 768 160 1 4 \/ 3 1,333
 1280 \/ 800 160 1 8 \/ 5 1.6
Dependiendo de lo que desea que aparezca en las pantallas diferentes puede:

 Diseño de variantes de diseño diferente.
Dos diseño variantes (vertical y horizontal) para cada dimensión.
Las vistas se redimensionan automáticamente para las diferentes densidades.
Sin embargo podría necesita tener en las proporciones de diferente anchura y altura de cuenta (proporciones),
Este ajuste puede hacerse en el código o necesitaría dos variantes de diseño más.
 Calcular todas las dimensiones de vista y posiciones en el código mediante
%x , %y y DIP dimensiones.
Para la comparación:
 Una pantalla 5.5'' tiene una superficie de aproximadamente 2,5 veces más grande que una pantalla de 3,5 ''.
 Una pantalla de 7'' tiene una superficie de aproximadamente 4 veces más grande que una pantalla de 3,5 ''.
 Una pantalla de 10'' tiene una superficie de aproximadamente 9 veces más grande que una pantalla de 3,5 ''.
Los ejemplos siguientes muestran un mismo desplegado de diseño en el código para ajustar los tamaños de pantalla diferente
El código fuente es OneLayoutStreched, las imágenes son imágenes de emulador.
~3.5'' 240 \/ 320 ~3.5'' 320 \/ 480 ~3.5'' 480 \/ 800 ~5.5'' 800 \/ 1280 \/ 240
7 '' 800 \/ 1280 \/ 160 10 '' 800 \/ 1280 \/ 160
Probablemente no es la mejor solución para tener el mismo desplegado de diseño para todos los tamaños de pantalla.
Podría ser más interesante mostrar más vistas en las pantallas más grandes.
Código para comprobar el tipo de dispositivo:
Sub CheckDeviceType
' comprobar el tipo de dispositivo utilizado para definir tamaños de texto
' debe completarse si es necesario
LV = GetDeviceLayoutValues
Seleccione lv.Escala
Caso 2
DeviceType = \"Smartphone 5\"
TextSizeRatio = 1.5
Caso 1.5
Si lv.Ancho > 1100 entonces
DeviceType = \"Tableta de 7\"
TextSizeRatio = 2
Else
DeviceType = \"Smartphone 3.5\"
TextSizeRatio = 1
End If
Caso 1
Si lv.Ancho > 1100 entonces
DeviceType = \"Tablet 10\"
TextSizeRatio = 3
Else If lv.Ancho < 600 entonces
DeviceType = \"Smartphone 3.5\"
Else
DeviceType = \"Tableta de 7\"
TextSizeRatio = 2
End If
End Select
End Sub
Parte del código para establecer las dimensiones de la vista.
ArgumentException: The incoming token has expired. Get a new access token from the Authori
ArgumentException: The incoming token has expired. Get a new access token from the Auth
Si Activity.Width > Activity.Height entonces

WB = 100% y \/ 4
pnlToolbox.Left = 100% x - wb
pnlToolbox.Width = wb
pnlToolbox.Height = 100% y
pnlToolbox.Top = 0
btnTest1.Left = 0
btnTest1.Width = wb
btnTest1.Top = 0
btnTest1.Height = wb
.
lblTitle.Left = 10% x
lblTitle.Width = 80% x - wb
lblTitle.Top = 0
lblTitle.Height = 100% y \/ 8
lstTest.Left = 5% x
lstTest.Width = 90% x - wb
lstTest.Top = lblTitle.Height
lstTest.Height = 100% y - lstTest.Top
lstTest.TwoLinesLayout.Label.Height = 12% y
lstTest.TwoLinesLayout.Label.Top = 0
lstTest.TwoLinesLayout.SecondLabel.Height = 10% y
lstTest.TwoLinesLayout.SecondLabel.Top = 12% x
lstTest.TwoLinesLayout.ItemHeight = 24% y
Else
WB = 100% x \/ 4
pnlToolbox.Left = 0
pnlToolbox.Width = 100% x
pnlToolbox.Height = wb
pnlToolbox.Top = 100% y - wb
btnTest1.Left = 0
btnTest1.Width = wb
btnTest1.Top = 0
btnTest1.Height = wb
.
lblTitle.Left = 10% x
lblTitle.Width = 80% x
lblTitle.Top = 0
lblTitle.Height = 100% x \/ 8
lstTest.Left = 5% x
lstTest.Width = 90% x
lstTest.Top = lblTitle.Height
lstTest.Height = pnlToolbox.Top - lstTest.Top
lstTest.TwoLinesLayout.Label.Height = 12% x
lstTest.TwoLinesLayout.Label.Top = 0
lstTest.TwoLinesLayout.SecondLabel.Height = 10% x
lstTest.TwoLinesLayout.SecondLabel.Top = 12% x
lstTest.TwoLinesLayout.ItemHeight = 22% x
End If
btnTest1.Text = \"Prueba 1\"

btnTest1.TextSize = 16 * TextSizeRatio



lblTitle.Text = \"Prueba de diseño\"

lblTitle.TextSize = 20 * TextSizeRatio
lstTest.TwoLinesLayout.Label.TextSize = 20 * TextSizeRatio
lstTest.TwoLinesLayout.Label.Gravity = Gravity.CENTER_VERTICAL
lstTest.TwoLinesLayout.Label.Color = Colors.Blue
lstTest.TwoLinesLayout.SecondLabel.TextSize = 16 * TextSizeRatio
lstTest.TwoLinesLayout.SecondLabel.Gravity = Gravity.CENTER_VERTICAL
lstTest.TwoLinesLayout.SecondLabel.Color = Colors.Green
End Sub
En los siguientes ejemplos podemos ver la pantalla de una cuadrícula con botones. Las dimensiones del botón físico son
casi lo mismo. El código fuente es CodeLayout.
3.5'' 5.5'' 10''
El código fuente:
Dim I, j, k, nx, ny, x 0, x 1, x 2 como Int
x 0 = 4dip
x 1 = 60dip
x 2 = x 0 + x 1
NX = piso (Activity.Width\/x 2) - 1
NY = piso (Activity.Height\/x 2) - 1
k = 0
Para j = 0 A ny
Para i = 0 To nx
k = k + 1
Dim btn como botón
btn.Initialize(\"Btn\")
btn.Color = Colors.Red
Activity.AddView (btn, x 0 + i * x 2, x 0 + j * x 2, x 1, x 1)
btn.Texto = k
btn.TextSize = 20
Siguiente
Siguiente
Si desea mostrar más vistas en las pantallas más grandes debe definir dos variantes de diseño (uno para
Retrato y un paisaje) para cada tamaño de pantalla y resolución. Esto puede ser bastante
combersome.
Compromisos podrían ser utilizado, definir los diseños parcialmente en los archivos de diseño y parte en el código.
La adaptación de diferentes proporciones de aspecto podría hacerse en el código en lugar de diseño independiente
variantes.
Como ya se mencionó, no hay ninguna regla universal, la solución depende de diferentes factores.
Como un desarrollador debe definir sus necesidades y requerimientos en función de:
 ¿Qué tipo de proyecto está diseñando.
 ¿Qué tipo de datos que usted está recibiendo tratamiento, visualización, edición, etc..
 ¿Qué dispositivos y la pantalla le tamaños son certero.
 Lo que desea mostrar en las pantallas diferentes.
 Un mismo diseño pero estirada según los tamaños de pantalla.
 Variantes de diseño diferente para los diferentes tamaños, en una pantalla grande que pueden ser más vistas
muestra al mismo tiempo.
5.3 Orientaciones de pantalla
Pueden definirse tres valores de orientaion de pantalla diferentes:

 Retrato sólo
 Paisaje sólo
 Ambos
Estas orientaciones pueden ser bien definidas:

 En el IDE y son válidas para la actividad actual.
Pueden definirse diferentes orientaciones para diferentes actividades.
En el menú Proyecto \/ orientaciones compatibles
 En el código con la librería de teléfono

 Paisaje
Phone1.SetScreenOrientation(0)
 Retrato
 Ambos
Phone1.SetScreenOrientation(-1)
6 El emulador 85 Basic4Android Guía del principiante
6 El emulador
El emulador o dispositivo Virtual es un programa que simula dispositivos en el PC.
6.1 Lanzar un emulador
Para iniciar un emulador, haga clic en el IDE en el menú Herramientas en ejecutar el administrador de AVD.
.
Seleccione el emulador deseado.
El retrato emulador, en este caso. Haga clic en
Haga clic en
Espere hasta que esté listo el emulador, esto tomará bastante tiempo.
6.2 Crear un nuevo emulador
Agreguemos un nuevo emulador con una resolución de 480 \/ 800 píxeles, densidad 240.
En el administrador de AVD
Haga clic en
Introduzca el nombre emulador 480_800
Seleccione Android 2.2 – API nivel 8
Introduzca el 16.
Entre 480 y 800
Haga clic en
Haga clic en .
Cambio de 160 a 240.
Haga clic en .
Haga clic en .
Se añade el nuevo emulador.

6.3 Problemas de emulador
Lamentablemente, el emulador es bastante lento y a veces un dolor.
Cuando se ejecute el programa o conectar con el emulador desde el diseñador, a veces se quiere
Vea el siguiente mensaje.
Tienes dos opciones:

-Sí (Oui) para cancelar el proceso.
-No (no) continuar el proceso.
Mayoría de las veces cuando se hace clic , el proceso tendrá éxito.
Sin embargo, incluso después de que hace clic en , a veces verá siguiente mensaje.
En la mayoría de los casos, si se ejecuta el programa una vez más, se establecerá la conexión con el emulador
y funcionará correctamente.
Esto suele ocurrir cuando el emulador todavía se está ejecutando un programa o si el emulador es todavía
conectado a otro proyecto. En este caso, presione el botón back hasta llegar a la casa del emulador
pantalla e inténtelo de nuevo.
Si esto ocurre por segunda vez, cerrar el emulador actual y volver a ejecutarla desde la AVD
Manager.
Si el primer mensaje anterior aparece con demasiada frecuencia puede aumentar el valor de tiempo de espera del proceso.
6.3.1 Proceso timeout
En el menú de herramientas IDE.
Establezca el parámetro de ProcessesTimeoutSeconds en un valor más alto.

Muchas establecerlo a 45 segundos.
6.4 Intercambio de archivos con el PC
Para obtener acceso a archivos en el emulador puede utilizar al Dalvik Debug Monitor.
El nombre es ddms.bat y se encuentra en la carpeta donde copió el SDK de Android.
Ejemplo: C:\\Android\\android-sdk-windows\\tools.
Asegúrese de que está ejecutando el emulador.

Ejecute el archivo ddms.bat:
Aparecerá una ventana como esta.
Espere un momento.
Se mostrará el Dalvik Debug Monitor.

En la esquina superior izquierda debe ver un

referencia en el emulador.
Seleccionarlo.
Luego en el menú dispositivo
Seleccione File Explorer...
El explorador de archivos del dispositivo será displayd:
Ver varios
carpetas.
En data\\app te vas
encontrar aplicaciones.
mnt\\sdcard
es la
DirRootExternal
carpeta.
En el ejemplo de la
archivo persons.db es un
base de datos copiado en un
Programa B4A
DirAssets a
DirRootExternal.
En la esquina superior izquierda verá tres iconos:
Extraiga el archivo de dispositivo, copia el archivo a la PC

Archivo en el dispositivo, copias de un archivo en el dispositivo de empuje
Elimina el archivo
Al hacer clic en cualquiera

o muestra el explorador de archivos estándar de Windows para seleccionar el destino o
carpeta de origen para el archivo seleccionado.
Si no funciona el Dalvik Debug Monitor necesita agregar la ruta donde se encuentra el archivo ddms.bat
a las variables de entorno.
 Desde el escritorio, haga clic en mi PC y haga clic en propiedades.
 En la ventana Propiedades del sistema, haga clic en la ficha Avanzadas.
 En la sección de opciones avanzadas, haga clic en el botón Variables de entorno.
 Finalmente, en la ventana de Variables de entorno (como se muestra a continuación), resaltar la variable Path en
la sección sistemas Variable y haga clic en el botón Editar (modificador). Agregar o modificar las líneas de ruta
con las rutas desea que el equipo tenga acceso a. Cada directorio diferente se separa con un
punto y coma como se muestra a continuación.
7 B4A puente 94 Basic4Android Guía del principiante
7 Puente B4A
Hasta ahora existían dos métodos para probar la aplicación durante el desarrollo.
Usted puede ya sea trabajo con el emulador de Android o si el dispositivo admite la depuración de la ADB, estás
puede conectarse a su dispositivo real.
El emulador de Android es muy lento en comparación con un dispositivo real (especialmente con aplicaciones
instalación).
Por lo tanto, en la mayoría de los casos es más conveniente trabajar con un dispositivo real.
Personalmente, estoy usando el emulador sólo cuando se trabaja con el diseñador visual.
Sin embargo, no todos los dispositivos admiten depuración de ADB. Esta es exactamente la razón para la nueva B4A-
Herramienta de puente.
B4A-puente está formado de dos componentes. Un componente se ejecuta en el dispositivo y permite el segundo
componente que es parte del IDE para conectarse y comunicarse con el dispositivo.
La conexión se realiza a través de una red (B4A-puente no puede funcionar si no hay ninguna red disponible).
Una vez conectado, B4A-puente admite todas las características IDE que incluyen: instalación de aplicaciones,
Ver LogCat y el diseñador visual.
Android no permite a las aplicaciones silenciosamente instalar otras aplicaciones, por lo tanto, al ejecutar su
aplicación mediante B4A-puente, verá un cuadro de diálogo pidiendo su aprobación.
Getting started with B4A-puente
1. En primer lugar necesita instalar B4A-puente en el dispositivo.

B4A-puente puede descargarse aquí: http:\/\/www.basic4ppc.com\/android\/files\/b4a_bridge.apk.
B4A-puente también está disponible en Android market. Buscar: B4A puente.
Tenga en cuenta que se necesita para permitir la instalación de aplicaciones de \"Fuentes desconocidas\". Esto se hace
elegir la configuración de la pantalla de inicio - administrar aplicaciones.
2. Ejecutar B4A-puente en su dispositivo. Mostrará una pantalla similar a:
Estado será: a la espera de las conexiones.

3. En el IDE, elija Herramientas - B4A puente - conectar.

Debe ingresar la dirección IP que aparece en la pantalla del dispositivo.
La barra de estado en la parte inferior de la pantalla muestra el estado actual:
Eso es todo.
Cuando B4A-puente se conecta en primer lugar comprueba si la aplicación diseñador necesita ser actualizada. En
ese caso, primero instalará la aplicación diseñador.
B4A-puente sigue funcionando como un servicio hasta que usted oprima el botón Stop.
Usted siempre puede alcanzar mediante la apertura de la pantalla de notificaciones:
Pulsando en la notificación se abrirá la pantalla principal.
Como se mencionó anteriormente, cuando se ejecuta una aplicación deberá aprobar la instalación. Usted
normalmente se verá en las siguientes pantallas:
En el cuadro de diálogo anterior que debe elegir abrir para iniciar la aplicación.
Si intenta instalar una aplicación existente firmada con una clave diferente, la instalación fallará (sin
cualquier mensaje significativo). Debe desinstalar primero la aplicación existente. Ir a la pantalla de inicio
-Ajustes - aplicaciones - administrar aplicaciones - Elija la aplicación - desinstalación.
Una vez terminado desarrollando le debe pulsar el botón Stop para ahorrar batería.
Nota escrita con Basic4android B4A-puente.
El código fuente está disponible aquí: http:\/\/www.basic4ppc.com\/forum\/basic...html#post45854
8 El diseñador 97 Basic4Android Guía del principiante
8 El diseñador
El diseñador permite generar diseños con el emulador o un dispositivo real.
8. El diseñador \/ 8.1 el menú 98 Basic4Android Guía del principiante
8.1 El menú
8.1.1 Menú de archivo
Nuevo Se abre un nuevo diseño de vacío.

Abierto Abre un diseño existente.
Guardar Guarda el diseño actual.

Guardar como...Guarda el diseño actual con un nuevo nombre.
Principal Lista archivo de diseño, en este caso sólo un archivo, 'Main'.
8.1.2 AddView menú
Este menú le permite seleccionar la vista que desea agregar en el

diseño actual en el dispositivo o el emulador.
Botón agrega un botón

Casilla de verificación agrega una casilla de verificación
EditText agrega un EditText
ImageView agrega un ImageView
Etiqueta añade una etiqueta
ListView agrega un control ListView
Panel agrega un Panel
ProgressBar agrega un componente ProgressBar
RadioButton agrega un componente RadioButton
ScrollView agrega un Scrollview
SeekBar agrega un SeekBar
Spinner agrega una Spinner
TabHost agrega un TabHost
ToggleButton agrega un ToggleButton
Vista Web agrega una vista Web
8. El diseñador \/ 8.1 el menú 99 Basic4Android Guía del principiante
8.1.3 El menú Herramientas
Generar los miembros Generador de miembros
Traer al frente Trae la vista seleccionada al frente

Enviar al fondo
Duplicar seleccionado Vista duplica la vista seleccionada
Quitar de la vista seleccionadaQuita la vista seleccionada
Cuadrícula de cambio Permite cambiar el tamaño de la cuadrícula

Conectar al dispositivo se conecta el dispositivo o el emulador
Desconecte el dispositivo se desconecta el emulador o
el dispositivo.
Mostrar resumen diseñador

Ejecutar ScriptEjecuta el código de secuencia de comandos de las secuenci
8. El diseñador \/ 8.2 herramientas 100 Basic4Android Guía del principiante
8.2 Herramientas
8.2.1 Generar miembros

Permite generar declaraciones Dim y marcos para subrutinas.
La herramienta de generar miembros permite para generar automáticamente referencias y marcos de subrutina.
Haga clic en para abrir el generador.
Aquí encontramos todas las vistas en el diseño actual.

Verificamos todas las vistas y controlar el evento Click para el botón de btnAction.
Comprobación de una vista genera su referencia en la Globals Sub en el código. Esto es
necesarios para que la vista reconoce y permite la función de Autocompletar.
Al hacer clic en un evento de una vista genera el marco Sub para este evento.
Haga clic en para generar las referencias y sub marco y .

8.2.2 BringTo frontal
Cuando vistas se solapan, lo oculto o

vista parcial de oculto puede ser llevado al frente.
Haga clic en la vista para traer al frente para seleccionarlo.
Haga clic en
para hacer frente a la vista seleccionada.
Esto es especialmente interesante con grandes paneles.
8.2.3 Enviar al fondo
es
lo contrario de traer al frente.
8.2.4 Duplicar vista seleccionada
Haga clic en la vista que desee duplicar a

seleccionarlo.
Haga clic en
para duplicar la vista.
La vista se duplica.
8.2.5 Retire la vista seleccionada
Haga clic en la vista para quitar para seleccionarlo.
Haga clic en
para quitarlo.
Se ha quitado la vista.
Nota: Tenga cuidado, no se le pedirá si usted

realmente desea eliminar de la vista.
8.2.6 Cuadrícula de cambio
La cuadrícula es una cuadrícula invisible con un tamaño determinado. Tamaño de la cuadrícula predeterminado es de 10 pí
posiciones y dimensiones de una vista se ajustará a los valores en los pasos correspondientes al tamaño de la cuadrícula.
Mover una vista se hará en pasos iguales al tamaño de la cuadrícula.
Haga clic en
Puede cambiar el tamaño de la cuadrícula

el valor que desee.
8. El diseñador \/ 8.3 Configuración General 103 Basic4Android Guía del principiante
8.2.7 Conecte el dispositivo o el emulador
Haga clic en para conectarse a un dispositivo o un emulador.
Si se conectan los diferentes dispositivos o emuladores, se le pedirá que dispositivo o el emulador

¿desea conectarse.
Seleccione el emulador o el dispositivo en el

lista.
Haga clic en para confirmar.
8.3 Configuración general
Muestra el estado del diseñador, en este caso la

Diseñador está conectado.
Selecciona la vista actual a editar.
Cuando se selecciona el cuadro combinado de vista, presionando arriba o hacia abajo se moverá a través de la
vistas y las propiedades de la vista mostrará automáticamente.
La ventana se puede ajustar a permanecer siempre en la parte superior.

8. El diseñador \/ 8.4 archivos de imagen 104 Basic4Android Guía del principiante
8.4 Archivos de imagen
Puede agregar archivos de imagen para el diseño.
Haga clic en para seleccionar los archivos de la (s) para agregar.
Estos archivos se mostrarán en la lista de archivos de imagen.
Estos archivos se guardan en la carpeta de archivos del proyecto.
Para eliminar archivos, comprobar los archivos que desea eliminar
y haga clic en .
8. El diseñador \/ 8,5 lista de propiedades 105 Basic4Android Guía del principiante
8.5 Lista de propiedades
Una lista de las propiedades de la vista seleccionada

organizados en grupos.
Todas las propiedades pueden modificarse directamente en el

lista.
Todas las propiedades en el grupo principal y algunos de

las propiedades de los otros grupos son comunes
a todos los tipos de vista.
Explicación de algunas propiedades generales para todos los tipos de vistas:
Nombre Nombre de la vista. Es recomendable dar nombres descriptivos. Común

uso es dar un prefijo de 3 caracteres y agregar el propósito de la vista. En el ejemplo, la vista es de
Escriba la etiqueta y su propósito es introducir un resultado. Así que le damos el nombre \"lblResult\", \"lbl\" para
Etiqueta y \"Resultado\" para el propósito. Esto no lleva mucho tiempo durante el diseño del esquema
pero ahorra mucho tiempo durante la codificación y el mantenimiento del programa.
Tipo Tipo de la vista, no son editable. No es posible cambiar el tipo de una vista.
Si es necesario, debe quitar la vista y agregar uno nuevo.
Nombre del evento Nombre genérico de las subrutinas que administra los eventos de la vista. De forma predeterminada,
el nombre del evento es el mismo que el nombre de la vista como en el ejemplo. Los eventos de varias vistas
puede ser redirigido a una subrutina misma. En ese caso debe introducir el nombre de esa rutina.
Mirar el ejemplo de SecondProgram para la gestión de eventos de clic de los botones de la
teclado, la rutina btnEvent_Click.
Padre Nombre de la vista de los padres. Actividad, en el ejemplo. La vista padre puede ser
cambiado en la selección de uno nuevo en la lista.
Izquierda X coordenadas del borde izquierdo de la vista desde el borde izquierdo de su padre
Vista, en píxeles (los píxeles están en realidad dips, píxeles independientes de la densidad).
8. El diseñador \/ 8,5 lista de propiedades 106 Basic4Android Guía del principiante
Arriba Y coordinar del borde superior de la vista desde el borde superior de su padre
Vista, en píxeles (los píxeles están en realidad dips, píxeles independientes de la densidad).
Ancho Ancho de la vista en píxeles (los píxeles están en realidad dips, densidad
píxeles independientes).
Altura Altura de la vista en píxeles (los píxeles están en realidad dips, densidad
píxeles independientes).
Habilitado Habilita o deshabilita el uso de la vista Ex: activado = True
Visible Determina si la vista es visible para el usuario o no.
Etiqueta Este es un marcador de posición que puede utilizar para almacenar datos adicionales. Etiqueta pued
texto, pero también puede ser cualquier otro tipo de objeto. Etiqueta se utiliza en el ejemplo de SecondProgram para la
botones numéricos haga clic en gestión de eventos en la rutina btnEvent_Click.
8. El diseñador \/ 8,6 variantes de diseño 107 Basic4Android Guía del principiante
8.6 Variantes de diseño
Variantes de diseño diferente pueden gestionarse en un mismo archivo de diseño.
Hagamos un ejemplo basado en el proyecto de TestLayouts

(que puede encontrarse en el Directorio de Guide\\SourceCode\\TestLayouts):
-Copiar toda la carpeta TestLayouts.
-Cambiar su nombre a TestLayoutVariants.
-Renombrar el archivo TestLayout.b4a a TestLayoutVariants.b4a.
-Ejecute el IDE.
-Ejecutar el emulador (320 * 480 - 160)
-Ejecutar el diseñador.
-Conecte el diseñador para el dispositivo o el emulador.
El emulador debe tener este aspecto.

En el diseñador, haga clic en .
Seleccione:
480 x 320
escala = 1
Haga clic en
Se agrega la nueva variante.
Ir al emulador, presione Ctrl + F11, para cambiarlo al modo de paisaje.
Debe tener este aspecto.

La caja de herramientas no es visible, para que se la seleccionam

en el diseñador.
Y establezca su valor superior a 10.
Aparece el cuadro de herramientas.
Necesitamos escribir código para automáticamente

reorganizar las vistas del paisaje al modo
se utiliza.
Altura del botón 65
ListView1:
Ancho = 380
Altura = 220
En el código cambiamos la rutina de Activity_Create de
Para
Ejecute el programa.
El emulador debe tener este aspecto:
Haga clic en Ctrl + F11 para cambiar a retrato >>>
Ahora tenemos dos variantes de diseño en el mismo archivo de diseño.

Con el 320 * 240_120 emulador.
Podemos lograr un efecto similar en el diseñador cuando se selecciona una variante de diseño diferentes y nos
cambiar a modo de paisaje (Ctrl-F11).
8 El diseñador \/ 8.7 Resumen diseñador 112 Basic4Android Guía del principiante
8.7 El diseñador de resumen
El diseñador abstracto es una herramienta que muestra el diseño en una ventana independiente y es parte de la
Diseñador. Es mucho más rápido que el emulador.
Su objetivo principal es crear variantes de diseño diferente.
Los diferentes puntos de vista no se muestran con su forma exacta pero sólo como rectángulos coloreados.
Al hacer clic en una vista muestra sus propiedades en el diseñador.
Emulador Diseñador de resumen

8.7.1 El menú
Diseño
Partidos:
La variante elegida en la
Diseñador.
El dispositivo conectado.
Elección de la más actual

tamaños de pantalla y resoluciones.
Seleccione una resolución y posición

las diferentes opiniones según
las nuevas dimensiones y escala.
Zoom
Dos posibilidades:
50 %
100 %
Herramientas
Cambiar el tamaño de forma para adaptarse al diseño.
Agrega el diseño actual como una nueva variante de diseño en el

Diseñador.
8.7.2 Ejemplo
Tomemos un ejemplo simple con un diseño en el modo de retrato, como la imagen de abajo.
Ahora nos gustaría hacer una variante de paisaje.
Haga clic en el teléfono (paisaje) en el menú Diseño
El diseñador tiene el siguiente aspecto:
Haga clic en el menú Herramientas en

Agregar diseño actual como nueva variante
para agregar el modo de paisaje como un nuevo
variante en el archivo de diseño.
Ahora nos reorganizar las vistas para encajar

la nueva orientación.
En el diseñador vemos la nueva variante.
Si se selecciona en el diseñador
la variante anterior
verá la pantalla de la izquierda.

Haga clic en el menú de herramientas, cambiar el tamaño para encajar diseño de formulario
a cambia el tamaño de la ventana para ajustar el diseño.

8 El diseñador \/ 8.9 Scripts de diseñador 117 Basic4Android Guía del principiante
8.8 Agregar vistas por código
También es posible agregar vistas por código en lugar de utilizar el diseñador de un dispositivo, el emulador o
el diseñador abstracto.
Ventaja: usted tiene el control total de la vista.
Desventaja: tienes que definir casi todo.
El código fuente está en el directorio del código fuente: AddViewsByCode
Para las posiciones y dimensiones de las vistas en la pantalla dos opciones especiales están disponibles:
 DIP píxeles independientes de la densidad.
100dip = DipToCurrent(100) DipToCurrent es una palabra clave DIP es el acceso directo
100dip = 100 \/ 160 * densidad de dispositivo
La densidad por defecto es 160 dpi puntos por pulgada (píxeles por pulgada)
Densidades en Android:
o 120 escala 0.75
o 160 escala 1 predeterminado
o 240 escala 1.5
o 320 escala 2
 %x y %y representan las distancias proporcionales a la altura y anchura de la pantalla activa.

20% x = 0.2 * Activity.Width
90% y = 0.9 * Activity.Height
20% x = PerXToCurrent(20) PerXToCurrent es una palabra clave %x es el acceso directo
90% y = PerYToCurrent(90)
Ejemplo:
Pongamos una etiqueta encima de la pantalla y un Panel debajo de ella con una etiqueta y un botón en él:
8. El diseñador \/ 8,8 agregar vistas por código 118 Basic4Android Guía del principiante
'Diming' los puntos de vista.
Dim lblTitle, lblPanelTitle como etiqueta

Dim pnlTest como Panel
Como botón de Dim btnTest
Inicializando la etiqueta de título:

lblTitle.Initialize(\"\") Inicializa la etiqueta, no EventName requerido.
lblTitle.Color = Colors.Red Establece el color de fondo en rojo.
lblTitle.TextSize = 20 Establece el tamaño del texto a 20.
lblTitle.TextColor = Colors.Blue Establece el color del texto a azul.
lblTitle.Gravity = Gravity.CENTER_HORIZONTAL + Gravity.CENTER_VERTICAL
Establece la gravedad de la etiqueta.
lblTitle.Text = \"Title\" Establece el texto de la etiqueta 'Title'.
Activity.AddView (lblTitle, 20% x, 10dip, 60% x, 30dip) Agrega la vista a la actividad.
Si la etiqueta se sumó en el diseñador, todo el código anterior no habría sido necesario

debido a las propiedades ya habría definidas en el diseñador.
En Activity.AddView línea vemos que:
 se establece la propiedad Left al 20% x, 20% de Activity.Width.
 la propiedad Top se establece en 10dip, 10 píxeles independientes de la densidad.
 la propiedad Width se establece en 60% x, 60% de Activity.Width
 la propiedad Height se establece en 30dip, 30 píxeles independientes de la densidad.
pnlTest.Initialize(\"\") Inicializa el Panel, no EventName requerido.

pnlTest.Color = Colors.Blue Establece el color de fondo azul.
btnTest.Initialize(\"btnTest\") Inicializa el botón, EventName = btnTest.

btnTest.Text = \"Prueba\" Establece el texto del botón de \"Test\"
lblPanelTitle.Initialize(\"\")
lblPanelTitle.Color = Colors.Red
lblPanelTitle.TextSize = 16
lblPanelTitle.TextColor = Colors.Blue
lblPanelTitle.Gravity = Gravity.CENTER_HORIZONTAL + Gravity.CENTER_VERTICAL
lblPanelTitle.Text = \"Prueba del Panel\"
Similar al etiqueta de título.
Activity.AddView (pnlTest,0,lblTitle.Top + lblTitle.Height + 10dip, 100% x, 50% y)

Agrega el Panel pnlTest a la actividad.
 la izquierda está establecida en 0
 se establece la propiedad superior a 10dips por debajo del etiqueta de título
 se establece la propiedad Width a 100% x, la Activity.Width total
 la propiedad Height se establece en 50% y, la mitad de la Activity.Height
pnlTest.AddView (lblPanelTitle, 20dip, 10dip, 100dip, 30dip)
Agrega la etiqueta lblPanelTitle a la pnlTest de Panel en la posición dada y con el dado
dimensiones en salsas.
pnlTest.AddView (btnTest, 50dip, 50dip, 100dip, 60dip)
Agrega el botón btnTest para la pnlTest de Panel en la posición dada y con las dimensiones determinadas en
dips.
Y el resultado:
8.9 Secuencias de comandos de diseñadores
Uno de los más comunes problemas los desarrolladores Android cara es la necesidad de adoptar la interfaz de usuario
para dispositivos con diferentes tamaños de pantalla.
Como se describe en el tutorial de diseñador visual, puede crear múltiples variantes de diseño para que coincida con
pantallas diferentes.
Sin embargo no es viable ni recomendado para crear muchas variantes de diseño.
Basic4android v1.9 introduce una nueva herramienta llamada \"Scripts de diseñador\" que le ayudará a afinar
su diseño y ajustarla fácilmente a las diferentes pantallas y resoluciones.
La idea es combinar la utilidad del diseñador visual con la flexibilidad y la potencia de

Código de programación.
Puede escribir una secuencia de comandos simple para ajustar el diseño basado en las dimensiones del dispositivo actual y
ver los resultados inmediatamente. No es necesario compilar e instalar el programa completo cada vez.
Usted puede ver también inmediatamente los resultados en el diseñador de resumen. Esto le permite probar su
diseño en muchas diferentes tamaños de pantalla.
Cómo
Cada archivo de diseño puede incluir código de secuencia de comandos. El guión está escrito dentro del diseñador visual bajo
nueva ficha de diseñador Scripts:
Sus dos tipos de guiones: el guión general que se aplicará a todas las variantes y una secuencia de comandos
específicos de la variante actual.
Una vez que se pulsa en el botón Ejecutar Script (o F5), el script se ejecuta y el dispositivo conectado \/
emulador y diseñador resumen mostrará el diseño actualizado.
Lo mismo ocurre cuando se ejecuta el programa compilado. La secuencia de comandos (ya compilado)
ejecutado una vez cargado el diseño.
El general de comandos se ejecuta primero seguido del variante script específico.
El lenguaje de script es muy sencillo y está optimizado para la gestión del diseño.
Permite iniciar con un ejemplo.

Ejemplo
En este ejemplo vamos a construir el esquema siguiente:
btnLeft y btnRight deben colocarse en las esquinas superiores.

btnDown debe estar ubicado en la parte inferior y llene toda la anchura.
ListView1 debe rellenar toda el área disponible.
ToggleButton1 debe colocarse exactamente en el centro.
El primer paso es agregar los puntos de vista y colocarlos con el diseñador visual (no necesita ser
100% de precisión).
Ahora seleccione la ficha Diseño de secuencias de comandos y agregue el código.
Tenga en cuenta que las opiniones se bloquean cuando se selecciona la ficha Diseño de secuencias de comandos.
En este caso es el código:
' Todos los script de variantes

btnRight.Right = 100% x
btnDown.Bottom = 100% y
btnDown.Width = 100% x
EditText1.Width = 100% x
EditText1.Bottom = btnDown.Top - 5dip
ListView1.Width = 100% x
ListView1.SetTopAndBottom(,.Abajo, EditText1.Top)
ToggleButton1.HorizontalCenter = 50% x
ToggleButton1.VerticalCenter = 50% y
El resultado:
10 '' tablet
Referencia
ArgumentException: The incoming token has expired. Get a new access token from the Authorization Server. : ID=
ArgumentException: The incoming token has expired. Get a new access token from the Authorization Server. : ID=3311.V
ArgumentException: The incoming token has expired. Get a new access token from the Authorization Server. : ID=3
-Anchura \/ altura - Obtiene o establece el ancho o la altura de la vista.
-TextSize - Obtiene o establece el tamaño del texto. No debe utilizar unidades 'dip' con este valor como es
ya medido en unidades físicas.
-Texto - Obtiene o establece el texto de la vista.

Sólo están disponibles para vistas que muestran texto propiedades TextSize y texto.
-Imagen - establece el archivo de imagen (sólo escritura). Sólo se admite por ImageView.
-Visible - Obtiene o establece la propiedad visible de la vista.
Métodos:
-SetLeftAndRight (izquierda, derecha) - establece propiedades de izquierda y derecha de la vista. Este método cambia el
ancho de la vista en función de los dos valores.
-SetTopAndBottom (superior, inferior) - establece propiedades de superior e inferior de la vista. Este método
cambia la altura de la vista en función de los dos valores.
Notas y consejos
-valores %x y %y están en relación con la opinión de que el diseño de las cargas.

Generalmente será la actividad. Sin embargo se utiliza Panel.LoadLayout, será en relación con esto
panel.
-Utilizar las unidades 'dip' de todos los tamaños (excepto TextSize). Mediante el uso de 'dip' unidades los valores serán
escalan correctamente en dispositivos con mayor o menor resolución.
-En la mayoría de los casos se recomienda no crear variantes con escalas distintas de 1.0. Al agregar
dicha variante se le dará la opción de agregar una variante normalizada en su lugar con una escala de 1.0.
-Variables - se pueden utilizar variables en la secuencia de comandos. No es necesario declarar las variables antes
usarlas (no es ninguna palabra clave Dim en la secuencia de comandos).
-Activity.RerunDesignerScript (LayoutFile As String, ancho como Int, altura como Int) - en algunos casos
es deseable para ejecutar el código del script nuevamente durante el programa. Por ejemplo, puede actualizar
el diseño cuando el teclado en pantalla es visible. Método Activity.RerunDesignerScript permite
Vuelva a ejecutar el script y especifique la anchura y altura que representa 100 x % y 100% y.
Para que este método funcione, todas las vistas que se hace referencia en la secuencia de comandos deben declararse en Sub
Globals.
Tenga en cuenta que este método no debe utilizarse para manejar los cambios de orientación de pantalla. En ese caso la
actividad va a crearse y la secuencia de comandos se ejecutará durante la llamada de Activity.LoadLayout.
9 Actividad y proceso de ciclo de vida 126 Basic4Android Guía del principiante
9 Ciclo de vida del proceso y la actividad

Comencemos simple:
Cada programa de Basic4android se ejecuta en su propio proceso.
Un proceso tiene un subproceso principal que también es llamado el subproceso de la interfaz de usuario que vive tanto tiem
vidas. Un proceso puede tener también más subprocesos que son útiles para tareas en segundo plano.
Un proceso se inicia cuando el usuario inicia la aplicación, suponiendo que no se está ejecutando ya en
el fondo.
Al final del proceso es menos determinante. Ocurrirá en algún momento después de que el usuario o sistema ha cerrado todos
las actividades.
Si por ejemplo tiene una actividad y el usuario presiona la tecla atrás, se cierra la actividad.
Más tarde cuando el teléfono queda poca memoria (y eventualmente ocurrirá) se cerrará el proceso.
Si el usuario inicia su programa nuevamente y el proceso no fue asesinado y luego será el mismo proceso
ser reutilizados.
Una aplicación de Basic4android está hecha de una o más actividades. Android soporta varios otros
componentes \"principales\". Estos serán agregados a Basic4android en el futuro.
Las actividades son algo similares a los formularios Windows Forms.
Una diferencia importante es que, si bien no es una actividad en primer plano puede morir a fin de
preservar la memoria. Normalmente querrá guardar el estado de la actividad antes de se pierde. Ya sea en
un almacenamiento persistente o en la memoria que está asociado con el proceso.
Posteriormente a esta actividad se crearse cuando sea necesario.
Otro punto delicado ocurre cuando hay un cambio de configuración principales en el dispositivo. La mayoría
común es un cambio de orientación (el usuario gira el dispositivo). Cuando se produce un cambio del
actividades actuales son destruidas y luego recreadas. Ahora es posible crear la actividad según
a la nueva configuración (por ejemplo, ahora sabemos las nuevas dimensiones de la pantalla).
9.1 ¿Cómo maneja?
Cuando se crea una nueva actividad se iniciará con la siguiente plantilla de código:
Las variables pueden ser globales o locales. Las variables locales son variables que se declaran dentro de un sub
otro que Process_Globals o Globals.
Las variables locales son locales a la sub que contiene. Una vez los extremos sub, estas variables ya no existen.
Las variables globales pueden accederse desde todos los subs.
Existen dos tipos de variables globales.

Las variables de procesos y actividad.
9.2 Variables globales del proceso
Estas variables viven como vive el proceso.

Debe declarar estas variables dentro de sub Process_Globals.
Este sub es llamado una vez cuando se inicia el proceso (esto es cierto para todas las actividades, no sólo la primera
actividad).
Estas variables son las variables sólo \"públicas\". Lo que significa que puede acceder desde otros
módulos así.
Sin embargo, no todos los tipos de objetos se pueden declarar como variables de proceso.
Todas las vistas por ejemplo no pueden declararse como variables de proceso.
La razón es que no queremos hacer una referencia a los objetos que deben ser destruidos juntos
con la actividad.
En otras palabras, cuando se destruye la actividad, todas las vistas que figuran en la actividad son
destruido así. Si lo no hizo y mantiene una referencia a una vista después de la actividad
destruido, el recolector de elementos no sería capaz de liberar el recurso y tendríamos un
pérdida de memoria. Si tenemos una referencia a una vista, el recolector no sería capaz de liberar el
recursos ya tendremos una pérdida de memoria.
El compilador aplica este requisito.
9.3 Variables de actividad
Estas variables son propiedad de la actividad.

Debe declarar estas variables dentro Sub Globals.
Estas variables son \"privadas\" y sólo se pueden acceder desde el módulo de actividad actual.
Todos los tipos de objeto pueden declararse como variables de actividad.
Cada vez que se crea la actividad, se llama Sub Globals (antes Activity_Create).
Estas variables existen mientras exista la actividad.
9.4 Sub Activity_Create (cumshot As Boolean)
Este sub se llama cuando se crea la actividad.

La actividad se crea
 Cuando el usuario inicia primero la aplicación
 ha cambiado la configuración del dispositivo (el usuario gira el dispositivo) y la actividad fue
destruido
 Cuando la actividad en el fondo y OS decidió destruirla para liberar
memoria.
El propósito principal de este sub es cargar o crear el diseño.(entre otros usos).
El parámetro de la Declarción nos dice si es la primera vez que esta actividad se crea. Primera vez se relaciona con
en el proceso actual.
Puede utilizar valores para ejecutar todo tipo de inicializaciones relacionados con las variables de proceso.
Por ejemplo si tiene un archivo con una lista de valores usted necesita leer, puede leerlo si
Declarción es True y guarde la lista como una variable de proceso declarando la lista Sub
Process_Globals
Ahora sabemos que esta lista estará disponible tanto como la vida del proceso y no es necesario para
cargarlo incluso cuando se recrea la actividad.
Para resumir, puede probar declarción sea True y, a continuación, inicializar las variables de proceso que
se declaran en Sub Process_Globals.
9.5 Globals versus cumshot
Process_Globals y Globals debe utilizarse para declarar las variables.

También puede establecer los valores de las variables \"simples\" (numéricos, cadenas y booleanos).
Allí no debería poner cualquier otro código.

En su lugar, usted debe poner el código en Activity_Create.
9.6 Sub Activity_Resume

Sub Activity_Pause (UserClosed As Boolean)
Cada vez que la actividad se mueve en primer plano al fondo que se llama Activity_Pause.
También se llama Activity_Pause cuando la actividad está en primer plano y un cambio de configuración
se produce (que conduce a la actividad en pausa y luego destruidos).
Activity_Pause es el último lugar para guardar información importante.
Generalmente hay dos tipos de mecanismos que permiten guardar el estado de actividad.
Información que sólo es relevante a la instancia actual de la aplicación puede almacenarse en uno o más
las variables de proceso.
Otra información debe almacenarse en un almacenamiento persistente (archivo o base de datos).
Por ejemplo, si el usuario modifica algunos ajustes deben guardar los cambios en un almacenamiento persistente
en este punto. De lo contrario se pueden perder los cambios.
Activity_Resume se llama justo después de acabados Activity_Create o reanudar una actividad en pausa
(actividad se trasladó a fondo y ahora se vuelve al primer plano).
Tenga en cuenta que cuando abres una actividad diferente (por llamada StartActivity), la actividad actual es el primera
en pausa y, a continuación, se creará la otra actividad si es necesario y se reanudó (siempre).
Como se discutió anteriormente Activity_Pause se llama cada vez que la actividad se mueve en primer plano para
el fondo. Esto puede suceder porque:
1. Se inició una actividad diferente.
2. Se presionó el botón de inicio.
3. Un evento de configuración cambiada fue levantada (orientación cambiada por ejemplo).
4. Se presionó el botón atrás.
En los escenarios 1 y 2, se interrumpirá la actividad y por ahora se mantiene en memoria como se espera ser
reutilizados posteriormente.
En el escenario 3 se interrumpirá la actividad, destruido y creado (y reanudó) nuevamente.
En el escenario 4 la actividad será en pausa y destruida. Pulsando el botón de la parte posterior es similar a
cierre de la actividad. En este caso no necesita guardar cualquier instancia información específica (la
posición de pacman en un juego de PacMan por ejemplo).
El parámetro UserClosed será cierto en este escenario y false en todos los demás. Tenga en cuenta que también será
True al llamar a Activity.Finish. Este método hace una pausa y destruye la actividad actual, similar a
el botón atrás.
Puede utilizar UserClosed parámetro para decidir qué datos para guardar y también si desea restablecer cualquiera
las variables de proceso relacionados con su estado inicial (mover la posición de pacman al centro si la posición es un
variable de proceso).
10 Variables y objetos 130 Basic4Android Guía del principiante
10 Variables y objetos
Una variable es un nombre simbólico dado a alguna cantidad conocida o desconocida o información, para la
propósito de permitir que el nombre ser usado independientemente de la información que representa. Una variable
nombre en código de fuente de computadora generalmente asociada a una ubicación de almacenamiento de datos y así tambi
contenido y estos pueden cambiar durante el curso de la ejecución del programa. (fuente Wikipedia)
Sistema de tipo de Basic4android se deriva directamente del sistema de tipo de Java.

Existen dos tipos de variables: tipos primitivos y no primitivas.
Primitivas incluyen los tipos numéricos: Byte, Short, Int, Long, Float y doble.
Primitivas también incluyen: Boolean y Char.
10.1 Tipos de variables
Lista de tipos con sus rangos de:
B4A Tipo valor mín. valor máx.

Boolean Boolean Falso True
7 7
-2 2-1
Byte entero de 8 bits
-128 127
15 15
-2 2 -1
Corto entero de 16 bits
-32768 32767
31 31
-2 2 -1
Int entero de 32 bits
-2147483648 2147483647
63 63
-2 2 -1
Largo entero largo de 64 bits
-9223372036854775808 9223372036854775807
-149 -23 127
número de punto flotante -2 (2 -2 ) * 2
Flotador
32 bits 1.4E-45 3.4028235 E 38
-1074 -52 1023
doble precisión -2 (2 -2 ) * 2
Doble número 2.2250738585072014 E- 1.7976931348623157 e
64 bits 308 308
Char carácter
Cadena matriz de caracteres
Tipos primitivos se pasan siempre por valor a otros subs o cuando asigna a otras variables.
Por ejemplo:
La variable A = 12
Se pasa por valor a rutina S2
A variable aún equivale a 12, aunque b fue cambiado en rutina S2.
Variable B = 12
Su valor se cambia a B = 45
Todos los demás tipos, incluyendo matrices de tipos primitivos y las cadenas se clasifican como no primitivo
tipos.
Cuando se pasa una primitiva-no a un sub o cuando se le asigna a una variable diferente, una copia de la
se pasa una referencia.
Esto significa que los datos en sí no está duplicados.
Es ligeramente diferente al pasar por referencia, como no se puede cambiar la referencia del original
variable.
Todos los tipos pueden ser tratados como objetos.

Colecciones como listas y mapas de trabajo con objetos y por lo tanto, puede almacenar cualquier valor.
Aquí está un ejemplo de un error común, donde el desarrollador intenta agregar varios arreglos de discos a una lista:
Dim arr(3) como Int

Dim List1 como lista
List1.Initialize
Para i = 1 A 5
ARR(0) = i * 2
ARR(1) = i * 2
ARR(2) = i * 2
List1.Add(arr) ' Agregar el conjunto como un solo elemento
Siguiente
ARR = List1.Get(0) ' obtener el primer elemento de la lista
Log(arr(0)) ' lo que se imprimirá aquí???
Usted puede esperar para imprimir 2. Sin embargo se imprimirá 10.

Hemos creado una sola matriz y 5 referencias de esta matriz se agregó a la lista.
Los valores de la matriz solo son los valores establecidos en la última iteración.
Para solucionar esto tenemos que crear una nueva matriz cada iteración.
Esto se hace por llamada Dim cada iteración:
Dim arr(3) como Int ' esta llamada es redundante en este caso.
List1.Initialize
Para i = 1 A 5
Dim arr(3) como Int
ARR(0) = i * 2
ARR(1) = i * 2
ARR(2) = i * 2
List1.Add(arr) ' Agregar el conjunto como un solo elemento
Siguiente
ARR = List1.Get(0) ' obtener el primer elemento de la lista
Log(arr(0)) ' se imprimirán 2
Consejo: Puede utilizar la biblioteca de CollectionsExtra de agraham para copiar una matriz.
10.2 Nombres de variables
Depende de usted para dar cualquier nombre a una variable, excepto palabras reservadas.
Un nombre de variable deben comenzar con una letra y debe estar compuesto por los siguientes caracteres A-z, un-
z, 0-9 y de subrayado \"_\", sin espacios, sin corchetes etc..
Nombres de variables distinguen mayúsculas de minúsculas, esto significa que el índice y refieren a la misma variable.
Pero es una buena práctica para darles nombres descriptivos.

Ejemplo:
Interés = Capital * tasa \/ 100 es significativo
n1 = n2 * n3 \/ 100 no significativo
Para las vistas resulta útil añadir al nombre de un prefijo de tres caracteres que define su tipo.
Ejemplos:
lblCapital LBL > etiqueta Capital > fin
edtInterest EDT > EditText Interés > fin
btnNext btn > botón Próxima > fin
10.3 Declarar variables
10.3.1 Simples variables
Las variables declaradas con la Dim palabra clave seguida por el nombre de la variable y el Comopalabra clave
y seguido por el tipo de variable. Ejemplos:
Declara tres variables como doble,

números de doble precisión.
Declara tres variables como Int, números enteros.
Declara tres variables como EditText vistas.
Declara dos variables como vistas de botón.
Las mismas variables también pueden declararse de manera breve.
Los nombres de las variables separaron por comas y seguido por la declaración de tipo.
Nombres de vista deben declararse cuando queremos utilizarlas en el código.

Por ejemplo, si queremos para cambiar el texto en una vista de EditText en el código, como
edtCapital.Text = \"1200\",
Tenemos que hacer referencia a este punto de vista EditText por su nombre
edtCapital , esto se hace con el Dim
Declaración.
Si nunca hacemos cualquier referencia a este punto de vista EditText en cualquier lugar en el código sin declaración
es necesario.
Utilizando una rutina de evento para vista no necesita una declaración bien.
Para asignar un valor a una variable escritura su nombre seguido por el signo igual y seguido por la
valor, como:
Capital = 1200
LastName = \"SMITH\"
Tenga en cuenta que paraescribimos sólo 1200 porque Capital es un número.

Capital
Pero paraLastName escribimos SMITH porque LastName es una cadena.
Cadenas siempre deben escribirse entre comillas dobles.
10.3.2 Variables de matriz
Los arreglos son colecciones de datos u objetos que se pueden seleccionar mediante índices. Arreglos de discos pueden tener
dimensiones.
La declaración contiene la Dim palabra clave seguida por el nombre de la variable
LastName, el número de
elementos entre paréntesis (50), la palabra claveComo
y el tipo de variable Cadena.
Ejemplos:
Matriz de una dimensión de cadenas, el número total de elementos de 50.
Matriz de dos dimensiones de dobles, el número total de elementos 9.
Matriz de tres dimensiones de enteros, número total de elementos 150.
El primer índice de cada dimensión de una matriz es 0.

LastName(0), Matrix(0,0), Data(0,0,0)
El último índice es igual al número de elementos en cada dimensión menos 1.

LastName(49), Matrix(2,2), Data(2,4,9)
o
Este ejemplo muestra cómo obtener acceso a todos los elementos de un tres matriz dimensional.
Una manera más versátil para declarar matrices es utilizar variables.
Declaramos la variable Dim NbPers As Int y establezca su valor en 10,NbPers = 10 .

El punto y coma \":\" es un separador para la declaración de dos en la misma línea.
Luego declaramos las matrices con esta variable en lugar del número 10 como antes.
La gran ventaja es que si en algún momento tenemos que cambiar el número de elementos, cambiamos sólo uno
valor.
Para la matriz de datos podríamos utilizar el siguiente código.
Y la rutina de acceso.
Llenar una matriz con la palabra clave de matriz:

10.3.3 Conjunto de opiniones (objetos)
Vistas u objetos también pueden estar en una matriz. El código siguiente muestra un ejemplo:
Los nombres individuales (b1, b2, etc.) deben ser también 'Dimed'.
En el ejemplo debajo de los botones se agregan a la actividad por código.
Los botones también se podrían haber añadido en un archivo de diseño, en ese caso tampoco deben ser inicializados,
ni agregado a la actividad y las propiedades de texto y una etiqueta también deben establecerse en el diseñador.
En ese caso el código tendría este aspecto:
10.3.4 Las variables de tipo
Permítanos reutilizar el ejemplo con los datos de una persona.

En lugar de declarar cada parámetro por separado, podemos definir una variable de tipo personal con el
Escriba la palabra clave:
El nuevo tipo de personal es Persona , luego declaramos variables individuales o matrices de este personal
tipo.
Para acceder a un determinado tema utilizar el siguiente código.
CurrentUser.FirstName
CurrentUser.LastName
User(1).LastName
User(1).FirstName
El nombre de variable, seguido de un punto y el parámetro deseado.

Si la variable es una matriz el nombre es seguido por el índice deseado entre paréntesis.
Es posible asignar una variable con tipo a otra variable del mismo tipo, como se muestra a continuación.
10.4 Casting
Basic4android proyecta tipos automáticamente según sea necesario. También convierte a números en cadenas y vice
viceversa automáticamente.
En muchos casos necesita convertir explícitamente un objeto a un tipo específico.
Esto puede hacerse mediante la asignación del objeto a una variable del tipo necesario.
Por ejemplo, palabra clave Sender hace referencia a un objeto que es el objeto que provocó el evento.
El código siguiente cambia el color del botón pulsado.
Tenga en cuenta que hay varios botones que comparten la misma sub evento.
El código anterior puede escribirse también más elegante:

10.5 Ámbito de aplicación
10.5.1 Variables de proceso de
Estas variables viven como vive el proceso.

Debe declarar estas variables dentro de sub Process_Globals.
Este sub es llamado una vez cuando se inicia el proceso (esto es cierto para todas las actividades, no sólo la primera
actividad).
Estas variables son las variables sólo \"públicas\". Lo que significa que puede acceder desde otros
módulos así.
Sin embargo, no todos los tipos de objetos se pueden declarar como variables de proceso.
Todas las vistas por ejemplo no pueden declararse como variables de proceso.
La razón es que no queremos hacer una referencia a los objetos que deben ser destruidos juntos
con la actividad.
En otras palabras, una vez que se destruye la actividad, todas las vistas que figuran en el
actividad están siendo destruidos así.
Si tenemos una referencia a una vista, el recolector de elementos no podrá liberar el recurso y nos
tendrá una pérdida de memoria. El compilador aplica este requisito.
Para acceder a las variables globales de proceso en otros módulos que el módulo donde se declararon sus
los nombres deben tener el nombre del módulo que fueron declarados como prefijo.
Ejemplo:
Las variables definidas en un modle con el nombre: MyModule
Sub Process_Globals
Dim Mi_var As String
End Sub
Acceso a la variable en el módulo MyModule:

MyVar = \"Texto\"
Acceso a la variable en cualquier otro módulo:

MyModule.MyVar = \"Texto\"
10.5.2 Variables de actividad
Estas variables están contenidas por la actividad.

Debe declarar estas variables dentro Sub Globals.
Estas variables son \"privadas\" y sólo se pueden acceder desde el módulo de actividad actual.
Todos los tipos de objeto pueden declararse como variables de actividad.
Cada vez que se crea la actividad, se llama Sub Globals (antes Activity_Create).
Estas variables existen mientras exista la actividad.
10.5.3 Las variables locales de
Las variables declaradas en una subrutina son locales a esta subrutina.

Son \"privadas\" y sólo se puede acceder desde dentro de la subrutina donde ellos fueron declarados.
Todos los tipos de objetos se pueden declarar como variables locales.
En cada llamada de la subrutina se inicializan las variables locales a su valor predeterminado o a cualquier otro
valor han definido en el código y son 'destruido' cuando se deja la subrutina.
10.6 Consejos
Una vista puede asignarse a una variable para poder cambiar fácilmente las propiedades comunes de la vista.
Por ejemplo, el código siguiente desactiva todas las vistas que son hijos directos de la actividad:
Si sólo queremos deshabilitar botones:

11 Módulos 140 Basic4Android Guía del principiante
11 Módulos
Existe al menos un módulo principal.
Su nombre es siempre principal y no puede cambiarse.
Existen tres tipos de módulos:

 Módulos de actividad
 Módulos de código
 Módulos de servicio
11 Módulos 34s Basic4Android Guía del principiante
11.1 Módulos de actividad
Cada actividad tiene su propio módulo. Para un mejor conocimiento del ciclo de vida de actividad de echar un vistazo a la
Capítulo de ciclo de vida de proceso y actividad.
Puede agregar un módulo existente o un nuevo módulo.
Para agregar un nuevo módulo de actividad haga clic en:
En el ejemplo se explica detalladamente en el capítulo: programa de 3 actividades.
Para acceder a cualquier objeto o variable en un módulo distinto del módulo donde fueron declarados te
debe agregar el nombre del módulo como prefijo para el objeto o el nombre de la variable separados por un punto.
Ejemplos del programa ThreeActivityExample:

Se declaran variables valor1 y valor2 en módulo principal en Sub Process_Globals.
Para acceder a estas variables desde otro módulo el nombre es Main.Value1 o Main.Value2.
NO es posible acceso cualquier vista desde otro módulo de actividad, porque cuando es una nueva actividad
comenzó la actividad actual está en pausa y es no más accesible!
11.2 Módulos de código
Módulos de código contienen código solamente. No es posible ninguna actividad en módulos de código.
El propósito y la ventaja de los módulos de código es compartir mismo código en diferentes programas, principalmente para
cálculos u otra gestión general.
Algunos módulos de código, llamados utilidades, ya están publicadas por Erel en el Foro:
 DBUtils, bases de datos de Android ahora son simples. Utilidades de administración de base de datos.
 HttpUtils, servicios web Android ahora son simples.
 StateManager, ayuda a administrar el estado y configuración de la aplicación Android.
11.3 Módulos de servicio
Existe un tutorial de módulos de servicio.

12 Programas de ejemplo 144 Basic4Android Guía del principiante
12 Programas de ejemplo
12.1 Interfaces de usuario
Hagamos tres diferentes interfaces de usuario para seleccionar tres pantallas diferentes.
Las interfaces de tres usuario son:
Menú Vista de TabHost Caja de herramientas de botón
Para cada programa de prueba existe un diseño principal.
Para cada una de las tres páginas hay archivos de diseño independiente página1 y página2 página 3.
Cada archivo de diseño se carga a un Panel o un TabHost.
Estos diseños pueden contener cualquier vistas necesita.
12.1.1 Menú ejemplo (UserInterfaceMenu.b4a)
El programa de prueba es: UserInterfaceMenu.b4a. El código es auto explicativo.
1. Cada página está en un Panel, pnlPage1, pnlPage2 y pnlPage3.

2. Los paneles se agregan por código.
3. Se cargan los archivos de diseño de página a los paneles.
4. Los elementos de menú se añaden a la actividad.
5. Una rutina de eventos Click para cada elemento de menú.
También podría hacerse en una rutina (como en UserInterfaceButtonToolbox.b4a).
12.1.2 TabHost ejemplo (UserInterfaceTabHost.b4a)
El programa de prueba es: UserInterfaceTabHost.b4a El código es auto explicativo.
1. Cada página se encuentra en un panel de TabHost.

2. La visión de TabHost es en la composición principal.
3. Los paneles de TabHost se agregan con los archivos de diseño de página.
12.1.3 Ejemplo de cuadro de herramientas del botón (UserInterfaceButtonToolbox.b4a)
El programa de prueba es: UserInterfaceButtonToolbox.b4a El código es auto explicativo.
1. Cada página está en un Panel, pnlPage1, pnlPage2 y pnlPage3.

2. Los paneles se agregan por código.
3. Se cargan los archivos de diseño de página a los paneles.
4. Los botones están en el diseño principal en el panel de pnlToolBox.
5. Una rutina de evento Click para todos los botones.
Programa de ejemplo de actividad tres 12.2 148 Basic4Android Guía del principiante
12.2 Programa con 3 actividades (ThreeActivityExample.b4a)
El programa de prueba es: ThreeActivityExample.b4a
El objetivo del programa es:

- para mostrar cómo administrar varias actividades.
- trabajar con variables de proceso Global a través de diferentes actividades. Las variables pueden ser
pero cambió en diferentes actividades, están disponibles durante todo el proyecto.
- cambiar los parámetros de diseño, en un pequeño panel rojo en movimiento sobre la pantalla.
- guardar y cargar el diseño de los parámetros del rojo pequeño panel con un objeto de mapa así la Plaza
mantendrá la misma posición después de cambiar una página o reiniciar el programa.
El programa se parece a continuación:
Tenemos:
- 3 páginas, cada uno en su propia actividad.
- 3 proceso de variables globales, valor1, valor2 y valor3
- en cada página 1 EditText ver para modificar el valor de la variable con el índice de la página.
- 2 Etiquetas para mostrar las dos variables.
- en la página 1 un pequeño cuadrado rojo Panel para moverse.
Se puede:
- Valor1 de cambio en la página 1.
- Cambio valor2 en página2.
- Cambio valor3 en la página 3.
- Mueva el cuadrado rojo pequeño sobre la pantalla.
- Seleccione página2 o página 3 en la página 1.
Tomemos el ejemplo con la caja de herramientas del botón (UserInterfaceButtonToolbox.b4a).

En lugar de tener nuestras tres páginas en tres paneles utilizaremos 3 actividades.
Principal, página 2 y 3 de la página.
Para ello debemos crear dos nuevos módulos: página2 y página 3.
En el clic de la IDE en.
Introduzca el nombre página2
y haga clic en .
Un nuevo módulo se agrega al proyecto.

Modificar el código del módulo página2 como a continuación:
Añadir ahora un nuevo módulo \"Página3\" del mismo modo como página2 y modificar el código como a continuación:
Estos códigos son auto explicativas.

Debemos modificar el código del módulo principal:
En el Sub proceso-Globals añadimos tras variables.

Valor1, valor2 y valor3 para guardar algunos valores.
mapMoveTopLeft como un objeto de mapa para guardar el parámetro Left y Top de la pequeña plaza Roja.
En Globals tenemos las siguientes variables:

lblValue2_P1 es la etiqueta para mostrar valor2 en página 1.
lblValue3_P1 es la etiqueta para mostrar valor3 en la página 1.
edtValue1_P1 es el EditText entrar valor1 en página 1.
pnlPage1 es el contenedor para el diseño de la página 1.
pnlMove es el pequeño cuadrado rojo.
X 0, Y0, X 1 y Y1 son utilizadas para memorizar las coordenadas iniciales al mover el cuadrado rojo.
Sub Activity_Create se modifica como a continuación:
Cuando la rutina se llama por primera vez, inicialice las tres variables de valor.
En Activity_Resume Sub inicializan los parámetros de las vistas de actividad principal.

Init.txt es el fichero con los parámetros de izquierda y de arriba de la pequeña pnlMove de la Plaza Roja.
Si el archivo existe lo leemos y establecer los parámetros Left y Top de pnlMove.
Si el archivo no existe nos inicializar el objeto de mapa y configurar los dos primeros parámetros a la izquierda y
Parámetros principales de pnlMove...
Cuando se detiene la actividad de \"Principal\", debido a un cambio de página o el programa de cerca, tenemos:
- Ajuste variable Value1 al contenido de edtValue1.Text.
- guardar el mapa en archivo Init.txt.
Para volver a Page1 Page2 o página 3, el usuario debe presionar la tecla atrás. Para evitar
el programa se detiene cuando el usuario hace clic, por inadvertencia, un tiempo demasiado, comprobamos en Sub
Activity_KeyPress qué tecla se ha presionado. Y si es la tecla atrás nos muestre un mensaje en un
Cuadro de mensaje preguntando al usuario si realmente desea salir del programa. Si sí, entonces establecemos el regreso
valor en False significa que el evento es enviado al OS para cerrar el programa. Si la respuesta es
No, establecemos el valor devuelto en True, lo que significa que nos 'consumir' el evento y el sistema operativo no
detener el programa.
Para mostrar cómo administrar los parámetros de diseño que tenemos el cuadrado rojo pequeño, pnlMove, que puede ser
moverse en la pantalla. La posición de pnlMove se maneja en Sub Activity_Touch donde obtenemos
tres parámetros:
- Acción manteniendo el valor de la acción del usuario.
ACTION_DOWN el usuario toca la pantalla.
ACTION_MOVE el usuario se mueve en la pantalla
ACTION_UP el usuario abandona la pantalla
- X la coordenada x del dedo en la pantalla.
- Y la coordenada y del dedo en la pantalla.
Para poder mover el pnlMove hacemos lo siguiente:

- Cuando la acción es igual a ACTION_DOWN, el usuario toca la pantalla
nos memorizar las coordenadas de los dedos y las coordenadas de la esquina superior izquierda de
pnlMove (líneas 76 a 79).
- Cuando la acción es igual a ACTION_MOVE el usuario mueve el dedo sobre la pantalla,

calculamos el desplazamiento relativo, dX y dY, en ambas direcciones y establecer la nueva izquierda
y los parámetros de pnlMove (líneas de 82 a 85).
- Cuando la acción es igual a ACTION_UP, el usuario sale de la pantalla y

actualizamos los dos parámetros del objeto de mapa (líneas 88 y 89 =.
En Sub btnPage_Click empezamos la actividad de Page según qué botón se presionó.

- Declaramos un nuevo objeto de botón Enviar.
- Atribuimos al remitente para enviar.
El remitente es la vista del botón que provocó el evento.
- Dependiendo del valor de la etiqueta del objeto sender empezamos la actividad correcta.
Todavía tenemos que modificar los archivos de diseño de cuatro:
Principal:
Quitamos btnPage1, que ya no sea necesaria.

Ampliar los dos botones restantes y cambiarlas
Página 1:
Añadimos las vistas como en la imagen de la izquierda.
Similares para la página 2 y 3 de la página.
Los archivos de diseño están en el proyecto.

12.3 Programa de ejemplo Scrollview 155 Basic4Android Guía del principiante
12.3 Ejemplos de ScrollView
ScrollView es una vista muy versátil para mostrar listas de objetos con datos o usuario vistas de interfaz.
Actualmente, ListViews son limitados a dos líneas de texto y una imagen por el conjunto de datos.
ScrollViews tienen un Panel interno, más grande que la pantalla, que puede desplazarse verticalmente y mantiene
cualquier tipo de vistas como una distribución o listas de conjuntos de vista.
Algunas imágenes de ejemplos: (un resumen de ejemplos de ScrollView)
Cuadrícula en TableView...ScrollView SQLLiteDB ScrollView, diseños...
Otro ejemplo de ScrollView Añadir imageview... HelpScrollView
http:\/\/www.Basic4ppc.com\/F
orum\/Attachments\/basic4andr
oid-updates-Questions\/7324d1
301153817-real-newb-question
-about-how-display-Block-Scro
llable-Text-helpscrollview.jpg
12.3.1 Programa de ejemplo ScrollView

Hagamos un ejemplo ScrollView con las siguientes funciones:
 Leer un archivo csv y mostrarlo en una tabla basada en un ScrollView.

 El ScrollView puede desplazarse verticalmente con el estándar de desplazamiento en función de la
ScrollView.
 El ScrollView puede también desplazar horizontalmente con un Seekbar o dinámicamente con el
dedo en el rectángulo azul inferior (SeekBar visible o no).
 Al hacer clic en una celda destaca la fila y la celda, esta rutina permite agregar otras funciones
relacionados con una fila o una celda.
 Haga clic en un encabezado, muestra la columna, esta rutina permite agregar funciones relacionadas con un
columna.
Definimos las siguientes variables y asigna sus valores predeterminados:

StringUtils1 Se utiliza para leer el archivo csv.
ArgumentException: The incoming ArgumentException:
token hasThe incomingGet
expired. token has expired.
a new access Get a new
token access
from thetoken from
Authori
RowHeight Alto de una fila en el ScrollView.
RowLineWidth Ancho de las líneas entre las filas.
RowHeight_1 Altura interna de una fila
RowHeight_1 = RowHeight - RowLineWidth
ColLineWidth Ancho de las líneas entre las columnas.
ColumnWidth() Ancho de las columnas diferentes como una matriz
ColumnWidth_1() Anchura interna de las diferentes columnas.
TotalColumnWidth() Coordenadas del borde izquierdo de una columna de una matriz.
HeaderColor Color de fondo de encabezados.
HeaderFontColor Color de fuente de encabezados.
HeaderLineColor Color de la línea de encabezados.
LineColor Color de línea celular.
CellColor Color de línea de fondo de celda.
FontColor Color de línea de fuente de celda.
Alineación Alineación del texto del texto de los encabezados y las células.
SelectedRow Índice de la fila seleccionada.
SelectedRowColor Color de la fila seleccionada.
SelectedCellColor Color de la celda seleccionada.
Tipo RowCol (fila como Int, Col como Int)
Definir una variable personalizada que contiene un índice de columna y una fila.
MoveLeft0 Utilizado para el desplazamiento horizontal.
MoveX0 Utilizado para el desplazamiento horizontal.
MoveX1 Utilizado para el desplazamiento horizontal.
DeltaScroll Utilizado para el desplazamiento horizontal.
DeltaX Utilizado para el desplazamiento horizontal.
Time0 Utilizado para el desplazamiento horizontal.
Personalmente, prefiero trabajar con variables en lugar de valores. El mantenimiento y

modificación de un programa es mucho más fácil con las variables que con valores numéricos.
Ahora definimos las opiniones para el programa:

scvPersons ScrollView para mostrar los datos.
pnlHeader Panel para mostrar los encabezados.
skbScroll SeekBar para desplazarse al encabezado y ScrollView.
pnlScroll Panel para el desplazamiento horizontal 'dinámico'.
Timer1 Temporizador utiliza el desplazamiento horizontal 'dinámico'.
Ahora nos inicializar las diferentes opiniones y variables, tenemos:

 Inicializar el panel para el desplazamiento horizontal.
 Inicializar el componente SeekBar para el desplazamiento horizontal.
 Inicializar el ScrollView
 Inicializar el ancho de columna interna y las coordenadas izquierdas para cada columna y el total
ancho de todas las columnas.
 Inicializar el ancho ScrollView.
 Establecer el parámetro Max para el componente Seekbar
 Establece el índice de la fila seleccionada en -1, no hay ninguna fila seleccionada.
 Cargar el archivo csv, configurar los encabezados y llenar el ScrollView.
 Inicializar el temporizador para el desplazamiento horizontal.
Luego leer el archivo csv, llenamos los encabezados y la tabla (ScrollView).

 En primer lugar, si existen los encabezados, leemos el archivo csv con los encabezados.
 O, si no existen los encabezados, leemos el archivo csv sin los encabezados y establecer el valor predeterminado
nombres de encabezado a Col1, Col2 etc..
 Obtener el número de columnas.
 Mostrar los encabezadosSetHeader(h).
 Visualización de la tabla, añadiendo las diferentes filas para el ScrollView AddRow(row).
Para mostrar los encabezados de nosotros:

 Inicializar el panel cabecera.
 Establece el color del panel de cabecera en el color de la línea de encabezado.
 Inicializar una etiqueta para cada nombre de columna.
 Definir los parámetros diferentes para las etiquetas.
 Añadir las etiquetas en el panel de encabezado.
 Añadir el panel cabecera a la actividad
Llenar una fila de la ScrollView con la rutina de AddRow:

 Primero comprobamos si el número de células es igual al número de columnas.
 Inicializar una etiqueta para cada celda de la fila.
 Establecer los diferentes parámetros de la celda.
 Inicializar una variable RowCol, rc, para la etiqueta.
 Conjunto rc.Fila para el índice de fila y rc.COL para el índice de la columna.
 Coloque la etiqueta de la rc.
 Añadir cada etiqueta a la ScrollView.
 Ajuste la altura del panel interno de la ScrollView.
Nota: al final de una línea, un carácter de subrayado como en medios de 213 de línea
'continuar la misma línea siguiente instrucción'.
Otras funciones:
 Cell_Click
Haga clic en el evento de una de las celdas de la tabla.
o Dim rc como una fila Col. l Dim y variable como una etiqueta
o Set l igual al remitente, que provocó el evento
o Conjunto rc igual que el parámetro de la etiqueta del remitente
o Llamar a la rutina de SelectRow
o Mostrar en el título de actividades los índices de fila y columna y el contenido de la celda.
 Header_Click
Haga clic en el evento de una de las celdas de encabezado de la tabla.
o Dim l como etiqueta y Dim col como un entero
o Conjunto que igual al remitente
o Establezca col en el parámetro de la etiqueta del remitente, que es el índice de la columna.
o Mostrar la columna seleccionada en el título de la actividad.
 SelectRow
Esta rutina gestiona los colores de la fila seleccionada y celular.
Se llama de la rutina Cell_Click
o Dim col como un entero.
o Si hay una fila seleccionada, defina el color de celda normal.
o Establezca la variable de SelectedRow en el nuevo índice de la fila seleccionada.
o Establecer la fila seleccionada y seleccionar colores de celda.
 GetView
Obtiene el objeto Label para determinada fila y columna.
o Dim l como una etiqueta.
o Obtiene la vista en la determinada fila y columna, el índice de la vista en el panel de ScrollView
es igual a Fila * NumberOfColumns + Col.
o Devuelve la etiqueta.
 GetCell
Obtiene el texto de la etiqueta para la determinada fila y columna.
o Obtiene la vista de la determinada fila y columna.
o Devolver el parámetro texto de vistas.
 SetCell (no se usa en el programa)

Establece el texto de la etiqueta de la determinada fila y columna.
o Obtiene la vista de la determinada fila y columna
o Establece el parámetro texto de vistas en el valor dado
 ClearAll
o Elimina todas las vistas (etiquetas) desde el ScrollView Panel
o Establece la altura del Panel ScrollView 0
o Establece el índice de fila seleccionado a -1, no hay ninguna fila seleccionada
 Horizontal con el componente SeekBar

o Establece el parámetro izquierdo del panel de cabecera y el ScrollView.
o El valor SeekBar Max fue establecido en
skbScroll.Max = scvPersons.Width - Activity.Width.
 Horizontal desplazamiento con el panel de desplazamiento.

o pnlScroll_Touch y Timer1_Tick.
o Dejo a usted a encontrar cómo estos funcionan.
El principio básico consiste en calcular la velocidad entre ACTION_DOWN y

ACTION_UP y en la rutina de temporizador para mover dinámicamente el encabezado y el
ScrollView y reducir la velocidad.
13 Lenguaje basic 167 Basic4Android Guía del principiante
13 Lenguaje basic
En programación, BASIC (una sigla que significa multiuso simbólico del principiante
Código de instrucción) es una familia de lenguajes de programación de alto nivel diseñado para ser fácil de usar.
El BASIC Dartmouth original fue diseñado en 1964 por John George Kemeny y Thomas
Eugene Kurtz en el Dartmouth College en New Hampshire, Estados Unidos para facilitar el acceso del equipo a no-
estudiantes de Ciencias. En el momento, casi todo el uso de equipos requeridas escribir software personalizado, que
era algo sólo científicos y matemáticos solían hacerlo. El lenguaje y sus variantes
llegó a ser generalizada en microcomputadoras en la década de 1970 y 1980.
BASIC sigue siendo popular hasta el día de hoy en un puñado de dialectos altamente modificados y nuevos lenguajes
influenciado por BASIC como Microsoft Visual Basic. (fuente Wikipedia).
13.1 Flujo de programa
Este es un resumen de las explicaciones más detalladas en el ciclo de vida del proceso y la actividad.
El programa va a través de las rutinas siguientes cuando empezando de arriba a abajo:
13.1.1 Process_Globals rutina

Dedicada a la declaración de variables de proceso global. Variables que son válidas durante todo el
vida tiempo del proceso y accesible desde todo el mundo en el programa.
13.1.2 Globals rutina

Dedicada a la declaración de variables globales de actividad. Variables que son válidas sólo durante la vida
tiempo de la actividad y entrañas sólo accesibles la actividad. Tan pronto como la actividad está en pausa, estos
las variables son no más disponibles.
13.1.3 Rutina Activity_Create (cumshot As Boolean)

Área para inicializar las variables de la actividad.
Si las variables u objetos deben ser inicializados una sola vez, la primera vez en el lanzamiento de la aplicación,
puede utilizar el parámetro de la Declarción para comprobarlo.
13.1.4 Activity_Resume rutina

Esta rutina se llama cada vez que se inicia una actividad o reanudado, reactiva, aquí puede configurar
los parámetros de configuración para la nueva actividad actual.
13.1.5 Rutina Activity_Pause (UserClosed As Boolean)

Cuando la actividad se va a hacer una pausa, esta rutina se llama Activity_Pause.
Aquí es necesario guardar los parámetros de actividad que desea volver cuando la actividad es reanudado (re-
activado)
Una de las razones más frecuentes por qué una actividad está en pausa, es un cambio de orientación.
En ese caso la actividad actual es 'pausa' y reactiva con la nueva orientación y va a
menos a través de la rutina de Activity_Resume, pero normalmente a través de Globals, Activity_Create y
Activity_Resume.
La variable UserClosed puede utilizarse para distinguir si la actividad se ha parado por la

Sistema operativo (ej: cambio de orientación) o por el usuario (ex: haga clic en el botón back).
Flujo del programa: ejemplo: MyFirstProgram.
1. Las programa de llamadas

Process_Globals.
En el ejemplo no hay ninguna
código.
2. A continuación, el programa se llama

Globals.
Declara las variables.
3. A continuación, el programa se llama

Activity_Create.
Carga el diseño de \"Principal\".
Llama a la subrutina nueva.
4. Es el código en Sub New

ejecutado.
Al llegar a la final de Sub, la
programa vuelve a la
línea siguiente nueva.
En este caso la línea 25.
5. Se llama Activity_Resume.
Ningún código.
6. El programa espera un
evento.
7. Si el usuario hace clic en el

Botón btnAction
Es la btnAction_Click Sub
llama y el código dentro de
el Sub es ejecutado.
8. El programa espera
otro evento.
13.2 Expresiones
Una expresión en un lenguaje de programación es una combinación de valores explícitos, constantes, variables,
operadores y funciones que se interpretan según las normas particulares de precedencia y de
Asociación para un lenguaje de programación determinado, que calcula y luego produce (retornos)
otro valor. Este proceso, como para expresiones matemáticas, se denomina evaluación. El valor puede
ser de varios tipos, como numérico, cadena y lógicos (fuente Wikipedia).
Por ejemplo, 2 + 3 es una expresión aritmética y programación que evalúa a 5. Una variable es
una expresión porque es un puntero a un valor en la memoria, entonces y + 6 es una expresión. Un ejemplo de
una expresión relacional es 4 = 4, que se evalúa como True (fuente Wikipedia).
13.2.1 Expresiones matemáticas
Operador Ejemplo Nivel de prioridad Operación

+ x + y 3 Adición
- x - y 3 Resta
* x * y 2 Multiplicación
\/ x \/ y 2 División
Mod x y Mod 2 Módulo
y
Power(x,y) x
Alimentación 1 Poder de
Nivel de prioridad: en una expresión, operaciones con nivel 1 se evalúan antes de las operaciones con
nivel 2, que son evaluados antes de las operaciones con el nivel 3.
Ejemplos:
4 + 5 * 3 + 2 = 21 > 4 + 15 + 2
(4 + 5) * (3 + 2) = 45 >9*5
2 2
(4 + 5) * (3 + 2) = 405 >9*5 > 81 * 5
Power(4+5,2)*(3+2)
11 Mod 4 = 3 > Mod es el resto del 10 \/ 4

3
23 Power(23,3) > 23 en el poder de 3
2
-2 = - 4
2
(-2) = 4
13.2.2 Expresiones relacionales
En Ciencias de la computación en expresiones relacionales operador pruebas de algún tipo de relación entre dos
entidades. Estos incluyen la igualdad numérica (por ejemplo, 5 = 5) y las desigualdades (por ejemplo, 4 > = 3).
En B4A estos operadores devolución verdadero o falso, dependiendo de si la relación condicional
entre los dos operandos posee o no (fuente Wikipedia).
Operador Ejemplo Utilizada para probar

= x=y la equivalencia de los dos valores
<> y x <> la equivalencia negada de dos valores
> x>y Si el valor de la expresión de la izquierda es mayor que la de la derecha
< x<y Si el valor de la expresión de la izquierda es menor que el de la derecha
>= x>=y Si el valor de la expresión de la izquierda es mayor o igual a la de la derecha
<= x<=y Si el valor de la expresión de la izquierda es menor o igual a la de la derecha
13.2.3 Expresiones booleanas
En Ciencias de la computación, una expresión booleana es una expresión que produce un valor booleano cuando
evaluadas, es decir, uno de verdadero o falso. Una expresión booleana puede estar compuesta de una combinación de
las constantes booleanas True o False, variables de tipo Boolean, operadores de valor booleano, y
Funciones de valor booleano (fuente Wikipedia).
Operadores booleanos se utilizan en sentencias condicionales como IF-Then y Select-Case.
Operador Comentario
O Booleano o Z=XOY Z = True si x o y es igual a True o ambos son verdadero
Y Boolean Y Z = X Y Y Z = True si x e y son ambas igual a True
(No) Booleano no X = True Y = Not(X) > Y = False
O Y
X Y Z Z
Falso Falso Falso Falso
True Falso True Falso
Falso True True Falso
True True True True
13.3 Sentencias condicionales
Están disponibles diferentes sentencias condicionales en Basic.
13.3.1 Si – entonces – End If
La estructura If-Then-Else permite operar pruebas condicionales y ejecutar secciones de código diferente
según el resultado de la prueba.
Caso general:
La estructura If-Then-Else funciona como sigue:

1. Al llegar a la línea con la Si palabra clave,
Prueba1es ejecutado.
2. Si el resultado es verdadero, entonces se ejecuta hasta que la línea con la Else If palabra clave.
empresa1
Y salta a la siguiente línea el End If palabra clave y continúa.
3. Si el resultado es False, entonces
test2 es ejecutado.
4. Si el resultado es verdadero, entonces
code2 se ejecuta hasta que la línea con la Else palabra clave.
Y salta a la siguiente línea el End If palabra clave y continúa.
5. Si el resultado es False, entonces
Code3 se ejecuta y continúa en la siguiente línea el Final
Si palabra clave.
Las pruebas pueden ser cualquier tipo de prueba condicional con dos posibilidades de verdadero o falso.
Algunos ejemplos:
La más simple estructura If-Then.
Lo mismo pero en una línea.
La más simple estructura If-Then-Else.
Lo mismo pero en una línea.
Personalmente, prefiero la estructura en varias líneas, mejor legibles.

Una vieja costumbre de HP Basic hace algunas décadas, este básico aceptado sólo una instrucción por línea.
Nota. Diferencia entre:
B4A VB
Else If ElseIf
En B4A hay un personaje en blanco entre Else y Si.

13.3.2 Seleccionar – caso
El Select - estructura Case permite comparar un TestExpression con otros Expresiones y

para ejecutar las secciones de código diferente según los partidos entre el TestExpression y
Expresiones.
Caso general:
TestExpression es la expresión para probar.
ExpressionList1 es una lista de expresiones para comparar

Para
TestExpression
ExpressionList2 es otra lista de expresiones para comparar
Para
TestExpression
El Select - estructura Case funciona como sigue:
1. El TestExpression se evalúa.
2. Si un elemento en la ExpressionList1 partidos TestExpression a continuación, ejecuta
empresa1 y continúa en la siguiente línea el End Select palabra clave.
3. Si un elemento en la ExpressionList2 partidos TestExpression a continuación, ejecuta
code2 y continúa en la siguiente línea el End Select palabra clave.
4. Para ninguna coincidencia de expresión
TestExpression ejecuta Code3
y continúa en la siguiente línea el End Select palabra clave.
TestExpression puede ser cualquier expresión o valor.

ExpressionList1 es una lista de valores o expresiones.
Ejemplos:
El valor de la variable es un valor numérico.
El TestExpression es la suma de un + b
El TestExpression es un personaje en
Nota. Diferencias entre:

B4A VB
Seleccione Seleccione el caso
Caso 1,2,3,4,8,9, 10Case 1 A 4, 8 A 9
En VB, la palabra claveCaso se agrega después deSeleccione

la palabra clave.
VB acepta Caso 1 A 4 , esto no está implementado en B4A.
13.4 Estructuras de bucle
Estructuras de bucle diferentes están disponibles en Basic.
13.4.1 Para – Next
En un bucle de For–Next un mismo código será ejecutado un número determinado de veces.

Ejemplo:
i variable incremental
N1 valor inicial
N2 valor final
N3 paso
El bucle de For–Next funciona como sigue:

1. Al principio, la variable incremental es igual a la n1 de valor inicial.
i = n1
2. El código específico entre el Paray Siguiente Palabras clave es ejecutado.
3. Al llegar a la siguiente, la variable incremental se incrementa por el paso valor n3.
i = i + n3.
4. El programa salta a Para, compara si la variable incremental es inferior o igual a
el valor final de n2.
probar si me < = n2
5. Si sí, el programa continúa en el paso 2, la línea siguiente a la Parapalabra clave.
6. Si No, el programa continúa en la siguiente línea el Siguiente palabra clave.
Si el valor es igual a '+ 1' la palabra clave de paso no es necesario.
es el mismo que
La variable de paso puede ser negativa.
Es posible salir For – Next bucle con el palabra clave.

Salida
En este ejemplo, si la variable a es igual a 0
A continuación, salir del bucle.

Nota: Las diferencias entre

B4A VB
Siguiente Siguiente i
Salida Salida para
En VB:
 La variable de incremento se añade después de la Palabra clave.
Siguiente
 Se especifica el tipo de bucle después deSalida
la palabra clave.
13.4.2 Do - Loop
Existen varias configuraciones:
pruebaes cualquier expresión

Ejecuta el Códigomientraspruebaes True
pruebaes cualquier expresión

Ejecuta el Códigohasta pruebaes True
El Do mientras - bucle bucle funciona como sigue:

1. Al principio, pruebase evalúa.
2. Si es True, se ejecuta a continuación
Código
3. Si False continúa en la línea siguiente a la palabra clave Loop.
El Do hasta - bucle bucle funciona como sigue:

1. Al principio, pruebase evalúa.
2. Si es False, entonces se ejecuta
Código
3. Si True continúa en la línea siguiente a la palabra clave Loop.
Es posible salir de una estructura de bucle Do con la palabra clave de salida.
Si un = 0 a continuación, salir del bucle
Ejemplos:
Nota: La diferencia entre:

B4A VB
Salida Bucle de salida
En VB se especifica el tipo de bucle después deSalida

la palabra clave.
VB también acepta los siguientes lazos, que no son compatibles con B4A.
13.5 Subs
Una subrutina (\"Sub\") es un fragmento de código. Puede ser de cualquier longitud, y tiene un nombre distintivo
y un alcance definido (en los medios de alcance de las variables anteriormente). En el código de Basci4Android, un
subrutina se llama \"Sub\" y es equivalente a procedimientos, funciones, métodos y
subtitulos en otros lenguajes de programación. Las líneas de código dentro de un Sub se ejecutan desde
primero al último, como se describe en el capítulo de flujo del programa.
Se recomienda no tener demasiados Subs, reciben menos legibles.
13.5.1 Sentencias para declarar
Un Sub se declara de la siguiente manera:
Sub CalcInterest (tasa de Capital como doble, doble) como doble

Devolver Capital * tasa \/ 100
End Sub
Comienza con la palabra clave Sub, seguido del nombre del Sub, seguido de una lista de parámetros, seguida
por el tipo de valor devuelto y termina con las palabras
EndclaveSub.
Subs siempre se declaran en el nivel superior del módulo, puede anidar dos Subs
uno dentro del otro.
13.5.2 Llamando a un Sub
Cuando desea ejecutar las líneas de código en un Sub, simplemente escribes nombre del Sub.
Por ejemplo:
Interés = CalcInterest(1234, 5.2)
Interés Valor devuelto por la Sub.

CalcInterest Nombre de Sub.
1235 Capitalvalue transmitida a la Sub.
5,25 Tasa devalor transmitido a la Sub.
13.5.3 Llamando a un Sub desde otro módulo
Una subrutina declarada en un módulo de código puede acceder desde cualquier otro módulo, pero el nombre de la
rutina debe tener el nombre del nódulo donde fue declarada como prefijo.
Ejemplo: Si la rutina de CalcInterest fueron declarada en el moduel MyModule entonces llamar a la rutina
debe ser:
Interés = MyModule.CalcInterest(1234, 5.2)
En lugar de:
Interés = CalcInterest(1234, 5.2)
13.5.4 Nomenclatura
Básicamente, puede nombrar a un Sub cualquier nombre que es legal para una variable. Se recomienda
nombre del Sub con un nombre significativo, como
CalcInterest en el ejemplo, así que usted puede indicar lo que
hace de la lectura del código.
No hay límite en el número de Subs puede agregar a su programa, pero no es
permite para tener dos Subs con el mismo nombre en el mismo módulo.
13.5.5 Parámetros
Los parámetros pueden transmitirse a la Sub. La lista sigue al nombre de sub. La lista de parámetros es poner
soportes.
Los tipos de parámetro deben declararse directamente en la lista.
En B4A, los parámetros se transmiten por valor y no por referencia.
13.5.6 Valor devuelto de
Un sub puede devolver un valor, esto puede ser cualquier objeto.

Devolver un valor se realiza con la palabra clave Return.
El tipo del valor devuelto es añadido después de la lista de parámetros.
13.6 Eventos
En la programación orientada a objetos tenemos objetos que pueden reaccionar sobre las acciones de otro usuario llamadas
eventos.
El número y el tipo de eventos que puede elevar un objeto dependen del tipo del objeto.
Objetos de la interfaz de usuario se llaman 'Vistas' en Android.
Resumen de los eventos de diferentes puntos de vista:
Eventos
Cél ckedChange
ItemLongClick
FOCnosChaESNd
lUEChaESNd
ChaESNd
GEFinisél d
erPressed
haESNd
LongClick
ItemClick
KeyPress
TOUC
h
Dujon
Click
Up
a. C.
TeXT
ENT
Tun
Pun
Vun
Vistas
Actividad
Botón
Casilla de verificación
EditText
ImageView
Etiqueta
ListView
Panel
RadioButton
SeekBar
Spinner
TabHost
ToggleButton
Vista Web
Los eventos más comunes son:
 Haga clic en Evento que se provoca cuando el usuario hace clic en la vista.
Ejemplo:
 LongClick Evento que se provoca cuando el usuario hace clic en la vista y mantiene pulsado durante un rato.
Ejemplo:
 Toque (Acción como Int, X como flotador, Y como Float)

Evento que se provoca cuando el usuario toca la pantalla.
Se manejan tres acciones diferentes:

-Activity.Action_DOWN, el usuario toca la pantalla.
-Activity.Action_MOVE, el usuario mueve el dedo sin salir de la pantalla.
-Activity.Action_UP, el usuario sale de la pantalla.
Se dan las coordenadas x an y de la posición del dedo.
Ejemplo:
 CheckChanged (Comprobar As Boolean)

Evento que se provoca cuando el usuario hace clic en una casilla de verificación o un botón de opción
Comprobado es igual a True si está activada la vista o False si no está marcada.
Ejemplo:
 KeyPress (KeyCode como Int) Como Boolean

Evento que se provoca cuando el usuario presiona una tecla física o virtual.
KeyCode es el código de la tecla presionada, puede recibirlos con la palabra clave códigos de tecla.
El evento puede devolver cualquiera:

-True, el evento se 'consume', considerado por el sistema operativo como ya se ha ejecutado y
no se realiza ninguna otra acción.
-Falso, el evento no es consumido y transmitido al sistema para futuras acciones.
Ejemplo:
13.7 Bibliotecas
Bibliotecas de añadir más objetos y funcionalidades a B4A.

Algunas de estas bibliotecas se envían con B4A y son parte del sistema de desarrollo estándar.
Otros, a menudo desarrollado por usuarios como Andrew Graham (agraham), puede ser descargado (por registrado
sólo usuarios) para agregar funcionalidades suplementarias para el entorno de desarrollo B4A.
Cuando usted necesita una biblioteca, usted tiene que:

- Comprobar en la ficha de Lib, si ya tienes la biblioteca.
- Para bibliotecas adicionales, compruebe si es la versión más reciente.
- Si sí, entonces revise la biblioteca en la lista para seleccionarlo.
- Si no, descargue la biblioteca, descomprimirlo y copiar la

<LibraryName>.jar y archivos .xml de <LibraryName>a la carpeta de bibliotecas adicionales.
- Reinicie el IDE y compruebe la biblioteca en la lista de la ficha de Lib para seleccionarlo.
13.7.1 Las bibliotecas estándar de
Las bibliotecas estándar de B4A se guardan en la carpeta de las bibliotecas en la carpeta del programa B4A.
Normalmente en: C:\\Program Files\\Anywhere Software\\Basic4android\\Libraries
13.7.2 Carpeta de bibliotecas adicionales
Para las bibliotecas adicionales es útil configurar una carpeta especial para guardarlos en otro lugar.
Por ejemplo: D:\\Basic4Android\\AddLibraries
Al instalar una nueva versión de B4A, todas las bibliotecas estándar se actualizan automáticamente, pero la
bibliotecas adicionales no están incluidas. La ventaja de la carpeta especial es que no necesita
se preocupan por ellos porque esta carpeta no se ve afectada al instalar la nueva versión de B4A.
Las bibliotecas adicionales no se actualizan sistemáticamente con la nueva versión de B4A.
Cuando se inicia el IDE, busca primero para las bibliotecas disponibles en la carpeta de las bibliotecas de B4A y luego
en la carpeta de las bibliotecas adicionales.
Si configura una carpeta especial bibliotecas adicionales debe especificarlo en el IDE.
En el menú Herramientas \/ configurar rutas de acceso:
Introduzca el nombre de la carpeta y haga clic en .
13.7.3 Error mensaje \"falta una referencia de la biblioteca?\"
Si recibe este mensaje, significa que ha olvidado comprobar la biblioteca especificada en la lista de la ficha de Lib!
13.8 Manipulación de cadenas
Basic4Android permite manipulaciones de cadenas como otros idiomas básicos pero con algunas diferencias.
Estas manipulaciones pueden hacerse directamente en una cadena.

Ejemplo:
Resultado:
123, 234; 45; 23
Las diferentes funciones son:

 CharAt(Index) Devuelve el carácter en el índice especificado.
 CompareTo(Other) Lexicográficamente compara la cadena con la otra cadena.
 Contains(SearchFor) Comprueba si la cadena contiene la cadena SearchFor dada.
 EndsWith(Suffix) Devuelve True si la cadena termina con la subcadena de sufijo determinada.
 EqualsIgnoreCase(Other) devuelve True si dos cadenas son iguales ignorando su caso.
 GetBytes(Charset) Codifica la cadena de caracteres en una nueva matriz de bytes.
 IndexOf(SearchFor) Devuelve el índice de la primera aparición de SearchFor en el
cadena.
 IndexOf2(SearchFor, Index) Devuelve el índice de la primera aparición de SearchFor
en la cadena. Inicia la búsqueda en el índice especificado.
 LastIndexOf(SearchFor) Devuelve el índice de la primera aparición de SearchFor en el
cadena. Inicia la búsqueda del final de la cadena.
 Legnth Devuelve la longitud, el número de caracteres, de la cadena.
 Replace (destino, reemplazo) Devuelve una nueva cadena resultante de la sustitución de
todas las apariciones de destino con reemplazo.
 StartsWith(Prefix) Devuelve True si esta cadena comienza con el prefijo especificado.
 Substring(BeginIndex) Devuelve una nueva cadena que es una subcadena de la cadena original.
La nueva cadena incluirá el carácter BeginIndex y se extenderá hasta el final de la
cadena.
 Substring2(BeginIndex,EndIndex) Devuelve una nueva cadena que es una subcadena de la
cadena original. La nueva cadena incluirá el carácter BeginIndex y se extenderá a
el carácter EndIndex, no incluyendo el último carácter.
 ToLowerCase Devuelve una nueva cadena que es el resultado de la menor esta cadena de la carcasa.
 ToUpperCase Devuelve una nueva cadena que es el resultado del alto cuerpo de esta cadena.
 Trim Devuelve una copia de la secuencia original sin ningún iniciales o finales
espacios en blanco.
Número de formato, mostrar los números como cadenas con diferentes formatos, hay dos palabras clave:
 NumberFormat (número doble, MinimumIntegers como Int, MaximumFractions como Int)
NumberFormat (12345.6789, 0, 2) = 12,345.68
NumberFormat (1, 3, 0) = 001
NumberFormat (valor, 3, 0) pueden utilizar variables.
NumberFormat (valor + 10, 3, 0) pueden utilizar las operaciones aritméticas.
NumberFormat ((lblscore.Texto + 10), 0, 0) Si una variable es una cadena agregar paréntesis.
 NumberFormat2 (número como doble, MinimumIntegers como Int, MaximumFractions como

Int, MinimumFractions como Int, GroupingUsed As Boolean)
NumberFormat2 (12345.67, 0, 3, 3, True) = 12,345.670
13.9 Temporizadores
Un objeto Timer genera eventos de garrapatas en los intervalos especificados. Utilizando un temporizador es una buena alter
gancho largo, ya que permite que el subproceso de la interfaz de usuario manejar otros eventos y mensajes.
Tenga en cuenta que los eventos del temporizador no disparará mientras el subproceso de la interfaz de usuario está ocupa
Llame a palabra clave DoEvents).
Eventos del temporizador no se activará cuando se detiene la actividad, o si es un diálogo de bloqueo (como Msgbox)
visible.
También es importante desactivar el temporizador cuando la actividad es una pausa y luego activarlo cuando se
se reanuda. Esto ahorra CPU y batería.
Tiene un temporizador:
 Tres parámetros.
o Inicializar Inicializa el temporizador con dos parámetros, el EventName y el
intervalo.
Timer1.Initialize (EventName como cadena, intervalo de tiempo)
Ej.: Timer1.Initialize (\"Timer1\", 1000)
o Intervalo Establece el intervalo del temporizador en milisegundos.

Timer1. Intervalo = intervalo
Gxx Timer1.Interval = 1000segundo 1
o Habilitado Habilita o deshabilita al temporizador. Es False de forma predeterminada.

Ej.: Timer1.Enabled = True
 Un evento
o Garrapata La rutina de la garrapata se llama cada intervalo de tiempo.
Gxx Sub Timer1_Tick
El temporizador debe declararse en una rutina de Process_Global.
Pero debe ser inicializado en la rutina de Activity_Create en el módulo donde la garrapata de temporizador
se utiliza la rutina del evento.
Y la rutina del evento Tick del Timer.

Esta rutina se llamará cada segundo (1000 milisegundos) por el sistema operativo.
Encontrará un ejemplo en el programa de ejemplo RotatingNeedle.

13.10 Archivos
Muchas aplicaciones requieren acceso a un almacenamiento persistente. Son los dos tipos más comunes de almacenamiento
archivos y bases de datos.
13.10.1 Objeto de archivo
El objeto predefinido Archivo

tiene una serie de funciones para trabajar con archivos.
Ubicaciones de archivos - allí son varios lugares importantes donde puede leer o escribir archivos.
File.DirAssets
La carpeta de activos incluye los archivos que se agregaron con el administrador de archivos en el IDE.
Es la carpeta de archivos en la carpeta del proyecto.
Estos archivos son de sólo lectura.
No puede crear nuevos archivos en esta carpeta (que en realidad se encuentra dentro del archivo apk).
Si tiene un archivo de base de datos en la carpeta Dir.Assets deberás copiarlo a otra carpeta antes de
puede utilizarlo.
File.DirInternal \/ File.DirInternalCache
Estas dos carpetas se guardan en la memoria principal del dispositivo y son privadas para su aplicación.
Otras aplicaciones no pueden acceder a estos archivos.
La carpeta de caché puede obtener eliminada por el sistema operativo Si necesita más espacio.
File.DirRootExternal
La carpeta de raíz de la tarjeta de almacenamiento.
File.DirDefaultExternal
La carpeta predeterminada para su aplicación en la tarjeta SD.
La carpeta es: datos < tarjeta de almacenamiento > \/ Android \/ \/ < paquete > \/files\/
Se creará si es necesario.
Tenga en cuenta que llamar a cualquiera de los dos anteriores propiedades agregará el permiso de EXTERNAL_STORAGE
para su aplicación.
Sugerencia: Puede comprobar si hay una tarjeta de almacenamiento y si está disponible con
File.ExternalReadable y File.ExternalWritable.
Para comprobar si un archivo ya existe uso:

File.exists (Dir como cadena, FileName As String)
Devuelve True si el archivo existe y False si no.
El objeto de archivo incluye varios métodos para escribir en archivos y lectura de archivos.
Para poder escribir en un archivo o leer desde un archivo, se debe abrir.

File.OpenOutput (Dir como cadena, nombre de archivo como cadena, anexar As Boolean)
-Abre el archivo dado para la salida, la anexar parámetro indica si el texto se agregará a la
final del archivo existente o no. Si el archivo no existe se creará.
File.OpenInput (Dir como cadena, FileName As String)

-Abre el archivo para lectura.
File.WriteString (Dir como cadena, nombre de archivo como cadena, texto As String)
-Escribe el texto en un archivo nuevo.
File.ReadString (Dir como cadena, FileName As String) As String

-Lee un archivo y devuelve su contenido como una cadena.
File.WriteList (Dir como cadena, nombre de archivo como cadena, lista como lista)
-Escribe todos los valores almacenados en una lista en un archivo. Todos los valores se convierten al tipo de cadena si es nec
valor se almacenará en una línea de separare.
Tenga en cuenta que si el valor contiene el carácter de nueva línea será guardado durante más de una línea y cuando
leerla, se leerá como varios elementos.
File.ReadList (Dir como cadena, FileName As String) como lista

-Lee un archivo y lo almacena cada línea como un elemento de una lista.
File.WriteMap (Dir como cadena, nombre de archivo como cadena, mapa, mapa)
-Toma un objeto de mapa que contiene pares de clave y valor y lo almacena en un archivo de texto. El archivo
formato es conocido como archivo de propiedades Java: .properties - Wikipedia, la enciclopedia libre
El formato de archivo no es demasiado importante, a menos que el archivo se supone para ser editado manualmente. Este form
es fácil editarlo manualmente.
Un uso común de File.WriteMap es para guardar un mapa de \"configuraciones\" en un archivo.
File.ReadMap (Dir como cadena, FileName As String) como mapa

-Lee un archivo de propiedades y devuelve sus pares de clave y valor como un objeto de mapa. Tenga en cuenta que e
entradas pueden ser diferentes de la orden original.
Algunas otras útiles funciones:
File.Copy (DirSource As String, ello como cadena, DirTarget As String, FileTarget As String)
-Copia el archivo de origen desde el directorio de origen en el archivo de destino en el directorio de destino.
Tenga en cuenta que no es posible copiar archivos a la carpeta de activos.
File.Delete (Dir como cadena, FileName As String)

-Elimina el archivo del directorio dado.
File.Listfiles (Dir como cadena) como lista

-Enumera los archivos y subdirectorios del directorio diven.
Ejemplo:
List1 = File.ListFiles(File.DirRootExternal)
List1 puede ser 'dimed' en Sub Globals
File.Size (Dir As String FileName As String)

-Devuelve el tamaño en bytes del archivo especificado.
Este método no es compatible con archivos en la carpeta de activos.
13.10.2 Nombres de archivo
Los nombres de archivo Android permiten siguientes caracteres:

un a-z, A-z, 0 a 9 puntos. subrayado _ e incluso después de caracteres + -%
¿Espacios y caracteres siguientes *? no se permiten.
Ejemplo: MyFile.txt
Tenga en cuenta que los nombres de archivo Android son case sensitive!
MyFile.txt es diferente de myfile.txt
13.10.3 Subcarpetas
Puede definir las subcarpetas en Android con.

File.MakeDir (File.DirInternal, \"Imágenes\")
Para acceder a la subcarpeta debe agregar el subfoldername a la foldername con «\/» se situe.
ImageView1.Bitmap = LoadBitmap (File.DirInternal
O agregar el subfoldername antes del nombre de archivo se situe «\/».

ImageView1.Bitmap = LoadBitmap (File.DirInternal, \"Pictures\/test1.png\")
Ambas posibilidades de trabajo.

13.10.4 TextWriter
Hay dos otras funciones útiles para archivos de texto: TextWriter y TextReader:
TextWriter.Initialize (OutputStream como OutputStream)

-Inicializa un objeto TextWriter como un flujo de salida.
Ejemplo:
Dim Writer As TextWriter
Writer.Initialize (File.OpenOutput (File.DirRootExternal, \"Test.txt\", False))
Escritor podría ser 'dimed' en Sub Globals.
TextWriter.Initialize2 (OutputStream como OutputStream, codificación como cadena)

-Inicializa un objeto TextWriter como secuencia de salida.
-Codificación indica la página de códigos (también llamado conjunto de caracteres), el texto de codificación (ver capítulo sig
Ejemplo:
Dim Writer As TextWriter
Writer.Initialize2 (File.OpenOutput (File.DirRootExternal,\"Test.txt\", False), \"ISO-8859-1\")
Escritor podría ser 'dimed' en Sub Globals.
TextWriter.Write (texto As String)

-Escribe el texto en la secuencia.
TextWriter.WriteLine (texto As String)

-Escribe el texto en la secuencia seguida de un carácter de nueva línea Chr(10) LF.
TextWriter.WriteList (lista como lista)

-Escribe cada elemento en la lista como una sola línea.
Tenga en cuenta que un valor que contiene CRLF se guardará como dos líneas (que volverá dos artículos cuando
lectura con ReadList).
Todos los valores se convierten en cadenas.
TextWriter.Close
-Cierra la secuencia.
Ejemplo:
13.10.5 TextReader
Hay dos otras funciones útiles para archivos de texto: TextWriter y TextReader:
TextReader.Initialize (InputStream como InputStream)

-Inicializa un TextReader como una secuencia de entrada.
Ejemplo:
Dim Reader TextReader
Reader.Initialize (File.InputOutput (File.DirRootExternal, \"Test.txt\"))
Lector podría ser 'dimed' en Sub Globals.
TextReader.Initialize2 (InputStream como InputStream, codificación como cadena)

-Inicializa un TextReader como una secuencia de entrada.
-Codificación indica la página de códigos (también llamado conjunto de caracteres), la codificación de texto.
Ejemplo:
Dim Reader TextReader
Reader.Initialize (File.OpenInput (File.DirRootExternal, \"Test.txt\"), \"ISO-8859-1\")
Lector podría ser 'dimed' en Sub Globals.
TextReader.ReadAll As String
-Lee todo el texto restante y cierra la secuencia.
Ejemplo:
TXT = Reader.ReadAll
TextReader.ReadLine As String
-Lee la línea siguiente de la secuencia.
Los caracteres de línea nueva no se devuelven.
Devuelve Null si no hay no hay más caracteres a leer.
Ejemplo:
TextReader.ReadList como lista

-Lee el texto restante y devuelve un objeto List llenado de las líneas.
Cierra la secuencia cuando termine.
Ejemplo:
List1 = Reader.ReadList
13.10.6 Codificación de texto
Codificación de texto o codificación de caracteres consiste en un código que pares cada carácter de un determinado
repertorio con otra cosa. Otros términos como carácter conjunto (charset) y a veces de carácter
página Mapa o código se usan casi indistintamente (fuente Wikipedia).
El carácter predeterminado en Android es Unicode UTF-8.
En Windows el carácter más comunes conjuntos son ANSII y ANSIS.

 ASCII incluye definiciones para 128 caracteres, 33 son caracteres no imprimibles control (ahora
en su mayoría obsoletos) que afectan a cómo se procesa el texto y el espacio.
 ANSI, Windows-1252 o CP-1252 es un personaje de codificación del alfabeto latino, utilizado por
por defecto en los componentes heredados de Microsoft Windows en inglés y algunos otros occidentales
idiomas con 256 definiciones (un byte). Los primeros 128 caracteres son los mismos como en la
Codificación ASCII.
Muchos archivos generados por los programas de Windows están codificados con el conjunto de caracteres en el oeste de AN
países. Por ejemplo: archivos csv de Excel, archivos de Bloc de notas por defecto.
Pero con el Bloc de notas, los archivos pueden guardarse con UTF-8 codificación.
Android puede utilizar el siguiente conjuntos de caracteres:

 UTF-8 predeterminado el conjunto de caracteres
 UTF -16
 SER UTF - 16
 UTF - LE
 US-ASCII Conjunto de caracteres ASCII
 Conjunto de caracteres ISO-8859-1 casi equivalente a la ANSI
Para leer archivos de Windows codificados con ANSI debe usar el conjunto de caracteres ISO-8859-1.
Si necesita escribir archivos para su uso con Windows también se debe utilizar el conjunto de caracteres ISO-8859-1.
Otra diferencia entre Windows y Android es el fin del personaje de línea:

 Android, sólo el carácter de LF (Line Feed) Chr(10) se agrega al final de una línea.
 Windows, dos caracteres CR (CHR de retorno de carro y Chr(10) LF se agregan a la
final de una línea. Si necesita escribir archivos para Windows debe agregar CR usted mismo.
Es el símbolo de final de línea:

 Basic4Android CRLF Chr(10)
 Basic4PPC CRLF Chr(10)
Para leer o escribir archivos con una codificación diferente que debe utilizar los objetos TextReader o TextWriter
con los métodos de Initialize2. Incluso para leer archivos csv.
Consejo de lectura de archivos csv de Excel:

Usted puede escoger:
 En el escritorio, cargar el archivo csv en un editor de texto como Bloc de notas o Notepad ++
 Guarde el archivo con codificación UTF-8
O
 Codificación de leer todo el archivo con TextReader.Initialize2 y \"ISO-8859-1\".
 Guardarlo con TextWriter.Initialize con la codificación estándar de Android.
 Lea el archivo LoadCSV o LoadCSV2 de la biblioteca StringUtils.
13.11 Listas
Las listas son similares a los arreglos dinámicos, descripciones detalladas de todas las funciones son en el capítulo lista.
A menudo se utilizan listas y muchos ejemplos pueden encontrarse en los ejemplos de código:
 StringUtils LoadCSV, SaveCSV
 Módulo DBUtils InsertMaps, UpdateRecord, ExecuteMemoryTable, ExecuteSpinner,
ExecuteListView, ExecuteHtml, ExecuteJSON
 Módulo de gráficos para sostener las diferentes variables.
Una lista debe inicializarse antes de que se puede utilizar.

 Inicializar Inicializa una lista vacía.
List1.Initialize
List1.AddAll (matriz como Int (1, 2, 3, 4, 5))
 Initialize2 (unamatriz)
Inicializa una lista con los valores indicados. Este método se debe utilizar para convertir matrices a listas.
Tenga en cuenta que si se pasa una lista a este método y luego ambos objetos compartirán la misma lista y si
se pasa una matriz de que la lista será de un tamaño fijo.
Lo que significa que más tarde no se puede agregar o quitar elementos.
Ejemplo 1:
List1.Initialize2 (matriz como Int (1, 2, 3, 4, 5))
Ejemplo 2:
Dim SomeArray(10) As String
' Llenar la matriz
List1.Initialize2(SomeArray)
Puede agregar y quitar elementos de una lista y cambiará su tamaño en consecuencia.

Con cualquiera:
 Agregar (elemento As Object)
Agrega un valor al final de la lista.
List1.Add(Value)
 AddAll (matriz como String(\"value1\", \"value2\"))

Agrega todos los elementos de una matriz al final de la lista.
List1.AddAll(List2)
 AddAllAt (índice como Int, lista como lista)

Inserta todos los elementos de una matriz en la lista que comienza en la posición dada.
List1.AddAll (12, List2)
List1.AddAllAt (12, conjunto como Int (1, 2, 3, 4, 5))
 InsertAt (índice como Int, elemento As Object)

Inserta el elemento especificado en el índice especificado.
Como resultado se desplaza todos los elementos con mayor índice y luego el índice especificado.
List1.InsertAt (valor 12)
 RemoveAt (índice como Int)

Quita el elemento especificado en la posición especificada de la lista.
List1.RemoveAt(12)
Una lista puede contener cualquier tipo de objeto. Sin embargo, si una lista es declarada como un objeto global del proceso n
contener objetos de actividad (como vistas).
Basic4android convierte automáticamente matrices regulares en las listas. Cuando se espera un parámetro de la lista
se puede pasar una matriz en su lugar.
Obtener el tamaño de una lista:

 List1.Size
Utilice el método Get para obtener un elemento de la lista con:

 Get (índice como Int)
número = List1.Get(i)
Puede utilizar un bucle For para recorrer en iteración todos los valores:
Para i = 0 To List1.Size - 1
Dim número como Int
...
Siguiente
Las listas pueden ser guardadas y cargadas de archivos con:

 File.WriteList (Dir como cadena, nombre de archivo como cadena, lista como lista)
File.WriteList (File.DirRootExternal, \"Test.txt\", List1)
 File.ReadList (Dir como cadena, FileName As String)
List1 = File.ReadList (File.DirRootExternal, \"Test.txt\")
Puede cambiar un elemento sinngle con:

 List1. SET (índice como Int, elemento As Object)
List1.Set (valor 12)
Puede ordenarse una lista (deben encontrarse los elementos todos números o cadenas) con:
 Orden (ascendente As Boolean)
List1.Sort(true) orden ascendente
List1.Sort(false) Ordenar descendente
 SortCaseInsensitive (ascendente As Boolean)
Borrar una lista con:

 List1.Clear
13.12 Mapas de
Un mapa es una colección que contiene pares de claves y valores, son descripciones detalladas de todas las funciones
en el capítulo de mapa.
Las claves son únicas. Lo que significa que si agrega un par de clave\/valor (entrada) y la colección
ya tiene una entrada con la misma clave, la entrada anterior se eliminará del mapa.
La clave debe ser una cadena o un número. El valor puede ser cualquier tipo de objeto.
Similar a una lista, un mapa puede contener cualquier objeto, sin embargo, si es una variable global del proceso no
Los mapas son muy útiles para almacenar la configuración de aplicaciones.
Mapas se utilizan en estos códigos de ejemplo:

 Módulo DBUtils
utilizado para las entradas de la base de datos, las claves son los nombres de columna y los valores.
 Módulo StateManager usado para la configuración
Una lista debe inicializarse antes de que se puede utilizar.

 Inicializar Inicializa un mapa vacío.
Dim Map1 As mapa
Map1.Initialize
Agregar una nueva entrada:

 Pongo (clave como objeto, valor como objeto)
Map1.put (\"lengua\", \"Inglés\")
Obtener una entrada:

 Get (clave como objeto)
Idioma = Map1.Get(\"Language\")
Obtenga una clave o un valor en un índice determinado:

Devuelve el valor del elemento en el índice especificado.
GetKeyAt y GetValueAt deben utilizarse para recorrer en iteración todos los elementos.
Estos métodos están optimizados para recorrer en iteración los elementos en orden ascendente.
 GetKeyAt (índice como Int)
Clave = Map1.GetKeyAt(12)
Obtener un valor en un índice determinado:

 GetValueAt (índice como Int)
Valor = Map1.GetValueAt(12)
Comprobar si un mapa contiene en entrada, comprueba si existe una entrada con la clave dada:
 ContainsKey (clave como objeto)
Si Map1.ContainsKey(\"Language\") entonces
MsgBox (\"Ya hay una entrada con esta tecla!\", \"Atención\")
Retorno
End If
13 Lenguaje basic 196 ArgumentException: The incoming token has e
Quitar una entrada:

 Quitar (clave como objeto)
Map1.Remove(\"Language\")
Borrar una entrada, borra todos los elementos del mapa:

 Claro
Map1.Clear
Mapas pueden ser guardados y cargados con:

 File.WriteMap (Dir como cadena, nombre de archivo como cadena, mapa, mapa)
File.WriteMap (File.DirInternal, \"settings.txt\", mapSettings)
 ReadMap (Dir As String FileName As String)

Lee el archivo y analiza cada línea como un par de clave y valor (de cadenas).
Tenga en cuenta que el orden de los elementos en el mapa no puede ser el mismo que el orden en el archivo.
mapSettings = File.ReadMap (File.DirInternal, \"settings.txt\")
 Archivo. ReadMap2 (Dir como cadena, nombre de archivo como cadena, mapa como mapa)
Similar a ReadMap. ReadMap2 agrega los elementos del mapa dado.
Mediante el uso de ReadMap2 con un mapa poblado puede forzar el orden de elementos según sea necesario.
mapSettings = File.ReadMap2 (File.DirInternal, \"settings1.txt\", mapSettings)
14 Gráficos \/ dibujo 197 Basic4Android Guía del principiante
14 Gráficos \/ dibujo
14.1 Visión general
Para dibujar gráficos tenemos que utilizar un objeto Canvas.
Explicaciones desde el archivo de ayuda.

Un lienzo es un objeto que se basa en otros puntos de vista o mapas de bits (mutable).
Cuando el lienzo es inicializado y dibujar en una vista, un nuevo mapa de bits mutable es creado para
Fondo de la vista, fondo de la vista actual se copia en el nuevo mapa de bits y se establece el lienzo
para dibujar en el nuevo mapa de bits.
Los dibujos de lienzo no se actualizan inmediatamente en la pantalla. Debe llamar a la vista de destino
Invalidar el método para actualizar la vista.
Esto es útil ya que permite hacer varios dibujos y sólo entonces actualizar la pantalla.
El lienzo puede ser temporal limitada a una región específica (y así sólo afectan a esta región). Esto es
hecho llamando ClipPath. Retirar el recorte se hace llamando al RemoveClip.
Puede obtener el mapa de bits que el lienzo se basa en la propiedad de mapa de bits.
Esto es un 'objeto de actividad', no se puede declarar bajo Sub Process_Globals.
Es posible trazar en las siguientes vistas:

 Actividad
 ImageView
 Panel
 Mapa de bits (mutable)
En las siguientes funciones, usted encontrará una serie de parámetros comunes.

 Bitmap1 como mapa de bits un mapa de bits Android
 x, y. x 1, y1, x 2, y2 como flotador son las coordenadas, variables de flotador.
 Color como Int son variables de color. Variables int
 SrcRect, DestRact, Rect1 como Rect son rectángulos, Rect objetos
 Llena As Boolean Bandera si la superficie está lleno (True) o no (False)
Las funciones de dibujo más comunes son:

 DrawBitmap (Bitmap1 como mapa de bits, SrcRect como Rect, DestRect como Rect)
Dibuja el mapa de bits determinada o sólo una parte de ella...
SrcRect = rectángulo de origen, puede ser sólo una parte del mapa de bits original.
DestRect = rectángulo de destino, puede ser de cualquier tamaño.
Dibujar con el mismo tamaño de ambos rectángulos tienen mismo ancho y la misma altura.
Si DestRect es diferente de la SrcRect el destino de dibujo es estirada o reducido
dependiendo de las proporciones de tamaño entre los dos rectángulos.
 Llamar BitmapRotated (Bitmap1 como mapa de bits, SrcRect como Rect, DestRect como Rect, grados
Como flotador)
Misma función como DrawBitmap, pero con una rotación de los grados determinados ángulo alrededor de la
Centro de mapa de bits.
 DrawCircle (x como flotador, y como Float, Radius como Float, Color como Int, llenado como Boolean,
StrokeWidth como Float)
Dibuja un círculo.
x una y son las coordenadas del centro del círculo y radio el radio de los círculos.
 DrawColor (Int Color)

Llena la vista de toda el color dado.
El color puede ser Colors.Transparent haciendo la vista toda transparente.
 DrawLine (x 1 como flotador, y1 como Float, x 2 como flotar, y2 como Float, Color como Int, StrokeWidth
Como flotador)
Dibuja una línea recta.
 DrawRect (Rect1 como Rect, Color como Int, llenado como Boolean, StrokeWidth como Float)
Dibuja un rectángulo con dado el tamaño, color, ancho de línea y lleno o no.
 DrawRectRotated (Rect1 como Rect, Color como Int, llenado como Boolean, StrokeWidth como Float,
Grados como Float)
Mismo que DrawRect pero girada por el ángulo dado
 DrawText (texto As String, x como flotador, y como Float, Typeface1 como tipo de letra, TestSize como
Float, Int Align1 como alinear de Color)
 DrawTextRotated (texto As String, x como flotador, y como Float, Typeface1 como tipo de letra,
TestSize como Float, Color como Int Align1 como alinear, grados como Float)
14.2 Programas de prueba de dibujo
14.2.1 Dibujo de mapas de bits giratorio \/ RotatingNeedle
El proyecto se encuentra en: SourceCode\\Graphics\\RotatingNeedle\\RotatingNeedle.b4a
En el primer programa de prueba demostraremos la función DrawBitmapRotated.

El programa tiene dos modos:
 Una aguja giratoria con una brújula estática
 Una brújula giratoria con una aguja estática
Tenemos en el diseño:
 3 botones
o
empieza a girar
o
movimiento de paso a paso
o
podemos dejar que gire bien la aguja
o la brújula.
 2 archivos de mapa de bits

o Compass.png
o Needle.png
En la función de DrawBitmapRotated el mapa de bits gira alrededor del centro de mapas de bits.
Si tuviéramos una imagen de la aguja como éste, tendríamos que hacer algunos cálculos para asegurarse de
gira alrededor del centro de la aguja.
Para evitar estos cálculos, el mapa de bits de aguja se ve como esta. Hemos añadido la parte inferior tan
que es el centro de la aguja en el centro del mapa de bits.
Los píxeles azules son, en realidad, los píxeles transparentes.

Tengamos una mirada en el código.
Aquí definimos tres variables globales con sus valores.

 AngleStep paso en grados para las variaciones de ángulo de un paso a la siguiente.
 Ángulo ángulo actual de la aguja
 Modo modo de programa
True = vueltas de aguja
Falso = vueltas brújula
Entonces definimos los diferentes objetos utilizados por el programa.

 Los tres botones desde el archivo de diseño.
 Dos vistas de lienzo, uno para la brújula y otro para la aguja.
 Dos mapas de bits, uno para la brújula y otro para la aguja.
 Dos ImageViews, uno para la brújula y otro para la aguja.
 Tres rectángulos, uno para la brújula, dos para el origen de la aguja y el destino.
 Un temporizador, se utiliza para mover dinámicamente la aguja o la brújula.
En la rutina Activity_Create:
 Definir dos variables utilizadas para los cálculos

 Cargar el archivo de diseño a la actividad
 Inicializar la brújula de mapa de bits

 Inicializar el mapa de bits de aguja
 Inicializar la brújula ImageView.

 Coloque la brújula de mapa de bits en la brújula ImageView de mapa de bits.
 Inicializar la aguja ImageView.
 Ajustar la aguja ImageView color a transparente.
 Calcular las coordenadas izquierda y superior de la brújula ImageView.

 Añadir la brújula ImageView a la actividad.
 Añadir la aguja ImageView a la actividad
con las mismas dimensiones que la brújula ImageView.
 Inicializar la brújula lienzo y conéctelo a la brújula ImageView.
 Inicializar el rectángulo de la brújula.
 Inicializar la aguja lienzo y conéctela a la aguja ImageView.

 Calcular las coordenadas izquierda y superior de la aguja ImageView.
 Inicializar los rectángulos de origen y destino de la aguja.
 Inicializar el temporizador, establecer el intervalo en ms de 200.

 Llamar a la rutina Timer1_Tick para dibujar la aguja
En la rutina de Timer1_Tick tenemos:
 Definir una variable local que representa el ángulo actual

 Calcular el ángulo de nuevo utilizando el operador Mod
 Si el modo = True, girando de modo de aguja nos:
o Dibuja un rectángulo transparente girado para borrar la aguja actual.
o Sacar la aguja con el nuevo ángulo.
o Invalidar la aguja ImageView actualizarlo.
 Si el modo = False, girar la brújula de modo:
o Dibujar la brújula con el nuevo ángulo, en nuestro caso la fuente y el destino
rectángulo son iguales.
o Invalidar la brújula ImageView actualizarlo.
En la rutina btnStep_Click:
 Llamar a la rutina Timer1_Tick para dibujar un nuevo paso.

En la rutina btnGoStop_Click:
 Si Timer1 = True, el temporizador está funcionando.

o Establecemos el parámetro Timer1.Enabled en False para detenerlo.
o Establecer el texto del botón btnGoStop a \"Go\".
o Coloque el botón de btnStep visible.
 Si Timer1 = False, el temporizador se detiene
o Establecemos el parámetro Timer1.Enabled en True para dejar que se ejecute.
o Establecer el texto del botón btnGoStop \"STOP\".
o Ocultar el botón de btnStep.
En la rutina btnMode_Click:
 Cambiamos el modo variable de true a False o de False a True con la no

palabra clave.
 Si el modo = True, girar la aguja, tenemos:
o Establecer el texto del botón a \"Aguja gira\".
o Dibuja un rectángulo transparente para borrar la aguja actual.
o Sacar la aguja en la nueva posición.
o Dibujar la brújula por defecto.
 Si el modo = False, girar la brújula, tenemos:
o Establecer el texto del botón de \"Brújula gira\".
o Borrar la aguja actual
o Sacar la aguja nueva.
14.2.2 Sencillo dibujar funciones
El proyecto se encuentra en: SourceCode\\Graphics\\SimpleDrawFunctions\\SimpleDrawFunctions.b4a
En el segundo programa de dibujo, SimpleDrawFunctions, usamos el otro plano común

funciones.
El programa no tiene otra finalidad que mostrar lo que puede hacerse con dibujos.
El programa tiene tres paneles que utilizamos como capas y tres botones de ToggleButtons que nos permite
para mostrar u ocultar cada capa.
Layer(0) tiene un fondo gris y las otras dos capas tienen un fondo transparente.
Se puede jugar con los botones para observar las diferentes combinaciones de capas visibles y ocultas.
En esta captura vemos únicamente la imagen de fondo de

la actividad.
Usamos el ToggleButtons para ocultar o mostrar el

diferentes capas.
Aquí mostramos layer(0).
El panel tiene un fondo gris oscuro con:

 un círculo azul.
 un círculo transparente, fondo de la actividad es
dentro de este círculo.
 un rectángulo semitransparente azul
 un rectángulo transparente, fondo de la actividad
es dentro de este círculo.
Tocar la pantalla y mover el dedo se mueve la

círculos azules y transparentes en layer(0).
El panel tiene un fondo transparente con:

 un círculo verde.
 una pequeña copia de la imagen de fondo de la actividad.
 un rectángulo semitransparente verde, girado.
Vemos que el rectángulo cubre la actividad

de fondo porque la capa 1 está al frente de la capa de 0.
El panel tiene un fondo transparente con:

 4 líneas en la parte superior.
 3 textos horizontales con tres diferentes
alineaciones.
 3 giradas textos con las tres alineaciones diferentes.
 un punto para cada texto que muestra la posición de la
punto de referencia.
Se puede jugar con los botones para mostrar las diferentes combinaciones de capas visibles y ocultas.
Tocar la pantalla con el dedo y moverlo,

mueve los círculos azules y transparentes.
En cada jugada, la imagen de backgound de la actividad

aparece.
Análisis del código:
No hay ningún archivo de diseño, todas las vistas se agregan por código.
En la rutina de Sub Globals declaramos las variables y diferentes puntos de vista:
Tenemos:
 3 Paneles
 3 Lienzos
 3 ToggleButtons
 1 Rect, rectángulo para dibujar rectángulos
 1 Mapa de bits, manteniendo la imagen de fondo de la actividad
 1 BitmapDrawable, tiene antecedentes de la actividad
 diferentes variables utilizadas para el dibujo.
Tenga en cuenta que usar matrices de puntos de vista de tres paneles, lienzos y togglebuttons.
Dim pnlLayer(3) como Panel En lugar deDim pnlLayer0, pnlLayer1, pnlLayer2 como grupo.
En la rutina de Sub Activity_Create nos inicializar las diferentes opiniones y agregarlos a la actividad:
Tenemos:
 inicializar el sólo si vistas declarción = True.
 cargar el Rose2.jpg archivo de imagen en mapa de bits.
 inicializar la imagen de fondo de la actividad.
 Establecer imagen de fondo de la actividad
 inicializar algunas variables.

En un bucle:
 inicializar los paneles capa.
definimos un EventName individual para cada uno de los tres paneles
utilizamos sólo un evento en layout(0).
 agregar los paneles a la actividad.
 inicializar los lienzos de capa.
 Establezca el parámetro de la etiqueta de paneles en el índice.
 inicializar la capa de ToggleButtons.

definimos un EventName único para todos los tres ToggleButtons.
Gestionamos el mostrar y ocultar los paneles en la rutina de un solo evento.
 calcular las coordenadas izquierda para cada ToggleButton.
 definir los textos de los dos Estados.
 Establezca el parámetro Checked a True.
 Establezca el parámetro de la etiqueta en el índice.
En la rutina de Sub Activity_Resume llamamos la rutina de dibujo.

En la rutina de Sub dibujo tenemos:
 dibujar el gris oscuro de fondo de layout(0).

 dibujar el fondo de layout(1) y layout(2) transparente.
 Dibuje cuatro líneas en layer(2)

cvsLayer(2).DrawLine (x 1, y1, x 2, y2, Colors.Red, 0)
el último parámetro de StrokeWidth es '0', esto significa modo de capilares, el ancho es de un píxel.
cvsLayer(2).DrawLine (x 1, y1, x 2, y2, Colors.Green, 0.99dip)
aquí usamos 0.99dip en lugar de 1dip porque en algunos casos ninguna línea o sólo partes de él son
dibujado. Este es un problema conocido en Android con un StrokeWidth de '1'.
 Dibuje una línea de círculo verde en layer(1).

 Dibuje un círculo azul lleno de layer(0).
 Dibuje un círculo transparente lleno en layer(0).
 definir las coordenadas de un rectángulo.

 dibujar un rectángulo rojo en layer(1).
 dibujar un rectángulo azul semitransparente en layer(0).
 dibujar un rectángulo girado verde semitransparente en layer(1).
 dibujar un rectángulo transparente en layer(0).
 dibujar un rectángulo rojo en layer(1).

 dibujar la imagen de fondo de la actividad en un rectángulo más pequeño en layer(1)
 dibujar el texto \"La Rosa\" con las tres alineaciones posibles diferentes.
 dibujar el punto de referencia para cada texto.
 igual al anterior pero rotados textos.

Mirar más estrecha sobre los textos mostrados vemos la referencia punto para cada texto.
Estas son las coordenadas x 1 y y1 utilizadas para mostrar los textos.
IZQUIERDA
alineación.
Alineación al centro.
Alineación a la derecha.
En la rutina de btnLayer_Checked Sub tenemos:
 Dim un botón local para obtener la vista que provocó el evento.

 Set Send a la vista de remitente
 cambiar el parámetro Visible de true a False o de False a True.
En la rutina de pnlLayer0_Checked Sub tenemos:
 Dibuje un círculo gris oscuro para borrar el anterior círculo azul y transparente.
 conjunto y yc a las nuevas coordenadas de los centros de círculo.
 Dibuje un círculo azul y transparente en layer(1).
 invalidar pnlLayout(1) para forzar la actualización del dibujo.
15 Palabras clave de B4A 213 Basic4Android Guía del principiante
15 Palabras clave de B4A
Lista de tipos:
Broca
Fecha y hora
Excepción
Palabras clave
LayoutValues
Cadena
StringBuilder
Temporizador
15.1 Broca
Bit es un objeto predefinido que contiene métodos relacionados bit a bit.
Ejemplo:
Dim banderas como Int
Flags = Bit.Or (100, 200)
Eventos:
Ninguno
Miembros:
Y (N1 como Int, N2 como Int) como Int
No (N como Int) como Int
O (N1 como Int, N2 como Int) como Int
ParseInt (valor como cadena, Radix como Int) como Int
ShiftLeft (N como Int, Shift As Int) como Int
ShiftRight (N como Int, Shift As Int) como Int
ToBinaryString (N como Int) As String
ToHexString (N como Int) As String
ToOctalString (N como Int) As String
UnsignedShiftRight (N como Int, Shift As Int) como Int
XOR (N1 como Int, N2 como Int) como Int
Descripción de los miembros:
Y (N1 como Int, N2 como Int) como Int

Devuelve la AND bit a bit de los dos valores.
No (N como Int) como Int

Devuelve el complemento bit a bit de un valor dado.
O (N1 como Int, N2 como Int) como Int

Devuelve el OR bit a bit de los dos valores.
ParseInt (valor como cadena, Radix como Int) como Int

Analiza el valor como un entero usando la base especificada.
Radix - debe estar entre 2 a 36.
ShiftLeft (N como Int, Shift As Int) como Int

N de turnos izquierda.
Shift - número de posiciones a desplazar.
ShiftRight (N como Int, Shift As Int) como Int

N de turnos derecha.
Mantiene el signo de valor original
ToBinaryString (N como Int) As String

Devuelve una representación de cadena de n en base 2.
ToHexString (N como Int) As String

ToOctalString (N como Int) As String

UnsignedShiftRight (N como Int, Shift As Int) como Int

N de turnos derecha.
Turnos ceros en las posiciones izquierdas.
XOR (N1 como Int, N2 como Int) como Int

Devuelve el XOR bit a bit de los dos valores.
15.2 Fecha y hora

Fecha y hora relacionados con métodos.
DateTime es un objeto predefinido. Debe no declararlo mismo.
Valores de fecha y hora se almacenan como garrapatas. Las garrapatas son el número de milisegundos desde el 1 de enero,
1970.
Este valor es demasiado grande para ser almacenado en una variable Int. Sólo deben almacenarse en un largo
variable.
Los métodos DateTime.Date y DateTime.Time convertir el valor de las garrapatas en una cadena.
Puede obtener la hora actual con DateTime.Now.
Ejemplo:
Dim ahora largo
Ahora = DateTime.Now
MsgBox (\"la fecha es:\"
El tiempo es:
Eventos:
Ninguno
Miembros:
Agregar (garrapatas tanto tiempo, años como meses como Int, Int, días como Int) As Long
Fecha (garrapatas As Long) As String
DateFormat como cadena
DateParse (fecha As String) As Long
GetDayOfMonth (garrapatas como larga) como Int
GetDayOfWeek (garrapatas como larga) como Int
GetDayOfYear (garrapatas como larga) como Int
GetHour (garrapatas como larga) como Int
GetMinute (garrapatas como larga) como Int
GetMonth (garrapatas como larga) como Int
GetSecond (garrapatas como larga) como Int
GetYear (garrapatas como larga) como Int
Ahora As Long [sólo lectura]
TicksPerDay siempre
TicksPerHour siempre
TicksPerMinute siempre
TicksPerSecond siempre
Tiempo (garrapatas As Long) As String
TimeFormat As String
TimeParse (tiempo As String) As Long

Agregar (garrapatas tanto tiempo, años como meses como Int, Int, días como Int) As Long
Devuelve un valor de garrapatas que es el resultado de agregar los intervalos de tiempo especificado en el valor determinado
Pasar valores negativos si desea restar los valores.
Ejemplo:
Dim mañana As Long
Mañana = DateTime.Add (DateTime.Now, 0, 0, 1)
Registro (\"mañana es la fecha:\"
Fecha (garrapatas As Long) As String

Devuelve una representación de cadena de la fecha (que se almacena como garrapatas).
El formato de fecha puede ajustarse con la palabra clave DateFormat.
Ejemplo:
Registro (\"hoy es:\"
DateFormat como cadena

Obtiene o establece el formato utilizado para analizar cadenas de fecha.
Consulte esta página para los patrones compatibles: formatos.
El modelo predeterminado es MM\/dd\/aaaa (23\/04\/2002 por ejemplo).
DateParse (fecha As String) As Long

Analiza la cadena de fecha y devuelve sus garrapatas representación.
Se producirá una excepción si se produce un error de análisis.
Ejemplo:
Dim en algún momento como Long
En algún momento = DateTime.DateParse(\"02\/23\/2007\")
GetDayOfMonth (garrapatas como larga) como Int

Devuelve el día de componente de mes desde el valor de las garrapatas.
Los valores oscilan entre 1 a 31.
GetDayOfWeek (garrapatas como larga) como Int

Devuelve el día de componente de semana desde el valor de las garrapatas.
GetDayOfYear (garrapatas como larga) como Int

Devuelve el día de componente del año el valor de las garrapatas.
GetHour (garrapatas como larga) como Int

Devuelve la hora del componente de día desde el valor de las garrapatas.
Los valores están entre 0 a 23.
GetMinute (garrapatas como larga) como Int

Devuelve los minutos dentro de un componente de hora del valor de las garrapatas.
GetMonth (garrapatas como larga) como Int

Devuelve el mes del componente del año el valor de las garrapatas.

Los valores son entre 1 y 12.
GetSecond (garrapatas como larga) como Int

Devuelve a los segundos dentro de un componente minuto desde el valor de las garrapatas.
GetYear (garrapatas como larga) como Int

Devuelve el componente del año el valor de las garrapatas.
Ahora As Long [sólo lectura]

Obtiene la hora actual como garrapatas (número de milisegundos desde el 01 de enero de 1970).
TicksPerDay siempre
TicksPerHour siempre
TicksPerMinute siempre
TicksPerSecond siempre
Tiempo (garrapatas As Long) As String

Devuelve una representación de cadena del tiempo (que se almacena como garrapatas).
El formato de tiempo puede ajustarse con la palabra clave TimeFormat.
Ejemplo:
Registro (\"la hora actual es:\"
TimeFormat As String
Obtiene o establece el formato utilizado para analizar las cadenas de tiempo.
Consulte esta página para los patrones compatibles: formatos.
El modelo predeterminado es HH (23: 45:12 por ejemplo).
TimeParse (tiempo As String) As Long

Analiza la cadena de fecha y devuelve sus garrapatas representación.
Tenga en cuenta que la fecha de valor devuelto será hoy.
15.3 Excepción
Tiene una excepción.
Puede acceder a la última excepción llamando al LastException.
Por ejemplo:
Trate de
Dim en como InputStream
in = File.OpenInput (File.DirInternal, \"SomeMissingFile.txt\")
'...
Captura
Log(LastException.Message)
End Try
En caso.IsInitialized entonces en.Cerrar
Eventos:
Ninguno
Miembros:
IsInitialized As Boolean
Mensaje As String [sólo lectura]
Mensaje As String [sólo lectura]
15.4 Palabras clave

Estas son las palabras clave internas.
Eventos:
Ninguno
Miembros:
ABS (número doble) como doble
ACos (Value As Double) como doble
ACosD (Value As Double) como doble
Matriz
ASC (Char como Char) como Int
ASin (Value As Double) como doble
ASinD (Value As Double) como doble
ATan (Value As Double) como doble
ATanD (Value As Double) como doble
BytesToString (Data() como Byte, StartOffset como Int, longitud como Int, CharSet As String) As String
Captura
cE como doble
CharsToString (Chars() como Char, StartOffset como Int, Int longitud) As String
Chr (UnicodeValue como Int) como Char

Continuar
Cos (como doble en radianes) como doble
CosD (grados como doble) como doble
IPC como doble
CRLF como cadena
Densidad como flotador
Dim
DipToCurrent (longitud como Int) como Int
DoEvents
Salida
ExitApplication
False As Boolean
Archivo como archivo
Piso (número doble) como doble
Para
GetDeviceLayoutValues como LayoutValues
GetType (objeto As Object) As String
Si
InputList (elementos como lista, título como cadena, CheckedItem como Int) como Int
InputMultiList (elementos como lista, título como cadena) como lista
Es
IsBackgroundTaskRunning (ContainerObject como objeto, TaskId como Int) As Boolean
ESNUMERO (texto As String) As Boolean
LastException como excepción
LoadBitmap (Dir como cadena, FileName As String) como mapa de bits
LoadBitmapSample (Dir como cadena, nombre de archivo como cadena, MaxWidth como Int, MaxHeight como
Int) como mapa de bits
Registro (mensaje As String)
Logaritmo (número doble, Base doble) como doble
Max (número1 como doble, número2 como doble) como doble
Min (número1 como doble, número2 como doble) como doble
MsgBox (mensaje As String, titulo As String)
Msgbox2 (mensaje As String, título como cadena, positivo como cadena, Cancel As String, negativo
Como cadena, icono como android.graphics.Bitmap) como Int
No (valor As Boolean) como Boolean
NULL como objeto
NumberFormat (número doble, MinimumIntegers como Int, MaximumFractions como Int) como
Cadena
NumberFormat2 (número doble, MinimumIntegers como Int, MaximumFractions como Int,

MinimumFractions como Int, GroupingUsed As Boolean) As String
PerXToCurrent (porcentaje como Float) como Int
PerYToCurrent (porcentaje como Float) como Int
Potencia (Base doble, exponente como doble) como doble
ProgressDialogHide
ProgressDialogShow (texto As String)
ProgressDialogShow2 (texto As String, Cancelable As Boolean)
CITAR como cadena
Regex como Regex
Retorno
RND (Min como Int, Max como Int) como Int
Redondear (número doble) As Long
Round2 (número como doble, DecimalPlaces como Int) como doble
Seleccione
Remitente como objeto

Pecado (como doble en radianes) como doble
SinD (grados como doble) como doble
Sqrt (Value As Double) como doble
StartActivity (actividad como objeto)
Sub
FICHA como cadena
Tan (radianes como doble) como doble
TanD (grados como doble) como doble
ToastMessageShow (mensaje As String, LongDuration As Boolean)
True As Boolean
Trate de
Tipo
Hasta
Tiempo
ABS (número doble) como doble

Devuelve el valor absoluto.
ACos (Value As Double) como doble

Devuelve el ángulo medido en radianes.
ACosD (Value As Double) como doble

Devuelve el ángulo medido en grados.
Matriz
Crea una matriz de dimensión única del tipo especificado.
La sintaxis es: matriz como tipo (lista de valores).
Ejemplo:
Dim Days() As String
Días = Array como cadena (\"Domingo\", \"Lunes\",...)
ASC (Char como Char) como Int

Devuelve el punto de código unicode del primer carácter o caracteres dado en cadena.
ASin (Value As Double) como doble

ASinD (Value As Double) como doble

ATan (Value As Double) como doble

ATanD (Value As Double) como doble

BytesToString (Data() como Byte, StartOffset como Int, longitud como Int, CharSet como cadena) como
Cadena
Decodifica las matrices de bytes dado como una cadena.
Datos - la matriz de bytes.
StartOffset - el primer byte para leer.
Longitud: número de bytes que leer.
CharSet - el nombre del juego de caracteres.
Ejemplo:
Dim s As String
s = BytesToString (Buffer, 0, Buffer.Length, \"UTF-8\")
Captura
Cualquier excepción que se inicia dentro de un bloque try quedarán retenida en el bloque catch.
Llame a LastException para obtener la excepción detectada.
Sintaxis:
Trate de
...
Captura
...
End Try
cE como doble
constante e (base de logaritmo natural).
CharsToString (Chars() como Char, StartOffset como Int, Int longitud) As String
Crea una nueva cadena copiando los caracteres de la matriz.
Copiar comienza desde StartOffset y el número de caracteres que copian equivale a la longitud.
Chr (UnicodeValue como Int) como Char

Devuelve el carácter que está representado por el valor unicode determinada.
Continuar
Detiene la ejecución de la iteración actual y continúa con el siguiente.
Cos (como doble en radianes) como doble

Calcula la función trigonométrica coseno. Ángulo medido en radianes.
CosD (grados como doble) como doble

Calcula la función trigonométrica coseno. Ángulo medido en grados.
IPC como doble

Constante PI.
CRLF como cadena

Carácter de nueva línea. El valor de chr (13).
Densidad como flotador

Devuelve la escala del dispositivo, que es DPI \/ 160.
(PPP significa puntos por pulgada).
Dim
Declara una variable.
Sintaxis:
Declare una variable sola:
Nombre de variable Dim [As tipo]
El tipo predeterminado es la cadena.
Declarar varias variables. Todas las variables serán del tipo especificado.
Dim variable1, variable2,..., [As tipo]
Tenga en cuenta que la sintaxis abreviada sólo se aplica a la palabra clave Dim.
Declarar una matriz:

Dim variable (Rank1, Rank2,...) [As tipo]
Ejemplo: Dim Days(7) As String
El rango real puede omitirse para cero matrices de longitud.
DipToCurrent (longitud como Int) como Int

Escala el valor, que representa una longitud específica de un dispositivo predeterminado de densidad (densidad = 1.0),
al dispositivo actual.
Por ejemplo, el siguiente código establece el valor de ancho de este botón para tener el mismo tamaño físico
en todos los dispositivos.
Button1.Width = DipToCurrent(100)
Tenga en cuenta que existe una sintaxis abreviada para este método. Cualquier número seguido de la cadena 'dip'
se convertirá en la misma manera (sin espacios entre el número y 'dip').
Por lo que el código anterior es equivalente a:
Button1.Width = 100dip ' dip-> píxeles independientes de densidad
DoEvents
Procesos de mensajes en la cola de mensajes en espera.
Puede llamarse DoEvents dentro de bucles largos para permitir que el programa de eventos de espera del proceso.
Salida
Se cierra el bucle más interior.
ExitApplication
Inmediatamente termina la aplicación y detiene el proceso.
Mayoría de las aplicaciones no debe usar este método y prefieren Activity.Finish que permite que el sistema operativo decidir
Cuando el proceso es asesinado.
False As Boolean
Archivo como archivo

Archivos de métodos relacionados.
Piso (número doble) como doble

Devuelve el doble más grande que es menor o igual al número especificado y es igual a un entero.
Para
Sintaxis:
For variable = valor1 a valor2 [intervalo de paso]
...
Siguiente
Ejemplo:
Para i = 1 A 10
Log(i) ' imprimirá 1 a 10 (inclusive).
Siguiente
Si la variable de iteración no se declaró antes de que sea de tipo int.
GetDeviceLayoutValues como LayoutValues

Devuelve el dispositivo LayoutValues.
Ejemplo:
Log(GetDeviceLayoutValues)
GetType (objeto As Object) As String

Devuelve una cadena que representa el tipo del objeto java.
Si
Sola línea:
Si condición entonces true-declaración [false-instrucción Else]
Multiline:
Si condición entonces
Declaración
Else If condición entonces
Declaración
...
Else
Declaración
End If
InputList (elementos como lista, título como cadena, CheckedItem como Int) como Int
Muestra un cuadro de diálogo modal con una lista de elementos y botones de radio. Pulsando sobre un elemento se cerrará el
cuadro de diálogo.
Devuelve el índice del elemento seleccionado o DialogResponse.Cancel si el usuario presiona en la parte posterior
clave.
Lista - elementos para mostrar.
Title - Título del diálogo.
CheckedItem - el índice del elemento que será seleccionado en primer lugar. Pasar -1 Si no hay ningún elemento debe ser
preseleccionados.
InputMultiList (elementos como lista, título como cadena) como lista

Muestra un cuadro de diálogo modal con una lista de elementos y casillas de verificación. El usuario puede seleccionar vario
El cuadro de diálogo se cierra pulsando sobre el botón \"Aceptar\".
Devuelve una lista con los índices de los elementos seleccionados. La lista está ordenada.
Devuelve una lista vacía si el usuario ha presionado la tecla back.
Es
Pruebas si el objeto si del tipo dado.
Ejemplo:
Para i = 0 To Activity.NumberOfViews - 1
Si Activity.GetView(i) es botón entonces
Dim b como botón
b = Activity.GetView(i)
b.color = Colors.Blue
End If
Siguiente
IsBackgroundTaskRunning (ContainerObject como objeto, TaskId como Int) As Boolean

Pruebas si una tarea en segundo plano, presentada por el objeto contenedor y con el id especificado, es
ejecutando.
ESNUMERO (texto As String) As Boolean

Comprueba si la cadena especificada puede analizarse de forma segura como un número.
LastException como excepción

Devuelve la última excepción que fue pillada (si existe tal).
LoadBitmap (Dir como cadena, FileName As String) como mapa de bits

Carga el mapa de bits.
Tenga en cuenta que el sistema de archivos Android distingue mayúsculas de minúsculas.
Debe considerar el uso de LoadBitmapSample si el tamaño de la imagen es grande.
El tamaño real del archivo no es relevante como normalmente se almacenan imágenes comprimidas.
Ejemplo:
Activity.SetBackgroundImage (LoadBitmap (File.DirAssets,
\"SomeFile.jpg\"))
LoadBitmapSample (Dir como cadena, nombre de archivo como cadena, MaxWidth como Int, MaxHeight como
Int) como mapa de bits
Carga el mapa de bits.
El decodificador subsample el mapa de bits si MaxWidth o MaxHeight es más pequeño que el mapa de bits
dimensiones.
Esto puede ahorrar un montón de memoria al cargar imágenes grandes.
Ejemplo:
Activity.SetBackgroundImage (LoadBitmapSample (File.DirAssets,

\"SomeFile.jpg\", Activity.Width, Activity.Height))
Registro (mensaje As String)

Registra un mensaje. El registro puede verse en la ficha LogCat.
Logaritmo (número doble, Base doble) como doble
Max (número1 como doble, número2 como doble) como doble

Devuelve el número más grande entre los dos números.
Min (número1 como doble, número2 como doble) como doble

Devuelve el número menor entre los dos números.
MsgBox (mensaje As String, titulo As String)

Muestra un cuadro de mensaje modal con el mensaje especificado y el título.
El cuadro de diálogo mostrará un botón OK.
Ejemplo:
MsgBox (\"Hola mundo\", \"Este es el título\")
Msgbox2 (mensaje As String, título como cadena, positivo como cadena, Cancel As String,
Negativo como cadena, icono como android.graphics.Bitmap) como Int
Muestra un cuadro de mensaje modal con el mensaje especificado y el título.
Mensaje - el mensaje del cuadro de diálogo.
Título - el título del cuadro de diálogo.
Positivo - el texto a mostrar para el botón de \"positivo\". Pasar \"\" si no desea mostrar el botón.
Cancelar - el texto a mostrar para el botón \"Cancelar\". Pasar \"\" si no desea mostrar el botón.
Negativo - el texto a mostrar para el botón de \"negativo\". Pasar \"\" si no desea mostrar el botón.
Icono - un mapa de bits que se dibujarán cerca el título. Pasar Null si no desea mostrar un icono.
Devuelve uno de los valores de DialogResponse.
Ejemplo:
Dim resultado como Int
resultado = Msgbox2 (\"Este es el mensaje\", \"Este es el título\",
\"Bueno\", \"\", \"Bad\", LoadBitmap (File.DirAssets, \"smiley.gif\"))
Si resultado = DialogResponse.Positive Then...
No (valor As Boolean) como Boolean

Invierte el valor de determinado valor booleano.
NULL como objeto
NumberFormat (número doble, MinimumIntegers como Int, MaximumFractions como Int)

Como cadena
Convierte al número especificado en una cadena.
La cadena incluirá al menos mínimo enteros y en la mayoría de los dígitos máximo fracciones.
Ejemplo:
Registro (NumberFormat (12345.6789, 0, 2)) ' \"12,345.68\"
Registro (NumberFormat (1, 3, 0)) ' \"001\"
NumberFormat2 (número como doble, MinimumIntegers como Int, MaximumFractions como

Int, MinimumFractions como Int, GroupingUsed As Boolean) As String
Convierte al número especificado en una cadena.
La cadena incluirá al menos mínimo enteros, a más dígitos de fracciones de máximo y mínimo
Dígitos de fracciones mínimas.
GroupingUsed - determina si al grupo cada tres enteros.
Ejemplo:
Registro (NumberFormat2 (12345.67, 0, 3, 3, false)) ' \"12345.670\"
PerXToCurrent (porcentaje como Float) como Int

Devuelve el tamaño real del determinado porcentaje de la anchura de la actividad.
Ejemplo:
Button1.Width = PerXToCurrent(50) ' Button1.Width = 50% * Activity.Width
Una sintaxis abreviada para este método está disponible. Cualquier número seguido de la cadena '% x'
se convertirá en la misma manera (sin espacios entre el número y '% x').
Button1.Width = 50% x
PerYToCurrent (porcentaje como Float) como Int

Devuelve el tamaño real del determinado porcentaje de la altura de la actividad.
Ejemplo:
Button1.Height = PerYToCurrent(50) ' Button1.Height = 50% * Activity.Height
Una sintaxis abreviada para este método está disponible. Cualquier número seguido de la cadena '% y'
se convertirá en la misma manera (sin espacios entre el número y '% y').
Button1.Height = 50% y
Potencia (Base doble, exponente como doble) como doble

Devuelve el valor Base elevado a la potencia de exponente.
ProgressDialogHide
Esconde un cuadro de diálogo de progreso visible. No hacer nada si no hay diálogo de progreso es visible.
ProgressDialogShow (texto As String)

Muestra un cuadro de diálogo con una barra giratoria circular y el texto especificado.
A diferencia de los métodos de Msgbox y InputList, el código no se bloqueará.
Debe llamar a ProgressDialogHide para quitar el cuadro de diálogo.
El cuadro de diálogo también se eliminarán si el usuario presiona la tecla atrás.
ProgressDialogShow2 (texto As String, Cancelable As Boolean)

Muestra un cuadro de diálogo con una barra giratoria circular y el texto especificado.
A diferencia de los métodos de Msgbox y InputList, el código no se bloqueará.
Debe llamar a ProgressDialogHide para quitar el cuadro de diálogo.
Cancelable - si el usuario puede descartar el cuadro de diálogo presionando la tecla atrás.
CITAR como cadena

Citar el personaje. El valor de chr (34).
Regex como Regex

Métodos relacionados de expresiones regulares.
Retorno
Devuelve desde el actual sub y opcionalmente devuelve el valor dado.
Sintaxis: Retorno [valor]
RND (Min como Int, Max como Int) como Int

Devuelve un entero aleatorio entre Min (inclusive) y Max (exclusivo).
Redondear (número doble) As Long

Devuelve el número largo más cercano al número dado.
Round2 (número como doble, DecimalPlaces como Int) como doble

Redondea el número determinado y deja hasta el número especificado de dígitos fraccionarios.
Seleccione
Compara un valor único para varios valores.
Seleccionados bloques no se pueden anidar.
Ejemplo:
Dim valor como Int
valor = 7
Seleccionar valor
Caso 1:
Log(\"One\")
Caso 2, 4, 6, 8:
Log(\"Even\")
Caso 3, 5, 7, 9:
Registro (\"impar más grande que uno\")
Otro caso
Registro (\"mayor que 9\")
End Select
Remitente como objeto

Devuelve el objeto que provocó el evento.
Sólo es válido mientras dentro del sub evento.
Ejemplo:
Sub Button_Click
Dim b como botón
b = Sender
b.Text = \"he hecho clic en\"
End Sub
Pecado (como doble en radianes) como doble

Calcula la función trigonométrica seno. Ángulo medido en radianes.
SinD (grados como doble) como doble

Calcula la función trigonométrica seno. Ángulo medido en grados.
Sqrt (Value As Double) como doble

Devuelve la raíz cuadrada positiva.
StartActivity (actividad como objeto)

Inicia una actividad o trae al frente si ya existe.
La actividad puede ser una cadena con el nombre de la actividad de destino o puede ser la propia actividad.
Después de esta llamada se interrumpirá la actividad actual y se reanudará la actividad de destino.
Este método también puede utilizarse para enviar objetos de calidades al sistema.
Ejemplo: StartActivity (Activity2)
Sub
Declara un sub con los parámetros y el tipo de valor devuelto.
Sintaxis: Nombre de Sub [(lista de parámetros)] [como tipo de retorno]
Los parámetros incluyen el nombre y tipo.
Las longitudes de matrices de dimensiones no deben incluirse.
Ejemplo:
Sub MySub (FirstName como cadena, LastName como cadena, edad como Int,
OtherValues() como doble) como Boolean
...
End Sub
En este ejemplo, OtherValues es la matriz de una sola dimensión.
La declaración de tipo de valor devuelto es diferente a otras declaraciones como el paréntesis de matriz siguen las
tipo y no
el nombre (que en este caso no existe).
FICHA como cadena

Carácter de tabulación.
Tan (radianes como doble) como doble

Calcula la tangente trigonométrica. Ángulo medido en radianes.
TanD (grados como doble) como doble

Calcula la tangente trigonométrica. Ángulo medido en grados.
ToastMessageShow (mensaje As String, LongDuration As Boolean)

Muestra un mensaje poco rápido que se apaga automáticamente.
Mensaje - el mensaje de texto a mostrar.
LongDuration - si true, a continuación, muestra el mensaje durante un largo período, de lo contrario muestra el mensaje para u
período corto.
True As Boolean
Trate de
Cualquier excepción que se inicia dentro de un bloque try quedarán retenida en el bloque catch.
Llame a LastException para obtener la excepción detectada.
Sintaxis:
Trate de
...
Captura
...
End Try
Tipo
Declara una estructura.
Sólo puede utilizarse dentro de sub Globals o sub Process_Globals.
Sintaxis:
Escriba el nombre de tipo (campo1, Campo2,...)
Campos incluyen nombre y tipo.
Ejemplo:
Tipo MyType (Name As String, Items(10) como Int)
Dim a, b como MyType
a.Initialize
a.Items(2) = 123
Hasta
Bucles hasta que la condición es verdadera.
Sintaxis:
Do Until condición
...
LOOP
Tiempo
Bucles mientras la condición es verdadera.
Sintaxis:
Mientras que la condición
...
LOOP
15.5 LayoutValues
Contiene valores relacionados con la pantalla.
Puede obtener los valores de la la pantalla actual llamando al GetDeviceLayoutValues.
Por ejemplo:
Dim lv como LayoutValues
LV = GetDeviceLayoutValues
Log(LV) ' imprimirá los valores en el registro
Activity.LoadLayout y Panel.LoadLayout devolver un objeto LayoutValues con el
los valores de la
variante de diseño elegido.
Eventos:
Ninguno
Miembros:
Altura como Int
Escala como flotador
toString As String
Ancho como Int
Altura como Int

La altura de la pantalla (píxeles).
Escala como flotador

El valor de escala del dispositivo que es igual a 'puntos por pulgada' \/ 160. Para la mayoría de los dispositivos, el valor será 1
o 1.5 (alta resolución).
toString As String
Ancho como Int

El ancho de la pantalla (píxeles).
15.6 Cadena
Las cadenas son inmutables en Basic4android, lo que significa que puede cambiar el valor de una cadena
variables pero usted no puede cambiar el texto almacenado en un objeto string.
Por lo que métodos como la subcadena, Trim y ToLowerCase devolución una cadena nueva, no cambian la
valor de la cadena actual.
Uso típico:
Dim s As String
s = \"texto\"
s = s.Replace (\"a\", \"b\")
Si usted necesita una cadena mutable, puede usar StringBuilder.
Tenga en cuenta que los literales de cadena son también objetos string:
Registro (\"texto\".Trim)
Eventos:
Ninguno
Miembros:
CharAt (índice como Int) como Char
CompareTo (otro como cadena) como Int
EndsWith (sufijo As String) As Boolean
EqualsIgnoreCase (otros As String) As Boolean
GetBytes (Charset como cadena) como Byte()
IndexOf (SearchFor As String) como Int
IndexOf2 (SearchFor As String, índice como Int) como Int
Longitud como Int

Reemplazar (destino como cadena, reemplazo As String) As String
StartsWith (prefijo As String) As Boolean
SubString (BeginIndex como Int) As String
SubString2 (BeginIndex como Int, EndIndex como Int) As String
ToLowerCase como cadena
ToUpperCase como cadena
Recorte como cadena
CharAt (índice como Int) como Char

Devuelve el carácter en el índice especificado.
CompareTo (otro como cadena) como Int

Lexicográficamente compara las dos cadenas.
Devuelve un valor menor que 0, si la cadena actual precede a otro.
Devuelve 0 si dos cadenas son iguales.
Devuelve un valor mayor que 0 si la cadena actual viene después de otra.
Nota que mayúsculas preceden a minúsculas.
Ejemplos:
\"abc\".CompareTo(\"da\") ' < 0
\"abc\".CompareTo(\"Abc\") ' > 0
\"abc\".CompareTo(\"abca\")' < 0
EndsWith (sufijo As String) As Boolean

Devuelve true si esta cadena termina con el sufijo determinado.
EqualsIgnoreCase (otros As String) As Boolean

Devuelve true si dos cadenas son iguales ignorando su caso.
GetBytes (Charset como cadena) como Byte()

Codifica la cadena en una nueva matriz de bytes.
Ejemplo:
Dim Data() As Byte
Datos = \"Una cadena\".GetBytes(\"UTF8\")
IndexOf (SearchFor As String) como Int

Devuelve el índice de la primera aparición de cadena SearchFor en la cadena.
Devuelve -1 Si no se ha encontrado SearchFor.
IndexOf2 (SearchFor As String, índice como Int) como Int

Devuelve el índice de la primera aparición de cadena SearchFor en la cadena.

Inicia la búsqueda en el índice especificado.
Devuelve -1 Si no se ha encontrado SearchFor.
Longitud como Int

Devuelve la longitud de esta cadena.
Reemplazar (destino como cadena, reemplazo As String) As String

Devuelve una nueva cadena resultante de la sustitución de todas las apariciones de destino con
Reemplazo.
StartsWith (prefijo As String) As Boolean

Devuelve true si esta cadena comienza con el prefijo especificado.
SubString (BeginIndex como Int) As String

Devuelve una nueva cadena que es una subcadena de la cadena original.
La nueva cadena incluirá el carácter BeginIndex y se extenderá hasta el final de la cadena.
Ejemplo:
\"012345\".SubString(2) ' devuelve \"2345\"
SubString2 (BeginIndex como Int, EndIndex como Int) As String

Devuelve una nueva cadena que es una subcadena de la cadena original.
La nueva cadena incluirá el carácter BeginIndex y se extenderá hasta el carácter
EndIndex, no incluyendo el último carácter.
Ejemplo:
\"012345\".SubString2(2, 4) ' devuelve \"23\"
ToLowerCase como cadena

Devuelve una nueva cadena que es el resultado de la menor esta cadena de la carcasa.
ToUpperCase como cadena

Devuelve una nueva cadena que es el resultado del alto cuerpo de esta cadena.
Recorte como cadena

Devuelve una copia de la secuencia original sin ningún espacio en blanco inicial o final.
15.7 StringBuilder
StringBuilder es una cadena mutable, a diferencia de las cadenas regulares que son inmutables.
StringBuilder es especialmente útil cuando necesita concatenar cadenas de muchos.
El código siguiente muestra el aumento de rendimiento de StringBuilder:
As Long Dim Inicio
Inicio = DateTime.Now
' Cadena regular
Dim s As String
Para i = 1 A 5000
s = s
Siguiente
Registro (DateTime.Now - start)
' StringBuilder
Inicio = DateTime.Now
Dim sb como StringBuilder
SB.Inicializar
Para i = 1 A 5000
SB.Append(i)
Siguiente
Registro (DateTime.Now - start)
Probado en un dispositivo real, la primera 'bucle' for tardó unos 20 segundos y el segundo tomó menos de la décima
de un segundo.
La razón es que el código: s = s crea una nueva cadena en cada iteración (cadenas son
inmutable).
El método StringBuilder.ToString convierte el objeto en una cadena.
Eventos:
Ninguno
Miembros:
Append (texto As String) como StringBuilder
Inicializar
Insertar (Offset como Int, texto As String) como StringBuilder
Longitud como Int [sólo lectura]
Quitar (StartOffset como Int, EndOffset como Int) como StringBuilder
ToString como cadena
Append (texto As String) como StringBuilder

Anexa el texto especificado al final.
Devuelve el mismo objeto, de modo que puede encadenar métodos.
Ejemplo:
SB.Append (\"primera línea\").Append(CRLF).Append (\"segunda línea\")
Inicializar
Inicializa el objeto.
Ejemplo:
Dim sb como StringBuilder
SB.Inicializar
SB.Append (\"el valor es:\").Append(SomeOtherVariable).Append(CRLF)
Insertar (Offset como Int, texto As String) como StringBuilder

Inserta el texto especificado en el desplazamiento especificado.
Longitud como Int [sólo lectura]

Devuelve el número de caracteres.
Quitar (StartOffset como Int, EndOffset como Int) como StringBuilder

Elimina los caracteres especificados.
StartOffset - el primer carácter para quitar.
EndOffset - el índice final. Este personaje no se eliminarán.
ToString como cadena

Convierte el objeto en una cadena.
15.8 Temporizador
Un objeto Timer genera eventos de garrapatas en los intervalos especificados.
Utilizando un temporizador es una buena alternativa a un bucle largo, ya que permite que el subproceso de la interfaz de us
y mensajes.
Tenga en cuenta que los eventos del temporizador no disparará mientras el subproceso de la interfaz de usuario está ocupa
Llame a palabra clave DoEvents).
El temporizador de la propiedad Enabled se establece en False de forma predeterminada. Para hacerlo debe cambiarlo empie
en True.
Eventos del temporizador no se activará cuando se detiene la actividad, o si es un diálogo de bloqueo (como Msgbox)
visible.
Temporizadores deben declararse en Sub Process_Globals. De lo contrario puede obtener varios temporizadores
ejecutando cuando se recrea la actividad.
También es importante desactivar el temporizador cuando la actividad es una pausa y luego activarlo cuando se
se reanuda. Esto ahorra CPU y batería.
Eventos:
Garrapata
Miembros:
Habilitado como Boolean
Inicializar (EventName como cadena, intervalo de tiempo)
Intervalo de tiempo

Obtiene o establece si el temporizador está activado (chispero).
Inicializar (EventName como cadena, intervalo de tiempo)

Inicializa el temporizador con el prefijo sub de evento y el intervalo especificado (medido en milisegundos).
IMPORTANTE: este objeto debe declararse en Sub Process_Globals.
Ejemplo:
Timer1.Initialize (\"Timer1\", 1000)
Timer1.Enabled = True
Sub Timer1_Tick
' Controlar eventos de graduación
End Sub
Intervalo de tiempo
Obtiene o establece el intervalo entre tick eventos, medidos en milisegundos.
16 Views 237 Basic4Android Guía del principiante
16 Views
Lista de tipos:
Actividad
Botón
Casilla de verificación
EditText
ImageView
Etiqueta
ListView
Panel
ProgressBar
RadioButton
ScrollView
SeekBar
Spinner
TabHost
ToggleButton
Vista
Vista Web
16.1 Actividad
Cada módulo de actividad incluyen un objeto predefinido de actividad.
La actividad es el componente principal de la aplicación.
Las actividades han relacionado tres ciclo de vida especial evento: Activity_Create, Activity_Resume y
Activity_Pause.
Ver este tutorial para obtener más información acerca de las actividades y procesos de ciclo de vida: tutorial de ciclo de vida.
Puede agregar y quitar vistas a esta actividad con los métodos AddView y RemoveViewAt.
También puede cargar un archivo de diseño con LoadLayout.
El evento Touch puede utilizarse para manejar toques de usuario.
El primer parámetro de este evento es el parámetro de acción. Los valores de parámetro pueden ser
ACTION_DOWN,
ACTION_MOVE o ACTION_UP. Utilice este valor para encontrar la acción del usuario actual.
El evento KeyPress se produce cuando el usuario ha presionado la tecla y suponiendo que no hay otra vista
ha consumido este evento (como EditText).
Al manipular el evento KeyPress debe devolver un valor booleano que indica si la tecla
evento de prensa fue consumida.
Por ejemplo si el usuario presiona la tecla atrás y le devuelve verdadero, entonces el SO no cerrará su
actividad.
Sub Activity_KeyPress (KeyCode como Int) As Boolean

Si Keycode = KeyCodes.KEYCODE_BACK Then
Return True
Else
Return False
End If
End Sub
Puede agregar elementos de menú a la actividad con el método AddMenuItem. Nota que este método debe
sólo se puede llamar dentro de

Evento de Activity_Create.
Eventos:
Toque (acción como Int, X como flotador, Y como Float)
KeyPress (KeyCode como Int) As Boolean ' devolver true si desea consumir el evento
Haga clic en
LongClick
Miembros:
ACTION_DOWN como Int
ACTION_MOVE como Int
ACTION_UP como Int
AddMenuItem (título como cadena, EventName As String)
AddMenuItem2 (Title As String, EventName As String, mapa de bits como android.graphics.Bitmap)
AddView (vista como android.view.View, izquierda como Int, Top como Int, ancho como Int, altura como Int)
Antecedentes como android.graphics.drawable.Drawable
BringToFront
Color como Int [sólo escritura]
Acabado
GetView (índice como Int) como vista
Altura como Int
Inicializar (EventName As String)
Invalidar
Invalidate2 (Rect como android.graphics.Rect)
Invalidate3 (izquierda como Int, Top como Int, Int, como inferior como Int)
Izquierda como Int
LoadLayout (diseño como cadena) como LayoutValues
NumberOfViews como Int [sólo lectura]
RemoveView
RemoveViewAt (índice como Int)
RequestFocus As Boolean
SendToBack
SetBackgroundImage (mapa de bits como android.graphics.Bitmap)
SetLayout (izquierda como Int, Top como Int, Int ancho, altura como Int)
Etiqueta como objeto
Título como CharSequence
Top como Int
Ancho como Int
ACTION_DOWN como Int
ACTION_MOVE como Int
ACTION_UP como Int
AddMenuItem (título como cadena, EventName As String)

Agrega un elemento de menú a la actividad.
Título: título del elemento de menú.
EventName - el prefijo del nombre de sub que controlará el evento click.
Sólo debe llamar a este método dentro de sub Activity_Create.
Tenga en cuenta que el valor de 'Remitente' dentro del evento click es igual al texto del elemento de menú haga clic.
Ejemplo:
Activity.AddMenuItem (\"Abrir archivo\", \"OpenFile\")
...
Sub OpenFile_Click
...
End Sub
AddMenuItem2 (título como cadena, EventName como cadena, Bitmap como

Android.Graphics.Bitmap)
Agrega un elemento de menú a la actividad.
Título: título del elemento de menú.
EventName - el prefijo del nombre de sub que controlará el evento click.
Mapa de bits - mapa de bits para dibujar como el fondo del elemento.
Sólo los primeros cinco (o seis si hay seis total) elementos del menú Mostrar iconos.
Sólo debe llamar a este método dentro de sub Activity_Create.
Tenga en cuenta que el valor de 'Remitente' dentro del evento click es igual al texto del elemento de menú haga clic.
Ejemplo:
Activity.AddMenuItem2 (\"Abrir archivo\", \"OpenFile\",
LoadBitmap (File.DirAssets, \"SomeImage.png\"))
...
Sub OpenFile_Click
...
End Sub
AddView (vista como android.view.View, izquierda como Int, Top como Int, ancho como Int, altura como
Int)
Agrega una vista a esta actividad.

Obtiene o establece el fondo dibujable.
BringToFront
Cambia el orden z de este punto de vista y lo trae al frente.

Define el fondo de la vista para ser un ColorDrawable con el color especificado.
Si el fondo actual es de tipo GradientDrawable o ColorDrawable serán las esquinas redondas
mantenido.
Acabado
Cierra esta actividad.

Obtiene la vista que se almacena en el índice especificado.
Altura como Int
Invalidar
Invalida la vista toda forzando la vista para dibujar a sí mismo.
Dibujar sólo sucederá cuando el programa puede procesar los mensajes. Generalmente cuando termina
ejecutando el código actual.

Invalida el rectángulo dado.
Izquierda como Int


Carga un archivo de diseño (.bal).
Devuelve el LayoutValues de la variante de diseño actual que se cargó.

Devuelve el número de puntos de vista del niño.
RemoveView
Quita este punto de vista de su padre.

Quita la vista que se almacena en el índice especificado.
Intenta ajustar el enfoque a esta vista.
Devuelve True si el foco se estableció.
SendToBack
Cambia el orden z de este punto de vista y lo envía a la parte posterior.
Cambia el tamaño y posición de la vista.

Obtiene o establece el valor de la etiqueta. Este es un marcador de posición que puede utilizar para almacenar datos adiciona
Título como CharSequence
Top como Int
Ancho como Int

Obtiene o establece el ancho de la vista.
16.2 Botón
Una vista de botón.

Si se cambia el fondo del botón generalmente deseará utilizar StateListDrawable que permite
establecer el \"valor predeterminado\" dibujable
y el \"presionado\" dibujable.
Eventos:
Abajo
Arriba
Haga clic en
LongClick
Miembros:
BringToFront
Gravedad como Int
Altura como Int
Invalidar
Izquierda como Int
RemoveView
SendToBack
Texto As String
TextColor como Int
TextSize como flotador
Top como Int
Tipografía como android.graphics.Typeface

Visible como Boolean
Ancho como Int

BringToFront

mantenido.
Gravedad como Int
Altura como Int
Invalidar

Izquierda como Int
RemoveView

SendToBack

Texto As String
TextColor como Int
Top como Int
Ancho como Int

16.3 Casilla de verificación
Una vista de la casilla de verificación. A diferencia de los botones de opción cada casilla puede comprobarse de forma inde
Eventos:
CheckedChange (marcada As Boolean)
Miembros:
BringToFront
Comprobar As Boolean

Gravedad como Int
Altura como Int
Invalidar
Izquierda como Int
RemoveView
SendToBack
Texto As String
TextColor como Int
Top como Int
Ancho como Int

BringToFront

mantenido.
Gravedad como Int
Altura como Int
Invalidar

Izquierda como Int
RemoveView
SendToBack

Texto As String
TextColor como Int
Top como Int
Ancho como Int

16.4 EditText
EditText es una vista que permite al usuario escribir texto libre (similar al control TextBox de formularios Windows Forms).
El EditText tiene dos modos; Previsualiza y MultiLine. Puede establecer que sea multilínea llamando
EditText1.SingleLine = False
En la mayoría de los dispositivos el teclado en pantalla mostrará automáticamente cuando el usuario presiona sobre el EditTex
Puede cambiar la propiedad InputType y cambiar el tipo de teclado que aparece.
Por ejemplo: EditText1.InputType = EditText1.INPUT_TYPE_NUMBERS causará
el teclado numérico para aparecer cuando
el usuario presiona el EditText. Tenga en cuenta que también causará el EditText aceptar sólo números.
El evento TextChanged se activa siempre que los cambios de texto e incluye las cadenas nuevas y viejas.
El evento EnterPressed se activa cuando el usuario presiona la tecla enter o la tecla de acción (hecho o siguiente).
Eventos:
TextChanged (antiguo como cadena, de nuevo como cadena)
EnterPressed
Miembros:
BringToFront
ForceDoneButton As Boolean [sólo escritura]

Gravedad como Int
Altura como Int
Sugerencia como cadena
HintColor como Int
INPUT_TYPE_DECIMAL_NUMBERS como Int
INPUT_TYPE_NONE como Int
INPUT_TYPE_NUMBERS como Int
INPUT_TYPE_PHONE como Int
INPUT_TYPE_TEXT como Int
InputType como Int
Invalidar
Izquierda como Int
PasswordMode As Boolean [sólo escritura]
RemoveView
SelectAll
SelectionStart como Int
SendToBack
Previsualiza As Boolean [sólo escritura]

Texto As String
TextColor como Int
Top como Int
Ancho como Int
Envuelva As Boolean [sólo escritura]

BringToFront

mantenido.
ForceDoneButton As Boolean [sólo escritura]

Por defecto el sistema operativo establece la clave de la acción de teclado virtual para mostrar Done o siguiente según la
diseño específico.
Puede forzar que se muestre realizado por establecer este valor en True.
Ejemplo:
EditText1.ForceDoneButton = True
Gravedad como Int
Altura como Int
Sugerencia como cadena

Obtiene o establece el texto que aparecerá cuando el EditText está vacía.
Ejemplo:
EditText1.Hint = \"Ingrese el nombre de usuario\"
HintColor como Int

Obtiene o establece el color del texto de sugerencia.

Ejemplo:
EditText1.HintColor = Colors.Gray
INPUT_TYPE_DECIMAL_NUMBERS como Int

Se mostrará el teclado numérico. Se aceptan números, punto decimal y signo.
INPUT_TYPE_NONE como Int

No se mostrará teclado.
INPUT_TYPE_NUMBERS como Int

Se mostrará el teclado numérico. Se aceptan sólo números.
INPUT_TYPE_PHONE como Int

Teclado se mostrará en modo teléfono.
INPUT_TYPE_TEXT como Int

Modo de texto predeterminado.
InputType como Int

Obtiene o establece el indicador de tipo de entrada. Este indicador se utiliza para determinar la configuración del teclado virtu
Ejemplo:
EditText1.InputType = EditText1.INPUT_TYPE_NUMBERS
Invalidar

Izquierda como Int
PasswordMode As Boolean [sólo escritura]

Establece si el EditText debe estar en modo de contraseña y ocultar los personajes reales.
RemoveView
SelectAll
Selecciona todo el texto.
SelectionStart como Int

Obtiene o establece la posición de inicio de la selección (o la posición del cursor).
Devuelve -1 Si no hay selección o cursor.
SendToBack
Previsualiza As Boolean [sólo escritura]

Establece si el EditText debe estar en modo de línea única o varias líneas.

Texto As String
TextColor como Int
Top como Int
Ancho como Int

Envuelva As Boolean [sólo escritura]

Establece si el contenido del texto se ajustará dentro de los límites de EditText. Pertinentes cuando la EditText
en modo multilínea.
Ejemplo:
EditText1.Wrap = False
16.5 ImageView
Una vista que muestra una imagen.

Puede asignar un mapa de bits mediante la propiedad de mapa de bits.
La propiedad de gravedad cambia la manera en que aparece la imagen.
Los dos valores más relevantes son Gravity.FILL (que causa la imagen llenar toda la vista)
y Gravity.CENTER (que se dibuja la imagen en el centro de la vista).
Eventos:
Haga clic en
LongClick
Miembros:
Mapa de bits como android.graphics.Bitmap
BringToFront
Gravedad como Int
Altura como Int
Invalidar
Izquierda como Int

RemoveView
SendToBack
Top como Int
Ancho como Int

Mapa de bits como android.graphics.Bitmap

Obtiene o establece el mapa de bits asignado a la ImageView.
Ejemplo:
ImageView1.Bitmap = LoadBitmap (File.DirAssets, \"someimage.jpg\")
BringToFront

mantenido.
Gravedad como Int

Obtiene o establece la gravedad asignada a los mapas de bits.
Ejemplo:
ImageView1.Gravity = Gravity.Fill
Altura como Int
Invalidar


Izquierda como Int
RemoveView
SendToBack

Top como Int
Ancho como Int

16.6 Etiqueta
Una vista de etiqueta que muestra el texto de sólo lectura.

Eventos:
Haga clic en
LongClick
Miembros:
BringToFront
Gravedad como Int
Altura como Int
Invalidar
Izquierda como Int
RemoveView
SendToBack
Texto As String
TextColor como Int
Top como Int
Ancho como Int

BringToFront

mantenido.
Gravedad como Int
Altura como Int
Invalidar

Izquierda como Int
RemoveView
SendToBack

Texto As String
TextColor como Int
Top como Int
Ancho como Int

16.7 ListView
ListView es una vista muy útil que puede manejar las listas de grandes y pequeñas.
El control ListView provoca dos eventos. ItemClick se provoca cuando se hace clic en un elemento y es ItemLongClick
provoca cuando un elemento está seleccionado y celebrado.
Consulte el tutorial de ListView para obtener más información.
Eventos:
ItemClick (posición como Int, valor como objeto)
ItemLongClick (posición como Int, valor como objeto)
Miembros:
AddSingleLine (texto As String)
AddSingleLine2 (texto As String, ReturnValue como objeto)
AddTwoLines (Text1 como cadena, Text2 As String)
AddTwoLines2 (Text1 Text2 como cadena, cadena, ReturnValue como objeto)
AddTwoLinesAndBitmap (Text1 como cadena, Text2 como cadena, mapa de bits como
AddTwoLinesAndBitmap2 (Text1 como cadena, Text2 como cadena, Bitmap como

Android.Graphics.Bitmap, ReturnValue As Object)
BringToFront
Claro
FastScrollEnabled As Boolean
GetItem (índice como Int) como objeto
Altura como Int
Invalidar
Izquierda como Int
RemoveAt (índice como Int)
RemoveView
ScrollingBackgroundColor como Int [sólo escritura]
SendToBack
SingleLineLayout como SingleLineLayout [sólo lectura]
Tamaño como Int [sólo lectura]
Top como Int

TwoLinesAndBitmap como TwoLinesAndBitmapLayout [sólo lectura]
TwoLinesLayout como TwoLinesLayout [sólo lectura]
Ancho como Int
AddSingleLine (texto As String)

Agrega un elemento de línea único.
Ejemplo:
ListView1.AddSingleLine(\"Sunday\")
AddSingleLine2 (texto As String, ReturnValue como objeto)

Agrega un elemento de línea único.
Especificado devuelva valor será devuelto al llamar a GetItem o en el caso de ItemClick.
Ejemplo:
ListView1.AddSingleLine2 (\"Domingo\", 1)
AddTwoLines (Text1 como cadena, Text2 As String)

Agrega un elemento de dos líneas.
Ejemplo:
ListView1.AddTwoLines (\"Esta es la primera línea.\", \"Y esto es el
segundo\")
AddTwoLines2 (Text1 Text2 como cadena, cadena, ReturnValue como objeto)

Agrega un elemento de dos líneas.
AddTwoLinesAndBitmap (Text1 como cadena, Text2 como cadena, mapa de bits como
Agrega un dos líneas y un elemento de mapa de bits.
Ejemplo:
ListView1.AddTwoLinesAndBitmap (\"Primera línea\", \"Segunda línea\",
LoadBitmap (File.DirAssets, \"SomeImage.png\"))
AddTwoLinesAndBitmap2 (Text1 como cadena, Text2 como cadena, Bitmap como

Android.Graphics.Bitmap, ReturnValue As Object)
Agrega un dos líneas y un elemento de mapa de bits.

BringToFront
Claro
Borra todos los elementos de la lista.

mantenido.
FastScrollEnabled As Boolean
Obtiene o establece si el icono de desplazamiento rápido aparecerá cuando el usuario desplaza a la lista.
El valor predeterminado es false.
GetItem (índice como Int) como objeto

Devuelve el valor del elemento en la posición especificada.
Devuelve el \"valor de retorno\" si fue creado y si no devuelve el texto de la primera línea.
Altura como Int
Invalidar

Izquierda como Int

Quita el elemento en la posición especificada.
RemoveView

ScrollingBackgroundColor como Int [sólo escritura]

Establece el color de fondo que se utilizará mientras se desplaza la lista.
Esto es una optimización que hacer para que el desplazamiento más suave.
Establecida en
Colors.transparent Si el fondo detrás de la lista no es un color sólido.
El valor por defecto es negro.
SendToBack
SingleLineLayout como SingleLineLayout [sólo lectura]

Devuelve el esquema que se utiliza para mostrar los elementos de línea único.
Puede cambiar los valores de diseño para cambiar la apariencia de dichos elementos.
Ejemplo:
Dim Label1 As Label
Label1 = ListView1.SingleLineLayout.Label
Label1.TextSize = 20
Label1.textColor = Colors.Green

Devuelve el número de elementos almacenados en la lista.

Top como Int
TwoLinesAndBitmap como TwoLinesAndBitmapLayout [sólo lectura]

Devuelve el esquema que se utiliza para mostrar dos líneas y elementos de mapa de bits.
Por ejemplo, si desea quitar la segunda etiqueta (en todos los artículos con este diseño):
ListView1.TwoLinesAndBitmap.SecondLabel.Visible = False
TwoLinesLayout como TwoLinesLayout [sólo lectura]

Devuelve el esquema que se utiliza para mostrar elementos de dos líneas.
Ejemplo:
Dim Label1 As Label
Label1 = ListView1.TwoLinesLayout.SecondLabel
Label1.TextSize = 20
Label1.textColor = Colors.Green
Ancho como Int

16.8 Panel
Un Panel es una vista que contiene otras vistas de niño.

Puede agregar vistas de niño mediante programación o mediante carga un archivo de diseño.
El Panel provoca el evento de toque. El primer parámetro de este evento es la acción que es uno de los
Constantes de acción de la actividad.
Eventos:
Toque (acción como Int, X como flotador, Y como Float)
Haga clic en
LongClick
Miembros:
AddView (vista como android.view.View, izquierda como Int, Top como Int, ancho como Int, altura como Int)
BringToFront
Altura como Int
Invalidar
Izquierda como Int
RemoveView
SendToBack
Top como Int
Ancho como Int
AddView (vista como android.view.View, izquierda como Int, Top como Int, ancho como Int, altura como
Int)
Agrega una vista a este panel.

BringToFront

mantenido.

Obtiene la vista que se almacena en el índice especificado.
Altura como Int
Invalidar

Izquierda como Int

Carga un archivo de diseño para este panel. Devuelve el valor de la variante de diseño elegido.

Devuelve el número de puntos de vista del niño.
RemoveView

Quita la vista que se almacena en el índice especificado.
SendToBack

Top como Int
Ancho como Int

16.9 ProgressBar
Una vista de la barra de progreso. La propiedad de progreso establece el valor de progreso que es entre 0 a 100.
Eventos:
Ninguno
Miembros:
BringToFront
Altura como Int
Invalidar
Izquierda como Int
Progreso como Int
RemoveView
SendToBack
Top como Int
Ancho como Int

BringToFront

mantenido.
Altura como Int
Invalidar

Izquierda como Int
Progreso como Int

Obtiene o establece el valor de progreso.
RemoveView
SendToBack

Top como Int
Ancho como Int

16.10 RadioButton
Una vista de RadioButton. Puede comprobarse sólo un RadioButton en un grupo. Cuando un diferente
RadioButton se comprueba que todos los demás serán
automáticamente estar desactivada. Agrupación se realiza mediante la adición de botones de opción para la misma actividad o
panel.
Eventos:
Miembros:

BringToFront
Gravedad como Int
Altura como Int
Invalidar
Izquierda como Int
RemoveView
SendToBack
Texto As String
TextColor como Int
Top como Int
Ancho como Int


BringToFront

mantenido.
Gravedad como Int
Altura como Int
Invalidar

Izquierda como Int
RemoveView
SendToBack

Texto As String
TextColor como Int
Top como Int
Ancho como Int

16.11 ScrollView
ScrollView es una vista que contiene otras vistas y permite al usuario desplazarse verticalmente esas opiniones.
Consulte el tutorial de ScrollView para obtener más información.
El ScrollView tiene un panel interior que contiene las opiniones del niño.
Puede agregar vistas llamando al: ScrollView1.Panel.AddView(...)
Eventos:
Ninguno
Miembros:
BringToFront
FullScroll (abajo As Boolean)
Altura como Int
Inicializar (altura como Int)
Invalidar
Izquierda como Int
Panel como Panel [sólo lectura]
RemoveView
ScrollPosition como Int
SendToBack
Top como Int
Ancho como Int


BringToFront

mantenido.
FullScroll (abajo As Boolean)

Desplaza la vista de desplazamiento en la parte superior o inferior.
Altura como Int
Inicializar (altura como Int)

Inicializa el ScrollView y establece su altura panel interior a la altura determinada.
Más tarde puede cambiar esta altura por llamada ScrollView.Panel.Height.
Dim ScrollView1 As ScrollView

ScrollView1.Initialize(1000dip)
Invalidar

Izquierda como Int
Panel como Panel [sólo lectura]

Devuelve el panel que puede utilizar para agregar vistas a.
Ejemplo:
ScrollView1.Panel.AddView(...)
RemoveView
ScrollPosition como Int

Obtiene o establece la posición de desplazamiento.
SendToBack

Top como Int
Ancho como Int

16.12 SeekBar
Una vista que permite al usuario establecer un valor arrastrando un control deslizante. Similares para WinForms TrackBar.
El evento ValueChanged se produce siempre que se cambia el valor. El parámetro UserChanged puede
utilizarse para distinguir entre cambios realizadas por el usuario y hecho mediante programación.
Eventos:
ValueChanged (valor como Int, UserChanged As Boolean)
Miembros:
BringToFront

Altura como Int
Invalidar
Izquierda como Int
Max como Int
RemoveView
SendToBack
Top como Int
Valor como Int
Ancho como Int

BringToFront

mantenido.
Altura como Int
Invalidar

Izquierda como Int
Max como Int

Obtiene o establece el máximo permite valor.
RemoveView
SendToBack

Top como Int
Valor como Int

Obtiene o establece el valor actual.
Ancho como Int

16.13 Spinner
Una lista plegada que se abre cuando el usuario hace clic en ella y permite al usuario seleccionar un elemento. Similar a
ComboBox de formularios Windows Forms.
Se provoca el evento de ItemClick cada vez que un usuario presiona sobre un tema (incluso si es el ya seleccionados
elemento).
Eventos:
ItemClick (posición como Int, valor como objeto)
Miembros:
Add (elemento As String)
AddAll (lista como lista)
BringToFront
Claro
GetItem (índice como Int) As String
Altura como Int
IndexOf (valor As String) como Int
Invalidar
Izquierda como Int
Preguntar como cadena
RemoveView
SelectedIndex como Int
SelectedItem As String [sólo lectura]
SendToBack
Top como Int
Ancho como Int
Add (elemento As String)

Agrega un elemento.
Ejemplo:
Spinner1.Add(\"Sunday\")

Agrega varios elementos.
Ejemplo:
Spinner1.AddAll (matriz como cadena (\"Domingo\", \"Lunes\",...))

BringToFront
Claro
Borra todos los elementos.

mantenido.
GetItem (índice como Int) As String

Devuelve el elemento en el índice especificado.
Altura como Int
IndexOf (valor As String) como Int
Invalidar

Izquierda como Int
Preguntar como cadena

Obtiene o establece el título que se mostrará cuando se abre la ruleta.

Quita el elemento en el índice especificado.
RemoveView

SelectedIndex como Int

Obtiene o establece el índice del elemento seleccionado. Devuelve -1 Si no hay ningún elemento está seleccionado.
SelectedItem As String [sólo lectura]

Devuelve el valor del elemento seleccionado.
SendToBack

Devuelve el número de elementos.

Top como Int
Ancho como Int

16.14 TabHost
TabHost es una vista que contiene varias páginas de ficha. Cada página contiene otras vistas de niño.
Consulte el tutorial de TabHost para obtener más información.
Eventos:
TabChanged
Haga clic en
LongClick
Miembros:
AddTab (Title As String, LayoutFile As String)
AddTab2 (Title As String, vista como android.view.View)
AddTabWithIcon (Title As String, DefaultBitmap como android.graphics.Bitmap,

SelectedBitmap como android.graphics.Bitmap, LayoutFile As String)
AddTabWithIcon2 (Title As String, DefaultBitmap como android.graphics.Bitmap,

SelectedBitmap como android.graphics.Bitmap, ver como android.view.View)
BringToFront
CurrentTab como Int
Altura como Int

Invalidar
Izquierda como Int
RemoveView
SendToBack
TabCount como Int [sólo lectura]
Top como Int
Ancho como Int
AddTab (Title As String, LayoutFile As String)

Agrega una página de ficha.
Título - el título de la página.
LayoutFile - un archivo de diseño que describe el diseño de página.
Ejemplo:
TabHost1.AddTab (\"Página 1\", \"page1.bal\")
AddTab2 (Title As String, vista como android.view.View)

Agrega una página de ficha.
Vista - el contenido de la página. Normalmente la vista debe ser un panel que contiene otras vistas.
AddTabWithIcon (Title As String, DefaultBitmap como android.graphics.Bitmap,

SelectedBitmap como android.graphics.Bitmap, LayoutFile As String)
Agrega una página de ficha. El título de la ficha incluye un icono.
DefaultBitmap - el icono que se realizará cuando la página no está seleccionada.
SelectedBitmap - el icono que se realizará cuando se selecciona la página.

LayoutFile - un archivo de diseño que describe el diseño de página.
Ejemplo:
Dim bmp1, bmp2 como mapa de bits
bmp1 = LoadBitmap (File.DirAssets, \"ic.png\")
BMP2 = LoadBitmap (File.DirAssets, \"ic_selected.png\")
TabHost1.AddTabWithIcon (\"Página 1\", bmp1, bmp2,\"tabpage1.bal\")
AddTabWithIcon2 (Title As String, DefaultBitmap como android.graphics.Bitmap,

SelectedBitmap como android.graphics.Bitmap, ver como android.view.View)
Agrega una página de ficha. El título de la ficha incluye un icono.
DefaultBitmap - el icono que se realizará cuando la página no está seleccionada.
SelectedBitmap - el icono que se realizará cuando se selecciona la página.
Vista - el contenido de la página. Normalmente la vista debe ser un panel que contiene otras vistas.

BringToFront

mantenido.
CurrentTab como Int

Obtiene o establece la ficha actual.
Ejemplo:
TabHost1.CurrentTab = (TabHost1.CurrentTab + 1) Mod
TabHost1.TabCount ' a la ficha siguiente.
Altura como Int
Invalidar


Izquierda como Int
RemoveView
SendToBack
TabCount como Int [sólo lectura]

Devuelve el número de páginas de fichas.

Top como Int
Ancho como Int

16.15 ToggleButton
Una vista de ToggleButton. Este punto de vista que es similar a un botón tiene dos modos: encendido y apagado.
Cuando el usuario presiona sobre ella, cambiará su modo.
Puede establecer el texto con las propiedades TextOn y TextOff.
Eventos:
Miembros:
BringToFront
Gravedad como Int
Altura como Int
Invalidar
Izquierda como Int
RemoveView
SendToBack

TextColor como Int
TextOff As String
TextOn como cadena
Top como Int
Ancho como Int

BringToFront

mantenido.
Gravedad como Int
Altura como Int
Invalidar


Izquierda como Int
RemoveView
SendToBack

TextColor como Int
TextOff As String
Obtiene o establece el texto que aparecerá en el modo OFF.
TextOn como cadena

Obtiene o establece el texto que aparecerá en el modo ON.
Top como Int
Ancho como Int

16.16 Vista
Vista es un tipo especial de objeto. No puede crear nuevos objetos de la vista. Sin embargo todos los demás tipos de vista
puede asignarse a una variable de la vista.
Esto le permite acceder a las propiedades compartidas de todas las vistas.
Por ejemplo, este código oculta todas las vistas de una actividad:
Para i = 0 To Activity.NumberOfViews - 1
Dim v como vista
v = Activity.GetView(i)
v.Visible = False
Siguiente
Eventos:
Haga clic en
LongClick
Miembros:
BringToFront
Altura como Int
Invalidar
Izquierda como Int
RemoveView
SendToBack

Top como Int
Ancho como Int

BringToFront

mantenido.
Altura como Int
Invalidar

Izquierda como Int
RemoveView
SendToBack

Top como Int
Ancho como Int

16.17 WebView
La vista de vista Web utiliza el motor interno de WebKit para mostrar páginas Html.
La página que aparece puede ser una página en línea cargada con LoadUrl o un Html cadena cargado con
LoadHtml.
Permisos:
Android.Permission.Internet
Eventos:
Ninguno
Miembros:
Atrás

BringToFront
Avance
Altura como Int
Invalidar
JavaScriptEnabled As Boolean
Izquierda como Int
LoadHtml (Html como cadena)
LoadUrl (Url como cadena)
RemoveView
SendToBack
Top como Int
URL As String [sólo lectura]
Ancho como Int
ZoomEnabled As Boolean

Atrás
Vuelve a la dirección Url anterior.

BringToFront

mantenido.
Avance
Va hacia adelante a la siguiente dirección Url.
Altura como Int
Invalidar

JavaScriptEnabled As Boolean
Obtiene o establece si JavaScript está habilitado.
JavaScript está habilitado de forma predeterminada.
Izquierda como Int
LoadHtml (Html como cadena)

Carga el Html determinado.

Ejemplo:
WebView1.LoadHtml (\"<html><body>¡ Hola mundo!<\/body><\/html>\")
Puede utilizar \"file:\/\/\/android_asset\" para acceder a los archivos con el gestor de archivos:
WebView1.LoadHtml (\"<html><body>< img
src='file:\/\/\/android_asset\/someimage.jpg'\/ ><\/body><\/html> \")
Tenga en cuenta que deben tener acceso a archivos añadidos con el gestor de archivos con un nombre de entubado inferior.
LoadUrl (Url como cadena)

Carga la dirección Url especificada.
Ejemplo:
WebView1.LoadUrl(\"http:\/\/www.google.com\")
RemoveView
SendToBack

Top como Int
URL As String [sólo lectura]

Devuelve la dirección Url actual.
Ancho como Int

ZoomEnabled As Boolean
Obtiene o establece si está habilitada la característica de zoom interno.
La función de zoom está activada por defecto.
17 Colecciones de 294 Basic4Android Guía del principiante
17 Colecciones
Lista de tipos:
Lista
Mapa
17.1 Lista
Las listas son similares a los arreglos dinámicos. Puede agregar y quitar elementos de una lista y cambiará su
tamaño en consecuencia.
Una lista puede contener cualquier tipo de objeto. Sin embargo, si una lista es declarada como un objeto global del proceso n
Basic4android convierte automáticamente matrices regulares en las listas. Cuando se espera un parámetro de la lista
se puede pasar una matriz en su lugar.
Por ejemplo:
List1.Initialize
Utilice el método Get para obtener un elemento de la lista.
Las listas pueden ser guardadas y carga de archivos usando File.WriteList y File.ReadList.
Puede utilizar un bucle For para recorrer en iteración todos los valores:
Para i = 0 To List1.Size - 1
Dim número como Int
...
Siguiente
Eventos:
Ninguno
Miembros:
Agregar (elemento As Object)
AddAllAt (índice como Int, lista como lista)
Claro
Obtener (índice como Int) como objeto
IndexOf (elemento As Object) como Int
Inicializar
Initialize2 (matriz como lista)
InsertAt (índice como Int, elemento As Object)

SET (índice como Int, elemento As Object)
Orden (ascendente As Boolean)
SortCaseInsensitive (ascendente As Boolean)
SortType (FieldName como cadena, ascendente As Boolean)
Agregar (elemento As Object)

Agrega un elemento al final de la lista.

Agrega todos los elementos en la colección especificada al final de la lista.
Tenga en cuenta que puede agregar una matriz directamente.
Ejemplo:
List.AddAll (matriz como String(\"value1\", \"value2\"))
AddAllAt (índice como Int, lista como lista)

Agrega todos los elementos de la colección especificada, empezando por el índice especificado.
Claro
Quita todos los elementos de la lista.
Obtener (índice como Int) como objeto

Obtiene el elemento en el índice especificado. No se quita el elemento de la lista.
IndexOf (elemento As Object) como Int

Devuelve el índice del elemento especificado, o -1 Si no se encontró.
Inicializar
Inicializa una lista vacía.
Initialize2 (matriz como lista)

Inicializa una lista con los valores indicados. Este método se debe utilizar para convertir matrices a listas.
Tenga en cuenta que si pasa una lista a este método, entonces ambos objetos compartirán la misma lista,
y si se pasa una matriz la lista será de un tamaño fijo. Lo que significa que más tarde no se puede agregar o quitar
artículos.
Ejemplo:
List1.Initialize2 (matriz como Int(1,2,3,4,5))
Ejemplo:
Dim SomeArray(10) As String
' Llenar matriz...
List1.Initialize2(SomeArray)
InsertAt (índice como Int, elemento As Object)

Inserta el elemento especificado en el índice especificado. Como resultado todos los artículos con índice más grande entonce
se desplazan el índice especificado.

Quita el elemento en el índice especificado.
SET (índice como Int, elemento As Object)

Reemplaza el elemento actual en el índice especificado con el nuevo elemento.

Devuelve el número de elementos de la lista.
Orden (ascendente As Boolean)

Ordena la lista.
Todos los elementos deben ser números o cadenas.
SortCaseInsensitive (ascendente As Boolean)

Lexicográficamente ordena la lista, ignorando el caso de caracteres.
Todos los elementos deben ser números o cadenas.
SortType (FieldName como cadena, ascendente As Boolean)

Ordena una lista con elementos de usuario habían definido tipo. La lista está ordenada según el campo especificado.
FieldName - el nombre del campo entre mayúsculas y minúsculas que se utilizará para la clasificación. Campo debe contener
o cadenas.
Ascendente - si desea ordenar ascendente o descendente.
Ejemplo:
Sub Process_Globals
Persona de tipo (nombre As String, Int edad)
End Sub
Sub Activity_Create (cumshot As Boolean)

Dim personas como lista
Persons.Initialize
Para i = 1 A 50
Dim p como persona
p.Name = \"Persona\"
p.Age = Rnd (0, 121)
Persons.Add(p)
Siguiente
Persons.SortType (\"edad\", True) ' ordenar la lista según el campo de la edad.
Para i = 0 To Persons.Size - 1
Dim p como persona
p = Persons.Get(i)
Log(p)
Siguiente
End Sub
17.2 Mapa
Una colección que contiene pares de claves y valores. Las claves son únicas. Lo que significa que si agrega
un par de clave\/valor (entrada) y la colección ya tiene una entrada con la misma clave, el anterior
se eliminará la entrada del mapa.
Obtención de un elemento se realiza buscando su clave. Esto suele ser una operación muy rápida o (1 () en comparación con
a O(n) en una lista).
La clave debe ser una cadena o un número. El valor puede ser cualquier tipo de objeto.
Tenga en cuenta que esta aplicación de mapa devuelve los elementos en el mismo orden como se agregaron.
Normalmente utilizará poner agregar elementos y Get o GetDefault para obtener los valores basados en la clave.
Si usted necesita recorrer en iteración todos los elementos puede utilizar un bucle For como:
Para i = 0 To Map1.Size - 1
Dim clave, valor As String
Clave = Map1.GetKeyAt(i)
Valor = Map1.GetValueAt(i)
Siguiente
Similar a una lista, un mapa puede contener cualquier objeto, sin embargo, si es una variable global del proceso no
Los mapas son muy útiles para almacenar la configuración de aplicaciones.
Puede guardar y cargar los mapas con File.WriteMap y File.ReadMap.
Eventos:
Ninguno
Miembros:
Claro
ContainsKey (clave como objeto) As Boolean
Get (clave como objeto) como objeto
GetDefault (clave como objeto, por defecto como objeto) como objeto
GetKeyAt (índice como Int) como objeto
GetValueAt (índice como Int) como objeto
Inicializar
Poner (clave como objeto, valor como objeto) como objeto
Quitar (clave como objeto) como objeto

Claro
Borra todos los elementos del mapa.
ContainsKey (clave como objeto) As Boolean

Comprueba si hay un elemento con la clave dada.
Ejemplo:
Si Map.ContainsKey(\"some key\") entonces...
Get (clave como objeto) como objeto

Devuelve el valor del elemento con la clave dada.
GetDefault (clave como objeto, por defecto como objeto) como objeto
Devuelve el valor del elemento con la clave dada. Si no existe ningún elemento es el valor predeterminado especificado
regresó.
GetKeyAt (índice como Int) como objeto

Devuelve la clave del elemento en el índice especificado.
Ejemplo:
Para i = 0 to Map.Size - 1
Registro (\"clave:\"
Registro (\"valor:\"
Siguiente
GetValueAt (índice como Int) como objeto

Devuelve el valor del elemento en el índice especificado.
Ejemplo:
Para i = 0 to Map.Size - 1
Registro (\"clave:\"
Registro (\"valor:\"
Siguiente
Inicializar
Inicializa el objeto.
Ejemplo:
Dim Map1 As mapa
Map1.Initialize
Poner (clave como objeto, valor como objeto) como objeto

Pone un par de clave y valor en el mapa, sobrescribiendo el elemento anterior con esta clave (si tal existe).
Devuelve el elemento anterior con esta tecla o null si no había ningún elemento.
Tenga en cuenta que si utiliza cadenas como las teclas de las teclas distinguen mayúsculas de minúsculas.
Ejemplo:
Map1.put (\"tecla\", \"Valor\")
Quitar (clave como objeto) como objeto

Quita el elemento con la clave dada, si tal existe.
Devuelve el elemento eliminado o null si no se ha encontrado ningún elemento coincidente.

Devuelve el número de elementos almacenados en el mapa.
18 VB6 versus B4A 301 Basic4Android Guía del principiante
18 VB6 versus B4A

Escrito por: nfordbscndrd http:\/\/www.Basic4ppc.com\/Forum\/Members\/nfordbscndrd.html
UBU B4A
=== ===
controles Vistas (botón, edittext, etiqueta, etc.).
En la ventana de código de VB6, la lista desplegable izquierda superior contiene todos
los controles que has colocado en el formulario actual y la lista de la derecha
contiene todos los eventos para cada control. El equivalente en B4A puede
se encuentra haciendo clic en diseñador - herramientas - generar miembros. Vez
han creado Subs en el programa de codificación de la ventana, los ficha \"módulos\"
en el lado derecho aparecerá una lista cada uno de los Subs.
En B4A, empezar escribiendo \"Sub [viewName]\" seguido de un espacio y

Siga las instrucciones, pulsando Enter después de cada selección hasta B4A
termina con \"EventName\" destacada. Esto es donde usted escribiría en
el nombre de Sub.
Dim\/ReDim:
---------
Dim Array(n) Dim Array(n+1)
Mientras que \"n\" es el último número de índice en VB6, que indica el número
de elementos de la matriz cuando se utiliza en B4A. Por ejemplo, para atenuar una matriz
con 0-32 elementos en VB6, dirías Dim A(32), mientras que para convertir
Esto para B4A, necesita cambiar a Dim A(33), sin embargo, es índice # 33
nunca usado (hacerlo así podría ocasionar un error fuera de rango).
ReDim Array() Dim Array(n+1)--para borrar una matriz, sólo Dim lo nuevo.
[Dim un Int: Dim b as Boolean]

Si no es b entonces...Si Not(b) entonces...
Si b entonces... mismo
Si b = True Then mismo
Si entonces... Si un > 0 Then...
B4A no tratar cualquier valor distinto de cero como True como VB6.
un = un + b Si b = True entonces a = a - 1
Valor de booleano no puede utilizarse en una función matemática en B4A.
Global Const x = 1 B4A no tiene una función Global Const.

En Sub Globals, se puede decir Dim x como Int: x = 1
pero x no es una constante (su valor puede ser cambiado).
Bucles, If-Then, seleccione caso:

---------------------------
Hacer [hasta\/tiempo] mismo
Bucle [hasta\/tiempo] Loop [hasta que\/mientras no permitido.]
Para - siguiente mismo
Para i... - siguiente me la variable del bucle (i) no es permitir con siguiente.
Exit Do para Salida
Si - entonces - Else excepto ElseIf del VB mismo, es \"Else If\" en B4A; Ditto EndIf
--- Continuar [salta a la siguiente en bucle para el siguiente]

Para i = 1 a 6 Para i = 1 a 6
Si i = 4 entonces Si i = 4 a continuación,
... código... ... código...
End If ...
Siguiente Siguiente
Seleccione caso [expr] seleccionar [valor]
Colores:
------
18 VB6 versus B4A 60W Basic4Android Guía del principiante
L1.BackColor = L1.Color = Colors.Red

vbRed
L1.ForeColor = L1.TextColor = Colors.Black
vbBlack
Llamar a un sub:
-------------
SubName x, y SubName (x, y)
Sub SubName() Sub SubName() como Int\/cadena\/etc--no una variable Global

ser
un parámetro, por lo que dicen «reproductor» es una variable Global,
usted
no se puede decir: PlayCard(player). En su lugar, usted tiene que decir:
i = reproductor: PlayCard(i)
Función FName() Sub FName() como [var.type]

Como [var.type] En B4A, cualquier Sub puede utilizarse como una función mediante la adici
tipo de variable tales como
Sub CheckX (x como Int) As Boolean
.. .optional código...
Si x = [valor deseado], a continuación, devuelve True
.. .optional código...
End Sub
Si no se da retorno, luego cero\/False \"\" es devuelto.
El código de llamada no tiene que hacer referencia a la devolución
valor, por lo que si bien \"si CheckX(x) = True...\" es válida,
es tan sólo \"CheckX(x)\"
Exit Sub Retorno
Exit Function Devolver [valor]
General:
-------
DoEvents mismo, excepto Erel dice:
\"Llamar a DoEvents en un bucle consume muchos recursos y
no permite el sistema procesar todos los mensajes de espera
correctamente\". Esto fue en respuesta a mi señalando que
mientras
en un bucle Do con DoEvents en ella, no podía ser vista Web
cargado
o si cargado, haría clic en proceso no un hipervínculo. Y
Agraham
dice: \"el bucle es mala práctica en dispositivos móviles. La CPU
será
ejecución de código y usando la energía de la batería como constantemente la
código nunca pondremos el bucle inactivo OS donde el
hardware
medidas de ahorro de energía se invoca\".
Format() NumberFormat
InputBox($) InputList (elementos como CheckedItem de la lista, el título, como Int) como
Muestra la lista de opciones con los botones de radio. Índice de devoluc
CheckedItem es el valor predeterminado.
InputMultiList (elementos como lista, título) como lista
Usere puede seleccionar varios elementos a través de las casillas de ve
Devuelve la lista con los índices de cuadros comprobados.
MsgBox \"texto\" MsgBox (\"texto\", \"título\")

i=MsgBox() MsgBox2 (mensaje, título, positivo, cancelar, negativo, icono) como
Int
Muestra tres botones con texto que se mostrará para los botones
(Positivo, cancelar, negativo)
Icono se mostrará cerca el título y se especifica como:
LoadBitmap (File.DirAssets, \".gif [filename]\")
--- ToastMessageShow (texto, b) [donde b = True para larga duración]
RND es < 1 RND (min, max) es entero > = min a < máx.
Round(n) mismo, o Round2 (n, x) donde x = número de lugares decimales
i = Val(string) Si IsNumber(string) entonces i = string Else I = 0--

Un intento de uso i = string \"lanza una excepción\", si el
la cadena es
no números.
control.SetFocus vista.RequestFocus
n \/ 0: error n \/ 0 = 2147483647--B4A no \"una excepción\" para

División por 0, pero volver a 2147483647 no importa
¿Cuál es el valor de \"n\".
x = Shell(\"...\") Vea la \"Intención\". Esto no es un reemplazo completo, sino que permite

código como el siguiente del Foro B4A (por Erel):
Dim pi como PhoneIntents
StartActivity
(pi.OpenBrowser(\"file:\/\/\/sdcard\/yourfile.html\"))
t = Timer t = DateTime.Now ' las garrapatas son números de milisegundos desde 1 -

1-70
TabIndex:
--------
En VB6, TabIndex puede configurarse para controlar el orden en que los controles obtienen foco
Cuando se presiona Tab. Según Erel, en B4A:
\"Android maneja la secuencia según su posición. Puede establecer
EditText.ForceDone = True en todas sus EditTexts. Luego coger la
Evento de EditText_EnterPressed y establecer explícitamente el foco al siguiente
Ver (con EditText.RequestFocus).\"
Configuración de transparencia de la etiqueta:

--------------------------
Propiedades - estilo espalda Diseñador - dibujable - Alpha
Constantes:
---------
"" Quote = Chr$(34)
vbCr CRLF = Chr$(13)
vbCrLf ninguno
Cadena «miembros»:
----------------
VB6 utiliza un puntero de posición de caracteres comenzando con 1.
B4A utiliza un puntero de índice de caracteres comenzando con 0.
UBU B4A
MID$ (\"abcde\", 1, 1) = \"a\" = índice 0--de la matriz de la letra \"a\" = \"abcde\".CharAt(0)
MID$ (\"abcde\", 2, 1) = \"b\" = índice de la matriz de carta 1
MID$ (\"abcde\", 3, 1) = \"c\" = índice de matriz Carta 2
MID$ (\"abcde\", 4, 1) = \"d\" = índice de matriz carta 3
MID$ (\"abcde\", 5, 1) = \"e\" = índice de matriz carta 4
UBU B4A
=== ===
$ MID (texto, n, 1) texto.CharAt(n-1)
$ MID (texto, n) texto.SubString(n-1)
MID$ (texto, n, x) [x = longitud querido] texto.SubString2 (n-1, n + x-1) [n + x-1 = end
posición]
MID$ (texto, n, x) = text2 texto = texto.SubString2 (0, n-2)
Text2.SubString2 (0, x-1)

texto.Subcadena (n-1 + z) donde...
z = Min (x, text2.length)
Left$ (texto, n) [chars n=num.of.] texto.SubString2(0, n)
Right$ (texto, n) texto.SubString (texto.Longitud - n + 1)
Si un$ = $ b... Si a.CompareTo(b)...
Si la derecha$ (texto, n) = text2... Si texto.EndsWith(text2)...
Si se deja$ (texto, n) = text2... Si texto.StartsWith(text2)...
Si Lcase$(text) = Lcase$(text2)... Si texto.EqualsIgnoreCase(text2)...
x = Len(text) x = texto.Longitud
texto = Replace (texto, str, str2) texto.Reemplazar (str, str2)
LCase(Text) texto.ToLowerCase
UCase(Text) texto.ToUpperCase
Trim(Text) texto.Trim
(no LTrim o RTrim en B4A)
INSTR (texto, string) texto.IndexOf(string)
INSTR (int, texto, string) texto.IndexOf2(string, int)
Devuelve-1 Si no se encuentra.
Índice de devoluciones pers, no posición.
Comienza la búsqueda en \"int\".
Si Lcase$(x) = Lcase$(y)... Si x.EqualsIgnoreCase(y)...
texto = Left$ (texto, n) texto.Insertar (n, s)
Right$ (texto, y)
ASC(s) [donde s = carácter] mismo
Captura de errores:
--------------
VB6:
===
Sub SomeSub
En [Local] Error GoTo ErrorTrap
.. .algunos código...
On Error GoTo 0 [fin opcional en la captura de error]
.. .optional código adicional...
Exit Sub [para evitar la ejecución de código de ErrorTrap]
ErrorTrap:
.. .optional código de corrección de errores...
Curriculum Vitae [opcional: \"Resume Next\" o \"Resume [etiqueta de línea]\".
End Sub
B4A:
===
Sub SomeSub
Trate de
.. .algunos código...
Capturas [sólo se ejecuta si error anterior]
Log(LastException) [opcional]
.. .optional código de corrección de errores...
End Try
.. .optional código adicional...
End Sub
Con B4A, si obtiene un error atrapado en medio de una subrutina grande, usted
puede
NO hacer una corrección y reanudar dentro del código que se ejecute. Sólo el
Código
ejecutado en \"Catch\". Parece que Try-Catch-End Try de uso
principalmente
durante el desarrollo.
Try-Catch en lugar de GoTo:

--------------------------
Try-Catch puede utilizarse como un sustituto de GoTo [etiqueta de línea] para el avance, pero no
Salta hacia atrás. No puede utilizarse para reemplazar GoSub, para el que no tiene ningún B4A
equivalente.
Iniciar el código con \"Try\" y sustituir la [etiqueta de línea] con \"Catch\".

Sustituir \"GoTo [etiqueta de línea]\" código que creará una excepción, que
causas
un salto a la \"Captura\", como OpenInput (\"mal camino\", \"bad filename\").
\"Ventana inmediato\" vs \"Registros\" ficha

--------------------------------
Comentarios, valores de variables, etc., pueden mostrarse en inmediato de VB6
Ventana introduciendo en el código \"Debug.Print...\".
En el entorno de B4A, la ficha de registros en el lado derecho del IDE es una

forma de mostrar los valores de variables, etc., mientras se ejecuta el código.
VB6 y (ahora) B4A permiten single-paso a paso a través del código mientras
está funcionando y ver los valores de las variables. VB6 también permite cambiar
el valor de las variables, para cambiar el código, saltar a otras líneas de
la línea actual, etc. Porque B4A se ejecuta en un PC mientras la aplicación se ejecuta en
un dispositivo separado, B4A es actualmente incapaz de duplicar todos estos
Características de depuración de VB6.
19 FAQ DE 306 Basic4Android Guía del principiante
19 PREGUNTAS FRECUENTES
Algunos de los capítulos a continuación han sido recogidos desde el Foro.
19.1 Mensaje \"Por favor Guardar proyecto primero\"
Al intentar compilar o abra el diseñador veo un mensaje diciendo: \"Por favor guardar código fuente primero.\"
Un nuevo proyecto no tiene una carpeta que contiene hasta que primero está guardado.
Guardar el proyecto y este error desaparecerá.
19.2 Mensaje \"Le falta una referencia de la biblioteca\"
Compilador dice: \"falta una referencia de la biblioteca?\".
Vaya a la ficha de bibliotecas en el panel derecho y compruebe la

bibliotecas requeridas.
Si no sabes qué biblioteca un tipo de objeto específico

pertenece a, puede ir a la documentación página o
la lista de bibliotecas adicionales.
En la parte inferior de esta página hay una larga lista con todos los
tipos de objetos.
Pulsando sobre cualquier tipo le llevará a la biblioteca de derecha.

Tenga en cuenta que la versión de prueba no admite bibliotecas. Sólo
la versión completa.
19.3 Cómo cargar \/ actualización de una biblioteca
Consulte el capítulo de las bibliotecas en la guía.
Se muestra una lista de las bibliotecas oficiales y adicionales con enlaces a los hilos del Foro pertinente en el
B4A Wiki aquí: lista de bibliotecas
Para cargar o actualizar una biblioteca siga estos pasos:

 Descargue el archivo zip de biblioteca en algún lugar.
 Descomprimirlo.
 Copie los archivos xxx.jar y xxx.xml a la
o Carpeta de la biblioteca de B4A para una biblioteca estándar de B4A
o Carpeta de bibliotecas adicionales para una librería adicional.
 Reinicie el IDE y compruebe la biblioteca en la lista de la ficha de Lib para seleccionarlo.
ArgumentException:
ArgumentException:
The incoming
The incoming
tokentoken
has expired.
has expired.
Get Get
a new
a new
access
access
token
token
fro
ArgumentException: The incoming token has expired. Get a new access token from the Authorization Se
ArgumentException: The incoming token has expired. Get a new access token from the Authorization Server. : ID
 Para poder tener acceso a cualquier vista por su nombre, usted debe Dim en el Globals Sub
rutina.
Vistas que se añadieron

 en el diseñador en un archivo de diseño no debe ser inicializado!
o Dim sólo la vista en la rutina de Sub Globals.
Sub Globals
Dim lblTitle como etiqueta
y nada más.
 por código debe ser initilized.

o Dim la vista en la rutina de Sub Globals.
Sub Globals
Dim lblTitle como etiqueta
o Inicializarla y agregarlo a la actividad (o un Panel) en la rutina Activity_Create.

Si entonces cumshot
lblTitle.Initialize(\"\")
Activity.AddView (lblTitle, 10dip, 10dip, 200dip, 50dip)
End If
Lista \/ mapa.
Lista y mapa objetos deben inicializarse antes de que se pueden utilizar.

19.5 Dividir una línea larga en dos o más líneas
Para dividir una larga línea en dos o más líneas pone un carácter de subrayado, separados por un espacio en blanco
carácter, al final de la línea. Mire el ejemplo en el capítulo siguiente.
ANSW = Msgbox2 (\"desea salir del programa\", \"A T T E N T I O N\", \"Sí\", \"\", \"No\", Null)
Se convierte en:
ANSW = Msgbox2 (\"desea salir del programa\", _

\"A T T E N T I Ó N\", \"Sí\", \"\", \"No\", Null)
19.6 Evitar cerrar una aplicación \/ captura códigos de tecla como Back \/ menú
Esto puede hacerse por interceptar el evento Activity_KeyPress.
Sub Activity_KeyPress (KeyCode como Int) As Boolean ' devuelve True para consumir el
evento
Dim Answ como Int
Si KeyCode = KeyCodes.KEYCODE_BACK Then

ANSW = Msgbox2 (\"desea salir del programa?\", _
\"A T T E N T I Ó N\", \"Sí\", \"\", \"No\", Null)
Si Answ = DialogResponse.NEGATIVE Then
Return True
End If
End If
Return False
End Sub
 Comprobamos si el el KeyCode equivale a la tecla atrás.

 Si sí, le pedimos al usuario si realmente desea salir del programa.
o Si 'No' volvemos cierto que consumir el evento.
o De lo contrario nos devuelven False para transmitir el evento para el sistema operativo.
TH
Sólo como recordatorio, el guión bajo al final de la línea 5
ANSW = Msgbox2 (\"desea salir del programa?\", _
significa divide la línea y pone el resto en la línea siguiente.
ATENCIÓN:
La tecla de inicio no puede ser atrapada en el Activity_KeyPress rutina de evento!
19.7 Eventos no deseados como clic, tacto u otros
Propuesto por alfcen:
Supongamos que tiene una actividad que contiene varios botones con eventos de clic.
Ahora, agregar un Panel sobre la actividad, cubriendo así los botones. Como toque en el
panel que se verá que fue despedido un evento click de un botón en la actividad.
Esto no es un bug de B4A, por el contrario, puede ser bastante útil.
Sin embargo, si esto no es buscado, simplemente añada:
Sub Panel1_Click
' no hacer nada aquí o colocar código a ser ejecutado a golpecitos en el panel
End Sub
19,8 Agregar un elemento de menú
También debe tener una mirada a los programas de ejemplo \/ interfaces de usuario.
Esto se hace con los métodos AddMenuItem o AddMenuItem2.

Una vez que se agrega un elemento de menú puede ni modificar ni quitar o deshabilitar.
Activity.AddMenuItem (\"Título\", \"EventName\")

Activity.AddMenuItem (\"Título\", \"EventName\", imagen)
Ejemplos:
Activity.AddMenuItem (\"Load\", \"mnuLoad\")

Activity.AddMenuItem (\"Guardar\", \"mnuSave\", imagen)
Activity.AddMenuItem (\"Load\", \"mnuLoad\", LoadBitmap (File.DirAssets, \"Load.png\"))

Activity.AddMenuItem (\"Guardar\", \"mnuSave\", LoadBitmap (File.DirAssets, \"Save.png\"))
19.9 ¿Cómo elimino una vista con el diseñador
Para eliminar una vista con el diseñador debe:

 Seleccione la vista para quitar el dispositivo, el emulador o en el diseñador.
 Retirar, en el menú que herramientas haga clic en quitar vista seleccionada.
Mensaje 19.10 «proceso tiene tiempo de espera»
Si a menudo recibe este mensaje \"El proceso tiene tiempo de espera\" puede cambiar su valor:
 En el IDE menú Herramientas \/ Opciones de IDE haga clic en configurar el tiempo de proceso.
 Y cambiar el valor:
19.11 Obteniendo una imagen de la Galería
Siguiendo el código le permite cargar una imagen de la Galería.
Sub Process_Globals
Dim selector como ContentChooser
End Sub
Sub Globals
End Sub

Si entonces cumshot
selector de campos.Initialize(\"Chooser\")
End If
selector de campos.Mostrar (\"imagen \/ *\", \"Seleccionar imagen\")
End Sub
Sub chooser_Result (éxito As Boolean, Dir As String FileName As String)

Si éxito entonces
Dim bmp como mapa de bits
BMP.Inicializar (Dir, nombre de archivo)
Activity.SetBackgroundImage(BMP)
Else
ToastMessageShow (\"ninguna imagen seleccionada\", True)
End If
End Sub
19.12 Cómo eliminar archivos de x.bal u otros archivos de un proyecto
Para eliminar archivos de proyecto debe utilizar los archivos de la ficha en la esquina inferior derecha del IDE.
 Seleccione los archivos que desea eliminar.
 Haga clic en y confirmar para eliminar los archivos.

Si elimina los archivos en la carpeta, recibirá un mensaje para los archivos que faltan la siguiente
tiempo de que iniciar el proyecto.
19.13 Bloquear una orientación de la pantalla
Para bloquear la orientación de retrato o paisaje.

Este es válido para la actividad actual.
Puede definir orientaciones de pantalla diferentes para diferentes actividades.
En el IDE, menú:
Proyecto orientaciones soportan:
 Ambos
 Retrato
 Paisaje
También se puede hacer por código con

SetScreenOrientation desde la biblioteca de teléfono:
 Paisaje
 Retrato
 Ambos
Phone1.SetScreenOrientation(-1)
19.14 Segunda actividad de cierre de
Desde el Foro:
En relación con el tutorial de 'twoactivities' por Erel, noté cuando se presiona el botón posterior de
la principal actividad, Activity2 luego mostró nuevamente.
En el código de Activity2 despuésStartActivity(Main)

de Añadir
Activity.Finish.
StartActivity(Main)
Activity.Finish
19.15 Tomar una captura de pantalla programaticaly
Usted puede tomar una captura de pantalla del dispositivo o el emulador con el siguiente código:
Las necesidades de la biblioteca de reflexión.
Sub btnScrShot_LongClick
' Tomar una captura de pantalla.
Dim Obj1, Obj2 como Reflector
Dim bmp como mapa de bits
Dim c como lienzo
Ahora, la Dim I As Long
Dim dt As String
DateTime.DateFormat = \"yyMMddHHmmss\"
Ahora = DateTime.now
DT = DateTime.Date(now) ' por ejemplo: \"110812150355\" es Aug.12, 2011, 15:03:55
Obj1.Target = Obj1.GetActivityBA
Obj1.Target = Obj1.GetField(\"vg\")
BMP.InitializeMutable (Activity.Width, Activity.Height)
c.Initialize2(BMP)
Dim args(1) As Object
Dim types(1) As String
Obj2.Target = c
Obj2.Target = Obj2.GetField(\"canvas\")
args(0) = Obj2.Target
Types(0) = \"android.graphics.Canvas\"
Obj1.RunMethod4 (\"dibujar\", args, tipos)
Dim Out As OutputStream
A = File.OpenOutput (File.DirRootExternal, dt
BMP.WriteToStream (Out, 100, \"PNG\")
Out.Close
End Sub
19.16 Después de compilar, donde están los archivos
El compilador genera un archivo *.apk que se encuentra en la carpeta de 'Objetos'. Cuando es el IDE
conectado a un dispositivo o en el emulador el archivo apk es automáticamente cargado a ella.
El nombre del archivo apk es la 'etiqueta de aplicación' especificada cuando se ha definido el proyecto.
Ejemplo: GPSExample.apk
Si ha marcado 'Incluir información de depuración' y depurador de acople en el IDE se obtendrá un
archivo apk con el sufijo _DEBUG.
Ejemplo: GPSExample_DEBUG.apk
Si desea distribuir la aplicación debe desactivar estas dos opciones.
19.17 Ejecutar una aplicación desde otra
Respuesta de Erels a la pregunta:

Puede iniciar cualquier aplicación enviando la intención correcta.
La forma más sencilla de ver la intención requerida es mirar los registros sin filtrar al iniciar manualmente
la aplicación.
El código siguiente muestra cómo ejecutar una aplicación desde otro.

El PackageManager es un objeto en la biblioteca de teléfono.
Se necesita el nombre del paquete exacto!
Dim pm como PackageManager

Dim en como intención
en.Inicializar (\"\", \"\")

in = pm.GetApplicationIntent
En caso.Entonces IsInitialized
StartActivity(in)
End If
19,18 Cómo pasar una matriz a un Sub
Es posible pasar matrices, matrices multidimensionales también, a un sub.
Ejemplo de código.
Dim (1), two(1,2), three(1,2,3) As String
Sub Test(a() As String, b(,) As String, c(,,) As String) como String(,)

...
End Sub
'
'
Prueba (uno, dos, tres)
Es necesario especificar el rango (número de dimensiones) en la definición de Sub con ','.

Si desea que el Sub para devolver una matriz también debe speccify.
Sub Test(a() As String, b(,) As String, c(,,) As String) As String

Devuelve una cadena única.
Sub Test(a() As String, b(,) As String, c(,,) As String) como String()

Devuelve una matriz de cadenas rango.
Sub Test(a() As String, b(,) As String, c(,,) As String) como String(,)

Devuelve una matriz de cadenas de rango dos.
19.19 Obtención de idioma y país de dispositivo
Puede obtener el actual idioma y país desde un dispositivo con el siguiente código.

Log(GetDefaultLanguage)
End Sub
Sub GetDefaultLanguage
Dim r como Reflector
r.Target = r.RunStaticMethod (\"java.util.Locale\", \"getDefault\", Null, Null)
Volver a r.RunMethod(\"getDisplayName\")
End Sub
GetDefaultLanguage Devuelve una cadena con el idioma y el país.
Necesidades de la biblioteca de reflexión (disponible sólo para los usuarios que compraron Basic4Android)!
Ejemplos:
 Inglés (Estados Unidos)

 Deutsch (Österreich)
 Français (Suisse)
19.20 Donde está el archivo apk
Donde está el archivo apk:

El archivo apk se encuentra en la carpeta objetos de su proyecto.
19.21 Por qué es mi result.apk de nombre de archivo apk
El nombre de archivo es el mismo que el nombre de archivo de proyecto principal pero en vez del sufijo .b4a tiene la .apk
sufijo.
Si se introducen caracteres no autorizados, como un espacio, el nombre del archivo apk será result.apk.
El nombre de apk no tiene ninguna importancia, el nombre que se muestra es el nombre de etiqueta que le dio cuando creó
el proyecto.
19,22 Por qué es mi xxx_DEBUG.apk de nombre de archivo apk
Distribuir un programa que debe seleccionar en el IDE, en la lista de Drpodown,

Liberación.
19.23 Seleccione True \/ casos truco
La pregunta: sería bueno poder utilizar Select Case utilizando el 'mayor que' y 'menos'
los operadores <>. Limpiador de código que 'si' hace 'otra cosa' y 'end if' etc..
Este truco hace:
i = 10
Seleccione True
Caso (me < 9)
Log(\"false\")
Caso (i = 10)
Log(\"true\")
End Select
19.24 Llenar una matriz con números aleatorios sin repeticiones
Este fragmento de código de Erel se basa en el algoritmo de shuffle Fisher-Yates.
Sub Globals
Dim numbers(10) como Int
End Sub

' poner números 1-10 en la matriz
Para i = 0 A 9
Numbers(i) = i + 1
Siguiente
ShuffleArray(numbers)
Para i = 0 A 9
Log(Numbers(i)) ' imprimir los números en el registro
Siguiente
End Sub
Sub ShuffleArray(arr() como Int)

Dim I As Int
Para i = popularizadoLongitud - paso 1 A 0 -1

Dim j, k como Int
j = Rnd (0, + 1)
k = arr(j)
ARR(j) = arr(i)
ARR(i) = k
Siguiente
End Sub
19.25 Detectar la orientación de la pantalla
El siguiente código detecta la pantalla orientaion, comparando si el ancho de la actividad es mayor que la
altura de la actividad, a continuación, la orientación es \"paisaje\" de lo contrario es \"portrait\".
Sub Globals
Dim orientación como cadena
End Sub

Si Activity.Width > Activity.Height entonces
Orientación = \"Paisaje\"
Else
Orientación = \"Claro\"
End If
End Sub
19.26 Algunas funciones no funcionan en Activity_Pause
No se admiten todas las funciones detener el programa en elActivity_Pause rutina.

Como:
 Cuadros de mensaje MsgBox
 Cuadros de diálogo modales
InputDialog, etc. de FileDialog.
 Cuadros de diálogo personalizados
 Puntos de interrupción
Trabajo de registro y ToasMessage.
19.27 Llamando la calculadora interna
La siguiente subrutina llama la calculadora interna.
Calculadora de Sub
Dim I As intenciones
i.Initialize (\"\", \"\")
i.SetComponent (\"com.android.calculator2 \/.Calculadora\")
Trate de
StartActivity(i)
Captura
ToastMessageShow (\"Calculadora app no encontrado.\", True)
End Try
End Sub
19,28 Obtenga la Alpha \/ rojo \/ verde \/ azul

Dim argb() como Int
ARGB = GetARGB(Colors.Transparent)
Registro (\"A =\"
Registro (\"R =\"
Registro (\"G =\"
Registro (\"B =\"
End Sub
Sub GetARGB (Int Color) como Int()

Dim res(4) como Int
res(0) = Bit.UnsignedShiftRight (Bit.And (Color, 0xff000000), 24)
res(3) = Bit.And (Color, 0xff)
Res de retorno
End Sub
En líneaSub GetARGB (Int Color) como Int() el () Después

Intde
son necesarios porque el retorno
valor es una matriz.
19 Glosario de 319 Basic4Android Guía del principiante
Glosario 20
Android Android es una pila de software para dispositivos móviles que incluye un sistema operativo,
aplicaciones de middleware y clave. Google Inc. adquirió, en 2005, Android Inc., la compañía que
inicialmente se desarrolló el software.
Java Java es un lenguaje de programación originalmente desarrollado por James Gosling en el sol
Microsystems (que ahora es una subsidiaria de Oracle Corporation) y lanzado en 1995 como un núcleo
componente de la plataforma Java de Sun Microsystems. El idioma deriva gran parte de su sintaxis de c
y C++, pero tiene un modelo de objetos más simple y menos instalaciones de bajo nivel.
Actividad Una actividad es algo único y centrado que el usuario puede hacer. Casi todas las actividades
interactuar con el usuario, por lo que la clase de actividad se encarga de crear una ventana para usted en que usted
puede colocar su interfaz de usuario.
Vista Proporciona clases que exponen clases de interfaz de usuario básica que manejan el diseño de la pantalla y
interacción con el usuario. Ejemplos: Etiqueta, Panel, botón, EditText etc..

Basic Android 4 - Guía para Principiantes PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Basic Android 4 - Guía para Principiantes PDF

Cargado por

Copyright:

Formatos disponibles

Guía para principiantes

Copyright: © 2011 cualquier Software Edición 2.1

8.2 Tools ........................................................................................................................... 100

13.1.2 Globals routine..................................................................................................... 168

16.2 Button.......................................................................................................................... 241

Erel Uziel (Erel)

1.1 Instalación de Basic4Android y Android SDK

Basic4android depende de dos componentes adicionales (libres):

-Abrir la Link de descarga de Java JDK 7.

-Descargar el archivo e instalarlo.

Siguiente paso es instalar el SDK de Android y una plataforma:

Tenga en cuenta que puede instalar más paquetes más tarde.

-Presione en instalar seleccionado e instalar ambos paquetes.

1.1.1 Instalar y configurar Basic4Android

- Descargar e instalar Basic4android .

-Seleccionar el menú de herramientas - configurar rutas de acceso.

-Utilice los botones de navegación para localizar \"javac.exe\" y \"android.jar\"

Android.jar se encuentra bajo <android-sdk-windows> \\platforms\\android-8

En Windows de 64 bits, Java probablemente se instalará en C:\\Program Files (x 86).

1.2 Instalar emulador Android

Por favor siga las instrucciones de instalación (y configuración) si no lo ha hecho todavía:

Crear nueva AVD

-Seleccionar el menú de herramientas - Run AVD Manager.

-El Manager de AVD debería aparecer:

-Tenga en cuenta que puede crear más de una

-Ahora, haga clic en con el fin de iniciar el emulador.

-Verá esta pantalla.

-Haga clic en para iniciar el emulador

-Verá varias ventanas apareciendo y desapareciendo. Esto está bien.

-El emulador debe arrancar:

El emulador está listo cuando se pone a

Puede ver esta pantalla, que es la pantalla de bloqueo,

Arrastre el icono de bloqueo a la derecha para desbloquear la

Tenga en cuenta que no es necesario reiniciar el emulador

Si no estás familiarizado con Android puede reproducir

Solución de problemas: Si aparece un mensaje de error

2 Mi primer programa (MyFirstProgram.b4a)

El proyecto está disponible en la carpeta de código fuente:

Vamos al diseño de la interfaz de usuario con el diseñador en el emulador y vaya paso

Debe guardar el proyecto antes de ejecutar el diseñador.

Crear una carpeta nueva MyFirstProgram y guardar

El retrato emulador, en este caso. Haga clic en

Espere hasta que el diseñador está listo.

Conecte el emulador al diseñador.

Espere hasta que el diseñador y el emulador

Podrá ver el estado del diseñador aquí:

La parte superior del emulador tenga este aspecto.

Ahora agregaremos las 2 etiquetas para los números.

La etiqueta aparecerá en el emulador, y sus parámetros por defecto aparecen en el diseñador.

Cambiar el tamaño y mover la etiqueta con el rojo

Los nuevos parámetros Left, Top, Width y

Cambiemos los parámetros de esta primera etiqueta

Presionar retorno o haciendo clic en otro lugar que también

Principal: módulo principal

Comprobar y modificar los otros parámetros:

A la izquierda, parte superior, la anchura y la altura son OK.

Tipo de letra, estilo son OK

Los nuevos parámetros.

Coloque la etiqueta nueva y cambiar su nombre a lblNumber2.

Ahora agreguemos una vista EditText. En haga clic en diseñador de

Cambiemos estos parámetros.

Alineación horizontal Para

Tipo de entrada a los números