Escolar Documentos
Profissional Documentos
Cultura Documentos
Embarcadero Technologies, Inc. es un proveedor líder de herramientas premiadas para los desarrolladores de aplicaciones y
profesionales de bases de datos para que puedan diseñar sistemas derecha, construirlos más rápido y funcionar mejor,
independientemente de su plataforma o lenguaje de programación. Noventa de la lista Fortune 100 y una comunidad activa de más de
tres millones de usuarios de todo el mundo confían en los productos de Embarcadero para aumentar la productividad, reducir costes,
simplificar la gestión del cambio y el cumplimiento y acelerar la innovación. herramientas del buque insignia de la compañía incluyen:
Embarcadero® Change Manager ™, CodeGear RAD Studio ™, DBArtisan®, Delphi®, ER / Studio, JBuilder® y Rapid SQL®. Fundada en
1993, Embarcadero tiene su sede en Austin, con oficinas ubicadas en todo el mundo. Embarcadero está en línea en www.embarcadero.com
. De marzo de 2017
Embarcadero Technologies 2
do ONTENIDOS
Tutoriales móviles: Desarrollo de aplicaciones móviles (iOS y Android) ........................... 10
Preparar ................................................. .................................................. .................................... 11
El uso de elementos de la interfaz de usuario básico ............................................. ....................................... 11
El uso de la funcionalidad del dispositivo ............................................... .................................................. ... 13
El uso de backend como servicio ............................................. .................................................. .... 14
Acceso a una base de datos ............................................... .................................................. ........... 15
Ver también ................................................ .................................................. ............................ 15
Tutorial móvil: Configurar el entorno de desarrollo en el Mac (IOS) .................... 16
Requisitos en el Mac y el IOS ............................................ ....................................... dieciséis
Pasos para configurar su Mac para ejecutar su aplicación iOS ........................................ ... dieciséis
Paso 1: Instalar el Asistente Plataforma ........................................... .................................. 17
Paso 2: Ejecutar el Asistente Plataforma ........................................... ..................................... 18
Paso 3: Instalar Xcode en el Mac .......................................... ........................................ 19
Próximos pasos ................................................ .................................................. ..................... 20
Pasos adicionales para configurar su Mac para ejecutar su aplicación iOS en tu dispositivo iOS
... ..................... ........................................ . ............................................................................... . 20
Paso 1: Asegúrese de que las herramientas Xcode línea de comandos se ha instalado en su Mac .. 20 Paso 2: Regístrese para
obtener una cuenta de desarrollador ...................... .................................................. 22
Paso 3: Solicitud, descargar e instalar su certificado de Desarrollo ......................... 22
Solicitud, descargar e instalar su certificado ........................................... ............... 22
Paso 4: Registrar un dispositivo para la implementación .......................................... ....................... 24
Paso 5: crear e instalar un archivo de suministro ......................................... ..................... 24
Ver también ................................................ .................................................. ............................ 25
Tutorial móvil: configurar el entorno de desarrollo en PC con Windows (IOS) ............ 26
Configuración de la RAD Studio Ambiente ............................................ ........................... 26
Crear un perfil de conexión para el Mac ........................................... ........................... 26
Añadir un SDK para el Sistema de Desarrollo para el dispositivo iOS conectado a la Mac29 Véase también
................................. .................................................. ........................................... 31
Tutorial móvil: configurar el entorno de desarrollo en PC con Windows (Android) ..... 33
Ver también ................................................ .................................................. ............................ 33
Tutorial móvil: Creación de una aplicación para plataformas móviles (iOS y Android) ......... 34
Antes de que empieces ............................................... .................................................. ................ 34
Paso 1: Crear una nueva aplicación de FireMonkey para Android o iOS ............................... 34
Paso 2: Seleccione un estilo ............................................ .................................................. ............ 36
Paso 3: colocar los componentes en el Formulario de ....................................... Multi-Device ............ 36
Paso 4: Adición de vistas para su proyecto .......................................... ..................................... 39
Paso 5: Escribir un controlador de eventos para un clic de botón por el usuario .................................... 39 ..
Paso 6: Prueba de su aplicación móvil ........................................... .................................... 40
Probar la aplicación Android en el dispositivo Android .......................................... .... 41
Probar la aplicación iOS .............................................. ............................................... 42
Ver también ................................................ .................................................. ............................ 43
Tutorial móvil: El uso de una libreta de direcciones de componentes (iOS y Android) ........................ 45
Características básicas de los componentes TAddressBook ............................................ .............. 46
Embarcadero Technologies 3
Creación de una aplicación de ejemplo .............................................. ........................................... 46
El diseño de la interfaz de usuario .............................................. ........................................... 46
Recuperando la lista de contactos .............................................. ............................................. 49
Implementación del Control de Elementos Funcionalidad ............................................. ......... 51
Mantener libreta de direcciones de sincronización ............................................. ........................................ 54
Configuración del acceso a la libreta de direcciones ............................................. .............................. 55
Ejecución de la aplicación de ejemplo .............................................. ........................................ 57
Ver también ................................................ .................................................. ............................ 59
Ejemplos de código ................................................ .................................................. ............... 59
Tutorial móvil: El uso de un componente de botón con diferentes estilos (iOS y Android) .... 60
Botones en plataformas móviles .............................................. ................................................ 60
Definir la apariencia de un componente Button ......................................... .............. 61
Usando tintColor y IconTintColor en los botones ............................................ ............... 62
Usando diseñadas y coloreadas botones de Plataformas de destino .......................................... ... 64
Personalización de botones con estilos .............................................. ..................................... 64
La colocación de una imagen sobre un botón ............................................ ........................................ 64
Crear un control segmentado Utilización de componentes Botón ........................................... ... sesenta y cinco
Crear una barra de Alcance en una barra de herramientas de componentes .......................................... ...................... 67
Las diferencias importantes entre un TButton y TSpeedButton ..................................... 68
Ver también ................................................ .................................................. ............................ 68
Tutorial móvil: Utilizar un componente de calendario para seleccionar una fecha (iOS y Android) .......... 69
Calendario en plataformas móviles .............................................. .............................................. 69
La implementación de un controlador de eventos para los cambios del usuario de la Fecha .................................... 71
Ver también ................................................ .................................................. ............................ 72
Las muestras ................................................. .................................................. ........................ 73
Tutorial móvil: Usando Combo componentes de la caja para recoger cosas de una lista (iOS y Android)
... ..................... ........................................ . ............................................................................... . 74
La implementación de un selector de aplicaciones en múltiples dispositivos .......................................... ............ 74
La construcción de una lista de artículos mediante código ........................................... ....................................... 76
Viendo un artículo específico .............................................. .................................................. . 77
La implementación de un controlador de eventos para la selección del usuario .......................................... ..... 78
Ver también ................................................ .................................................. ............................ 79
Las muestras ................................................. .................................................. ........................ 80
Tutorial móvil: El uso de un componente de mapa para trabajar con mapas (iOS y Android) ......... 81
Características básicas de los componentes TMapView ............................................ ..................... 81
Creación de una aplicación de ejemplo .............................................. ........................................... 82
Configuración de aplicaciones de Android para utilizar el componente TMapView ...................... 82
El diseño de la interfaz de usuario .............................................. ........................................... 82
Ejecución de la aplicación de ejemplo .............................................. ........................................ 87
Ver también ................................................ .................................................. ............................ 88
Ejemplos de código ................................................ .................................................. ............... 88
Tutorial móvil: Utilizar un componente MultiView a la pantalla alternativa Vistas de la Información (iOS y Android)
................................ .................................................. ......................................... 89
Sobre el Componente TMultiView .............................................. ..................................... 89
Maestras del panel modos de presentación .............................................. ................................... 90
Embarcadero Technologies 4
El diseño de la interfaz de usuario .............................................. ............................................... 97
Diseñar el panel principal .............................................. ............................................. 97
Diseñar el panel de detalles .............................................. ............................................... 98
La implementación de la funcionalidad de la cámara Botones ............................................. ........... 98
Configuración de las propiedades del componente TMultiView ............................................. ............ 101
Ejecutar el Ejemplo de Aplicación .............................................. .................................... 102
Las muestras de productos móviles que utilizan TMultiView ............................................ .................. 102
Ver también ................................................ .................................................. .......................... 103
Tutorial móvil: Uso del Explorador de componentes (iOS y Android) ...................... 104
Diseñar la interfaz de usuario .............................................. .................................................. 105
Escribir un controlador de eventos para abrir una página Web cuando el usuario cambia la dirección URL en el control de edición
............................... .................................................. ............................................. 107
Implementar un método común para abrir una página Web ......................................... .... 108
Implementar un controlador de eventos para el evento OnChange .......................................... 109 ..
Implementar un controlador de eventos para el botón Volver .......................................... ........... 110
Selección del teclado virtual apropiado para la aplicación Web Browser .................. 110
WebBrowser Código Móvil de fragmentos .............................................. .................................. 112
Ver también ................................................ .................................................. .......................... 112
Tutorial móvil: Utilización de componentes de la ficha para mostrar las páginas (iOS y Android) .............. 114
Usando el estilo nativo de aquí en iOS y Android ........................................ ........ 114
Proyectos Tab páginas utilizando el Diseñador de formularios ........................................... ................ 115
La comparación de los Parámetros de la ficha en iOS y Android .......................................... .......... 120
Uso de Multi-resolución personalizada iconos para las pestañas ......................................... ............ 125
Viendo multi-resolución de los iconos personalizados en la más aquí .......................................... ........ 126
El uso de un solo mapa de bits Resolución de un icono personalizado ........................................ ....... 129
Definición de controles dentro de un TabControl ............................................. .............................. 130
Cambio de la página en tiempo de ejecución ............................................ ......................................... 132
Por el usuario tocando la pestaña ............................................ ........................................... 132
Por acciones y un ActionList ............................................. .......................................... 132
Por código fuente ............................................... .................................................. ........... 137
Ver también ................................................ .................................................. .......................... 140
Las muestras ................................................. .................................................. ...................... 140
Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (iOS y Android) 141 Utilización de componentes
ListBox para mostrar una vista de tabla en plataformas móviles .................. 141
Lista llanura ................................................ .................................................. ....................... 142
Lista agrupados ................................................ .................................................. ............... 143
Caja de búsqeda ................................................ .................................................. .................. 143
Crear artículos por el componente ListBox ............................................ ........................... 144
Agregar un encabezado ............................................... .................................................. ............... 146
Añadir un encabezado de grupo / pie de página a la Lista ......................................... ............................ 147
Mostrar elementos de lista como elementos agrupados por separado ........................................... .................. 148
Añadir una casilla de verificación u otro accesorio a un elemento de cuadro de lista ....................................... .... 149
Añadir un icono a un elemento de cuadro de lista ........................................... .......................................... 150
Agregar información detallada a un elemento ............................................ .................................. 150
Ejecución de la aplicación ............................................... ............................................. 151
Embarcadero Technologies 5
Crear su aplicación ListBox .............................................. ....................................... 151
Agregar elementos a un cuadro de lista a partir del código .......................................... ........................... 151
Crear un menú de desbordamiento .............................................. .............................................. 154
Crear el controlador de eventos para el botón de desbordamiento .......................................... ...... 155
Añadir un cuadro de búsqueda .............................................. .................................................. ......... 156
Ejecución de la aplicación ............................................... ............................................. 157
Ver también ................................................ .................................................. .......................... 158
Tutorial móvil: Usando LiveBindings para rellenar un ListView (iOS y Android) ............ 159
Paso 1: Crear el proyecto ............................................ ................................................ 159
Paso 2: Añadir campos ............................................. .................................................. ........ 160
Paso 3: Creación de LiveBindings ............................................. ............................................ 161
Paso 4: Añadir más campos (mapas de bits, moneda) ....................................... ................... 164
Paso 5: Adición de la onButtonClick controlador de eventos .......................................... ............... 165
Los resultados ................................................ .................................................. ...................... 166
Ver también ................................................ .................................................. .......................... 167
Tutorial móvil: Usando LiveBindings rellenar un cuadro de lista en aplicaciones móviles (iOS y Android)
................................. .................................................. ............................................. 169
Paso 1: Crear el proyecto ............................................ ................................................ 169
Paso 2: Creación de los LiveBindings ............................................ ...................................... 171
Los resultados ................................................ .................................................. ...................... 174
Ver también ................................................ .................................................. .......................... 174
Tutorial móvil: Usar diseño de Ajuste forma diferente tamaños u orientaciones (iOS y Android)
... ..................... ........................................ . ............................................................................. . 175
Cada componente FireMonkey puede tener un propietario, un padre y niños ............ 175
El uso de propiedades de un componente FireMonkey ................. 175 relacionados con el diseño común
Utilizar la propiedad Align .............................................. ................................................ 175
El uso de los márgenes de la propiedad .............................................. ........................................... 177
Utilizar la propiedad Relleno .............................................. .......................................... 177
Utilizar la propiedad Anclas .............................................. ........................................... 178
Uso del componente TLayout .............................................. ......................................... 179
Ver también ................................................ .................................................. .......................... 179
Tutorial móvil: tomar y compartir una imagen y texto Sharing (iOS y Android) .... 181
Temas ................................................. .................................................. ............................. 184
Ver también ................................................ .................................................. .......................... 184
Tutorial móvil: Usando Ubicación Sensores (iOS y Android) ....................................... ..... 186
Diseñar la interfaz de usuario .............................................. .................................................. 187
La posición del sensor ............................................... .................................................. ........ 188
Leer información de ubicación (Latitud, Longitud) del Componente LocationSensor
.................... ........................................ . ............................................................................. . 189
Mostrar la ubicación actual Uso de Google Maps a través de un componente TWebBrowser ... 190 Uso de geocodificación
inversa ................................ .................................................. ................ 191
Mostrar una dirección de lectura mecánica en el componente ListBox .......................................... ....... 193
Al describir por qué su aplicación necesita la ubicación del usuario ........................................ 194
Ver también ................................................ .................................................. .......................... 194
Las muestras ................................................. .................................................. ...................... 194
Embarcadero Technologies 6
Tutorial móviles: El uso de Notificaciones (iOS y Android) ........................................ ........... 196
Tres de notificación o alerta estilos básicos ............................................ .............................. 196
Bandera de aviso en dispositivos móviles ............................................. ......................... 196
Los diálogos de alerta: IOS número de placa y número de notificaciones de Android ................... 197
El centro de notificaciones en dispositivos móviles ............................................. ............................. 197
Acceder al servicio de notificación .............................................. ......................................... 198
Añadir FMLocalNotificationPermission (IOS) ............................................. ........................ 199
Establecer el número de placa del icono y notificación Número de Código ............................ 199
Notificación horario ................................................ .................................................. ..... 201
Repetir un mensaje de notificación de .............................................. ......................................... 202
Actualizar o cancelar una notificación de mensajes programada o repetida ............................ 203
Presentar el mensaje de notificación Inmediatamente ............................................. ................ 204
Personalización del sonido de notificación .............................................. ................................ 205
Banner notificación o la notificación de alertas ............................................. .......................... 208
Añadir acción a la notificación de alertas (Sólo IOS) ........................................ .................... 209
Agregar acción de Notificaciones .............................................. ............................................... 211
Ejecutar la aplicación ............................................... .................................................. . 212
Ver también ................................................ .................................................. .......................... 212
Las muestras ................................................. .................................................. ...................... 212
Tutorial móvil: Usando el Marcador de teléfono en dispositivos móviles (iOS y Android) ........... 213
Acerca del teléfono Servicios del Marcador en dispositivos móviles .......................................... ......... 213
Acceder a los servicios de teléfono del Marcador ............................................. ................................. 213
El diseño de la interfaz de usuario .............................................. ............................................. 214
Obtener las propiedades del portador .............................................. ........................................... 215
Ejecutar la aplicación ............................................... ............................................... 215
Haciendo una llamada ............................................... .................................................. ................... 216
La detección de los cambios de estado de llamada ............................................. ..................................... 218
La aplicación de la Handler OnCallStateChanged Evento .......................................... 219
Ver también ................................................ .................................................. .......................... 221
Las muestras ................................................. .................................................. ...................... 222
Móviles Tutorial: Uso de notificaciones remotas (iOS y Android) ..................................... 223
Push Notification remota ............................................... ................................................. 223
RESTO marco BAAS ............................................... .................................................. .... 224
Temas en este tutorial móvil ............................................. ............................................. 224
Ver también ................................................ .................................................. .......................... 224
Ejemplos de código ................................................ .................................................. ............. 224
Tutorial móvil: Usando BaaS de backend de almacenamiento (iOS y Android) ............................ 225
Cómo hacer llegar su aplicación compatible en Kinvey y Parse .......................................... ...................... 226
Diseño y montaje de la interfaz de usuario .......................................... .............................. 226
Adición de los componentes Backend .............................................. ................................... 227
Creación y almacenamiento de objetos .............................................. ........................................... 228
Eliminar objetos ................................................ .................................................. ............ 229
Recuperando objetos ................................................ .................................................. .......... 231
Ejecución de la aplicación ............................................... ................................................. 234
Ver también ................................................ .................................................. .......................... 235
Embarcadero Technologies 7
Ejemplos de código ................................................ .................................................. ............. 235
Móviles Tutorial: Uso de FireDAC y SQLite (iOS y Android) ...................................... 236
Usando FireDAC para conectarse a la base de datos ........................................... ....................... 236
La creación de la base de datos utilizando el framework FireDAC ............................................ ............ 237
Diseño y configurar la interfaz de usuario ........................................... ................................. 239
Uso del Asistente LiveBindings .............................................. .......................................... 240
Añadir los componentes LiveBinding .............................................. ................................ 240
Conexión a los datos .............................................. ................................................. 241
Viendo ShopItem en el ListView ............................................. .............................. 243
Crear el controlador de eventos para que el botón Borrar visible cuando el usuario selecciona un elemento de la lista de
............................... .................................................. ............................ 244
Crear el controlador de eventos para el botón Agregar para añadir una entrada en la Lista .............. 245
Crear el controlador de eventos para el botón Eliminar para eliminar una entrada de la List249 Preparar la aplicación
de tiempo de ejecución ............................. ......................................... 250
Configuración de la implementación de la base de datos para móviles ........................................... ........... 250
Agregar y configurar su base de datos de archivos en el gestor de despliegue .................... 251
Modificar su código para conectarse a un archivo de base de datos local en el móvil ...................... 252
Especificación de la ubicación de la base de datos SQLite en el dispositivo móvil ................. 252
Creación de una tabla Si no existe ninguno ............................................ ....................................... 253
Ejecución de la aplicación en un simulador o en un dispositivo móvil ............................... 253
Ver también ................................................ .................................................. .......................... 255
Tutorial móvil: El uso de InterBase Togo con FireDAC (iOS y Android) ...................... 256
Usando FireDAC para conectarse a la base de datos ........................................... ....................... 257
Diseño y configurar la interfaz de usuario ........................................... ................................. 258
Conexión a los datos .............................................. .................................................. ... 258
Distribución de aplicaciones para móviles ............................................. .............................. 262
La implementación de InterBase Togo Archivos necesarios y el archivo de base a móvil ......... 262
Ejecutar la aplicación en un simulador o en un dispositivo móvil ....................................... 265
Solución de problemas ................................................. .................................................. ............ 266
Problemas InterBase ................................................ .................................................. .......... 266
Problemas de manejo de excepciones ............................................... ............................................ 266
Ver también ................................................ .................................................. .......................... 267
Las muestras ................................................. .................................................. ...................... 267
Tutorial móvil: Usando dbexpress y SQLite (iOS y Android) ................................... 268
Usando dbexpress para conectarse a la base de datos ........................................... ................... 269
La creación de la base de datos en el entorno Windows para fines de desarrollo .... 270
Crear la base de datos en el Explorador de datos ........................................... ...................... 270
Crear tabla en DataExplorer .............................................. ...................................... 271
Diseño y configurar la interfaz de usuario ........................................... ................................. 273
Conexión a los datos .............................................. .................................................. ... 274
Crear el controlador de eventos para que el botón Borrar visible cuando el usuario selecciona un elemento de la lista de
............................... .................................................. ............................ 275
Crear el controlador de eventos para el botón Agregar para añadir una entrada en la Lista .............. 277
Crear el controlador de eventos para el botón Eliminar para eliminar una entrada de la List281 Configuración de la base de
datos de despliegue para plataformas móviles ........................... .......... 282
Embarcadero Technologies 8
Agregar y configurar su base de datos de archivos en el gestor de despliegue .................... 283
Modificar su código para conectarse a un archivo de base de datos local en plataformas móviles ..... 284
Especificación de la ubicación de la base de datos SQLite en el dispositivo móvil ................. 284
Creación de una tabla Si no existe ninguno ............................................ ....................................... 284
Ejecución de la aplicación en un dispositivo móvil ........................................... ................... 285
Ver también ................................................ .................................................. .......................... 287
Tutorial móvil: El uso de InterBase Togo con dbexpress (iOS y Android) ................... 288
Usando dbexpress para conectarse a la base de datos ........................................... ................... 289
Diseño y configurar la interfaz de usuario ........................................... ................................. 290
Conexión a los datos .............................................. .................................................. ... 290
Distribución de aplicaciones para móviles ............................................. ............................. 293
Implementar InterBase Togo, dbExpress driver y el Archivo de Base de datos para móvil ....... 294
Modificar el código para conectarse a un archivo de base de datos local en el móvil ........................ 296
Ejecutar la aplicación en un simulador o en un dispositivo móvil ....................................... 297
Solución de problemas ................................................. .................................................. ............ 297
Problemas InterBase ................................................ .................................................. .......... 297
Problemas de manejo de excepciones ............................................... ............................................ 298
Ver también ................................................ .................................................. .......................... 298
Tutorial móvil: Conexión a una base de datos empresarial desde un cliente móvil (iOS y Android)
... ..................... ........................................ . ............................................................................. . 300
Creación de la etapa intermedia, un servidor DataSnap .......................................... ...................... 300
Crear una aplicación de servidor DataSnap VCL ............................................ ................... 301
Definir un conjunto de datos en el servidor DataSnap ........................................... ...................... 303
Exponer el conjunto de datos desde el servidor DataSnap ........................................... .............. 305
Ejecutar el servidor DataSnap .............................................. ............................................... 306
Creación de una aplicación móvil que se conecta al servidor DataSnap ...................... 306
Implementar la Biblioteca MIDAS al simulador de iOS ........................................... ....................... 309
Ejecutar la aplicación en la plataforma móvil ........................................... .................... 310
Ver también ................................................ .................................................. .......................... 310
Tutoriales móviles: Tabla de los componentes utilizados ........................................... ....................... 311
Embarcadero Technologies 9
Tutoriales móviles: Desarrollo de aplicaciones
móviles (iOS y Android)
Este conjunto integrado de tutoriales le guía a través del desarrollo de un Delphi o C ++ aplicación multi-dispositivo para iOS y
Android:
o Después de los tres tutoriales de configuración inicial, el primer tutorial que muestra cómo construir un IOS
o aplicación Android usando herramientas FireMonkey.
o Los tutoriales restantes demuestran los componentes FireMonkey recomendados para usar
con el fin de lograr un look-and-feel nativo en iOS y aplicaciones Android. Estos tutoriales móviles
Embarcadero Technologies 10
Preparar
Embarcadero Technologies 11
o El uso de un componente de botón con diferentes estilos (IOS y
Androide)
Embarcadero Technologies 12
o Usando LiveBindings para rellenar un ListView (iOS y Android)
Embarcadero Technologies 13
o Uso de Notificaciones (iOS y Android)
Embarcadero Technologies 14
Acceso a una base de datos
Ver también
Embarcadero Technologies 15
Tutorial móvil: Configurar el entorno de desarrollo en el
Mac (IOS)
Una aplicación FireMonkey Delphi destinado para la plataforma de destino iOS puede ser probado opcionalmente en el simulador de
iOS disponible en el Mac. aplicaciones FireMonkey C ++ y Delphi pueden ser probados usando el dispositivo iOS orientar la plataforma;
esta prueba requiere un dispositivo iOS de prueba conectada al Mac.
o La primera mitad de este tutorial se describen los pasos que debe llevar a cabo con el fin de ejecutar
su aplicación iOS (Delphi solamente) en el simulador de iOS en el Mac.
o La segunda mitad de este tutorial se describen los pasos adicionales necesarios para ejecutar su
aplicación iOS (Delphi o C ++) en su dispositivo iOS. Nota: los simulador de iOS no es compatible con BCCIOSARM,
el compilador ++ C para el dispositivo iOS . Sólo los dispositivos IOS están soportados por BCCIOSARM.
o 10.10 Yosemite
o 10.11 El Capitán
(Ni OS es compatible con los sistemas heredados y PowerPC Macintosh 680x0-basa Todos los Mac desde 2007 están basados en Intel;. Todas
las Mac desde el año 2008 son de 64 bits.)
o Para el desarrollo de iOS, la última versión del SDK de iOS y Xcode instalado, junto con
las herramientas de línea de comando Xcode .
Nota: RAD Studio no es compatible con versiones del SDK de iOS inferiores a 8,0.
o Un dispositivo iOS conectado al Mac por el puerto USB (requerido para la verificación o el funcionamiento de su
iOS aplicación en el dispositivo)
Para implementar una aplicación de iOS a su dispositivo con fines de depuración y prueba, el sistema debe tener la
configuración mostrada en la siguiente figura. RAD Studio se ejecuta en un ordenador PC con Windows. Este ordenador PC
está conectado a un Mac con el plataforma Auxiliar y teniendo
Para implementar una aplicación de iOS a la simulador de iOS en el Mac oa un dispositivo iOS, es necesario instalar las siguientes
herramientas en su Mac:
o Xcode
Xcode es el entorno de desarrollo y depuración en el Mac y proporciona los archivos de desarrollo necesarios
para OS X y iOS aplicaciones.
los plataforma Auxiliar debe estar ejecutando en el Mac al implementar una aplicación de iOS desde su PC a un simulador de
iOS o un dispositivo iOS. El instalador de OS X para el Asistente de plataforma se llama PAServer19.0.pkg y está disponible en dos
lugares:
http://altd.embarcadero.com/releases/studio/19.0/PAServer/PAServer19.0.pkg
Embarcadero Technologies 17
Para más detalles, véase Instalación del Asistente de plataforma en un Mac .
o bien pulse Regreso, o introduzca una contraseña para PAServer y pulse Retorno.
3. A continuación se le pedirá que introduzca su contraseña de usuario de Mac para permitir que el Asistente de Plataforma
de depurar (tomar el control de otro proceso) su aplicación.
Embarcadero Technologies 18
Introduzca su contraseña y seleccione Tomar el control:
Para más detalles sobre cómo ejecutar el Asistente de plataforma, véase Ejecución del Asistente de la plataforma en un Mac .
Xcode es el entorno de desarrollo y depuración en el Mac, y proporciona los archivos de desarrollo necesarios para OS
X y iOS aplicaciones. Puede instalar Xcode desde cualquiera de las siguientes fuentes:
o En su "Instalar OS X" de DVD, bajo Instalaciones opcionales, haga doble clic Xcode.mpkg a
instalar Xcode en su sistema.
o Como desarrollador de Apple registrado, puede descargar la última versión de Xcode como
paquete (. dmg). Para registrarse y luego descargar Xcode:
Embarcadero Technologies 19
Próximos pasos
Nota: Sólo las aplicaciones Delphi se pueden ejecutar en el simulador de iOS. C ++ Builder no admite el
simulador de iOS.
o simulador de iOS: Para ejecutar una aplicación iOS (Delphi solamente) en el simulador de iOS sobre el
Mac, no tiene que completar la segunda mitad de este tutorial. En cambio, ahora se puede pasar a la siguiente
tutorial ( Tutorial móvil: Configurar el entorno de desarrollo en PC con Windows (IOS) ) Para completar la
configuración de su IDE RAD Studio.
o iOS Dispositivo: Para ejecutar la aplicación iOS (ya sea Delphi o C ++ Builder) en su iOS
Dispositivo, por favor utilice los siguientes pasos de este tutorial para completar la configuración de su Mac. A
continuación, vaya al siguiente tutorial ( Tutorial móvil: Configurar el entorno de desarrollo en PC con Windows (IOS) )
Para completar la configuración de su IDE RAD Studio.
Los siguientes pasos adicionales que permiten ejecutar su aplicación iOS en su Dispositivo IOS.
Recuerde que su dispositivo iOS debe estar conectado a su Mac mediante un cable USB.
Embarcadero Technologies 20
Para asegurarse de que el herramientas de línea de comandos Xcode se instalan en tu Mac :
4. Sobre el Ubicación ventana, compruebe que la Herramientas de línea de comandos muestra el Xcode
versión (con el que se han instalado las herramientas de línea de comandos). Esto significa que las herramientas Xcode línea de
comandos ya están instalados y que no es necesario para instalarlos.
5. Si las herramientas Xcode de línea de comandos no están instalados, el Herramientas de línea de comandos no muestran la versión de
Xcode.
Embarcadero Technologies 21
3. Haga clic en el Instalar botón al lado de Herramientas de línea de comandos.
Se le pregunta por su desarrollador de inicio de sesión de Apple durante el proceso de instalación. Para más detalles, véase Instalación
desplegar aplicaciones para iOS. Siga los pasos descritos en el Unirse al Programa de Desarrolladores de Apple .
Para los equipos de desarrollo, certificados de desarrollo deben ser solicitados por cada miembro del equipo, y estas solicitudes deben ser
aprobadas por un administrador del equipo.
Embarcadero Technologies 22
ß Si usted es un miembro del equipo de desarrollo de un programa de empresa / organización, el administrador
del equipo tiene que aprobar su solicitud. Después de su administrador de equipo lo aprueba, se puede
descargar el certificado.
ß Si eres un desarrollador individual, debería ver una opción de descarga de su certificado, poco después de que
usted lo solicite. Consulte la documentación de Apple en: Guía de firma de código para detalles.
Guardar la solicitud de certificado como un archivo CSR, y luego enviarlo a la entidad de certificación a través de la portal de
aprovisionamiento iOS de la siguiente manera:
3. En la página que se abre, haga clic en el icono del signo más (+).
Esto abre la Agregar certificado iOS mago.
4. Sobre el Seleccione tipo página, haga clic Continuar y siga las instrucciones en pantalla para
continuar con el asistente.
2. Ir Portal de aprovisionamiento iOS . Puede descargar el certificado clic en el Desarrollo Descargar botón como se muestra
a continuación:
Embarcadero Technologies 23
Paso 4: Registrar un dispositivo para la implementación
Antes de que un dispositivo puede ejecutar aplicaciones de usuario, debe estar inscrito en el Portal de Aprovisionamiento de Apple . Dispositivos son
registrados por su ID de dispositivo único (UDID). El UDID se puede determinar usando Xcode, como sigue:
ß Si usted es parte de una empresa / organización, pida al administrador del equipo para registrar su dispositivo.
o Si usted es parte de una empresa / organización, sus administradores equipo debe crear una provisión
perfil que se puede utilizar.
Una vez creado el archivo de suministro, debe instalarlo en Xcode, de la siguiente manera:
Embarcadero Technologies 24
3. Haga clic en el más una tecla cantar añadir un archivo de suministro.
Para ejecutar la aplicación de iOS, consulte Tutorial móvil: Configurar el entorno de desarrollo en PC con Windows (IOS) y
completar la configuración de su IDE RAD Studio. (Si ha configurado su PC como parte de la gestión de su aplicación en
el simulador de iOS, puede omitir este paso).
Ver también
o Tutorial móvil: Creación de una aplicación para plataformas móviles (iOS y Android)
ß Crear un ID de Apple
Embarcadero Technologies 25
Tutorial móvil: Configurar el entorno de desarrollo en
PC con Windows (IOS)
Antes de comenzar este tutorial, usted debe leer y realizar la siguiente sesión de tutoría:
Una aplicación FireMonkey destinado para la plataforma de destino iOS puede ser probado inicialmente en el simulador de iOS disponible
en el Mac. El segundo medio del proceso de prueba utiliza la dispositivo iOS
plataforma de destino y requiere un dispositivo iOS de prueba conectada al Mac.
Nota: En los dispositivos iOS, puede ejecutar tanto aplicaciones C ++ y Delphi. sin embargo, el simulador de iOS no es compatible
con BCCIOSARM , De modo que sólo los dispositivos IOS son compatibles para C ++. Para implementar una aplicación iOS para su
dispositivo iOS o simulador de iOS para fines de depuración y prueba, RAD Studio utiliza el plataforma Auxiliar , Que se debe instalar
y correr en el Mac. Su entorno de desarrollo de hardware y software debe tener la configuración demostrada en la siguiente figura.
RAD Studio se ejecuta en un ordenador PC con Windows. El ordenador PC debe estar conectado a un Mac con el plataforma
Auxiliar y después de haber instalado las versiones adecuadas de Xcode y el IOS SDK (para el desarrollo de iOS). Para ejecutar
aplicaciones de iOS en un dispositivo iOS, el dispositivo iOS debe conectarse mediante un cable USB al Mac.
En esta sección se describen los pasos para configurar el entorno de desarrollo después configurar el entorno de su
Mac.
1. En el estudio IDE RAD, abierto Herramientas> Opciones> Opciones de entorno> Administrador de perfiles de conexión .
Embarcadero Technologies 26
3. A continuación aparece el Crear un perfil de conexión mago. Definir un nombre para la conexión
perfil, como "Mi Mac". Asegúrese de seleccionar OS X como la plataforma y, a continuación, haga
clic Siguiente:
Embarcadero Technologies 27
4. Sobre el información de la máquina remota página, establecer el nombre o la dirección IP de la máquina Mac,
un número de puerto a utilizar (el puerto predeterminado 64211 normalmente funciona), y una contraseña opcional (si se desea utilizar una
contraseña).
Embarcadero Technologies 28
5. Hacer clic Conexión de prueba, y asegúrese de que el perfil de conexión se realiza correctamente sin
de error (que debe recibir el mensaje " La conexión a <nombre de host> en el puerto <número de puerto>
tenido éxito ").
6. Si el Conexión de prueba tiene éxito, haga clic en el Terminar botón, pues comprobar los ajustes y vuelve a intentarlo.
Embarcadero Technologies 29
2. Hacer clic Añadir.
3. Sobre el Añadir un nuevo SDK cuadro de diálogo, seleccione iOS Device - 32 bit o iOS Device - 64 bit
como plataforma.
Embarcadero Technologies 30
4. Después de seleccionar una plataforma, el IDE llena un perfil (por ejemplo, "Mi Mac") y la versión del SDK
cuadro combinado con la lista de versiones de SDK disponibles en la máquina donde el servidor Asistente Plataforma se está
ejecutando:
6. Una vez finalizada la operación, haga clic Cerca para cerrar el diálogo.
Ver también
o Tutorial móvil: Creación de una aplicación para plataformas móviles (iOS y Android)
o Desarrollo de aplicaciones OS X
Embarcadero Technologies 31
ß El lanzamiento de su aplicación en dispositivos
ß iAd Red
Embarcadero Technologies 32
Tutorial móvil: Configurar el entorno de desarrollo en
PC con Windows (Android)
Durante el instalación RAD Studio , Las herramientas de desarrollo de Android necesarios están instalados y configurados en el
sistema. Nada más es necesario para iniciar el desarrollo de Android . Con el fin de ser capaz de ejecutar aplicaciones en un dispositivo
Ver también
o Tutorial móvil: Creación de una aplicación para plataformas móviles (iOS y Android)
Embarcadero Technologies 33
Tutorial móvil: Creación de una aplicación para
plataformas móviles (iOS y Android)
En este tema se describe cómo crear una aplicación "Hello World" multidispositivo (C ++ o Delphi), ya sea para el iOS o Android plataforma
de destino .
Para desarrollar aplicaciones móviles (Android iOS y) usando RAD Studio, es necesario completar algunos pasos de configuración
importantes. Este tutorial asume que ha completado todos los pasos de configuración necesarios. Para más detalles, véase:
Embarcadero Technologies 34
2. Seleccionar Aplicación en blanco. los Diseñador de formularios muestra una nueva forma:
1. Androide: Ver Configuración del sistema para detectar su dispositivo Android usar
un dispositivo Android.
Embarcadero Technologies 35
2. iOS: Si desea crear una iOS aplicación, abra el Plataforma de destino nodo en el
Gerente de proyecto y haga doble clic iOS Simulator ( sólo para Delphi) o un dispositivo iOS conectado (ya sea
para Delphi o C ++):
Nota: Al seleccionar una plataforma, los componentes que no están disponibles para esta plataforma en particular aparecen como no disponibles.
1. Seleccione ya sea iOS o Android a partir de la Estilo en el menú desplegable con el fin de definir la
vista maestra para mostrar todas las propiedades relacionadas con este estilo.
Le recomendamos que lea este tutorial antes de empezar a colocar componentes: Tutorial móvil: Usar diseño de Ajuste forma
diferente tamaños u orientaciones (iOS y Android) . El primer paso en la creación de una aplicación multi-dispositivo está
diseñando la interfaz de usuario. Hay muchos componentes reutilizables disponibles en el IDE para la creación de interfaces de
usuario.
1. Mover el puntero del ratón sobre la paleta de herramientas Y ampliar la Estándar por categoría
clic en el icono de signo más (+) junto al nombre de la categoría.
3. Repita estos pasos, pero ahora agregar una TLabel y una TButton componente al formulario.
6. Ahora debería ver tres componentes en el Diseñador de formularios . Aquí es una aplicación para iOS:
Embarcadero Technologies 36
7. Después de colocar estos componentes en el Diseñador de formularios , El IDE establece automáticamente los nombres de los
componentes.
Para ver o cambiar el nombre de un componente, haga clic en el componente en el Diseñador de formularios , Y luego encontrar su Nombre
propiedad en el Inspector de Objetos y el estructura Ver : Para TButton componente, el nombre del componente está configurado por
defecto para Botón 1 ( o Button2 Button3, dependiendo del número de TButtons que ha creado en esta solicitud).
Embarcadero Technologies 37
Nota: nombres de los formularios establecidos por defecto como Form1, Form2, Form3, ... son de la opinión Maestro. vistas de dispositivos se
denominan FormName_ViewName como Form1_iPhone ( iPhone 3,5” forma) y
Form1_NmXhdpiPh ( Android la forma del teléfono 4” ).
9. Puede cambiar fácilmente a código fuente mediante la selección de la código ( para Delphi) o < unidad
nombre> .cpp / <nombre de unidad> .h ( para la ficha C ++) en la parte inferior del Diseñador de formularios. También puede pulsar el F12 tecla
para cambiar entre el Diseñador de formularios y el Editor de código :
Delphi C ++
los Editor de código muestra el código fuente que el IDE ha generado. Usted debe encontrar tres componentes
definidos (Edit1, Label1 y Button1):
Embarcadero Technologies 38
Delphi C ++
Nota: Al guardar o ejecutar su proyecto, el usos y incluir cláusulas se actualizan (para añadir FMX.StdCtrls de TLabel y
para FMX.Edit TEdit ).
2. Seleccione las vistas disponibles que quiere añadir simplemente haciendo clic sobre ellos.
3. Vaya a la vista de hacer los cambios que desee incluir. Para añadir una vista personalizada, consulte Adición
El siguiente paso es definir un controlador de eventos Para el TButton componente. Se pueden definir los controladores de eventos para su
aplicación en la misma forma que defina controladores de eventos para plataformas de escritorio. Para el TButton componente, el caso más
típico es un clic de botón.
Haga doble clic en el botón en el Diseñador de formularios, y RAD Studio crea esqueleto de código que puede utilizar para implementar un
controlador de eventos para el evento de clic de botón:
Embarcadero Technologies 39
Delphi C ++
Ahora se puede implementar respuestas dentro de la Button1Click método. Los códigos siguientes fragmentos (Delphi y C ++)
implementar una respuesta que muestra un pequeño cuadro de diálogo, que dice "Hola + <nombre entró en el cuadro de
Código C ++:
En Delphi, las comillas que rodean los literales de cadena deben ser comillas simples rectas (es decir, ' cuerda'). Puede utilizar el
signo más (+) para concatenar cadenas. Si necesita una comilla simple dentro de una cadena, se pueden utilizar dos comillas
simples consecutivas dentro de una cadena, que produce una comilla simple.
Mientras que usted está escribiendo código, algunos consejos sobre herramientas aparecerá, indicando el tipo de parámetro es necesario especificar.
Los consejos sobre herramientas también muestran los tipos de miembros que se admiten en una clase determinada:
Delphi C ++
botón ( ) en el IDE, pulse F9, o seleccione Ejecutar> Ejecutar Del RAD Studio
menú principal:
Embarcadero Technologies 40
Delphi C ++
Si completa los pasos descritos en Tutorial móvil: Configurar el entorno de desarrollo en PC con Windows (Android) antes
de crear su nuevo proyecto, ahora se puede ejecutar su aplicación para Android en un dispositivo Android conectado a su PC
mediante un cable USB.
Embarcadero Technologies 41
Prueba de su IOS pruebas de aplicaciones en el
Por defecto, las aplicaciones Delphi FireMonkey IOS se ejecutan en el simulador de iOS plataforma de destino. Se puede confirmar la plataforma
de destino en el Gerente de proyecto :
Cuando se ejecuta la aplicación, que se implementa en el Mac y luego al simulador de iOS en el Mac. Para nuestra aplicación, se muestra
un formulario con un cuadro de edición y un botón. Introducir texto en el cuadro de edición y haga clic en el Di hola botón:
Nota: En los simuladores de iOS, se puede probar únicamente sus aplicaciones Delphi.
Embarcadero Technologies 42
Las pruebas en un dispositivo iOS conectado
Si completa los pasos descritos en Tutorial móvil: Configurar el entorno de desarrollo en el Mac (IOS) y Tutorial móvil:
Configurar el entorno de desarrollo en PC con Windows (IOS) antes de crear su nuevo proyecto, ahora se puede ejecutar su
aplicación para iOS en un dispositivo iOS conectado a su Mac mediante un cable USB. Para ejecutar la aplicación de iOS en un
dispositivo iOS conectado, primero seleccione el iOS Device - 32 bit o iOS Device - 64 bit orientar la plataforma de manera que el
Asistente Plataforma despliega la aplicación al conectado Dispositivo iOS:
Después de seleccionar la adecuada dispositivo iOS plataforma de destino, ejecute su aplicación para iOS haciendo clic en el
correr botón en el IDE, presionando F9 o seleccionar Ejecutar> Ejecutar .
En el Mac, es posible que aparezca un cuadro de diálogo pidiendo su permiso para firmar el código aplicación de iOS. Seleccione "Permitir siempre" o
"Permitir" para firmar su aplicación.
A continuación, vaya a su dispositivo iOS y espere a que aparezca su aplicación FireMonkey IOS. Ver la imagen de la puesta en marcha de FireMonkey
(el icono está disponible en $ (BDS) \ bin \ ilustraciones \ IOS, y se puede establecer la imagen lanzamiento en Opciones de aplicación ):
Ver también
o Tutorial móvil: El uso de un componente de botón con diferentes estilos (iOS y Android)
Embarcadero Technologies 43
o Desarrollo de aplicaciones móviles Android
o Desarrollo de aplicaciones OS X
Embarcadero Technologies 44
Tutorial móvil: El uso de una libreta de direcciones de
componentes (iOS y Android)
Antes de comenzar este tutorial, se recomienda que lea y realizar las siguientes tutoriales:
o Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (iOS y Android)
FireMonkey proporciona la TAddressBook componente para trabajar con libreta de direcciones en los dispositivos iOS y Android.
Este tutorial describe cómo crear una aplicación FireMonkey simple que utiliza el
TAddressBook componente.
iOS Androide
iphone 5
Embarcadero Technologies 45
Características básicas de los componentes TAddressBook
En las plataformas móviles (iOS y Android), apoya la FireMonkey TAddressBook componente que permite a las aplicaciones acceder a un
libro de direcciones del dispositivo. Las características básicas de este componente son los siguientes:
o El envío de una solicitud de acceso a un libro de direcciones del dispositivo y obtener el estado de acceso.
Esta sección le ayuda a desarrollar una aplicación de ejemplo (para plataformas de destino Android y iOS) que ilustra el
uso de la TAddressBook componente. La aplicación muestra las técnicas siguientes:
o Recuperando todos los contactos del defecto fuente en el libro de direcciones del dispositivo.
5. Sobre el Diseñador de formularios , botón derecho del ratón TListBox, y luego en el menú contextual, seleccione Añadir
Elemento> TSearchBox .
Embarcadero Technologies 46
6. En el paleta de herramientas , Selecciona el TMultiView componente, y soltarlo en el Diseñador de formularios .
o El Panel Master proporciona una forma para especificar y añadir un nuevo contacto a la libreta de direcciones.
Embarcadero Technologies 47
Después de realizar los pasos anteriores, su Diseñador de formularios será similar a la siguiente pantalla:
1. En el estructura Ver , seleccione MultiView1, y luego en el Inspector de Objetos , Especificar las siguientes propiedades:
2. En el paleta de herramientas , Seleccione tres TLabel componentes, tres TEdit componentes, y dos
TButton componentes, y caer al Multiview1.
3. En el Inspector de Objetos , Especifique las siguientes propiedades de los elementos de control que ha colocado en MultiView1:
Embarcadero Technologies 48
ß por Botón 1 y button2:
Le recomendamos que organizar los elementos de control del panel principal de la siguiente manera:
En esta sección se explica cómo recuperar la lista de contactos de la fuente por defecto en un libro de direcciones del dispositivo.
Delphi:
privado
{} declaraciones privadas
Embarcadero Technologies 49
procedimiento FillContactList;
AddListBoxItem procedimiento (Contacto: TAddressBookContact);
C ++ Builder:
Delphi:
Contactos);
ListBox1.BeginUpdate; tratar ListBox1.Clear;
ListBox1.EndUpdate; fin;
finalmente
empezar
C ++ Builder:
// Llenar el cuadro de lista con los nombres de visualización de contacto existido. anulará
__fastcall TForm1 :: FillContactsList () {
Embarcadero Technologies 50
int i;
TAddressBookContacts * Contactos = new TAddressBookContacts (); __tratar { AddressBook1-> AllContacts (AddressBook1->
} __finalmente {
__finalmente {
Contactos-> Libre (); }
__tratar {
Para completar el desarrollo de la aplicación, se debe implementar controladores de eventos para todos los elementos de control que se
le ha caído en el formulario de solicitud.
1. Sobre el Diseñador de formularios , Haga doble clic en un botón de velocidad ( btnRefresh o btnRemove).
2. En el Editor de código , Especifique los siguientes controladores de eventos para cada botón:
Delphi:
// ------------------- Para botón Quitar -------------------------- --------------- procedimiento TForm1.btnRemoveClick (Sender: TObject); var ContactIndex,
ContactID: Integer;
Embarcadero Technologies 51
ContactID: = ListBox1.ListItems [ContactIndex] .Tag; Contacto: =
AddressBook1.ContactByID (Contact ID); Si los contactos <> nil entonces
ListBox1.BeginUpdate;
ListBox1.Items.Delete (ContactIndex); finalmente
ListBox1.EndUpdate;
Contact.Free; fin; fin; fin;
// ------------------- Para botón Actualizar -------------------------- ------------- procedimiento TForm1.btnRefreshClick (Sender: TObject);
empezar
FillContactsList; fin;
C ++ Builder:
// ------------------- Para botón Quitar -------------------------- --------------- // Eliminar el contacto seleccionado de la lista de cuadro vacío
__fastcall TForm1 :: btnRemoveClick (TObject * remitente) {
int Contact ID = ListBox1-> ListItems [ContactIndex] -> Tag; TAddressBookContact * Contacto = AddressBook1->
ContactByID (Contact ID); si (Contacto! = NULL) {
(ContactIndex); } __finalmente {
} // -------------------------- Para botón Actualizar ------------------ ------------------- __fastcall vacío TForm1 :: btnRefreshClick (TObject * remitente) {
FillContactsList (); }
Para implementar los controladores de eventos onClick para los botones del panel principal:
3. En el panel principal, haga doble clic en el Añadir botón y, a continuación, aplicar el siguiente
controlador de eventos:
Embarcadero Technologies 52
ß por Delphi:
TContactAddresses; empezar
edtFirstName.Text;
Contact.LastName: = edtLastName.Text; // Añadir los correos electrónico de trabajo: = TContactEmails.Create;
tratar eMails.AddEmail (TContactEmail.TLabelKind.Work, edtWorkMail.Text);
ListBox1.EndUpdate; fin;
finalmente
Contact.Free; fin;
MultiView1.HideMaster; fin;
ß por C ++:
// Añadir un contacto recién creado a libreta de direcciones sin efecto __fastcall TForm1 ::
btnOKClick (TObject * Remitente) {
Embarcadero Technologies 53
__finalmente {
eMails-> Libre (); } AddressBook1->
();
AddListBoxItem (Contacto); } __finalmente
{
ListBox1-> EndUpdate (); }} __finalmente
HideMaster (); }
4. En el panel principal, haga doble clic en el Cancelar botón y, a continuación, aplicar el siguiente
controlador de eventos:
ß por Delphi:
edtFirstName.Text: = '';
edtLastName.Text: = ''; edtWorkMail.Text:
= ''; MultiView1.HideMaster; fin;
ß por C ++:
Tal vez algunas herramientas de terceros realizar cambios en una libreta de direcciones del dispositivo cuando se ejecuta la aplicación. En
este escenario, es importante para mantener la información sincronizada entre el libro de direcciones del dispositivo y la instancia de la libreta
de direcciones con las que su aplicación está trabajando directamente. Para este fin, proporciona la FireMonkey
TAddressBook.RevertCurrentChangesAndUpdate método.
Embarcadero Technologies 54
Para mantener la sincronización de libreta de direcciones
2. Haga doble clic al lado OnExternalChange, y luego poner en práctica el siguiente evento
entrenador de animales:
ß por Delphi:
ß por C ++:
antes de utilizar TAddressBook , Su aplicación debe solicitar un permiso para acceder a la libreta de direcciones en un
dispositivo móvil de destino.
Esta sección proporciona los pasos para configurar sus aplicaciones para Android e iOS para acceder a la libreta de direcciones en los
dispositivos móviles de destino.
2. Haga doble clic al lado en el programa, y luego poner en práctica el siguiente controlador de eventos:
ß por Delphi:
Embarcadero Technologies 55
ß por C ++:
TDialogService :: ShowMessage
Delphi:
usos
FMX.DialogService;
C ++:
# incluir <FMX.DialogService.hpp>
4. Haga doble clic al lado OnPermissionRequest, y luego poner en práctica el siguiente evento
entrenador de animales:
ß por Delphi:
Si a continuación, AAccessGranted
Empezar
FillContactlist; Fin
más
ShowMessage ( 'No se puede tener acceso a la Libreta de direcciones Motivo:'. + UnMensaje);
fin;
ß por C ++:
Embarcadero Technologies 56
vacío __fastcall TForm1 :: AddressBook1PermissionRequest (TObject * ASender,
const UnicodeString unMensaje, const int AAccessGranted) {if (AAccessGranted) {
}}
Antes de ejecutar aplicaciones Android que utilizan el TAddressBook componente, es necesario configurar algunos utiliza
permisos para su proyecto.
ß Obtener cuentas
ß contactos escribir
1. En el Gerente de proyecto , Seleccionar la plataforma de destino (con el apoyo de plataformas: Android o iOS).
Importante: Antes de ejecutar esta aplicación en los dispositivos Android, asegúrese de que ha completado los pasos de Configuración
de aplicaciones de Android para acceder a la libreta de direcciones .
2. prensa Shift + Ctrl + F9 para ejecutar la aplicación sin depurar. Para probar la
Embarcadero Technologies 57
Para eliminar un contacto
Embarcadero Technologies 58
Ver también
o TAddressBook
o Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (iOS y Android)
Ejemplos de código
Embarcadero Technologies 59
Tutorial móvil: Uso de un botón
Componente con diferentes estilos (iOS y Android)
Los siguientes son algunos ejemplos de diferentes estilos con componentes de botón disponibles para su uso en diferentes partes
de la interfaz de usuario de la aplicación:
iOS Androide
Embarcadero Technologies 60
iOS Androide
Seleccione un componente (en este caso, un botón), a continuación, busque y cambie el valor de algunas propiedades de la siguiente manera:
o Cambiar el texto que aparece en la superficie botón mediante la actualización del valor de la Texto
propiedad en el Inspector de Objetos .
o Haga clic en la flecha hacia abajo en el StyleLookup propiedad. En el StyleLookup En la lista desplegable, puede seleccionar
Embarcadero Technologies 61
o Para crear un botón de color, cambiar los valores de la tintColor y IconTintColor
propiedades. Esta última propiedad sólo está disponible para los botones de estilo con iconos. La siguiente sección proporciona
más detalles sobre el uso de tintColor y IconTintColor.
por TButton y TSpeedButton , FireMonkey proporciona dos propiedades que determinan cómo teñir o colorear el botón:
Embarcadero Technologies 62
Nota: los tintColor y IconTintColor propiedades sólo están disponibles en el
Inspector de Objetos si selecciona un estilo adecuado para el botón y seleccione una vista adecuada en el Diseñador de
formularios (Estas propiedades no son visibles en todos Puntos de vista). Para la plataforma de destino Android:
o Para los botones de velocidad, es necesario seleccionar un valor StyleLookup adecuada con el fin de cambiar
el tintColor valor en el inspector de objetos.
o Modificar tintColor y IconTintColor, elegir un dispositivo Android desde el Puntos de vista lista
en la parte superior derecha del diseñador de formularios.
o FireMonkey proporciona botones que corresponden a la Guía de estilo de manzana , Y algunos botones no sean compatibles
con la función de tinte.
o Por ejemplo, en IOS, botones segmentados tienen la tintColor propiedad. Cuando se cambia el StyleLookup propiedad
de un botón, el Inspector de Objetos Muestra u oculta la automáticamente tintColor y IconTintColor propiedades como
apropiado para el
StyleLookup El valor de la propiedad. La siguiente imagen muestra tres TSpeedButtons en una aplicación para Android:
Embarcadero Technologies 63
Usando diseñadas y coloreadas botones de Plataformas de destino
Para obtener información sobre la disponibilidad de la StyleLookup , tintColor y IconTintColor propiedades de botones en todas las plataformas
de destino, ver este cuadro resumen: Usando diseñadas y coloreadas botones de Plataformas de destino .
Ahora en FireMonkey, una TStyleBook componente es una colección de estilos para diferentes plataformas de destino. Usted puede crear
sus estilos personalizados de un solo botón o para una clase de control conjunto ( TButton o TSpeedButton ).
2. Sobre el Diseñador de formularios , Haga clic en un botón de velocidad botón o, a continuación, elija en el menú contextual uno de los siguientes
elementos:
ß Editar estilo personalizado: se abre la FireMonkey estilo del diseñador para editar los estilos de
botón seleccionado.
ß Editar estilo por defecto: se abre la FireMonkey estilo del diseñador para editar los estilos de
la clase de control seleccionada (tal como TButton o TSpeedButton ).
Para obtener más información acerca de trabajar con estilos personalizados, consulte los siguientes temas:
o Editor BitmapLinks
RAD Studio le permite poner fácilmente imágenes personalizadas en componentes de botón en tiempo de diseño.
Embarcadero Technologies 64
Para colocar una imagen sobre un botón:
3. En el estructura Ver , Seleccione el botón, expanda el Imagen nodo y, a continuación, haga clic 0 - Empty (1.000).
4. En el Inspector de Objetos , Haga clic en el botón de puntos suspensivos (...) junto a Mapa de bits.
iOS Androide
iOS Androide
iOS Androide
iOS Androide
iOS Androide
Embarcadero Technologies 66
iOS Androide
8. Para especificar que uno de estos componentes es que aparezca como Presionado por defecto, establecer el
Se presiona propiedad de un componente a Cierto:
iOS Androide
Se puede definir un control segmentado en una barra de herramientas; Esto también se conoce como una Ámbito de bar, un control segmentado
que se puede utilizar para controlar el ámbito de una búsqueda.
Usa los mismos controles TSpeedButton como en los pasos anteriores, pero con los siguientes valores para la StyleLookup propiedad
(sólo disponible en la plataforma de destino IOS):
o toolbuttonleft
o toolbuttonmiddle
o toolbuttonright
(En el conjunto de plataforma de destino Android StyleLookup como Botón de herramienta para cada uno de los botones).
Embarcadero Technologies 67
iOS Androide
o El estilo de TSpeedButton puede ser diferente que el estilo de TButton . Por ejemplo, en la plataforma Android, el estilo por
defecto de la TSpeedButton es similar a la Botón de herramienta
estilo de la TButton . Si quieres una TSpeedButton con un estilo similar al de la TButton , elegir el ButtonStyle
estilo.
Ver también
o Tutorial móvil: Creación de una aplicación para plataformas móviles (iOS y Android)
o Tutorial móvil: Utilizar un componente de calendario para seleccionar una fecha (iOS y Android)
o Muestra FMX.Controls
o FMX.StdCtrls.TButton
o FMX.StdCtrls.TSpeedButton
o FMX.Controls.TStyledControl.StyleLookup
o FMX.StdCtrls.TToolBar
o FMX.StdCtrls.TCustomButton.IconTintColor
o FMX.StdCtrls.TCustomButton.TintColor
o FMX.StdCtrls.TToolBar.TintColor
Embarcadero Technologies 68
Tutorial móvil: Utilizar un componente de calendario
para seleccionar una fecha (iOS y Android)
ios 7 Androide
Ipad 2
LG-E612
Nota: los TCalendarEdit componente utilizado en RAD Studio XE5 o anterior está en desuso. Utilizar el TDateEdit
componente en su lugar.
en el buscador ( ):
Embarcadero Technologies 69
Después se le cae el componente, se puede ver la TDateEdit componente en el Diseñador de formularios:
ß ShowCheckBox : cuando cierto, muestra una casilla de verificación en la TDateEdit controlar. Esta
casilla de verificación permite activar / desactivar el TDateEdit el control en tiempo de ejecución.
Embarcadero Technologies 70
iOS6 (iPhone5) Android (LG-E612)
Después de que el usuario cambia la fecha, la AlCambiar evento se dispara. Se puede implementar un controlador de eventos para el AlCambiar evento
para reaccionar a la acción del usuario.
2. En el Inspector de Objetos , abre el Eventos página, y haga doble clic en el espacio vacío al lado de AlCambiar.
Delphi:
C ++ Builder:
Embarcadero Technologies 71
vacío __fastcall TForm25 :: DateEdit1Change (TObject * Remitente) {
Este código muestra un cuadro de diálogo de mensaje con una fecha seleccionada. los FormatDateTime función convierte la fecha seleccionada en un
formato especificado (en este caso dddddd da formato de fecha al estilo de largo):
Ver también
o Tutorial móvil: El uso de un componente de botón con diferentes estilos (iOS y Android)
o Tutorial móvil: Usando Combo componentes de la caja para recoger cosas de una lista (IOS y
Androide)
o FMX.DateTimeCtrls.TDateEdit
Embarcadero Technologies 72
Las muestras
Embarcadero Technologies 73
Tutorial móvil: Usando Combo componentes de la caja para
recoger cosas de una lista (iOS y Android)
iOS Androide
Embarcadero Technologies 74
3. Después se le cae el componente, se puede ver el componente TComboBox en el Formulario
Diseñador. Haga clic con el TComboBox del componente y seleccione Los productos editor ...:
Embarcadero Technologies 75
7. Editar otros elementos, así, como Alaska, Arizona, Arkansas, California, Colorado, y por lo
adelante.
11. Ejecutar la aplicación en la plataforma de destino elegido móvil (simulador de iOS (para Delphi
solamente), iOS Device, o Dispositivo Android). Después de tocar una TComboBox , Aparece el control Selector, y se puede
seleccionar un elemento.
Para crear una lista de artículos que utilizan código, debería poner en práctica el onFormCreate controlador de eventos de la siguiente manera:
Delphi:
Embarcadero Technologies 76
C ++ Builder:
Para mostrar la lista con el quinto elemento seleccionado ( "California"), especifique ItemIndex para ComboBox1 de la siguiente manera:
Delphi:
C ++ Builder:
vacío __fastcall TForm1 :: FormCreate (TObject * Remitente) {// Índice del quinto
elemento es "4"
ComboBox1-> ItemIndex = 4; ComboBox2-> Productos->
Añadir ( "Tiger"); ComboBox2-> Productos-> Añadir ( "gato");
ComboBox2-> Productos-> Añadir ( "pingüino"); ComboBox2->
Productos-> Añadir ( "abeja"); // Otros animales se pueden
enumerar aquí ComboBox2-> Productos-> Añadir ( "elefante");
ComboBox2-> Productos-> Añadir ( "León"); }
Embarcadero Technologies 77
Si usted no sabe el valor del índice, se puede encontrar el valor mediante el uso de la Índice de método. Para mostrar la ComboBox2
con el artículo cuyo texto es 'Penguin' seleccionado, añada la línea siguiente al código anterior:
Delphi:
C ++ Builder:
Después de que el usuario selecciona un elemento, el AlCambiar evento se dispara. Para responder a la acción del usuario, se puede implementar un
controlador de eventos para el evento OnChange.
Nota: Antes de continuar con este escenario, realice los siguientes pasos:
2. En el Inspector de Objetos , abre el Eventos página, y haga doble clic en el espacio vacío al lado de AlCambiar.
Delphi:
C ++ Builder:
Embarcadero Technologies 78
Este controlador de eventos muestra un diálogo de mensaje que indica el elemento seleccionado. En el código de Delphi, el Formato función
devuelve una cadena con formato montado a partir de una cadena de formato y una serie de argumentos:
Ver también
o Tutorial móvil: Utilizar un componente de calendario para seleccionar una fecha (iOS y Android)
o Tutorial móvil: Utilización de componentes de la ficha para mostrar las páginas (iOS y Android)
o Desarrollo de aplicaciones OS X
Embarcadero Technologies 79
Las muestras
Embarcadero Technologies 80
Tutorial móvil: El uso de un componente de mapa para
trabajar con mapas (iOS y Android)
FireMonkey envuelve un componente de mapa como TMapView . Este componente proporciona acceso a las API de mapas que dependen de
la plataforma de destino de la siguiente manera:
Este tutorial describe cómo crear una aplicación FireMonkey simple que utiliza el TMapView
componente.
iOS Androide
Protectores
los TMapView componente añade mapas interactivos a sus aplicaciones móviles. Las características básicas de este
componente son los siguientes:
Embarcadero Technologies 81
o Cuatro tipos de mapas: Normal, satélite, híbrido, y (para Android solamente) Terreno
o Controlar el mapa: Capacidad para controlar las propiedades de mapa, como el centro del mapa
coordina, la orientación del mapa, etc.
Esta sección le ayuda a desarrollar una aplicación de ejemplo (para plataformas de destino Android y iOS) que ilustra
el uso de la TMapView componente. La aplicación muestra las técnicas siguientes:
o Al girar el mapa
Antes de usar Google Maps, asegúrese de que tiene una API de Google Maps para Android clave (libremente disponible). Sin esta
clave en su lugar, su aplicación de mapas generará un error en tiempo de ejecución. También es necesario configurar algunas permisos y
opciones de proyectos para su aplicación. Para obtener instrucciones detalladas sobre cómo configurar la aplicación, consulte Configuración
5. En el Inspector de Objetos , selecciona el Alinear propiedades de las barras de herramientas a Parte superior y Fondo,
respectivamente.
Embarcadero Technologies 82
El diseño de las barras de herramientas de aplicación
Coloque todos los elementos de control sobre las barras de herramientas. La aplicación utiliza dos barras de herramientas (Una barra de herramientas superior,
y una barra de herramientas inferior).
o En el paleta de herramientas , Seleccione los siguientes componentes y los deje caer sobre la barra de herramientas superior:
ß Dos TEdit componentes: le permiten establecer las coordenadas del centro del mapa (latitud
y longitud).
ß TButton : Actualiza el mapa con el centro del mapa actual coordina. Para especificar las propiedades
3. En el paleta de herramientas , Seleccione tres TSpeedButton componentes y agregarlos como elementos secundarios de Layout1.
Después de realizar los pasos anteriores, su Diseñador de formularios será similar a la siguiente pantalla:
Embarcadero Technologies 83
Implementación del Control de Elementos Funcionalidad
Para completar el desarrollo de la aplicación, se debe implementar controladores de eventos para todos los elementos de control que se le ha
caído en las barras de herramientas.
1. Sobre el Diseñador de formularios , Haga doble clic en un botón de velocidad ( Normal, satélite, y Híbrido).
2. En el Editor de código , Especifique los siguientes controladores de eventos para cada botón:
Delphi:
MapView1.MapType: = TMapType.Normal;
TrackBar1.Value: = 0,0; fin;
MapView1.MapType: = TMapType.Satellite;
TrackBar1.Value: = 0,0; fin;
Embarcadero Technologies 84
procedimiento TForm1.SpeedButton3Click (Sender: TObject); empezar
MapView1.MapType: = TMapType.Hybrid;
TrackBar1.Value: = 0,0; fin;
C ++ Builder:
- -
- -
Valor = 0,0; }
2. En el Inspector de Objetos , abre el Eventos pestaña, y luego haga doble clic al lado onChange.
Especifique el siguiente código:
Delphi:
C ++ Builder:
Embarcadero Technologies 85
1. Sobre el Diseñador de formularios , Haga doble clic en el Ir botón.
Delphi:
TMapCoordinate; empezar
C ++ Builder:
Los marcadores identifican ubicaciones en el mapa. Si desea agregar marcadores al mapa, se puede implementar el OnMapClick
controlador de eventos para el mapa de la siguiente manera.
2. En el Inspector de Objetos , abre el Eventos pestaña, y haga doble clic al lado OnMapClick.
Delphi:
TMapMarkerDescriptor; empezar
C ++ Builder:
Embarcadero Technologies 86
vacío __fastcall TForm1 :: MapView1MapClick (const TMapCoordinate y posición) {
TMapMarkerDescriptor myMarker = TMapMarkerDescriptor :: Create ( "MyMarker" Posición,);
1. En el Gerente de proyecto , Seleccionar la plataforma de destino (con el apoyo de plataformas: Android o iOS).
Importante: Antes de ejecutar esta aplicación en los dispositivos Android, asegúrese de que ha completado los pasos
de Configuración de aplicaciones de Android para usar Google Maps .
2. prensa Shift + Ctrl + F9 para ejecutar la aplicación sin depurar. Para probar la
2. Especifique el nuevo centro del mapa (por defecto el centro del mapa es (0.0, 0.0)):
4. Toca el elemento de barra de la pista, y luego mover el indicador de deslizamiento arrastrándolo a una
Ubicación particular. [ Esto cambia la orientación del mapa (cojinete). La orientación del mapa es la dirección en la que una
línea vertical en los puntos del mapa, medida en grados en sentido horario desde el norte.]
Embarcadero Technologies 87
iOS Androide
Protectores
Ver también
o TMapView
Ejemplos de código
o Muestra un mapa
Embarcadero Technologies 88
Tutorial móvil: Utilizar un componente MultiView a la
pantalla alternativa Vistas de la Información (iOS y
Android)
o los panel principal puede mostrar una colección de controles visuales, tales como cuadros de edición,
etiquetas, listas, y así sucesivamente.
o los panel de detalles típicamente muestra información sobre la base de las propiedades de los controles en
el panel principal.
La pantalla siguiente ilustra un ejemplo de interfaz maestro-detalle. En el panel principal (el panel de Acoplado a la izquierda), se introduce una
posición geográfica y, a continuación, haga clic en Buscar para hacer que el panel de detalles (panel derecho) para visualizar el mapa de
Google adecuado.
Embarcadero Technologies 89
Maestro panel de presentación Modos
los TMultiView clase define un conjunto de propiedades que le permiten controlar el comportamiento de la interfaz. Por ejemplo, el TMultiView.Mode
propiedad especifica el modo de presentación de panel principal como se describe en la siguiente tabla:
Embarcadero Technologies 90
TMultiView.Mode Maestro panel de presentación
En el modo de cajón , el panel principal puede ser si oculta o se puede deslizar para solapar el panel de
Cajón
detalles .
Una aplicación selecciona automáticamente el modo de presentación de panel principal. ver el Plataforma Modo de
PlatformBehaviour
comportamiento dependiente subsección.
El usuario puede personalizar la presentación panel principal. La clase de presentación personalizada se debe
Personalizado establecer en el CustomPresentationClass propiedad. ver el Modo personalizado subsección.
Nota: En tiempo de diseño, después de cambiar el TMultiView.Mode valor de la propiedad en el Inspector de Objetos , El
panel principal podría llegar a ser invisible. Para solucionar este problema, en el Diseñador de formularios , Selecciona el TMultiView
componente y, a continuación, en el Inspector de Objetos , selecciona el Visible propiedad a Cierto.
Modo cajón
Embarcadero Technologies 91
Modo popover
También puede establecer la TMultiView.Mode propiedad a popover para hacer que el panel principal de un menú emergente que
aparece junto al botón master especificado en el TMultiView.MasterButton
propiedad.
Embarcadero Technologies 92
Importante: En el modo de Popover, debe establecer el TMultiView.MasterButton
propiedad. Esta propiedad se refiere a un elemento de interfaz de usuario que muestra u oculta el panel principal. En la
pantalla anterior, el botón principal es la Mostrar ocultar botón.
Si se establece el TMultiView.Mode propiedad a Panel de navegación, el panel principal se muestra inicialmente como un panel
acoplado minimizado. Se puede controlar la anchura inicial de este panel con el
CollapsedWidth propiedad (por defecto, CollapsedWidth = 50).
Embarcadero Technologies 93
Propina Para recortar cualquier parte de los elementos secundarios movidos fuera del panel de exploración
minimizado, establecer el TMultiview.ClipChildren propiedad a Cierto.
Para expandir el panel de navegación para mostrar todos los controles secundarios, pulse el botón master especificado en el TMultiView.MasterButton
propiedad.
Embarcadero Technologies 94
Panel de navegación ampliado
Embarcadero Technologies 95
colapsa o expande el panel principal. En la pantalla anterior, el botón Master es
el
Puede dejar que la aplicación selecciona automáticamente el modo de presentación de panel principal, si el
TMultiView.Mode propiedad se establece en PlatformBehaviour. Para esta configuración, el comportamiento de la aplicación depende
del tipo de dispositivo y la orientación, como se describe en la siguiente tabla:
Modo personalizado
En el modo personalizado, puede personalizar la presentación panel maestro para cumplir con sus tareas. Para personalizar la
presentación panel principal, realice los siguientes pasos básicos:
2. En el MyPresentationClass, opcionalmente, anular los siguientes métodos virtuales definidos en la clase base:
ß DoOpen
ß DoClose
ß GetDisplayName
ß DoInstall
ß DoUninstall
Estos métodos definen el comportamiento panel principal.
ß por Delphi:
MultiView1.CustomPresentationClass: = MyPresentationClass;
Embarcadero Technologies 96
fin;
ß por C ++:
Este tema le ayuda a desarrollar una sencilla aplicación que ilustra el uso de la TMultiView
componente.
3. Caída de otros controles, como botones, cuadros de edición o cualquier otro control que necesita sobre la
recipiente MultiView.
4. En el paleta de herramientas , Seleccione un componente que desea utilizar como un panel de detalles (por ejemplo,
TPanel ), Y soltar los controles en este panel.
Para aclarar este procedimiento, las siguientes secciones consideran un ejemplo particular: una aplicación que controla la cámara
del dispositivo móvil.
Embarcadero Technologies 97
4. Caída de dos TButton componentes en el TMultiview recipiente y, a continuación, en el Objeto
Inspector especificar las siguientes propiedades de los botones:
ß name = imgCameraView
ß align = Cliente
Propina: Ponga todos los elementos del panel de detalles en un recipiente único (una TPanel
componente en nuestro ejemplo). Este recipiente debe ser especificado en el
TMultiView.TargetControl propiedad.
Para completar el desarrollo de la aplicación, se debe implementar controladores de eventos para los botones de aplicación y la Obtener
la imagen método privado que obtiene una imagen de la cámara del dispositivo.
1. Sobre el Diseñador de formularios , Haga doble clic en el iniciar la cámara botón, e inserte el siguiente
código:
ß por Delphi:
Embarcadero Technologies 98
procedimiento TForm1.bStartCameraClick (Sender: TObject); empezar
ß por C ++:
Activo = true; }
ß por Delphi:
ß por C ++:
Activo = false; }
ß por Delphi:
CameraComponent1.Active: = false;
CameraComponent1.Kind: = FMX.Media.TCameraKind.FrontCamera; CameraComponent1.Active: =
true; fin;
ß por C ++:
Embarcadero Technologies 99
}
ß por Delphi:
CameraComponent1.Active: = false;
CameraComponent1.Kind: = FMX.Media.TCameraKind.BackCamera; CameraComponent1.Active:
= true; fin;
ß por C ++:
ß por Delphi:
ß por C ++:
Para el TForm1 clase, se debe implementar el método privado Obtener la imagen. El controlador de eventos
onSampleBufferReady llama a este método para obtener la imagen de la cámara del dispositivo.
Haz lo siguiente:
ß por Delphi:
privado
{} Declaraciones privadas procedimiento
GetImage;
ß por C ++:
ß por Delphi:
ß por C ++:
En el Diseñador de formularios, seleccione la TMultiView componente y, a continuación, en el Inspector de Objetos , Establezca las propiedades siguientes:
o TargetControl = O panel1 Modo = cajón o Visible = verdadera o Ampliar la DrawerOptions nodo, y establecer el Modo propiedad
a OverlapDetailView. o Ampliar la ShadowOptions nodo, y establecer el Color propiedad a Beige. ( Esta propiedad
define el color de la sombra del panel principal. Se puede utilizar cualquier color disponible.)
1. En el Gerente de proyecto , Seleccionar la plataforma de destino (con el apoyo de plataformas: Android o iOS).
3. Para abrir el panel principal, desliza desde el borde izquierdo de la pantalla del dispositivo.
4. Para activar la cámara del dispositivo, en el panel principal, haga clic Iniciar la cámara.
5. Opcionalmente, se puede seleccionar la cámara delantera o trasera (si está disponible) mediante el uso de la Frente o
Espalda botón, respectivamente.
Ver también
o FMX.MultiView.TMultiView
o FMX.MultiView.TMultiViewPresentation
FireMonkey envuelve el componente navegador web como el TWebBrowser componente. Puedes usar
TWebBrowser en las aplicaciones de escritorio, así como aplicaciones móviles, pero este tema se describe cómo crear una sencilla aplicación de
navegador Web FireMonkey para las plataformas iOS y Android.
Encontrar TToolBar, introducir unos pocos caracteres (como "herramienta") en el Buscar cuadro de la paleta de herramientas:
5. Selecciona el TButton componente en el Diseñador de formularios, y luego en el Inspector de Objetos , selecciona el StyleLookup propiedad
a priortoolbutton.
ß los priortoolbutton valor para StyleLookup TButton añade una etiqueta de botón Volver.
ß Para más detalles sobre la selección de un estilo en aplicaciones multi-dispositivo, consulte Móvil
Tutorial: Utilizar un componente de botón con diferentes estilos (iOS y Android) .
Para obtener más información sobre cómo seleccionar el tipo de teclado virtual más adecuado en plataformas móviles, consulte Selección
del teclado virtual apropiado para el navegador web de aplicaciones .
Después de completar estos pasos, la forma debe ser similar a la siguiente imagen:
Escribir un controlador de eventos para abrir una página Web cuando el usuario cambia la
dirección URL en el control de edición
A diferencia de las plataformas de escritorio, las plataformas móviles usar el teclado virtual para introducir texto como en las siguientes
imágenes. El usuario puede completar la acción haciendo clic en "Done".
Protectores
FireMonkey ofrece muchos tipos de controladores de eventos para cubrir la mayoría de las acciones de los usuarios. Después se
selecciona el botón "Hecho", el marco FireMonkey envía una AlCambiar evento para el control TEdit. Por otra parte, no hay ningún
evento específico para el botón "Atrás". En esta sección, se implementa controladores de eventos para apoyar ambos escenarios.
Antes de implementar controladores de eventos, aplicar primero un método común para abrir una página Web basada en el Texto propiedad
del control de edición.
Delphi:
privado
{} Declaraciones privadas procedimiento
OpenURL;
Delphi:
C ++ Builder:
1. Crear el controlador de eventos mediante la selección de la Editar componente (en el Diseñador de formularios), y
haga doble clic en el espacio en blanco al lado de la AlCambiar evento (en el inspector de objetos de Eventos lengüeta).
Delphi:
OpenURL; fin;
C ++ Builder:
Para poner en práctica el Espalda botón de su navegador web, sólo tiene que llamar al Regresa método en el componente de
explorador Web:
Delphi:
WebBrowser1.GoBack; fin;
C ++ Builder:
(); }
El comportamiento básico ahora se implementa para esta aplicación Web Browser. Intente ejecutar la aplicación en su
dispositivo Android, el simulador de iOS, o el dispositivo IOS.
El tipo de teclado virtual más adecuado para los componentes de navegador Web es URL. Como ya hemos discutido en Diseñar la
interfaz de usuario , Los pasos siguientes establecen el URL como el tipo de teclado virtual para el componente de explorador Web en
este ejemplo. Seleccione la casilla de edición en el Diseñador de formularios, y luego en el Inspector de Objetos , selecciona el KeyboardType
propiedad a URL.
o Inicio | programas | Embarcadero RAD Studio 10.2 Tokio | Las muestras y vaya a
\ Object Pascal \ móvil Fragmentos \ WebBrowser
o Subversión
Repositorio: http://sourceforge.net/p/radstudiodemos/code/HEAD/tree/branches/RADS tudio_Tokyo / Objeto%
20Pascal / Móvil% 20Snippets / WebBrowser
Ver también
o Tutorial móvil: Usando Combo componentes de la caja para recoger cosas de una lista (IOS y
Androide)
o Tutorial móvil: Utilización de componentes de la ficha para mostrar las páginas (iOS y Android)
o Muestra FMX.KeyboardTypes
o TWebBrowser
o TToolBar
o TButton
o TEdit
o StyleLookup
Aquí se definen por FMX.TabControl.TTabControl , Que es un contenedor que puede contener varias páginas con pestañas. Cada pestaña puede
contener cualquier control como un elemento de interfaz de usuario. Puede ocultar la pestaña de estas páginas, y cambiar las páginas sin mostrar
pestañas.
Este tutorial muestra pestañas con el mismo estilo tanto en iOS y Android, pero no se recomienda esta práctica.
o En Android:
ß Las fichas se colocan habitualmente en la parte superior de la pantalla (lo que debe establecer
TTabPosition ya sea para Parte superior o para PlatformDefault).
ß Las fichas muestran tradicionalmente sólo texto. Sin embargo, FireMonkey le permite especificar
iconos personalizados que se mostrarán en las pestañas (véase Con Personal multi-resolución de los iconos de las pestañas ).
o En iOS:
ß Las fichas se muestran normalmente en la parte inferior de la pantalla (lo que debe establecer
TTabPosition ya sea para Fondo o para PlatformDefault).
Nota: Se puede utilizar el PlatformDefault valor de la TTabPosition enumeración para ajustar la posición de tabulación de
acuerdo con el comportamiento por defecto de la plataforma de destino. Cuando PlatformDefault se establece para TTabPosition
:
Para crear páginas de fichas en su aplicación, utilice el TTabControl componente con los pasos siguientes:
1. Seleccionar:
6. Hacer clic Añadir artículo tres veces, de modo que ahora tiene tres instancias de TabItem aquí.
Cerrar el cuadro de diálogo.
9.
11. Para cambiar la ubicación de las pestañas, seleccione la TabPosition propiedad para el TabControl
componente, y configurarlo para que uno de los valores siguientes en el Inspector de Objetos :
Las siguientes figuras muestran ambas aplicaciones con la misma TabPosition (ajustes Arriba, Abajo, puntos,
y Ninguna) en iOS y Android.
Sin embargo, se debe configurar los diferentes ajustes apropiados de la ficha para cada plataforma móvil, como se indica en #using
el estilo nativo de aquí en iOS y Android .
iOS Androide
iOS Androide
iOS Androide
No se visualizan aquí.
En su lugar, tres puntos ([...]) se muestran para indicar las páginas adicionales.
iOS Androide
No hay aquí o puntos se visualizan en tiempo de ejecución, aunque se pueden ver en tiempo de diseño. La página sólo se puede
cambiar a través de código o acción.
iOS Androide
notas:
o En Androide aplicaciones, iconos predefinidos no son compatibles, por lo que debe utilizar iconos personalizados.
o En iOS aplicaciones, se puede utilizar cualquiera de los iconos predefinidos o iconos personalizados.
o Para iOS, puede utilizar nuestros iconos predefinidos mediante el establecimiento de la StyleLookup propiedad de
o Los glifos personalizados utilizados en esta sección están disponibles en un archivo zip que se entrega en su
C: \ Archivos de programa (x86) \ Embarcadero \ Studio \ 19.0 \ Images \ GlyFX directorio. Los tres PNG utilizados aquí
se encuentran en el Iconos \ Aero \ PNG \ 32x32 directorio:
ß users_32 ( Gente)
ß unlock_32 ( Seguridad)
ß tree_32 ( Organización)
descomprimir el glyFX.zip presentar antes de utilizar el Editor de MultiResBitmap si desea utilizar estas imágenes o cualquier
otro disponible en la colección GlyFX.
1. En el Inspector de Objetos , seleccione TabItem1, y luego cambiar el subtítulo de pestaña, que se especifica en el Texto
propiedad a Gente; cambiar el Texto propiedad de TabItem2 a
Seguridad, y TabItem3 a Organización.
2. Seleccione una ficha y haga clic en el botón de puntos suspensivos [...] en el CustomIcon propiedad de TTabItem en
el Inspector de Objetos :
4. Asegúrese de que está en la vista principal y, en el Editor de MultiResBitmap, haga clic en la matriz
cerca de Tamaño personalizado, y luego elegir tamaño predeterminado.
5. Repita los pasos siguientes para añadir cualquier escalas adicionales que desee para apoyar:
ß Cuando haya añadido todas las escalas que desea, el editor tiene el siguiente aspecto:
La imagen seleccionada aparece ahora escala apropiada en cada una de las entradas de cal en el Editor de
MultiResBitmap:
8. Repita los pasos 2 a 7 para cada uno de los restantes TabItems, y asignar a cada una TabItem
imagen de icono personalizado.
Después de definir un icono personalizado, el marco FireMonkey genera una imagen seleccionada y
No seleccionada (atenuado) Imagen basado en el archivo .png dado. Esta transformación se realiza mediante el canal alfa de los
datos de mapa de bits. Por ejemplo:
También puede utilizar solamente un mapa de bits de una sola resolución mediante el uso de la Editor de mapa de bits . Una resolución de
mapa de bits sola muestra sólo una escala en la vista de estructura:
Para especificar un mapa de bits de una sola resolución de un icono personalizado, realice el primer paso del procedimiento anterior y luego
proceder como sigue:
2. Ahora, en el Inspector de Objetos , Haga clic en el botón de puntos suspensivos [...] en el mapa de bits campo (de la
TabItem1.CustomIcon [0] ). Esto abre la Editor de mapa de bits :
3. En el Editor de mapa de bits , haga clic en el Carga... botón y seleccionar un archivo PNG. Se recomienda un tamaño de 30x30
píxeles de resolución normal, y 60x60 píxeles para alta resolución:
Como se ha comentado, cada página de la ficha puede contener cualquier número de controles incluyendo otra TabControl. En tal caso, se puede
navegar y gestionar las diferentes páginas de la lengüeta en la facilidad estructura Ver :
Si aquí son visibles (cuando el TabPosition propiedad se establece que no sea Ninguna), un usuario final puede simplemente toque una ficha para
abrir la página correspondiente.
Un acción corresponde a uno o más elementos de la interfaz de usuario, tales como comandos de menú, botones de la barra, y los
controles. Acciones cumplen dos funciones:
o Acciones responden cuando se activa un control, por ejemplo, cuando el usuario hace clic en un aplicación
botón o elige un elemento del menú.
Estos son los pasos para habilitar un usuario para mover a diferentes páginas de la ficha haciendo clic en un botón:
2. Desde el paleta de herramientas , Agrega un TActionList componente de la forma y, a continuación, añadir una
TButton a TabItem1:
3. Con el botón seleccionado, en el Inspector de Objetos , seleccione acción | Nueva Acción estándar
| Tab> TChangeTabAction en el menú desplegable. Después de que el usuario hace clic en este botón, se realiza la acción
que acaba de definir (la página cambia pestaña):
7. En el Diseñador de formularios, seleccione TabItem2 y soltar dos TButtons de la paleta de herramientas para
TabItem2.
12. En el Diseñador de formularios, seleccione TabItem3 y soltar un TButton de la paleta de herramientas para
TabItem3.
Puede utilizar cualquiera de las tres formas siguientes para cambiar la etiqueta activa a partir del código fuente, haciendo clic en el
botón.
Delphi:
TabControl1.ActiveTab: = TabItem1;
C ++:
La propiedad TabIndex es un valor entero de base cero. Se puede especificar cualquier número entre 0
y TabControl1.TabCount - 1.
Delphi:
TabControl1.TabIndex: = 2;
C ++:
TabControl1-> TabIndex = 2;
Se puede llamar al ExecuteTarget Método de cualquiera de las acciones de control de pestaña ( TChangeTabAction ,
TNextTabAction y TPreviousTabAction ). Debe asegurarse de definir el
TChangeTabAction.Tab , TPreviousTabAction.TabControl o el TNextTabAction.TabControl
propiedades.
Delphi:
C ++:
// Puede fijar el objetivo en tiempo de ejecución si no está definido todavía. ChangeTabAction1-> Tab =
Ver también
o Tutorial móvil: El uso de un componente de botón con diferentes estilos (iOS y Android)
o Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (iOS y Android)
Las muestras
o pestaña deslizante
Nota: FMX.ListBox.TListBox el rendimiento puede ser lento en el móvil. Utilizar TListView Si desea desarrollar aplicaciones
más complejas, especialmente las aplicaciones con grandes bases de datos.
Caja de búsqeda
Puede añadir un cuadro de búsqueda a un cuadro de lista. Con un cuadro de búsqueda, los usuarios pueden reducir fácilmente una selección de una
lista larga como en las siguientes imágenes.
2. Selecciona el TListBox componente en el paleta de herramientas , Y soltarlo en el Diseñador de formularios . Para encontrar TListBox, introducir
unos pocos caracteres (como "TList") en el Buscar cuadro de la paleta de herramientas:
5. Sobre el Artículos de diseño, haga clic en el Añadir artículo varias veces el botón para añadir varios artículos a
el cuadro de lista:
Se puede definir un encabezado en el componente TListBox mediante el uso de los siguientes pasos:
A la cabecera de un TListBox
Propiedad Valor
Alinear Cliente
StyleLookup toollabel
TextSettings.HorzAlign Centro
Se puede definir un encabezado de grupo y un pie del grupo de artículos en TListBox de la siguiente manera:
4. Seleccionar ListBoxGroupHeader1 en la lista de elementos y haga clic en el Arriba varias veces el botón
hasta que este elemento se convierte en el primer elemento de la lista:
5. Cerrar el cuadro de diálogo. Ahora usted tiene un encabezado de grupo y un pie de página en el Grupo
TListBox componente.
Los artículos por un cuadro de lista se pueden mostrar, ya sea como Llanura o una lista agrupados lista. Esta elección es controlada por el GroupingKind
propiedad y el StyleLookup propiedad, como se muestra en el siguiente gráfico:
Se puede seleccionar el GroupingKind propiedad y el StyleLookup propiedad en el inspector de objetos cuando el cuadro de lista
se selecciona en el Diseñador de formularios.
Cada artículo en un TListBox puede usar un accesorio como Marca de verificación a través de la
ItemData.Accessory propiedad. El siguiente cuadro muestra el valor se puede asignar a ItemData.Accessory
y el accesorio asignado:
Se puede seleccionar la propiedad de accesorios en el inspector de objetos al cuadro de lista de artículos está seleccionado en el diseñador de formularios.
Cada artículo en un componente ListBox puede contener datos de mapa de bits, como una Icono, a través de
ItemData.Bitmap propiedad:
Se puede seleccionar el mapa de bits propiedad en el inspector de objetos cuando el ListBoxItem se selecciona en el Diseñador de
formularios. Con el fin de ver el Icono, debe seleccionar un StyleLookup que apoya la mapa de bits propiedad. Cambie la propiedad
StyleLookup a listboxitemleftdetail.
Se puede añadir información adicional al texto de cada elemento en el componente ListBox. Especificar texto adicional en el ItemData.Detail
propiedad, y seleccionar la ubicación del texto de detalle a través de la StyleLookup propiedad, como se muestra en la siguiente tabla:
listboxitemnodetail
listboxitembottomdetail
listboxitemrightdetail
listboxitemleftdetail
Ejecución de la aplicación
Para añadir elementos regulares a un cuadro de lista, sólo tiene que llamar al Artículos. Añadir método como se muestra en el siguiente fragmento de
código:
o Delphi:
o C ++:
continuación, agregarlo al cuadro de lista. Los siguientes códigos de muestra añadir elementos a un cuadro de lista, como se muestra en la imagen:
Delphi:
ListBoxItem: TListBoxItem;
ListBoxGroupHeader: TListBoxGroupHeader; empezar
// Añadir elementos ( 'a', 'AA', 'aaa', 'b', 'bb', 'BBB', 'c', ...) a la lista para i: = 1 a 3 do begin
// o, puede agregar elementos mediante la creación de una instancia de TListBoxItem por sí mismo ListBoxItem: =
TListBoxItem.Create (ListBox1); ListBoxItem.Text: = Buffer;
ListBox1.EndUpdate; fin;
C ++:
Char c; int i;
Búfer de cadena;
TListBoxItem * ListBoxItem;
TListBoxGroupHeader * ListBoxGroupHeader; ListBox1-> BeginUpdate
// Añadir elementos ( 'a', 'aa', 'aaa', 'b', 'bb', 'bbb', 'c', -> -> ->) a la lista para (i = 1; i <4; i ++) { // StringOfChar devuelve una
cadena con un número determinado de repetir personajes->
// o, puede agregar elementos mediante la creación de una instancia de TListBoxItem por sí mismo ListBoxItem = new
TListBoxItem (ListBox1); ListBoxItem-> Text = Buffer;
Un menú emergente de desbordamiento se accede a través de la barra de acción y se utiliza para proporcionar acceso a los artículos o elementos
que se utilizan con menos frecuencia adicionales. En FireMonkey, se puede implementar fácilmente un menú de desbordamiento usando TListBox :
4. Durante los primeros cuatro TListBoxItem componentes en TListBox ir Inspector de Objetos , expandir
ItemData :
En el Diseñador de formularios, haga doble clic en el OverflowButton componente. Agregue el código siguiente a este controlador de eventos:
o Delphi:
fin; fin;
o C ++:
o Para añadir un cuadro de búsqueda al componente ListBox, haga clic en el TListBox componentes y
sólo tiene que seleccionar Agregar elemento> TSearchBox en el menú contextual:
ß Para crear el controlador de eventos para el SearchButton, Haga doble clic en él y añadir el
siguiente código:
Delphi:
C ++:
Ejecución de la aplicación
1. Seleccione:
ß Ejecutar> Ejecutar
2. Para invocar el menú adicional, haga clic en los puntos suspensivos vertical en la barra de acción.
Ver también
o FMX.ListBox.TListBox
o Tutorial móvil: Usando LiveBindings rellenar un cuadro de lista en aplicaciones móviles (IOS
y Android)
o Tutorial móvil: El uso de un componente de botón con diferentes estilos (iOS y Android)
o Tutorial móvil: Utilización de componentes de la ficha para mostrar las páginas (iOS y Android)
Este tutorial muestra cómo utilizar LiveBindings diseñador para llenar una componente ListView FireMonkey a partir de una TPrototypeBindSource
que contiene algunos datos de ejemplo. El tutorial muestra cómo agregar los datos de la muestra y cómo hacer que los enlaces entre
la fuente de creación de prototipos y el componente de vista de lista con el fin de llenar la lista. Como cada LiveBinding, este tutorial
requiere sin código. Sin embargo, con el fin de crear una aplicación útil, es necesario agregar controladores de eventos y otros
códigos.
Nota: Para obtener más información acerca de la selección de la Estilo y Puntos de vista, ver Selector de estilo y
Usando FireMonkey Vistas .
ß En el Inspector de Objetos , Localizar el tintColor propiedad y establezca su valor en un valor adecuado, como
por ejemplo Mar verde.
La siguiente imagen muestra tanto la estructura Ver y el Inspector de Objetos . En el estructura Ver , ít. y se expande TEXTBUTTON
está seleccionado, y en el Inspector de Objetos , tintColor se establece en Mar verde:
5.
7.
Nota: En tiempo de diseño, el color de la tinta que ha aplicado a los botones de texto podría no ser visible. Para que
los cambios visibles, elija el Dominar vista en el selector de estilo para cambiar el estilo actual de su Diseñador de
formularios a cualquiera Androide o
IOS. Para más detalles, véase Diseñador de formularios .
En este punto en el tutorial, se ha configurado el componente ListView para mostrar una imagen en el lado izquierdo del
elemento de texto y para mostrar un botón en el lado derecho del elemento de texto.
2. En el Agregue campo caja de diálogo, Ctrl + clic para seleccionar Los mapas de bits y Moneda datos de campo. Cuando haya terminado, haga
clic DE ACUERDO.
Este paso agrega un botón que representa el color y el número de cada elemento de vista de lista, tales como Blue
19.
Este paso muestra el valor de campo de moneda en el botón situado en la parte derecha de cada elemento de lista.
Ahora la vista de lista muestra algunos datos de color asociados con cada elemento y también muestra los datos de moneda de muestra en el
botón asociado a cada elemento de la lista.
Para crear una aplicación practica, se puede añadir el onButtonClick controlador de eventos que se activa cuando se hace clic en un elemento
ListView.
3. En el Editor de código , Implementar un proceso adecuado OnButtonClick controlador de eventos. El siguiente código de ejemplo agrega el
controlador de eventos que muestra un cuadro de mensaje que aparece cuando un elemento ListView:
Delphi:
C ++ Builder:
Los resultados
Para ver su aplicación móvil tal y como aparecería en un dispositivo móvil, es necesario configurar el sistema como se describe en la
apropiada Preparar tutorial, disponibles aquí Y establecer el Ver a un dispositivo móvil de destino (tal como Iphone 4") en el Diseñador de
formularios. Luego hay que completar las medidas necesarias para el despliegue de su aplicación a la plataforma móvil de destino. A
continuación, puede ejecutar la aplicación en su dispositivo móvil, ya sea pulsando F9 o eligiendo
Ejecutar> Ejecutar .
Protectores Galaxy s4
Ver también
o Tutorial móvil: Utilización de componentes de la ficha para mostrar las páginas (iOS y Android)
o Tutorial móvil: Usar diseño de Ajuste forma diferente tamaños u orientaciones (IOS y
Androide)
o FMX.ListView.TListView
o TPrototypeBindSource
o LiveBindings diseñador
Este tutorial le guiará por los pasos de conectar datos a un control ListBox FireMonkey en sus dispositivos móviles,
utilizando LiveBindings.
1. Seleccionar:
3. Seleccione el componente de cuadro de lista en el diseñador de formularios, y en el Inspector de Objetos , Localizar el DefaultItemStyles.ItemStyle
propiedad. Configurarlo para que la listboxitemrightdetail estilo.
4. Deseleccionar el componente de cuadro de lista, haga clic en un área en blanco del diseñador de formularios.
6. Seleccione el componente de rectángulo en el Diseñador de formularios, y en el Inspector de Objetos , selecciona el Alinear propiedad a Fondo.
8. Ahora deja caer una TPrototypeBindSource desde el paleta de herramientas en su forma. En este punto, su
1. Haga clic con el TPrototypeBindSource componente y, a continuación, haga clic Agregue campo sobre el
Menú de contexto.
3. Validar su selección haciendo clic en el DE ACUERDO botón. Ahora los datos de la muestra está lista para ser
utilizado a través de LiveBindings.
7. Haga clic en el botón de puntos suspensivos [...] en el Rectángulo1 Diagrama de bloques en el LiveBindings
Diseñador Y en el diálogo que se abre, escriba Color de relleno. Selecciona el Color de relleno casilla de verificación, haga clic en DE
ACUERDO:
Nota: Al intentar unirse Color de relleno a SelectedValue, Se abre un cuadro de mensaje de confirmación. En
este cuadro de mensaje, seleccione Sí.
Después de completar los pasos anteriores, el diagrama LiveBindings será similar a la siguiente imagen:
Cuando se selecciona un elemento del cuadro de lista, los cambios de color del rectángulo en consecuencia:
Ver también
o LiveBindings diseñador
o Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (iOS y Android)
En este tutorial se describe una estrategia general para el uso de la Dominar ver para diferentes factores de forma (tales como teléfono o tableta),
sin el uso de diferentes puntos de vista para cada factor de forma.
El diseño para un niño se define como un valor relativo a su padre. En la siguiente imagen, Label1 es el hijo de Toolbar1,
y la distribución de Label1 es relativa a Toolbar1.
Un control de Alinear propiedad determina si se vuelve a colocar de forma automática y / o cambiar de tamaño a lo largo de cuatro lados
o centro de su matriz, tanto inicialmente como que el padre se cambia el tamaño. El valor por defecto para el Alinear propiedad es Ninguna,
lo que significa que no hay cálculos automáticos se realizan: el control queda donde se coloca:
Los valores típicos para el Alinear propiedad son los siguientes (Dodgerblue indica el área para el niño):
Izquierda Derecha
Centrar Cliente
Si se utiliza una Alinear valor de Arriba, Abajo, Izquierda, Derecha o de un componente, el Alinear
propiedades para otros componentes utilizan el área restante. El tamaño y forma de la zona restante ( Cliente) también
cambia en base a la orientación del dispositivo, y con base en el factor de forma (iPhone o iPad).
Las siguientes imágenes muestran el diseño de paisaje (horizontal) y para el retrato (vertical) cuando se tienen dos (2) componentes
que utilizan Parte superior, y un (1) componente que utiliza Cliente.
márgenes asegurar la separación entre los controles posicionado automáticamente por un padre. En la siguiente imagen, el
Relleno deja de lado el espacio en el interior del cuadro de contenido de los padres. En el inspector de objetos, puede establecer los valores
(en píxeles) para el Relleno :
o Izquierda
o Derecha
o Fondo
o Parte superior
En la siguiente imagen, el componente principal (que contiene dos regiones) utiliza el Relleno
de establecimiento para asegurar el espacio en el interior del componente de los padres:
Se necesitan Anchors cuando un control debe mantener su posición a una cierta distancia de los bordes de su padre, o se debe
estirar el tiempo que se mantiene la distancia original entre sus bordes y los bordes de su matriz. controles anclados 'palo' a los lados
de los contenedores y estiramiento, si es así se especifique.
Si usted tiene una Editar de control en la parte superior de una Barra de herramientas, es posible que desee mantener una distancia fija entre el borde
derecho de la Editar Control y el borde de la forma ( Barra de herramientas). Anclajes permiten especificar que un control debe permanecer fijo en relación
a los lados de su padre. Si desea que el Editar control para mantener la misma posición relativa en relación con la barra de herramientas (su padre), se
puede establecer el anclas propiedad a akLeft, akTop, Akright. Cuando se cambia el tamaño de la barra de herramientas, el control de edición se cambia
iOS
Androide
Si usted tiene un control Button en el extremo derecho de la barra de herramientas, es posible que desee mantener la misma
distancia entre el derecho borde del control Button y el borde de la Forma. Sin embargo, puede que no desee mantener la misma
distancia entre el izquierda borde del control Button y el izquierda borde de la Forma. En este caso, se puede establecer el anclas propiedad
a akTop, Akright
(De-seleccione akLeft), de manera que el control Button mantiene las mismas distancias con la barra de herramientas (matriz) para Parte superior y Derecha.
Androide:
Puedes usar Alinear , Relleno , márgenes , anclas , Y otras propiedades de TLayout para definir el diseño para un área específica.
Usted puede utilizar el componente TLayout al igual que el DIV etiqueta en HTML.
Ver también
o Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (iOS y Android)
o Gestos en FireMonkey
Antes de comenzar este tutorial, usted debe leer y realizar el siguiente tutorial:
o Tutorial móvil: El uso de un componente de botón con diferentes estilos (iOS y Android)
Este tutorial cubre las siguientes tareas típicas para el uso de imágenes y compartir el texto con sus aplicaciones en
plataformas móviles.
Tomar una foto con la cámara del dispositivo Usando una imagen del dispositivo Photo Library
temas
o Tomar y compartir imágenes y texto Usando las listas de acciones
Ver también
o acciones FireMonkey
o FMX.StdCtrls.TButton
o FMX.Objects.TImage
o Muestra FMX.PhotoEditorDemo
o Muestra FMX.CameraComponent
o http://appleinsider.com/articles/12/02/16/share_sheets
Antes de comenzar este tutorial, usted debe leer y llevar a cabo las siguientes sesiones de tutoría:
o Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (iOS y Android)
o Tutorial móvil: Usar diseño de Ajuste forma diferente tamaños u orientaciones (IOS y
Androide)
Nota: En los dispositivos Android, TLocationSensor requiere específica utiliza permisos a ajustar y, específicamente Acceso a la
ubicación gruesa y Acceso a la ubicación bien.
En este tutorial se describen los pasos básicos para localizar su dispositivo móvil (usando latitud y longitud), y utilizar La
geocodificación inversa para convertir a una dirección legible, como en la siguiente imagen:
Nota: Antes de continuar con este escenario, en el Gerente de proyecto , Configurar la plataforma de destino activa
para dispositivo iOS o Androide. De lo contrario, no se puede añadir el
TWebBrowser componente.
o En el TListBox, establecer el Alinear propiedad a Izquierda para reservar la parte izquierda de la interfaz de usuario. Entonces
crear los siguientes subcomponentes bajo el cuadro de lista:
o Un componente TWebBrowser (WebBrowser1) para mostrar la página Web (Google Maps). Conjunto
el Alinear propiedad a Cliente.
TLocationSensor dispara una OnLocationChanged evento cuando el dispositivo detecta movimiento. Se puede ajustar la
sensibilidad de TLocationSensor utilizando el Distancia y Exactitud propiedades.
o los Distancia propiedad especifica la distancia mínima (en metros) por el cual el dispositivo
debe moverse con el fin de hacer que el sensor de localización reubicar el dispositivo y volver nueva información de ubicación. Por
ejemplo, si se establece Distancia a "10", TLocationSensor dispara una
OnLocationChanged evento al mover "10 metros".
o los Exactitud propiedad representa el nivel de precisión (en metros) por el cual el sensor
localiza el dispositivo geográficamente, en relación con el punto geográfico en el que en realidad se encuentra el dispositivo.
Propina: Se debe especificar la precisión más bajo que funcione para su aplicación; cuanto mayor sea la precisión, más el
tiempo y la energía que requiere el sensor para determinar la ubicación. Los valores recomendados: distancia = 0; Precisión
= 0.
Delphi:
C ++:
Como se señaló anteriormente, TLocationSensor dispara una OnLocationChanged evento cuando se mueve el dispositivo móvil.
Puede mostrar la ubicación actual (latitud y longitud) usando los parámetros con un controlador de eventos.
Delphi:
empezar
LDecSeparator: = FormatSettings.DecimalSeparator;
FormatSettings.DecimalSeparator: =; '' // Muestra la ubicación actual
C ++:
https://maps.google.com/maps?q=(Latitude-value),(Longitude-value)
Así puede añadir esta URL a su controlador de eventos previamente creado OnLocationChanged como sigue:
Delphi:
'Https://maps.google.com/maps?q=%s,%s',
[Format ( '% 2.6f', [NewLocation.Latitude]), Formato ( '% 2.6f', [NewLocation.Longitude])]);
C ++:
Google Maps
Cadena LLongitude = FloatToStr (NewLocation.Longitude, FormatSettings); Cadena URLString = "";
geocodificación es el proceso de transformación de datos geográficos, tales como la dirección y el código postal, en coordenadas
geográficas. geocodificación inversa es el proceso de transformación de coordenadas geográficas en otros datos geográficos, tales
como la dirección. En este caso, utilizamos TGeocoder "revertir Geocode" nuestra localización (latitud y longitud) a la información de
2. Definir un evento OnGeocodeReverse para que pueda recibir el evento más tarde.
Nota: Como TGeocoder no es un componente (esto es sólo una clase), es necesario definir los pasos a través de su código (no se
puede colocar un componente, ni asignar un controlador de eventos a través del Inspector de Objetos).
En primer lugar, definir un nuevo campo "FGeocoder" en la sección privada de la forma. También puede definir un "procedimiento
OnGeocodeReverseEvent", como en los siguientes fragmentos de código.
Delphi:
tipo
TForm1 = class (TForm)
// IDE define componentes visibles (o no visuales) aquí automáticamente
Ahora se puede crear una instancia de TGeocoder y configurarlo con datos con la siguiente Delphi o código C ++.
TGeocoder.Current da el tipo de clase que realmente implementa el servicio de codificación geográfica. El código de " TGeocoder.Current.Create"
llama al constructor (Crear) para el tipo especificado, y lo guarda en el FGeocoder campo. También es necesario especificar un
controlador de eventos, que se dispara cuando TGeocoder completa geocodificación inversa. Asignar OnGeocodeReverseEvent
( que se acaba de definir en el paso anterior) a FGeocoder.OnGeocodeReverse.
Por último, si ha creado una instancia del juego TGeocoder, y TGeocoder no se está ejecutando, llame TGeocoder.GeocodeReverse
con información de ubicación. Después TGeocoder recibe datos, la
OnGeocodeReverseEvent evento se dispara.
Delphi:
C ++:
si (FGeocoder == NULL) {
si (TGeocoder :: actual! = NULL) {
FGeocoder = (TGeocoder *) nueva TGeocoderClass (TGeocoder :: actual); } si (FGeocoder! = NULL) {
para abordar
Como se describió anteriormente, después de Reverse codificación geográfica se ha completado, una OnGeocodeReverseEvent Está despedido.
A continuación, asignar propiedades de la TCivicAddress Dirección de parámetro para mostrar información de la dirección de lectura en los campos del
cuadro de lista:
Delphi:
ListBoxItemAdminArea.ItemData.Detail : = Address.AdminArea;
ListBoxItemCountryCode.ItemData.Detail : = Address.CountryCode;
ListBoxItemCountryName.ItemData.Detail : = Address.CountryName;
ListBoxItemFeatureName.ItemData.Detail : = Address.FeatureName;
ListBoxItemLocality.ItemData.Detail : = Address.Locality;
ListBoxItemPostalCode.ItemData.Detail : = Address.PostalCode;
ListBoxItemSubAdminArea.ItemData.Detail : = Address.SubAdminArea;
C ++:
Si (Dirección! = NULL) {
ListBoxItemAdminArea-> ItemData-> Detalle = Dirección-> AdminArea;
ListBoxItemCountryCode-> ItemData-> Detalle = Dirección-> countryCode;
ListBoxItemCountryName-> ItemData-> Detalle = Dirección-> CountryName;
ListBoxItemFeatureName-> ItemData-> Detalle = Dirección-> FeatureName;
ListBoxItemLocality-> ItemData-> Detalle = Dirección-> localidad;
ListBoxItemPostalCode-> ItemData-> Detalle = Dirección-> PostalCode;
ListBoxItemSubAdminArea-> ItemData-> Detalle = Dirección-> SubAdminArea;
ListBoxItemSubLocality-> ItemData-> Detalle = Dirección-> SubLocality;
ListBoxItemSubThoroughfare-> ItemData-> Detalle = Dirección-
> SubThoroughfare; ListBoxItemThoroughfare-> ItemData-> Detalle
= Dirección-> Vías;
}}
Antes de ti desplegar su aplicación definitiva hay que seleccionar Proyecto> Opciones> Información de la versión , Con IOS
Dispositivo como el objetivo, y actualizar los valores de NSLocationAlwaysUsageDescription y
NSLocationWhenInUseUsageDescriptioncon un mensaje que explica por qué su solicitud pide la ubicación del usuario. Sus
usuarios ver este mensaje cuando la aplicación les pide que se autorice IOS para proporcionar la ubicación del
dispositivo iOS con la aplicación.
Ver también
o Tutorial móvil: Usar diseño de Ajuste forma diferente tamaños u orientaciones (IOS y
Androide)
o System.Sensors.TGeocoder
o System.Sensors.Components.TLocationSensor
Las muestras
o Ubicación muestra
En este tutorial se describen los pasos básicos para usar las notificaciones en su dispositivo móvil; para más detalles, véase el uso de
notificaciones .
iOS
Androide
Protectores
Androide
Las siguientes imágenes muestran el centro de notificaciones en un iPad (Centro de Notificaciones) y Android (buzón de notificaciones), donde el
usuario puede tirar hacia abajo la lista de todas las notificaciones recientes.
iOS
usos
System.Notification;
ß Para aplicaciones C ++, agregue la siguiente incluir operador a la cabecera del proyecto
archivo (archivo .h):
# incluir <System.Notification.hpp>
los FMLocalNotificationPermission configuración habilita las notificaciones locales en los dispositivos iOS 8+:
TNotification.Number define el Icono número de placa ( para iOS dispositivos) y la número de notificación ( para dispositivos
Android).
Para establecer el número de iOS icono insignia (para Delphi o C ++) o el número de notificaciones de Android (sólo para aplicaciones de Delphi), es
necesario poner en práctica el método correspondiente.
3. crear el Al hacer clic caso de la NúmeroConjunto botón haciendo doble clic en el botón.
4. implementar el controlador de eventos Para el evento OnClick del NúmeroConjunto botón añadiendo el siguiente código:
ß por Delphi:
TNotification; empezar
MyNotification.AlertBody: = 'Delphi para su dispositivo móvil ya está aquí!'; // Nota: Usted debe enviar la notificación al
centro de notificación para el número de placa del icono que se mostrará.
ß por C ++:
Después de ejecutar la aplicación (pulse F9) y haciendo clic en el NúmeroConjunto botón, se puede ver lo siguiente:
o Un número que aparece junto al mensaje de notificación en el centro de notificaciones (en Android):
Androide
crear una instancia de la TNotification clase y, para definir la Nombre , AlertBody y FireDate campos.
4. implementar el controlador de eventos Para el evento OnClick del ScheduleNotification botón añadiendo el siguiente
código:
ß por Delphi:
empezar
'MyNotification';
MyNotification.AlertBody: = 'Delphi para su dispositivo móvil ya está aquí!'; // Fired en 10 segundos
ß por C ++:
Después de ejecutar la aplicación (pulse F9) y haciendo clic en el ScheduleNotification botón, se puede ver el mensaje de notificación
(AlertBody) en la parte superior de su dispositivo de pantalla de inicio. Para los dispositivos IOS, este mensaje es similar a la pantalla
siguiente:
Para repetir un mensaje de notificación, es necesario crear una instancia de la TNotification clase y, para definir la Nombre , AlertBody
y FireDate campos. También es necesario utilizar la ScheduleNotification método y fijar el Intervalo de repetición propiedad. En el
siguiente código, el intervalo repetido se establece en un minuto.
4. implementar el controlador de eventos Para el evento OnClick del RepeatedNotification botón añadiendo el siguiente
código:
ß por Delphi:
empezar
'MyNotification';
MyNotification.AlertBody: 'notificación repitiendo cada minuto!'; // Fired en 10 segundos
ß por C ++:
myNotification-> FireDate = Now () + EncodeTime (0, 0, 10, 0); // repetida cada minuto
Después de ejecutar la aplicación (pulse F9) y haciendo clic en el RepeatedNotification botón, se puede ver el mensaje de notificación
(AlertBody) en la parte superior de su dispositivo de pantalla de inicio. Para los dispositivos IOS, este mensaje es similar a la pantalla
siguiente:
presentado todavía. Para actualizar una notificación programada, simplemente llame al ScheduleNotification método de nuevo con
una instancia de TNotification que tiene el mismo nombre (propiedad Name). Para cancelar una notificación programada, sólo
4. implementar el controlador de eventos Para el evento OnClick del CancelNotification botón añadiendo el siguiente
código:
ß por Delphi:
ß por C ++:
CancelNotification ( "MyNotification"); }
Para mostrar un mensaje de notificación, es necesario crear una instancia de la TNotification clase y, para definir la Nombre y
AlertBody campos.
4. implementar el controlador de eventos Para el evento OnClick del PresentNotification botón añadiendo el siguiente
código:
empezar
'MyNotification';
MyNotification.AlertBody: = 'Delphi para su dispositivo móvil ya está aquí!'; // Conjunto del icono del número de placa (para
iOS) o el número de mensajes (para Android), así MyNotification.Number: = 18; MyNotification.EnableSound: = false; // Enviar
mensaje al centro de notificación NotificationCenter1.PresentNotification (MyNotification); finalmente
ß por C ++:
vacío __fastcall TForm1 :: PresentNotificationClick (TObject * Remitente) {if (NotificationCenter1-> Apoyado ()) {
} __finalmente {
4. implementar el controlador de eventos Para el evento OnClick del SoundNotification botón añadiendo el siguiente
código:
ß por Delphi:
empezar
'MyNotification';
MyNotification.AlertBody: = 'Delphi para su dispositivo móvil ya está aquí!'; MyNotification.EnableSound: = True;
MyNotification.SoundName: = GetSoundName; MyNotification.FireDate: = ahora + EncodeTime (0, 0, 10, 0); // Enviar
mensaje al centro de notificación NotificationCenter1.ScheduleNotification (MyNotification); finalmente
ß por C ++:
CreateNotification ();
__tratar {
myNotification-> Name = "MyNotification";
myNotification-> AlertBody = "C ++ para su dispositivo móvil ya está aquí!"; myNotification-> EnableSound = true;
myNotification-> SoundName = GetSoundName (); myNotification-> FireDate = Now () + EncodeTime (0, 0, 10, 0);
// Enviar notificación al centro de notificación NotificationCenter1-> ScheduleNotification (myNotification); } __finalmente
{
ß por Delphi:
usos
System.IOUtils; privado
ß por C ++:
Nota: Dependiendo del sistema operativo de destino, los datos de sonido debe ser una extensión de archivo diferente.
ß por Delphi:
{$ R * .fmx}
TForm1.GetSoundName función: string; begin {$ IFDEF IOS}
ß por C ++:
Nota: El myAndroidSound.mp3 archivos de sonido y myiOSSound.caf no están incluidos en la instalación RAD Studio. Se puede utilizar
cualquier archivos CAF que tiene MP3 y, pero recuerde que debe cambiar el nombre en el fragmento de código anterior para el nombre de
los archivos. Vea este enlace para obtener más información sobre cómo convertir archivos MP3 a formato CAF: Cómo convertir de MP3 a la
CAF
ß En el Confirmar diálogo, haga clic Sí para agregar los archivos de sonido a su proyecto.
8. Abre el Gestor de despliegue para asegurarse de que los archivos de sonido se despliegan con su
solicitud. Puede ver las entradas correspondientes en la columna de la ruta de acceso remoto:
ß Para iOS:. \
Androide
es necesario establecer el alertaction campo para el nombre del botón de acción, y luego configurar el HasAction campo para Cierto, como sigue.
4. implementar el controlador de eventos Para el evento OnClick del ActionNotification botón añadiendo el siguiente
código:
ß por Delphi:
empezar
'MyNotification';
MyNotification.AlertBody: Delphi =' para iOS ya está aquí! '; MyNotification.Number: = 2;
MyNotification.AlertAction: = 'Launch'; MyNotification.HasAction: = True;
ß por C ++:
vacío __fastcall TForm1 :: ActionNotificationClick (TObject * Remitente) {if (NotificationCenter1-> Apoyado ()) {
Nota: Sólo los dispositivos iOS compatibles con la función de alerta de notificación. La notificación de alerta se abre en
el usuario hace clic en el mensaje de notificación en el centro de notificaciones. Para escribir la respuesta, haga doble clic en el TNotificationCenter
componente en el Diseñador de formularios Y luego poner en práctica el OnReceiveLocalNotification controlador de eventos. El siguiente
fragmento de código implementa una respuesta para mostrar un cuadro de mensaje que dice: "El <Nombre de la notificación>" hace clic en
la notificación ".
o por Delphi:
empezar
ShowMessage ( 'El' + + ANotification.Name 'notificación clic en él.'); fin;
o por C ++:
Ver también
o Uso de notificaciones
o Tutorial móvil: tomar y compartir una imagen, texto y compartir (iOS y Android)
Las muestras
En este tutorial se describen los pasos básicos para utilizar los servicios de marcación del teléfono en su dispositivo móvil.
En las plataformas móviles, proporciona la FireMonkey IFMXPhoneDialerService interfaz que define la estructura de las clases de servicio
de marcación del teléfono, tales como TPhoneDialerService . Los servicios de marcación del teléfono le permiten realizar las siguientes
operaciones:
1. Seleccionar:
Delphi:
usos
FMX.Platform, FMX.PhoneDialer;
C ++:
# incluir <FMX.Platform.hpp>
# incluir <FMX.PhoneDialer.hpp>
o Sólo para aplicaciones de Delphi: Añadir la siguiente línea a la sección pública de la definición del formulario:
Delphi:
C ++:
o Sólo para aplicaciones de Delphi: en la sección de implementación, anular el constructor de forma tan
de la siguiente manera:
o Sólo para C ++ Builder aplicaciones: en el estructura Ver , Haga clic en la forma y en el Objeto
Inspector , abre el Eventos pestaña y haga doble clic onCreate. Implementar la siguiente onCreate controlador
de eventos para el formulario de solicitud:
Para configurar los elementos de interfaz de usuario, realice los siguientes pasos:
ß Nombre a btnGetCarrierInfo
2. En el Inspector de Objetos, haga doble clic en el al hacer clic acontecimiento, y aplicar el al hacer clic
controlador de eventos de la siguiente manera:
Delphi:
{Prueba de si los servicios PhoneDialer son compatibles con su dispositivo} if Assigned (PhoneDialerService), entonces
comienzan
{Si es así, actualizar las etiquetas con la información recuperada} lblCarrierName.Text: = 'Nombre de la
compañía:' + PhoneDialerService.GetCarrier.GetCarrierName;
C ++:
si (serviceSupported) {
lblCarrierName-> Text = "Nombre de la compañía:" + phoneDialerService-
> GetCarrier () -> GetCarrierName ();
lblISOCountryCode-> Text = "Código de país ISO:" + phoneDialerService-
> GetCarrier () -> GetIsoCountryCode ();
} Else ShowMessage ( "Este dispositivo no es compatible con los servicios del marcador del teléfono."); }
Ejecutar la aplicación
Importante: Antes de ejecutar su aplicación Delphi en un dispositivo Android, compruebe que los siguientes
permisos se establecen en
o Llamada telefónica
Después de hacer clic en el Obtener Información Carrier botón, la aplicación muestra la información básica sobre el portador, similar a las
pantallas siguientes:
iOS Androide
FireMonkey proporciona la IFMXPhoneDialerService.Call método que hace una llamada telefónica a un número de teléfono
especificado.
Para su aplicación para realizar llamadas, añadir los siguientes elementos al diseñador de la forma:
ß Nombre a edtTelephoneNumber.
ß KillFocusByReturn a Cierto.
ß KeyboardType a PhonePad.
ß ReturnKeyType a Ir.
o Sobre el Eventos pestaña, haga doble clic al hacer clic, y luego poner en práctica el al hacer clic controlador de eventos
como sigue:
Delphi:
{Prueba de si los servicios PhoneDialer son compatibles con su dispositivo} if Assigned (PhoneDialerService), entonces
comienzan
C ++:
si (serviceSupported) {
si (edtTelephoneNumber-> texto! = "") {
phoneDialerService-> Llamada (edtTelephoneNumber-> texto); }
else {
ShowMessage ( "type-in por favor un número de teléfono."); edtTelephoneNumber->
SetFocus (); }
} Else ShowMessage ( "Este dispositivo no es compatible con los servicios del marcador del teléfono."); }
iOS Androide
los IFMXPhoneDialerService interfaz proporciona el OnCallStateChanged evento que le permite manejar los cambios de estado de
llamada. los TCallState enumeración describe los posibles estados de llamada telefónica.
En la siguiente tabla se describen los elementos de la TCallState enumeración (los estados admitidos para cada plataforma están
marcados con "+").
Para poner en práctica el OnCallStateChanged controlador de eventos, realice los pasos siguientes:
1. Añadir el siguiente encabezado procedimiento para la sección privada de la definición del formulario:
Delphi:
C ++:
Delphi:
C ++:
Delphi:
procedimiento TForm1.MyOnCallStateChanged (const ACallID: String; const ACallState: TCallState); var OUTTEXT: String; Empezar
caso de ACallState
TCallState.None: OUTTEXT: = '' No hay llamadas;
TCallState.Connected: OUTTEXT: = 'conectado';
TCallState.Incoming: OUTTEXT: = 'Llamada entrante';
TCallState.Dialing: OUTTEXT: = 'Marcación';
TCallState.Disconnected: OUTTEXT: = 'desconectado'; fin;
C ++:
vacío __fastcall TForm1 :: MyOnCallStateChanged (const UnicodeString aCallID, const TCallState aCallState) {
interruptor (aCallState) {
TCallState caso :: Ninguno:
lblCallState-> Texto = "No hay llamadas"; descanso;
Nota: En este proyecto de ejemplo, la TLabel componente está al lado de la caja y la TEdit Hacer una llamada botón,
bajo Número de teléfono.
Ver también
o Tutorial móvil: tomar y compartir una imagen, texto y compartir (iOS y Android)
o FMX.PhoneDialer.IFMXPhoneDialerService
Las muestras
Este tutorial da los pasos básicos para configurar y utilizar las notificaciones remotas (notificaciones push) en su
iOS o dispositivo móvil Android.
Nota: dispositivos Kindle Fire no son compatibles con las notificaciones push.
tiempo real. Ambos iOS y Androide oferta de soporte integrado para las notificaciones remotas, y RAD Studio ofrece un marco RESTO
BaaS que soporta los siguientes protocolos, los proveedores de nube y servicios de back-end:
o protocolos:
ß Analizar gramaticalmente
ß Kinvey
o servicio de back-end:
ß ccsme
Para recibir notificaciones push, es necesario configurar el servicio de mensajería (APS o GCM), el dispositivo, el proveedor de
servicios de nube o EMS, y su aplicación RAD Studio, como se describe en las tres páginas de este tutorial móvil.
notas:
o El termino Notificaciones remotas cubiertas De Apple Push Notification tanto como google Cloud
Mensajería.
o iOS y Androide También tienen notificaciones locales que se envían desde una aplicación o desde el
OS para llamar la atención del usuario. Para más información, ver Móviles Tutorial: Uso de notificaciones
(iOS y Android) .
o El termino Proveedor de servicio cubre en este tutorial los proveedores de servicios cloud (Kinvey y
Analizar) y el proveedor de servicios de back-end EMS.
2. Configuración del proveedor de servicios. Elija una de las siguientes opciones, dependiendo de
el proveedor de servicios:
Ver también
o BaaS general
Ejemplos de código
Este tutorial da los pasos básicos para usar almacenamiento de back-end utilizando Kinvey y Analizar gramaticalmente como proveedores Baas.
En este tutorial se crea una Lista de la compra donde los elementos agregados se almacenan en la nube por el proveedor BaaS, por lo que estos elementos
pueden ser compartidos y actualizados entre los diferentes dispositivos, si es necesario.
iOS Androide
iPod Nexus 7
Con el almacenamiento de back-end que puede almacenar archivos y datos en la nube. Posteriormente, esta información puede ser
Antes de empezar a hacer este tutorial, asegúrese de que ya tiene una cuenta con Kinvey o Analizar gramaticalmente
y que usted ya tiene una aplicación creada en el proveedor de back-end.
Para configurar la interfaz de usuario para esta muestra tutorial siga estos pasos:
2. Caída de una TLabel en el formulario y establezca las siguientes propiedades en el Inspector de Objetos :
3. Caída de una TButton sobre el TLabel y establezca las siguientes propiedades en el Inspector de Objetos:
4. Caída de una TEdit en el formulario y establezca las siguientes propiedades en el Inspector de Objetos:
5. Caída de una TButton sobre el TEdit y establezca las siguientes propiedades en el Inspector de Objetos:
6. Caída de una TListView en el formulario y establezca las siguientes propiedades en el Inspector de Objetos:
En la aplicación, cuando se escribe algo en el TEdit y haga clic Añadir artículo, el contenido escrito en el
TEdit se almacena en la nube, en el Kinvey o Analizar gramaticalmente proveedor de BaaS. Para crear el objeto, utilice el Crear objeto método.
Delphi:
TJSONObject;
LEntity: TBackendEntityValue; empezar si
empezar
LJSONObject: = TJSONObject.Create; LJSONObject.AddPair ( 'item',
Edit1.Text);
BackendStorage1.Storage.CreateObject ( 'ShoppingList', LJSONObject, LEntity);
C ++:
TJSONObject * LJSONObject;
== "") {
ShowMessage ( "Por favor, introduzca un elemento."); } Else {
Eliminar objetos
Para permitir a los usuarios eliminar cualquier elemento de la lista. En el TListView componente, si usted pase su dedo hacia la izquierda o hacia la
derecha sobre uno de los elementos de la TListView, un Borrar botón se muestra en la parte derecha. Para eliminar el elemento cuando el Borrar se
hace clic en el botón de dicho elemento, haga lo siguiente:
Delphi:
procedimiento TForm1.ListView1DeletingItem (Sender: TObject; AIndex: Integer; var ACanDelete: Boolean); var LQuery: string;
LJSONArray: TJSONArray;
LEntities: tarray <TBackendEntityValue>; empezar
ACanDelete: = false;
LJSONArray: = TJSONArray.Create; tratar
si (Longitud (LEntities)> 0) y
BackendStorage1.Storage.DeleteObject ( 'ShoppingList', LEntities [0] .ObjectID) entonces
ACanDelete: = true demás
Nota: La línea LQuery: = Format ( 'query = { "elemento": "% s"}', [(Sender como TListView) .Items [AIndex] .Texto]); es para Kinvey. En Parse, la
palabra consulta debe cambiar para dónde por lo que si usted está usando Analizar como proveedor Baas, en esta línea debe ser LQuery: = Format (
'donde = { "elemento": "% s"}', [(Sender como TListView) .Items [AIndex] .Texto]); .
C ++:
anulará __fastcall TForm1 :: ListView1DeletingItem (TObject * Sender, int AIndex, bool y ACanDelete) {
LQuery [0] = ( "query = {\" punto \ ": \" "+ (listView1-> los items
> operador [] (AIndex) -> texto) + "\"} "); // "query = {\" punto \": \ "" en Kinvey y "dónde = {\" punto \ ": \"" en Analizar
gramaticalmente
BackendStorage1-> Almacenamiento-> QueryObjects ( "ShoppingList", LQuery, 0,
LJSONArray, LEntities);
if (((LEntities.Length)> 0) y BackendStorage1-> Almacenamiento-
> DeleteObject ( "ShoppingList", LEntities [0] .ObjectID)) {
ACanDelete = true; } Else { ShowMessage ( "artículo no se pudo eliminar."); }} __finalmente
Nota: La línea LQuery [0] = ( "query = {\" punto \ ": \" "+ (lista-> Productos-> Artículo [AIndex] -> texto) +" \ "}"); es para Kinvey. En Parse, la palabra consulta
debe cambiar para dónde por lo que si usted está usando Analizar como proveedor Baas, en esta línea debe ser LQuery [0] = artículo ( "donde = {\" \
": \" "+ (lista-> Productos-> Artículo [AIndex] -
> Texto) + "\"} ") ;.
Delphi:
ß En el Visor de clase panel, haga clic TForm1 debajo Unidad 1 y seleccione Agregar método .
C ++:
ß En el Lista de tipos panel (panel izquierdo), ampliar su proyecto, haga clic TForm1 bajo y seleccione Agregar
método .
ß Escribir Actualizar lista bajo el nombre", vacío en “Tipo de retorno”, ajuste “visibilidad” a
público y haga clic Añadir.
Delphi:
TJSONArray;
Litém: TListViewItem; I: Integer;
empezar
ListView1.ClearItems;
porque yo: = 0 a 1 LJSONArray.Count-do begin
Litém: = ListView1.Items.Add;
LItem.Text: = (LJSonArray.Items [I] .GetValue <string> ( 'item')); fin; finalmente
C ++:
LQuery,
0, LJSONArray); ListView1-> Productos-> Borrar ();
3. Haga doble clic en el botón Actualización y el siguiente código por lo que este botón llama al
Actualizar lista método:
Delphi:
C ++:
Actualizar lista(); }
4. Para actualizar la lista una vez que se agrega un elemento, haga doble clic en el AddItemButton para acceder a la
Código de la Al hacer clic evento añadió antes y agregue el código siguiente como la última frase de la
sentencia else:
Delphi:
Actualizar lista;
C ++:
Actualizar lista();
Delphi:
C ++:
Actualizar lista(); }
Ejecución de la aplicación
Para ejecutar la aplicación, siga estos pasos:
Nota: Esta aplicación utiliza la deslizar-a-eliminar característica que se apoya en aplicaciones móviles (iOS y Android), así como
aplicaciones de escritorio (Windows y OS X) cuando la entrada táctil está disponible.
3. Una vez que añadir o eliminar elementos en su aplicación, puede ir a la consola Kinvey o
a Analizar su tablero de instrumentos para ver los cambios también desde la nube.
iPod Nexus 7
Ver también
o BaaS general
Ejemplos de código
Antes de comenzar este tutorial, usted debe leer y realizar la siguiente sesión de tutoría:
En este tutorial se describen los pasos básicos para utilizar SQLite como un almacenamiento de datos local en el dispositivo móvil a través
del marco FireDAC.
iOS Androide
FireDAC es un conjunto único de Universal Data Access componentes para el desarrollo de aplicaciones de bases de datos
multiplataforma para Delphi y C ++ Builder. Con su potente arquitectura común, FireDAC permite el acceso directo de alta
velocidad nativa de Delphi a InterBase, SQLite, MySQL,
o Para las plataformas móviles, FireDAC soportes InterBase Togo tanto como SQLite. Estas
productos de base de datos pueden funcionar en dispositivos iOS y Android.
o Para otras bases de datos, como Oracle, es necesario tener al menos una biblioteca de cliente. En
plataformas Windows, la biblioteca cliente se proporciona como un archivo DLL conectarse. Por lo tanto, es necesario desarrollar
aplicaciones utilizando tecnologías de nivel medio como DataSnap REST para conectarse a estos productos de base de datos desde
un dispositivo móvil.
Otro tutorial explica cómo conectarse a la base de datos de Enterprise sin necesidad de utilizar una biblioteca de cliente en un
dispositivo móvil; ver Tutorial móvil: Conexión a una base de datos empresarial desde un cliente móvil (iOS y Android) .
En primer lugar, es necesario crear un archivo de base de datos SQLite en su plataforma de desarrollo de Windows. Utilice los siguientes pasos, para
que pueda utilizar el Diseñador de formularios para diseñar la interfaz de usuario de su aplicación móvil.
Este tutorial usa una TListView componente como el elemento de interfaz de usuario.
Para configurar un componente ListView y otros elementos de interfaz de usuario, usar los siguientes pasos:
2. Caída de una TButton en el componente de barra de herramientas y establecer las siguientes propiedades en el
Inspector de Objetos :
3. Caída de una TButton en el componente de barra de herramientas y establecer las siguientes propiedades en el
Inspector de Objetos :
4. Caída de una TLabel en el componente de barra de herramientas y establecer las siguientes propiedades en el Objeto
Inspector :
5. Caída de una TListView componente en el formulario y establezca las siguientes propiedades en el Objeto
Inspector :
ß Selecciona el Alinear propiedad a Cliente, de modo que el componente ListView utiliza el entero
formar.
11. Haga clic en el Terminar botón. En este punto, TBindSourceDB y TFDQuery componentes se añadieron a su
formulario.
7. Seleccionar BindSourceDB1.
Nota: Estos últimos pasos no son obligatorios para este tutorial, ya que sólo hay un campo en
BindSourceDB1. Estos pasos son útiles para enlazar con el valor seleccionado si estamos manejando varios campos de una base de
datos.
Delphi:
o por C ++:
El siguiente paso es añadir una característica a esta aplicación para añadir un elemento a la lista de la compra.
o por Delphi:
privado
procedimiento OnInputQuery_Close (const aResult: TModalResult; aValores const: array de cadena);
procedimiento TForm1.OnInputQuery_Close (const aResult: TModalResult; aValores const: array de cadena); var TaskName: String; empezar
o En el Diseñador de formularios, haga doble clic en el ButtonAdd componente. Agregue el código siguiente
a este controlador de eventos:
o por C ++:
o Añadir la siguiente definición de clase (en el archivo .h de su unidad, después de que el previamente definido
tipo):
o Agregue la siguiente declaración de conformidad con la sección privada de la forma (en el archivo .h de su
unidad):
anulará __fastcall TForm1 :: OnInputQuery_Close (const Sistema :: :: Uitypes TModalResult aResult, Sistema :: UnicodeString const *
regreso;
TaskName = aValores [0]; tratar {
ShowMessage (e.Message); }}
o En el Diseñador de formularios, haga doble clic en el ButtonAdd componente. Agregue el código siguiente
a este controlador de eventos:
los InputQuery función muestra un cuadro de diálogo preguntando al usuario final para introducir texto. Esta función devuelve Cierto cuando el usuario
selecciona DE ACUERDO, por lo que se puede agregar datos a la base de datos sólo cuando el usuario selecciona DE ACUERDO y el texto contiene algunos
datos.
3. En el estructura Ver , Haga clic en el ButtonDelete del componente y seleccione Control> Traer al frente . Esto hace
que el botón en la parte delantera visual de la forma activa.
4. En el Diseñador de formularios, haga doble clic en el ButtonDelete componente. Agregue el código siguiente a este controlador de
eventos.
empezar
en el correo: Excepción do
begin
ShowMessage (e.Message); fin; fin; fin;
o por C ++:
ShowMessage (e.Message); }}
en el formulario.
Hasta este punto, usted ha usado SQLite en el escritorio. Esto significa que la base de datos real se encuentra en la unidad de
disco duro local (por ejemplo,
Para conectarse a una base de datos local en el móvil, es necesario realizar las siguientes acciones:
o Compruebe la configuración (para conectarse a la base de datos de archivo) en un archivo local en el marco del
Documentos carpeta (por dispositivo IOS) o interno almacenamiento (para el dispositivo Android).
Antes de poder ejecutar la aplicación en el móvil, es necesario configurar el despliegue de su archivo de base de datos
(shoplist.s3db).
1. Puede agregar la base de datos a su proyecto con uno de los dos métodos siguientes:
ß Haga clic en el nombre del proyecto en el Gerente de proyecto y seleccione Añadir… desde el
menú contextual (o Proyecto> Agregar al proyecto ) para mostrar la Añadir al proyecto caja de diálogo. Vaya a la
ubicación de base de datos
C: \ Users \ Public \ Documents \ Embarcadero \ Studio \ 19.0 \ Samples \ Data,
seleccione la base de datos shoplist.s3db y haga clic Abierto.
2. Después de añadir el archivo de base de datos, la archivos destacados escaparates, haga clic Cancelar a
cierralo.
Las características básicas de esta aplicación están implementadas. Siguiendo los pasos de este tutorial, ha creado un archivo
de base de datos en Windows. El archivo de base de datos no está disponible en su dispositivo móvil a menos que copiarlo en el
dispositivo móvil o crear sobre la marcha. Puede crear una base de datos SQLite y tabla con los siguientes pasos:
o por Delphi:
los TPath expediente se declara en System.IOUtils unidad, por lo que es necesario añadir System.IOUtils en la cláusula usos de su unidad.
aplicación {$ R * .fmx}
utiliza System.IOUtils;
o por C ++:
# terminara si }
Con SQLite puede crear una tabla cuando no existe una tabla, mediante el uso de la CREAR TABLA SI NO EXISTE declaración. Puede
crear una tabla después de que el componente TFDConnection se conecta a la base de datos y antes de que el componente
TFDQuery conecta a la mesa. Utilice los siguientes pasos:
o por Delphi:
FDConnection1.ExecSQL ( 'CREATE TABLE SI NO EXISTE Artículo (ShopItem TEXT NOT NULL)'); fin;
o por C ++:
Ahora su aplicación está lista para funcionar con un simulador o dispositivo móvil conectado.
Para ejecutar la aplicación
ß Ejecutar> Ejecutar
Nota: Si usted tiene un problema con el funcionamiento de la aplicación, siga los pasos que se indican en
Solución de problemas .
Ver también
o Tutorial móvil: Conexión a una base de datos empresarial desde un cliente móvil (iOS y
Androide)
Antes de comenzar este tutorial, usted debe leer y realizar la siguiente sesión de tutoría:
Propina: Para seguir este tutorial, se necesita una licencia para IBToGo o IBLite:
o Si usted es un usuario de prueba, la instalación incluye una licencia de prueba para IBToGo.
Puede probar InterBase en iOS y Android mediante la selección de su licencia de prueba durante la fase de
despliegue, tal como se describe en este tutorial. Las licencias de prueba se instalan con el producto de
prueba, en
C: \ Users \ Public \ Documents \ Embarcadero \ InterBase \ Redist \ Inte rBaseXE7.
Siga los pasos a IBLite e implementación de prueba IBToGo Licencias obtener e instalar el archivo de
licencia.
Nota: En los dispositivos Android, aplicaciones InterBase ToGo requieren específica permisos a ajustar y, específicamente:
o internet ( es necesario conectar con un servidor remoto) En este tutorial se describen los pasos básicos para navegar por los
datos gestionados por InterBase Togo en sus dispositivos iOS y Android a través del marco FireDAC.
Nota: Puede utilizar FireDAC, dbexpress y Interbase expresos componentes (IBX) para construir
interbase Togo aplicaciones. Para una discusión detallada sobre el uso de Interbase expreso componentes en una
aplicación Delphi, lea la Introducción a InterBase expreso artículo. Para este tutorial, vamos a conectar a interbase Togo utilizando
FireDAC.
FireDAC es un conjunto único de Universal Data Access componentes para el desarrollo de aplicaciones de bases de datos
multiplataforma para Delphi y C ++ Builder. Con su potente arquitectura común, FireDAC permite el acceso directo de alta
velocidad nativa de Delphi a InterBase, SQLite, MySQL, SQL Server, Oracle, PostgreSQL, IBM DB2, SQL Anywhere, Access,
Firebird, Informix, y mucho más.
o Para las plataformas móviles, FireDAC soportes InterBase Togo tanto como SQLite. Estas
productos de base de datos pueden funcionar en dispositivos iOS y Android.
o Para otras bases de datos, como Oracle, es necesario tener al menos una biblioteca de cliente. En
plataformas Windows, la biblioteca cliente se proporciona como un archivo DLL conectarse. Por lo tanto, es necesario desarrollar
aplicaciones utilizando tecnologías de nivel medio como DataSnap para conectarse a estos productos de base de datos desde un
dispositivo móvil.
ß Selecciona el Alinear propiedad a Cliente, de modo que el componente ListView utiliza el entero
formar.
5. Agrega un TLabel componente al Grupo Especial, y establezca las siguientes propiedades en el Objeto
Inspector:
2. Selecciona el Conectado propiedad a Cierto. Nota: Si se produce un error ( "base de datos no disponible") en el
entorno de desarrollo, esto significa que usted no tiene una licencia vigente para InterBase. La licencia de InterBase Developer
Edition se incluye como parte del producto de algunas ediciones del producto. Para más información, ver
Solución de problemas .
2. Haga clic en el Ejecutar botón para ver los resultados del comando.
6. Abre el LiveBindings diseñador y conectar los datos y la interfaz de usuario como sigue:
1. Haga clic NOMBRE COMÚN en FDQuery1, y arrastrar el cursor del ratón para Item.Text
en ListView1.
Nota: los Preparación de una aplicación de tiempo de ejecución FireDAC tema, se explica el uso de los componentes
TFDGUIxWaitCursor y TFDPhysIBDriverLink en una aplicación FireDAC.
Para conectarse a una base de datos local en el móvil, es necesario realizar las siguientes acciones:
o Compruebe la configuración (para conectarse a la base de datos de archivo) en un archivo local en el marco del
Documentos carpeta (por dispositivo IOS) o interno almacenamiento (para el dispositivo Android).
La implementación de InterBase Togo Archivos necesarios y el archivo de base de datos para móviles
Para ejecutar la aplicación en el móvil, que necesita para implementar los siguientes archivos:
o archivo requerido interbase Togo (el archivo de licencia y otros archivos de configuración)
1. Puede agregar la base de datos a su proyecto con uno de los dos métodos siguientes:
ß Haga clic en el nombre del proyecto en el Gerente de proyecto y seleccione Añadir… desde el
menú contextual (o Proyecto> Agregar al proyecto ) para mostrar la Añadir al proyecto caja de diálogo. Vaya a la
ubicación de base de datos
C: \ Users \ Public \ Documents \ Embarcadero \ Studio \ 19.0 \ Samples \ Data,
seleccione la base de datos dbdemos.gdb y haga clic Abierto.
2. Después de añadir el archivo de base de datos, la archivos destacados escaparates. Seleccionar InterBase
Ir en el Función ficheros, y haga clic DE ACUERDO para cerrar el cuadro de diálogo Archivos destacado.
Como se puede ver en la siguiente imagen, el reg_ibtogo.txt archivo de licencia se ha seleccionado para este tutorial.
5. Ver cómo el Ruta remota de dbdemos.gdb se ha establecido para las plataformas iOS y Android:
Como se acaba de configurar, al ejecutar la aplicación en el dispositivo móvil, el archivo de base de datos (dbdemos.gdb) se va
a desplegar a la Documentos carpeta (para la plataforma iOS) o interno
almacenamiento (para la plataforma Android) en la zona del recinto de seguridad de la aplicación de dispositivos múltiples. Para el TFDConnection
ß por Delphi:
{$ ENDIF} end;
los TPath expediente se declara en System.IOUtils unidad, por lo que es necesario añadir System.IOUtils
en la cláusula de usos, como sigue:
aplicación {$ R * .fmx}
{$ R * .NmXhdpiPh.fmx ANDROID} {$ R *
.iPhone4in.fmx IOS}
ß por C ++:
definido (_PLAT_ANDROID)
FDConnection1-> params-> Valores [ "Protocolo"] = "local"; FDConnection1-> params->
Valores [ "Base de datos"] =
Sistema :: :: Ioutils TPath :: Combine (Sistema :: Ioutils :: :: TPath GetDocumentsPath (), "dbdemos.gdb");
# terminara si }
Ahora su aplicación está lista para funcionar ( Ejecutar> Ejecutar o pulse F9). Usted debe ser capaz de navegar por los datos del
mismo modo que en el IDE. Puede reducir la lista use la búsqueda.
Solución de problemas
Problemas InterBase
Véase el siguiente sección con información detallada sobre problemas de licencia de Interbase.
Nota: Siga los pasos a IBLite e implementación de prueba IBToGo Licencias para obtener un archivo de licencia válido.
Si la aplicación genera una excepción sin tener código correcto manejo excepción, su aplicación multi-dispositivo simplemente se
bloquea (desaparece) en tiempo de ejecución.
Si se encuentra con un accidente, es posible que desee conectarse manualmente a la base de datos, mientras que a solucionar el
problema siguiendo los siguientes pasos:
Delphi:
en el correo: Excepción do
begin
ShowMessage (e.Message); fin; fin; fin;
C ++:
(Exception & e) {
ShowMessage (e.Message); }}
Ver también
o InterBase Togo
o http://www.embarcadero.com/products/interbase/product-editions
o Tutorial móvil: Conexión a una base de datos empresarial desde un cliente móvil (iOS y
Androide)
Las muestras
Precaución: dbExpress, que se describe en este tutorial, está siendo obsoleto. Esto significa que dbexpress será retirado de
RAD Studio en una próxima versión. En lugar de dbexpress, recomendamos que utilice nuestra solución de base de datos más
reciente, FireDAC,
que se describe en un tutorial similares, aquí:
Tutorial móvil: Usando FireDAC y SQLite (iOS y Android) . Antes de comenzar este tutorial, usted debe
o Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (IOS y
Androide)
En este tutorial se describen los pasos básicos para utilizar SQLite como un almacenamiento de datos local en el dispositivo móvil a
través del marco dbexpress.
o Para las plataformas móviles, soporta dbexpress InterBase Togo tanto como SQLite. Estas
productos de base de datos pueden funcionar en dispositivos iOS y Android.
o Para otras bases de datos, como Oracle, es necesario tener al menos una biblioteca de cliente. En
plataformas Windows, la biblioteca cliente se proporciona como un archivo DLL conectarse. Por lo tanto, es necesario desarrollar
aplicaciones utilizando tecnologías de nivel medio como DataSnap para conectarse a estos productos de base de datos desde un
dispositivo móvil.
Otro tutorial explica cómo conectarse a la base de datos de Enterprise sin necesidad de utilizar una biblioteca de cliente en un
dispositivo móvil; ver Tutorial móvil: Conexión a una base de datos empresarial desde un cliente móvil (iOS y Android) .
1. Ir Data Explorer , Haga clic en el SQLite nodo y seleccione Agregar nueva conexión:
6. De vuelta a la Nuevo enlace cuadro de diálogo, haga clic en el Conexión de prueba botón. Con este
operación, el nuevo archivo de base de datos se crea si no existía un archivo:
Nota: Asegurarse de que sqlite3.dll está presente en el sistema de desarrollo. Si este archivo no está presente, descarga de
sqlite3.dll http://www.sqlite.org/download.html a la ruta del sistema (por ejemplo,
C: \ Windows \ SysWOW64 para Windows de 64 bits).
1. Sobre el Data Explorer , Haga doble clic en el Lista de la compra nodo bajo la sección SQLite,
botón derecho del ratón Mesas, y luego seleccione nueva tabla en el menú contextual.
3. Haga clic en el Salvar botón y especificar un nombre de tabla (por ejemplo, Ít.)
Este tutorial usa una TListBox componente como el elemento de interfaz de usuario.
Para configurar un componente ListBox y otros elementos de interfaz de usuario, usar los siguientes pasos:
3. Caída de una TButton en el componente de barra de herramientas y establecer las siguientes propiedades en el
Inspector de Objetos :
4. Caída de una TButton en el componente de barra de herramientas y establecer las siguientes propiedades en el
Inspector de Objetos :
5. Caída de una TLabel en el componente de barra de herramientas y establecer las siguientes propiedades en el Objeto
Inspector :
6. Caída de una TListBox componente en el formulario y establezca las siguientes propiedades en el Objeto
Inspector :
ß Selecciona el Alinear propiedad a Cliente, de modo que el componente ListBox utiliza el entero
formar.
Después de estos pasos se conecta la interfaz de usuario de la aplicación con los datos de una base de datos SQLite. Si ha utilizado una tabla con
los datos existentes para este tutorial, ahora debería ver los datos actuales de diseñador de formularios.
Delphi:
C ++ Builder:
anulará __fastcall TForm1 :: ListBox1ItemClick (const TCustomListBox * Remitente, const TListBoxItem * Elemento) {
si (ListBox1-> Seleccionado)
ButtonDelete-> Visible = True; más
El siguiente paso es añadir una característica a esta aplicación para añadir un elemento a la lista de la compra.
Delphi:
procedimiento TForm1.OnInputQuery_Close (const aResult: TModalResult; aValores const: array de cadena); var TaskName: string; empezar
entonces
empezar
. SQLQueryInsert.ParamByName ( 'ShopItem') AsString: = TaskName; SQLQueryInsert.ExecSQL ();
ItemTable.Refresh;
C ++ Builder:
typedef void __fastcall (__closure * TInputCloseQueryProcEvent) (const Sistema :: :: Uitypes TModalResult aResult,
OnInputQuery_Close (const Sistema :: :: Uitypes TModalResult aResult, Sistema :: UnicodeString const * aValores, const int
AValues_High) {
TaskName cadena; TaskName = "";
si (aResult! = Mrok)
regreso;
TaskName = aValores [0]; tratar { si (TaskName.Trim
()! = "")
SQLQueryInsert-> ParamByName ( "ShopItem") -> AsString = TaskName; SQLQueryInsert-> ExecSQL
(); ItemTable-> Actualizar ();
los InputQuery función muestra un cuadro de diálogo que pide al usuario final para introducir un texto. Esta función devuelve Cierto cuando el usuario selecciona
DE ACUERDO, por lo que se puede agregar datos a la base de datos sólo cuando el usuario selecciona DE ACUERDO y el texto contiene algunos datos.
3. En la vista de estructura, seleccione el ButtonDelete componente. Agregue el código siguiente a este controlador de eventos.
empezar
TaskName;
SQLQueryDelete.ExecSQL ();
ItemTable.Refresh;
LinkFillControlToField1.BindList.FillList; Si ListBox1.Selected <> nil
entonces
ButtonDelete.Visible: = true demás
en el correo: Excepción do
begin
ShowMessage (e.Message); fin; fin; fin;
C ++ Builder:
AsString = TaskName;
SQLQueryDelete-> ExecSQL (); ItemTable->
Actualizar ();
LinkFillControlToField1-> BindList-> FillList (); si (ListBox1-> Seleccionado)
ShowMessage (e.Message); }}
Hasta este punto, usted ha usado SQLite en el escritorio. Esto significa que la base de datos real se encuentra en la unidad de
disco duro local (por ejemplo,
C: \ Users \ Public \ Documents \ Embarcadero \ Studio \ 19.0 \ Samples \ Data \ shoplist.s3db). En el dispositivo móvil, las aplicaciones son de
arena en caja, y por lo general sólo se pueden leer y escribir datos que se encuentra en el Documentos carpeta (por dispositivo IOS) y interno de
almacenamiento (por dispositivo Android) debajo de la carpeta de la aplicación.
o Compruebe la configuración (para conectarse a la base de datos de archivo) en un archivo local en el marco del
Documentos carpeta (por dispositivo IOS) o interno almacenamiento (para el dispositivo Android).
Antes de poder ejecutar la aplicación en el móvil, es necesario configurar el despliegue de su archivo de base de datos
(shoplist.s3db).
1. Puede agregar la base de datos a su proyecto con uno de los dos métodos siguientes:
ß Haga clic en el nombre del proyecto en el Gerente de proyecto y seleccione Añadir… desde el
menú contextual (o Proyecto> Agregar al proyecto ) para mostrar la Añadir al proyecto caja de diálogo. Vaya a la
ubicación de base de datos
C: \ Users \ Public \ Documents \ Embarcadero \ Studio \ 19.0 \ Samples \ Data,
seleccione la base de datos shoplist.s3db y haga clic Abierto.
2. Después de añadir el archivo de base de datos, la archivos destacados escaparates, haga clic Cancelar a
cierralo.
Como se acaba de configurar, al ejecutar la aplicación en el dispositivo móvil, el archivo de base de datos (shoplist.s3db) está listo para
ser desplegado en el Documentos carpeta (para la plataforma iOS) o interno
almacenamiento (para la plataforma Android) en la zona del recinto de seguridad de la aplicación de dispositivos múltiples.
Las características básicas de esta aplicación están implementadas. A medida que trabajó en el Explorador de datos, que ha creado un
archivo de base de datos en Windows. El archivo de base de datos no está disponible en su dispositivo móvil a menos que copiarlo en el
dispositivo móvil o crear sobre la marcha. Puede crear una base de datos SQLite y tabla con los siguientes pasos:
Delphi:
los TPath expediente se declara en System.IOUtils unidad, por lo que es necesario añadir System.IOUtils en la cláusula usos de su unidad.
C ++ Builder:
# terminara si
}
los TPath expediente se declara en System.IOUtils biblioteca, por lo que es necesario agregar # incluir <System.IOUtils.hpp> en
su unidad de cabecera.
Con SQLite puede crear una tabla cuando no existe una tabla, mediante el uso de la CREAR TABLA SI NO EXISTE declaración. Puede
crear una tabla después de que el componente se conecta a TSQLConnection
Delphi:
ShoppinglistConnection.ExecuteDirect ( 'CREATE TABLE SI NO EXISTE Artículo (ShopItem TEXT NOT NULL)'); fin;
C ++ Builder:
ß Ejecutar> Ejecutar
Nota: Si usted tiene un problema con el funcionamiento de la aplicación, siga los pasos que se indican en
Solución de problemas .
Ver también
o Tutorial móvil: Conexión a una base de datos empresarial desde un cliente móvil (iOS y
Androide)
Precaución: dbExpress, que se describe en este tutorial, está siendo obsoleto. Esto significa que dbexpress será retirado de
RAD Studio en una próxima versión. En lugar de dbexpress, recomendamos que utilice nuestra solución de base de datos más
reciente, FireDAC,
que se describe en un tutorial similares, aquí:
Tutorial móvil: El uso de InterBase Togo con FireDAC (iOS y Android) . Antes de comenzar este tutorial,
Propina: Siguiendo este tutorial requiere una licencia para IBToGo o IBLite:
o Si usted es un usuario de prueba, la instalación incluye una licencia de prueba para IBToGo.
Puede probar InterBase en iOS y Android mediante la selección de su licencia de prueba durante la fase de
despliegue, tal como se describe en este tutorial. Las licencias de prueba se instalan con el producto de
prueba, en
C: \ Users \ Public \ Documents \ Embarcadero \ InterBase \ Redist \ Inte rBaseXE7.
Nota: En los dispositivos Android, aplicaciones InterBase ToGo requieren específica permisos a ajustar y, específicamente:
o internet ( es necesario conectar con un servidor remoto) En este tutorial se describen los pasos básicos para navegar por los
datos gestionados por InterBase Togo en sus dispositivos iOS y Android a través del marco dbexpress.
Nota: Puede utilizar FireDAC, dbexpress y Interbase expresos componentes (IBX) para construir
interbase Togo aplicaciones. Para una discusión detallada sobre el uso de Interbase expreso componentes en una
aplicación Delphi, lea la Introducción a InterBase expreso artículo. Para este tutorial, vamos a conectar a interbase Togo usando
marco dbexpress.
o Para las plataformas móviles, soporta dbexpress InterBase Togo tanto como SQLite. Estas
productos de base de datos pueden funcionar en dispositivos iOS y Android.
o Para otras bases de datos, como Oracle, es necesario tener al menos una biblioteca de cliente. En
plataformas Windows, la biblioteca cliente se proporciona como un archivo DLL conectarse. Por lo tanto, es necesario desarrollar
aplicaciones utilizando tecnologías de nivel medio como DataSnap para conectarse a estos productos de base de datos desde un
dispositivo móvil.
ß Selecciona el Alinear propiedad a Cliente, de modo que el componente ListView utiliza el entero
formar.
5. Agrega un TLabel componente al Grupo Especial, y establezca las siguientes propiedades en el Objeto
Inspector:
1. Esta aplicación utiliza InterBase Togo, por lo que establece la Conductor propiedad a IBLite / Togo.
3. Haga clic en los puntos suspensivos [...] para el Parámetros propiedad, y establecer el Base de datos valor a
C: \ Users \ Public \ Documents \ Embarcadero \ Studio \ 19.0 \ Samples \ Data \ db demos.gdb ( ubicación de la base
de datos).
entorno de desarrollo, esto significa que usted no tiene una licencia vigente para InterBase. La licencia de InterBase Developer
Edition se incluye como parte del producto de algunas ediciones del producto. Para más información, ver
Solución de problemas .
3. Abre el LiveBindings diseñador y conectar los datos y la interfaz de usuario como sigue:
1. Haga clic NOMBRE COMÚN en SQLDataSet1, y arrastrar el cursor del ratón para
Item.Text en ListView1.
o Compruebe la configuración (para conectarse a la base de datos de archivo) en un archivo local en el marco del
Documentos carpeta (por dispositivo IOS) o interno almacenamiento (para el dispositivo Android).
Implementar InterBase Togo, dbExpress driver y el Archivo de Base de datos para móviles
Para ejecutar la aplicación en el móvil, que necesita para implementar los siguientes archivos:
o interbase Togo
1. Puede agregar la base de datos a su proyecto con uno de los dos métodos siguientes:
ß Haga clic en el nombre del proyecto en el Gerente de proyecto y seleccione Añadir… desde el
menú contextual (o Proyecto> Agregar al proyecto ) para mostrar la Añadir al proyecto caja de diálogo. Vaya a la
ubicación de base de datos
C: \ Users \ Public \ Documents \ Embarcadero \ Studio \ 19.0 \ Samples \ Data,
seleccione la base de datos dbdemos.gdb y haga clic Abierto.
2. Después de añadir el archivo de base de datos, la archivos destacados escaparates. Seleccionar el siguiente
módulos de base de datos y, a continuación, haga clic DE ACUERDO para cerrar el cuadro de diálogo Archivos destacado:
Como se puede ver en la siguiente imagen, el reg_ibtogo.txt archivo de licencia se ha seleccionado para este tutorial.
ß Dbexpress InterBase Conductor Consejo: Si va a probar la aplicación en el simulador de iOS, entonces también
Como se acaba de configurar, al ejecutar la aplicación en el dispositivo móvil, el archivo de base de datos (dbdemos.gdb) se va
a desplegar a la Documentos carpeta (para la plataforma iOS) o interno
almacenamiento (para la plataforma Android) en la zona del recinto de seguridad de la aplicación de dispositivos múltiples.
Como se describe en el paso anterior, el componente TSQLConnection está conectado a una base de datos en el sistema de archivos local
con una ruta absoluta. Así que hay que sustituir la ubicación del archivo antes de conectarse a la base de datos, de la siguiente manera:
Delphi:
C ++:
definido (_PLAT_ANDROID)
SQLConnection1-> params-> Valores [ "Base de datos"] =
Sistema :: :: Ioutils TPath :: Combine (Sistema :: Ioutils :: :: TPath GetDocumentsPath (), "dbdemos.gdb");
# terminara si }
Ahora su aplicación está lista para funcionar. Usted debe ser capaz de navegar por los datos del mismo modo que en el IDE.
Puede reducir la lista use la búsqueda.
iOS Androide
Solución de problemas
Problemas InterBase
Véase el siguiente sección con información detallada sobre problemas de licencia de Interbase.
Nota: Siga los pasos a IBLite e implementación de prueba IBToGo Licencias para obtener un archivo de licencia válido.
Si la aplicación genera una excepción sin tener código correcto manejo excepción, su aplicación multi-dispositivo simplemente se
bloquea (desaparece) en tiempo de ejecución.
Si se encuentra con un accidente, es posible que desee conectarse manualmente a la base de datos, mientras que a solucionar el
problema siguiendo los siguientes pasos:
2. Caída de un botón en el formulario, y crear el siguiente controlador de eventos para conectar manualmente
a la base de datos:
Delphi:
en el correo: Excepción do
begin
ShowMessage (e.Message); fin; fin; fin;
C ++:
Mensaje); }
Ver también
o http://www.embarcadero.com/products/interbase/product-editions
ß Tutorial móvil: Utilización de componentes ListBox para mostrar una vista de tabla (IOS y
Androide)
o Escoger Inicio | programas | Embarcadero InterBase XE7 | <Xx> = bit ejemplo gd_db |
Administrador del servidor de InterBase y verificar que el servidor de InterBase se está ejecutando. El servidor de InterBase debe
ejecutar antes de crear o ejecutar el ejemplo. En este tutorial se describe cómo conectarse a una base de datos de la empresa desde una
Para conectarse a una base de datos de Enterprise, es necesario tener una biblioteca cliente. En la mayoría de los casos, la biblioteca cliente es proporcionada
por el proveedor de base de datos en formato DLL. Esta estrategia no funciona bien para los dispositivos móviles porque ninguna biblioteca cliente está
disponible. Para resolver este problema, se puede desarrollar una
nivel medio para conectarse a una base de datos empresarial, y su aplicación se puede comunicar con el nivel medio.
RAD Studio proporciona la DataSnap marco con el que se puede desarrollar el nivel medio (y tener acceso al nivel medio), casi
sin necesidad de codificación. En este tutorial se describen los pasos para desarrollar el nivel medio y luego desarrollar el
cliente móvil.
En primer lugar, crear un servidor DataSnap que expone una tabla de un servidor de base de datos. En este tutorial se utiliza una
DataSnap servidor VCL Forms Application como un servidor DataSnap.
1. Con el fin de crear un proyecto nuevo Delphi o C ++, seleccione Archivo> Nuevo> Otros y desde el Nuevos objetos diálogo
Seleccionar:
4. En el cuarto paso, deje el puerto de comunicaciones TCP / IP predeterminada de 211. Esta voluntad
asegúrese de que la comunicación entre el cliente y el servidor pasará a través del puerto de
DataSnap defecto.
4. Guarde la unidad de métodos de servidor (por defecto como creado por el Asistente:
ServerMethodsUnit1) como ServerModuleUnit.
5. Guarde la unidad de contenedor de servidor (por defecto como creado por el Asistente:
ServerContainerUnit1) como ServerContainerUnit.
TDataSetProvider paquetes de datos de un conjunto de datos y pasa uno o más transportables paquetes de datos al cliente
DataSnap.
Nota: Este tutorial utiliza InterBase como un ejemplo. Sin embargo, puede conectarse a cualquier servidor de base de datos
utilizando los mismos pasos. Seleccione el controlador adecuado, y otras propiedades para apuntar a su base de datos.
Acaba de crear un nuevo módulo de servidor que contiene un conjunto de datos y una DataSetProvider que los paquetes de datos a la
capa siguiente. El siguiente paso es exponer el módulo de servidor al cliente DataSnap.
Delphi:
Con este controlador de eventos, el servidor DataSnap expone a los proveedores, así como los métodos públicos en esta clase a
un cliente DataSnap. Sobre la base de los pasos en la sección anterior, ahora se va a exponer la DataSetProvider_EMPLOYEE
DataSetProvider componente a su cliente DataSnap.
Implementación del servidor DataSnap es completa. Botón derecho del ratón DataSnapServerProject.exe
y seleccione Ejecutar sin depurar.
Ahora se puede ver el servidor DataSnap que se ejecuta en la máquina Windows. Debido a que este servidor DataSnap no tiene ningún elemento de
interfaz de usuario, que se parece a un formulario en blanco, y esto es como era de esperar en este punto.
1. En el Gerente de proyecto , botón derecho del ratón DataSnapTutorialProjectGroup, y seleccione Agregar nuevo proyecto.
TSQLConnection encapsula una conexión dbexpress a un servidor de base de datos. Además, es compatible con el servidor DataSnap.
Si usted ve un error, por favor, compruebe las propiedades que acaba de configurar.
TClientDataSet implementa un conjunto de datos de base de datos independiente, y esto puede ser usado como un amortiguador inmemory local de los
registros de otro conjunto de datos.
ß TListBox componente
7. Abre el LiveBindings diseñador y conectar los datos y la interfaz de usuario como sigue:
1. Haga clic NOMBRE COMPLETO en BindSourceDB1, y arrastrar el cursor del ratón para Item.Text
en ListBox1:
iOS Androide
Para ejecutar la aplicación en el simulador de iOS, que necesita para implementar los siguientes archivos:
o Biblioteca MIDAS
ß Biblioteca MIDAS
aplicación. Usted debe ser capaz de navegar por los datos tal como lo hace en el IDE.
Ver también
o Datasnap.DSServer.TDSServer
En la siguiente tabla se enumeran los componentes FireMonkey que se utilizan en cada uno de los tutoriales móviles:
El uso de un componente de botón TButton , Posición TSpeedButton , Altura , Anchura , StyleLookup , tintColor , IconTintColor , Nombre del grupo ,
con diferentes estilos (iOS y Android)
Se presiona
El uso de un calendario
TDateEdit
Componente para elegir una fecha
ShowCheckBox
(iOS y Android)
Utilizar un componente
MultiView a la pantalla TMultiView , TDrawerAppearance visible , Modo , MasterButton , DoOpen , DoClose , GetDisplayName
alternativa Vistas de la ,
Información (iOS y Android) DoInstall , TargetControl , DrawerOptions , ShadowOptions
mostrar las páginas (iOS y Android) TTabControl , TTabItem , Editor MultiResBitmap , Lista de Acción , TButton
El uso de SQLite y
Data Explorer , TListBox , TButton , TLabel , TSQLQuery , InputQuery ,
dbexpress (iOS y Android)
Gestor de despliegue
Conexión a una
Asistente del servidor DataSnap , TDSServerModule , TSQLConnection ,
Empresa de base de datos desde un
TSQLDataSet , TDataSetProvider , TDSProviderConnection , TClientDataSet ,
cliente móvil (iOS y Android)
TListBox
Nota: Esta lista de componentes está destinado sólo para fines informativos y puede que no sea del todo exacta o
completa.