BIBLIA DE FLASH-y-PHP

Biblia deFlash®

y PHP

Matthew Keefe

1

Biblia de Flash® y PHP

Publicado por Wiley Editorial, Inc. 10475 Crosspoint Boulevard Indianapolis, IN 46256 www.wiley.com Copyright © 2008 Publicado por Wiley Editorial, Inc., Indianápolis, Indiana Publicado simultáneamente en Canadá ISBN: 978-0-470-25824-8 Fabricado en los Estados Unidos de América 10 9 8 7 6 5 4 3 2 1 Ninguna parte de esta publicación puede ser reproducida, almacenada en un sistema de recuperación o transmitida en cualquier forma o cualquier medio, sea electrónico, mecánico, fotocopia, grabación, el escaneo o de otro modo, excepto según lo permitido en las Secciones 107 y 108 de la Ley Derechos de Autor Estados Unidos 1976, sin que el previo por escrito de la editorial, o a través del pago de la tasa por copia correspondiente al Copyright Clearance Center, 222 Rosewood Drive, Danvers, MA 01923, (978) 750-8400, fax (978) 646-8600. Pida a la Editorial para autorización deberán dirigirse al Departamento Jurídico, Wiley Editorial, Inc., 10475 Crosspoint Blvd., Indianápolis, IN 46256, (317) 572-3447, fax (317) 572-4355, o en línea en http://www.wiley.com/go/permissions.

LIMITE DE RESPONSABILIDAD/RENUNCIA DE GARANTIA : EL EDITORIAL Y EL AUTOR NO HACEN NINGUNA DECLARACION O GARANTÍA CON RESPECTO A LA PRECISIÓN O INTEGRIDAD DEL CONTENIDO DE ESTE TRABAJO Y EXPRESAMENTE DECLINA CUALQUIER GARANTÍA, INCLUYENDO SIN LIMITACIÓN, LAS GARANTÍAS DE IDONEIDAD PARA UN PROPOSITO PARTICULAR. NINGUNA GARANTÍA SE PUEDE CREAR O AMPLIAR PARA VENTAS O MATERIAL PROMOCIONAL. EL ASESORAMIENTO Y LAS ESTRATEGIAS CONTENIDAS EN ESTE SITIO NO PUEDE SER ADECUADO PARA CADA SITUACIÓN. ESTA OBRA SE VENDE CON EL ENTENDIMIENTO QUE EL EDITOR ES QUE NO SE DEDICA A PROMOCIONAR SERVICIOS LEGALES, CONTABLES, U OTROS SERVICIOS PROFESIONALES. SI LA AYUDA PROFESIONAL ES REQUERIDA, LOS SERVICIOS DE UN PROFESIONAL COMPETENTE DEBE BUSCARSE. NI LOS EDITORES NI EL AUTOR SERÁN RESPONSABLES POR DAÑOS DERIVADOSDE AQUÍ. EL HECHO DE QUE UN SITIO WEB U ORGANIZACIÓN SE HACE REFERENCIA EN ESTE TRABAJO COMO UNA CITACIÓN Y/O UNA FUENTE POTENCIAL DE NUEVA INFORMACIÓN DE LA ORGANIZACIÓN WEB O PUEDA PROPORCIONAR O RECOMENDACIONES QUE PUEDA HACER. ADEMAS, LOS LECTORES DEBEN SER CONSCIENTES DE QUE INTERNET SITIOS WEB QUE APARECEN EN ESTE TRABAJO HAN CAMBIADO O DESAPARECIDO ENTRE CUANDO ESTA OBRA FUE ESCRITA Y CUANDO SE LEE.

Para información general sobre nuestros productos y servicios o para obtener apoyo técnico, por favor contacte a nuestro Departamento de Atención al Cliente dentro de los EE.UU. al (800) 762-2974, fuera de los EE.UU al (317) 572-3993 o por fax (317) 572-4002.

Biblioteca del Congreso Número Control: 2008925780 Marcas: Wiley, y el logo de Wiley, y marcas relacionada con el comercio son marcas comerciales o marcas comerciales registradas de John Wiley & Sons, Inc. y/o sus afiliadas, en los Estados Unidos y otros países, y no puede ser utilizada sin permiso por escrito.Flash es una marca registrada de Adobe Systems Incorporated en los Estados Unidos y/u otros países. Todas las demás marcas son propiedad de sus respectivos propietarios. Wiley Editorial, Inc., no está asociado con ningún producto o proveedor mencionado en este libro.Wiley también publica sus libros en una variedad de formatos electrónicos. Parte del contenido que aparece en la impresión pueden no estar disponibles en los libros electrónicos.

2

Acerca del Autor Matthew Keefe es un nuevo diseñador de medios y desarrollador, con una sólida experiencia en el desarrollo de aplicaciones para la web y fuera de línea. Originalmente era una artista de tiempo completo gráfico, se encontró que gran parte de la programación relacionada con su trabajo de diseño estaba subcontratado. Matt aprendió rápidamente la programación para la web y descubrió una habilidad valiosa, pero poco conocido-puesto en esta industria, que la inteligencia es la capacidad para construir un sitio y también la capacidad de fuerza diseñarlo. Este fue preferido por los clientes, ya que podría hacer todo el proyecto con un estudio.Matt ha trabajado con empresas como Delphi, PhotoshopCafe, Kineticz Interactive, y las organizaciones Studios para nombrar unos pocos. Su trabajo ha sido publicado en Cómo Wow con Flash (Peachpit Press) para que él contribuyera como autor y el editor técnico. Matt también ha finalizado recientemente un puesto de trabajo como el editor técnico de primera de ActionScript 3 (Adobe Dev Library).

Ejemplos de su obra se puede encontrar en su expediente personal en mkeefe.com.

3

A mi padre amoroso.Creditos

Senior Acquisitions Editor Stephanie McComb Project Editor Beth Taylor Technical Editor Navid Mitchell Copy Editor Kim Heusel Editorial Manager Robyn Siesky Business Manager Amy Knies Sr. Marketing Manager Sandy Smith Vice President and Executive Group Publisher Richard Swadley Vice President and Executive Publisher Bob Ipsen Vice President and Publisher Barry Pruett Project Coordinator Erin Smith Graphics and Production Specialists Claudia Bell Jennifer Mayberry Ronald Terry Quality Control Technician Susan Moritz Media Development Project Manager Laura Moss-Hollister Media Development Coordinator Jenny Swisher Associate Producer Shawn Patrick Proofreading Christine Sabooni Indexing Broccoli Information Management

4

PrólogoMacromedia. . . error Adobe Flash es manos abajo de uno de las más impresionantes y poderosas herramientas para cualquier diseñador, cuando se trata de llevar una experiencia para el usuario. Y como Flash sigue evolucionando no sólo para web, para lo cual es popular, pero también para usuarios fuera de línea con la evolución de la plataforma, como Adobe AIR y la amplia gama de herramientas de terceros que pueden ser utilizados. Sin embargo, para un desarrollador de Flash hardcore ha tenido una mala reputación. Debido principalmente al hecho de que el 1.0 es un idioma torpe, desgarbado, e inmaduro. En comparación con otros lenguajes populares, cuando se introdujo como 1,0, que no era algo que se toma en serio en los ojos de un desarrollador y con razón. Pero entonces, si Flash es tan obstaculizar, ¿por qué estoy incluso la lectura de un prólogo para un libro sobre el tema?

Las cosas han cambiado, cambiado drásticamente. AS 3.0 ya está aquí y es uno de los mejores lenguajes en todo, si se entiende. AS 2.0 fue un paso en la dirección correcta, pero como 3.0 ha superado los sueños de todos los desarrolladores de Flash. Archivos de pequeño tamaño, desempeño muy sólido, e incluso algunos de manejo de datos de los rivales de Java, así que realmente no existe un desarrollador que puede decir que ya no es un lenguaje concreto.

Y con AS 3.0 una nueva era de tratamiento de los datos se introducen en Flash. Y no sólo con Flash, pero cuando empiezas a mezclar en PHP5, MySQL 5, ASP, AMFPHP, y otros métodos de manipulación de datos, las posibilidades que se abren en una nueva esfera. Los datos está en juego en AS 3.0, y es sólo una cuestión de leer un libro como este para aplicarla. Sockets, XML, servicios web y otras fuentes de datos externas permiten un desarrollador de Flash para conseguir realmente sucio en una fuente de datos y actualizar el contenido sin tocar los archivos Flash de nuevo. La ventaja es que permite más tiempo para desarrollar una experiencia de usuario atractivas sin preocuparse de las ediciones de repetición, el presupuesto futuro de un cliente, etc. en realidad permite a los desarrolladores de Flash graves a seguir trabajando con las fuentes de datos a medida que se desarrollan y se concentran en los beneficios de matizar el contenido en sí, en lugar de lo que el contenido es en el momento de desarrollo que pueden cambiar en el capricho de un cliente más adelante.

Atrás han quedado los días en que usted se basaría sitio web de un cliente, tiene una tonelada de fondos soberanos más grandes, sólo para que ellos necesitan constantemente actualizaciones para las fotos, la copia, artículos del catálogo, etc. En este libro leerás como utilizar los métodos mencionados para ampliar su comprensión de sacar la última restricción para conocer Flash de gran alcance, la actualización sin publicar, la apertura de un FLA, o preocuparse de si el cliente te ha enviado la copia de la derecha, imagen, o de otros activos. Deshacerse de la idea de que un proyecto de Flash está plagada de cada vez que cambia de modo fla y abrazar la idea de ejecutar la generación de contenidos en tiempo.

Michael Minor Director de medios interactivos invertedCreative.com

5

AgradecimientosMe gustaría dar las gracias a Laura Sinise por ayudarme a empezar. Este libro no habría sido posible sin las siguientes personas: Adquisiciones Editor Senior, Stephanie McComb; Project Editor, Beth Taylor; Copy Editor, Kim Heusel Technical Editor, Navid Mitchell y Mary Keefe. También me gustaría agradecer a mis amigos de Colin, Felipe, Brooke, Frank, Jimmy, y Daz y mi primo Teisha por su enorme cantidad de apoyo. Y, por último, me gustaría agradecer a mi familia por su comprensión y paciencia mientras yo estaba encerrado en mi oficina durante todas las horas de la noche.

6

ContenidoAcerca del Autor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v Prólogo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vii Agradecimientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .ix Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix

Parte I: Entender los Conceptos Básicos 1 Capitulo 1: Introducción con Flash y PHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Agregar Apache a un Servidor Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3 Instalación de Apache para Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4 Instalación de Apache para UNIX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 Modificación de Apache para Windows y UNIX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .13

Instalación de MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 Instalación de MySQL para Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .14 Instalación de MySQL para UNIX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Protección de MySQL . . . . . . . . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Configuración de PHP en el Servidor Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Instalación de PHP para Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 Instalación de PHP para UNIX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Capitulo 2: Explorando Flash y PHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Introducción al Servidor Web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . . . 37 Trabajar con archivos .htaccess . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37 Protección de su contenido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 Recopilación de información acerca de Apache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 Utilización de documentos de error personalizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

Explorando lo básico de PHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 Entender las variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 Trabajar con funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .49 Entender las estructuras de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 Uso de la comprobación de tipos en PHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Explorarando lo Básico de MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Uso de declaraciones o sentencias (stantemets) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 Condiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .58

Explorarando Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . . . . . 59 Flash IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59Editores alternativos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 Flash-Dispositivos habilitados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62 Un Paso Adelante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62

7

Capitulo 3: Como realizar la conexión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .63 Entender Comunicaciones en Flash ..........................................................................................63

Determinar el estado de PHP ........................................................................................64 Trabajar con distintos tipos de conexión ...….................................................................65

Conexión de Flash a PHP...........................................................................................................69 Conexión de PHP a MySQL…......................................................................................................73

Determinar el estado de MySQL....................................................................................73 Conectar a MySQL..........................................................................................................74 Acercar todo junto……....................................................................................................77

Resumen……...............................................................................................................................84

Capitulo 4: Trabajar con Datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .85 Cargar datos en Flash.................................................................................................................85

Comprender las clases utilizadas para cargar los datos.................................................86 Poner todo junto…….......................................................................................................87

Controlar carga de datos……………..............................................................................................88 Una-vía de carga……….....................................................................................................88 Dos-manera de carga .....................................................................................................88

Cargar XML en Flash…….............................................................................................................89 Trabajar con XML en PHP...........................................................................................................92

Carga de XML……….........................................................................................................92 Envío de XML..................................................................................................................93

Cargar imágenes usando PHP……...............................................................................................95 Configurar cargador de la imagen..................................................................................96

Resumen………............................................................................................................................98

Capitulo 5: Interactuar con el Usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 Desarrollo de un formulario usando Flash.................................................................................99 Creación de un formulario de contacto....................................................................................101

Llamar el PHP………........................................................................................................103 Controladores de evento en formulario de contacto...................................................103 Correo en PHP…….........................................................................................................105

Módulo de login en Flash.........................................................................................................106 Código esqueleto .........................................................................................................106 Controladores de eventos en login………………..............................................................107 Integración del Servidor para el módulo de inicio de sesión .......................................110

Resumen…………........................................................................................................................111

Capitulo 6: Trabajar con Cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .113 Cargar Cookies..........................................................................................................................113

Uso de cookies con PHP……...........................................................................................114 Uso de cookies en Flash ...............................................................................................118 Descubrir los beneficios del uso de cookies en PHP ....................................................122

Resumen………..........................................................................................................................124

8

Parte II: Desarrollo de contenido interactivo 125

Capitulo 7: Mantenimiento de Seguridad al trabajar con la entrada de usuario. . . .127 Precaución con el uso de entrada de usuario..........................................................................127

Forma adecuada de manejar la carga de archivos.......................................................128 Comprobación de la entrada valida..............................................................................131

Limpiar de datos de usuario.....................................................................................................132 Desinfección de los datos.............................................................................................133 Limpieza adecuada de datos HTML..............................................................................136

Almacenamiento de datos.......................................................................................................136 Escribir de forma segura a un archivo..........................................................................137 Crear y guardar una contraseña segura usando PHP ...................................................141

Retornar datos .........................................................................................................................143 Retornar datos de forma segura ..................................................................................143 Utilizando un enfoque más seguro para el retorno de datos ......................................144

Comprender la seguridad Flash de Sandbox............................................................................145 Configurar el tipo de sandbox......................................................................................145 Uso de la propiedad sandboxType...............................................................................145 Determinar el activo sandbox ......................................................................................147 Garantizar una aplicación no puede ser compartida....................................................151

Resumen...................................................................................................................................152

Capitulo 8: Uso de Sockets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .153 Comprender los Sockets...........................................................................................................153

Seguridad en sockets....................................................................................................154 Implementación de un servidor socket........................................................................154 Entender la conexión del socket...................................................................................154

Trabajar con Sockets en PHP....................................................................................................154 Buscando la versión de línea de comandos de PHP.....................................................155 Construir un servidor socket………................................................................................156 Probar el servidor de socket.........................................................................................158 Crear un persistente servidor socket............................................................................160

Trabajar con Sockets en Flash..................................................................................................161 Inicialización de una conexión de socket......................................................................161 Controladores de eventos (Event handlers)................................................................162 Conexiones remota de socket......................................................................................163 Uso de una clase para conexiones de socket...............................................................164

Creación de un cliente de Chat con Sockets Usando Flash y PHP............................................167 Servidor socket PHP para el cliente de chat.................................................................167 Conectar al servidor socket…………...............................................................................175 Crear el cliente en Flash……..........................................................................................177

Resumen………..........................................................................................................................188

9

Parte III: Ampliación de Flash y PHP 189

Capitulo 9: Trabajar con bibliotecas de terceros. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 Repasando bibliotecas de terceros..........................................................................................191

Otros tipos de bibliotecas de terceros.........................................................................192 Bibliotecas en PHP........................................................................................................193

Instalación de bibliotecas de terceros.....................................................................................193 Instalación de bibliotecas en Flash CS3........................................................................193 Instalación de bibliotecas en PHP................................................................................195

Uso de bibliotecas de terceros................................................................................................196 Trabajar con bibliotecas en Flash CS3..........................................................................196 Trabajar con bibliotecas en PHP................................................................................197

Echando un vistazo a AMFPHP..................................................................................................198 AMFPHP para AS3 y desarrolladores de PHP..............................................................198 Pruebas AMFPHP con un servicio personalizado.........................................................201 Uso de AMFPHP en Flash..........................................................................................205

Construcción de u mundo real de la Aplicación Usando AMFPHP............................................210 Servicios de AMFPHP....................................................................................................210 Integración de ActionScript para AMFPHP..............................................................216

Resumen..........................................................................................................................218

Capitulo 10: Uso de programación orientada a objetos. . . . . . . . . . . . . . . . . . . . . . . 219 Entender la programación orientada a objetos (OOP)...........................................................219

Información general de las prácticas de OOP..............................................................220 Uso de Clases en PHP........................................................................................................225

Importación de clases en PHP.......................................................................................226 Instanciación............................................................................................................226 Clases múltiples......................................................................................................228

Uso de Clases en Flash......................................................................................................229 Importación................................................................................................................229 Clase de documento......................................................................................................229 Biblioteca de clases.......................................................................................................230

Uso de Flash y PHP para construir clases personalizadas.........................................................231 Resumen.........................................................................................................................235

Parte IV: Desarrollo de Aplicaciones 237

Capitulo 11: Desarrollo de aplicaciones básicas. . . . . . . . . . . . . . . . . . 239 Entender elementos de una aplicación.......................................................................239

Entender el diseño de la aplicación..........................................................................240 Finalización de la etapa de planificación.....................................................................242

Desarrollo de un cliente de Chat............................................................................................242 La porción de Flash....................................................................................................242

10

PHP para la aplicación de chat...................................................................................252

Uso de PHP para el desarrollo de una galería de fotos............................................................260 El desarrollo de ActionScript....................................................................................261 Navegación de galería de fotos..................................................................................266 PHP para la galería de fotos........................................................................................270

Uso de PHP para desarrollar un lector RSS...............................................................................274 Importación de

clases....................................................................................................275 Cargando el PHP......................................................................................................275

Uso de PHP, Flash, y MySQL para desarrollar de un banner dinámico......................................279Abrir una ventana del navegador..................................................................................281 Desarrollo Del PHP................................................................................................283 Selección aleatoria....................................................................................................283

Uso de PHP para desarrollar un contador de visitas.................................................................285 Contador de visitas lógico............................................................................................285 Desarrollo de contador de visitas en Flash....................................................................286

Resumen..........................................................................................................................287

Capitulo 12: Desarrollo del mundo real de las aplicaciones. . . . . . . . . . . . . . . . . . . . 289 Entender el mundo real de las aplicaciones.........................................................................289 Uso de PayPal en Flash........................................................................................................290

Uso de POST data....................................................................................................293 Uso de sendToURL....................................................................................................294 Establecer una comunicación de PayPal......................................................................294

Uso de Flash y PHP para construir un Cart................................................................................295 Diseño de la cesta (cart) de compras............................................................................296 Construcción del PHP....................................................................................................306

Uso de PHP y Flash para construir una aplicación de búsqueda del Amazon..........................317 Uso del servicio web de Amazon..............................................................................317 Simplificación de la respuesta XML..............................................................................319

Desarrollo de una galería de fotos usando flickr......................................................................326 Interfaz con el servicio Web..............................................................................331 Construir un documento XML personalizado...............................................................332

Resumen..........................................................................................................................333

Capítulo 13: Uso avanzado del mundo real de las aplicaciones. . . . . . . . . . . . . . . . . 335 Construcción de una aplicación de dibujo en in Flash..............................................................335

API de dibujo en Flash..............................................................................................336 Uso de la librería GD en PHP..................................................................................................341

Generación de una imagen en la librería GD................................................................343 Recolección de datos de pixeles en Flash......................................................................345

Uso de Flash para desarrollar un monitor del sitio web...........................................................347 Desarrollo de PHP para el monitor del sitio web.........................................................347 Uso de PHP a e-mail del administrador....................................................................349

11

Desarrollo del ActionScript para el monitor del sitio web.............................................351 Uso de Flash para desarrollar un reproductor de video...........................................................359 Desarrollo de una aplicación de encuesta................................................................................364

Creando el PHP y MySQL..................................................................................364 Desarrollo de ActionScript para la encuesta.................................................................368

Construcción de un simple editor de archivos..........................................................................373 Resumen.........................................................................................................................380

Capitulo 14: Depurar aplicaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 381 Uso de informe de error en PHP..........................................................................................381

Mostrando los errores para depurar.............................................................................383 Entender los niveles de error................................................................................383

Depurar en Flash..........................................................................................................385 Uso de una alternativa Trace................................................................................................389 Resumen..........................................................................................................................392

Parte V: Mantenimiento de servidor, aplicación y de base de datos 393

Capítulo 15: Mantenimiento de una aplicación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 Comentando código............................................................................................................395

Entender los estilos para comentar código............................................................396 Eliminación de comentarios y depurar ayuda..............................................................399

Gestion de un cambio de registro............................................................................................399 Seguimiento de errores................................................................................................399 Usos adicionales........................................................................................................400 Creación dinámica de cambios..................................................................................400

Administración de múltiples versiones.....................................................................................401 Aplicación de control de versiones...............................................................................401 Apoyar el control de versión de CS3.............................................................................401 Configuración de control de versiones..........................................................................402

Uso de librerías personalizadas................................................................................................403 Uso de librerías personalizadas con el control de versión............................................403 Publicación de SWC..................................................................................................404

Resumen.........................................................................................................................404

Capítulo 16: Mantenimiento de un servidor escalable y más eficiente. . . . . . . . . . . 405 Ejecutando un servidor actualizado.........................................................................................405

Uso de actualizaciones automáticas.............................................................................406 Plataforma Zend.........................................................................................................406

Trabajar con Development Installs ..................................................................................406 Construcción de otra versión de Apache en el mismo sistema.....................................406 Trabajar con tecnología de punta..................................................................407 Dependencias..........................................................................................................407

Almacenamiento en cache y optimización...............................................................................408 Optimización de PHP....................................................................................................408 Optimización de Apache...............................................................................................412

12

Optimización de MySQL................................................................................................413 Almacenamiento en cache............................................................................................416 Instalación de memcached en Linux.............................................................................416 Instalación de memcached en Windows.......................................................................418 Terminando la instalación para Linux y Windows..................................................418 Gestión de servidores....................................................................................................420

Manejo de copias de seguridad (Backup).................................................................................421 Administración de archivos...........................................................................................421 Administración copias de

seguridad..............................................................................421 Uso de PHP para copia de seguridad de base de datos.................................................424

Resumen..........................................................................................................................427

Capítulo 17: Construcción complete de aplicaciones avanzadas. . . . . . . . . . . . . . . . 429 Construir un reproductor de video básico...............................................................................429 Construir un reproductor de Video en Flash y PHP..................................................................432

Como empezar........................................................................................................432 Integración remota..............................................................................................437 Desarrollar un reproductor de video avanzado............................................................446 Construit la clase VideoListItem..............................................................................456

Trabajar con seguimiento de video..........................................................................................461 Actualización de la clase de video.................................................................................462 Método updateVideoTracking..................................................................................463

Construcción de un componente de inicio de sesión de usuario en Flash................................465 Desarrollo de la clase LoginWindow........................................................................466 Prueba del componente de inicio de sesión.................................................................473 Creando la clase del gestor de inicio de sesión en PHP................................................476 Agregar remoto al componente de inicio de sesión.....................................................478

Finalizando el reproductor de video........................................................................................481 Uso de una biblioteca externa......................................................................................482 Agregar el componente de inicio de sesión (login)......................................................482

Resumen..........................................................................................................................486

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487

13

IntroducciónEste libro es una exploración de varias partes en Flash y PHP. Flash se ha utilizado para todo, desde los anuncios de banner a las aplicaciones básicas completamente funcionales a través de la web y de escritorio.

A menudo se puede encontrar la información necesaria para escribir aplicaciones asombrosas de Flash o la contraparte del lado del servidor pero rara vez ambos. Este libro se basa tanto en los aspectos y explica el proceso de trabajar con PHP en sus proyectos de Flash.

La primera parte del libro es un paso a paso del proceso de instalación y configuración de PHP y todos los componentes necesarios. Una vez instalados los componentes, el paso siguiente es un resumen de PHP y una guía de qué características y técnicas encontrará en el libro como de continuar a través de los capítulos. Cada capítulo comienza con una descripción básica y después se traslada rápidamente a la información pertinente, dejando de lado cualquier pelusa para asegurar que está recibiendo toda la información importante de inmediato.

Parte II se centra en la importancia y las mejores prácticas de hacer sus aplicaciones más seguras, manteniendo la funcionalidad. El tema de la seguridad se repite en los diversos ejemplos en este libro, pero esta parte en particular, es donde se encuentra la mayoría de la información de seguridad.

La parte III se extiende Flash y PHP, trabajando con varias aplicaciones de terceros y las bibliotecas. Este capítulo finaliza con una visión general de AMFPHP para construir más avanzado y más fácil de mantener aplicaciones.

Parte IV tiene toda la información anterior y le guía por el proceso de construcción completo de aplicaciones del mundo real en Flash y PHP. Estas aplicaciones del mundo real le ayudarán a construir sus versiones personalizadas y en última instancia, le permiten crear aplicaciones más avanzadas y dinámicas.

Ejemplos y archivos fuentes

Usted puede encontrar todo el código fuente y los archivos de arranque de los ejemplos en este libro en el siguiente sitio web.

www.wiley.com/go/flashandphpbible

14

http://www.wiley.com/go/flashandphpbible

Introducción

Lo que usted Necesitará El ActionScript utilizado en este libro no es avanzado, pero un conocimiento básico de los fundamentos que le permiten comprender mejor los ejemplos. La Biblia Flash es un complemento perfecto para este libro y lo recomiendo.

Una comprensión básica de las prácticas de programación orientada a objetos le ayudaría en la segunda parte del libro, pero no es necesario para entender los ejemplos en general. Es posible que desee tomar un libro sobre prácticas avanzadas de programación orientada a objetos para obtener un entendimiento más profundo del tema de.

El PHP utilizado en este libro está asumiendo un conocimiento muy básico de la materia. Esto significa que usted no sólo aprenderá los temas avanzados, pero cómo llegar allí desde el principio. PHP también le permite desarrollarse en un formato basado en la clase, de forma que se utilizarán en la plena aplicación de los capítulos para asegurarse de que están construyendo una aplicación más completa y actualizable.

La última cosa que necesita es una conexión a Internet para descargar el código para el libro y trabajar con algunos de los servicios de terceros. Esto no se usa en todo el libro, pero para obtener la experiencia completa de la conexión a Internet será necesario.

Eso es todo lo que usted necesita. Ahora es el momento de saltar adentro del capítulo 1 en sólo unas pocas páginas de distancia.

15

Parte I

Entender los conceptos básicos

16

Capitulo 1Introducción con Flash y PHP

El proceso de empezar incluye la instalación y configuración de Apache, MySQL y PHP. Los ejemplos en este libro asumen la instalación que se llevará a cabo a nivel local, sin embargo, puede modificar las rutas de acceso y direcciones URL, si desea utilizar un servidor remoto.

El orden en que instalar estos programas es importante, ya que utilizan rutas de acceso y las variables de los demás, lo que resulta en el entorno de desarrollo completo.

Esta guía de instalación cubre los sistemas Windows y UNIX. Si usted ha decidido trabajar en el libro en un servidor existente, puede saltar al capítulo 2. Sin embargo, hay cierta seguridad y la información de configuración dentro de este capítulo, usted puede encontrar útil.

Agregar Apache a un servidor web

El primer paso para trabajar con Flash y PHP es para instalar los componentes necesarios. El proceso de instalación se define por la instalación de Apache, MySQL, PHP y, por último. Esta orden es necesario porque PHP necesita caminos para Apache y MySQL para proporcionar ese apoyo.

Usted puede volver a compilar (build) cualquiera de estos componentes en el futuro.

Sin embargo, si usted sigue este orden de instalación que significará menos trabajo y rehacer en el futuro.

Los componentes que se instalen cambiar de vez en cuando, pero el proceso de instalación en general sigue siendo bastante constante. Esto significa que usted puede descargar los archivos más recientes de sus respectivos sitios de los proyectos, o para asegurar que todos los componentes trabajan juntos, usted puede obtener estos archivos desde la página del libro.

Usted debe tener un conocimiento básico del sistema en el que va a instalar. Es importante para ejecutar un sistema de desarrollo en una ubicación segura. La mejor configuración es un equipo detrás de un firewall físico o en una red interna. Si esto no es posible, simplemente configurar el Apache no permitir las conexiones remotas y se puede cambiar el número de puerto para ocultarlo en la red.

NOTA desarrollo de sistemas puede requerir una configuración más avanzada en función de cómo se han creado. Usted puede encontrar los problemas comunes se explica en el sitio Web del libro.

Instalación de Apache para Windows Una vez que determine que el sistema está instalando el sistema de desarrollo puede empezar a descargar los componentes necesarios. Se recomienda que utilice los archivos proporcionados con el libro. También proporcionan los lugares necesarios para descargar los archivos más recientes.

17

La última versión de acceso desde el sitio Web de Apache. Es más fácil de instalar desde la versión del instalador binario en lugar de compilar el código fuente. Sin embargo, la compilación de código fuente, se ofrecen un mayor nivel de personalización y permite entender lo que se está ejecutando bajo el capó.

PRECAUCIÓN construcción de la fuente no es para el principiante. Se requiere un cierto nivel de experiencia y sólo se recomienda a aquellos que realmente sienten el desafío.

Los últimos archivos binarios para Windows de instalación de Apache se puede encontrar en

www.apache.org/dyn/closer.cgi/httpd/binaries/win32/.

Instalación

Iniciar el proceso de instalación abriendo el archivo de instalación de Windows que era o bien descargarse de la página de libros o directamente desde el sitio Web de Apache.

Esta instalación será principalmente visual, porque el instalador de Windows es una instalación gráfica. La clave para una correcta instalación sigue de cerca y la lectura de las pantallas de todo el proceso de instalación. La primera pantalla, como se muestra en la Figura 1.1, no requiere ninguna modificación.

Las siguientes dos pantallas son el acuerdo de licencia, que puede tomar el tiempo para leer o simplemente haga clic en Siguiente, ya que la información es bastante estándar.

Después de eso, usted encontrará una introducción a Apache, que le da un buen panorama de lo que Apache tiene para ofrecer, como se muestra en la Figura 1.2. La pantalla también se ofrecen enlaces a recursos muy valiosos que rodean la comunidad de Apache.

FIGURA 1.1

La primera pantalla que no requiere ninguna modificación del usuario. Simplemente haga clic en Siguiente para continuar el proceso de instalación.

18

http://www.apache.org/dyn/closer.cgi/httpd/binaries/win32/

FIGURA 1.2 La información del servidor de un sistema de desarrollo no tiene por qué ser real, ya que muestra la figura.

19

La instalación del servidor es donde se define la configuración específica para su entorno. Si usted se de instalar Apache en un sistema real, usted podría llenar en esta página con la información correcta, de lo contrario no sería Apache pide la ruta correcta. Puede aceptar las opciones por defecto para una configuración de desarrollo, como esta.

Siendo que la instalación está en un servidor de desarrollo no tienen que rellenar la pantalla con los datos reales, a menos que utilice esta guía para instalar en un servidor en vivo.

La instalación de Apache HTTP Server 2.0 y accesos directos para los programas: La opción es cuando se desea instalar Apache para que sólo el usuario actual puede acceder a él. Si desea que todos los usuarios puedan acceder a Apache, a continuación, tendrá que instalarlo como un servicio.

El proceso de instalación de Apache se puede hacer de dos maneras, como se muestra en la Figura 1.3. La primera opción es aceptar todas las configuraciones por defecto, que resulta en una instalación más rápida, pero no es siempre la mejor opción.

La opción más común es la segunda alternativa personalizada en la que le dicen a Apache qué herramientas y bibliotecas que desea instalar. De vez en cuando al instalar una aplicación que puede experimentar una escasez de espacio en disco duro.

Apache, por otra parte, es tan pequeño, con todas las herramientas adicional instalado que no debería haber un problema de instalarlo.

FIGURA 1.3

20

La opción Personalizar se determina para asegurar todas las herramientas de desarrollo están instalados, como la biblioteca y la capacidad de construcción de módulo.

Para los ejemplos en este libro, lo mejor es aceptar la instalación personalizada y asegúrese de que todas las bibliotecas y las extensiones están instalados. Por ejemplo, algunos de los módulos utilizados para modificar las solicitudes de los usuarios sólo están disponibles cuando se instala la versión completa.

Dependiendo del sistema, puede tomar un tiempo para instalar Apache. Incluso si la barra de estado deje de moverse no se trate; algunos de los archivos tardan más que otros a la instalación. La aplicación le avisa si algo sucede durante el proceso de instalación, que es muy raro. Apache actualizar la barra de progreso, como se muestra en la Figura 1.4, mientras que la instalación está ocurriendo.

FIGURA 1.4 21

Estado de la instalación de Apache

La última pantalla que se ve es una nota que la instalación fue exitosa. Un símbolo de DOS puede aparecer que le notifica que el servicio de Apache está comenzando. También puede obtener una advertencia de Firewall, y tendrá que conceder el acceso de Apache pide.

Pruebas

Felicidades. Si todo ha ido bien debería tener ahora Apache instalado en su máquina Windows. Para probar la instalación, abra un navegador Web y el punto en el servidor Web Apache locales, que también es conocido como localhost.

http://localhost/

Usted debe ser presentado con una pantalla similar a lo que se ve en la figura 1.5, que básicamente se le informa de que Apache se ha instalado correctamente y está listo para comenzar a cumplir el contenido.

Dependiendo del proceso de instalación, puede modificar esta situación, que a veces es necesario cuando se instala en un servidor remoto. Usted no sería capaz de acceder al servidor web Apache en la dirección localhost. En su lugar, desea señalar a la dirección IP o el nombre de dominio de su sitio Web.

22

FIGURA 1.5 La pantalla de bienvenida por defecto de Apache

Con Apache instalado, puede modificar la página predeterminada para ver realmente cómo funciona el Apache.Los archivos de Internet que sirve de Apache se encuentran en la raíz del documento. Esto es similar a la public_html o www que usted ha visto muy probablemente en un servidor Web remoto. A diferencia de un servidor Web remoto, los permisos de estos archivos son a menudo inaccesibles para los demás usuarios no ver desde su propio ordenador personal.

La ubicación de este directorio Web en Windows utilizando una instalación por defecto es:

C:\Program Files\Apache Group\Apache2\htdocs

Usted verá muchos ficheros en este directorio, tales como los archivos del mismo índice en varios idiomas.Usted no desea modificar cualquiera de estos archivos, ya que podría estropear el núcleo de Apache o introducir errores que serían muy difíciles de rastrear, por tanto, crear un nuevo archivo. Usando su editor de texto favorito, crear una página HTML muy simples, tales como las siguientes:

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”> <html xmlns=”http://www.w3.org/1999/xhtml” lang=”en”> <head> <title>My Custom Page</title> <body> <h1>Welcome to my custom page</h1>

23

<p>This is a test of the customization of Apache!</p> <p>Pretty cool huh?</p> </body> </html>

Guardar este nuevo archivo en el directorio de la Web Apache y el nombre que myPage.html. Después de guardar el archivo, abra en el navegador Web para presenciar la flexibilidad en Apache.

Este no es el ejemplo más avanzado, pero se le debería dar la idea básica de cómo modificar y trabajar con el servidor web Apache. Ahora es el momento de crear ejemplos más útiles, porque tiene lo básico. En este punto, con Apache instalado y probado, puede pasar a la instalación y configuración de PHP, o puedes ir adelante con el proceso de configuración de Apache.

Alternativamente, se puede leer a través de la instalación de Apache en UNIX, que se trata en la siguiente sección.

La instalación de Apache en UNIX estaría más cerca de trabajar con un servidor remoto, ya que encontrará que la mayoría de los servidores Web se basan en Linux. Esto no significa que usted nunca se encontrará un servidor basado en Windows Web en vivo, pero ciertamente no es tan común.

Instalación de Apache para UNIX

El proceso de instalación en UNIX es más avanzada que la instalación de Windows. Sin embargo, la instalación de UNIX a menudo es el escenario más común para un servidor en vivo.

El primer paso para instalar Apache es la descarga de la fuente. Esta fuente puede ser descargado desde el sitio del libro, o directamente desde el sitio Web de Apache. Uso de la fuente proporcionada en el sitio web del libro asegura que se está ejecutando un sistema casi idéntico al utilizado para escribir este libro. Va a encontrar la fuente, como se muestra en la Figura 1.6, directamente desde Apache en la siguiente URL: http://httpd.apache.org/download.cgi.

24

http://httpd.apache.org/download.cgi

FIGURA 1.6 Aquí está una lista de las posibles versiones del código fuente para su descarga desde el servidor Apache.

Después de descargar el código fuente de Apache, puede comenzar el proceso de instalación.

Preinstalación

Antes de la instalación puede comenzar, la fuente debe ser extraído del archivo descargado. Esto se hace simplemente descomprimir el archivo tarball y desempaquetar el archivo sin comprimir.

$ gzip -d httpd-2.2.6.tar.gz $ tar xvf httpd-2.2.6.tar

Una vez que los dos últimos procesos se completa, se quedan con un nuevo directorio que contiene el código fuente.Antes de continuar, cambiar de directorio, lo que significa que estará en el directorio del código fuente se encuentra en.

$ cd httpd-2.2.6/

25

Instalación

Cuando se extrae el código fuente, usted puede comenzar el proceso de instalación. Apache instalar con su propio conjunto de opciones, pero usted tiene la posibilidad de modificar estos. Si desea configurar Apache con los valores predeterminados, simplemente escriba ./configure. Sin embargo, es una mejor práctica para adaptar el proceso de instalación de su entorno.

Una de las opciones más importantes que puede definir es el --prefix, que es donde Apache se instalará. Esta opción se utiliza en toda la aplicación y también se utiliza más tarde durante la instalación de PHP y en la sección de configuración.

Para simplificar un proceso de configuración se utiliza parcialmente modificada, pero no dude en mirar a través de la documentación de Apache para obtener una mejor comprensión de lo que la configuración se puede cambiar.

$ ./configure --prefix=/usr/local/apache --enable-rewrite=shared \ --enable-spelling=shared

Una vez que comienza el proceso de configuración, puede tomar unos minutos para completar. La mayoría de las veces podrás ver el proceso de impresión en la ventana de terminal, pero incluso si no lo es, se está ejecutando.

Después de configurar el comando se haya completado, puede ejecutar make para construir el paquete de Apache.

$ make

Una vez más, este proceso puede llevar tiempo dependiendo de su sistema, así que por favor sea paciente. Una vez que el comando make se ha completado, el último comando para ejecutar instala el paquete, para terminar la parte de la instalación.

$ make install

Pruebas

Con Apache instalado, usted puede iniciar y ponerlo a prueba en el navegador.

Apache se instala una herramienta muy útil, apachectl, que se puede encontrar en el directorio bin/ de la ubicación de instalación. Usando el camino elegido para esta instalación, la aplicación apachectl se encuentran aquí.

$ usr/local/apache/bin/apachectl

Utilice el comando siguiente para iniciar el servidor Apache:

$ usr/local/apache/bin/apachectl start

Utilice este comando para detener el servidor Apache:

$ usr/local/apache/bin/apachectl stop

Para reiniciar el servidor Apache, utilice este comando:

$ usr/local/apache/bin/apachectl restart

26

Probando el servidor se realiza haciendo una llamada a localhost desde el navegador web en http://localhost/. Como usted puede ver, la instalación fue un éxito. A fin de probar y entender mejor cómo modificar los archivos de Apache sirve, HMTL crear un nuevo archivo y guardarlo en la raíz de la Web Apache.

Usando su editor de texto favorito, que en UNIX más probable es que vi, crear este nuevo archivo HTML. Los siguientes comandos asumen que se está usando vi.

Crear un Nuevo archivo:

$ vi /usr/local/apache/htdocs/sampleFile.html

Con el fin de comenzar a introducir el código HTML, usted necesita decirle a vi entrar en modo de inserción, que se realiza pulsando I. Presione ESC para salir del modo de inserción.

Pegue o escriba el siguiente ejemplo de código HTML:

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Strict//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd”> <html xmlns=”http://www.w3.org/1999/xhtml” lang=”en”> <head> <title>My Custom Page</title> <body> <h1>Welcome to my custom page</h1> <p>This is a test of the customization of Apache!</p> <p>Pretty cool huh?</p> </body> </html>

Una vez que el archivo es creado, pulse ESC y escriba el siguiente comando para guardar y cerrar el editor.Tenga en cuenta, el : es parte del comando.

:wq

Algunos archivos de agregar o modificar requieren que reinicie Apache, sin embargo, los archivos de base de Internet no entran en esa categoría. Ahora puede mostrar la nueva página, añadiendo el nombre del archivo a la llamada localhost en

http://localhost/sampleFile.html.

Como se puede ver, el servidor de Apache ha sido instalado correctamente y se haya podido añadir un archivo personalizado que Apache adecuadamente sirve. En este punto, usted debe tener un conocimiento básico de cómo funciona el Apache. La siguiente sección (independiente de la plataforma) entra en más detalles acerca de cómo se puede modificar Apache.

27

Modificación de Apache para Windows y UNIX

Los siguientes consejos, trucos y ajustes se pueden realizar en las instalaciones de Windows o UNIX. Esto se debe a que son específicas de Apache y no el medio ambiente que puede correr.

Cuando se trabaja en el desarrollo de sistemas no es raro que requieren más de una instalación de Apache. Esto podría poner a prueba sangrante código de vanguardia, un apoyo más plug-ins, o simplemente para garantizar un proyecto se ejecuta en un clon del sistema en vivo.

El proceso de instalación de Apache se mantiene más o menos igual. Sólo tienes que cambiar la opción de prefijo apuntando a una nueva ubicación/diferente. Usted puede ejecutar varias versiones de Apache, sin embargo, requieren de ubicaciones de instalación independiente. Ejecutar varias versiones de Apache, al mismo tiempo utilizando sólo las opciones por defecto de instalación no es posible. Esto se debe a Apache que se creó para escuchar las peticiones en el puerto 80 por defecto.

Usted puede modificar el puerto que escucha en el Apache editando el archivo de configuración. Los archivos de configuración se encuentran en el directorio conf/, que se encuentra en el directorio que usted designe durante la instalación de Apache.

Por ejemplo, puede cambiar el puerto que funciona en Apache. Comience por abrir el fichero de configuración.

Para abrir el archivo de configuración en UNIX, use vi.

$ vi /usr/local/apache/conf/httpd.conf

Para abrir el archivo de configuración de Windows, navegue hasta el directorio de instalación y abrir el archivo httpd.conf en su editor de texto favorito.

C:\Program Files\Apache Group\Apache2\conf\httpd.conf

Cuando el archivo está abierto, desplácese hacia abajo o de búsqueda de la directiva Listen, que tendrá un aspecto similar a la siguiente:

## Listen: Allows you to bind Apache to specific IP addresses and/or # ports, instead of the default. See also the <VirtualHost> # directive. #Listen 80

NOTA Apache sólo se verá en este archivo durante el inicio. Cuando haya terminado la edición, asegúrese de reiniciar el servidor Apache.

Cambio de un valor que le permite ejecutar varias copias de Apache. Sin embargo, ejecutar varias instancias de Apache puede ser intensivo del procesador, así que asegúrese de que sólo se ejecutan como muchos casos, según sea necesario. En la mayoría de los casos, se ejecutará sólo una instancia en un servidor en vivo.

28

Instalación de MySQLAhora que está instalado Apache, el siguiente componente a instalar es MySQL. Esta sería la base de datos que el contenido de su aplicación se almacenan y se gestione por medio de PHP.

Instalación de MySQL para Windows

Al igual que el proceso de instalación de Apache, MySQL tiene un instalador de Windows que hace que todo el proceso mucho más fácil. Las guías de instalación a través del proceso de instalación de la base de datos básicos y los componentes adicionales que necesita. Para esta instalación, la instalación por defecto se utiliza, pero no dude en personalizar, que es una muy buena manera de aprender.

Descargar

El primer paso para la instalación de MySQL es descargar la última instalar los archivos. Puede utilizar los archivos proporcionados en el sitio Web del libro para garantizar la compatibilidad o puede visitar el sitio Web de MySQL en http://dev.mysql.com/downloads/mysql/5.0.html#win32 para obtener la última versión estable en este momento.

Seleccione el programa de instalación de Win32 con el programa de instalación para que el proceso de instalación en general más fácil. Esto le permite utilizar la interfaz gráfica de usuario en lugar del comando tradicional línea de proceso de las versiones anteriores.

Instalación Después de descargar y abrir el instalador de una página de bienvenida, seguida por otras páginas que componen el proceso de instalación, como se muestra en la Figura 1.7. Similar a la instalación de Apache, MySQL también tiene varias opciones de configuración que necesitan ser modificados. Repasa atentamente los pasos siguientes para asegurar su base de datos funcionará correctamente.

Elija la opción de instalación Típica, que instala los componentes básicos necesarios para operar y mantener una base de datos MySQL. Haga clic en Siguiente para pasar al siguiente paso.

En este punto, MySQL ha sido instalado. La última página le da la opción de iniciar la sección de configuración al hacer clic en Siguiente.

Asegúrese de seleccionar esta opción. Si accidentalmente cerca de esta página usted puede volver a ejecutar o abrir la aplicación de configuración en el directorio mysql/ en archivos de programa.

La instalación de MySQL no ofrecen casi nada en la modificación. Esto es porque el apoyo a la aplicación Asistente para la configuración se ocupa de todas las opciones de configuración necesarios.

Seleccione la opción de configuración detallada, como se muestra en la Figura 1.8. Esto le permite ajustar la configuración de MySQL en lugar de utilizar todos los valores predeterminados. Haga clic en Next para continuar.

29

http://dev.mysql.com/downloads/mysql/5.0.html#win32

FIGURA 1.7 Esta página es el proceso de instalación. La instalación puede durar varios minutos, dependiendo del sistema.

Si selecciona la opción de configuración estándar se le presenta con una pequeña lista de las pantallas de configuración. Esto acelera el proceso de configuración, pero no le permiten personalizar la funcionalidad de MySQL y podría resultar en un sistema menos eficiente.

30

FIGURA 1.8 Seleccione el tipo de configuración.

El tipo de servidor determina la memoria, disco duro, y el uso de la CPU. Esto ha sido instalado en su equipo de desarrollo de modo que quieren asegurarse de que MySQL no llegar a ser excesivamente procesador o recursos. Selección de la opción Máquina de Desarrollo garantiza esto no suceda.

Las otras dos opciones son para los servidores dedicados. La opción de la máquina del servidor se utiliza cuando se instala MySQL en la misma máquina del servidor Web, como Apache, se está ejecutando. Esto está bien para un medio en el sitio de la trata, pero usted puede encontrar un aumento en el uso de recursos que el sitio se vuelve más activa.

Cuando esto sucede, tendrá que introducir una máquina dedicada a ejecutar su base de datos MySQL, que en este momento es que seleccione la opción Dedicado MySQL Server Machine. Esta opción le dice a MySQL se instala en una máquina dedicada y utilizar todos los recursos y la memoria que se presente.

NOTA Asegúrese de que usted nunca accidentalmente seleccione la opción dedicado MySQL Server Machine cuando se instala en un servidor Web. Su sistema no será capaz de gestionar adecuadamente los recursos y, eventualmente, podría fallar.

MySQL constantemente tratan de asignar toda la memoria libre, siempre que esté disponible, lo que significa que el servidor Web cierra una conexión rancio, MySQL podría robar la memoria libre hasta que no haya más espacio para la conexión disponible.

After you select an option (in this example Dedicated Machine), click Next (see Figure 1.9).

31

FIGURA 1.9 Después de seleccionar una opción (en este ejemplo máquina dedicada), haga clic en Siguiente (ver Figura 1.9).

Seleccione la opción multifuncional de base de datos como el tipo de uso de base de datos para permitir la máxima capacidad de expansión del sistema. Esto permite a MySQL para optimizar tanto para los motores de almacenamiento InnoDB y MyISAM. Si esta es la primera vez que la instalación de MySQL, que es muy posible, porque muchos sistemas del buque con ella ya está instalado, usted puede preguntarse cómo se usan las otras dos opciones.

La base de datos transaccional opción Sólo se usa cuando va a correr una gran cantidad de consultas transactionbased. Esto significa que se ajuste un montón de preguntas (UPDATE, SELECT, DELETE, INSERT) en una carrera para asegurar que todos los cuadros adecuados y los datos son modificados. Pero si algo va mal en una de esas modificaciones que podría arruinar los datos restantes.

Esto significaría una gran cantidad de edición de datos innecesarios y en algunos casos podría resultar en datos incorrectos. Una transacción busca un error o un disparo y si se encuentran todas las modificaciones introducidas durante el inicio de la transacción se deshacen y vuelve a su estado no modificados.

He aquí un ejemplo simple de una transacción basada en MySQL, que modifica dos partes separadas de los datos en la misma mesa.

START TRANSACTION;

UPDATE users SET credits = credits - 100 WHERE id = 3002; UPDATE users SET credits = credits + 100 WHERE id = 3002;

COMMIT;

32

Durante el proceso de una operación de las anotaciones se hagan disponibles para otras sesiones para garantizar que los datos no pueden ser leídos o modificados, mientras que una transacción se está realizando. Usted puede pensar en este proceso como algo similar a dar vuelta a la alimentación en su casa a que alguien no puede querer darle al interruptor de luz mientras está trabajando en algo. La base de datos no transaccionales Sólo se selecciona la opción cuando usted sabe que nunca tendrá la capacidad de transacción. Esto sólo se permite que el motor de almacenamiento MyISAM, que pueden proporcionar mejores resultados, pero también limita la funcionalidad en general.

Frecuentemente usted encontrará la opción de base de datos multifuncional, como se muestra en la figura 1.10, en la mejor opción, pero también es bueno saber la oferta de otras opciones.

FIGURA 1.10 La opción multifuncional de base de datos es seleccionado como el tipo de almacenamiento de base de datos.

La siguiente página le permite personalizar el sistema de almacenamiento InnoDB, pero lo mejor es dejarla como esta con la configuración predeterminada.

En algunos casos, puede que quiera elegir una ubicación distinta, que puede hacer haciendo clic en el botón Examinar a la derecha del cuadro de instalación. Elegir un lugar diferente sólo es necesario cuando el anuncio Drive Info en la parte inferior de la ventana de informes de una pequeña cantidad de espacio libre en disco, lo que significa que su base de datos podría consumir el resto de sus recursos.

PRECAUCIÓN Asegúrese de que nunca elegir una unidad extraíble, como la ubicación de almacenamiento, ya que podría perjudicar a la base de datos si la unidad no está conectada en todo momento.

Como se dijo anteriormente, con mayor frecuencia es mejor dejar esta opción en su opción por defecto, como se muestra en la figura 1.11, para garantizar las funciones de su base de datos correctamente.

33

FIGURA1.11 Configuración de tablas InnoDB

La siguiente opción es una aproximación de conexiones simultáneas que su base de datos MySQL que hacer. Debido a que esta instalación se realiza en un servidor de desarrollo, una estimación de no más de 25 es un supuesto realista. En realidad, no sería raro tener más de 5, pero el 25 es un número de buena base.

Seleccione el procesamiento de transacciones online (OLTP) en la opción "Decisión de Apoyo ", la partida cuando se está desarrollando una aplicación Web para que el público tiene acceso. Esto es porque realmente no tienen idea de cuántas personas pueden tratar de acceder al sistema en cualquier momento dado. A medida que su aplicación sigue creciendo incluso puede ser necesario a la cadena de múltiples bases de datos así como para manejar la carga, pero por ahora una base de datos es suficiente, especialmente considerando que esta instalación se está realizando en el sistema local.

Seleccione la opción de ajuste manual cuando se desea especificar un número exacto. Esto sólo es necesario cuando se desea tener un control total sobre la aplicación Web. Muchas veces se ve este número manual establecida en 300 viven en las aplicaciones Web. Esto parece ser un buena medio con la capacidad de manejar múltiples conexiones.

Tenga cuidado de no establecer la opción de conexiones simultáneas, como se muestra en la Figura 1.12, demasiado alto porque el sistema sólo tendrá tantos recursos que pueden ser divididos y compartidos por cada conexión. Si agrega más memoria a su solicitud, usted puede aumentar este número, pero que no siempre puede ser la mejor opción.

34

FIGURA 1.12 Establezca el número aproximado de conexiones simultáneas.

Las opciones de red de determinar si las bases de datos MySQL será visible a otros sistemas, más allá de la configuración local. Para la garantía definitiva, deshabilitar el TCP/IP. Si usted tiene varias máquinas de desarrollo, puede habilitar y elija un puerto no estándar.

Para esta instalación, la red está habilitada, como se muestra en la figura 1.13, y el puerto por defecto se utiliza porque no tienen la intención de permitir que otras personas se conectan, pero mi servidor web está ubicado detrás de un firewall de hardware para mayor seguridad.

Elija un número de puerto no estándar si instala otra versión de MySQL en el mismo sistema.Esto no es muy común, pero a veces hay que desplegar hacia atrás entornos compatibles para probar el código en diversas configuraciones. Esta es una alternativa rentable a la construcción y el mantenimiento de una máquina física para manejar el proceso de pruebas.

Asegúrese de seleccionar la opción Habilitar el modo estricto para garantizar las funciones de su servidor de base de datos correctamente.

35

FIGURA 1.13 Configuración de las opciones de red

En la siguiente página se puede seleccionar el juego de caracteres predeterminado utilizado en su base de datos. El juego de caracteres estándar se selecciona la opción para este ejemplo (ver Figura 1.14), pero muchas veces esto no es la mejor opción, ya que no permite la compatibilidad con la mayoría de los sistemas existentes o permitir la expansión en el tiempo. Para este ejemplo va a funcionar bien porque no tienen ningún carácter avanzado se utiliza.

Usted puede, por supuesto, seleccione cualquier opción que mejor se adapte a su uso, pero prefiero el mejor apoyo para la opción de Multilingüismo. Esta opción permite una mayor expansión y es altamente recomendable cuando el almacenamiento de texto en muchos idiomas diferentes.

Seleccione el carácter seleccionado por defecto Manual Set/ opción de gestión de las raras ocasiones en que desea especificar un cierto carácter configurado para utilizar en lugar de elegir una selección de ellos. Usted probablemente nunca utilice esta opción porque es demasiado específica, pero está disponible si es necesario.

Si usted piensa que va a utilizar varios idiomas, le recomiendo la segunda opción, el mejor apoyo al multilingüismo, para asegurar sus aplicaciones será capaz de expandirse, y también le permitirá experimentar con diferentes opciones después.

La página Opciones de Windows (vea la Figura 1.15) determina cómo se inicializa MySQL. Por ejemplo, si usted elige para ejecutar MySQL como un servicio que se inicia o detiene de forma automática, controlada por el sistema operativo. Si usted tiene instalada una versión anterior de MySQL, usted tendrá que elegir un nombre de servicio diferente. Esto es para garantizar el servicio existente no colisionar con este.

36

Seleccione el lanzamiento del servidor MySQL automáticamente opción para asegurar la base de datos está disponible cuando se inicia el sistema. Esto no es obligatorio, pero si lo hace de modo que no tienen que iniciar el servicio manualmente cada vez que reinicie su máquina. Puede, por supuesto, la solicitud de acceso a los servicios en su sistema y modificar esta opción en cualquier momento, así como desactivar el servicio hasta la próxima vez que la máquina arranca.

FIGURA 1.14 Selección de un juego de caracteres predeterminado

El directorio Incluye Bin en Windows opción PATH, cuando se selecciona, incluye soporte para MySQL desde la línea de comandos, simplemente escribiendo MySQL. Esto significa que cualquier símbolo del sistema le permitirá un acceso rápido a la base de datos MySQL. Puede consultar las instrucciones de su sistema operativo para modificar esta variable PATH.

También puede añadir PHP y Apache para esta variable mismo camino, que los expondría a la línea de comandos también. De hecho, cuando se instala PHP algunos materiales de instrucción para llevar a cabo esta modificación se ofrece.

37

FIGURA 1.15 Las opciones de Windows determina cómo MySQL se inicia y se accede.

La configuración final se utiliza para establecer una contraseña de root, como se muestra en la figura 1.16. El usuario root tiene permisos globales sobre sus bases de datos, así que puede imaginarse lo importante que es asegurar este usuario.Usted no tiene que elegir una contraseña, pero por defecto, MySQL se instala sin contraseña de root, lo que significa que nadie tiene acceso a sus bases de datos.

Lo mejor es elegir una difícil de adivinar la contraseña, vuelva a escribir una vez más, y asegúrese de que el acceso a la raíz de la opción Habilitar el control remoto de máquinas no se ha seleccionado para deshabilitar la capacidad para administrar las bases de datos de forma remota. Puede parecer esta opción permitiría una mejor facilidad de uso, pero hay algunas excepciones, una de las cuales es la seguridad general de un sistema.

A pesar de que esta configuración se realiza en un servidor de desarrollo, es mejor mantener la seguridad en la vanguardia del proceso de instalación. Si lo hace, asegúrese de seguir las precauciones necesarias al realizar una instalación similar en una configuración remota.

Si la seguridad no es una preocupación, usted tiene la opción de crear una cuenta anónima. Sin embargo, la creación de dicha cuenta es casi idéntico a un nombre de usuario root sin contraseña y tienen las mismas preocupaciones por la seguridad global.

38

FIGURA 1.16 Opciones de seguridad para MySQL

La última página, como se muestra en la figura 1.17, es para la transformación de la configuración de los valores establecidos en las páginas anteriores. Si por alguna razón se detecta un error, MySQL le notificará.

La mayoría de las veces podrás ver cada viñeta con una marca aplicada de completarse.

Cuando se termina el proceso, se le presentará con un aviso informándole de la configuración se ha completado y MySQL está listo para usar.

Ahora ha instalado correctamente y configurado MySQL para ser utilizados por el resto de este libro. Haga clic en Finalizar para cerrar la página de configuración y comenzar a probar la instalación.

39

FIGURA 1.17 Pantalla de configuración de transformación con avisos adecuados, ya que cada tarea se ha completado.

Pruebas

Después de instalar MySQL puedes probarlo. Puede ver el estado del servicio usando el monitor de MySQL, que determina si el servidor de base de datos está en marcha. Usted puede utilizar la línea de comandos para registrar e investigar en la base de datos MySQL igual que lo haría en un servidor remoto.

Para abrir un nuevo símbolo del sistema, como se muestra en la Figura 1.18, presione la tecla Windows + R. Cuando el tipo de sistema abierto, el siguiente comando para iniciar sesión:

$ mysql -uroot -p

NOTA Si aparece "command not found", tendrá que añadir MySQL a la variable PATH.

Un aviso Introduzca Contraseña. Escriba la contraseña establecida en el proceso de configuración.

NOTA Cuando se escribe una contraseña, el sistema no mostrará las actualizaciones de texto.

40

FIGURA 1.18 El símbolo del sistema con el comando entró para iniciar sesión en el servidor de base de datos MySQL

Si la conexión es exitosa, un aviso que describe el servidor MySQL. La notificación contiene la versión de MySQL que está actualmente en ejecución. El siguiente es un ejemplo de la Comunicación:

Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 5 Server version: 5.0T.45-community-nt MySQL Community Edition (GPL)

Una vez que se conecte a MySQL, el símbolo del sistema cambia a mysql>. A partir de este momento, hasta que salga, todos los comandos se dirigen al servidor de base de datos.

Por ejemplo, para ver qué bases de datos están disponibles, escriba el comando siguiente:

mysql> show databases;

Para probar la instalación de bases de datos, crear una nueva base de datos:

mysql> create database flashphp;

Cuando se crea la base de datos, se puede seleccionar con el siguiente comando:

mysql> use flashphp;

Incluso puede pasar en el nombre de base de datos durante la fase de inicio de sesión, como el:

$ mysql -uroot -p flashphp

41

En este punto, MySQL debe ser instalado correctamente en el servidor de desarrollo de Windows. La siguiente sección explica cómo instalar MySQL para UNIX y sistemas similares a UNIX. El proceso de instalación de PHP está directamente siguiendo las instrucciones de UNIX. Siéntase libre para ir por delante si sólo desea centrarse en un sistema Windows.

Instalación de MySQL para UNIX Usted puede instalar MySQL en su sistema UNIX, utilizando el código fuente proporcionado en el sitio del libro, o usted puede descargar los archivos más recientes de MySQL directamente en http://dev.mysql.com/ downloads/mysql/5.0.html#linux.

NOTA La versión de descarga depende del entorno en el que está instalando.Consulte la siguiente guía para más información: http://dev.mysql.com/doc/refman/5.0/en/which-version.html.

Después de descargar los archivos de instalación es necesario, puede comenzar la preparación para el proceso de instalación. El primer paso es agregar el usuario y grupo mysql para que MySQL Ejecutar como. El comando siguiente crea el grupo mysql y añade un usuario de MySQL a ese grupo nuevo:

$ groupadd mysql $ useradd -g mysql mysql

Elija el directorio en el que desea instalar MySQL. Usted puede elegir el mismo lugar donde se instaló Apache para mantener todos sus componentes de desarrollo en el mismo lugar.

$ cd /usr/local

NOTA Puede que tenga que realizar la instalación de MySQL como root si se protege el directorio.

Descomprima el paquete de distribución y crear un vínculo simbólico a ese directorio.

$ gunzip < /usr/local/mysql-5.0.45-linux-i686-glibc23.tar.gz | tar xvf - $ ln -s /usr/local/ mysql-5.0.45-linux-i686-glibc23 mysql

Cuando el comando se ha completado el desembalaje, el cambio en el directorio de instalación.

$ cd mysql

Cambiar la propiedad de los archivos a MySQL ejecutando un comando de la propiedad recursiva. El primer comando cambia la propiedad y el segundo cambia el atributo de grupo.

$ chown -R mysql $ chgrp -R mysql

Si no tiene instalada una versión anterior de MySQL en este equipo, debe crear el directorio de datos MySQL y tablas de permisos.

scripts/mysql_install_db --user=mysql

Si quiere que MySQL se ejecute automáticamente cuando la máquina empieza, puede copiar el archivo mysql.server situado en el apoyo o directorio a la ubicación donde el sistema tiene sus archivos de arranque. Para obtener más información sobre la ubicación del directorio que las preocupaciones y otros sistemas específicos, vaya a http://dev.mysql.com/doc/refman/5.0/en/UNIX-postinstallation.html#automatic-start.

42

http://dev.mysql.com/doc/refman/5.0/en/UNIX-postinstallation.html#automatic-start

http://dev.mysql.com/doc/refman/5.0/en/which-version.html

Cuando todo está bien expandido e instalado, puede empezar a probar.

Para iniciar el servidor MySQL, ejecute el comando siguiente desde el directorio de instalación de MySQL:

$ bin/mysqld_safe -- user=mysql & Utilice el siguiente comando para verificar que el servidor está funcionando realmente:

$ bin/mysqladmin version $ bin/mysqladmin variables

La salida de mysqladmin version varía dependiendo de la versión instalada. Esta es una muestra que regresa ese comando:

mysqladmin Ver 14.12 Distrib 5.0.54, for pc-linux-gnu on i686 Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB This software comes with ABSOLUTELY NO WARRANTY. This is free software, and you are welcome to modify and redistribute it under the GPL license

Server version 5.0.54 Protocol version 10 Connection Localhost via UNIX socket UNIX socket /var/lib/mysql/mysql.sock Uptime: 0 days 2 hours 2 min 07 sec

Threads: 1 Questions: 323 Slow queries: 0 Opens: 0 Flush tables: 1 Open tables: 7 Queries per second avg: 0.000

Protección de MySQL

Es importante que usted proteja a los usuarios de MySQL de la actividad maliciosa. Por defecto, MySQL se instala la raíz y los usuarios anónimos, sin contraseñas, que es lo mismo que usar un valor predeterminado global. Es una práctica muy buena para asignar contraseñas de inmediato y en algunos casos, eliminar por completo los usuarios anónimos.

Configurar un contraseña en Windows

La contraseña para la cuenta root se le dio una contraseña cuando se ejecutó el programa de instalación. Sin embargo, si por alguna razón usted desea cambiarla, simplemente ejecute el siguiente comando, NEW_PASSWORD sustituyendo con la contraseña real que desea utilizar:

$ mysql -uroot mysql> SET PASSWORD FOR ‘root’@’localhost’ = PASSWORD(NEW_PASSWORD); mysql> SET PASSWORD FOR ‘root’@’%’ = PASSWORD(NEW_PASSWORD);

Configurar un contraseña en UNIX

La instalación de MySQL en Unix deja el login de root sin contraseña, a diferencia de la instalación de Windows. Es muy importante asignar una contraseña inmediatamente:

$ mysql -uroot

43

mysql> SET PASSWORD FOR ‘root’@’localhost’ = PASSWORD(NEW_PASSWORD); mysql> SET PASSWORD FOR ‘root’@’host_name’ = PASSWORD(NEW_PASSWORD);

Se debe reemplazar host_name con el nombre de host del servidor. Si usted no conoce la máquina del servidor, ejecute este comando mientras está conectado a MySQL para determinar la información:

SELECT Host, User FROM mysql.user;

Para eliminar la cuenta anónima, acceda a MySQL y emitir el siguiente comando:

DROP USER ‘’;

PRECAUCIÓN Tenga cuidado al eliminar un usuario y revise la ortografía del nombre del usuario antes de emitir esa orden.

Configuración de PHP en el Servidor WebPHP es el último componente para instalar a fin de completar el proceso de construcción del sistema de desarrollo. El proceso de instalación de PHP es sencillo, pero requiere un poco de personalización.

NOTA Al instalar el soporte para XML y las bibliotecas de GD, el sistema puede requerir de las bibliotecas y de componentes adicionales.

Instalación de PHP para Windows

Instalación de PHP para Windows es en realidad bastante simple. Gran parte del proceso de instalación consiste en mover archivos de un lado y edición de archivos existentes. Usted puede encontrar los archivos de instalación de PHP en el sitio Web del libro o puede descargar la última archivos directamente desde el sitio en php.org www.php.net/downloads.php.

Instalación

Para empezar el proceso de instalación de PHP, ejecute el instalador de la aplicación que ha descargado. La página de bienvenida para el asistente de configuración, como se muestra en la figura 1.19.

La carpeta de destino, como se muestra en la figura 1.20, es donde se instala PHP. Por defecto, se eligió una ruta de directorio de Archivos de programa dentro de ella. Esto puede causar problemas en algunos servidores. Una ruta común es C:\php o C:\php5 si va a instalar varias copias de PHP.

44

http://www.php.net/downloads.php

FIGURA 1.19 La página de bienvenida de instalación de PHP

45

FIGURA 1.20 Seleccione la carpeta de destino.

El programa de instalación de PHP está construido para configurar PHP y Apache para trabajar juntos. Esto incluye la edición de los archivos de configuración de Apache.

En la página de configuración de servidor Web, como se muestra en la Figura 1.21, seleccione la versión de Apache que había instalado previamente. Si no está seguro de qué versión está instalada, puede ejecutar el siguiente comando en el símbolo del sistema:

/usr/local/apache2/bin/httpd –v

El siguiente es un ejemplo de salida de la orden anterior:

Server version: Apache/2.0.59 Server built: Aug 31 2007 01:58:43

46

FIGURA 1.21 La página web de configuración del Instalador de PHP

En la siguiente página, ver la Figura 1.22, es donde se informará a la instalación de la ubicación del directorio de configuración de Apache. Por ejemplo, si has seguido la guía de instalación de Apache en el comienzo de este capítulo, el camino sería el siguiente:

C:\Program Files\Apache Group\Apache2\conf\

En la siguiente página que usted elija las extensiones adicionales necesarios para este libro (vea la Figura 1.23). Dichas extensiones son GD2, EXIF, MySQL, y PEAR. También puede elegir instalar cualquier otra que usted piensa que puede ser útil.

47

FIGURA 1.22 Directorio de configuración de Apache

48

FIGURA 1.23 Elija las extensiones que desea instalar, además de PHP.

Toda la configuración se establece en este momento, y usted puede hacer clic en Instalar para comenzar el proceso de instalación de PHP. Cuando haya finalizado la instalación de una página aparece Completo.

Usted puede abrir el directorio en el que PHP está instalado y ver los diferentes archivos. También puede editar el archivo php.ini para satisfacer sus necesidades específicas.

C:\php5\php.ini

La configuración por defecto de la php.ini debe trabajar para una configuración de desarrollo con la excepción que debe permitir a display_errors. Habilitación de la visualización de los errores le dice a PHP para imprimir cualquier error en la pantalla. En una instalación de producción que podría ser considerado un problema de seguridad. Un servidor de desarrollo es generalmente sólo visto por los televidentes autorizados, lo que significa que permite esta opción no es un problema.

Abra el archivo php.ini y busque la sección relativa a error_reporting.

display_errors = Off

Cambia el valor a On.

display_errors = On

49

NOTA Los cambios en el archivo php.ini no son visibles hasta que se reinicie el servidor.

Asegúrese de reiniciar el servidor web Apache antes de continuar porque usted ha hecho algunas modificaciones en la configuración de Apache.

Pruebas

Después de instalar PHP puede crear una muestra del archivo PHP a probarlo. Un archivo de ejemplo común es el archivo phpinfo, lo que le permite ver las variables de configuración para la instalación de PHP en el servidor.

Usted puede utilizar el Bloc de notas o cualquier otro editor de texto para crear este archivo de ejemplo. Si instala la suite completa Web de Adobe, puede utilizar Dreamweaver para escribir archivos de PHP (ver Figura 1.24).

Esta es la sintaxis para el archivo phpinfo.

<?php phpinfo(); ?>

Guardar este archivo como info.php en la raíz de documentos de la instalación de Apache. Por ejemplo, si instala Apache en la ubicación predeterminada, el archivo PHP se guarda en:

C:\Program Files\Apache Group\Apache2\htdocs\info.php

50

FIGURA 1.24 La muestra del archivo PHP como se ve en Dreamweaver CS3

Ahora puede abrir este archivo en el explorador Web, como se observa en la Figura 1.25.

http://localhost/info.php

Si lo prefiere, puede crear un archivo PHP para probar si PHP está funcionando correctamente, como los siguientes:

<?php print “Hello, World! This is PHP.”; ?>

Al ejecutar este archivo en el navegador, debería ver el mensaje aparece.

51

FIGURA 1.25 Información PHP muestra en un explorador Web

Instalación de PHP para UNIX

Instalación de PHP para UNIX es más detallado y requiere más configuración. Esto es cierto para la mayoría de configuraciones de instalación de comandos de línea. Usted puede descargar el instalador de archivos desde el sitio Web del libro o de uno de los sitios Web oficiales de PHP.

Después de obtener los archivos de instalación de PHP, usted puede comenzar el proceso de instalación. Antes de comenzar la instalación, es una buena idea dejar de Apache para asegurarse que ninguno de los archivos se corrompe.

/usr/local/apache/bin/apachectl stop

Para iniciar la instalación, cree el directorio en donde PHP se instalará.

mkdir /usr/local/php5

Puede sustituir simplemente PHP5 para php. Sin embargo, añadiendo el número de versión hace que sea más fácil disponer de múltiples instalaciones y será más fácil de manejar en el futuro.

cd /usr/local/php5

52

Descomprimir los archivos y escriba el directorio de instalación:

gunzip php-5.2.5.tar.gz tar -xvf php-5.2.5.tar cd php-5.2.5

Configuración de parametros de construcción

El siguiente paso es la construcción de la línea de configuración. Este contendrá todas las extensiones necesarias y las características que desea incluir en la instalación. Por ejemplo, es necesario incluir la base de datos y soporte de imágenes para completar algunos de los capítulos de este libro, entre otros. Cada opción está contenida dentro de un conjunto de comillas simples ( ') e incluirá la ruta si es necesario.

./configure’ ‘--prefix=/usr/local/php5’ ‘--withapxs=/usr/local/apache/bin/apxs’ ‘--with-gd’ ‘--enable-exif’ ‘--with-mysql=shared,/usr/local/php5’ ‘--withmysqli=shared,/usr/local/php5/bin/mysql_config’ ‘--withlibxml-dir=shared,/usr/local/php5’ ‘--withxsl=shared,/usr/local/php5’ ‘--with-jpeg-dir=/usr/local/php5’ ‘--with-png-dir=/usr/local/php5’ ‘--enable-gd-native-ttf’ ‘-- with-freetype-dir=/usr/local/php5’ ‘--withgettext=shared,/usr/local/php5’

Cuando el proceso de configuración es completa (que puede tardar un tiempo dependiendo del sistema), crear y ejecutar el instalador:

make make install

Después de que el hacer el comando de instalación se ha completado, PHP debe ser instalado.

Configuración

Unas raciones de PHP necesita ser configurado para asegurarse de que funciona a la perfección con Apache y su sistema de desarrollo global. Modificación de este proceso es bastante fácil de completar, pero incorrecta puede resultar en un sistema roto. Además, al modificar los archivos de configuración, lo mejor es hacer una primera copia de seguridad.

El primer paso es mover el archivo php.ini a una ubicación central que PHP usará cuando se inicia.

cp php.ini.recommended /usr/local/lib/php.ini

Con el fin que Apache cargue los archivos de PHP, añadir módulo de referencias necesarias:

LoadModule php5_module modules/libphp5.so AddType application/x-httpd-php .php .phtml AddType application/x-httpd-php-source .phps

Reinicia Apache que estos cambios surtan efecto. Cada vez que usted modifique los valores en PHP o Apache, debe reiniciar el servidor.

/usr/local/apache/bin/apachectl start

Con todo correctamente instalado, puede probar la configuración mediante la ejecución de una muestra de archivos de PHP:

53

<?php phpinfo(); ?>

Resumen

En este capítulo, usted fue a través de los pasos necesarios para instalar el sistema de desarrollo completo. Este proceso incluyó la instalación de Apache, PHP y MySQL en Windows o UNIX servidor Web. El siguiente capítulo le guía por el proceso de hacer esta configuración de desarrollo más seguro. Esto incluye la obtención de los archivos en el servidor, así como la configuración general del servidor a través del archivo de configuración httpd.conf.

54

Capitulo 2

Explorando Flash y PHPSi ha instalado todos los componentes en el servidor, puede configurar el programa de instalación para ser más seguro. Después se explica la seguridad, el siguiente paso es configurar los controladores de error apropiado y buscar la manera de crear una configuración más fácil de usar para el usuario final.

Después de la seguridad y la configuración del servidor Web se completa, que se verá en una visión general de PHP para entender mejor cómo funciona todo. El uso de MySQL y la integración básica con PHP se explican utilizando varios ejemplos con las descripciones y explicaciones.

La última sección explora Flash, incluyendo la configuración de clase y una explicación general de IDE.

Introducción al Servidor Web

En el Capítulo 1, aprendió a configurar un servidor de desarrollo, que incluyó la instalación de PHP, MySQL y Apache. Esta sección es una visión general de cómo el servidor Web está configurado, así como la forma de hacer que el sistema sea más seguro.

Trabajar con archivos .htaccess

El archivo .htaccess se utiliza para modificar la forma de las funciones de Apache para un directorio específico. Este archivo es similar al archivo httpd.conf en la configuración global de Apache, con la excepción de que no es necesario y puede ser a nivel mundial con discapacidad, siempre que el administrador modifica la configuración del servidor Web.

La sintaxis de este archivo no es muy avanzada. Se trata básicamente de un archivo de texto que informa al servidor Web de modificaciones específicas.

Por ejemplo, ¿ha notado un sitio Web que se ha especializado extensiones de archivo, como anfitrión de la Web MediaTemple, que tiene el siguiente formato?

http://www.mediatemple.net/contact. mt

Observe cómo la url tiene la extensión .mt. Esta extensión no es una extensión de archivo estándar. Esta modificación puede conseguirse utilizando el archivo .htaccess:

# use custom file extensions AddType application/x-httpd-php .me

Esta modificación también se puede hacer utilizando el archivo httpd.conf, si usted prefiere que el servidor Web podrá utilizar esta extensión de archivo personalizado.

Apache maneja muchas peticiones por defecto y puede ofrecer aún más con módulos adicionales instalados. Un módulo en particular, le permite tener las URL personalizadas, también conocido comúnmente como limpiar las URL.

55

http://www.mediatemple.net/contact.mt

Las posibilidades .htaccess son variados y dependen totalmente de su aplicación. Uno de los usos más comunes de. Htaccess es redirigir www y sin www las solicitudes en la misma ubicación. Esto no sólo limita enlaces redundantes, pero también proporciona una mejor optimización del motor de búsqueda.

Un ejemplo de esta conversión, utilizando el dominio de example.org, sería algo similar a lo siguiente:

# Force www.domain.com to domain.com RewriteCond %{HTTP_HOST} ^www.example.org [NC] RewriteRule ^(.*)$ http://example.org/$1 [R=301,L]

Protección de su contenido

Usted puede proteger su contenido en un número de maneras. Usted puede construir un sistema de autenticación personalizada o utilizar la autenticación básica que está empaquetado con Apache.

La autenticación básica se establece en dos fases. El primer paso es crear la contraseña y usuario.

Utiliza el archivo htpasswd para crear el archivo de contraseñas. Esta contraseña la creación de comandos se encuentra en el directorio bin/ en la que instaló Apache. Por ejemplo, lo más probable es encontrar el archivo en la ubicación siguiente, suponiendo que utiliza la ruta de instalación se sugiere en el capítulo 1.

$ /usr/local/apache/bin/htpasswd

La primera vez que crear un usuario, es necesario informar a la contraseña de solicitud de creación para crear un archivo de la nueva contraseña. Desde ese momento se omite la opción-c.

PRECAUCIÓN Error para quitar la opción-c después de la instalación del primer usuario se traducirá en un nuevo archivo de contraseñas y eliminar cualquier información a los usuarios existentes.

Aunque no es obligatorio, es una buena práctica periódicamente copias de seguridad de esta y cualquier otros archivos importantes en caso de que su sistema se encuentra con un accidente inesperado o corrupción de datos.

El comando para crear una contraseña es simplemente una llamada a la aplicación de contraseña con el nombre de usuario se añade al final.

$ cd /usr/local/apache/bin/ $ htpasswd -c /usr/local/apache/passwd/passwords USERNAME

Asegúrese de sustituir USERNAME por el nombre de usuario real que usted desea agregar.

La aplicación htpasswd le pedirá la contraseña que desea asignar y, a continuación, pedirá que escriba la misma contraseña de nuevo para confirmar.

El archivo generado es la contraseña cifrada. Sin embargo, aún debe guardarlo en un lugar seguro. Bajo ninguna circunstancia debe este archivo ser almacenado en el directorio público, ya que podría comprometer la integridad de su sistema.

Esto no es tan importante en un sistema de desarrollo, pero es una buena práctica a seguir todas las medidas de seguridad adecuadas, incluso en una configuración de desarrollo, para familiarizarse con ellos. A medida

56

que continúe trabajando en los servidores, la seguridad se convertirá en una segunda naturaleza. Nunca debe colocar apagado para ahorrar tiempo.

Después de crear el archivo de contraseñas, añadir el control de seguridad en .htaccess en cualquier lugar que se desea proteger con contraseña. Por ejemplo, vamos a añadir la autenticación al servidor entero porque un servidor de desarrollo y que no quiere que nadie viéndolo.

Agregue lo siguiente a un nuevo archivo .htaccess en la raíz del directorio Web.

AuthType Basic AuthName “Authorization Required” AuthUserFile /usr/local/apache/passwd/passwords Require valid-user

Esto informa a Apache que cualquier solicitud en este directorio y por debajo requiere autorización. La última línea permite a cualquier usuario en el archivo de contraseñas para poder iniciar sesión.

Require valid-user

También puede agregar un nombre de usuario específico, pero esto es más difícil de mantener.

Esta es la autenticación básica por lo que tiene varias limitaciones. Por ejemplo, usted no puede modificar el cuadro de diálogo que aparece en el navegador del usuario. No se puede modificar la etiqueta de valores junto a los cuadros de entrada y, lo más importante, no se puede permitir que el usuario salga.

Si su aplicación requiere un sistema de acceso más personalizado e integrado, que puede ser mejor para construir una instalación personalizado PHP/ MySQL, dependiendo de tus necesidades.

Recopilación de información acerca de Apache

A medida que continúe trabajando con Apache, hay algunos comandos y herramientas que pueden resultar en más tiempo para desarrollar una aplicación en lugar de microgestión en el servidor.

Iniciar y Detener Apache

A veces, Apache puede actuar justo como cualquier otra pieza de software o hardware en su sistema. A menudo, cuando esto ocurre, un simple reinicio se soluciona el problema. Por ejemplo, como más archivos de los usuarios petición de Apache, puede comenzar a llenar la memoria interna y los archivos temporales.

Para reiniciar Apache sólo tiene que llamar al siguiente comando en UNIX desde la línea de comandos o reiniciar el servicio en Windows:

$ /usr/local/apache/bin/apachectl restart

NOTA La ruta de acceso a la aplicación apachectl puede variar dependiendo de la instalación de Apache.

Si desea detener Apache y no tener reiniciar, utilice el siguiente comando. Lo más probable es que hacer cuando la instalación de nuevos módulos o la actualización de Apache en sí.

$ /usr/local/apache/bin/apachectl stop

57

Para iniciar el servidor de nuevo después de completar la actualización, basta con utilizar la opción de arranque:

$ /usr/local/apache/bin/apachectl start

Determinar la versión de Apache En ocasiones, cuando la instalación de nuevo software, lo que necesita saber qué versión de Apache está ejecutando actualmente. Por ejemplo, al instalar PHP, es necesario saber qué versión de Apache se está utilizando. Esto se encuentra ejecutando un simple comando interruptor.

$ /usr/local/apache/bin/httpd -V

El resultado de este comando sería algo similar a la Figura 2.1.

Determar que modulos están instalados en Apache

Usted puede fácilmente determinar qué módulos están instalados actualmente en Apache con el comando siguientes indicadores de la línea en UNIX.

$ /usr/local/apache/bin/apachectl -t -D DUMP_MODULES

Para determinar los módulos de Windows, se debe ejecutar el siguiente comando:

httpd -t -D DUMP_MODULES

58

FIGURA 2.1 Viendo la actual versión de Apache

Una respuesta de ejemplo de este comando es algo similar a lo siguiente:

Loaded Modules: core_module (static) mpm_worker_module (static) http_module (static) so_module (static) include_module (shared) deflate_module (shared) log_config_module (shared) env_module (shared) expires_module (shared) headers_module (shared) setenvif_module (shared) ssl_module (shared) mime_module (shared) status_module (shared) autoindex_module (shared) info_module (shared)

59

vhost_alias_module (shared) negotiation_module (shared) dir_module (shared) imagemap_module (shared) actions_module (shared) userdir_module (shared) alias_module (shared) rewrite_module (shared) ... Syntax OK

Si se omite la marca -D DUMP_MODULES D-DUMP_MODULES sólo verá la respuesta de sintaxis. Se le informa si algo está mal o le dice que todo está bien.

$ /usr/local/apache/bin/apachectl –t

Para Windows el commando sería

httpd -t

Utilización de documentos de error personalizados

Cuando ve una URL de un sitio Web, Apache sirve una página para usted basado en su petición. Por defecto, si Apache se le pide para servir a un archivo que no puede encontrar, devuelve una fea página 404 que no es muy informativo y de hecho provoca una preocupación potencial para la seguridad.

Como se puede ver en la Figura 2.2, Apache ha publicado la información del servidor para que el mundo vea. Ahora bien, este no es un problema de seguridad enorme, pero cada pieza de información puede añadir hasta un grave problema.

FIGURA 2.2 Página de error por defecto de Apache

Una cuestión más importante con el uso de las páginas de error estándar es el hecho de que el usuario se presenta con una página inútil. Por ejemplo, el usuario ya sabe que el archivo no existe, pero no tiene a dónde ir, ni idea de lo que podría ser el problema. Por extraño que parezca, si un usuario se muestra una página 404 que él o ella no suele durar, y eso significa que un usuario abandonado por su sitio.

60

Modificar Apache

Por suerte, Apache le permite modificar esta página de error por defecto. Algunos hosts permiten modificar el archivo usando el panel de control que incluye instalado cuando adquirió el servidor. En este caso, sin embargo, el servidor de desarrollo requiere que configurar manualmente la mayoría de ella.

La utilización de documentos de error personalizado es tan simple como añadir la modificación de un archivo .htaccess. Este archivo se almacena normalmente en la raíz de documentos para asegurar que todos los archivos se vea el archivo.

El código siguiente es la sintaxis necesaria para modificar el documento de error.

# Customized Error Handler ErrorDocument 204 /error.html ErrorDocument 301 /error.html ErrorDocument 302 /error.html ErrorDocument 400 /error.html ErrorDocument 401 /error.html ErrorDocument 403 /error.html ErrorDocument 404 /error.html ErrorDocument 500 /error.html ErrorDocument 501 /error.html ErrorDocument 502 /error.html ErrorDocument 503 /error.html

Como puede ver, los documentos de error será sustituido por un archivo. Usted puede, por supuesto, apuntar a un archivo separado para cada error detectado. Si no asigna una página de error específico, Apache vuelve a su forma predeterminada. La lista anterior es un registro sólido de los códigos de error posible, pero no es completar una. Documento de error dinámico

Utilizando PHP, usted puede crear un error de manejo dinámico del sistema. La idea es llamar a una página como lo hizo en el ejemplo anterior, con la excepción de que una variable se pasará a notificar a esa página de que se detectó el error.

Usted comienza por modificar el controlador de errores en el archivo .htaccess, tales como:

# Error Handler, request is sent to a php file ErrorDocument 204 /errorHandler.php?e=204 ErrorDocument 301 /errorHandler.php?e=301 ErrorDocument 302 /errorHandler.php?e=302 ErrorDocument 400 /errorHandler.php?e=400 ErrorDocument 401 /errorHandler.php?e=401 ErrorDocument 403 /errorHandler.php?e=403 ErrorDocument 404 /errorHandler.php?e=404 ErrorDocument 500 /errorHandler.php?e=500 ErrorDocument 501 /errorHandler.php?e=501 ErrorDocument 502 /errorHandler.php?e=502 ErrorDocument 503 /errorHandler.php?e=503

61

Este código le dice a Apache para redirigir los errores en el fichero de errorHandler.php, pasando en el código de error. El siguiente paso es crear el archivo PHP que se encargará de los códigos de error. Este PHP espera un argumento y será lo suficientemente inteligente como para devolver una respuesta válida si no hay error se pasa en.

La primera parte del archivo captura el código de error e inicializa una variable para almacenar la cadena de error.

<?php $errorCode = $_GET[‘e’]; $errorString = “”; ... ?>

Cuando un código de error se encuentra, un control para asegurarse de que es un número válido que se haga para mantener la aplicación segura.

<?php $errorCode = $_GET[‘e’]; $errorString = “”; if(!is_numeric($errorCode)) { $errorCode = -1; }... ?>

Un cambio de base se utiliza para determinar el código de error se encontró. Los interruptores se explica en la sección "Explorando los fundamentos de PHP" más adelante en este capítulo.

<?php $errorCode = $_GET[‘e’]; $errorString = “”; if(!is_numeric($errorCode)) { $errorCode = -1; }

switch($errorCode) {case 204: // Sin Contenido (Documento vacío) $errorString = “Sin Contenido (Documento vacío)”; break; case 301: // Movido Permanentemente $errorString = “Movido Permanentemente”; break; case 400: // Solicitud Incorrecta $errorString = “Solicitud Incorrecta”; break; case 401: // Usuario no autorizado $errorString = “Usuario no autorizado”; break; case 403: // Prohibido

62

$errorString = “Prohibido”; break; case 404: // Documento No Encontrado $errorString = “Documento No Encontrado”; break; case 500: // Error Interno del Servidor $errorString = “Error Interno del Servidor”; break; case 503: // Fuera de los Recursos $errorString = “Fuera de los Recursos”; break; case -1: // Error Desconocido $errorString = “Error Desconocido”; } ?>

El último paso es para mostrar la cadena de error al usuario, que completa el error habitual de manipulación de secuencia de comandos. Usted notará que algunos de los códigos de error se omitieron en el interruptor para demostrar el hecho de que el guión se mueve en silencio sobre si se muestra un código de error no válido.

<?php $errorCode = $_GET[‘e’]; $errorString = “”; if(!is_numeric($errorCode)) { $errorCode = -1; }

switch($errorCode) {case 204: // Sin Contenido (Documento vacío) $errorString = “Sin Contenido (Documento vacío)”; break; case 301: // Movido Permanentemente $errorString = “Movido Permanentemente”; break; case 400: // Solicitud Incorrecta $errorString = “Solicitud Incorrecta”; break; case 401: // Usuario no autorizado $errorString = “Usuario no autorizado”; break; case 403: // Prohibido $errorString = “Prohibido”; break; case 404: // Documento No Encontrado $errorString = “Documento No Encontrado”; break; case 500: // Error Interno del Servidor $errorString = “Error Interno del Servidor”; break; case 503: // Fuera de los Recursos $errorString = “Fuera de los Recursos”;

63

break; case -1: // Error Desconocido $errorString = “Error Desconocido”; } ?>

<h2>Se produjo un error al procesar su solicitud</h2> <h3><?=$errorString?></h3>

La variable $errorString se imprime en la pantalla, informando al usuario que ha ocurrido un error.

Este controlador de errores personalizado presenta un error mucho mejor para el usuario. Algunos sitios web incluyen enlaces relevantes de interés o utilidad de la consulta (si se trataba de una búsqueda) para devolver la información pertinente. Es lamentable que un usuario podría ver una página de error, pero es más común como los cambios de tecnología y los sistemas se actualizan.

Es una buena idea para mantener vínculos permanentes, porque los motores de búsqueda vínculos caché. En el futuro, será beneficioso para su tráfico en caso de que el vínculo todavía trabajaba.

Como un bono a la secuencia de comandos anterior, que se encuentra en el sitio Web para este libro, hay un error completo sistema de manejo que incluye los errores localizados (se puede adaptar a otro idioma) y utiliza plantillas PHP y CSS personalizado archivo modificar el estilo.

64

Explorando lo básico de PHP

PHP (Hypertext Pre-Processor) es un servidor de secuencias de comandos de lenguaje que se ejecuta en Apache u otras aplicaciones similares de servidor Web. PHP es uno de los servidores más populares lenguajes de secuencias de comandos, ya que es bastante sencillo para empezar y puede manejar aplicaciones robustas.

La estructura de codificación se basa en C y puede ser escrito en un procedimiento (paso a paso) o la estructura de Classbased (objetos, propiedades, métodos, y así sucesivamente). Una vez que entienda los conceptos básicos de PHP, usted realmente puede comenzar a ver el verdadero poder.

Este libro está basado en PHP 5, pero muchos de los siguientes consejos, técnicas y estilos se explica en esta sección puede ser utilizada para PHP 4 y PHP 5, que las versiones son bastante similares.

Entender las variables

Variables, también conocido comúnmente como vars o propiedades (cuando se trabaja con clases), son probablemente el elemento más utilizado en la programación. Se utilizan para asignar un valor a un lugar que puede ser llamado en otra parte del código. El uso de variables no es sólo un ahorro de tiempo, sino que también hace el programa más estructurado y de fácil mantenimiento.

Aquí hay un ejemplo muy simple de una definición de variable en PHP:

$myVar = “hello world”;

El ejemplo anterior asigna la cadena "Hello World" a la variable $myvar.

Hay algunas cosas a tener en cuenta cuando se trabaja con variables.

Debe estar precedida por un simbolo dolar ($) (al menos en una Clase). Se debe finalizar con punto y coma (;).

Las variables pueden aceptar muchos tipos de datos, incluyendo pero no limitado a, String, Boolean, y Array, cada uno de los que se discute en las siguientes secciones.

Cadenas

Las variables de cadena (String) contienen texto, tales como:

“Hello, World!”

También se puede construir cadenas utilizando las técnicas de concatenación, como:

$var = “Hello”; $var .= “, World!”; print $var; // Outputs: Hello, World!

65

Booleans

Booleanos son variables especiales que pueden ser uno de los dos valores posibles: verdadero o falso. Se utilizan sobre todo en caso de declaraciones y otras formas de control condicional, como:

$loggedIn = false; if($loggedIn == false) { print “Sorry, you are not logged in!”; }

Arrays

Las matrices son estructuras complejas de datos que consiste en un grupo de elementos que se accede por la indexación.En PHP, este índice puede ser un valor numérico o una cadena.

Aquí hay un ejemplo de una matriz y las dos formas de acceder a los datos:

<?php $fruit = array( “Orange”, “Apple”, “Strawberry”, “Grape” ); print $fruit[1]; // Apple $fruit = array( “orange” => “Orange”, “apple” => “Apple”, “strawberry” => “Strawberry”, “grape” => “Grape” ); print $fruit[‘orange’]; // Orange ?>

Objectos

Clases en PHP describir un objeto o la definición de un objeto. Se componen de auto-definirse los métodos y propiedades, que le permite crear una funcionalidad personalizada.

Aquí hay un ejemplo muy básico de una clase en PHP con una llamada de ejemplo en la parte inferior del ejemplo:

<?php class Animals { function Animal() {}public function speak($word) {

66

print $word; } }class Dog extends Animals { function Dog($word) { Animals::speak($word); } }// Create a new Dog $dog = new Dog(“Hello.. Woof!”); ?>

Trabajar con funciones

En el desarrollo de aplicaciones que tienden a repetir las diversas tareas. Constantemente tener que escribir estas medidas puede ser un proceso largo. Más importante aún, el código de repetición hace que una aplicación sea menos eficiente.

Funciones le permiten colocar las tareas repetitivas en un recipiente pequeño y agradable que usted puede llamar en cualquier momento siempre y cuando la función es accesible.

Esta es una función de ejemplo que agrega dos números y devuelve la suma:

function addNumbers($num1, $num2) { // return the sum of the two numbers return ($num1 + $num2); }

Usted llama a una función por referencia al nombre de función y de pasarle cualquier argumento que la función requiere. Este ejemplo devuelve 10 como la suma.

Un argumento es un valor que se pasa a la función y más tarde utilizados en la función como una variable local.

addNumbers(4, 6); // outputs 10

Funciones en PHP puede tener un argumento predeterminado asignado, lo que significa que no será necesario que el argumento se apruebe en, como:

function addNumbers($num1, $num2, $print=true) { if($print) { print “Sum is: “ . ($num1 + $num2); }else { return ($num1 + $num2); } }

67

Esta función imprime el resultado directamente a la pantalla o devolver el valor si la variable $print es falso, que es por defecto. No se puede excluir un argumento en el medio de la definición de otros argumentos. Por ejemplo, la siguiente llamada de función no sería válido:

function say($upperCase=false, $string) { if($upperCase) { return strtoupper($string); }else { return $string; } }say(“Hello, World!”);

Que se asignaría el pasado-en cadena en el valor de $upperCase y hacer caso omiso de la variable $string. Dado que PHP no se preocupa de qué tipo de valor se pasa, se produce un error en la línea donde se devuelve la cadena.

Las clases también tienen funciones, llamados métodos. Los métodos pueden mantener las características especiales que las funciones estándar no pueden.

Entender las estructuras de control

Mayoría de los lenguajes de programación tienen estructuras de control que los fragmentos de código de la oferta global y proporcionar una ruta más dinámico para una aplicación. Las siguientes son algunas de las estructuras de control más comunes, incluyendo las usadas en la mayoría de este libro.

if

El construcción if se encuentra en cualquier lenguaje de programación popular, incluido PHP. Permite la ejecución condicional de fragmentos de código. Un ejemplo de una declaración if es:

$admin = getAdminStatus(); if($admin == true) { print “Admin logged in, show admin controls”; }

Puede anidar sentencias if con otros estados, si una cantidad ilimitada de veces. Un uso más realista de las declaraciones if de anidación es una aplicación de inicio de sesión que ha variado de los niveles de autenticación.

$loggedIn = true; $admin = true; $editable = true; if($loggedIn) { if($admin)

68

{ if($editable) { // allow the page to be // edited because a valid // administrator is logged in } } }

else

Suponga que desea mostrar un mensaje de error a los usuarios no registrados y en el panel de control adecuado, si el usuario está conectado. Esto se hace con una declaración más, que se ejecuta si la condición else no se cumpla.

$loggedIn = false; if($loggedIn) { // display control panel }else { // display login form and error message }

Una cosa no es necesaria y se coloca después de todos los otros controles condicional, como elseif, que está en la siguiente sección.

elseif

El elseif es la combinación de un if y un else. Esta declaración se coloca después de un if, y permite que el código coincida con otra condición, que puede ser completamente diferente a si antes de ejecutar.

NOTA Un else o else..if sólo se evaluarán si la anterior condición no se cumple.

$loggedIn = false; $colorOfSky = “blue”; if($loggedIn) { // user logged in }elseif($ColorOfSky == “blue”) { // color of sky is blue, log user in?? }

while

El while es un tipo de bucle. El código dentro de las llaves {} se ejecuta "mientras" se cumple la condición.Una vez que la condición ya no es válida, el bucle se detiene.

69

PRECAUCIÓN bucles en PHP puede correr para siempre si no programado correctamente. Tenga cuidado al trabajar con loops y siempre verifique los datos válidos primero.

while($x < 50) { print “x=” . $x . “<br />”; $x++; }

for

Un bucle es el circuito más complejos en PHP. Aquí hay un ejemplo:

for($x=0; $x < 10; $x++) { print “x=” . $x . “<br />”; }

La primera expresión ($x = 0) se ejecuta de manera incondicional una vez al comienzo del bucle. La segunda expresión ($x <10;) se evalúa en cada paso y el ciclo continuará hasta que esta condición se cumple o que el bucle se detiene con una pausa. En cada paso, la tercera expresión ($x + +) es ejecutado. En este ejemplo, incrementos de $x en cada paso.

Puede anidar los bucles e incluso definir las variables múltiples en la primera expresión. Esto puede hacer que el código sea más rápido, pero más difícil de leer.

foreach

El bucle foreach se utiliza para iterar sobre un arreglo. Se asigna la variable de bucle al conjunto deseado, y en cada paso el valor se almacena en la variable de bucle.

$fruits = array(“Orange”, “Apple”, “Banana”, “Grapefruit”); foreach($fruits as $fruit) { print “Fruit: “ . $fruit; }

NOTA La variable $fruit seguirán existiendo una vez al bucle foreach se ha completado, por lo que es una buena idea de destruir el uso de la variable unset (), como unset (($fruit).

break

La ruptura de control finaliza la ejecución de un bucle, sin importar si la condición se cumple o no. Puede colocar un valor numérico opcional informar a PHP de cuántos niveles debe romper. Esto es útil cuando se tiene un ciclo anidado que tiene que decirle a los padres a la salida si se produce un error.

for($i=0; $i < count($users); $i++) {

for($j=0; $j < 5; $j++) {

if($users[$i][$j][‘valid’] == false) {

70

// found invalid user, group is compromised // exit both loops break 2;

} }

}

continue

A diferencia de break, continue saldrá de la iteración actual de un bucle, pero permitirá que las iteraciones restantes a continuar en.

Esto es útil cuando se recorre un montón de datos y sólo desea actuar en datos válidos.

for($i=0; $i < count($users); $i++) { if($users[$i][‘valid’] == false) { // invalid user, continue with remaining list continue; }// more code logic here }

Al igual que break, continue también acepta un argumento numérico diciendo que el número de niveles de encerrar bucles para saltar sobre.

switch

Un switch es similar a una serie de sentencias if utilizando la misma expresión (variable). Por lo general se utiliza un switch cuando se quiere probar una variable en contra de muchas de las condiciones.

switch($userLevel) { case ‘ADMIN’: print “User is an admin”; break; case ‘MODERATOR’: print “User is a mod”; break; case ‘MEMBER’: print “User is an member”; break; case ‘GUEST’: print “User is an guest”; break; }

Un break se utiliza para garantizar los controles restantes no se ejecutará, de hecho, si quita los break s, cada condición se comprobará, que pueden causar problemas si la intención de hacer una validación de varios niveles.

71

require

La declaración require () intenta cargar un archivo y se cerrará el programa con un error grave si el archivo no se encuentra. Esta función comprueba el archivo en contra de included_path actual, así como el directorio el archivo se ejecuta en.

require(“importantFile.php”);

El error que se muestra (ver figura 2.3) a veces puede causar un problema de seguridad potencial en que se mostrará la ruta del archivo salido adelante. Una mejor manera de manejar esto es crear un cheque por el primer archivo y un limpiador de pantalla, un mensaje menos crucial para el usuario.

if(!file_exists(“importantFile.php”)) { $error = “Sorry, one of the core components could not be loaded”; exit($error); // display clean error and exit remaining script }require(“importantFile.php”); // never runs, if file doesn’t exist

72

FIGURE 2.3 PHP require() error as seen in the browser

include

La sentencia include () es similar a la requiere, con la excepción que mostrará un error pero no detener la ejecución de la secuencia de comandos.

include(“optionalFile.php”);

require_once

La declaración require_once comporta de manera similar a require, con la excepción de que si el archivo actual ya está cargado, no intentará cargar de nuevo. Esto es más útil a medida que continuamos construyendo aplicaciones de gran tamaño que a veces comparten muchos archivos. Esto asegura que se ha cargado ningún código redundante.

require_once(“requiredFile.php”); // ... other code here require_once(“requiredFile.php”);

El segundo require_once no funcionará porque el archivo ya se ha cargado en la parte anterior del código.

73

include_once

El include_once () es similar a la require_once con la excepción de que si el archivo no se encuentra, sólo se muestra un simple error.

Uso de la comprobación de tipos en PHP

A diferencia de la mayoría de lenguajes de programación, PHP no requiere la tipificación estricta de las variables. Esto significa que usted no tiene que definir qué tipo de datos de una variable llevará a cabo.

Esto puede parecer una buena cosa porque las variables se pueden compartir. Sin embargo, la desventaja potencial de este enfoque es que una variable que espera ser una cadena que podría aparecer como una matriz. Lo más probable es romper el código o provocar una porción de código de explotación. Imagine un código similar al siguiente:

$id = -1; if(isset($id)) { // sql call here, set id to a string, for some reason $id = “user id”; }// more logic here if($id == -1) { // user not logged in }else { // user logged in }

Este es un ejemplo muy dramático, porque está lleno de las peores situaciones, pero se puede ver cómo las variables sin tipo pueden causar dolores de cabeza.

Funciones de verificación de Tipos

PHP ofrece algunas funciones especiales que le permiten comprobar el tipo de una variable, pero esto no impide que otro código deba sobrescribir las variables.

Un ejemplo de una de estas funciones se is_string, que comprueba si el passed-in el contenido de las variables de cadena.

$saying = “Hello, World!”; if(is_string($saying)) { print “$saying is a string”; }

PHP ofrece la capacidad de prueba para las matrices, los números, las cadenas, y los valores vacíos.

74

Soporte para versions futuras

Se ha mencionado que las futuras versiones de PHP podría incluir la comprobación de tipos estricta, pero por ahora, estas funciones, cuando sea necesario, proporcionará un mayor nivel de integridad para su aplicación It has been mentioned that future versions of PHP could include strict type checking, but for now, these functions, when needed, will provide a higher level of integrity for your application.

Explorando lo básico de MySQL

MySQL es la aplicación de almacenamiento usadas con PHP para crear una aplicación dinámica. Puede almacenar casi cualquier tipo de datos en una base de datos MySQL y tienen la capacidad de compartir esa información con otras aplicaciones y sistemas. A menudo, una base de datos se utiliza cuando la búsqueda se debe hacer o si los datos está cambiando con frecuencia y mucha gente va a pedir estos datos actualizados.

La alternativa a una base de datos es un archivo (archivo de texto) que tiene muchas limitaciones, las más devastadoras que el hecho de que sólo muchos casos en que el archivo puede ser utilizado una sola vez. Otra limitación es la capacidad de indexar y buscar rápidamente un archivo de texto.

Uso de declaraciones o sentencias (stantements)

El contenido en una base de datos MySQL son almacenadas en tablas. Estas tablas se almacenan en bases de datos que componen el sistema de MySQL. Los datos almacenados en estos cuadros se accede utilizando diversas declaraciones y condiciones, que se llaman las consultas. Hay muchas declaraciones que se pueden utilizar en las consultas SQL.

SELECT

La sentencia SELECT es la declaración más común, lo que le dice a MySQL qué contenidos (columnas) que desea obtener de una tabla.

SELECT id,name,ip, bio FROM users WHERE id=3

Usted puede seleccionar los datos de varias tablas con comas (,) para separar la columna de la tabla y los nombres.

SELECT users.id, users.name, members.posts, members.subs FROM users, members WHERE members.userID=users.id AND users.id=3

INSERT

La sentencia INSERT se utiliza para añadir nuevas filas a una tabla existente. Hay múltiples maneras de definir un INSERT.

Si sólo desea actualizar algunas columnas que usted necesita para definir las columnas.

INSERT INTO members (name, bio, ip) VALUES ($name, $bio, $ip);

75

Un acceso directo se utiliza para excluir a las definiciones de columna. Sin embargo, esto sólo es posible cuando todos los valores se actualizan o se han asignado los valores por defecto cuando se crea la tabla.

INSERT INTO members ($name, $bio, $ip);

Después de un INSERT, ha concluido, usted puede hacer una llamada a mysql_insert_id (), que devolverá el ID de la inserción exitosa última.

$result = mysql_query(“INSERT INTO members (“ . $name . “, “ . $bio . “, “ . $ip . “)”); $rowID = mysql_insert_id($result);

DELETE

La sentencia DELETE se utiliza para eliminar una o más filas de una tabla. Al igual que las demás declaraciones, puede crear una condición utilizando, WHERE, AND, OR, y así sucesivamente.

DELETE FROM users WHERE id=3

También puede eliminar todos los registros en una base de datos, omitiendo la condición:

DELETE FROM users

PRECAUCIÓN La sentencia DELETE es muy poderosa que se debe utilizar con extrema precaución.

Condiciones

Las condiciones en MySQL se utilizan para limitar la cantidad de datos que se devuelve. Por ejemplo, una consulta SQL como la siguiente devuelve todos los usuarios en la base de datos:

SELECT * FROM users

WHERE Esto estaría bien si eso es lo que desea que se produzca. Es probable que sólo quieren regresar a ciertos usuarios o incluso a un usuario específico. Esto se haría usando la condición WHERE.

SELECT * FROM users WHERE id=3

AND

La condición AND se utiliza cuando se necesita para que coincida con más de una condición. Un ejemplo sería que desea devolver una base de datos de los miembros que se han registrado y tienen una cuenta válida.

SELECT * FROM users WHERE active=1 AND registered=”yes”

Usted puede utilizar cualquier combinación de las sentencias condicionales, con la excepción de que sólo debe haber uno en el pliego.

76

OR

En la declaración OR se utiliza cuando se desea sólo una condición para que coincida. Por ejemplo, desea que los usuarios que tengan un nivel de administrador o mod. Piense en esto como if..else para SQL.

SELECT * FROM users WHERE level=’admin’ OR level=’mod’

Las condiciones en MySQL puede ser útil cuando se trata de desglosar los datos, especialmente cuando se inicia la combinación de ellos. No es raro para crear sentencias SQL muy complejo en cuestión de minutos.

Explorando Flash

Flash no es sólo una tecnología, es también el nombre de una herramienta de desarrollo de Adobe, que se utiliza para crear contenido Flash activado. Este contenido puede ser desde un simple anuncio publicitario a todo el camino a una completa base de datos impulsada sitio web con video y la interacción del usuario.

Flash IDE

Flash IDE (Integrated Development Environment), como se muestra en la Figura 2.4, es una herramienta de desarrollo robusta con muchas características útiles.

77

FIGURE 2.4 Flash CS3 IDE with default layout

Una de las herramientas de actualización es el editor de código, también conocido como el panel de ActionScript. Este panel, como se ve en la figura 2.5, es donde se escribe el código ActionScript para las aplicaciones de Flash. La última versión se ha completado de código robusto, depuración avanzada, así como el resaltado de sintaxis para mi algunas de las nuevas características.

78

FIGURE 2.5 Panel ActionScript en Flash CS3

Aquí es donde la mayoría de su vida el desarrollo se gasta. El panel no es el único editor, usted puede crear archivos completos de ActionScript, como se muestra en la Figura 2.6, y los incluyen en su aplicación.

Para crear un archivo AS, seleccione Archivo Nuevo. Elija ActionScript 3 Archivo de la columna del medio.Guarde el archivo como Sample.as a su escritorio.

79

FIGURE 2.6 External ActionScript editor included with Flash CS3

Editores Alternativos

Encontrarás muchos editores de ActionScript en el mercado. Mi favorito es FDT de Powerflasher en http://fdt.powerflasher.com/. Este editor ofrece la mayor cantidad de personalización y se basa en el editor de Eclipse, que muchas otras empresas dependen.

Crear un nuevo archivo FLA y guardarlo en su escritorio también. Ahora abra el editor de código y agregue el siguiente código:

#include “Sample.as”

Esa línea de código incluye el contenido de Sample.as en su aplicación. Esto significa que usted puede escribir todo el código ActionScript en el archivo externo y Flash sabrá incluirlo cuando se prueba o construir la aplicación.

80

Flash-dispositivos habilitados

Flash ya no es una simple herramienta de animación para crear gráficos llamativos para la Web. Ahora puede encontrar Flash instalado en una gran variedad de productos tales como teléfonos celulares, reproductores de medios, e incluso en algunas cámaras. La tecnología del teléfono celular es especialmente interesante porque estos dispositivos suelen tener conexiones a Internet activa, lo que significa que usted puede desarrollar aplicaciones dinámicas de Internet (RIA) para dispositivos móviles, así como el escritorio.

Un paso adelante

Ahora debe tener un conocimiento básico de lo que Flash es y cómo se ha avanzado en la última versión. En este libro se explican los distintos aspectos de Flash y ActionScript en cuanto a trabajar con PHP y gestión de datos.

Sin embargo, para una guía más detallada sobre Flash CS3, le recomiendo el Adobe Flash CS3 Professional Biblia, publicado por John Wiley & Sons, Inc..

Resumen

En este capítulo, usted aprendió sobre el servidor Web y cómo modificar los archivos de configuración para configurar su desarrollo a medida o el medio ambiente en vivo. Esta información incluye páginas de error personalizadas, la aplicación de módulos específicos, y mejores prácticas para la protección de su contenido.

Después de entender los conceptos básicos de trabajo con el servidor Web, el siguiente paso fue aprender a trabajar con PHP. El estudio abarcó los aspectos básicos de PHP, así como detalles de los capítulos de este libro.

La segunda mitad del capítulo incluye información sobre MySQL y cómo trabajar con los datos en su base de datos.

La última parte fue una visión general de Flash y cómo trabajar con el entorno de desarrollo. Para una visión más detallada, se dieron algunas referencias.

81

Capitulo 3Cómo realizar la Conexión

Cómo conseguir una conexión es una frase usada para describir el proceso de conexión a diversas fuentes de datos. En este capítulo, es el proceso de conexión de ActionScript (Flash), PHP, MySQL y de diversas maneras. Esta información puede ser un sitio Web simple o una base de datos impulsada por el sistema de gestión de contenido de Flash, que se convierte en el front-end de visualización.

Si estos tres componentes no están instalados, consulte el Capítulo 1 antes de continuar con este capítulo.

La primera parte de cada sección se centra en lo que cada tipo de conexión tiene que ofrecer y se avanza hacia ejemplos para proporcionar una visión completa del resultado final.

Entender Comunicaciones en Flash

Desarrollo de aplicaciones autónomo carece de ciertas funciones, principalmente la capacidad de trabajar con datos dinámicos. En pequeñas aplicaciones que puede utilizar archivos planos, como los archivos XML, pero los que plantearía un problema como un proyecto sigue creciendo.

Archivo de texto simple basado en aplicaciones también sufren el bloqueo de archivos, lo que puede ocurrir si hay demasiadas personas accediendo al archivo. Cuando esto ocurre, Apache y/o PHP puede lanzar un error que no da lugar a los usuarios para utilizar el sitio.

Determinar el estado de PHP

El primer paso para establecer una conexión con PHP en Flash es determinar si PHP está correctamente instalado y en funcionamiento. Esto se hace mediante la creación de un archivo PHP simple de las salidas de la configuración actual de la versión de PHP instalada.

La función de PHP phpinfo() muestra la información de configuración mediante la creación de una página personalizada de HTML, como se muestra en la Figura 3.1.

ADVERTENCIA Dejar el archivo phpinfo en su servidor puede ser un riesgo de seguridad. Lo mejor es que sólo debe subir cuando lo necesite para mirar, y luego borrarlo.

El siguiente es un archivo de información que muestra que hace una llamada a la función phpinfo().

<?php // output php configuration settings phpinfo(); ?>

82

FIGURA 3.1 Aquí está la salida de la función phpinfo, que muestra la configuración actual de configuración de PHP.

Si se le presenta con el archivo phpinfo, que generalmente es de color morado y se inicia con la versión de PHP instalada, entonces todo está instalado correctamente.

Sin embargo, si usted ve un cuadro de diálogo para descargar el archivo PHP, esto significa que Apache es configurado incorrectamente o no se ha habilitado para el apoyo de PHP. Este nivel de configuración se trata en el capítulo 1 y en los archivos de ayuda que se suministran con Apache. En raras ocasiones puede presentarse con un servidor no se encuentra la página, lo que podría significar Apache no está instalado o corriendo.

Suponiendo que PHP y Apache están funcionando correctamente, puede seguir adelante con el proceso de conexión de Flash a PHP.

Trabajar con distintos tipos de conexión

Flash ofrece muchos tipos diferentes de opciones de comunicación. La determinación de que la comunicación a utilizar en el proyecto se lleva a cabo mediante la característica intencional de la aplicación específica.

83

Una-vía de comunicación

Una comunicación bidireccional en Flash es el proceso de envío de datos a un servidor web y no buscar o por el cuidado si una respuesta vuelve. Esto es principalmente usado para abrir un URL, pero también podría utilizarse para actualizar un archivo con la intención de manipular el resultado. Este tipo de comunicación se utiliza a menudo por el simple hecho de mandar un evento o si lleva algún tipo de sistema de limpieza.

Por ejemplo, si su sitio necesita limpieza periódica de archivo (borrar, renombrar, mover), es una buena idea para unir esta al frente del sistema final, porque los recursos del servidor sólo se utilizarán cuando las mismas ya proporcionar contenido para el usuario . Este se habría iniciado por una comunicación bidireccional entre escenas.

NOTA La actualización de visualización concepto no debe ser utilizado para soluciones de copia de seguridad porque una visión lento podría dar lugar a falta de copias de seguridad.

He aquí un ejemplo de la comunicación unidireccional en Flash:

var serverFile:String = “http://localhost/callLink.php”; var urlRequest:URLRequest = new URLRequest(serverFile); navigateToURL(urlRequest);

La función navigateToURL acepta dos parámetros. El primer parámetro es la instancia del URLRequest, y el segundo parámetro es la ventana o el de destino. Por defecto, la ventana es _self, lo que significa la nueva página se cargará en el navegador actual, si existe.

Sin embargo, en algunos casos, puede que desee abrir una nueva ventana del navegador, que se puede hacer añadiendo el segundo parámetro.

var serverFile:String = “http://localhost/callLink.php”; var urlRequest:URLRequest = new URLRequest(serverFile); navigateToURL(urlRequest, “_blank”);

El parámetro de la ventana puede aceptar una de las siguientes cadenas, como se muestra en la Tabla 3.1.

TABLE 3.1 Window Targets para enlaces

“_self” Marco actual de la ventana actual “_blank” Nueva ventana “_parent” Parent del marco actual “_top” Marco de alto nivel en la ventana actual

El parámetro ventana también puede aceptar un nombre personalizado, como el nombre de un marco o ventana específica. Por ejemplo, suponiendo que usted desea enviar un vínculo a la ventana llamada "childWindowBox", el código se vería como el siguiente bloque:

var serverFile:String = “http://localhost/callLink.php”; var urlRequest:URLRequest = new URLRequest(serverFile);

84

navigateToURL(urlRequest, “childWindowBox”);

Usted sustiye los nombres de las ventanas precompilados y añade su nombre personalizado. Aunque este es un pequeño cambio, ofrece algunas grandes funcionalidades añadidas.

Abrir una ventana nueva o existente es sólo una de las posibilidades de conexión con otros datos.

Otro tipo de comunicación unidireccional en Flash se puede realizar mediante el uso de sendToURL().

El sendToURL () se utiliza para comunicarse en silencio con un guión. Comunicación silenciosa es una forma de comunicación unidireccional que no carga una página Web por separado. Esta forma de comunicación ofrece la posibilidad de enviar datos a un servidor sin interferir con la experiencia de navegación del usuario.

Aquí está el ejemplo anterior, con la nueva función añadida, junto con algún error de manipulación de base para gestionar las solicitudes no válidas y no está disponible.

var serverFile:String = “http://localhost/callLink.php”; var urlRequest:URLRequest = new URLRequest(serverFile); try { sendToURL(urlRequest); } catch (e:Error) { // handle error here }

Envío de datos al servidor

Puede haber ocasiones en las que desea no sólo en silencio solicita una dirección URL, sino también enviar los datos a lo largo de la misma. Esto se hace utilizando la clase URLVariables, que le permite crear un objeto de pares nombre/valor. Estos serían los mismos que los que se encuentran en una solicitud de HTML estándar.

var serverFile:String = “http://localhost/callLink.php”; var variables:URLVariables = new URLVariables(); variables.id = 1004; variables.user = “James”; var urlRequest:URLRequest = new URLRequest(serverFile); urlRequest.data = variables; try { sendToURL(urlRequest); }catch (e:Error) { // handle error here }

Otro ejemplo de una vía de comunicación es a ciegas enviar datos POST a un servidor. Esto añade la seguridad un poco más a su aplicación mediante la eliminación de los parámetros de la URL, y se realiza mediante la inclusión de los parámetros dentro de la petición.

85

El código de la solicitud de datos POST es simplemente asignar un valor a la propiedad método de la instancia URLRequest. ActionScript tiene una variable estática en la clase URLRequestMethod que se asigna a la variable método.

var serverFile:String = “http://localhost/callLink.php”; var variables:URLVariables = new URLVariables(); variables.id = 1004; variables.user = “James”; var urlRequest:URLRequest = new URLRequest(serverFile); urlRequest.method = URLRequestMethod.POST; urlRequest.data = variables; try { sendToURL(urlRequest); } catch (e:Error) { // handle error here }

Aquí está una muestra de que se enviarán al servidor. Como puede ver, el contenido y los elementos POST tienen la información que se envió. Las partes restantes de la solicitud son los atributos de datos estándar y no son específicas para este ejemplo.

POST /callLink.php HTTP/1.1 Accept-Language: en Accept-Encoding: gzip, deflate Cookie: login=usernames;session-id=120670l Referer: http://www.example.org/ User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X; en) AppleWebKit/522.11.1 (KHTML, like Gecko) Version/3.0.3 Safari/522.12.1 Content: id=1004%2Fuser=James Content-Type: application/x-www-form-urlencoded Accept: text/xml, text/html;q=0.9,text/plain;q=0.8,image/png Pragma: no-cache Content-Length: 327 Connection: keep-alive Host: www.example.org

Dos-vías de comunicación

En algunos casos, usted desea recibir una respuesta cuando envía los datos. Una de ellas sería cuando se intenta cargar los datos de un usuario específico de una base de datos. Usted podría pasar el identificador de usuario y espera recibir algún tipo de datos que contienen información de ese usuario.

La respuesta de una comunicación de dos vías se controla mediante la asignación de un detector de eventos y la asignación de una función de controlador.

var serverFile:String = “http://localhost/callLink.php”; var variables:URLVariables = new URLVariables();

86

variables.id = 1004; variables.user = “James”; var urlRequest:URLRequest = new URLRequest(serverFile); urlRequest.method = URLRequestMethod.POST; urlRequest.data = variables; var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, userResponseHandler); try { urlLoader.load(urlRequest); } catch (e:Error) { //handle error here } // handler function function userResponseHandler(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var args:URLVariables = new URLVariables(urlLoader.data); trace(“User Data: “ + args.response); }

La función de respuesta se pasa una referencia al evento. Las instancias URLLoader y URLVariables manejar el proceso separando la respuesta y volver sólo los datos que fue enviado de vuelta. La respuesta viene de nuevo con otros valores y parámetros, pero la mayoría de las veces sólo estará interesado en la propiedad de datos de la instancia de URLLoader.

Más aplicaciones completas a menudo regresan formato XML, que está cubierto en el capítulo 3 con otros datos de diferentes ejemplos de carga.

Ahora que sabe cómo trabajar con un solo sentido y comunicación de dos vías, la siguiente sección se expande sobre estas prácticas mediante la conexión a PHP.

Conexión de Flash a PHP

El proceso de conexión de flash PHP se realiza mediante las clases de pre-compilados que se introdujeron en la sección anterior. Si usted no tiene instalado PHP en este momento, consulte el Capítulo 1 para comprender e instalar PHP.

Para iniciar este ejemplo, abra el archivo de partida que se incluye en los archivos de libro de origen. Los archivos de código fuente se puede encontrar en el sitio Web del libro. El archivo de partida para este ejemplo tiene el diseño y componentes que han añadido, como se muestra en la Figura 3.2, que le permite centrarse en el código que hace que todo funcione.

La primera parte de este ejemplo es para definir la variable de que el archivo PHP se encuentra en el servidor local o remoto.

var phpFile:String = “http://localhost/connecting/exampleConn.php”; Una vez definida la ubicación del script PHP, el siguiente paso es crear la función que se llama cuando se pulsa el botón. function callServer(e:MouseEvent):void {

87

var urlRequest:URLRequest = new URLRequest(phpFile); var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, serverResponse); loader.load(urlRequest); }

FIGURA 3.2 Aquí está el diseño completo de la aplicación de ejemplo que va a trabajar con el.

Esta función crea instancias URLLoader y URLRequest. El phpfile se pasa a la URLRequest para crear el objeto. Por último, el detector de eventos se adjunta a la variable de gestor para hacer referencia a serverResponse, que es la función que se llama cuando se carga los datos.

function serverResponse(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); timeTxt.text = variables.returnValue; }

El controlador de función serverResponse () del servidor se encarga de capturar los datos que se pasa de nuevo desde el archivo PHP. Después de que los datos se ha cargado correctamente, se pasa a la clase URLVariables para generar un objeto dinámico.

88

Este objeto contiene los datos dinámicos de respuesta pasados del servidor, por lo que una llamada a un objeto simple es todo lo que se necesita para cargar los datos de la muestra. En este ejemplo, los datos de la muestra será el timestamp UNIX capturado y devuelto por PHP.

La última parte es un controlador simple botón que llama a la función callServer cuando un usuario hace clic en el botón.

callBtn.addEventListener(MouseEvent.CLICK, callServer);

El código PHP para este ejemplo es muy simple una declaración de impresión. La función time() se utiliza para agarrar el timestamp UNIX actual. La variable returnValue situado en la cadena es una definición de variable personalizada, de modo Flash sabe cómo llamar una vez que se carguen los datos.

Esta variable se puede nombrar cualquier número de cosas e incluso puede ser una serie de estos:

<?php print “returnValue=Hello from PHP, time is: “ . time(); ?>

Concatenación de datos

El .= se utiliza para concatenar o unirse a múltiples variables utilizadas en una cadena larga. En este caso, se está construyendo en la línea anterior para crear la cadena de datos de usuario que le será devuelto a Flash.

<?php $userData = “username=James”; $userData .= “&id=1004”; $userData .= “&level=Reader”; print $userData; ?>

El resultado que se pasará de nuevo a Flash se verá algo similar a lo siguiente:

username=James&id=1004&level=Reader

Usted puede notar que el nombre de relación entre el valor es muy similar a la forma en que se envíen los datos POST. Sin embargo todo lo que necesita saber para trabajar con estos datos en Flash son los nombres de las variables.

Múltiples piezas de datos

Tome la función actual serverResponse () y modificarlo para incluir estas nuevas variables que se envían desde el código PHP. El ejemplo siguiente es regresar no modificable valores, sin embargo, en una aplicación real, que los datos lo más probable es venir de una fuente de datos dinámicos.

Como aprendimos en la sección anterior, el formato de datos de Flash se convierte en una muy simple y fácil de usar, conjunto de objetos.

function serverResponse(e:Event):void {

89

var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); userTxt.text = “Welcome back, “ + variables.username; levelTxt.text = “Your current level is: “ + variables.level; }

Una limitación de la función anterior es las variables var sólo es accesible dentro de esa función.Para asegurar los datos devueltos sea accesible por toda la aplicación, es una buena idea guardar los datos en una variable externa.

Por ejemplo, este ejemplo se basará en el código anterior, añadiendo la nueva variable de asignación y definición. El primer cambio consiste en crear una variable de objeto que almacenará los datos.

var phpFile:String = “http://localhost/connecting/exampleConn.php”; var storedResult:Object; function callServer(e:MouseEvent):void { ... }function serverResponse(e:Event):void { ... }callBtn.addEventListener(MouseEvent.CLICK, callServer);

Después de la variable de objeto es definida por new, el siguiente paso es modificar la función serverResponse para almacenar los datos cargados en la variable de la recién creada.

function serverResponse(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); // check for valid data if(uint(variables.itemLength) > 0) { storedResult = variables; }userTxt.text = “Welcome back, “ + variables.username; levelTxt.text = “Your current level is: “ + variables.level; }

Los datos objeto cargado se almacena en el objeto storedResult, pero sólo si se encuentra una itemLength válida. La variable itemLength también es devuelto por el PHP y validado mediante una simple sentencia if.

Con esta nueva incorporación al código que se puede compartir los datos cargados con otras variables y secciones dentro de esta misma solicitud.

NOTA Los datos almacenados no son accesible hasta que el proceso de carga se complete.

El último paso es modificar el PHP para devolver la variable nueva creada itemLength, que se hace con otra adición a la cadena $userData.

90

<?php $userData = “username=James”; $userData .= “&id=1004”; $userData .= “&level=Reader”; $userData .= “&itemLength=3”; print $userData; ?>

Ahora que tiene una comprensión de cómo cargar los datos estáticos de PHP en Flash, la siguiente sección se amplía en este formato de datos estáticos y presenta una base de datos MySQL.

Conexión de PHP a MySQL

Cargando datos en Flash de un archivo PHP estático es una gran manera de aprender el proceso. Sin embargo, una aplicación RealWorld probablemente no va a utilizar ese formato. Los datos siempre están cambiando y nadie quiere actualizar los archivos PHP con la mano.

Determinar el estado de MySQL

Antes de la conexión con MySQL esté establecido, asegúrese de que MySQL está instalado y funcionando correctamente.

NOTA La instalación por defecto de MySQL deja la contraseña en blanco. Esto está bien para un sitio de pruebas, pero la contraseña no debe dejarse en blanco en un servidor en vivo.

La instalación más comun para el uso de MySQL en PHP es mediante la inclusión de la biblioteca de MySQL durante el proceso de instalación de PHP. Esto significa que la información de MySQL será mostrado en phphinfo, que se explica en la sección anterior.

Comprobación de MySQL se hace simplemente mediante la creación de un archivo de prueba phpinfo y funcionando en tu navegador, como se muestra en la Figura 3.3.

<?php phpinfo(); ?>

Este resultado es una página HTML masiva que muestra toda la información relativa a la instalación actual de PHP. Para determinar el estado de MySQL, la búsqueda de "MySQL". Tenga en cuenta que podría haber más de uno.

91

FIGURA 3.3 Aquí está la parte del archivo phpinfo que explica la instalación de MySQL disponible.

NOTA La sección de MySQL en el archivo phpinfo no será visible a todos si no se instala.

Suponiendo que MySQL está correctamente instalado y en funcionamiento, puede pasar a la siguiente sección, que explica cómo conectar PHP a una base de datos MySQL.

Conectar a MySQL

El proceso de conectar a MySQL de PHP es bastante simple. El primer paso es obtener la información de conexión de su administración del servidor o, si usted acaba de instalar, los datos de acceso serían los valores predeterminados.

Aquí está el muy básico, no hay código volantes para conectarse a una base de datos MySQL.

<?php $host = “localhost”; $user = “”; $pass = “”; $link = mysql_connect($host, $user, $pass); ?>

92

La función mysql_connect acepta tres argumentos. El nombre de host es el primer argumento, que casi siempre se establece en "localhost". El segundo es el nombre de usuario que se eligió al instalar MySQL, y, por último, la contraseña de su base de datos MySQL, que es blanco para la configuración por defecto.

La función mysql_connect retorna un ID de recursos, que es una referencia a la conexión de MySQL actual. Este ID se puede utilizar en el futuro las llamadas SQL, como mysql_query, y muchas otras funciones. Si le sucede que imprimir esta variable $link podrás ver un código de recursos. El ejemplo siguiente devuelve código identificador de recurso:

<?php $link = mysql_connect(“localhost”, “root”, “”); print “Response: “ . $link; ?>

El bloque de código anterior produce una respuesta, como:

Response: Resource id #32

Conexión persistente

La función mysql_connect estandar cerrará la conexión una vez finalizada la ejecución del script.Sin embargo, hay algunos casos en los que se desea mantener una conexión que no se cierra una vez que el guión está finalizado.

La función mysql_pconnect es exactamente lo que hace esto posible. Esta función mantiene una conexión después de que el script se ejecuta. La ventaja de mysql_pconnect es que elimina la necesidad de una nueva conexión. Sin embargo, la desventaja es que las conexiones persistentes se almacenan en una piscina y no se garantiza la misma conexión cada vez, que puede producir resultados inesperados.

He aquí un ejemplo de una conexión persistente, donde el único cambio es pa delante de la palabra "conectar" en la función de conexión.

<?php $link = mysql_pconnect(“localhost”, “root”, “”); print “Persistent Resource ID: “ . $link; ?>

Cerrar la conexión

Después de que el SQL finalice la ejecución, una buena práctica es eliminar la conexión a liberar recursos y memoria. Esto se hace simplemente haciendo un llamado a mysql_close(), que cierra la conexión.

Cierre de la conexión no es siempre necesaria, ya que se cerrará automáticamente cuando la secuencia de comandos detenga su ejecución. Dicho esto, en una aplicación más grande es mejor liberar recursos tan pronto como sea posible para mantener un uso responsable.

Aquí está el anterior mysql_connect() ejemplo, con la adición cerrar.

<?php $link = mysql_connect(“localhost”, “root”, “”); print “Response: “ . $link;

93

// close connection mysql_close($link); ?>

La función mysql_close puede aceptar una referencia de recursos de identificación, que viene muy bien cuando usted tiene múltiples conexiones. Este argumento no es obligatorio, por defecto la última conexión se cerrará.

NOTA Una conexión persistente creado por mysql_pconnect() no puede cerrar con mysql_close().

Seleccionar la base de datos

Después de establecer la conexión MySQL, usted puede seleccionar una base de datos. Usted no será capaz de consultar la base de datos hasta una conexión adecuada y de la base de datos son los elegidos. La función mysql_select_db le permite seleccionar la base de datos para consulta. También puede utilizar esta función para cambiar las bases de datos.

NOTA De una conexión activa sólo puede tener una base de datos conectada a la vez.

La función mysql_select_db acepta dos parámetros. El primer parámetro es el nombre de base de datos.El segundo parámetro (opcional) es un enlace al recurso de conexión activa. Esto es importante para usar cuando usted tiene pocas conexiones diferentes o si desea seguir correctamente la conexión activa.

Aquí hay un ejemplo utilizando el código anterior para la conexión y seleccionar una base de datos:

<?php $link = mysql_connect(“localhost”, “root”, “”); mysql_select_db(“db_name”, $link); // close connection mysql_close($link); ?>

Acercar todo junto

Usted puede usar su comprensión de cómo conectar a MySQL desde PHP para ampliar este concepto y crear una aplicación completa.

La primera parte del proceso de desarrollo es crear la base de datos y tablas, y rellenar con los datos.En este ejemplo será el comienzo de un sitio de una lista de CD donde el usuario solicita se devuelve una categoría de género y los álbumes especificos.

Comience por crear dos tablas de MySQL para este ejemplo. El primer cuadro corresponde a los géneros y la segunda tabla es la lista de álbumes.

CREATE TABLE genre ( id int(11) NOT NULL auto_increment, name varchar(100) default ‘’, dateAdded int(11) default ‘0’, PRIMARY KEY (id) ) ENGINE=MyISAM; CREATE TABLE albums (

94

id int(11) NOT NULL auto_increment, genreID int(11) NOT NULL default ‘0’, artist varchar(200) NOT NULL default ‘’, albumName varchar(200) NOT NULL default ‘’, PRIMARY KEY (id) ) ENGINE=MyISAM;

Utilizando cualquier navegador o editor que desee, crear una base de datos de música y añadir los dos cuadros para empezar. Después de crear las tablas, se puede llenar con los datos predefinidos para este ejemplo, que se lleva a cabo mediante la ejecución de una serie de declaraciones de INSERT MySQL.

INSERT INTO genre (name, dateAdded) VALUES (‘Blues’, 1197090235); INSERT INTO genre (name, dateAdded) VALUES (‘Country’, 1197090146); INSERT INTO genre (name, dateAdded) VALUES (‘Jazz’, 1197090525); INSERT INTO genre (name, dateAdded) VALUES (‘Rock’, 1197090230); INSERT INTO albums (genreID, artist, albumName) VALUES (4, ‘Rob Thermo’, ‘Rob\’s Rock Mix’); INSERT INTO albums (genreID, artist, albumName) VALUES (4, ‘Bill Dato’, ‘Rock Out Live’); INSERT INTO albums (genreID, artist, albumName) VALUES (4, ‘Jim Limb’, ‘Woodward 37th’); INSERT INTO albums (genreID, artist, albumName) VALUES (4, ‘Jason Alex’, ‘Guitar Mashup’); INSERT INTO albums (genreID, artist, albumName) VALUES (4, ‘Sam Riley’, ‘The Live Ones’);

Con la base de datos creada y las mesas asignadas y lleno de datos de ejemplo, puede continuar con la parte de PHP de la aplicación.

Conectar el PHP

El código PHP se inicia mediante la conexión a la base de datos recién creado usando las técnicas aprendidas en la sección anterior.

<?php $link = mysql_connect(“localhost”, “username”, “password”); mysql_select_db(“music”, $link);

Cuando se establece una conexión, puede crear la consulta que se ocupa de la carga de los datos del álbum. En primer lugar, crear el género para buscar mediante el establecimiento de una variable estática. En una aplicación más completa, la variable más probable es que se pasa a través de URL o de alguna otra forma de una llamada.

$genreID = 4; $query = “SELECT g.name, a.artist, a.albumName”; $query .= “ FROM albums a, genre g”; $query .= “ WHERE a.genreID=g.id”; $query .= “ AND g.id=” . $genreID;

95

Una llamada a mysql_query () se hace, que es responsable de ejecutar la consulta SQL anterior.Esta función devuelve un identificador de recurso que se utilizará en el resto de las llamadas de SQL.

$result = mysql_query($query);

Este álbum cargado de datos se almacenarán en un nombre o cadena de valor de la simplicidad, sino un ejemplo del mundo más real-lo más probable es utilizar XML u otro tipo de datos estructurados.

$response = “resp=loaded\n”;

CROSS--REF El uso de datos XML se explica en el capítulo 3. Esto incluye la carga y el ahorro de XML cuando se trabaja con PHP/MySQL objetos de datos.

En este punto, la conexión a MySQL y la llamada debe ser creado, pero aún no puede probar el código, porque no emitirá nada. La siguiente sección explica el dar salida de los datos mediante un bucle while común para recorrer los datos devueltos por las tablas de la base de datos de música.

Los datos se devuelven en un formato de lista de base, pero tiene que haber una forma de diferenciar los datos.Esto se hace mediante la creación de un identificador único en cada instancia de los resultados y la asignación a el valor del nombre.

$index = 0;

La siguiente parte es la carne de la solicitud, que es el bucle while.

while($row = mysql_fetch_array($result)) { ... }

El contenido del bucle while construye la respuesta de cadena.

while($row = mysql_fetch_array($result)) { $response .= “&artist” . $index . “=” . $row[‘artist’]; $response .= “&album” . $index . “=” . $row[‘albumName’]; $response .= “&genre” . $index . “=” . $row[‘name’]. “\n”; $index++; }

Usted se dará cuenta de la variable $ respuesta se le asigna un nombre y el valor de cada pieza individual de los datos devueltos por la base de datos. Los datos devueltos por la función mysql_fetch_array entra como una matriz multidimensional. La variable $row almacena cada fila de datos, y utiliza el nombre de la columna para acceder a la pieza específica de datos, tales como:

$response .= “&artist” . $index . “=” . $row[‘artist’];

Este proceso se repite para cada pieza de datos que desea capturar. Los datos que está disponible para este circuito, mientras que se determina en la consulta SQL que se definió en la sección anterior.

96

Usted puede haber notado que la consulta SQL se vio obligado a incluir sólo las columnas necesarias. Esto se hace para limitar la cantidad de datos y utilizar menos memoria, lo que se suma como un sistema sigue creciendo.

Si usted necesita todas las columnas de las tablas, se puede utilizar un asterisco (*), que modifica la llamada anterior de SQL para buscar algo como:

$query = “SELECT g.*, a.*”; $query .= “ FROM albums a, genre g”; $query .= “ WHERE a.genreID=g.id”; $query .= “ AND g.id=” . $genreID;

Dos letras se asignan asteriscos (*) porque son referencias a las dos tablas necesarias para este ejemplo.Uso de múltiples tablas en una llamada de SQL es muy común en mantener la relación de los datos conocidos, y ello permite que los datos que se almacenan en las pequeñas, trozos más manejables.

La última parte de PHP crea un "total" de valor que indica a Flash la cantidad de datos que se devuelven.Esto es necesario porque los datos están en formato de cadena. Cuando se utiliza un tipo de datos XML o matrices, no necesitará esta variable adicional.

El índice creado por cada fila de datos se hace el recuento, ya que sólo se incrementa cuando se encuentra una nueva fila de datos, lo que significa que está en sincronía con la cantidad de datos en la cadena.

$response .= “&total=” . $index;

La última parte es la declaración de impresión, que expone estos datos para Flash o una aplicación Web para cargar.

print $response;

Aquí hay un ejemplo de respuesta:

resp=loaded &artist0=Rob Thermo&album0=Rob’s Rock Mix&genre0=Rock &artist1=Bill Dato&album1=Rock Out Live&genre1=Rock &artist2=Jim Limb&album2=Woodward 37th&genre2=Rock &artist3=Jason Alex&album3=Guitar Mashup&genre3=Rock &artist4=Sam Riley&album4=The Live Ones&genre4=Rock &total=5

Esa es la aplicación completa, que carga en un bloque de datos del álbum usando el género como la clave.

Aquí está todo el código PHP en una lista para copiar/pegar o para examinar de cerca y comprender mejor cómo es que trabajan todos juntos.

<?php $link = mysql_connect(“localhost”, “username”, “password”); mysql_select_db(“music”, $link); $genreID = 4; $query = “SELECT g.name, a.artist, a.albumName”; $query .= “ FROM albums a, genre g”;

97

$query .= “ WHERE a.genreID=g.id”; $query .= “ AND g.id=” . $genreID; $result = mysql_query($query); $response = “resp=loaded\n”; $index = 0; while($row = mysql_fetch_array($result)) { $response .= “&artist” . $index . “=” . $row[‘artist’]; $response .= “&album” . $index . “=” . $row[‘albumName’]; $response .= “&genre” . $index . “=” . $row[‘name’]. “\n”; $index++; }$response .= “&total=” . $index; print $response; ?>

Construir el Flash

La porción de Flash de esta aplicación es responsable de cargar los datos y recorre a imprimir cada álbum. Para simplificar, esta aplicación es ActionScript, lo que significa la presentación de los datos se hace en el panel Salida.

Una aplicación más completa que tomar estos datos cargados y mostrarlos en una lista o de otro componente de datos personalizados.

El primer paso es definir el archivo PHP que se llama, que tendría un aspecto similar a este, dependiendo de cómo su sistema está configurado:

var phpFile:String = “http://localhost/getAlbums.php”;

Cuando se define la variable de PHP, el siguiente paso es crear la función que se llama el servidor.

function loadHandler():void { ... }

Esta función establece la primera instancia de URLRequest, pasando la variable de PHP como un argumento.

var urlRequest:URLRequest = new URLRequest(phpFile);

El URLLoader se utiliza para crear un detector de eventos y para iniciar el proceso de carga en la realización de esta función. La variable URLRequest se pasa a la función de carga de la instancia de clase URLLoader, que se requiere para cualquier tipo de carga de datos.

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, callServerHandler); urlLoader.load(urlRequest);

La siguiente función es la de definir callServerHandler, que se llama una vez que los datos son enviados desde el archivo PHP escrito en la sección anterior. Esta función se pasa una referencia de evento que contiene los datos cargados.

98

function callServerHandler(e:Event):void { ... }

El primer paso en esta función es la de crear la instancia de URLLoader, que se utiliza para capturar los datos cargados. La instancia de eventos contiene una propiedad de destino, que se utiliza aquí pasando en un nuevo URLLoader.

El resultado se almacena en la variable de gestor local, que se utilizará en el resto de esta función,.

var loader:URLLoader = URLLoader(e.target);

Usted puede recordar de la sección de PHP de este ejemplo que los datos se devuelven en pares de nombre y objeto de valor. Que los datos se almacenan en la propiedad de datos de la recién creada instancia de gestor.

Estos datos se pasa a una instancia de la clase URLVariables, que crea un objeto de ActionScript para otras partes de la secuencia de comandos puede manejar los datos.

var dataObj:URLVariables = new URLVariables(loader.data);

Ahora que se carguen los datos, puede probar usando una simple declaración de seguimiento que debe mostrar las entradas totales devueltos.

trace(“Total Albums: “ + dataObj.total);

Que la llamada trace debe mostrar lo siguiente en el panel Salida:

//Output: Total Albums: 5

Esto significa que el archivo PHP que se llama y los datos se carga correctamente desde la base de datos usando PHP como el controlador de datos en el medio.

Usted podría terminar el script de aquí, ya que todas las obras, pero para seguir usando el bucle for.. para mostrar la información de cada álbum utilizando una serie de trace las llamadas por la simplicidad.

El bucle for.. se establece con la propiedad total de la dataObj para determinar cuántas veces el bucle debe ejecutarse.

for(var i:uint = 0; i < dataObj.total; i++) { ... }

La primera huella (trace) en el bucle for.. muestra el álbum actual que se muestra. El número actual álbum es creado utilizando la variable i del bucle 1 agregado. La razón de esto es que la variable i comienza en cero, y para fines de presentación del primer disco debe ser de 1.

trace(“Album “ + (i + 1));

99

La siguiente sentencia trace está configurado para mostrar el artista actual. El valor se recupera de la instancia de objetos dataObj utilizando una referencia de objeto dinámico. El nombre "artista" se adjunta a la variable i, que crea un nombre de instancia.

trace(“ Artist: “ + dataObj[‘artist’ + i]);

El resto de las instrucciones de seguimiento (trace) son duplicados de la anterior, con el nombre de instancia y en la descripción ligeramente modificada.

trace(“ Album: “ + dataObj[‘album’ + i]); trace(“ Genre: “ + dataObj[‘genre’ + i]);

En este punto, el ciclo se completa y también lo es la aplicación de ejemplo completa. Ahora puede probar el ejemplo y debería ver las instrucciones de seguimiento de muestra en el panel Salida, como se muestra en la Figura 3.4.

FIGURA 3.4 Aquí hay un ejemplo de los datos del álbum aparece en el panel Salida.

100

La porción de ActionScript completo de esta aplicación sigue:

var phpFile:String = “http://localhost/getAlbums.php”; function loadHandler():void { var urlRequest:URLRequest = new URLRequest(phpFile); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, callServerHandler); urlLoader.load(urlRequest); }function callServerHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var dataObj:URLVariables = new URLVariables(loader.data); // Simple trace for example for(var i:uint = 0; i < dataObj.total; i++) { trace(“Album “ + (i + 1)); trace(“ Artist: “ + dataObj[‘artist’ + i]); trace(“ Album: “ + dataObj[‘album’ + i]); trace(“ Genre: “ + dataObj[‘genre’ + i]); } }loadHandler(); loadHandler();

Resumen

El ejemplo anterior debería haber dado una comprensión bastante buena de trabajar con una base de datos MySQL en Flash usando PHP como la secuencia de comandos en el medio. Puede ampliar este ejemplo para crear una aplicación más robusta ya que esta muestra se utilizó para ilustrar el concepto, y no centrarse en pantalla o la propia apicación.

De datos de MySQL es sólo un ejemplo de los datos que se pueden mostrar en Flash.

El siguiente capítulo se amplía en este ejemplo y presenta objetos de datos más avanzadas, tales como XML, junto con otras formas de datos, tales como imágenes y archivos de texto.

101

Capitulo 4Trabajar con Datos

Trabajar con datos es el proceso de enviar y cargar información para ActionScript de interpretar. Hay dos tipos de datos que pueden ser utilizados en ActionScript. Estos serían estáticas y dinámicas. En los casos más comunes, el proceso dinámico que se prefiere a la estática. Principalmente porque los datos dinámicos a menudo incluye un componente de base de datos.

En este capítulo se trata de trabajar con datos dinámicos en Flash y PHP. Usted comienza por la carga de archivos de texto simple, a continuación, pasar a XML y la carga más avanzados. El capítulo concluye con una aplicación de ejemplo completa que carga los datos de imagen para mostrar una imagen en miniatura y la imagen de tamaño normal.

Cargar datos en Flash

Cargando datos en Flash es una práctica muy común. En casi todos los proyectos, que desea tener algunos dinámicos (actualizables) de las porciones. El propósito de los datos dinámicos es la de limitar el importe de la actualización necesaria. Por ejemplo, si nos fijamos en un sitio de noticias, verás que la mayoría del contenido externo no cambia (logotipos, navegación, etc.) Esto también es válido para una aplicación Flash en la que lo más probable es que sólo tienen una cierta parte que en realidad necesita ser actualizado. Esta sección le guía por el proceso de carga de datos XML de todas las forma de imágenes y sonido.

El proceso de carga de datos en Flash se familiariza con bastante rapidez como la mayoría de los tipos de datos que se carga tienen requisitos similares.

Empiece por buscar un ejemplo sencillo que cargar un archivo de texto. En este ejemplo se buscará el archivo de texto en un par de lugares diferentes dependiendo de donde la aplicación se está ejecutando. Si se ejecuta este código en el IDE de Flash se verá en el mismo lugar de la FLA se guarda o en el directorio temp del usuario si el archivo no se ha guardado. Si el código es compilado en un archivo SWF, el archivo de texto se cargan desde el mismo directorio que el SWF se almacena en.

var txtFile:String = “sample.txt”; var urlRequest:URLRequst = new URLRequest(txtFile); var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, loadHandler); loader.load(urlRequest); function loadHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); trace(“Loaded Data: “ + loader.data); }

El anterior ejemplo, carga un archivo "sample.txt" y todos los rastros de su contenido en el panel Salida de Flash, que se abre automáticamente. Otra forma de abrir o cerrar el panel de salida es por la elección de la ventana salida.

102

Comprender las clases utilizadas para cargar los datos

De ActionScript en Flash tiene una serie de clases prefabricadas que se utilizan para cargar los datos. La siguiente sección explica la función de cada una de esas clases.

URLRequest

Esta clase se utiliza para configurar el archivo que se carga. Se puede asignar de manera directa a una variable, o para mantener el código general más compacto, asignar directamente dentro de load() de la URLLoader.De hecho, se puede aplicar este proceso a muchas de las clases. Esto no tiene ningún impacto en la funcionalidad de la clase y no es un paso necesario.

...loader.load(new URLRequest(txtFile));

URLLoader

Como se indica en el Docs Live Adobe, "La clase URLLoader descarga datos desde una URL como texto, datos binarios o variables con codificación URL. Es útil para la descarga de archivos de texto, XML, o cualquier otra información que se utilizará en una dinámica, basada en datos de aplicación.”

El URLLoader sirve a dos propósitos al enviar y cargar datos en ActionScript. El primer objetivo de la URLLoader es configurar el controlador completo. El otro propósito es capturar los datos cargados en el controlador completo. Una diferencia notable de la segunda finalidad es el hecho de la URLLoader no tiene una nueva palabra clave antes de que.

Configurar el callback

El último paso en la creación de un gestor de datos es la devolución de llamada. La devolución de llamada es otro nombre para el “controlador” de la función que se llama cuando los datos se ha cargado completamente. Esta función se asigna al evento Event.COMPLETE en la clase URLLoader.

var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, loadHandler);

Esta función de devolución de llamada requiere un argumento del tipo de evento, que se pasa automáticamente en cuando se llama al ActionScript. Este argumento es que el contenido de los datos cargados se almacenan.

NOTA Si usted se olvide de incluir el argumento en el controlador de eventos obtendrá un argumento de error de recuento de desfase.

ArgumentError: Error #1063: Argument count mismatch on sendtophp_fla::MainTimeline/serverResponse(). Expected 0, got 1. at flash.events::EventDispatcher/dispatchEventFunction() at flash.events::EventDispatcher/dispatchEvent() at flash.net::URLLoader/onComplete()

103

Poner todo junto

Ahora que tiene una comprensión de cómo el código para cargar los datos con ActionScript funciona, puedes pasar a ejemplos más concretos de envío y de carga. En este ejemplo, usted puede experimentar y construir a partir de la clase URLLoader porque tiene mucho más que justo el simple evento COMPLETE que usted utiliza. Por ejemplo, hay un evento IOError que se llama cuando se carga o por un error de envío. El código para diversos eventos es casi lo mismo, para su ejemplo IOError se vería como este:

var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, ioHandler); function ioHandler(e:Event):void { trace(“File loading was terminated”); }

Usted notará rápidamente que lo único que cambia es la cadena de eventos y la función de controlador.Eventos múltiples también pueden ser asignados, y es a menudo una buena idea mantener un alto nivel de compatibilidad. También son capaces para depurar código rápidamente si configura los eventos adecuados.

Asignar múltiples eventos

Suponga que desea manejar el IOError y el evento completo para la instancia del cargador. Usted puede entrar en cada controlador de eventos, sin embargo, esto puede convertirse en un largo proceso cuando se trabaja con cargadores múltiples. Una forma de lograr el resultado pretendido es utilizar una función para asignar los controladores.Es, básicamente, pasan en la meta como un argumento y asignar dinámicamente los controladores de su evento.

var txtFile:String = “sample.txt”; var urlRequest:URLRequest = new URLRequest(txtFile); var loader:URLLoader = new URLLoader(); assignHandlers(loader); loader.load(urlRequest); function assignHandlers(target:*):void { target[“addEventListener”](Event.COMPLETE, completeHandler); target[“addEventListener”](IOErrorEvent.IO_ERROR, ioErrorHandler); }

function completeHandler(e:Event):void { ... }

function ioErrorHandler(e:Event):void { ... }

104

Un nuevo concepto introducido en esta función es la forma dinámica de la asignación de detectores de eventos. El [] se utilizan para definir una cadena dentro de ellos como una variable. En este caso, la cadena "addEventListener" es en realidad el método para invocar y los valores con los () son los argumentos para pasar al método.El uso de este ejemplo para la escucha de un solo evento es una especie de exageración, pero si usted está trabajando con varios eventos que se convierte rápidamente en beneficios.

Manipular carga de datos

Después de usar los pasos anteriores para cargar los datos, tendrá que utilizar estos datos de alguna manera.Sin embargo, antes de que te sumerjas en el trabajo con los datos cargados se necesita una comprensión de lo que se pasa de nuevo y cómo trabajar con él. En las siguientes secciones, aprenderá a manejar los datos que se ha cargado. Una vez que haya completado esta sección se entenderá por completo la manera de cargar los datos y cómo trabajar con los datos cargados.

Una-vía de carga

Carga de un archivo de texto o la imagen es considerada una forma de carga, sobre todo porque no se pasa a lo largo de las normas o medidas para el archivo cargado. Una llamada a cargar una imagen se esperaría una imagen que se volvió y nada más. Este tipo de proceso de carga es más comúnmente entendido, si nos fijamos en un sitio Web. El logo en ese sitio se solicita y se carga, sin datos adicionales se las arregló para lograr esto.

Dos-vía de carga

Dos formas de carga es el proceso de carga de datos al pasar a lo largo de los argumentos de que el proceso solicitado se encargará. Por ejemplo, una llamada a un servidor de publicidad pasaría a lo largo de la cuenta de ello y posiblemente de algún otro tipo de información para determinar qué anuncios se debe mostrar.

Cuando se trabaja con aplicaciones de PHP o scripts dinámicos de otros es muy probable que pase a lo largo de los parámetros de trabajar. Aún más importante es el hecho de que usted puede obtener diferentes tipos de datos de vuelta. Por ejemplo, usted puede esperar que un objeto, obtenga un código de error. El propósito de esta sección es desarrollar una forma en la que se pueda manejar este caso.

var phpFile:String = “sample.php”; var urlRequest:URLRequest = new URLRequest(phpFile); var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, serverHandler); loader.load(urlRequest); function serverHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var vars:URLVariables = new URLVariables(loader.data); if(vars.response == ‘ERROR’) { trace(“An Error occurred, response not loaded”); }else {

105

trace(“Server Response: “ + vars.response); } }

Este controlador es muy similar a los ejemplos anteriores, con la excepción de que la variable de respuesta se ha dado una definición sin tipo. Esto permite que varios tipos de datos que se almacenen en ella, como una cadena para un error y un objeto para la respuesta esperada.

NOTA Tenga cuidado al establecer una variable como untyped (sin tipo). Esto elimina la comprobación de errores y hace que sea difícil saber lo que contiene una variable.

Cargar XML en Flash

Es más que probable que usted se encontrará trabajando con gran cantidad de datos. Lo ideal sería que esta información será devuelto en formato XML. XML es un estándar de la industria, después de empezar a trabajar con él rápidamente entender por qué. Se basa en las etiquetas para definir los objetos de datos, similar a una matriz multidimensional. El promotor se le permite definir etiquetas personalizadas, con tanta facilidad la construcción de un estilo de XML es muy útil sin dolor.

Usar E4X con XML

Una importante actualización a ActionScript 3 es la capacidad para analizar XML utilizando E4X. Esto nos permite obtener rápidamente los datos ocultos en lo profundo de un archivo XML con el código y mucho menos de lo necesario en las versiones anteriores.

Por ejemplo, usted puede comenzar con un archivo XML como este:

<store> <item> <name>Book</name> <section>Learning</section> <price>19.95</price> <inStock>yes</inStock> </item> <item> <name>Football</name> <section>Sports</section> <price>4.99</price> <inStock>no</inStock> </item> <item> <name>Bike</name> <section>Sports</section> <price>89.95</price> <inStock>yes</inStock> </item> <item> <name>Basketball</name> <section>Sports</section> <price>8.95</price> <inStock>no</inStock>

106

</item> <item> <name>Magazine</name> <section>Periodicals</section> <price>5.95</price> <inStock>yes</inStock> </item> </store>

Ahora quieres cargar este archivo y mostrar sólo los artículos que están en stock. Uso E4X Esta será una tarea muy sencilla.

Usted puede comenzar con la secuencia de carga estándar que se ha visto en ejemplos anteriores. El camino hacia el archivo XML que queremos cargar en este ejemplo es “storeItems.xml”.

var xmlFile:String = “storeItems.xml”; loadXML(); function loadXML():void { var urlRequest:URLRequest = new URLRequest(xmlFile); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, xmlHandler); urlLoader.load(urlRequest); }

Después de que el archivo XML se cargue completamente la función de xmlHandler se llama. Esta función está en el archivo XML que se lee y el punto donde se utiliza E4X.

Esta función es un poco más avanzada que la que hemos visto en los ejemplos de código anteriores, de modo que la función se divide en piezas más manejables.

function xmlHandler(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data); // Loop through all items, ONLY show items in stock for each(var item in xml..item) { if(String(item..inStock) == ‘yes’) { trace(“Product: “ + item.name); trace(“\tSection: “ + item.section); trace(“\tPrice: “ + item.price); } } }

El primer paso en esta función es tomar los datos cargados y pasar a la clase XML, que asegura que usted va a trabajar con objetos XML válido en las siguientes secciones.

var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

107

Un for..each se utiliza en cada bucle para caminar por el archivo XML y buscar elementos que están en stock. Este bucle también tiene un operador especial .. "Descendiente de acceso", que está buscando para cada elemento en el objeto XML. El "descendiente de acceso" se introdujo en ActionScript 3 para acceder a los descendientes o hijos y los hijos en los niños. Esto se hace utilizando dos operadores en la sucesión de puntos (..) seguido por el nombre del elemento descendiente.

for each(var item in xml..item) { ... }

Este es un avance enorme de ActionScript 2, donde se establecería bucles anidados y atravesar todo el documento XML. Sin embargo, una cosa para notar es que el descendiente de acceso es sensible a mayúsculas por lo que es mejor utilizar una convención de nomenclatura coherente.

<items> <item> <objectName>Example</objectName> </item> </items>

La convención de nombres más comunes para los nombres de nodo cuando se trabaja con XML es camel-caso. Camel-case está comenzando la primera palabra con un carácter en minúscula y luego la primera letra de cada palabra en mayúscula.

firstSecondThird

Ahora que el general for..each para cada bucle define el siguiente paso añadir en la verificación real de los artículos instock. Esto se logra mediante la creación de una sentencia condicional para ir dentro del bucle.

var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data); for each(var item in xml..item) { if(String(item..inStock) == ‘yes’) { trace(“Product: “ + item.name); trace(“\tSection: “ + item.section); trace(“\tPrice: “ + item.price); } }

Esta parte se ve en cada elemento en el circuito, y utilizando el descendiente de acceso, busca la variable de instock. La variable instock bien se establecerá en sí o no, si la variable se establece en sí, entonces simplemente imprimir los datos del artículo. En un ejemplo más avanzado de estos datos lo más probable es que se pasa a una función de visualización o, posiblemente, un componente DataGrid.

Eso es todo lo que hay que buscar rápidamente a través de un archivo XML y la comprobación de los valores específicos del nodo.Puede ampliar este ejemplo para buscar múltiples tipos y utilizar los resultados para construir una mini-tienda que sólo debe mostrar los elementos que están en stock.

108

NOTA Al trabajar con XML es una buena idea mantener un formato coherente. Esto le permite trabajar con varios archivos sin tener que reconstruir la lógica del programa en general. También es una buena idea para que pueda trabajar con otros desarrolladores en el mismo proyecto.

Trabajar con XML en PHP

En la siguiente sección usted aprenderá cómo cargar y administrar los datos XML utilizando PHP. Esto le permitirá desarrollar aplicaciones de forma más dinámica.

Carga de XML

El proceso de cargar el código XML en PHP se puede lograr en un par de maneras diferentes. Usted puede tomar rápidamente un vistazo a usar PHP para cargar XML porque este proceso es bastante sencillo. A continuación, buscar la forma de crear dinámicamente y enviar datos XML. Este proceso se puede lograr en un par de maneras diferentes.

Old-fashioned Dom XML

Dom XML es la vieja manera de trabajar con XML. En cierto modo es muy similar a trabajar con XML en versiones anteriores de ActionScript. Usted necesita utilizar una serie de bucles para encontrar los nodos, y esto simplemente requiere un código mucho más de lo necesario.

<?php $doc = domxml_open_file(‘sample.xml’); $node = $doc->document_element()->first_child(); while($node) { if(($node->node_name() == ‘sampleNode’) && ($node->node_type() == XML_ELEMENT_NODE)) { $content = $node->first_child(); print $content->node_value(); break; }$node = $node->next_sibling(); }?>

NOTA El código domxml requiere PHP 4.3, o bien debe tener PECL instalado por separado. Usted puede encontrar más información en el sitio Web de PHP (http://us.php.net/manual/en/ref.domxml.php).

El anterior ejemplo, se carga en el archivo XML y el uso de Dom XML analiza a través de ella para encontrar el sampleNode. Trabajo en el bucle, que busca el nodo seleccionado, y cuando ese nodo se encuentra imprimir el contenido en la pantalla. No es un ejemplo muy elaborado, pero muestra el proceso general que se encuentra en un ejemplo más avanzado.

109

Simple XML

Trabajar con XML sencillo rápidamente muestra lo fácil que se puede cargar el código XML. Este bloque de código es lograr el mismo resultado que antes, pero con muchas menos líneas de código. Dos líneas de código en lugar de 13 es una mejora considerable.

<?php $xml = simplexml_load_file(‘sample.xml’); print $xml->sampleNode;?>

Envío de XML

El proceso de envío de XML de PHP en Flash se explica en la sección siguiente. En general, el código para esto es muy similar a la carga de XML.

Imprimir dinamicamente XML

A menudo tendrá que trabajar con XML dinámico. Normalmente, cuando se trata de una base de datos se convierte en una práctica mucho más común. El proceso de creación de XML dinámico es muy simple: Se establece el tipo correcto de encabezado de

archivo e imprimir el XML primas. El siguiente bloque de código es un ejemplo de cómo alcanzar esto.

<?php header(“content-type: text/xml”); $xmlData = “”; $xmlData .= “<store>\n”; $xmlData .= “ <item>\n”; $xmlData .= “ <name>Book</name>\n”; $xmlData .= “ <section>Learning</section>\n”; $xmlData .= “ <price>19.95</price>\n”; $xmlData .= “ <inStock>yes</inStock>\n”; $xmlData .= “ </item>\n”; $xmlData .= “ <item>\n”; $xmlData .= “ <name>Football</name>\n”; $xmlData .= “ <section>Sports</section>\n”; $xmlData .= “ <price>4.99</price>\n”; $xmlData .= “ <inStock>no</inStock>\n”; $xmlData .= “ </item>\n”; $xmlData .= “ <item>\n”; $xmlData .= “ <name>Bike</name>\n”; $xmlData .= “ <section>Sports</section>\n”; $xmlData .= “ <price>89.95</price>\n”; $xmlData .= “ <inStock>yes</inStock>\n”; $xmlData .= “ </item>\n”; // add more ‘item’s here $xmlData .= “</store>\n”; print “response=” . $xmlData; ?>

La línea de la magia en este ejemplo sería la función de impresión que envía el XML en el búfer de salida y, finalmente, pasa a lo largo de Flash. Como puede ver, este es un ejemplo bastante simple.

110

Dinamica de XML desde la base de datos

Supongamos que quiere crear el XML de una llamada de base de datos MySQL. Una base de datos es un enfoque más común al desarrollar una aplicación, porque los datos es a menudo dinámico. Imprime estática en el caso no sería muy fácil de mantener. Aquí está el código, que se desglosan y se ha ido a través de.

<?php header(“content-type: text/xml”); $query = “SELECT * FROM store WHERE inStock=yes”; $link = mysql_connect(“localhost”, “user”, “pass”); $result = mysql_query($query, $link); $xmlData = “”; $xmlData .= “<store>\n”; while($row = mysql_fetch_array($result)) { $xmlData .= “ <item>\n”; $xmlData .= “ <name>” . $row[‘name’] . “</name>\n”; $xmlData .= “ <section>” . $row[‘section’] . “</section>\n”; $xmlData .= “ <price>” . $row[‘price’] . “</price>\n”; $xmlData .= “ <inStock>” . $row[‘inStock’] . “</inStock>\n”; $xmlData .= “ </item>\n”; }$xmlData .= “</store>\n”; print “response=” . $xmlData; ?>

Usted miró a cargar el contenido de una base de datos en el capítulo 2, y en su mayor parte es el mismo proceso. En realidad, la única diferencia se encuentra dentro del bucle while. Este es el punto en el que construir la estructura de árbol XML y, finalmente, la impresión de la respuesta de vuelta a Flash.

Ahí lo tienen formas múltiples para enviar y cargar datos XML en PHP y Flash. Usted puede tomar estos ejemplos sencillos y construir aplicaciones completas. De hecho, usted será sobre la base de este ejemplo en el capítulo 11 para el ejercicio de la Mini cesta de compras.

Cargar imagenes usando PHP

ActionScript puede cargar mucho más que simple texto y archivos XML. Un concepto más avanzado es cargar las imágenes, pero usted tendrá que un paso más y las imágenes de carga determinada por un archivo PHP.

Cargue el archivo de arranque que se puede encontrar en los libros de sitio Web. Este archivo tiene un UILoader y un TileList vertical para mantener las imágenes, como se muestra en la Figura 4.1. El contenido de este archivo no son particularmente importantes para este ejemplo, pero usted puede experimentar con otros componentes para construir aplicaciones más avanzadas.

111

FIGURE 4.1 Mostrando la solicitud completa con imágenes cargadas

Configurar cargador de la imagen

El primer paso para construir el cargador de la imagen es la construcción de la parte de ActionScript de la solicitud, que se muestra aquí. El siguiente código asume que el thumbSP ScrollPane ya se encuentra en la etapa.

var xmlFile:String = “http://localhost/ch03/loadImages.php”; var imageDir:String = “images/”; function callServer(e:MouseEvent):void { var urlRequest:URLRequest = new URLRequest(xmlFile); var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, xmlLoaded); loader.load(urlRequest); }function xmlLoaded(e:Event):void { var loader:URLLoader = URLLoader(e.target); var xml:XML = new XML(loader.data); var thumbContainer:TileList = thumbSP; thumbContainer.removeAll();

112

thumbContainer.sourceFunction = sourceHandler; thumbContainer.addEventListener(Event.CHANGE, loadMainImage); for each(var item:XML in xml..product) { var smImage:String = item.smImage.toString(); var lgImage:String = item.lgImage.toString(); thumbContainer.addItem({source:{sm:smImage, lg:lgImage}}); } }function sourceHandler(item:Object):String { return imageDir + item.source.sm; }function loadMainImage(e:Event):void { imageUI.source = imageDir + e.target.selectedItem.source.lg; }callBtn.addEventListener(MouseEvent.CLICK, callServer);

Este ejemplo tiene un código exclusivamente para trabajar con los componentes, que no es necesario para entender en este punto. Sin embargo, la función de cargador de xmlLoaded es el foco. El primero, xmlLoaded, se utiliza para caminar por el archivo XML cargado y las imágenes en miniatura en el componente TileList.

Notará que el XML uso E4X para encontrar los nodos de la imagen. Este ejemplo asume que los nodos a ser llamado producto, que es donde la imagen de las fuentes pequeñas y grandes se pueden encontrar.

Se utiliza el método addItem para pasar en un objeto que contiene la imagen de las fuentes pequeñas y grandes. Esto ahorra tiempo al escribir la lógica de hacer clic en una miniatura. Los incendios TileList fuera un evento de cambio cuando se hace clic en un tema. Esto se utiliza para conectar el controlador, que carga la imagen grande.

thumbContainer.addEventListener(Event.CHANGE, loadMainImage); function loadMainImage(e:Event):void { imageUI.source = imageDir + e.target.selectedItem.source.lg; }

El controlador de sourceFunction se utiliza para agregar en la ruta de acceso a las imágenes. Esta función se llama cada vez que un elemento se agrega a la TileList.

thumbContainer.sourceFunction = sourceHandler; function sourceHandler(item:Object):String { return imageDir + item.source.sm; }

113

Resumen

En este capítulo usted aprendió cómo enviar y cargar datos usando PHP y Flash que luego se amplió a este mediante el envío y carga de datos XML, que le ha permitido desarrollar una aplicación más dinámica .

Ahora debe tener un buen entendimiento de cómo trabajar con datos en Flash y PHP. También aprendió algunas de las razones diferentes por las cuales usted debe usar una forma específica de datos en la aplicación.

114

Capitulo 5Interactuar con el Usuario

La aplicación muchas veces tienen algún nivel de interacción con el usuario final para enriquecer la experiencia de aplicación general. Esto es más común de un contacto o algún otro tipo de formulario, que permite que el dueño del sitio, para permitir la comunicación sin dar una dirección de correo electrónico o que requieren que el usuario tenga un cliente de correo electrónico. Otra forma que usted encontraría en una aplicación es una forma de acceso, que le permite limitar el acceso a determinados aspectos o partes de su aplicación.

En este capítulo se explicará el proceso de construcción de formulario en Flash y cómo hacerlas interactivas usando PHP. También obtendrá una visión general de envío de datos mediante Flash, sin embargo, te recomiendo leer el capítulo 4 para entender completamente el proceso de envío y carga de datos.

Desarrollo de un Formulario usando Flash

Los formularios generalmente consisten en cuadros de entrada, botones, cuadros de lista y botones de radio, como se muestra en la Figura 5.1. Cada uno de estos elementos está disponible como un componente de Flash. Puedes acceder al panel de componentes eligiendo Window Componentes. Usando uno de estos componentes precompilados es tan simple como hacer clic y arrastrándolo a una capa en el documento de Flash.

FIGURA 5.1 Ejemplo de formulario construido usando los componentes por defecto que vienen con Flash

NOTA Si el componente no aparece en el escenario, garantizar la capa no muestra un icono de llave en la lista de capas.

Si ejecutó esta película Flash, se verían algunos componentes frescos en el escenario, pero no serían funcionales. El proceso de su utilización es muy sencilla. Se asigna un nombre de instancia del componente y el nombre de referencia en el código ActionScript.

115

Por ejemplo, si usted tenía un TextInput y quería que cebado, debe agregar el siguiente:

textInstance.text = “please enter your name”;

Tan útil como el código es, también debe capturar la entrada del usuario. Esto se logra mediante la adición de un componente de botón Enviar al escenario.

userName.text = “please enter your name”; submitBtn.addEventListener(MouseEvent.CLICK, submitHandler); function submitHandler(e:MouseEvent):void { trace(“User input: “ + userName.text); }

Puede ampliar este ejemplo para añadir la comprobación de errores y hacer cumplir los campos obligatorios:

function submitHandler(e:MouseEvent):void { if(userName.text.length == 0) { trace(“Please enter a name!”); } }

Muy a menudo, usted querrá obtener información de un visor de su sitio. Esto se logra mediante la adición de un formulario de contacto, que generalmente consta de un formulario de Flash que las conversaciones en un archivo PHP.

Creación de un formulario de contacto

Para esta sección, usted va a utilizar el archivo de inicio que se incluye en el sitio Web del libro. Este archivo tiene todos los componentes situados en el MovieClip contactMC ya en el escenario y se le ha asignado los nombres de instancia que va a utilizar en el código ActionScript.

Aquí está el ActionScript completo del formulario de contacto:

var phpFile:String = “http://localhost/ch04/contact.php”; var form:MovieClip = contactMC; function sendMessage(e:MouseEvent):void { // first check the fields var nameStr:String = form.nameTxt.text; var subjectStr:String = form.subjectTxt.text; var messageStr:String = form.msgTxt.text; var allFields:Boolean = true; // check name if(nameStr.length < 2) { allFields = false; }

116

// check subject if(subjectStr.length < 2) { allFields = false; }// check message if(messageStr.length < 2) { allFields = false; }if(!allFields) { trace(“All required fields not filled in!”); form.statusTxt.htmlText = “<font color=\”#FF0000\”>”+ “All required fields not filled in!</font>”; return; }var variables:URLVariables = new URLVariables(); variables.name = nameStr; variables.subject = subjectStr; variables.msg = messageStr; var urlRequest:URLRequest = new URLRequest(phpFile); urlRequest.method = URLRequestMethod.POST; urlRequest.data = variables; var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, sendHandler); loader.load(urlRequest); }function sendHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); if(variables.resultCode == “SENT”) { // message sent form.statusTxt.htmlText = “<font color=\”#009933\”>Email”+ “ sent, thank you.</font>”; }else if(variables.resultCode == “ERROR”) { // message not sent form.statusTxt.htmlText = “<font color=\”#FF0000\”>Email”+ “ not sent, please try again.</font>”; }else { // unknown response form.statusTxt.htmlText = “<font color=\”#FF0000\”>Unknown” + “ ERROR</font>”; } }form.sendBtn.addEventListener(MouseEvent.CLICK, sendMessage);

117

El enfoque de esta sección estará en las funciones sendMessage y sendHandler. La función sendMessage asigna las variables que se pasan a la PHP, crea instancias de las clases necesarias, y establece el caso de oyentes (event listeners).

function sendMessage(e:MouseEvent):void { ... var variables:URLVariables = new URLVariables(); variables.name = nameStr; variables.subject = subjectStr; variables.msg = messageStr; var urlRequest:URLRequest = new URLRequest(phpFile); urlRequest.method = URLRequestMethod.POST; urlRequest.data = variables; var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, sendHandler); loader.load(urlRequest); }

CROSS--REF Parte del código en la sección anterior se explica en mayor detalle en el capítulo 4.

LLamar el PHP

La llamada a la PHP se divide en tres clases: la clase URLVariables, URLRequest y URLLoader, los trabajos de los cuales son la creación de un contenedor para los datos del formulario de contacto, hacer un objeto de solicitud y, finalmente, llamar al archivo PHP.

Las clase URLVariables tiendas de los datos de contacto del formulario en un formato de objeto nombre.valor, que luego se adjunta a la propiedad de los datos de la URLRequest.

El URLRequest establece un método de petición mediante la propiedad POST estático de la clase URLRequestMethod, que indica a Flash si desea enviar los datos en formato GET o POST.

GET envía los datos a cabo adjunta al final de la URL:

file.php?var1=value1&var2=value2

POST envía los datos en la solicitud, que en la mayoría de los casos es más seguro.

La última clase utilizado en este formulario de contacto es URLLoader. Esta clase añade el detector de eventos que se llama cuando el PHP se ha cargado completamente y cualquier respuesta que se espera ha sido devuelto. Esta clase también hace una llamada a la método load(), pasando por una referencia a la URLRequest. En última instancia, hace la llamada al PHP y pasa a lo largo de las variables de formulario de contacto que ha asignado. Eso es todo lo que se necesita para configurar y realizar la llamada al PHP.

118

Controladores de evento en formulario de contacto

El siguiente paso en el proceso es establecer el controlador de eventos que se llama cuando el PHP envía una respuesta.

function sendHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); if(variables.resultCode == “SENT”) { form.statusTxt.htmlText = “<font color=\”#009933\”>Email”+ “ sent, thank you.</font>”; }

else if(variables.resultCode == “ERROR”) { form.statusTxt.htmlText = “<font color=\”#FF0000\”>Email”+ “ not sent, please try again.</font>”; }else { form.statusTxt.htmlText = “<font color=\”#FF0000\”>Unknown” +” ERROR</font>”; } }

Usted notará rápidamente que la clase URLLoader se utiliza de nuevo, pero esta vez para obtener la respuesta de PHP. Este se coloca en la clase URLVariables para sacar el resultado de la respuesta global. El PHP está configurada para simplemente responder con un mensaje SENT (enviado) o respuesta de error (ERROR response), sin embargo, también usar una instrucción más para atrapar cualquier respuestas desconocidas, algunos de los cuales podrían incluir errores de red o de simples errores de análisis en el código PHP.

Un componente Label se encuentra en el formulario de contacto MovieClip, que es donde la respuesta se envía al usuario a ver. En una escritura más avanzado que volvería más probable es que una serie de resultados y dejar el texto de respuesta en el Flash, lo que permitiría la capacidad de adaptar las respuestas a determinados idiomas, también llamada localización.

Con la creación de ActionScript, puede pasar al código de PHP:

<?php error_reporting(0); // disable all error reporting set_time_limit(120); // let script run for no more than 2 minutes

$emailTo = “[email protected]”;

$name = $_POST[‘name’]; $from = $_POST[‘fromEmail’]; $subject = $_POST[‘subject’]; $msg = $_POST[‘msg’];

if(!empty($_POST))

119

{ $headers = “”; $headers .= “”; $date = date(“F j, Y”, time()); // Grab todays date $email_info .= “Below is the visitors contact info and message.\n\n”; $email_info .= “Visitor’s Info:\n”; $email_info .= “-----------------------------------------\n”; $email_info .= “Name: “ . $from . “\n”; $email_info .= “Date Sent: “ . $date . “\n\n”; $email_info .= “Message\n”; $email_info .= “-----------------------------------------\n”; $email_info .= “” . $msg . “\n”; // Mail headers, do not alter $mailheaders = “From: “ . $from . “ <” . $name . “> \n”; $mailheaders .= “Reply-To: “ . $from . “\n\n”;

if(mail($emailTo, $subject, $email_info, $mailheaders)) { print “resultCode=SENT”; }else { print “resultCode=ERROR”; } }?>

Correo en PHP

La mayor parte de este PHP es similar a lo que han estado trabajando en las secciones anteriores, con algunas excepciones, por supuesto. La excepción más notable es la introducción de la función mail(), que tiene una serie de argumentos:

mail($to, $subject, $emailBodyInfo, $emailHeaders);

Los dos primeros son el correo electrónico para enviar y de asunto del correo electrónico, que es bastante estándar. Los dos últimos son los más importantes: $emailBodyInfo contiene el contenido de su e-mail, y $emailHeaders define el archivo como un e-mail. Esta variable contiene la información de enrutamiento, la respuesta a, y todos los otros variablese-mail specifican que un servidor de correo busca.

Globales

Asigna variables para contener los datos en el pasado de Flash, que se realiza mediante el global $_POST datos de matriz. Globales en PHP manejar la información general de los terrenos y los valores que cualquier secuencia de comandos tiene acceso. Usted va más razones por las globales puede ser el enfoque equivocado en el capítulo de seguridad.

Volviendo a tu programa de correo electrónico, el uso de la variable de los datos globales $_POST para acceder a las variables pasadas desde Flash.

120

$emailTo = “[email protected]”; $name = $_POST[‘name’]; $from = $_POST[‘fromEmail’]; $subject = $_POST[‘subject’]; $msg = $_POST[‘msg’];

Eso es todo el código que se necesita para desarrollar un formulario de contacto completamente funcional usando Flash y PHP.

Usted puede ampliar en este ejemplo y dar al formulario de contacto mucha más funcionalidad. Algunas cosas para pensar en añadir sería un proceso de validación más robusta, más campos de formulario, y las respuestas, posiblemente, más informativo para el usuario.

Mantener la seguridad en mente

Un elemento muy importante tener en cuenta acerca de este ejemplo formulario de contacto es el código no honra los procedimientos de seguridad y de hecho permite al usuario pasar los datos a PHP. Un ejemplo más sólido y directo exigiría un nivel mucho más fuerte de la seguridad, sin embargo, para fines de demostración general de seguridad ha quedado fuera.

Módulo de Login en Flash

Más a menudo que no se quiere tener una parte segura de un sitio Web. Un ejemplo muy popular de esto sería una sección de repaso para un fotógrafo, cuando un cliente puede ingresar y ver las fotos.

La porción del formulario de esta aplicación es casi idéntica al formulario de contacto. Se necesita un nombre cuadro de usuario y de Contraseña y un botón Enviar a fuego fuera de la rutina de controlador de inicio de sesión.

Aquí hay un diseño de muestra que se puede encontrar en el archivo de partida, o usted puede crear a partir de cero.

Los nombres de instancia para este ejemplo se muestran en la Tabla 5.1.

TABLA 5.1 Componentes de Formulario para el modulo de Login

usernameTxt Nombre de usuario para iniciar sesión passwordTxt Password to be attempted resetBtn Boton de reinicio, limpiar los campos loginBtn Boton de inicio de sesion, encender el loginHandler

Ahora que tiene el formulario visual completo, puede pasar al ActionScript, lo que hace que el formulario sea funcional.

Código esqueleto

En los ejemplos anteriores, usted miró todo el código en una sección larga, pero a veces puede ser abrumadora. En cuanto a la estructura de código ofrece una manera rápida de evaluar las variables de programa, las funciones, y otros elementos.

121

Aquí está el esqueleto de código para el módulo de Login (inicio de sesión):

stop(); // stop the playhead

var phpFile:String = “http://localhost/ch04/login.php”; var form:MovieClip = loginMC; var loggedIn:Boolean = false;

function loginHandler(e:MouseEvent):void {...} function resetHandler(e:MouseEvent):void {...} function clearIndicators():void {...} function sendHandler(e:Event):void {...}

form.usernameTxt.tabIndex = 1; form.passwordTxt.tabIndex = 2; form.resetBtn.tabIndex = 3; form.loginBtn.tabIndex = 4;

form.passwordTxt.displayAsPassword = true; form.resetBtn.addEventListener(MouseEvent.CLICK, resetHandler); form.loginBtn.addEventListener(MouseEvent.CLICK, loginHandler);

Controladores de eventos en Login

Similar al ejemplo de formulario de contacto, es necesario asignar los controladores de eventos que manejan la información de acceso, la compensación, y los cambios de interfaz de usuario para el módulo de inicio de sesión (login).

El primer controlador de eventos es loginHandler, que es responsable de llamar al servidor de datos y garantizar la validez se pasa al servidor. Su última tarea es asignar el controlador para el evento resultado.

function loginHandler(e:MouseEvent):void { clearIndicators();

var user:String = form.usernameTxt.text; var pass:String = form.passwordTxt.text; var allFields:Boolean = true;

if(user.length < 2) { allFields = false; form.userRequiredIndicator.alpha = 1.0; }

if(pass.length < 2) { allFields = false; form.passRequiredIndicator.alpha = 1.0; }

122

if(!allFields) { form.statusTxt.htmlText= “<font color=\”#FF0000\”>Username” + “ and Password required!</font>”; return; }

var variables:URLVariables = new URLVariables(); variables.user = user; variables.pass = pass;

var urlRequest:URLRequest = new URLRequest(phpFile); urlRequest.method = URLRequestMethod.POST; urlRequest.data = variables;

var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, sendHandler); loader.load(urlRequest); }

Este controlador comienza por asignar el nombre de usuario y contraseña para campos variables internas. Estas nuevas variables, luego se comprueba la longitud válido, que si se establece correctamente la variable allFields. Esta variable allFields se utiliza para determinar si el mensaje de error se debe mostrar y la función se debe abandonar el mismo. Si allFields no se establece que puede continuar la creación de la llamada al servidor. Esta parte es idéntico al ejemplo de formulario de contacto. De hecho, pronto se dará cuenta de que ActionScript tiene un formato muy similar para todos los tipos de carga y el envío de datos.

El siguiente controlador se centrará en clearHandler, es la que se asigna al resetBtn.Su trabajo consiste en borrar todos los campos del formulario y hacer una llamada a la función clearIndicators, que se verá en un momento.

function resetHandler(e:MouseEvent):void { form.usernameTxt.text = “”; form.passwordTxt.text = “”; form.statusTxt.htmlText = “”; clearIndicators(); }

La función clearIndicators cambia la opacidad alfa de los iconos que se pueden encontrar a la derecha de los componentes de TextInput nombre de usuario y contraseña en el archivo de arranque. Si está creando este módulo desde el principio lo más probable es omitir esta función y la llamada a ella en el resetHandler.

function clearIndicators():void { form.userRequiredIndicator.alpha = 0; form.passRequiredIndicator.alpha = 0; }

El último controlador necesario para este módulo es el sendHandler, que se llama cuando el código PHP envía una respuesta.

123

function sendHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); if(variables.resultCode == “LOGGED_IN”) { loggedIn = true; gotoAndStop(2); }else if(variables.resultCode == “NOT_LOGGED_IN”) { form.statusTxt.htmlText = “<font color=\”#FF0000\”>”+ “Username/Password not correct.</font>”; } }

La respuesta que pasa de PHP es evaluada para determinar si el usuario es válido y si o no a la página segura debe mostrarse.

if(variables.resultCode == “LOGGED_IN”) { loggedIn = true; // user logged in, gotoAndStop(2); // sample has secure page on frame 2 }else if(variables.resultCode == “NOT_LOGGED_IN”) { form.statusTxt.htmlText = “<font color=\”#FF0000\”>”+ “Username/Password not correct.</font>”; }

Suponiendo que el usuario está conectado, usted establece una variable de loggedIn y pasar al segundo cuadro, que en el ejemplo de arriba es una sección secreta, como se muestra en la Figura 5.2. Su ejemplo más probable es que tenga una razón más importante para estar conectado, pero tal vez no.

124

FIGURA 5.2 Ejemplo de página segura que sólo es visible si el usuario se registra

Integración del Servidor para el modulo de login

El código PHP para el módulo de conexión es la siguiente parte en el proceso.

<?php error_reporting(0); // deshabilitar todos los reports de error $user = $_POST[‘user’]; $pass = $_POST[‘pass’]; // ejemplo de respuesta de contraseña, normalmente // se envia desde la base de datos $storedPassword = “83e4a96aed96436c621b9809e258b309”; if(!empty($_POST)) { if($user == “guest” && md5($pass) == $storedPassword) { print “resultCode=LOGGED_IN”; }else { print “resultCode=NOT_LOGGED_IN”; } }?>

Su enfoque en esta sección está en los datos de $_POST y comprobar condicional para determinar si la contraseña es correcta o no. Este resultado se envía de regreso a Flash en el que se utiliza para establecer registrado en el estado y todo lo que un usuario válido a ver.

125

Un ejemplo más sólido tendría el PHP se evaluará en una base de datos en lugar de una cuerda estática. La variable $storedPassword tiene una cadena md5() de hash. MD5 es un algoritmo de hash que está disponible en muchos lenguajes de programación, uno de los cuales es PHP y es más frecuente al almacenar contraseñas en una base de datos. Usted va a mirar MD5 un poco más en profundidad en el capítulo de seguridad, pero por ahora lo más importante a destacar es que la cadena de hash es su contraseña.

Ahora dispone de un módulo de inicio de sesión completo utilizando Flash y PHP. Desde aquí se puede ampliar este ejemplo para incluir la integración de bases de datos y más importante, un nivel adicional de seguridad.

Resumen

En este capítulo usted aprendió cómo construir formulario en Flash y cómo hacerlas interactivas usando PHP. Como un proyecto más avanzado que creó entonces un componente de inicio de sesión utilizando la información anterior, aprendió acerca del desarrollo de forma global.

126

Capitulo 6Trabajar con Cookies

Las cookies son muy comunes en la navegación Web. De hecho, usted sería muy difícil de navegar la Internet en la forma en que estamos acostumbrados a las cookies, si dejó de funcionar. Este capítulo es cómo trabajar con las cookies de Flash y PHP. Cubre la carga y el envío de cookies y se investiga cómo se elimina una cookie.

La segunda mitad del capítulo es acerca de compartir los objetos, que son las cookies de Flash. Actúan casi lo mismo que las cookies del navegador estándar con algunas diferencias, que se investigue.

Una vez que haya completado este capítulo, entenderemos completamente la forma de trabajar con las cookies y por qué son importantes para una aplicación exitosa y la experiencia del usuario.

Cargar Cookies

Una cookie es un archivo pequeño colocado en el ordenador del usuario por un servidor Web. Este archivo se envía de nuevo al servidor sin cambios cada vez que el usuario accede al servidor. Mayoría de las veces una cookie contendrá el nombre de usuario para un sitio Web. Una cookie también puede ser utilizado para guardar la configuración del usuario y de los demás pequeños de la información.

El proceso de carga de las cookies se explica en varias piezas para comprender mejor cómo funcionan. Usted notará que el proceso de carga "cookies" es muy similar a la carga de otros tipos de datos.

Uso de cookies con PHP

El uso de cookies con PHP es necesario para desarrollar una aplicación web usable. Usted encontrará muchas

oportunidades para aplicar las cookies de sesión de usuario a los estilos y muchos otros usos.

Al empezar a trabajar con datos dinámicos más a menudo se desea guardar partes de la máquina del usuario. Hacer esto permite que el programa de registro de un usuario de forma automática o modificar un estilo basado en la configuración del usuario.

Las cookies se guardan por dominio y el directorio. Esto significa que cualquier página dentro del mismo dominio o ruta de acceso puede leer que "cookie". Esto es muy útil cuando se construyen múltiples ejemplos y también significa otro sitio Web no puede leer las cookies de un sitio diferente.

NOTA La solución común para el intercambio de cookies a través de un dominio es crear un subdominio.Una cookie es sólo específico para el dominio global y simplemente hace caso omiso de caminos, parámetros, y subdominios.

Cargar una cookie

Ahora que tiene una comprensión de lo que es una "cookie", echar un vistazo a cómo cargar y trabajar con uno en PHP: El código siguiente intenta cargar una "cookie" y mostrar la respuesta como se muestra en la Figura 6.1

127

<?php $username = “Jimmy”; if (!isset($_COOKIE[‘user’])) { setcookie(“user”, $username); print “Welcome “ . $username; }else { Print “Welcome back, “ . $_COOKIE[‘user’]; }?>

Los controles de código anterior de la existencia de la cookie "usuario" en la matriz mundial de las cookies. Si se encuentra la cookie, el usuario es recibido de nuevo. Si la cookie no se encuentra, la cookie y el usuario es recibido por primera vez.

La variable $_COOKIE es una matriz multidimensional que puede contener muchas cookies diferentes. Esta variable se llena automáticamente por PHP y no requiere que usted agregue a la misma.

FIGURA 6.1 La declaración de impresión como se muestra en la ventana del navegador

128

Guardar un cookie

Establecer o guardar una cookie en PHP es muy simple: usted hace una llamada a la función setcookie. El primer argumento es el nombre de la cookie, el segundo argumento es el valor de la cookie. Por ejemplo, supongamos que desea establecer una cookie time_logged_in.

setcookie(“time_logged_in”, time());

Cada vez que desee guardar una cookie puede llamar a la función setcookie. Si la cookie existe, se actualiza, y si no existe, se crea.

NOTA La capacidad para guardar una cookie depende de si un usuario permite o no cookies.

La función setcookie acepta más de dos argumentos, pero en realidad sólo se requiere que el primer argumento, que es el name (nombre).

Caducidad de un Cookie

Por defecto, una cookie expira cuando termina el período de sesiones o el usuario cierra el navegador. La forma en que la sesión termina, es por una cantidad de tiempo predefinido en el servidor. Por defecto, esta cantidad es 0 segundos porque la sesión se termina cuando el navegador se cierra. Normalmente, el desarrollador no necesita saber cuánto tiempo dura una sesión. Usted, por supuesto, estar más interesados en existe o no la cookie.

En ocasiones, usted querrá asegurarse de que una cookie se borra después de una cierta cantidad de tiempo. Este es el caso cuando se trabaja con datos de seguridad o un sistema de gestión de contenidos. Supongamos que usted quiere que la cookie expire poco después de creada la cookie.

setcookie(“username”, “adminDave”, (time() + 7200));

Esto le dice el navegador del usuario para eliminar la cookie de 2 horas después de crear la cookie. La fecha de caducidad de una cookie es en segundos, así que para este ejemplo, 7200 es de 2 horas. Otra forma de verlo es (60 * 60 * 2).

¿Alguna vez has abierto tu navegador, visita un sitio, y se introdujeron al contenido personalizado que se había solicitado en una sesión anterior? Estos datos se determinó mediante una cookie guardado en su equipo que no se eliminan cuando finaliza el período de sesiones.

Mira un ejemplo de una cookie que no expira durante tres meses.

<?php $secondsInDay = 86400; $daysBeforeExpiration = 90; setcookie(“userStylePref”, “blueTheme”, (time() + ($secondsInDay * $daysBeforeExpiration)); ?>

Se comienza con el número de segundos en un día—86400. Luego de configurar la variable $daysBeforeExpiration que es la celebración de días que desea que la "cookie" dure.

129

El último paso es establecer la cookie. Multiplique el segundo por el día, añadir a la función time(), y esto se convierte en su fecha de vencimiento.

Tres meses es sólo un ejemplo, puede establecer un cookie expire años más tarde. Sin embargo, los usuarios tienen una tendencia a limpiar su almacenamiento de navegador. Por lo tanto, nunca debe permitir que una aplicación se base en la existencia de una "cookie".

Eliminar una cookie

En algún momento de su aplicación, usted probablemente querrá eliminar una cookie. Sin embargo, el navegador de Internet locales que el usuario está en no permitir que un servidor Web directamente eliminar una cookie. En su lugar, establezca la fecha de caducidad tras la fecha actual y, básicamente, hacer que la cookie expire. Esto le indica al navegador Web para borrar la cookie, porque ya no está en uso.

setcookie(“time_logged_in”, “”, (time() - 300));

Asignar múltiples cookies

El proceso de asignación de cookies múltiples es bastante sencillo. Es, básicamente, hacer varias llamadas a la función setcookie para garantizar que cada cookie tienga un nombre único.

<?php $username = “jimmy”; $userID = 5; $loggedInTime = time(); setcookie(“username”, $username); setcookie(“userid”, $userID); setcookie(“logged_in_since”, $loggedInTime); ?>

El código anterior establece tres cookies haciendo tres llamadas a la función única setcookie.También puede realizar la llamada setcookie en una función personalizada si el código passed-in requiere más seguridad. Por ejemplo, puede crear una función saveCookie que garantice el dato está limpio

<?php

function saveCookie($name, $value, $expires=0) { if($name == “”) { print “Name not provided, cookie not saved”; }if($value == “”) { print “Value not provided, cookie not saved”; }setcookie($name , $value, $expires); }

$username = “jimmy”;

130

$userID = 5; $loggedInTime = time();

saveCookie(“username”, $username); saveCookie(“userid”, $userID); saveCookie(“logged_in_since”, $loggedInTime); ?>

Su función saveCookie se utiliza como proxy para la función setcookie precompilados. Esto le permite comprobar el pasado en los datos y asegurarse de que ha sido debidamente cumplimentado. En el ejemplo anterior, se imprime un error si el nombre o el valor está vacío. Usted puede aprovechar esta seguridad simple comprobar un paso más allá al asegurar que los datos es, de hecho, una cadena y no contiene ningún código potencialmente malicioso. Al empezar a desarrollar aplicaciones Web que va a aprender a seguir las normas rígidas en lo que se refiere a la seguridad.

Ahora que han visto cómo usar cookies en PHP, usted puede buscar en el uso de "cookies" en Flash. El proceso de usar las cookies en Flash es muy similar, pero ofrece algunas ventajas que usted va a mirar.

Uso de cookies en Flash

Las cookies de Flash en realidad se llaman objetos compartidos y compartimos atributos similares a las cookies en PHP.Algunos de estos atributos incluyen la capacidad de almacenar pequeñas cantidades de datos a nivel local y recuperarlos por cualquier archivo en el dominio básico. Al igual que las cookies en PHP, el usuario tiene la posibilidad de desactivarlas por sitio o el mundo. Sin embargo, tienen algunas diferencias. Una ventaja importante a los objetos compartidos es la capacidad de unirse a ellos. Esto significa varias películas tienen la capacidad de ver el expediente y recibir una alerta cuando se actualiza. Por ejemplo, supongamos que tiene un juego multijugador, y queremos que cada cliente para seguir la partitura en sincronía. Con los objetos compartidos puede permitir que cada uno de los clientes de lectura/escritura de acceso y los otros actualizarán los cambios de puntuación.

Cargar Objetos compartidos

El código siguiente intenta cargar un objeto compartido y crea uno si no existe. Como puede ver, cargar un objeto compartido es bastante simple y sólo requiere una línea de código. Cookies en PHP no ofrecen la posibilidad de crear uno de forma nativa, si no existe, hay que comprobar la cookie y crear manualmente.

var so:SharedObject = SharedObject.getLocal(“sample”); trace(“Object is “ + so.size + “ bytes in size”);

Guardar objetos compartidos

El proceso de guardar un objeto compartido es también sencillo. Comience por crear una nueva instancia de la clase SharedObject.

var so:SharedObject = SharedObject.getLocal(“sample”);

Después de que el objeto se crea, puede adjuntar los datos del objeto compartido para añadir elementos a los datos del objeto, como:

131

var so:SharedObject = SharedObject.getLocal(“sample”); so.data.user = “guest”;

Usted puede llamar y recordar que por encima de bloque de código y el valor no se guarda todavía. La razón es porque es necesario alertar a los objetos para escribirlo en el sistema de archivos local, llamando al método flush.

var so:SharedObject = SharedObject.getLocal(“sample”); so.data.user = “guest”; so.flush();

NOTA Al usar flush (), comprueba si el usuario tiene almacenamiento local deshabilitado mediante el Administrador de configuración (www.macromedia.com/support/documentation/en/flashplayer/help/settings_manager07.html).

Si el objeto no existe, se crea uno. En algunos casos, usted querrá saber si el objeto compartido existe. La manera de lograrlo es mediante el control de la propiedad de tamaño.

var so:SharedObject = SharedObject.getLocal(“sample”); if(so.size == 0) { // Shared object doesn’t exist. trace(“Shared Object doesn’t exist.”); }

Suponiendo que el tamaño de la prueba volvió igual a cero, usted sabrrá que el objeto compartido no existe.A continuación, puede tomar este resultado y sustituir la simple traza con el código para crear el objeto.

var so:SharedObject = SharedObject.getLocal(“sample”); if(so.size == 0) { // Shared object doesn’t exist. so.data.user = “guest”; }

Eliminar objeto compartido

A diferencia de PHP, los objetos compartidos de forma explícita se puede eliminar del sistema de almacenamiento local. Realizar una llamada al método clear() elimina el objeto compartido y sus datos, pero la referencia al objeto permanecerá.

var so:SharedObject = SharedObject.getLocal(“sample”); so.data.user = “guest”;

trace(“Username is: “ + so.data.user); // guest

so.clear();

trace(“Username is: “ + so.data.user); // undefined

132

http://www.macromedia.com/support/documentation/en/flashplayer/help/settings_manager07.html

El segundo trace devuelve indefinido debido a que la llamada anterior a clear() ha suprimido el valor.Ahora puede volver a asignar el valor. Sin embargo, no es necesario eliminar un objeto para reasignarlo. Usted simplemente puede volver a escribir a la misma.

Acercar a todos juntos

Ahora que usted ha mirado en cada concepto individual, llevar todo en un último ejemplo. En este ejemplo se va a crear, guardar, editar y borrar un objeto compartido.

Comience por abrir el archivo de partida que se pueden encontrar en el sitio Web del libro, que ha sido pre-compilados para este ejemplo.

Después de abrir el fichero en Flash, abra el panel de acciones (presionar la tecla F9 o Alt + F9) y añadir el código ActionScript.

var soDomain:String = “sample”; var so:SharedObject = null; function loadObject():void { so = SharedObject.getLocal(soDomain); trace(“Shared Object Loaded”); }

function addDataToObject(name:String, value:String):void { if(so == null) {

trace(“You must first load the Shared Object”); }

so.data[name] = value; so.flush();

trace(“Value added: “ + so.data[name]); }

function deleteObject():void { if(so == null) { trace(“You must first load the Shared Object”); }so.clear();

trace(“Shared Object deleted”); }

function readObject(name:String):void { if(so == null) {

133

trace(“You must first load the Shared Object”); }else { trace(“Shared Object Value : “ + so.data[name]); } }

function loadHandler(e:MouseEvent):void { loadObject(); }function saveHandler(e:MouseEvent):void { addDataToObject(‘test’, valueTxt.text); }function deleteHandler(e:MouseEvent):void { deleteObject(); }function readHandler(e:MouseEvent):void { readObject(‘test’); }

loadBtn.addEventListener(MouseEvent.CLICK, loadHandler); saveBtn.addEventListener(MouseEvent.CLICK, saveHandler); deleteBtn.addEventListener(MouseEvent.CLICK, deleteHandler); readBtn.addEventListener(MouseEvent.CLICK, readHandler);

Las partes más importantes de este código es addDataToObject y la función de dos variables que son referencias a los objetos compartidos: nombre de la propiedad y el valor a la tienda.

var soDomain:String = “sample”; var so:SharedObject = null;

function addDataToObject(name:String, value:String):void { ... }

La función addDataToObjectcomprueba para asegurarse de que el objeto compartido se ha cargado correctamente y los intentos de asignar el valor utilizando un objeto dinámico.

function addDataToObject(name:String, value:String):void { if(so == undefined) { trace(“You must first load the Shared Object”); }

so.data[name] = value;

134

so.flush(); }

Después de llamar la función addDataToObject, se puede leer en el objeto compartido simplemente haciendo un llamado a los datos del objeto.

trace(“Shared Object Data: “ + so.data.test);

Eso es todo lo que hay que trabajar con objetos compartidos en Flash. Ahora ya sabe cómo cargar, guardar y eliminar los objetos compartidos y las cookies de Flash.

NOTA Los objetos compartidos también se pueden utilizar en un entorno remoto, pero requieren un sistema más avanzado.

Descubrir los beneficios de cookies en PHP

Ahora que han estudiado el uso de cookies, tanto en PHP y Flash, veamos algunas razones por las que el uso de cookies en PHP es una mejor opción. Cuando se trabaja en Flash, parece que los objetos compartidos son la mejor opción, pero no siempre lo son.

Cookies en PHP ofrecen la posibilidad de compartirlos entre sitios HTML y Flash. Los objetos compartidos sólo son accesibles desde dentro de Flash, que pueden ser tanto buenos como malos. El lado bueno es que ninguna otra aplicación puede cambiar las cookies. En el lado malo, sino que también significa que no puede compartir y agregar un nivel de coherencia entre las aplicaciones.

Hay una solución bastante común a este problema, sin embargo, que es regular el uso de cookies en Flash, pasando a través de un intermediario de PHP.

En primer lugar, mirar el código PHP que hará llegar la información de la cookie de vuelta a Flash.

<?php

if(isset($_POST[‘act’]) && $_POST[‘act’] == ‘getcookie’) { if(isset($_COOKIE[$_POST[‘cookieName’]])) { print “resp=” . $_COOKIE[$_POST[‘cookieName’]]; }else { print “resp=” . “cookie_not_found”; } }

?>

Este código garantiza los datos POST adecuados se envíen antes de continuar. Suponiendo que los datos válidos se pasa, el siguiente paso es determinar si la cookie, de hecho, existe. Utilice una prueba condicional para determinar si los datos de la cookie o un mensaje de error será enviado a Flash.

if(isset($_COOKIE[$_POST[‘cookieName’]]))

135

{ print “resp=” . $_COOKIE[$_POST[‘cookieName’]]; }else { print “resp=” . “cookie_not_found”; }

De cualquier manera, la variable pasada a Flash "respectivamente". De esta manera usted puede programar fácilmente el código ActionScript para manejar la respuesta en consecuencia.

La razón por la que se utiliza isset() en el primer caso de declaración de PHP no es tan accidental puede enviar un aviso a Flash alertar a la variable no es enviado. Este tipo de aplicación es un muy buen candidato para XML, que se explica en profundidad en el capítulo 3. XML lo que hace es tan sólo devolver en el valor que usted está interesado. Para este ejemplo simple, se continuará con un retorno printbased estándar.

Ahora que tiene el PHP en su lugar se puede pasar al ActionScript. El ActionScript hace una llamada al PHP y espera una "cookie" o error que será devuelto.

var phpFile:String = “http://localhost/ch05/cookies/loadCookie.php”;

var variables:URLVariables = new URLVariables(); variables.act = ‘getcookie’; variables.cookieName = ‘sample’;

var urlRequest:URLRequest = new URLRequest(phpFile); urlRequest.method = URLRequestMethod.POST; urlRequest.data = variables;

var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, serverHandler); loader.load(urlRequest);

function serverHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); if(variables.resp == ‘cookie_not_found’) { trace(“Requested Cookie Not Found”); }else { trace(“Cookie Data: “ + variables.resp); } }

El total de la llamada al servidor es similar a otras llamadas en este libro. El enfoque en esta convocatoria es de las variables pasadas al PHP y la respuesta. Se utiliza la clase URLVariables para asignar el acto y las variables cookieName. La variable de actuar le dice a PHP que su petición es válida, y la variable cookieName contiene el nombre de la cookie que usted está buscando.

136

var variables:URLVariables = new URLVariables(); variables.act = ‘getcookie’; variables.cookieName = ‘sample’;

Al igual que los otros ejemplos cargador, tiene que asignar una función para manejar la respuesta del servidor.Esta es la función que se llama después de que el PHP pasa de nuevo bien la cookie o un mensaje de error.Comience usando la clase URLLoader para obtener los datos que figuran en la respuesta. A continuación, realizar una llamada a la clase URLVariables, que devuelve un objeto de las variables de respuesta. En este caso, se busca respectivamente la "propiedad". En primer lugar, compruebe si la respuesta es "cookie_not_found", que se explica por sí mismo. Es más que probable, la cookie que se establecerán y la segunda sentencia trace podría ser llamado, pero la programación nunca es bueno para asumir esto. Por eso se añade la sentencia condicional.

function serverHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); if(variables.resp == ‘cookie_not_found’) { trace(“Requested Cookie Not Found”); }else { trace(“Cookie Data: “ + variables.resp); } }

Usted puede tomar este ejemplo para el siguiente paso, estableciendo la cookie si uno no se encuentra, o incluso pasar a lo largo de una matriz o un objeto de los nombres de cookies para cargar rápidamente todas las cookies de un sitio. AMFPHP, que usted va a mirar en el capítulo 8, sería una gran manera de la carga en varias cookies.

Como usted puede ver, hay varias formas de trabajar con las cookies, tanto en PHP y Flash. Incluso desarrollar una forma común en la que tanto PHP y Flash pueden compartir la misma cookie de datos.

NOTA Intercambio de información de la cookie todavía tiene la limitación de que el PHP tiene que estar en el dominio que va a cargar las cookies. Una cosa a tener en cuenta con este script es el hecho de que este ejemplo simple no es el control de la entrada pasa a la de PHP. Seguramente querría añadir en a una aplicación real.

Resumen En este capítulo usted aprendió cómo cargar y trabajar con las cookies de Flash y PHP. Para iniciar aprendió a cargar un cookie existente de la máquina del usuario y luego aprendió a modificar y actualizar esa cookie.

Ahora debió entender cómo trabajar con las cookies de Flash y PHP y entender por qué son importantes cuando se desarrolla una aplicación.

137

Parte II

Desarrollo de Contenido Interactivo

138

Capitulo 7

Mantenimiento de Seguridad al

Trabajar con la entrada de Uuario

Trabajar con la entrada del usuario se centra en las mejores prácticas de almacenamiento y la devolución de datos mientras se mantiene un alto nivel de seguridad.

Este capítulo está dividido en secciones que se centran en un aspecto específico del manejo de los datos de usuario. Esto no es un paso guía basada en el trabajo con los datos del usuario, que puede encontrarse en el Capítulo 4. En su lugar, este capítulo se centra en los aspectos específicos de la seguridad al manejar los datos.

El subtema de este capítulo es trabajar con la comprensión y sandbox (caja de arena) en Flash. Básicamente, la caja de arena es un contenedor que cada aplicación se ejecuta en el, pero la sección entra en más detalle y proporciona ejemplos visuales para explicar mejor la caja de arena y cómo afecta a sus aplicaciones.

Las prácticas previstas en este capítulo se puede adaptar a las aplicaciones futuras que se desarrollan. El mantenimiento de una aplicación segura es casi tan importante como el bloqueo de la casa antes de salir. Una aplicación técnicamente seguirá funcionando si no está seguro. Sin embargo, la vida útil de que la aplicación no es cierto. Hay muchos aspectos de la seguridad en una aplicación: datos esterilizado, inicios de sesión seguros, almacenamiento de archivos, y la posibilidad de aprovechamiento, para nombrar unos pocos. En este capítulo, el foco es la seguridad de la entrada del usuario. La entrada del usuario es cualquier pedazo de datos, el usuario puede modificar.Esta lista incluye los datos de las cookies, los inicios de sesión, las sesiones y la carga de archivos.

Precaución con el uso de entrada de usuario

Los datos del usuario se expande más allá de un sencillo cuadro de texto en un formulario de contacto. Ahora que sabes qué datos se considera la entrada de usuario, te estás preguntando cómo algo tan inofensivo como un sistema de carga de archivos representa un riesgo para la seguridad.

Como con la mayoría de seguridad, no es la tecnología o característica que tiene fallos, pero cómo se implementa.

Forma adecuada de manejar carga de archivos 139

Por ejemplo, supongamos que hay un archivo PHP de base que acepta la carga de archivos y almacena la información de los archivos cargados en una base de datos.

La primera cuestión a plantearse es ¿qué partes de esta sencilla aplicación son posibles problemas de seguridad?

La forma en si? El componente de base de datos? El archive cargado?

Comprobar extensions de archivos válidos

El archivo subido sería el menos obvio de una violación de seguridad, pero mira en algún código de ejemplo que explica cómo se puede fácilmente convertirse en un problema. Una muy común, pero el intento de inducir a error a asegurar la carga de archivos proceso es comprobar que una prórroga válida, como la:

<?php $file = $_FILES[0]; if(strpos($file[‘name’], ‘.jpg’) !== false) { if(!move_uploaded_file($file[‘tmp_name’], ‘storage/’)) { print “File uploaded”; } }?>

Como puede ver, el código está configurado para buscar el archivo con extensión .jpg. La función strpos se utiliza para devolver el índice o la colocación del valor facturado, que en este ejemplo es .jpg. A primera vista esto parece bastante seguro y deben dejar de cargar maliciosos, pero no es así. Este código no importa de donde la extensión del archivo es, por lo que podría haber imagename.jpg.php como el nombre del archivo y que será aprobado. Peor aún, si esto es para una galería de fotos de acceso público, ese archivo se puede ejecutar PHP libremente porque ya está en el servidor. La capacidad para ejecutar código intruso se convierte en una gran preocupación cuando el usuario malintencionado es capaz de colocar código directamente en un servidor de confiados.

Imagina una imagen que está siendo cargado que es en realidad un archivo PHP con el código como el siguiente:

<?php error_reporting(E_ALL); phpinfo(); mysql_connect(‘localhost’, ‘anyuser’, ‘anypass’); ?>

NOTA Presentación de informes de errores puede ser obligado a salir al deshabilitar la directiva display_errors en el archivo php.ini. Esto asegura el informe de errores no puede querer dar marcha atrás en.

140

Cuando se accede a través del navegador, este código podría permitir a todos los errores para ser visible, mostrar la información del servidor vital, la fuerza de un intento fallido de la base de datos exponer el verdadero camino de archivo, como se puede ver en la Figura 7.1, y determinar si existe una base de datos.

Uso de una mejor forma de comprobar las extensiones de archivo

Volviendo al ejemplo de una simple carga, vamos a añadir las medidas de seguridad más robusta. La principal modificación del código es el caso de declaración de los controles de una extensión de archivo válido. En lugar de buscar la existencia de un tipo de archivo, se ve al final del nombre de archivo y recupera la extensión correcta reales.

if(strrpos( $file[‘name’], ‘.jpg’) !== false) { ... }

FIGURA 7.1 Mensaje de error devuelto cuando la base de datos es intencionalmente a fallar en la conexión

141

A primera vista parece que nada ha cambiado, pero en realidad si. La función strpos ha sido sustituido por el strrpos menos común, que busca el tipo de archivo a partir del final de la cadena y en movimiento hacia el frente. Esto asegura que la extensión del archivo final se encuentra y no uno enterrado en el nombre.

Al igual que con el código, en general, la seguridad puede ser ampliado, y este ejemplo permite una gran expansión.Aquí hay un método más dinámico de la búsqueda de tipos de archivo válidos que se puede colocar fácilmente en un proyecto existente o de una marca-nuevo proyecto.

<?php

function checkForFileType($file, $type) {

$fileTypePos = strrpos($file,’.’); if($fileTypePos === false) { return “File not valid.”; }

if(substr($file, ($fileTypePos+1), strlen($file)) == $type) { return “Valid file type”; }else { return “Invalid or malicious file type detected.”; } }

checkForFileType(“sample.jpg”, “jpg”); ?>

El código anterior es una función personalizada que acepta dos argumentos. El primer argumento aborda el archivo a validar, y la segunda es la extensión de reconocer. Esta solución ampliable devuelve una cadena de determinar si el tipo de archivo se encuentra o no. Menos frecuente es la tercera posibilidad, un partido válido. Un partido no válido: el passed-in el archivo no tiene un nombre de archivo válido en todos los.

Ahora que la parte de carga del código es seguro, el siguiente punto de la seguridad es la forma real de sí mismo. Esta parte lo más probable consistirá en la caja de carga de archivos y cajas de entrada de datos adicionales. En general, un ataque automatizado (equipo configurado para explotar sitios web) es el tema de seguridad a los desarrolladores están más preocupados con, sino una forma de la entrada en Flash también pueden suponer un riesgo de seguridad.

Comprobación de la entrada válida

Comprobación de la validez de las cajas de entrada es un buen comienzo. Un ejemplo de un control de entrada en ActionScript es algo como lo siguiente:

if(length(fileNameTxt.text) > 0) { // file name is valid }

142

Esto es simplemente el control de la variable de fileNameTxt para una longitud que es mayor que 0, es decir, el cuadro de entrada tiene una cierta cantidad de texto en él. Ahora que el cuadro de entrada se sabe que es válida, una llamada al servidor se hace y esto se traduce en el PHP que se llama. El PHP no seguros para un ejemplo simple podría ser algo así.

<?php $name = $_POST[‘fileName’]; // database info goes here... mysql_query(“INSERT INTO uploads (name) VALUES (“ . $name . “)”); ?>

Esto es básicamente tomar el nombre de archivo y directamente insertarlo en la base de datos. Usted podría preguntarse en este punto como si el nombre de archivo es válida en Flash esto podría ser una preocupación de seguridad. El problema no está en los datos transmitidos desde Flash, pero lo más importante, el hecho de que el PHP podría ser llamado por otro método. Esta es una de las razones más importantes para asegurar correctamente todos los puntos de una aplicación.

Una alternativa más segura para el código anterior es

<?php

$name = $_POST[‘fileName’]; // database info goes here ...

if(!empty($name) && strlen($name) > 0) { mysql_query(“INSERT INTO uploads (name) VALUES (“ . $name . “)”); }

?>

Este código no sólo comprueba un valor válido, sino también garantiza que el valor es de una longitud válido.

if(!empty($name) && strlen($name) > 0)

En una aplicación en el mundo real, probablemente sería de verificación, por un valor de al menos dos o tres personajes, pero que todo depende del uso previsto. Esta pequeña actualización del código se asegura de que una llamada de Flash o cualquier otro método se garantizará.

Validar códigos postales (ZIP codes)

Por supuesto, proteger los datos no se limita a los campos de formulario básico. Supongamos que hay una parte de la aplicación que acepte un código postal de cinco dígitos cuando el usuario envía una imagen. La manera de garantizar un código postal válido es por las pruebas de un valor numérico y una longitud válida.

<?php $zipCode = $_POST[‘zip’]; if(is_numeric($zipCode) && strlen($zipCode) == 5)

143

{ // valid zip code found }?>

La función is_numeric() acepta una variable como un argumento que se ha probado para determinar si ese valor es un número. Esta función devuelve una respuesta verdadera/falsa por lo que puede utilizarse fácilmente dentro de una sentencia if o puede asignar el resultado a una variable. Buscando tipos válidos

Si desea realizar esta misma validación básica en Flash, se usaría las funciones typeof y length (longitud). La función typeof devuelve un valor de cadena que define lo que el tipo es del ítem passed-in. Esta función puede ser usado para algo más que la validación de número, pero funciona perfectamente para este ejemplo:

if(typeof(zipCode) == “number” && zipCode.toString().length == 5) { // valid zip code found }

Limpiar datos de usuario

Ahora que tiene una mejor comprensión de la seguridad en su aplicación, el siguiente paso es para desinfectar o limpiar los datos más avanzados antes de almacenarla. El proceso de almacenamiento de datos abarca tanto el uso de bases de datos y un enfoque más sencillo de utilizar archivos de texto estándar. La ventaja de los archivos de texto estándar es el hecho de que no necesita acceder a la base de datos. La desventaja de este método es que es una solución menos robusta que los resultados de las posibilidades de búsqueda mucho más lento. Mayoría de las veces se utiliza una base de datos, a menos que la aplicación sea bastante pequeña que no necesita el potencial de escala para una aplicación más grande.

Desinfeción de los datos

El primer paso para la desinfección de los datos se tratan en la sección anterior, que es garantizar que al menos los datos son válidos. Este proceso es necesario que las diversas funciones que interactúan con una base de datos o sistema de archivos se creará errores muy importantes si se utilizan conjuntos de datos vacía.

El proceso de desinfección de los datos debe hacerse en el PHP, porque siempre es una buena práctica para asumir cualquier passed-in los datos está sucio. Esto significa que aunque los datos fueron enviados desde su aplicación Flash que podría haber sido manipulados en el proceso de presentación.

CROSS--REF Los datos enviados desde Flash es fácil de ver utilizando Charles, que se discute en el capítulo 13.Charles se puede utilizar al 100 por ciento seguro de qué datos se están enviando desde Flash.

Hay un par de funciones muy útiles en PHP que puede ayudar en el proceso de desinfección de los datos antes de que se almacene. La primera función addslashes(), que caracteres de escape como cotizaciones y cortes en los datos que le pasan. El siguiente fragmento de código muestra cómo addslashes desinfecta adecuadamente los datos.

<?php

144

$quote = “I hope to finish the “coolest” Flash application ever. Which will use Flash and PHP”;

?>

Crear consultas SQL seguras

Si ha ejecutado el código anterior, se generaría un error porque el procesador de PHP no permite citas dentro de las comillas. Con citas múltiples, no sería capaz de determinar dónde una cadena se inicia y otra termina. Supongamos que la variable $quote se llena dinámicamente por una llamada de Flash. La variable será llenada correctamente en tiempo de ejecución porque el compilador no valida el contenido sobre la marcha, sin embargo, entrar en que los datos en SQL se producirá un error. Aún peor, en algunos casos, la cadena puede ser introducido parcialmente. Aquí hay una consulta SQL del mundo real donde usted puede ver fácilmente el problema con citas sin escape.

$sql = ‘UPDATE users SET business=Tom’s Diner WHERE id=’ . $ID;

Una vez más, la ejecución del código con el que ha introducido previamente en el PHP produce un error, pero que asumen esta cadena se construye con una petición de $_GET. Al principio, la petición parece seguro, pero el anuncio de consulta SQL comienza con una comilla simple (‘) y hay un apóstrofo en Tom's Diner. La llamada SQL real se convertirá en:

$sql = ‘UPDATE users SET business=Tom

Básicamente, esto se pone cada nombre de la empresa en la solicitud a Tom, que no es probablemente el resultado previsto. También sería muy difícil de revertir si la solicitud hace copias de seguridad adecuada. Este ejemplo es bastante extrema, porque las comillas es más común para una llamada de SQL, pero definitivamente se puede ver cómo datos no desinfectados podría causar un día muy malo para el administrador del sistema.

Ahora que sabes lo mal que datos no desinfectados pueden ser, volver a ese addslashes() y ver lo que la llamada se convierte en SQL:

$business = addslashes($_GET[‘name’]); $sql = ‘UPDATE users SET business=’ . $business . ‘ WHERE id=’ . $ID;

La llamada de SQL debidamente desinfectados ve algo como esto:

$sql = ‘UPDATE users SET business=Tom\’s Diner WHERE id=’ . $ID;

Mira a otra llamada SQL con formato incorrecto que tiene resultados drásticos. Esta se ocupa de la tala en una parte segura de una página Web. Una llamada de SQL para la autorización sería algo como esto:

<?php $user = “admin”; $pass = “password here”; $query = “SELECT * FROM staff WHERE user=’” . $user . “‘ AND

145

pass=’” . $pass . “‘“; ?>

Observe cómo una vez más el SQL a ciegas acepta los valores. Esto realmente se convierte en un problema cuando un usuario introduce una contraseña, tales como

$pass = “‘ OR ‘’=’”;

La llamada de SQL resultante es una contraseña vacía, porque las citas forzadas al SQL a su fin y la OR le permite a la igualdad de sí mismo. Crea una contraseña vacía, lo que significa que sólo el nombre de usuario es detener a alguien de iniciar la sesión, pero nueve de cada diez veces, de administración es un nombre de usuario válido.

SELECT * FROM staff WHERE user=’admin’ AND pass=’’ OR ‘’=’’

Así de simple \ significa que la diferencia entre una llamada de SQL eficaz y muy peligroso. Esta función es sólo una forma posible de datos para desinfectar.

La siguiente función, cuando se trabaja con una base de datos, es mysql_real_escape_string, que desinfecta los datos antes de entrar en la base de datos. Al usar esta función, primero debe realizar una conexión adecuada a la base de datos, de lo contrario recibirá un error.

La sintaxis para mysql_real_escape_string es casi lo mismo que addslashes(). Que se pasa en el valor que desea limpiar y un vínculo de MySQL opcional. Si un enlace no se pasa, se utiliza el enlace SQL última.

<?php // connect to database, generate $link $business = mysql_real_escape_string($_GET[‘name’], $link); $sql = ‘UPDATE users SET business=’ . $business . ‘ WHERE id=’ . $ID; ?>

La ventaja de utilizar esta función es que se encarga de todas las diversas escapar, que va más allá de comillas simples y dobles. El problema evidente es que requiere un enlace de MySQL, así que no se puede utilizar a menos que los datos serán almacenados en una base de datos. O, al menos, usted necesita tener acceso a una base de datos. Un uso incorrecto de esta función tendrá como resultado un error, como se observa en la Figura 7.2.

146

FIGURA 7.2 Mensaje de error aparece cuando un enlace de base de datos MySQL no está disponible

Limpieza adecuada de datos HTML

La función final que mirar es htmlentities(). Básicamente, esta función toma caracteres HTML y los convierte en valores numéricos. Estos son mejores porque cosas como "" se convierten&quot, y esto casi elimina la necesidad de desinfección avanzado de datos.

<?php

$str = “The ‘red’ fox <b>jumped</b>”;

// The 'red' fox <b>jumped</b> echo htmlentities($str, ENT_QUOTES);

147

?>

El segundo argumento en la función htmlentities() determina si las dos comillas simples y dobles se conviertan, Los valores posibles para este segundo argumento se muestran en la Tabla 7.1.

TABLA 7.1 Estilos de comillas disponibles

Nombre de Constante Descripción ENT_COMPAT Convierte las comillas dobles; estilo de comillas solaENT_QUOTES Convierte tanto comillas dobles e individualesENT_NOQUOTES Deja a las dos comillas dobles e individuales convertidos

Es una buena idea ejecutar estas tres funciones para asegurar que sus datos es tan limpio como sea posible. Sólo se necesita la potencia de procesamiento un poco más, pero puede hacer la diferencia entre una aplicación segura y una insegura.

Más importante aún, a medida que continúe la práctica estos conceptos de seguridad bien que pasarán menos tiempo de parches y la depuración en el futuro.

Almacenamiento de datos

La base de datos no es el método de almacenamiento sólo, como se explica en el comienzo de esta sección. También puede utilizar archivos de texto simple para almacenar información, y la mayoría de los pasos de desinfección que el trabajo aquí también. La única excepción es mysql_real_escape_string, que, como se dijo anteriormente, requiere un enlace SQL.

Escribir de forma segura a un archivo

Un ejemplo simple de la escritura de forma segura a un archivo sería algo como esto. En primer lugar, validar los datos antes de abrir el archivo. Esto garantiza que el archivo no puede verse accidentalmente por escrito a.

<?php

if($fileContents != “”) { $handle = fopen(“sample.txt” , “w+”); fwrite($handle, $fileContents); }else { print “File content not written, invalid data”; }

?>

Trabajar con datos en un orden lógico

148

Es importante mantener un orden lógico cuando se trabaja con datos. Por ejemplo, si la función addslashes() se ejecute antes de la sentencia if, la longitud del contenido podría ser expulsados y producir un resultado falso. Al mismo tiempo, si el archivo se abre antes de que los datos sean validados, un malintencionado podría explotar inyectar contenido en el archivo abierto. Piense en ello como las mismas precauciones que tomar cuando se inicia sesión en un sitio Web seguro en un lugar público.

Crear una clase para manejar saneamiento

En este punto usted debe entender completamente cómo desinfectar los datos que se pueden guardar en una base de datos o un archivo de texto simple. Usted puede ampliar estas mejores prácticas para crear un conjunto de herramientas más reutilizables. Por ejemplo, podría crear una clase de saneamiento que se ocupa automáticamente del proceso. Una clase básica sería algo similar a lo siguiente:

<?php

class Sanitization {

function cleanSQL($str) { return mysql_real_escape_string($str); }function cleanHTML($str) { return htmlentities($str, ENT_QUOTES); }

function cleanText($str) { $s = $str; if(!ini_get(‘magic_quotes_gpc’)) { $s = addslashes($s); }return $s; }

function checkLength($str, $acceptableLength) { if(strlen($str) >= $acceptableLength) { return true; }else { return false; } } }

?>

149

La clase define tres métodos, cada uno de ellos sea un sustituto de una técnica aprendida en la sección anterior. Este enfoque ofrece la posibilidad de ser reutilizables a medida que continúe trabajando en más aplicaciones. La clase también contiene más lógica de lo que se usa porque addslashes agrega barras a barras existentes. El resultado será tres barras de escapar cada comilla.

NOTA Una doble barra hará una barra en la parte delantera de la cita, ya que le indica al compilador para escapar de la barra y no pensar en ello como código.

The \\\’red\\\’ fox jumped.

Trabajar con opciones de magic_quotes

Hay una configuración en PHP llamada magic_quotes_gpc, que es responsable para escapar de los datos automáticamente, como se muestra en la Figura 7.3.

FIGURA 7.3 Un valor de ejemplo de la propiedad magic_quotes_gpc como se ve en la función phpinfo () de la listas

Desactivar magic_quotes

En menos de configuraciones de servidor común que esta característica no se puede apagar. Una prueba rápida para determinar si se ha habilitado la opción asegura barras adicionales no se añadirá.

150

if(!ini_get(‘magic_quotes_gpc’)) { $s = addslashes($s); }

Las otras dos funciones en la clase de saneamiento simplemente limpiar el passed-in los datos y devolverlo.

Usar objetos compartidos

Al empezar a construir aplicaciones más completa se llega a un punto en el almacenamiento de algunas pequeñas cantidades de datos en la máquina del usuario sea necesario. Estas pequeñas piezas de información en general, tienen un ID de usuario o período de sesiones que se asigna a una entrada de base de datos en el servidor en vivo. Una "cookie" Shared Object Flash se utiliza en este caso porque es una pequeña pieza de información almacenada en el ordenador del usuario, pero no es necesario para la aplicación se ejecute.

Cuando la aplicación que hace uso del objeto compartido se abra de nuevo, sería configurado para buscar este pequeño pedazo de datos y realizar una llamada a un servidor basado en el resultado. Sin embargo, al igual que las cookies normales que el navegador utiliza un objeto compartido puede ser editado por el usuario final, que puede tener resultados perjudiciales.

Como se indica en la sección anterior, es mejor no confiar en los datos que un usuario envía. Esta directriz común garantiza una aplicación más segura y, en general hace que sea más fácil trabajar con.

NOTA La mayoría de los agujeros en la solicitud son explotados por el usuario envíando los datos.

Imagine una aplicación de ejemplo, que se utiliza para trabajar con un objeto compartido. Esta solicitud puede ser configurado para abrir un objeto compartido y pasar los datos a un servidor remoto.

Una vez que el objeto compartido se ha cargado, una llamada al servidor remoto podría hacerse pasar por el pequeño pedazo de información de los objetos compartidos. En este ejemplo, la pequeña pieza de información podría ser un ID de usuario que se han guardado en un uso previo.

Uso de PHP para manejar datos de objetos compartidos

El código PHP se encarga de cargar esta pieza de información y consulta de la base de datos.Sin embargo, antes de una llamada a la base de datos se hace, el ID de usuario se valida asegurándose de que es un número válido y dentro del rango de.

<?php $userID = $_GET[‘user_id’]; $idRange = 500; if(is_numeric($userID) && $userID > 0 && $userID < $idRange) { // connect to database at this point mysql_connect(“localhost”, “user”, “pass”); mysql_select_db(“db_name”); $r = mysql_query(“SELECT * FROM user WHERE userID=” . $userID);

151

while($row = mysql_fetch_array($r)) { print “resp=success&username=” . $row[‘username’] . “&userlevel=” . $row[‘user_level’] . “&userstyle=” . $row[‘user_style’]; } }else { print “resp=” . “User ID not found or is invalid”; }?>

Suponiendo que el id de usuario es válida, un bloque de información se pasa de nuevo en formato de texto simple. Estos datos se carga en una matriz y se utiliza en el resto de la aplicación. Si el ID de usuario no es válida, se devuelve una cadena que informa al usuario de que algo pasó y el período de sesiones existente no se puede cargar. En la mayoría de los casos, si la sesión existente no se puede cargar, la aplicación Flash sabe que empezar de nuevo en lugar de tratar de utilizar datos incompletos o erróneos.

NOTA ActionScript 3 corelib de Adobe (biblioteca externa) tiene una clase de MD5 que se puede utilizar en lugar de PHP.

Crear y guardar una contraseña segura usando PHP

El proceso de modificación de una contraseña que se puede almacenar es bastante simple. En primer lugar, crear una conexión con el archivo PHP que pasa a lo largo de la contraseña en texto claro. Sin embargo, este proceso no es el más seguro y que sería mejor para devolver una respuesta de MD5 de la contraseña cuando se realiza un intento de inicio de sesión.

Para explicar el proceso, aquí la opción de un ejemplo de lo simple (menos seguro):

var phpFile:String = “http://localhost/md5creator.php”;

var query:String = “?pass=” . “password”; var urlRequest:URLRequest = new URLRequest(phpFile + query); var urlLoader:URLLoader = new URLLoader();

urlLoader.addEventListener(Event.COMPLETE, response); urlLoader.load(urlRequest);

function response(e:Event):void { var loader:URLLoader = URLLoader(e.target); var param:URLVariables = new URLVariables(loader.data); trace(“User Information Loaded”); trace(“\tUser: “ + param.username); trace(“\tLevel: “ + param. userlevel); trace(“\tStyle: “ + param.userstyle); }

Una llamada al PHP en el servidor se realiza utilizando un URLRequest básicos, que deberían ser familiares para usted a partir de ejemplos y capítulos anteriores. Una vez que el URLRequest se establece una función de

152

devolución de llamada es asignado para manejar la respuesta del servidor. En este ejemplo, tendrán que contener un MD5 de cadena o de un error. El PHP simplemente controla una cadena válida y devuelve un valor hash MD5 (cadena cifrada). Si una cadena incompleta o vacía se envía desde el Flash, PHP devuelve un mensaje de error.

<?php

$string = $_GET[‘string’];

if(strlen($string) == 0) { print “response=” . “String not provided.”; }else { $md5 = md5($string); print “response=” . $md5; }

?>

Este sería un ejemplo bastante simple para crear un valor hash MD5. En el uso del mundo real que usted querría a las semillas de la encriptación md5 para dar la respuesta más original y más difícil de romper.Una semilla es un valor conocido que se utiliza en el proceso de MD5. Si desea crear una semilla verdaderamente al azar, usando el time() es una buena idea, ya que casi todas las llamadas produce un resultado diferente.

El hash para este ejemplo se debe poder verificar cuando el usuario intenta iniciar sesión. Para este ejemplo, el nombre de la aplicación utilizada será "securepass".

cfcd208495d565ef66e7dff9f98764da

La semilla (seed) se anexa a la cadena existente que será codificado, ya sea al comienzo o al final.

$md5 = md5($string + “securepass”);

La posición de la semilla debe ser coherente, ya que se re-crea cuando el usuario intenta iniciar sesión en la próxima vez.

El código PHP con la semilla única aplicación se vería algo como esto:

<?php

$string = $_GET[‘string’];

if(strlen($string) == 0) { print “response=” . “String not provided.”; }else { $md5 = md5($string + “securepass”);

153

print “response=” . $md5; }

?>

En este punto, en la aplicación de la semilla es creado, y usted puede continuar con el proceso de almacenar ese valor en un objeto compartido.

Retornar datos

Es seguro asumir que tendrá que ser la devolución de datos de vuelta a Flash en algún momento de su aplicación. La preocupación general de seguridad en este proceso es similar al envío de datos, con la excepción de que más vulnerabilidades se trató sobre la devolución de los datos.

Retornar datos de forma segura

La idea de pasar de forma segura los datos de vuelta a Flash es mucho menos habló de tema. Esto se debe principalmente al hecho de que Flash no tiene que ser seguro, sin embargo, todavía es una buena práctica para garantizar que sea.

Si usted no puede validar los datos de volver a Flash puede abrir un agujero de seguridad que podría, por ejemplo, permitir a un usuario para acceder a una sección privada de una aplicación. Aún peor, puede tener efectos negativos sobre la experiencia del usuario, y sus usuarios pueden perder la fe en su aplicación.

Los datos de volver a Flash puede ser alterada de la misma forma los datos pueden salir. Para el ejemplo anterior, una serie de datos se devuelven, pero nunca se comprueba para asegurarse de que los datos son válidos.Vamos a ampliar el ejemplo anterior para añadir esta seguridad. La función de respuesta es la única sección de código que necesita ser modificado, porque la solicitud será el mismo.

function response(e:Event):void { var loader:URLLoader = URLLoader(e.target); var param:URLVariables = URLVariables(loader.data);

var username:String; var userLevel:uint; var userStyle:String; var validData:Boolean = true;

if(param.username != “”) { username = param.username; }else { validData = false; }

154

if(param.userlevel!= “”) { userLevel = param.userlevel; }else { validData = false; }

if(param.userstyle != “”) { userStyle = param.userstyle; }else { validData = false; }

if(!validData) { trace(“User data was not properly loaded”); }else { trace(“User Information Loaded”); trace(“\tUser: “ + param.username); trace(“\tLevel: “ + param. userlevel); trace(“\tStyle: “ + param.userstyle); }

}

Básicamente, este primer código inicializa variables para almacenar los datos del usuario y comprueba cada passed-in el valor de una entrada válida. La variable de validación se asigna a cierto desde el principio, porque si alguno de los estados, si no se cambiará a false. Este proceso se considera lógica inversa, pero funciona bastante bien para las rutinas de validación.

Utilizando un enfoque más seguro para el retorno de datos

En el ejemplo anterior, aprendió cómo trabajar con seguridad con los datos devueltos. El problema con este enfoque simplificado es que existen otras maneras de interceptar información pasa entre Flash y el servidor.

Usar respuesta unica

Hay varias opciones para crear una aplicación aún más seguro, que todo depende del tiempo y costo de desarrollo. Es un pensamiento común a ignorar los costos de la seguridad en última instancia, pero esto simplemente no es posible todo el tiempo. Frecuentemente usted trabajar en un proyecto que llega a un "punto suficientemente bueno" y la aplicación a los buques de las cuestiones, lo cual es una desventaja para el desarrollo de aplicaciones, pero muy común.

155

La mejor manera de mantener bajo el costo real es mirar todas sus opciones. Una opción es usar MD5 para crear códigos de respuesta única y asegurar los datos son válidos, que trabajará, pero nada impide que el "hacker" de descompilar el SWF y mirando directamente al código.

Proteger sus archivos

En versiones anteriores de ActionScript que fueron capaces de crear fondos soberanos ofuscado, lo que significa que la mayoría de aplicaciones no podía descompilación. Sin embargo, en el momento de escribir este documento no existe la herramienta para

aplicaciones de AS3.

Comprender la seguridad de Sandbox en Flash

El recinto (sandbox) de seguridad en Flash determina qué archivos se puede acceder en función de dónde se encuentra el archivo SWF. Un funciones del archivo SWF de manera diferente cuando se ejecuta localmente en la máquina del usuario que lo hace en un servidor.

Por ejemplo, un archivo SWF en el recinto local no puede acceder a los objetos locales y remotos. Esto impone un nivel de seguridad en la aplicación para asegurarse de fuentes no pueden cruzar entre sí.

Los archivos locales pueden ser colocados en una de las tres cajas de arena (sandboxes):

local-with-filesystem: Esto asegura al usuario que el contenido local y no por casualidad puede ser enviado a una red o compartirlo.

local-with-networking-sandbox: Permite que los SWFs locales puedan acceder a objetos remotos, si se encuentra un archivo de política válida.

local-trusted: Un archivo SWF en este recinto de seguridad puede tener acceso a datos desde cualquier lugar, tanto locales como remotos. Sólo los usuarios y administradores pueden mover un archivo SWF a este recinto de seguridad.

The local-trusted sandbox cannot accidentally be set by a stand-alone SWF. This is done to ensure the level of security a user would expect.

Con el fin de permitir el acceso a un dominio remoto, primero debe agregar a la clase de seguridad, haciendo un llamado a allowDomain().

Security.allowDomain(“www.example.org”);

También puede utilizar un archivo de política de dominio que permite el acceso de determinados dominios o todos los dominios con un comodín (“*”).

<allow-access-from-domain=”*” />

Configurar el tipo de sandbox

Cuando se publica un archivo SWF, puede elegir el tipo de recinto de seguridad especificados en función de los recursos necesarios para ese uso. Para establecer el tipo de recinto de seguridad, siga estos pasos:

156

1. Seleccione Configuración File.Publish (Choose File.Publish Settings). 2. Haga clic en la ficha Flash. 3. En la lista desplegable, haga clic en Reproducción de Seguridad. 4. Haga clic en Aceptar.

Uso de la propiedad sandboxType

Un archivo SWF puede utilizar sólo la lectura estática y la propiedad Security.sandboxType para determinar qué cajón de arena del reproductor de Flash ha asignado el SWF actual.

En algunos casos, usted tendrá que usar el valor actual de la propiedad sandboxType en la programación para determinar cómo una aplicación debe interactuar. Uso de una declaración simple cambio, puede crear una función personalizada que se traza el tipo de recinto de seguridad actuales, como se muestra en la Figura 7.4.

FIGURA 7.4 Ventana de resultados que muestra un resultado de ejemplo de la función de whichSandbox

function whichSandbox():String { var str:String = “”; switch(Security.sandboxType) {

157

case Security.REMOTE: str = “This SWF is from an Internet URL. “ + “It cannot access local files”; break; case Security.LOCAL_WITH_FILE: str = “This SWF is local, but not trusted by “ + “the user. It does not have access to “ + “remote files.”; break; case Security.LOCAL_WITH_NETWORK: str = “This SWF can communicate with remote “

+ “files, but can with local files.”; break; case Security.LOCAL_TRUSTED: str = “This SWF has been trusted by the user. “ + “It can read both local and remote files.”; break; }

return str;

}

trace(“Checking for current sandbox type.”); trace(whichSandbox());

Determinando el activo sandbox

Determinar el tipo de recinto de seguridad actual no se limita a un simple seguimiento de respuesta. Usted puede presentar al usuario una pantalla de advertencia le notifica que el SWF actual no puede tener acceso a recursos remotos, ya que se ejecuta localmente. También puede detener la fuerza de una película de correr si una caja de arena local se encuentra, lo que significa que la película ya no se ejecuta desde su sitio Web. Por ejemplo, una película ejecuta de forma local podría haber sido robado de su sitio, así que es una buena idea para comprobar esto y actuar en consecuencia.

La ejecución de aplicaciones en el recinto (sandbox) de seguridad locales

En este ejemplo se muestra en la Figura 7.5 comprueba el tipo de recinto de seguridad y muestra una cuenta regresiva, si la película se está ejecutando a nivel local.

158

FIGURA 7.5 Ejemplo de la aplicación completa que muestra una cuenta atrás de activos

Para empezar, abra el archivo de partida que se pueden encontrar en el sitio web de este libro.

Los activos de este ejemplo ya se han completado para que pueda centrarse en la programación.El primer paso es crear las variables necesarias.

var timer:Timer; var sandbox:String; var startingTime:uint = 5;

Después de las variables que están asignados, usted puede construir el init función inicial, que se llama tan pronto como comienza la película.

159

function init():void {

timerMC.alpha = 0; sandbox = Security.sandboxType;

if(sandbox.indexOf(‘local’) == -1) { startTimer(); } }

La parte principal de esta función es la sentencia if, que comprueba la presencia de la cadena "local" en el tipo de recinto de seguridad. Esto incluye cualquiera de las versiones locales y determina que la película no se está ejecutando en el recinto de seguridad remotas. Si se detecta un recinto de seguridad local, una llamada a startTimer se hace, que se inicializa y se inicia el temporizador de cuenta regresiva.

if(sandbox.indexOf(‘local’) != -1) { startTimer(); }

La función startTimer primero inicializa una instancia del nuevo temporizador y luego añade un detector de eventos, que se llama cada milisegundo. La última acción en esta función es mostrar el texto del temporizador, mediante el establecimiento de la propiedad alpha a 1.0 lo que la hace totalmente visible.

PRECAUCIÓN El uso de una actualización del temporizador de 1 milisegundo por un período largo de tiempo puede crear una película que no responde. Para una comprobación inmediata, como en este ejemplo, no es una gran preocupación.

function startTimer():void { startingTime *= 1000;

timer = new Timer(1, 0); timer.addEventListener(TimerEvent.TIMER, tickHandler); timer.start(); timerMC.alpha = 1.0; }

El controlador de eventos en la sección anterior le asigna una función para cada llamada al temporizador. Esta función es del controlador. El argumento pasado es una referencia al objeto de temporizador. Usted también puede hacer referencia al evento mundial, sin embargo, esto es más comprensible si regresa a este código en el futuro.

function tickHandler(e:TimerEvent):void { var time:Timer = e.target as Timer;

var milli:uint = (startingTime - getTimer()); var sec:uint = Math.round(milli / 1000);

timerMC.timerTxt.text = String(sec) + ((sec == 1) ? “ second” : “ seconds”);

160

if(sec == 0) { timer.stop(); stage.removeChildAt(0); } }

El objetivo del objeto de evento se presenta como temporizador. Una vez más, este paso no es obligatorio, pero es más fácil trabajar con el código. La idea es mostrar los segundos restantes, que se determina utilizando los milisegundos restantes.El milisegundos restantes se obtienen mediante la función getTimer(), que devuelve los milisegundos de la película actual ha estado en ejecución. El startingTime se resta de este valor y el resultado es el total de milisegundos.

var milli:uint = (startingTime - getTimer());

NOTA La función getTimer()siempre devuelve el tiempo total de la película actual ha estado en ejecución. Esto significa que si esta prueba se hace más adelante en el proceso de reproducción del valor no se muestran correctamente.

El milisegundos restantes se convierten entonces en segundos, usando un poco de matemáticas básicas. El valor actual de la variable de mili dividido por 1000 es igual a los segundos restantes.

var sec:uint = Math.round(milli / 1000);

Una vez determinados los segundos, que el valor es enviado al campo de texto timerTxt en el escenario. Para la exhibición gramatical correcta, la variable sec se utiliza para determinar si el segundo o segundos se debe mostrar. Esa variable sec se prueba en cada ejecución de esta función para determinar cuando el cronómetro se detiene y para descargar la aplicación completa.

if(sec == 0) { timer.stop(); stage.removeChildAt(0); }

Descargar una aplicación

La acción de la descarga de toda la aplicación se realiza mediante una llamada a la removeChildAt en la instancia del escenario. En este caso, toda la película debe ser eliminado, por lo que 0 es el sentido de pasar de índice 0 y hacia abajo.

if(sec == 0) { timer.stop(); stage.removeChildAt(0); }

El último paso del código es para hacer una llamada a init, que se inicia el proceso.

161

init();

Esa es la aplicación completa, que se ejecutará si el recinto de seguridad actual es local. Usted puede cambiar la lógica general en la presente solicitud y agregarlo a su cuenta para asegurarse de que su película no es mal ejecutar.

Aquí está el código completado:

var timer:Timer; var sandbox:String; var startingTime:uint = 5; function init():void { timerMC.alpha = 0; sandbox = Security.sandboxType; if(sandbox.indexOf(‘local’) == -1) { startTimer(); } }function startTimer():void { startingTime *= 1000; timer = new Timer(1, 0); timer.addEventListener(TimerEvent.TIMER, tickHandler); timer.start(); timerMC.alpha = 1.0; }function tickHandler(e:TimerEvent):void { var time:Timer = e.target as Timer; var milli:uint = (startingTime - getTimer()); var sec:uint = Math.round(milli / 1000); timerMC.timerTxt.text = String(sec) + ((sec == 1) ? “ second” : “ seconds”); if(sec == 0) { timer.stop(); stage.removeChildAt(0); } }init();

En este punto, usted debe tener una buena comprensión de cómo el recinto de seguridad de Flash que funciona y lo que es. Como puede ver, la caja de arena puede llegar a ser un problema en algunos casos, pero en general su objetivo es proteger al usuario. En el último ejemplo, el código se ha ampliado y ahora la caja de arena es capaz de proteger al propietario del contenido, así como del usuario.

162

Usted puede tomar las prácticas y técnicas aprendidas en esta sección y comenzar a adaptarlas a sus propias aplicaciones.

Garantizar una aplicación no puede ser compartida

Como un extra a esta sección, el último ejemplo será la de crear un estilo similar de verificación cajón de arena, pero esta vez con el objetivo de que una película no debe ser visible en cualquier otro sitio Web, excepto para lo que fue construido. Esto se logra mediante la propiedad url en el objeto loaderInfo. Esta propiedad es accesible en cualquier objeto cargado. Para este ejemplo, el objeto cargado sería el escenario, porque es la raíz de objeto de visualización. El código para determinar la ubicación actual de una película se está ejecutando es:

stage.loaderInfo.url

Este código devuelve una cadena que muestra una película donde se está ejecutando. Un ejemplo de respuesta de una película se ejecuta de forma local:

file:///MacPro%20HD/Library/Server/Documents/DomainCheck.swf

El uso de esta propiedad podría mostrar un mensaje de advertencia que se hizo en la prueba de caja de arena. Para fines de demostración, un dominio no válido se proporciona a causa de la película para ser removido inmediatamente.

if(String(stage.loaderInfo.url).indexOf(‘example.org’) != -1) { stage.removeChildAt(0); }

Suponiendo que el código anterior se ejecuta en una película que no se encuentra en el dominio example.org, la película se elimina y la aplicación ya no es accesible. Para una aplicación más completa que sería de verificación de la www y sin www versión del sitio web. También se podría ampliar en este código y comprobar si hay una lista de sitios válidos, lo que podría lograrse mediante un simple bucle y una serie de dominios permitidos.

NOTA Esta comprobación no es 100 por ciento seguro debido a las limitaciones en la forma en una dirección URL se puede acceder.

Ahora usted debería tener una comprensión de cómo asegurar su aplicación, y agregar un nivel de protección para evitar que otros sitios y lugares de beneficiarse de su contenido sin autorización.

Resumen

En este capítulo usted aprendió cómo limpiar adecuadamente los datos del usuario, aunque es consciente de cómo puede afectar la funcionalidad de su aplicación. A continuación, aprendió a cargar correctamente y limpiar los datos del usuario para garantizar el proceso de almacenamiento no se verán perjudicados. El almacenamiento de la seguridad de los datos se presenta a continuación con ejemplos de cómo simples llamadas SQL pueden causar dolores de cabeza en las aplicaciones.

163

El siguiente paso que se introdujo fue el proceso de devolución de datos a Flash y el análisis de estos datos para asegurarse de que estaba bien manejado.

La última sección es una introducción y una visión general de la caja de arena de Flash y cómo puede afectar a las aplicaciones. Como un bono que ha aprendido cómo crear una aplicación que se eliminará a sí misma si no se ejecuta en el dominio correcto.

164

Capitulo 8Uso de Sockets

Cuando se trabaja con aplicaciones multiusuario, hay diferentes maneras de enviar y recibir datos. Puede utilizar un formato XML basado en el método de entrega. Otra alternativa a la entrega estándar es construir un "tirón" (“pull”) de aplicación que comprueba si hay actualizaciones mediante un temporizador.

Sockets permite un método " push " (“empuje”) que deja fuera a los temporizadores y las actualizaciones sólo cuando los nuevos datos se envían. El uso de sockets no se limita a simples datos, que realmente podría construir una aplicación de dibujo multiusuario que pasar las coordenadas a través de los diversos que ha iniciado sesión en los clientes. Este capítulo se divide en dos partes. La primera parte explica sockets. La segunda parte es un Flash simple basada en aplicación de chat usando sockets como la entrega de los mensajes.

Comprender los Sockets

Un socket es un extremo de la comunicación o parte de una computadora de una red conectada a otro equipo en el mismo protocolo. La diferencia entre una conexión tradicional (Internet) y un conector es la capacidad de hacer una distinción entre las máquinas que usted está hablando.

Cuando usted solicita un sitio Web desde Internet, se obtiene la página solicitada, pero Internet no puede obligar a los nuevos datos directamente a usted (el cliente) sin pedir una vez más.

Un conector proporciona esta comunicación directa, permitiendo la conexión principal para enviar datos de nuevo a usted (el cliente). Esto es más comúnmente usado en aplicaciones de conexión directa, tales como la mensajería instantánea, aplicaciones de vídeo y entornos de colaboración en equipo.

Seguridad en sockets

El uso de sockets requiere una conexión más directa, lo que significa que la seguridad es una preocupación más grande.En general, cualquiera que sea la herramienta que está utilizando para implementar el cliente o el servidor de socket permite un nivel de seguridad directamente dentro de su propia biblioteca. Por ejemplo, Flash requiere una confianza que se creará en un dominio diferente que permite a ambas partes a autorizar la conexión. En cambio, una simple conexión realizada por la línea de comando no tiene ningún tipo de seguridad implica más allá de los límites de un protocolo estándar.

NOTA Sockets puede ser una mala elección cuando se aplique en determinados sistemas o configuraciones, debido a su naturaleza, la conexión directa.

Implementación de un servidor socket

El maestro de servidor socket puede ser implementada utilizando muchos lenguajes de programación común.

165

Para un socket persistentes o nivel de producción, lo más probable es ejecutarlo desde un servidor activo para garantizar que otros usuarios puedan conectarse a él y limitar el riesgo de una conexión abierta en el sistema local.

Entender la conexión del socket

La conexión de socket en el siguiente ejemplo se encarga de comunicarse con el usuario. Las siguientes secciones explican el proceso.

Partes de un socket

Una conexión de socket está formado por dos piezas. La primera parte es la conexión principal o servidor, y la segunda parte es de los clientes que se conectan con el maestro. Los clientes pueden hablar directamente con el maestro, pero no puede hablar en general, a otros clientes. Si desea que los clientes hablen entre sí se pondría en práctica un sistema de intercomunicación con el maestro.

Que hay que cumplir (Binding)

El socket principal está ligada a una determinada dirección IP y el puerto. Esto significa que la conexión principal se hace a este punto concreto para garantizar la conexión es única. Los clientes que quieren comunicarse con el servidor de socket debe conectarse a la misma dirección IP y puerto que el maestro.

Escuchar (Listening)

Esto es similar a la del servidor de Web estándar. Una vez que el servidor de socket se inicia, a la escucha de clientes activos y los nuevos que se quiere conectar. Estos clientes se añaden a la cola y comenzar a recibir las comunicaciones del grupo.

Trabajar con Sockets en PHP

Construcción de un servidor de socket en PHP requiere alguna configuración previa. Un servidor de socket en PHP no se pueden ejecutar desde la versión gráfica estándar debido a su conexión persistente. Un navegador Web estándar basado en la conexión sería tiempo de espera, o posiblemente accidente de la máquina host.

Una conexión de socket se ejecuta con el comando nongraphic versión en línea de PHP (CLI). El primer paso para trabajar con sockets en PHP es para determinar si usted tiene esta versión CLI de PHP instalada, ya que normalmente no se incluyen en un paquete de servidor Web.

Buscando la version de línea de commando de PHP

La versión de línea de comandos (CLI), si está instalado, es generalmente accesible directamente desde la Terminal en un Mac o el símbolo del sistema en un PC (ver figura 8.1).

Para determinar si usted tiene esta versión, simplemente abra la línea de comandos. En Windows, haga clic en Inicio y luego en Ejecutar. Escriba cmd en el cuadro de diálogo Ejecutar y haga clic en Aceptar. Si estás usando un Mac, abra el Finder, vaya a Aplicaciones/Utilidades, y abra el Terminal.

166

FIGURA 8.1 Ejemplo de un símbolo del sistema en Windows XP

Con la línea de comandos Abrir, escriba lo siguiente:

$ php -v

Este comando le dice a PHP que informe la información de versión y sale. El resultado debería ser algo similar a lo siguiente:

PHP 5.2.5 (cli) (built: Dec 20 2007 02:55:52) Copyright (c) 1997-2007 The PHP Group Zend Engine v2.2.0, Copyright (c) 1998-2007 Zend Technologies

Si recibe una respuesta similar a la siguiente, significa que la versión de PHP puede ser instalado, pero no a nivel mundial, accesible desde cualquier línea de comandos y se requiere una configuración.

-bash: php: command not found

Usted tendrá que localizar la versión de línea de comandos o instalar a continuar con este capítulo.

CROSS--REF Véase el Capítulo 1 para obtener información sobre cómo instalar la versión de línea de comandos de PHP.

Construir un servidor socket

Para crear un servidor de socket sencillo usando PHP, empezar por crear un archivo y guardarlo en un lugar de acceso común. Este archivo no tiene por qué estar en su directorio web y probablemente sólo será más difícil trabajar si lo es.

NOTA Usted quiere asegurarse el archivo socket no es visible en la Web, ya que podría causar que su PHP para que no funcione correctamente si un usuario malintencionado intenta ejecutar el archivo.

167

Para entender mejor cómo trabaja el socket, empezar con un ejemplo muy simple socket de servidor.

Simple PHP-servidor basado en socket

La primera parte del servidor de socket es determinar la dirección IP del servidor y número de puerto. Si está ejecutando el servidor local no es necesario para determinar su dirección IP física. En su lugar, puede utilizar la dirección local.

<?php

$host = “127.0.0.1”; $port = “8888”;

El número de puerto no es específico, pero debe ser único en la misma máquina para asegurarse de que no choquen con cualquier otra aplicación en su sistema o red (si se usa de forma remota).

Este script PHP necesidad de informar a seguir corriendo porque es necesario para buscar y administrar las conexiones de forma indefinida. Esto se logra mediante la aprobación de la función set_time_limit un valor de 0, lo que significa esta secuencia de comandos no debe parar hasta que salió bien.

set_time_limit(0);

Con la configuración del camino, usted puede crear la conexión de socket principal.

$sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);

Los tres argumentos que se pasan en la función socket_create define qué tipo de conexión que es y son constantes PHP. Para este ejemplo, no son importantes, pero que se explica más adelante en el capítulo.

La variable $sock ahora contiene un recurso de socket activo de identificación. El siguiente paso es enlazar el conector para el puerto definido en la primera parte del código.

socket_bind($sock, $host, $port);

Después de que el socket está enlazado al puerto, usted puede empezar a escuchar las conexiones. El primer argumento es la variable $socket, que tiene el socket de recursos de identificación. El segundo argumento es una variable de retraso que le dice a PHP la cantidad de mensajes que hacer cola antes de que un error se pasa al cliente. Esta variable es una sugerencia ya que algunos sistemas se definen o reemplazar este valor. Por ejemplo, Windows establece esta basado en el proveedor de servicios de base y, básicamente, ignora cualquier valor usersubmitted.

socket_listen($sock, 4);

En este punto, usted ha construido un servidor de socket que no hace nada. Esto básicamente significa que el servidor se inicia y espera las conexiones entrantes, pero no controla en modo alguno. El siguiente paso es configurar la parte del servidor de socket que maneja las conexiones de entrada.

Es necesario crear otro conector que se encarga de las conexiones de entrada, haciendo un llamado a socket_accept pasa en el recurso id $socket.

168

$childSocket = socket_accept($sock);

Desde este punto la variable $childSocket se utiliza para controlar todas las comunicaciones del cliente. Los datos enviados desde una conexión que se lee con la función socket_read.

$incomingData = socket_read($childSocket, 2048);

Esta función toma dos argumentos. El primer argumento es el controlador de socket de cliente, y el segundo argumento es el número de bytes para leer desde el cliente. Esto puede ser útil al intentar ejecutar un servidor de sockets más eficiente. También es una buena idea para limitar la salida en el lado del cliente (si es posible).

La función socket_read continúa cargando información en la variable $incomingData hasta el límite de datos es golpeado o uno de los personajes se encuentra la siguiente: retorno de carro (\n), tabulador (\t), o \0. PHP las trata como al final de caracteres de entrada y se mueve a la línea siguiente en la secuencia de comandos cuando se encuentra uno.

Responder a la conexión del cliente

Después de cargar los datos, el siguiente paso es el de actuar en esos datos y en la mayoría de los casos responde al cliente.Por ejemplo, la siguiente es una simple pregunta/respuesta demo que tenga PHP en respuesta a una pregunta:

if(substr($incomingData, 0, -2) == “are you hungry?”) { $response = “Server Response > I could eat!\n”; socket_write($childSocket, $response, strlen($response)); }

La función socket_write toma tres argumentos. La primera es que el niño toma de ID de recursos, el segundo argumento es la respuesta que se envía al cliente. El tercer argumento, que es opcional, es la longitud del $response. Este ejemplo sólo envía una respuesta al cliente cuando se le pide PHP si tiene hambre. Como puede ver, esto no es una aplicación muy práctica, pero no explican claramente cómo sockets se establecen y cómo interactuar con ellos.

El último paso para la aplicación de ejemplo, antes de la prueba, es el cierre de las dos conexiones de socket para liberar los recursos y permitir las conexiones a que se hizo.

NOTA Si desea seguir recibiendo conexiones que sólo desea quitar la variable $childSocket.

socket_close($childSocket); socket_close($sock);

Los enchufes pueden cerrarse en cualquier orden, pero es una buena práctica para cerrar el último maestro en caso de tener que recorrer varias conexiones de cliente primero.

Probar el servidor socket

Prueba del servidor de socket que se puede hacer mediante un simple sistema o terminal, como se muestra en la Figura 8.2.

169

Con la línea de comando abierto, inicie la versión de línea de comandos de PHP, pasando en el archivo de ejemplo utilizando la opción -f.

$ /path/to/php -f /path/to/socket/sample/simpleSocket.php

FIGURA 8.2 Servidor de socket simple se ejecuta en el símbolo del sistema

Usted notará que el indicador del sistema desaparece y el archivo PHP informes no hay actualizaciones. Esto no puede ser un resultado muy deseable porque nada es lo que le permite saber que el servidor se está ejecutando actualmente. Usted puede agregar una declaración de impresión muy simple a la parte superior del archivo, tales como:

<?php

$host = “127.0.0.1”; $port = “8888”;

set_time_limit(0);

print “Starting Socket Server...\n”;

...

Si detiene e inicia el servidor de sockets debería ver el mensaje impreso, similar a la siguiente:

$ /usr/bin/php -f /path/to/simpleSocket.php Starting Socket Server...

NOTA Si reinicia el servidor de socket a menudo puede ver una advertencia que indique que el puerto está en uso.Puede intentarlo de nuevo o elegir otro puerto para continuar con las pruebas.

170

Cuando el servidor de socket está funcionando correctamente puede abrir un nuevo sistema y tratar de conectar el cliente con el servidor de socket.

$ telnet 127.0.0.1 8888

Después de una conexión, un mensaje similar al siguiente debería aparecer:

$ telnet 127.0.0.1 8888 Trying 127.0.0.1... Connected to localhost. Escape character is ‘^]’.

Esta aplicación sólo acepta un mensaje para ser enviado antes de ser terminado. Si usted escriba nada que no sea "¿Tienes hambre?" (“are you hungry?”), No verá una respuesta, a menos que haya modificado la pregunta que se pide en la aplicación socket.

Aquí está el código completo de este ejemplo:

<?php $host = “127.0.0.1”; $port = “8888”; set_time_limit(0); print “Starting Socket Server...\n”; $sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP); socket_bind($sock, $host, $port); socket_listen($sock, 4); $childSocket = socket_accept($sock); $incomingData = socket_read($childSocket, 2048); if(substr($incomingData, 0, -2) == “are you hungry?”) { $response = “Server Response > I could eat!\n”; socket_write($childSocket, $response, strlen($response));

}socket_close($childSocket); socket_close($sock); ?>

La conexión se termina automáticamente cuando el mensaje se devuelve porque no hay ningún sistema en el lugar para buscar mensajes adicionales. Una aplicación más realista sería suponer algún tipo de bucle en lugar de buscar más de un mensaje.

Crear un persistente servidor socket

El servidor de socket persistentes sería muy similar al del ejemplo anterior, con la excepción de un control de bucle de mensajes nuevos.

Bucles (loops) Recursivos

PHP no ofrece un sistema asíncrono (basado en eventos) como se debería encontrar en ActionScript, pero usted puede crear un bucle para lograr el mismo resultado.

171

Por ejemplo, aquí hay una muy simple bucle while similar a la que se utilizará en el ejemplo de conexión persistente:

x = 0; while(x < 50) { x++; }

Gestionar conexiones múltiples

La clave para permitir a un usuario para enviar más de un mensaje por conexión es envolver el socket_read pide que se encargan de comprobar si hay mensajes nuevos en un bucle.

do { // look for new messages $incomingData = socket_read($childSocket, 2048); if(trim($incomingData) == “are you hungry?”) { $response = “Server Response > I could eat!\n”; socket_write($childSocket, $response, strlen($response)); }else if(trim($incomingData) == “exit”) { $response = “Goodbye!\n”; socket_write($childSocket, $response, strlen($response)); socket_close($childSocket); break; }else { $response = strtoupper(trim($incomingData)) . “\n”; socket_write($childSocket, $response, strlen($response)); } }while(true);

Si prueba el ejemplo, la conexión permanece activa hasta que cierre el sistema o que escriba "exit" cuando se conecta a la aplicación, que informa al servidor de socket para cerrar la conexión. También puede escribir nada, además de " exit " o la pregunta anterior y la respuesta será su entrada en mayúsculas.

Este sencillo ejemplo no tiene soporte para varios clientes, por lo que una vez cerrado el cliente, el servidor termina también. En la segunda parte de este capítulo se construye un completo de sockets basados en multiusuario aplicación de chat que, por definición, permite más de una conexión en un momento.

Ahora debe entender cómo funciona sockets en PHP, así como la forma de aplicar de maneras diferentes, dependiendo de la aplicación. La siguiente parte se explica cómo trabaja los sockets en Flash. Luego, en el capítulo final, se combina Flash y PHP para mandar y recibir información a través de sockets.

172

Trabajar con Sockets en Flash

Flash es considerado el lado del cliente de una conexión de socket. Esto significa que no se puede implementar un servidor de sockets, directamente en Flash, ya que Flash es una aplicación cliente-lado. Ser capaz de usar Flash como un servidor de sockets, si era posible, no sería muy beneficioso debido al hecho de que Flash es una aplicación gráfica. En esencia, sería un desperdicio de recursos a utilizar Flash en un entorno de línea de comandos.

Dicho esto, Flash hace un excelente cliente de servidor de socket. Telnet se utilizó en la sección anterior, que es una manera de inicializar una conexión de cliente a un servidor de socket. Flash permite que las conexiones TCP, que requieren más y más el código de instalación en el principio.

La mayoría del código de conexión en la siguiente sección se puede construir en una clase o una biblioteca común para reducir al mínimo la cantidad de código necesario para crear una conexión de socket.

Inicialización de una conexión socket

La primera parte de la inicialización de una conexión de socket es definir el host y el puerto para conectar.

var host:String = “127.0.0.1”; var port:uint = 8888;

Estas dos variables tendrá que ser el mismo que el código PHP que escribió en la sección anterior.O, si usted está utilizando el código suministrado, puede mantener los valores de la muestra sólo se muestra.

Una vez definidas las variables, crear una instancia de la clase Socket. El constructor de esta clase acepta dos parámetros. El primero es el anfitrión, y el segundo es el puerto para conectar.

var socket:Socket = new Socket(host, port);

A medida que continúe trabajando con las fuentes de datos dinámica, a encontrar rápidamente que los controladores de eventos adecuado que sea más fácil de entender cómo algo que está funcionando. Esto significa que los detectores de eventos añadir al proceso de socket es una buena idea. Iniciar la construcción de las llamadas, y luego crear los controladores de eventos más adelante.

socket.addEventListener(Event.CLOSE, closeHandler); socket.addEventListener(Event.CONNECT, connectHandler); socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); socket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);

Controladores de eventos (Event handlers)

Las funciones de controlador de eventos usado en esta aplicación de ejemplo de seguimiento de los errores a la ventana de salida.

173

Una aplicación más realista consistiría en exigir alguna lógica para manejar estos errores y responder al usuario en consecuencia.

function closeHandler(event:Event):void { trace(“Connection to [“ + host + “] closed”); }function ioErrorHandler(event:IOErrorEvent):void { trace(event.text); }function securityErrorHandler(event:SecurityErrorEvent):void { trace(event.toString()); }

Controladores especiales (Special handlers)

Este ejemplo tiene dos controladores de eventos especiales. El primer controlador de eventos especiales que se llama cuando una conexión es satisfactoria, que le informa que los mensajes pueden ser enviados al servidor de socket. Los mensajes enviados antes de una conexión adecuada se podría dar lugar a errores o mensajes perdidos.

function connectHandler(event:Event):void { trace(“Connected to [“ + host + “]”); }

La función connectHandler es el lugar ninguna llamada al servidor debe ser hecho. Sería un buen lugar para añadir la llamada del mensaje de la muestra, tales como:

function connectHandler(event:Event):void { trace(“Connected to [“ + host + “]”); try { socket.writeUTFBytes((“are you hungry?\n”); }catch(e:IOError) { trace(e); } }

El segundo controlador de eventos especiales se llama cuando una respuesta es totalmente reunidos desde el servidor de socket.Esto se utiliza para garantizar que los mensajes parciales no son evaluados, ya que podría provocar errores de programación que sería difícil hacer un seguimiento.

function socketDataHandler(event:ProgressEvent):void { trace(“Socket Server Response Loaded”);

174

}

Esta es la función en la que todo el código responde debe colocarse, de forma similar a la siguiente:

function socketDataHandler(event:ProgressEvent):void { var str:String = socket.readUTFBytes(socket.bytesAvailable); trace(“Socket Server Response: “ + str); }

Como puede ver, el trabajo con sockets en Flash no es tan diferente de cualquier otro objeto de datos. La consistencia del código a través de diferentes paquetes es un aspecto muy grandes de ActionScript.

Conexión remota de socket

El ejemplo anterior se conecta a un socket local (en la misma máquina), pero es más realista que su aplicación se conecta a un socket remoto. Esto significa que debe configurar una confianza entre el cliente y el servidor que ejecuta el servidor de aplicaciones sockets.

Confianza de seguridad

Un trust (confianza) utiliza el archivo crossdomain.xml con los puertos que están autorizados, tales como:

<?xml version=”1.0”?> <!DOCTYPE cross-domain-policy SYSTEM “http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd”> <cross-domain-policy> <allow-access-from domain=”*” to-ports=”8888” /> </cross-domain-policy>

Este archivo de acceso es que permite a cualquier cliente para conectarse en el puerto 8888 y no otro. También puede definir un dominio si esta aplicación socket sólo será accesible desde otro sitio Web, tales como.

<?xml version=”1.0”?> <!DOCTYPE cross-domain-policy SYSTEM “http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd”> <cross-domain-policy> <allow-access-from domain=”anothersite.com” to-ports=”8888” /> </cross-domain-policy>

La segunda parte de la confianza de seguridad es una llamada a allowDomain en el archivo de Flash. Este método de la clase de seguridad es responsable de definir un dominio que se le permite conectarse a este cliente. Esta conexión sólo se producirá si el sitio remoto tiene un buen archivo de crossdomain.

Security.allowDomain(“example.com”);

Cargar el achivo de política

En raros casos, el archivo de política de dominio no está en la ubicación predeterminada, por lo que una llamada a la loadPolicyFile se puede hacer para informar a Flash donde encontrar el archivo de crossdomain.xml.

Security.loadPolicyFile(“http://example.com/newloc/crossdomain

175

.xml”); Ahora debe saber cómo configurar un cliente basado en conexión de socket en Flash. Como puede ver, la mayoría de los códigos utilizados en una conexión de socket está a cargo de Flash.

Como se señala en el comienzo de esta sección, el código utilizado para crear una conexión de socket pueden ser reutilizados en sus proyectos.

Uso de una clase para conexiones de socket

Para entender mejor las conexiones de socket en Flash, vamos a empezar por ejemplo la construcción de un zócalo de base.Entonces una vez que los fundamentos están en su lugar, la siguiente sección abarcará la construcción de un socket completo de la aplicación de chat basado en la utilización de Flash y PHP.

Calse basica de socket

Esta es una clase básica de socket que fácilmente define los elementos personalizables. Sólo necesitará guardar el código en un archivo de ActionScript con el nombre de SimpleSocket en el mismo directorio que el documento de muestra de Flash.

package {import flash.errors.*; import flash.events.*; import flash.net.Socket; public class SimpleSocket extends Socket { public var host:String; public var port:uint; private var socket:Socket; public static var SOCK_CONNECTED:String = “onSockConnect”; public static var SOCK_IOERROR:String = “onSockIOError”; function SimpleSocket(h:String, p:uint) { host = h; port = p; socket = this; super(host, port); initListeners(); }public function sendMessage(str:String):void { if(connected) { socket.writeUTFBytes(str + “\n”); }else { trace(“Not connected, message not sent!”); } }public function readMessage():void { if(connected) {

176

var str:String = socket.readUTFBytes(socket.bytesAvailable); trace(“Socket Server Response: “ + str); } else { trace(“No message read, not connected!”); } }private function initListeners():void { socket.addEventListener(Event.CLOSE, closeHandler); socket.addEventListener(Event.CONNECT, connectHandler); socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); }private function closeHandler(event:Event):void { trace(“Connection to [“ + host + “] closed”); }private function ioErrorHandler(event:IOErrorEvent):void { dispatchEvent(new Event(SOCK_IOERROR)); }private function connectHandler(event:Event):void { trace(“Connected to [“ + host + “]”); dispatchEvent(new Event(SOCK_CONNECTED)); }private function socketDataHandler(event:ProgressEvent):void { readMessage(); } } } // last two braces are lined up for printing purposes

Usar la clase SimpleSocket

El proceso de utilizar la clase SimpleSocket es bastante simple. Comience por la creación de una nueva película de Flash. Esta película hace una llamada de importación, que es responsable de cargar la clase personalizada.

import SimpleSocket;

var sock:SimpleSocket;

Para crear una conexión de socket, comience por hacer una nueva instancia de la clase SimpleSocket, pasando en el host y el puerto de información para conectarse al servidor socket que desea.

sock = new SimpleSocket(‘127.0.0.1’, 8888);

Cuando se termina la llamada conexión de socket, se le desea asignar a los oyentes a los eventos personalizados.Esta clase simple sólo tiene eventos para una conexión exitosa y otra para cualquier error de conexión.Puede ampliar la clase y agregar más controladores de eventos, según sea necesario.

sock.addEventListener(SimpleSocket.SOCK_CONNECTED, connected);

177

sock.addEventListener(SimpleSocket.SOCK_IOERROR, ioError);El último paso es definir las funciones de controlador de eventos, tales como:

function ioError(e:Event):void { trace(“Can’t connect to “ + sock.host + “ on port “ + sock.port); }function connected(e:Event):void { sock.sendMessage(“are you hungry?”); }

Ahora puede ejecutar la película y debe ver la siguiente salida si se construyó o cargado el código del servidor de zócalo y el servidor se está ejecutando actualmente.

“Connected to [127.0.0.1] Socket Server Response: ARE YOU THERE?”

Esta clase puede ser ampliado para permitir a los requisitos más específicos, pero usted debe tener un conocimiento básico de cómo el sistema de socket trabaja en Flash. En este punto usted también debe saber cómo construir una clase personalizada para manejar la mayoría de la conexión de socket y comunicación de proceso.

La última sección se centra en la construcción de un cliente de chat multiusuario personalizado utilizando la información adquirida en las secciones anteriores.

Crear un cliente de Chat con Sockets Usando Flash y PHP

En las secciones anteriores, usted aprendió cómo construir un simple servidor PHP socket. A continuación, construyó un cliente de Flash básico para comunicarse con el servidor de socket de PHP. En esta sección, se combinan los pasos en una aplicación real. La aplicación que será construido es un cliente de chat multi-usuario que se ejecuta en Flash con un servidor de sockets de PHP para manejar las conexiones.

Esta aplicación de chat multiusuario permite múltiples conexiones de los clientes para hablar entre otros con el administrador de poder enviar mensajes específicos sobre el estado y los detalles de conexión.

Servidor socket PHP para el cliente de chat

La parte de PHP de la aplicación será de dos archivos: el real de la clase de servidor de zócalo y la página que llama a iniciar el servidor de zócalo.

El servidor socket de clase esqueleto parece en el siguiente bloque de código. Como puede ver, la clase Socket tiene muchos métodos. De partirlos en fácil de mantener las partes crearán un mejor producto en el final.

class ChatServer { ... function ChatServer($ip=’192.168.1.110’, $port=8888) {} public function startServer() {} public function stopServer() {} private function initLoop() {}

178

private function createMasterClient() {} private function notifyClient($sockID, $buffer) {} private function notifyClients($clients, $sock, $buffer, $admin) {} private function handleError($str, $err) {} private function endSocket($sockID=null) {} private function serverMessage($str) {} }

Propiedades del Chat

La primera parte para centrarse en la clase son las propiedades, que se encarga de almacenar los mensajes de error diferentes, así como detalles de la conexión.

private $ipAddress = null; private $port = null; private $masterClient = null; private $clients; // Server Messages private static $SOCKET_CREATE_FAIL = “socket_create() failed”; private static $SOCKET_BIND_FAIL = “socket_bind() failed”; private static $SOCKET_LISTEN_FAIL = “socket_listen() failed”; private static $SOCKET_ACCEPT_FAIL = “”; private $LINE_ENDING = “\n”; private static $SHOW_ERRORS = 1; // display errors (0=off, 1=on)

Estos métodos son los establecidos como privado para garantizar que no sea accidentalmente accesible a otros scripts.Puede configurar métodos get y set si decide que desea compartir estas o cualquiera de las propiedades de una clase.

PRECAUCIÓN Tenga cuidado cuando autorice a los métodos y propiedades para ser accesible a nivel mundial. La falta adecuada bloquea estos elementos puede resultar en fallas de seguridad.

El método constructor es responsable de almacenar el host y el puerto de la información. Este método también se crea una nueva matriz que almacenará la información del cliente conectado. Usted se dará cuenta de los valores más comunes en el constructor están predefinidos. Esto significa que, si no de host o puerto se define por la secuencia de comandos llamada se utilizan estos valores por defecto:

function ChatServer($ip=’127.0.0.1’, $port=8888) { $this->ipAddress = $ip; $this->port = $port; $this->clients = array(); }

La siguiente función es llamada por el segundo archivo PHP y es donde la función de servidor maestro, así como la función de sistema de escucha se llaman desde. La función stopServer izquierda está vacío porque el servidor de socket se apaga cuando la relación termina. Usted puede agregar más lógica que podría permitir la desviación a distancia o incluso de cierre en un momento determinado.

public function startServer() { $this->createMasterClient(); $this->initLoop();

179

}public function stopServer() { /* empty */ }

La función de initLoop, que se llama cuando se inicia el servidor, es el núcleo del servidor de socket.Esta función es responsable de la inicialización de nuevas conexiones y la escucha de los mensajes enviados desde las conexiones existentes. Esta función abarca la mayor parte de esta aplicación. Usted va a mirar en partes.

El primer paso de esta función es la de restablecer la variable $socketsChanged que contiene la lista modificada de conexiones de socket.

private function initLoop() { $socketsChanged = null; while(true) { // connection and message loop } }

El contenido del bucle while es donde la mayoría de los clientes y control de mensaje aparece. La función socket_select será responsable de modificar el estado de lectura de un socket de nuevos datos se encuentra, que lo señala, y añade al socket de la matriz de los sockets cambiado para ser doblada a través. Este es usado para limitar el control de los datos en los bucles foreach.

NOTA La función socket_select modifica la matriz. Es una buena idea hacer una primera copia.

... while { $socketsChanged = $this->clients; $write = NULL; $except = NULL; socket_select($socketsChanged, $write, $except, NULL); foreach($socketsChanged as $socket) { ... } }

Se podría ampliar esta funcionalidad a múltiples métodos en la clase, pero es una buena idea guardar todos los códigos pertinentes, junto.

El bucle foreach se ejecuta a través de cada conexión de socket activo. Se comprueba en el servidor maestro y luego se revisan para asegurarse de que existe un cliente activo. Si no hay cliente activo existe el script exits, porque algo ha ido mal y el código no será capaz de continuar.

foreach($socketsChanged as $socket) { if($socket == $this->masterClient) { if (($client = socket_accept($this->masterClient)) < 0) { $this->handleError(ChatServer::SOCKET_ACCEPT_FAIL, ‘’);

180

continue; } else { array_push($this->clients, $client); } }else { ... } }

Si el cliente se ha agregado y la instancia del servidor principal existe, la otra parte del código se ejecute. Esta parte comprueba el búfer de mensaje para un mensaje válido. Si no se encuentra buffer válido, la conexión del cliente finaliza. Esta rutina de limpieza garantiza que los recursos no se están desperdiciando.

Excluyendo el servidor maestro de la comunicación

Suponiendo que un mensaje válido se encuentra, el valor se almacena en una variable de cadena nueva y el servidor maestro se retira de la matriz. Esto se hace para garantizar todos los mensajes o el mantenimiento no se producirá en la conexión principal. Por ejemplo, un mensaje de difusión de informar a los clientes del servicio no es algo que el servidor maestro tiene que recibir.

La función array_shift elimina el primer elemento y rekeys la matriz, básicamente cambiando todos los elementos de uno.

if($socket == $this->masterClient) { ... }else { $buffer = ‘’; // filled by socket_recv (undocumented) $bytes = socket_recv($socket, $buffer, 2048, 0); if($bytes == 0) { $this->endSocket($socket); }else { $allclients = $this->clients; array_shift($allclients); // remove master $specialString = $buffer; }... }

Parametros especiales del chat

Cuando se encuentra un mensaje válido, se comprueba de los parámetros especiales. Esto podría ser un simple petición "exit" o una bandera de administración más avanzada que se utiliza para notificar a los clientes con mensajes de servicio.Los tipos de mensajes especiales son sólo un ejemplo de casos de uso. Usted puede cambiar, agregar o eliminar los mensajes especiales, dependiendo de cómo configurar su cliente de chat.

181

// look for admin beacon if(substr($specialString, 0, 7) == “[admin]”) { $this->notifyClients($allclients, $socket, substr($buffer, 7), true); }

El mensaje "exit" es llamado por un cliente que quiere salir de chat. Si el usuario simplemente cierra la película de Flash, el servidor de socket quita el usuario de la lista en el siguiente bucle paso. Esto le da al usuario una forma de dejar limpio el sistema y ver un mensaje "adiós" (“Goobye”) de que él o ella a salido.

else if(substr($specialString, 0, 4) == “exit”) {$this->serverMessage(“Closing Connection: “ . $socket); $this->notifyClient($socket, “Goodbye”); $this->endSocket($socket); }

A más avanzada aplicación de chat probablemente habría documentación en el sitio Web. Este comando "help" te muestra otra forma de entregar los comandos más utilizados directamente a sus clientes conectados. Usted se dará cuenta de este comando es muy similar al "hombre" de comandos que se encuentra en las terminales UNIX.

else if(substr($specialString, 0, 4) == “help”) { $this->notifyClient($socket, “Chat Help:\n” . “Type exit to leave chat”); }

Si no se encuentra ningún mensaje especial, simplemente transmitir el mensaje sin editar a todos los otros clientes. Este sistema aún se mostrará su comentario a usted. Una aplicación más completa sería necesario establecer para excluir el autor del comentario que no se actualicen.

else { $this->notifyClients($allclients, $socket, $buffer); }

Como puede ver, el método initLoop tiene un montón de responsabilidades y maneja una buena parte de todo el servidor de socket.

Conexión cliente - maestro

El método createMasterClient se llama cuando se inicia el socket de servidor. Este método inicializa el servidor de socket y crea la conexión principal a la que todos los demás clientes se conectan.

private function createMasterClient() { if(($this->masterClient = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)) < 0) { $this->handleError(ChatServer::SOCKET_CREATE_FAIL, $this->masterClient); }

182

Las opciones de socket se establecen para permitir la reutilización de la dirección local, que informa de PHP de sobrescribir la conexión existente está permitido. Usted establece este a false si quiere mantener una relación única.

socket_set_option($this->masterClient, SOL_SOCKET,SO_REUSEADDR, 1);

Antes de la conexión inicial se puede hacer, debe asegurarse de que la dirección está disponible y no en uso por una aplicación existente.

if(($bindRes = socket_bind($this->masterClient, $this->ipAddress, $this->port)) < 0) { $this->handleError(ChatServer::SOCKET_BIND_FAIL, $bindRes); }

Suponiendo que la dirección está disponible, se hace una llamada a socket_listen, lo que hace que el socket listo para recibir peticiones de conexión. Una vez hecha la conexión, el cliente principal es añadido a la matriz del cliente y el proceso de inicialización se ha completado.

if(($ret = socket_listen($this->masterClient, 5)) < 0) { $this->handleError(ChatServer::SOCKET_LISTEN_FAIL, $ret); }$this->clients = array($this->masterClient);

El último paso en el método de createMasterClient es enviar un mensaje de servidor que informa al operador de servidor que un nuevo servidor de chat se ha inicializado. En este ejemplo, el operador es que, por lo que se dará cuenta de una declaración de impresión en el sistema cuando se inicia el servidor.

$this->serverMessage(“Chat Server Started”); }

Notificar a un cliente específico

Hay dos tipos de notificaciones a clientes en esta aplicación de chat. El primer tipo es una notificación mundial y el segundo tipo es para un solo usuario. La sola notificación de usuario es más comúnmente utilizado para enviar mensajes de estado a un cliente.

El único método de usuario acepta dos parámetros que definen el conector específico de identificación y el mensaje a enviar a ese cliente. Un bucle foreach es usado para encontrar el cliente específico, y si la encuentra, una llamada a socket_write que se haga, enviando el mensaje.

private function notifyClient($sockID, $buffer) { foreach($this->clients as $client) { if($client == $sockID) { socket_write($client, $buffer . $this->LINE_ENDING); } } }

183

Notificar a todos los clientes

La notificación global es similar al método de un solo usuario, con la excepción que comprueba si se envía el mensaje ha de ser marcado como un mensaje de administración. La bandera de administrador se puede establecer cuando se hace una llamada a notifyClients. El valor por defecto es falso, asegurando que los mensajes de cliente no pueden ser marcados como provenientes de la administración.

private function notifyClients($clients, $sock, $buffer, $admin) { foreach($clients as $client) { if($admin == true) { socket_write($client, “ADMIN NOTICE: “ . $buffer); }else { socket_write($client, $sock . “ wrote: “ . $buffer); } } }

Controlar errores

Como la aplicación sigue funcionando, está obligada a tener un error o dos. En lugar de tirar estos errores de distancia, es una buena idea para capturarlos y al menos los mostrará en el servidor. Un ejemplo de un controlador de errores de base se puede ver aquí:

private function handleError($str, $err) { if(ChatServer::SHOW_ERRORS) { $this->serverMessage(($str . “: reason: “ . $err) . $this->LINE_ENDING); } }

El método de handleError comprueba primero que los errores deben ser mostradas por el control de la propiedad estática de SHOW_ERRORS, definido en la parte superior del archivo de clase. El passed-in el mensaje de error que se transmite al método serverMessage, que lo imprime.Usted puede llamar al método serverMessage directamente, pero utilizando este sistema de transmisión le permite capturar los errores y mantener el código limpio. No tendría sentido tener la condición de SHOW_ERRORS en serverMessage porque un mensaje no siempre es un error.

Finalizar una conexión

La conexión se termina cuando el cliente cierra el navegador o aplicación. Sin embargo, el usuario también puede cerrar la conexión mediante el envío de los parámetros especiales de "exit". Un método de terminación de conexión se utiliza para garantizar la matriz de conexiones activas está correctamente manejada. Este método también eliminará el maestro de clientes activos, si no existe, en última instancia poner fin a la conexión con el servidor propio zócalo.

184

La función array_search se utiliza para encontrar el socket id de cerrar. Esta función devuelve el id de la matriz. Esto se utiliza para eliminar la conexión de la lista y poner fin a la conexión de socket específico.

private function endSocket($sockID=null) { // close master if no socket is defined if($sockID == null) { $sockID = $this->masterClient; }$index = array_search($sockID, $this->clients); unset($this->clients[$index]); socket_close($sockID); }

Monitoriar servidor

El último método de la clase de chat se utiliza para imprimir los mensajes sobre el servidor directamente al socket activos del sistema, por lo general se ejecutan en el servidor Web para que los clientes estén conectando.

private function serverMessage($str) { print $str . $this->LINE_ENDING; }

Conectar al servidor socket

La conexión al chat de primera clase construido en la sección anterior es manejado por el segundo archivo PHP.Este archivo será el que podríamos llamar cuando quiere iniciar el servidor de chat. La construcción del sistema de esta manera le permite abandonar el chat de clase en su propio y duplicar la conexión sin modificar el código.

Construir el archive de conexion

He aquí un ejemplo de conexión en el dominio localhost, también conocida comúnmente como la dirección de bucle invertido de su máquina o el servidor.

#!/usr/bin/php -q <?php include ‘ChatServer.php’;

La primera línea se utiliza para definir el comando a la terminal. No es necesario, pero no significa que usted puede excluir a los interruptores, en este caso el -q que se utiliza para suprimir la producción de cabecera HTTP, cuando se llama al script PHP. La próxima línea incluye la clase ChatServer, lo que le permite llamar desde ese punto.

Una vez que el archivo se incluye adecuadamente puede hacer un nuevo ejemplo chat, pasar en el host y el puerto que le gustaría comenzar a escuchar. En este ejemplo, la máquina local se utiliza y está enlazado al puerto 8888. El número de puerto no tiene por qué ser la misma, ya que sólo necesita ser abierto. Es una buena idea escoger un número de puerto que no será utilizada por otras aplicaciones en su sistema.

$chatServer = new ChatServer(“127.0.0.1”, 8888);

185

El último paso es iniciar el servidor y permitir que otros se conecten a ella. Para detener el servidor puede cerrar el terminal o pulse Ctrl + C, que en la mayoría de los terminales pondrá fin al proceso activo.

$chatServer->startServer();

Aquí está el código completo de este sencillo test:

#!/usr/bin/php -q <?php include ‘ChatServer.php’; $chatServer = new ChatServer(“127.0.0.1”, 8888); $chatServer->startServer(); ?>

Probar la conexión

Para la prueba simple, puede conectar al servidor de chat utilizando el método de telnet, como se muestra en la Figura 8.3, que se explicó al comienzo del capítulo. Este método representa una gráfica y la limitación de uso, por lo que la próxima sección es el proceso de desarrollo de la aplicación Flash que se conecta a este servidor de sockets de PHP.

FIGURA 8.3 Ejemplo de servidor de chat se ejecuta en el símbolo del sistema

186

Crear el cliente en Flash

El cliente de chat Flash se utiliza para interactuar con el servidor de socket. Esta aplicación cliente se puede usar en forma local o en un sitio web, dependiendo de cómo el servidor de socket está configurado. Para este ejemplo, el código asume que el servidor de socket se ejecuta localmente.

La parte de diseño del cliente de Flash se ha terminado para usted, como se muestra en la Figura 8.4. Este archivo de arranque se encuentra en el sitio Web para este libro, junto con el código de todas las demás secciones.

La primera parte del código de Flash inicializa el host y el puerto de información, que se pasa a una nueva instancia de la clase Socket.



FIGURA 8.4 La aplicación completa, que puede encontrarse en el sitio Web del libro

187

Después de realizada la conexión, asignar los detectores de eventos, que será llamado cuando los nuevos datos se envían o se carga.

socket.addEventListener(Event.CLOSE, closeHandler); socket.addEventListener(Event.CONNECT, connectHandler); socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); socket.addEventListener(ProgressEvent.SOCKET_DATA, sockHandler);

El cliente de chat también necesita los controladores de eventos que serán asignados a la caja de mensajes de texto y botones de entrada de presentación, tales como:

msgTxt.addEventListener(Event.CHANGE, inputHandler);

clearBtn.addEventListener(MouseEvent.CLICK, clearButtonHandler); sendBtn.addEventListener(MouseEvent.CLICK, sendButtonHandler);

El último controlador de eventos se le asignará al teclado para permitir el uso de la tecla Intro para enviar mensajes. Esto no es un paso necesario, pero añade funcionalidad a la aplicación.

addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);

Funciones de control de eventos

Las funciones que se asignan a los controladores de eventos se puede ver en el siguiente código. Como puede ver, estos controladores de eventos tienen la funcionalidad básica para este ejemplo, pero podría ampliarse en una aplicación de mundo más real.

function closeHandler(event:Event):void { statusMessage(“Connection to [“ + host + “] closed”, “#FF0000”); disableInterface(); }function connectHandler(event:Event):void { statusMessage(“Connected to [“ + host + “]”, “#006600”); sendRequest(); }function ioErrorHandler(event:IOErrorEvent):void { statusMessage(event.text, “#FF0000”); }function securityErrorHandler(event:SecurityErrorEvent):void { statusMessage(event.toString(), “#FF0000”); }function sockHandler(event:ProgressEvent):void { readResponse(); }

188

Capturar pulsaciones de teclas

El controlador de eventos claves (Key) tiene un código especial. Esto atrapa caso de que el momento presiona la tecla y el control para ver si es la tecla Enter. Para este ejemplo, la única clave para buscar es Enter. Si usted necesita más de una, se podría definir en una matriz o utilizar un modificador de declaración switch..case.

Si el presionar la tecla Intro, se haga una llamada a dispatchEvent, obligando al hacer clic con el botón "Enviar".

function keyDownHandler(e:KeyboardEvent):void { if(e.keyCode == Keyboard.ENTER) { sendBtn.dispatchEvent(new MouseEvent(MouseEvent.CLICK)); } }

Controlar envoi de mensajes

El controlador de clave hace una llamada al evento, haga clic en el botón "Enviar", que se asigna a la función siguiente. Esta función comprueba la longitud del TextInput msgTxt y, si la longitud es mayor que cero, se prepara el mensaje y se envía.

El último paso de esta función es para desactivar la casilla de mensajes para garantizar el mismo mensaje que no está molesta.Se podría añadir el código de compensación en el controlador de estado. Esta claro que el campo una vez que sabe que el mensaje ha sido enviado. Esto le permite conservar el mensaje y evitar mensajes perdidos debido a fallos en la red.

function sendButtonHandler(e:MouseEvent):void { if(msgTxt.text.length > 0) { writeLine(msgTxt.text); clearBtn.dispatchEvent(new MouseEvent(MouseEvent.CLICK)); } }

Borrar (Clearing) el mensaje de la entrada

La función clearButtonHandler es llamado cada vez que desea borrar el campo de entrada de texto y deshabilitar el botón “Enviar” un mensaje nuevo hasta que se introduzca. Los botones se desactivarán cuando el evento de cambio de envío en la siguiente sección.

function clearButtonHandler(e:MouseEvent):void { msgTxt.text = “”; msgTxt.dispatchEvent(new Event(Event.CHANGE)); }

189

Checking the text input length

Cuando un mensaje nuevo se incluye o el cuadro de entrada se borra, una llamada a un cambio en el cuadro de msgTxt se hace. Este evento es responsable de comprobar la longitud del texto en el cuadro de entrada y activar o desactivar los botones Enviar y borrar, como se muestra en la Figura 8.5, en función del resultado de la verificación de la longitud.

function inputHandler(e:Event):void { if(e.target.text.length > 0) { clearBtn.enabled = true; sendBtn.enabled = true; }else { clearBtn.enabled = false; sendBtn.enabled = false; } }

FIGURA 8.5 Resultados de la aplicación en el estado desactivado

190

Mantener una interfaz estable

Para crear una aplicación estable, la interfaz y los botones están desactivados cuando no hay una conexión actual.

function enableInterface():void { msgTxt.enabled = true; bodyTxt.enabled = true; }function disableInterface():void {

bodyTxt.editable = false; msgTxt.enabled = false; clearBtn.enabled = false; sendBtn.enabled = false; }

Estos habilitan y deshabilitan las funciones son llamadas de otras partes del código, en función del resultado de la conexión activa. Por ejemplo, la función disableInterface se llama desde el closeHandler, que se distribuye cuando se termina una conexión activa.

function closeHandler(event:Event):void { ... disableInterface(); }

Enviar (Sending) la solicitud inicial

La función sendRequest se llama cuando se realiza una conexión. Esta función envía datos a la función de estado y borra toda la información existente en la cola en la conexión del socket.

function sendRequest():void { statusMessage(“Send initial request to [“ + host + “]”, “#006600”); socket.flush(); enableInterface(); }

Envío de mensajes en el servidor de socket

El proceso de hecho envía los mensajes en el servidor de socket se maneja en la función writeLine. Esta función se llama writeLine de la entrada y presentar los controladores, que se definen en la porción anterior del código.

function writeLine(str:String):void { ... }

191

La primera parte de la función es añadir una nueva línea en el mensaje, que puede tener en cuenta es el final del indicador de mensajes en PHP.

str += “\n”;

Esta función también hace uso de los try..catch el estilo de programación para garantizar los errores en el proceso de envío están correctamente capturados y oculta para el usuario. Para simplificar, el error se muestra en la ventana de salida. En una aplicación más realista, usted desearía informar al usuario si el mensaje no fue enviado, así como almacenar el mensaje intenta enviar de nuevo más tarde.

try { socket.writeUTFBytes(str); }catch(e:IOError) { trace(e); }

Controlar actualizaciones de estado

Esta aplicación posee un cuadro de situación, que se utiliza para notificar al usuario de la posible conexión o problemas de mensaje. Todas estas actualizaciones de estado se envían a la función de statusMessage, que las inserta en la casilla de estado y los colores en consecuencia.

function statusMessage(str:String, color:String=”#000000”):void { statusTxt.htmlText += “<font color=\”” + color + “\”>” + str + “</font>”; }

Un color por defecto se aplica en caso de que la persona que llama se olvida de definir uno. La no inclusión de un color predeterminado podría resultar en el texto no se añade.

La última función en esta aplicación basado en socket de chat se llama cuando un nuevo mensaje se recibe desde el servidor de socket.

function readResponse():void {}

La primera parte de esta función recupera el mensaje nuevo de la clase socket y lo asigna a la variable str, que se utiliza en la parte restante de esta función.

var str:String = socket.readUTFBytes(socket.bytesAvailable);

Antes de que el mensaje se pueda visualizar, debe quitar todas las líneas extra nuevo que podría afectar a cómo se muestra el texto. Esto se realiza mediante una función de subcadena muy básicas que devuelve el mensaje de exclusión de los dos últimos caracteres, que en este caso sería "\r\n".

// strip off line feeds if(str.substring((str.length-2), str.length) == “\r\n”)

192

{ trace(“found \\n\\r”);

str = str.substring(0, (str.length-2)); }

Una vez que las nuevas líneas se han eliminado, el siguiente paso es determinar si este mensaje fue enviado por un administrador. Este ejemplo permite a cualquier *usuario* a ser un administrador. En una aplicación más completa, usted quiere exigir a ingresar antes una cuenta de administrador puede ser utilizado. Si el mensaje es de un administrador, el contenido del mensaje son de color rojo, para que los mensajes de administración se resalten.

if(str.substring(0, 12) == “ADMIN NOTICE”) { bodyTxt.htmlText += “<font color=\”#FF0000\”>” + str + “</font>”; }

Si el mensaje es estándar, entonces simplemente se agrega a el área de texto y la función termina, esperando el siguiente mensaje para ser recuperado.

else { bodyTxt.htmlText += “<font color=\”#000000\”>” + str + “</font>”; }

Eso es todo lo que hay a la basada en Flash cliente de chat con un servidor de sockets en PHP. En este punto, usted puede iniciar el servidor de socket (a menos que ya se está ejecutando) y probar el cliente de chat, como se muestra en la Figura 8.6.Siendo que este sistema está pensado para múltiples conexiones, puede llamar a algunos de sus amigos y hacer que lo prueben.

O bien, puede modificar el código para permitir conexiones remotas y dejar a muchos usuarios conectarse mediante el envío de un enlace a la aplicación Flash.

Aquí está el código completo para el cliente de chat de ejemplo:



socket.addEventListener(Event.CLOSE, closeHandler); socket.addEventListener(Event.CONNECT, connectHandler); socket.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler); socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler); socket.addEventListener(ProgressEvent.SOCKET_DATA, sockHandler); msgTxt.addEventListener(Event.CHANGE, inputHandler); addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler); clearBtn.addEventListener(MouseEvent.CLICK, clearButtonHandler); sendBtn.addEventListener(MouseEvent.CLICK, sendButtonHandler);

this.align = StageAlign.TOP_LEFT;

193

this.scaleMode = StageScaleMode.NO_SCALE;

function writeLine(str:String):void { str += “\n”; try { socket.writeUTFBytes(str); }catch(e:IOError) { trace(e); } }

function sendRequest():void { statusMessage(“Send initial request to [“ + host + “]”, “#006600”); socket.flush(); enableInterface(); }

function readResponse():void { var str:String = socket.readUTFBytes(socket.bytesAvailable);

// strip off line feeds if(str.substring((str.length-2), str.length) == “\r\n”) { trace(“found \\n\\r”); str = str.substring(0, (str.length-2)); }

if(str.substring(0, 12) == “ADMIN NOTICE”) { bodyTxt.htmlText += “<font color=\”#FF0000\”>” + str + “</font>”; }else { bodyTxt.htmlText += “<font color=\”#000000\”>” + str + “</font>”; } }

function enableInterface():void { msgTxt.enabled = true; bodyTxt.enabled = true; }function disableInterface():void { bodyTxt.editable = false; msgTxt.enabled = false; clearBtn.enabled = false; sendBtn.enabled = false; }

194

function statusMessage(str:String, color:String=”#000000”):void { statusTxt.htmlText += “<font color=\”” + color + “\”>” + str + “</font>”; }

function clearButtonHandler(e:MouseEvent):void { msgTxt.text = “”; msgTxt.dispatchEvent(new Event(Event.CHANGE)); }

function sendButtonHandler(e:MouseEvent):void { if(msgTxt.text.length > 0) { writeLine(msgTxt.text); clearBtn.dispatchEvent(new MouseEvent(MouseEvent.CLICK)); } }

function inputHandler(e:Event):void { if(e.target.text.length > 0) { clearBtn.enabled = true; sendBtn.enabled = true; } else { clearBtn.enabled = false; sendBtn.enabled = false; } }

function closeHandler(event:Event):void { statusMessage(“Connection to [“ + host + “] closed”, “#FF0000”); disableInterface(); }

function connectHandler(event:Event):void { statusMessage(“Connected to [“ + host + “]”, “#006600”); sendRequest(); }

function ioErrorHandler(event:IOErrorEvent):void { statusMessage(event.text, “#FF0000”); }

function securityErrorHandler(event:SecurityErrorEvent):void { statusMessage(event.toString(), “#FF0000”); }

function sockHandler(event:ProgressEvent):void

195

{ readResponse(); }

function keyDownHandler(e:KeyboardEvent):void { if(e.keyCode == Keyboard.ENTER) { sendBtn.dispatchEvent(new MouseEvent(MouseEvent.CLICK)); } }

// disable interface until connected disableInterface();

FIGURA 8.6 La aplicación Chat se ejecuta en el navegador

196

Resumen

En este capítulo, usted ha aprendido lo que es un servidor de socket y cómo están construidos. A continuación, aprendieron a construir un servidor de socket sencillo y conectarse a él utilizando Flash. Una vez que había una comprensión del Flash y PHP partes del proceso, el paso final es construir una aplicación multiusuario completa de chat con un servidor de sockets en PHP corriendo detrás de las escenas.

Usted puede tomar la información aprendida en este capítulo y ampliarlo para crear una aplicación de chat totalmente funcional. Puede agregar características tales como la moderación, los miembros, temporizadores, salas de chat, y así sucesivamente. Es importante darse cuenta de que los sistemas de servidor de socket no se limitan a las aplicaciones de chat. Usted puede utilizar esta misma tecnología para construir una aplicación de dibujo multiusuario o incluso construir una arquitectura de monitoreo de servidor multipunto.

Como puede ver, sockets de corriente se puede utilizar en una variedad de maneras. Una vez que aprendas lo básico, su imaginación es el único límite a su desarrollo.

197

Parte III

AmpliarFlash y PHP

198

Capitulo 9

Trabajar con Librerias de terceros

El uso de bibliotecas de terceros sigue creciendo a medida que las aplicaciones más exigentes se están desarrollando. Bibliotecas de terceros a menudo a resolver un problema o realizar una tarea común más fáciles de manejar, que permite al desarrollador centrarse en los aspectos más importantes de la aplicación de.

La primera parte de este capítulo está dedicado a explicar qué bibliotecas de terceros son, cómo usarlos, y lo que se necesita para instalar una biblioteca.

La segunda parte de este capítulo se centra en el uso de AMFPHP en Flash.AMFPHP es básicamente una librería PHP que ofrece un vínculo común entre Flash y una base de datos, así como otros tipos de datos.

Repasando librerias de terceros

Una tercera parte es la colección de un paquete personalizado o un pedazo de código que es desarrollado por una compañía u organización a trabajar con el producto de otra compañía. Por ejemplo, si nos fijamos en el navegador Firefox, hay una serie de plug-ins y mejoras que son liberadas por los desarrolladores no trabajadores de Mozilla.

Los desarrolladores tienen distintas opiniones sobre bibliotecas de terceros, una de las preocupaciones más importantes acerca de estas bibliotecas es la seguridad. Tienes que tener cuidado al trabajar con otras porciones de código, especialmente si no tienen el tiempo o los conocimientos para investigar a fondo la forma en que funciona el código.

Los problemas de seguridad son aún más importantes cuando no se conoce a la parte que se desarrolló en la biblioteca o si la biblioteca está en contacto con algún aspecto de seguridad de su aplicación.

Por ejemplo, no es una buena idea usar una cookie o sesión en la biblioteca de un programador desconocido. Si lo hace, puede introducir los agujeros de seguridad en su aplicación.

Hay algunas excepciones notables al trabajar con bibliotecas de terceros y aplicaciones seguras.Por ejemplo, si usted está construyendo una aplicación de tienda, es una suposición razonable de que usted estará interactuando con algún tipo de sistema mercantil, como Authorize.net, Miva, o PayPal.

Estos sistemas ofrecen las bibliotecas de terceros que puede conectarse fácilmente a su solicitud y se sabe que son seguros porque se han probado completamente en diferentes entornos.

199

Otros tipos de librerias de terceros

Estas bibliotecas externas no se limitan a la seguridad o la manipulación de datos. Esto se debe al hecho de que Flash es un programa de diseño también. Hay muchos y excelentes bibliotecas de terceros disponibles para acelerar el desarrollo y el proceso de diseño.

En algunos casos, estas librerías externas proporcionan una funcionalidad que no es posible, directamente en Flash/ActionScript.

Librerias comerciales Flash

Hay algunas bibliotecas que se está construyendo tienen licencias comerciales, lo que significa que tienen el código más extensamente desarrollado. Usted no tendrá ningún problema para obtener soporte para estas bibliotecas.

Por ejemplo, gskinner.com tiene una robusta biblioteca de verificación y conjunto de componentes que está disponible para su compra. Esta biblioteca le permite construir en tiempo real un motor de corrección ortográfico en su aplicación con sólo unas pocas líneas de código. Usted puede encontrar más información acerca de la biblioteca gskinner el corrector ortográfico en el sitio Web de la empresa en www.gskinner.com/products/spl/.

Librerias Flash de código abierto

Usted también encontrará una amplia selección de las bibliotecas de código abierto libre para todos los aspectos del desarrollo y despliegue de aplicaciones. Un ejemplo de una biblioteca de código abierto es AMFPHP, que se examina en detalle en la sección "Echando un vistazo a AMFPHP".

Hay muchas otras bibliotecas de código abierto disponibles, como MCtweener, que es similar a la biblioteca de Tween incluido con mayor funcionalidad. Además, la documentación del proyecto contiene una gran cantidad de código de ejemplo.

Algunas otras bibliotecas de código abierto disponible para ayudar en su proceso de desarrollo se muestran en la tabla 9.1.

TABLA 9.1 Librerias de código abierto

Red5 Open Source Flash Server http://osflash.org/red5 Papervision3D Open Source 3D engine http://code.google.com/p/papervision3d/ as3corelib AS3 library for several http://code.google.com/p/as3corelib/ basic utilities

Esta es sólo una pequeña porción de la línea completa de las bibliotecas de código abierto disponible para ActionScript 3. Se le debería dar una buena idea de no sólo cómo ampliable ActionScript 3, sino también a los desarrolladores de cómo muchos han pasado largas horas en desarrollo de estas herramientas impresionante. Aún más sorprendente es el hecho de que estas bibliotecas son gratuitos, lo que significa que

200

http://www.gskinner.com/products/spl/

los desarrolladores más, incluido usted, puede crear contenido más interesante y atractivo, sin costes adicionales.

Librerias en PHP

Hay también muchas bibliotecas disponibles para PHP, que incluyen la gestión de sesiones, la manipulación de la imagen, conectividad de bases de datos, y la gestión de servidores en general para nombrar unos pocos. Básicamente, PHP se construye utilizando bibliotecas de terceros ya que PHP en sí mismo es un proyecto de código abierto. Esto significa que muchos desarrolladores de diferentes contribuir con código al proyecto.

Algunas de las bibliotecas más comunes de PHP incluye la librería GD, que se discute el capítulo 12.Tabla 9.2 Las otras listas comunes de las bibliotecas de PHP que va a utilizar en su proceso de desarrollo.

TABLA 9.2 Common PHP Libraries

Librería Descripción Source .Pear Una librería estructurada de http://pear.php.net/ código opensource ImageMagick Suite de software para crear, editar, www.imagemagick.org/ y componer imagenes de mapa de bitsPDF Library Librería de creación PDF para PHP www.php.net/pdf

Instalar librerias de terceros

Ahora debe tener una comprensión de lo bibliotecas de terceros están disponibles para su uso en el desarrollo de ActionScript 3.

El proceso de instalación de estas bibliotecas de terceros es muy similar, no importa qué biblioteca es.

NOTA Compruebe los requisitos de la versión de las bibliotecas para asegurarse de que trabajará con ActionScript 3 o la versión de PHP que se esté utilizando.

Instalar librerias en Flash CS3

Después de seleccionar las bibliotecas de terceros que desea utilizar, el siguiente paso es la instalación de estos. El proceso de instalación de una biblioteca de código en CS3 depende de la clase específica.

Instalar como un archivo MXP

Una forma de una biblioteca o un conjunto de componentes puede ser distribuido para la portabilidad es en el formato MXP. Estos archivos se cargan en el Extension Manager que se incluye con Flash CS3 y muchas otras aplicaciones de Adobe (ver Figura 9.1).

La ventaja de usar esta aplicación es incluir sus librerías para gestionar y se puede activar, desactivar o actualizar las librerías individuales en un agradable interfaz gráfica de usuario manejable. Esta aplicación también contiene enlaces directos al sitio Web del desarrollador de apoyo o de documentación en línea.

201

FIGURA 9.1 Extensión de los buques Manager con Flash CS3 y otras aplicaciones de Adobe.

Instalar como un paquete de clase estándar

El otro método de instalación más común es añadir manualmente las clases a la ruta de clases de Flash CS3. También necesita copiar la clase de archivos en los directorios de intercambio de que Flash sabe que buscar en las bibliotecas de terceros.

Es una buena idea crear una nueva carpeta en una parte separada de su equipo para que accidentalmente no modificar las clases por defecto que vienen con Flash CS3.

Crear una ruta de clases personalizadas

Con el fin de agregar una ruta de clase personalizado, primero debe crear un directorio en su computadora para almacenar sus clases. Después de determinar que el directorio que va a utilizar, añadir esta nueva ruta de acceso a la ruta de listas de clases existentes.

Para añadir una nueva ruta de clases a la lista existente, siga estos pasos:

1. Seleccione EditarPreferencias (Windows). En un Mac, selecciona FlashPreferencias para abrir el cuadro de diálogo Preferencias. 2. Haga clic en ActionScript en la lista Categoría y, a continuación, haga clic en Configuración de ActionScript 3.0.

202

3. Haga clic en Examinar con el Path, y busque el directorio que desee agregar. Haga clic en Aceptar.

Usted también puede agregar una ruta de clase para el proyecto específico de Flash mediante la modificación de la configuración de ActionScript en el cuadro de diálogo Configuración de publicación. Agregar la ruta de clase a un proyecto tiene la ventaja de que se moverá con la FLA, que significa que este archivo puede ser compartida y la rutas de clases global no deben ser modificados.

Ruta de clases (classpaths) por defecto

La ruta de clases por defecto de todos los documentos de Flash puede ser modificado para que no tenga que actualizar cada archivo Flash individuales. Los siguientes son los lugares donde Flash espera encontrar los archivos de clases, basada en una instalación por defecto. Windows: Disco duro\Documents and Settings\user\Local Settings\Application Data\Adobe\Adobe Flash CS3\language\Configuration\Classes.

Macintosh: Disco duro/Users/user/Library/Application Support/Adobe/Adobe Flash CS3/language/Configuration/Classes.

NOTA No elimine la ruta de clases global absoluta. Flash utiliza esta ruta de clases de acceso integrado en las clases. Si elimina esta ruta de clases puede volver a agregar mediante el siguiente trozo de código como una ruta nueva de clase: $(LocalData)/Classes.

Instalar librerias en PHP

Bibliotecas de PHP se han compilado directamente en el proceso de instalación de PHP. Sin embargo, con el uso de PEAR y otros sistemas comunes de biblioteca estructurado, puede instalar nuevas bibliotecas tras la instalación inicial que ha completado.

Un ejemplo de una biblioteca externa que se utiliza comúnmente y se puede agregar después de instalar PHP es la biblioteca de MySQL. Esta biblioteca se utiliza para comunicarse con una base de datos directamente en PHP.

El primer paso es abrir el archivo php.ini, elimine el archivo de biblioteca de mysql, y modificar la ubicación de la ruta de MySQL y el conector de puerto si elige otro diferente cuando se instala MySQL.

NOTA Es necesario reiniciar el servidor Apache después de modificar el archivo php.ini. Si una vez que reinicie Apache, MySQL y todavía no está funcionando adecuadamente, entonces usted puede tener una versión antigua instalada. Esto significa que usted puede tener que volver a compilar PHP.

CROSS--REF Para obtener información acerca de volver a compilar PHP, véase el Capítulo 1.

Uso de librerias de terceros

El primer paso para trabajar con bibliotecas de terceros es descargar los archivos de biblioteca en el sitio web del desarrollador. Una vez que haya descargado los archivos de biblioteca de clases, el siguiente paso es instalar y configurar la librería de terceros.

Normalmente, la biblioteca viene con un kit de prueba para asegurarse de que todo está funcionando correctamente. Este paso no es obligatorio, pero minimiza la depuración necesaria en su aplicación final.

203

Si la biblioteca no viene con un kit de prueba, usted puede crear rápidamente una, que se explica en la siguiente sección.

Trabajar con librerias en Flash CS3

Para determinar si las clases se carga correctamente, puede crear una aplicación de prueba de una parte específica de una clase que figura en la librería.

Para este ejemplo, se utiliza la biblioteca as3CoreLib de Adobe. Esta clase contiene una serie de clases de utilidad para todo, incluyendo la manipulación de imágenes todo el camino a la seguridad tales como herramientas de creación de valor hash MD5.

Aquí está un ejemplo de aplicación utilizando la funcionalidad de MD5:

import com.adobe.crypto.MD5;

function createHash(e:MouseEvent):void {

responseTxt.text = MD5.hash(origStrTxt.text);

}

createBtn.addEventListener(MouseEvent.CLICK, createHash);

La primera parte de esta aplicación importa las clases necesarias. En este ejemplo, que sería la clase MD5 en el paquete de cifrado.

La función se llama cuando se pulsa el botón. Una vez que se llama la función, el siguiente paso es crear un hash de nuevo llamando al método hash estático de la clase MD5. Por último, la cadena de nueva creación se devuelve al componente TextInput responseTxt encontrada en la escena.

Esa es la aplicación completa. Se trata de un uso muy simple, pero le informa cuando las clases adecuadas están instaladas y funcionan correctamente.

Trabajan en este tipo de unidad es muy común en el desarrollo porque si una aplicación se hace demasiado grande es mucho más difícil de depurar y gestionar.

Trabajar con librerias en PHP

Bibliotecas en PHP son muy similares a las porciones compiladas de PHP, pero aún debe probar que después de instalar una nueva biblioteca. Normalmente, también tendrá que reiniciar Apache para que los nuevos cambios de PHP para tener efecto. Muchas veces las instrucciones de instalación de una biblioteca se habla de esto, pero en cualquier caso hay que hacer.

Probar la librería MySQL

Para la prueba de apoyo de MySQL usted no tiene que crear un ejemplo elaborado, de hecho, puede crear un script que garantiza que no funciona bien, pero le informará si MySQL se ha instalado correctamente o no.

204

Esto no es una práctica muy común, pero en el interés de la prueba rápida funciona muy bien.

NOTA Después de ejecutar el código que usted sabe que va a fallar es una buena idea para limpiar los registros de errores para que no se confunda más adelante en el camino. Aquí está el código de la prueba simple.

<?php

// no password is sure to fail, // unless it is a default installation

mysql_connect(“localhost”, “root”, “”);

?>

Los intentos de sencilla aplicación para conectarse a la base de datos, y si se muestran de usuario no válido o la base de datos no seleccionada entonces usted sabe MySQL está instalado correctamente.

Sin embargo, si usted ve un error grave: función no encontrado ... significa que MySQL no ha sido adecuadamente configurado o instalado para trabajar con PHP.

Usted puede crear un archivos phpinfo rápida para determinar si MySQL se ha instalado y para rastrear el error específico.

Instalar la librería de MySQL

La biblioteca de MySQL se incluye normalmente con PHP, pero no viene activado por defecto. El primer paso es abrir el archivo php.ini para la versión de PHP que tiene instalado.

Usted encontrará una sección en el archivo php.ini con el título de “[mysql]”.Aquí es donde debe configurar la instalación de MySQL.

Una vez finalizada la configuración, el siguiente paso es eliminar la línea en la lista de bibliotecas que tiene el nombre "mysql" dentro de ella.

En este punto, la configuración se ha completado, el último paso es reiniciar Apache y probar el script anterior, una vez más, que debería mostrar un error de conexión y no el error fatal de PHP.

Echando un vistazo a AMFPHP

AMFPHP es una implementación de código abierto de la Action Message Format (AMF). AMF permite la serialización binaria de objetos de ActionScript para ser enviados al servidor de secuencias de comandos.

AMFPHP para desarrolladores de AS3 y PHP

Los desarrolladores de PHP pueden aprovechar su experiencia en PHP mediante la conexión a datos, tales como servicios Web y bases de datos. AMF permite tipos de datos nativos y la cartografía de objeto complejo entre el cliente y el servidor. AMFPHP es una de las más populares y de más rápido servidor de los protocolos de cliente de comunicación disponibles para los desarrolladores de Flash Player. Comunicación se organiza en formato binario, que generalmente es más compacta que otras representaciones.

205

AMFPHP y ActionScript 3

ActionScript 3 permite la compresión de las comunicaciones, lo que significa la salida más rápida de las llamadas y, en general un mejor rendimiento. Además, AMF3, que está disponible en ActionScript 3, también comprime la comunicación binaria para un mayor rendimiento.

Instalar AMFPHP

Instalación de AMFPHP es simple. Las secuencias de comandos requiere un servidor PHP y no necesitan los servicios adicionales o de las bibliotecas instaladas. Esto ofrece la ventaja de la configuración de casi instantánea, que permite al desarrollador a concentrarse en la aplicación real en lugar de preocuparse por lo que está ocurriendo detrás de las escenas.

Para instalar AMFPHP, primero descarga la última versión, que está disponible gratuitamente desde el sitio web SourceForge en http://sourceforge.net/project/showfiles.php?group_id=72483#files.SourceForge es la mayor Web de código abierto de desarrollo del sitio Web que aloja una serie de diferentes proyectos como AMFPHP.

El contenido de los archivos descargados se colocan en la raíz de su servidor Web en un nuevo directorio como flashservices o cualquier nombre que elija.

AMFPHP está casi listo para ir a la derecha de la caja. El único archivo que debe modificar es gateway.php, que se encuentra en la raíz del directorio de instalación. En este caso, el camino sería flashservices/gateway.php. En algunos casos, puede dejar todos los ajustes en el valor predeterminado, que es lo que se utiliza para este ejemplo.

Probar la instalación

Cuando todo está correctamente instalado, usted puede probar la instalación de AMFPHP mediante la apertura de la gateway.php en su navegador Web. Por ejemplo, suponiendo que la instalación se realiza a nivel local, la URL sería http://localhost/flashservices/gateway.php.

Una pantalla, como se muestra en la Figura 9.2, debe aparecer que le informa de que la instalación se realizó correctamente. Si ocurre un error, un error de PHP o una serie de errores, parece que le ayudará a determinar lo que posiblemente fue mal.

Herramientas de depuración AMFPHP

Antes de comenzar cualquier desarrollo, vistazo a alguna depuración y herramientas de visualización que se suministran con AMFPHP. Estas distintas herramientas se puede utilizar para depurar sus servicios.

PRECAUCIÓN Asegúrese de quitar estas herramientas de depuración en un servidor en vivo para reducir al mínimo los problemas de seguridad.

206

http://localhost/flashservices/gateway.php

FIGURA 9.2 Ejemplo del mensaje de bienvenida AMFPHP visto desde gateway.php llamando desde tu navegador Web

Navegador de servicios AMFPHP

El navegador de servicio AMFPHP, como se muestra en la Figura 9.3, es una aplicación basada en Flash que te permite ver los distintos servicios y examinar de cerca sus métodos y propiedades. También puede utilizar el navegador de servicio para probar el nuevo código antes de escribir el código ActionScript en Flash.

Usando estas herramientas de depuración añadidas le permite desarrollar aplicaciones más rápidamente y prueba de nuevos conceptos, con menos sobrecarga. También ayudan en la depuración de su código.

Depurar gateway de AMFPHP

La depuración de Gateway es script que se encuentra entre Flash y el gateway.php archivo para envolver errores. Es una buena práctica de utilizar esta secuencia de comandos durante la depuración o el desarrollo a nivel local. El único cambio en su código es para señalar a la debuggateway.php archivo en lugar de la gateway.php archivo estándar.

207

FIGURA 9.3 He aquí un ejemplo de servicio, visto desde el servicio de navegador de AMFPHP.

Los siguientes son algunos puntos importantes a tener en cuenta con el uso de este portal especializado:

Las sesiones no funcionarán correctamente. cURL deben estár habilitadas en PHP. El servidor experimenta un descenso en el rendimiento. Sólo se debe utilizar en un sistema de desarrollo.

Probar AMFPHP con un servicio personalizado

Con AMFPHP correctamente instalado, puede probar un servicio muy sencillo con el navegador de servicios.Más tarde, a construir una pequeña aplicación de búsqueda en Flash y PHP.

Un servicio de AMFPHP es un archivo estándar de PHP que se construye en un orden conocido. Por ejemplo, la primera parte de un archivo de servicio es la tabla de métodos, que se utiliza para exponer los métodos disponibles y definir las restricciones de acceso de ese servicio.

208

Un cuadro de métodos es una matriz multidimensional que contiene cada uno de los métodos. En esta tabla se define el método de muestreo del método getDate, que devuelve el timestamp UNIX actual de PHP. La tabla de métodos se encuentra en el constructor de la clase visto en la parte siguiente de código.

$this->methodTable = array ( “getDate” => array ( “access” => “remote”, “description” => “Example, returns Unix timestamp” ) );

Siguiendo con este ejemplo, crearía la muestra de clase PHP, que se convertirá en el servicio de AMFPHP. Esta es la clase de muestra, que contiene un método y el constructor.

<?php class Example { function Example() { $this->methodTable = array ( “getDate” => array ( “access” => “remote”, “description” => “Returns the current date.” )

); }/** * Returns Current Date */ function getDate() { // return current date return “Current Date: “ . date(“F j, Y”, time()); } }?>

NOTA El comentario sobre la función getDate será visto por el servicio de navegador y lo mostrará a continuación el método. Esto no es necesario, pero ayuda a entender lo que es un servicio no de un vistazo.

Guardar este archivo como Example.php en el directorio /services que se encuentran en la raíz del directorio de AMFPHP.

Aquí está la ubicación de este archivo si instala AMFPHP en la raíz de su servidor Web: http://localhost/flashservices/services/Example.php.

Ahora que este servicio simple se crea que puede probar yendo al navegador de servicio. Usted podrá ver su nuevo servicio, ubicado en la lista del lado izquierdo junto con otros servicios ya instalados. Si usted no ve el servicio, haga clic en Actualizar o volver a cargar la página mediante la actualización de su navegador.

209

Para probar el servicio, haga clic en el nombre en la lista del lado izquierdo, que carga el servicio en el panel de exploración a la derecha. El nombre del método se encuentra en la ficha de prueba, que en este ejemplo se denomina getDate. Haga clic en el botón de Call (llamada) para ejecutar el servicio. Verá la salida de los servicios en la ficha Resultados se encuentra en la parte inferior del panel de exploración.

La salida del servicio del ejemplo debe ser la fecha actual en formato de cadena, tales como.

“Current Date: October 5, 2007”

Las otras pestañas son para ver los datos de servicio, que se utiliza para la depuración y el seguimiento general de sus servicios.

Este ejemplo es bastante simple. No tiene parámetros y no crea ningún código real. Usted puede ampliar en el servicio anterior mediante la adición de otro método, que capitaliza la primera letra de cada palabra en la cadena. La parte de la capitalización del código se hace usando una función integrada de PHP llamada ucwords. Esta función acepta un parámetro y devuelve la cadena en mayúsculas.

<?php

class Example {

function Example() {

$this->methodTable = array ( “getDate” => array ( “access” => “remote”, “description” => “Returns the current date.” ),

“upperCaseWords” => array ( “access” => “remote”, “description” => “Converts arg to uppercase” ) ); }

/** * Returns Current Date */ function getDate() { // return current date return “Current Date: “ . date(“F j, Y”, time()); }

function upperCaseWords($str) { return ucwords($str); }

210

}

?>

Después de que el nuevo método se añade que es visible en el navegador de servicio (después de una actualización). Después de buscar en el navegador de servicio, usted se dará cuenta de una ventaja del método es que el cuadro AMFPHP agrega automáticamente cuadros de texto con el nombre de la variable para cada argumento encontrado.

El nuevo método acepta un argumento tal como se define en el código de servicio. Si escribe algún texto en el cuadro de texto y ejecutar el método, se capitaliza la cadena.

Por ejemplo, si utiliza la cadena "hello world", verá la salida del siguiente:

“Hello World”

Servicios de AMFPHP puede, por supuesto, tienen más de un argumento en un método. Crear otro nuevo método que tiene tres argumentos. El primer argumento es una cadena, el segundo una palabra a buscar, y la tercera es la palabra de sustitución. Básicamente, usted está creando una búsqueda basada en PHP y reemplazar el método.

Comience por la actualización de la tabla de métodos.

$this->methodTable = array ( “getDate” => array ( “access” => “remote”, “description” => “Returns the current date.” ), “upperCaseWords” => array ( “access” => “remote”, “description” => “Converts arg to uppercase” ), “searchAndReplace” => array ( “access” => “remote”, “description” => “Searches and replaces text” ) );

Cuando se actualiza la tabla de métodos, se añade el nuevo método. Usted no está limitado al código en el método. AMFPHP le permite llamar a otros métodos y propiedades de la misma clase o incluso incluir otros ficheros PHP para mayor funcionalidad.

/** * Searches and replaces text */ function searchAndReplace($haystack, $needle, $replacement) { $string = str_replace($needle, $replacement, $haystack); return $this->upperCaseWords($string); }

211

NOTA Si crea un nuevo método, y no se añade en la tabla de métodos, no va a ser exportados para su remota. Esto es útil cuando se quiere disponer de métodos privados, tales como conectividad de bases de datos, o capas de seguridad global.

Después de que el nuevo método, se añade, se puede comprobar por actualización del navegador de servicios. Notificación de los métodos que se enumeran en orden alfabético. El nuevo método se encuentra en la mitad de la lista horizontal.

El navegador de servicio agrega un campo de texto para cada argumento, en este caso hay tres. Escriba una cadena en el primer campo de texto, elija una de las palabras de esa cadena como la aguja, a continuación, que entrará en la segunda TextField. Por último, el tipo de reemplazo en el campo de texto de terceros. Después de los tres campos de texto se rellenan, puede hacer clic en el botón de llamada y ver el resultado en la ficha Resultados.

Suponiendo que se utilice la cadena "hola mundo" con la aguja de "mundo" y la sustitución de la "tierra", debería ver el siguiente resultado. La palabra es reemplazada y la primera letra de cada palabra en mayúsculas utilizando el método de upperCaseWords.

“Hello Earth”

Ahora que ha probado a fondo los servicios de AMFPHP, puede pasar a la instalación de las clases necesarias requeridas para Flash para realmente ser capaz de hacer uso de esta instalación. Ese proceso se explica en la siguiente sección.

Uso de AMFPHP en Flash

A diferencia de versiones anteriores, ActionScript 3 tiene todas las clases necesarias para la interacción remota e interactuar con AMFPHP ya instalado. Simplemente cargue las clases y escribir en el código ActionScript, que es todo bastante sencillo. Esta sección le guía a través del proceso de construcción de una aplicación Flash simple para entender mejor el proceso de trabajo con AMFPHP en Flash.

Cargar clases remoting

El primer paso para trabajar con AMFPHP en Flash es para cargar las clases.Esto es necesario para cualquier proyecto AMFPHP a construir, ya que contiene el núcleo del sistema remoto.

import flash.net.*;

When the classes are loaded, you can define a variable that points to the AMFPHP gateway file.

var gatewayURL:String = “http://localhost/flashservices/gateway.php”;

El siguiente paso es crear la instancia de NetConnection, que se asigna a la variable de puerta de enlace. En este punto, también puede configurar el método de los acontecimientos que se llama cuando se hace clic en un botón.

var gateway:NetConnection;

getDateBtn.addEventListener(MouseEvent.CLICK, getDate);

212

searcBtn.addEventListener(MouseEvent.CLICK, searchAndReplace); upperCaseWordsBtn.addEventListener(MouseEvent.CLICK, upperCaseWords); debugTxt.wordWrap = false;

Aquí está el esqueleto de los controladores de botón que se creará en la parte siguiente. Cada una de estas funciones hace una llamada al servicio de AMFPHP.

function getDate(e:MouseEvent):void { ... }

function searchAndReplace(e:MouseEvent):void { ... }

function upperCaseWords(e:MouseEvent):void { ... }

El primer método en el cual concentrarse es getDate, que hará una llamada al servidor sin argumentos y recibe una cadena de la fecha actual. Responder a la clase se utiliza para controlar la respuesta de objeto para el éxito y el fracaso tanto de la llama.

var responder:Responder = new Responder(onResult, onFault);

La siguiente parte de la función asigna una nueva instancia de la clase NetConnection. Una llamada al método connect se llama paso en la puerta de entrada variable url. Una vez establecida la conexión, se realiza una llamada cuando el primer argumento es el nombre del servicio y el método. La segunda variable es una referencia a la instancia de clase Responder.

gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Example.getDate”, responder);

Esta es la función getDate completo la responsabilidad de establecer la conexión AMFPHP y llamando al servicio solicitado.

function getDate(e:MouseEvent):void { var responder:Responder = new Responder(onResult, onFault); gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Example.getDate”, responder); }

Las otras dos funciones son muy similares, con excepción del nombre del método y los argumentos pasados al servicio.

La función searchAndReplace acepta tres argumentos.

arg1: La cadena (string) a buscar en

213

arg2: La palabra para buscar arg3: La palabra a remplazar

El servicio ubicado en la configuración de AMFPHP es responsable de ejecutar el método searchAndReplace, pero también hace una llamada al método de mayúsculas antes de regresar a la cadena.

function searchAndReplace(e:MouseEvent):void { var responder:Responder = new Responder(onResult, onFault);

gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Example.searchAndReplace”, responder, “hello world”, “world”, “earth” ); }

La función final es upperCaseWords, que tiene un argumento y devuelve una nueva cadena con la primera letra de cada palabra en mayúsculas. El resto de la función es la misma que las dos anteriores. Este es un buen ejemplo de AMFPHP ser capaz de lograr algo que no es nativo de ActionScript, que, por supuesto, es la parte en mayúsculas.

function upperCaseWords(e:MouseEvent):void { var responder:Responder = new Responder(onResult, onFault);

gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Example.upperCaseWords”, responder, “hello world”); }

Una vez que las tres funciones de responsable de llamar a los servicios que están definidos, la siguiente parte es el resultado de la depuración y funciones que son llamadas cuando el servicio devuelve una respuesta válida.

La función onResult se llama cuando se recibe un mensaje de éxito. En este sencillo ejemplo, el contenido en bruto de la producción son enviados a la componente TextArea situado en el escenario. También puede reemplazar la porción de TextArea del código con simples trace() para los estados más rápidode la prueba.

function onResult(responds:Object):void {

debugTxt.text = “Response: “ + responds;

}

Si ocurre un error, la función onFault se llama, que contiene el error específico. Para ver mejor el error, el contenido del objeto se ejecutan a través de una bucle for..in, que muestra cada elemento.Esta función también borra el área de texto para asegurar que los datos anteriores no se mezclen en el que podría causar confusión al tratar de depurar una aplicación.

214

El método de appendText AS3 es la sustitución de la forma "+ =" de la concatenación de cadenas en las versiones anteriores de ActionScript. Este método es mucho más rápido, lo que significa más rápida ejecución de código.

function onFault(responds:Object):void {

debugTxt.text = “”; debugTxt.appendText(“Debug::Error\n”); for(var i in responds) { debugTxt.appendText(“ “ + responds[i] + “\n”); }

}

Figuras 9.4, 9.5, y 9.6 muestran ejemplos de las respuestas de las aplicaciones de muestra dentro de AMFPHP. Usted puede ampliar en estos ejemplos para construir una aplicación más completa, que se realiza en la siguiente sección.

El primer ejemplo se muestra la respuesta del método getDate de las clases de la muestra AMFPHP. Este ejemplo devolverá la fecha actual en el formato de cadenas.

FIGURA 9.4 Aquí hay una respuesta del ejemplo a partir del primer método AMFPHP servicio.

215

El segundo ejemplo acepta un argumento y reemplaza el texto. Todo esto es un ejemplo sencillo, mostrando el proceso de trabajo con los argumentos en AMFPHP.

FIGURA 9.5 Aquí hay una respuesta del ejemplo a partir del segundo método AMFPHP servicio.

216

El tercer y último ejemplo es una respuesta de carbono. Básicamente se toma la cadena passed-in y devuelve exactamente como fue enviado.

FIGURA 9.6 Aquí hay una respuesta del ejemplo a partir del tercer método AMFPHP servicio.

217

Construir una aplicación del mundo real usando AMFPHP

Ahora que ha visto el uso del servicio AMFPHP y cómo aplicarla en Flash, se puede continuar la construcción de una aplicación real. Un buen ejemplo de una aplicación en el mundo real es un Flash de aplicaciones basadas en lista de álbumes, que se explica en las siguientes secciones.

La base de datos utilizada para este ejemplo es la misma que se crea en el capítulo 2. Si usted no ha completado el capítulo para este punto, recomiendo empezar por ahí.

Servicios de AMFPHP

Los servicios de AMFPHP necesarios para este ejemplo es responsable de consultar la base de datos basada en los argumentos passed-in. Esto también requiere un sistema de conexión de base de datos que deben ser seguras.Esto significa que los métodos no serán exportables o visible por AMFPHP.

218

Para simplificar, toda esta funcionalidad se incluye en uno de servicios. Sin embargo, en una aplicación más completa, usted desea separar las clases en los diferentes servicios de una solución más portátil.Figura 9.7 muestra la aplicación completa.

FIGURA 9.7 Aquí está la aplicación completa del ejemplo del mundo real.

La primera parte de la aplicación son los servicios de AMFPHP. Aquí está el esqueleto de clase para el servicio de álbum, que le da una mejor comprensión de la funcionalidad.

<?php

class Albums {

function Albums() { ... }

function connect() { ... }

function getAlbumByGenreID($genreID) {

219

... } }

?> El comienzo de cualquier proyecto AMFPHP debe ser la tabla de métodos ya sea incluido en el archivo de un mismo servicio o en un archivo separado que se incluye. La ventaja de usar el mismo archivo se puede crear rápidamente los cambios y no tienen que mantener un archivo diferente.

La tabla de método en este ejemplo se incluye en la función constructora de servicios. El método de conexión es privado para garantizar un mayor nivel de seguridad.

function Albums() {

$this->methodTable = array ( “connect” => array ( “access” => “private” ), “getAlbumByGenreID” => array ( “access” => “remote” ) );

}

El método de conexión comprueba en primer lugar para una conexión existente de limitar los recursos. Si una conexión existente no se encuentra, una nueva se crea y almacena en la variable privada _connection.

/** * @access private * @desc Connect to database - **PRIVATE** */ function connect() {

if($this->_connection == null) { $this->_connection = mysql_connect( $this->dbHost, $this->dbUser, $this->dbPass ); mysql_select_db($this->dbName, $this->_connection); }

}

Los parámetros de conexión se almacenan en las variables privadas dentro de la clase. Para un nivel adicional de seguridad, las variables se hizo privado a prohibir el acceso exterior de la base de datos de las credenciales sensibles.

220

// Database info private $dbHost = “localhost”; private $dbUser = “username”; private $dbPass = “password”; private $dbName = “database name”;

private $_connection = null;

El último método de la clase de servicio es la getAlbumByGenreID, que devuelve una matriz de datos de disco basado en el género ID pasa como un único argumento. La parte de la función establece una conexión con la base de datos con el sector privado método connect() definido en el paso anterior.

function getAlbumCatID($genreID) { $this->connect(); ... }

Una vez establecida la conexión de base de datos, el siguiente paso es la construcción de la cadena $sql.

$sql = “SELECT g.name, a.artist, a.albumName FROM albums a, genre g WHERE a.genreID=g.id AND g.id=” . $genreID;

La cadena $sql se pasa a mysql_query() con la conexión de base de datos como el segundo argumento.

$result = mysql_query($sql, $this->_connection);

El último paso de la función es la de crear la matriz asociativa de datos del álbum.

$rows = array(); while($row = mysql_fetch_array($result, MYSQL_ASSOC)) { array_push($rows, $row); }return $rows;

Una alternativa a la creación de la matriz en PHP usando un bucle while es pasar el identificador de recurso de vuelta a Flash y el uso de un registro conjunto personalizado de clase para analizar los datos de la fila a fila. Hacer esto en Flash tiene parte de la carga fuera del servidor y hace un mejor uso de la máquina del cliente.

Las versiones anteriores de Flash tenía una clase RecordSet nativo. En AS3, usted tendría que crear su propia clase. Esta clase ha sido añadido a los contenidos extra disponibles en el sitio Web del libro y adecuadamente imita la clase RecordSet de AS2.

El primer paso en el trabajo con la clase recordSet es de modificar el método de disco (álbum).

/** * List of albums for RecordSet */ function getAlbumByGenreID($genreID) {

221

$this->connect();

$sql = “SELECT g.name, a.artist, a.albumName FROM albums a, genre g WHERE a.genreID=g.id AND g.id=” . $genreID; return mysql_query($sql, $this->_connection);

}

Aqui esta la clase Album completo:

<?php

class Albums {

// Database info private $dbHost = “localhost”; private $dbUser = “username”; private $dbPass = “password”; private $dbName = “db name”;

private $_connection = null;

function Albums() {

$this->methodTable = array ( “connect” => array ( “access” => “private” ), “getAlbumByGenreID” => array ( “access” => “remote”,

“description” => “List of albums from category ID.”) );

}

/** * @access private * @desc Connect to database - **PRIVATE** */ function connect() {

if($this->_connection == null) { $this->_connection = mysql_connect( $this->dbHost, $this->dbUser, $this->dbPass

222

); mysql_select_db($this->dbName, $this->_connection); } }

/** * List of albums from genre ID. */ function getAlbumByGenreID($genreID) { $this->connect();

$sql = “SELECT g.name, a.artist, a.albumName FROM albums a, genre g WHERE a.genreID=g.id AND g.id=” . $genreID;

$result = mysql_query($sql, $this->_connection);

$rows = array();

while($row = mysql_fetch_array($result, MYSQL_ASSOC)) { array_push($rows, $row); } return $rows;

}

/** * List of albums for RecordSet */ function getAlbumByGenreID_recordset($genreID) {

$this->connect();

$sql = “SELECT g.name, a.artist, a.albumName FROM albums a, genre g WHERE a.genreID=g.id AND g.id=” . $genreID; return mysql_query($sql, $this->_connection);

}

}

?>

Integración de ActionScript para AMFPHP

El siguiente paso es la construcción de la parte Flash de la aplicación, que se encarga de mostrar los datos del álbum en un componente DataGrid precompilados.

Los cambios de la función sólo están dentro de la función onResult para este ejemplo más completo.

223


albumsDG.removeAll(); for(var i:uint=0; i < responds.length; i++) { albumsDG.addItem(responds[i]); }

}

Borrar resultados viejos

La función onResult borra todos los datos existentes en el DataGrid haciendo una llamada al método removeAll del componente DataGrid.

albumsDG.removeAll();

Después que se ha limpiado el DataGrid un for..loop es usado para insertar los datos de la fila de la base de datos.El addItem acepta un objeto como argumento. El control DataGrid es también lo suficientemente inteligente como para emparejar los nombres de objeto para ser usado como los títulos de la columna.

for(var i:uint=0; i < responds.length; i++) { albumsDG.addItem(responds[i]); }

El resto del ejemplo es la misma que la prueba de la aplicación de conceptos. Aunque no es una adición a la aplicación, el nombre del método del servicio debe ser modificado si usted decide utilizar el camino de RecordSet (registros) de mostrar la fila de datos.

Aquí está el código fuente completo del ejemplo de aplicación del álbum.

import flash.net.*;

var gatewayURL:String = “http://localhost/flashservices/gateway.php”; var gateway:NetConnection;

function loadAlbumData(e:MouseEvent):void {

var responder:Responder = new Responder(onResult, onFault);

gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Albums.getAlbumByGenreID”, responder, 4);

}


albumsDG.removeAll(); for(var i:uint=0; i < responds.length; i++)

224

{ albumsDG.addItem(responds[i]); } }

function onFault(responds:Object):void {

for(var i in responds) { trace(“[“ + i + “]\t” + responds[i]); }

}

loadAlbumBtn.addEventListener(MouseEvent.CLICK, loadAlbumData);

Como puede ver, trabajar con datos dinámicos usando AMFPHP tiene muchas ventajas sobre los métodos normales de trabajo con los datos.

Esta sección debería haber dado una buena comprensión de cómo trabajar con AMFPHP en ActionScript 3. Usted puede tomar los conceptos aprendidos en esta sección y basarse en la información de otros en este libro para crear una aplicación muy robusta.

Resumen

Usted aprendió el proceso de trabajar con bibliotecas de terceros en la primera parte del capítulo. Luego, en la segunda parte que fueron introducidos a cómo instalar correctamente las bibliotecas de terceros. Una vez completada la instalación inicial y el proceso de instalación, el siguiente paso fue crear código personalizado para trabajar con las bibliotecas instaladas.

La parte final del capítulo se centró en el trabajo con AMFPHP para crear aplicaciones más robustas y fortalecer los conceptos de trabajo con las bibliotecas.

225

Capitulo 10

Uso de ProgramaciónOrientada a objetos

Este capítulo se centra en las clases y programación orientada a objetos.La comprensión de cómo trabajar con las clases y en el que se debe utilizar le ayudará a escribir código más eficiente. La clave para la escritura en un objeto de formato de la programación orientada a objetos (OOP) es para evaluar correctamente la aplicación que será escrito.

Este capítulo comienza por explicar los aspectos individuales de la POO en Flash y PHP. La última sección de este capítulo es la construcción de una clase de ejemplo para mejorar su comprensión de las prácticas aprendidas en las secciones anteriores.

Es importante señalar que esta no es una guía detallada de programación orientada a objetos, que en realidad necesitaría su propio libro, pero es más una visión general para apoyar a los usos de este libro.

Entender la programacion orientada a objetos (OOP)

La clave para la comprensión de la programación orientada a objetos (OOP) es pensar de cada elemento como una pieza separada. En la programación tradicional, el código de los flujos de la línea 1 hasta que llega al final del documento, con la función de vez en cuando para llevar a cabo tareas repetitivas. El problema con este enfoque es la escalabilidad, o la habilidad de dejar crecer es un programa que evoluciona en el futuro.

Estoy seguro de que usted se está preguntando por qué debería importar si la aplicación es escalable o no. En realidad, es una preocupación muy importante que suele pasarse por alto en las aplicaciones. Hacer un programa escalable desde el principio significa reelaboración menos código y la edición en el futuro. En cierto modo, programación orientada a objetos y el código escalable en realidad van de la mano bastante bien cuando se usan correctamente.

Información general de las práctica de OOP

Ahora que tiene una comprensión de lo que la OOP es y cómo puede beneficiar a su código, puede ver lo que está involucrado en la redacción. El primer o en programación orientada a objetos es "objeto" o un conjunto de información contenida en una pieza fácil de administrar.

226

Clases

Una clase es una definición de todos los objetos de un tipo especificado. La clase define la estructura de los objetos y el comportamiento. Este enfoque no sólo permite que el código para ser distribuido, pero también le permite mantener un cierto nivel de seguridad.

Para entender mejor las clases, aquí es un ejemplo muy básico:

public class Hello { function Hello() {}public function getSaying():String { return “Hello World!”; } }

El código anterior es un ejemplo simple de una clase y no es más que la intención de demostrar visualmente cómo se construye una clase. El public antes de la clase define la clase entera como globalmente accesible. En algunos casos, esto no es el resultado deseado. Usted también puede asignar a cada método y la propiedad como los tipos de público (public), privado (prívate), o de otro dependiendo de los requisitos.

Aquí está un ejemplo común de la aplicación de protecciones a una clase para garantizar la seguridad:

public class UserLogin { function UserLogin() {}public function login():void { callDatabase(); } private function callDatabase():void {} }

Es seguro asumir que usted no desea que el método callDatabase ser llamado directamente, porque una llamada realmente malicioso que podría perjudicar a su base de datos y debilitar la integridad general de la aplicación. Forzar el método como privado garantiza el método no puede ser llamado. El usuario debe llamar al método de ingreso donde se puede validar la solicitud antes de que se llama la base de datos. Esto es, por supuesto, un uso muy simple de los tipos de públicos y privados, pero debería ayudar a entender por qué son importantes.

Constructor

El primer método en una clase es generalmente el constructor. El constructor es llamado automáticamente por el sistema y no pueden devolver los datos. Por lo general, cuando las tareas de inicialización se llevaría a cabo, como el dibujo de un objeto en el escenario o llamando a una base de datos.

227

Paquetes (Packages)

Los paquetes son los contenedores para varias clases que ofrecen la posibilidad de compartir la información dentro del contenedor global. Esto es similar a los empleados en una oficina que comparten información dentro de su propio departamento, pero al mismo tiempo puede pasar información a lo largo de la alta dirección sin que tener que abandonar la organización. En cierto modo, un paquete es una organización de clases.

Hay dos maneras de definir un paquete. El primero es el directorio actual, que sólo se convierte en:

package { class Example { function Example() {} } }

La otra opción es definir una estructura del paquete, por lo general definido por el desarrollador o el nombre de dominio de la empresa en orden inverso, como:

com.companywebsite.projectname

La estructura se coloca después de la palabra clave package.

package com.companywebsite.projectname { class Example { function Example() {} } }

Un ruta reversa del paquete de dominio se utiliza para asegurarse de que el paquete es único.También se utiliza para definir adecuadamente la solicitud o de la biblioteca. Otra ventaja de utilizar este enfoque es que se detenga las colisiones de clase, que es cuando dos clases diferentes tienen el mismo nombre. Esto ocurre más a menudo cuando bibliotecas de terceros se utilizan en una aplicación, ya que no tenemos control sobre los nombres utilizados en las clases. Si la biblioteca está bien construido, que tendrá una estructura de paquete único para evitar colisiones.

Importar

Importación cuando se trabaja con las clases se refiere a la carga, o la conectar clases juntos. Por ejemplo, en la escena de Flash es una instancia de la clase DisplayObject. Sin embargo, cuando se crea un movieclip, que es una instancia de la clase MovieClip, también se carga en una instancia de DisplayObject, junto con un montón de otras clases y paquetes.

Puede colocar las importaciones dentro de la clase por lo que sólo son visibles para esa clase, o usted puede cargarlos en el paquete que les permitan ser compartidos a través de todo el paquete. Por ejemplo, si tiene una clase de miembros, es seguro asumir que siempre se quiere que las credenciales de los miembros es visible

228

para validarlos en diversas partes de la aplicación. Usted podría comenzar por definir la clase de miembros, y luego importar la clase UserCredentials para la validación, como:

import UserCredentials;

public class Member { function Member() {} }

Esto permitiría a UserCredentials para ser vista por cualquier método o propiedad en la clase de Member (miembros). Sin embargo, hay algunos casos en los que se desea que todas las clases para compartir otra clase.

package { import UserCredentials; public class Member { function Member() {} } }

En ActionScript 3 no tiene que preocuparse por la importación de una clase más de una vez porque el compilador como es lo suficientemente inteligente como para importar sólo una vez. PHP, por el contrario, arroja un error si se intenta cargar una clase más de una vez. Esta realidad no es algo malo y puede evitarse fácilmente mediante la carga de todas las clases en un archivo. Basta pensar en esta clase magistral como el padre de todos los demás.La siguiente sección se centrará en las diferencias y similitudes de la clase en PHP y Flash.

Métodos y propiedades estáticas

Un método estático es uno que no requiere una instancia de clase a ser llamado. También permite que el código para conseguir un cierto nivel de coherencia. Por ejemplo, hay una clase Date (Fecha), y en que un método que devuelve los días de la semana. Es seguro asumir los días de la semana no va a cambiar, así que usted puede tener acceso a este método simplemente llamando directamente.

Date.getDaysOfWeek();

Un método estático que se llama de la siguiente manera: Class.method. No hay necesidad de un nombre de instancia o el constructor, de hecho, un constructor no es ni siquiera necesario en este tipo de clase. Sin embargo, es una buena práctica para tener un constructor para la complete compatibilidad.

Una propiedad estática es similar a un método estático en que se puede acceder sin una instancia.Sin embargo, tiene un atributo especial, su tipo y los datos no se puede cambiar, con la obvia excepción de una matriz o un objeto, que no puede tener elementos añadidos a la misma.

trace(“Days in Week: “ + Date.daysInWeek);

229

El código anterior es acceder a la propiedad estática daysInWeek, lo que devuelve un valor numérico que representa el total de días en una semana. Una propiedad estática es útil cuando usted tiene un valor que nunca cambia, como una URL o una compañía de información que se utilizará en una aplicación.

Singletons

Un singleton es un patrón de diseño. El tema de los patrones de diseño requiere de su propio libro, pero básicamente son las reglas y las prácticas se forman entre varios desarrolladores. Usted no está obligado a seguir un patrón de diseño, pero hacerlo más limpio y ofrece un código más escalable. El Singleton es probable que el patrón de diseño más comunes. Es comúnmente usado para pasar alrededor de una pieza de información que no cambia nunca y será necesario un poco durante una aplicación.

NOTA En la mayoría de lenguajes de programación que es común a declarar el constructor de una Singleton privado. Esto evita que los desarrolladores de forma accidental la creación de más de una instancia de un singleton. Sin embargo, no es compatible con ActionScript constructores privados.

Como ha aprendido anteriormente, una instancia de una clase se realiza mediante la nueva palabra clave. Esa es una manera usted puede acceder a una clase y otra es la reutilización de la instancia existente, tales como:

public class User { private static instance:User; function User(){} public static function getInstance():User { if(instance == null) { instance = new User(); } return instance; }public function exampleName():String { return “Joey”; } }

La mayoría de esta clase es el mismo que los ejemplos anteriores, con la excepción de la adición del método getInstance. Este método se utiliza para asegurar que una instancia única de la clase se utiliza siempre. Cualquier llamada a esta clase se realiza mediante el método getInstance, tales como:

import User; trace(“Example Call: “ + User.getInstance().exampleName);

La primera vez que la clase se hace referencia a la instancia única se genera. Cualquier llamada desde ese punto simplemente devuelve la instancia existente. Esto asegura que cualquier cambio a esta clase será visto por todos los participantes.La magia detrás de esta clase es el método y las propiedades estáticas, que se utilizan esencialmente para poner una puerta entre los métodos y la persona que llama. Todas las llamadas van a través de getInstance también te permiten poner un control de autorización para todas las llamadas.

230

NOTA Un producto único sólo debe utilizarse cuando sea necesario. Haciendo de cada clase que cree en un aislado no es una buena práctica, de hecho, la mayoría de los programas tienen un producto único que almacena toda la información necesaria.

Captadores (Getters) y definidores (setters)

Usted puede haber notado que mucha de la utilización de la clase se centra en pasar los datos de ida y vuelta. De hecho, eso es precisamente lo que toda la programación es, en cierto modo. La idea detrás de un getter y setter es para obtener acceso a las propiedades privadas. De hecho, es una apuesta bastante segura de que la mayoría de sus propiedades serán privadas, debido a que es una especie de la idea de una clase. Aquí hay un ejemplo de un get y set, con un esqueleto de la clase como un ejemplo:

class People { private var _person:String; public function get person():String { return _person; }public function set person(u:String):void { if(u.length > 0 && u.length < 25) { _person = u; } } }

El código anterior simplemente devuelve el valor actual de la propiedad privada_person. O bien, una llamada a la persona que modificar la propiedad privada si el nuevo valor es de al menos 1 y no más de 25 caracteres de longitud. Usted puede agregar cualquier nivel de seguridad o de modificación de datos a estos setters. La ventaja de utilizar un regulador es la capacidad de bloquear el acceso a las propiedades privadas, también llamada encapsulación.Esto asegura que el código no puede ser roto por pasar en los datos incorrectos, o peor aún, poner en peligro un sistema debido a una clase abierta.

Ahora que usted entiende lo que es un getter y setter, probablemente es una apuesta segura decir que probablemente también quieren saber cómo llamar a ellos. Esto se hace mediante el acceso a la variable pública, tales como:

var people:People = new People(); people.person = “Timmy”; trace(“The new person is: “ + people.person);

Como la mayoría de los aspectos de la programación, es responsabilidad del desarrollador para determinar dónde y cuándo el uso de un getter/setter es una buena idea. La forma más fácil de determinar esto es, en primer lugar la creación de un esquema de la correcta aplicación.

231

Uso de clases en PHP

Ahora que tiene una comprensión de lo que la OOP es y cómo funciona, el siguiente paso es analizar las diferencias de clase en Flash y PHP.

Para empezar, he aquí un ejemplo rápido de una clase en PHP:

<?php

class Example { public $sample = “Hello, World!”; function Example() { return $sample; } }

?>

Esa es la forma básica de crear una clase en PHP. Los principales aspectos son definiciones que empiezan con la propiedad pública, privada o protegida. Una propiedad seguirá siendo necesario $, al igual que en el código estándar de PHP. La diferencia real sólo otro es el hecho de PHP no declarar el tipo de cambio. De hecho, PHP realmente no importa lo estrictamente tipo de una variable se mantiene, que no es realmente una buena cosa. El desarrollador puede perder la capacidad de saber qué tipo de datos tiene una variable.

Importar clases en PHP

Importación de una clase en PHP se realiza mediante la carga del archivo con Include (incluir) o require (requieren). Usando include intentará cargar el archivo, pero continuará si el archivo no se encuentra. Require, por otra parte, también busca el archivo, pero sale de la secuencia de comandos con un error grave si el archivo no se encuentra, como se muestra en la Figura 10.1. Usar require ofrece la posibilidad de poner fin a una secuencia de comandos si los archivos adecuados no se encuentran. He aquí un ejemplo de la carga de una clase por que lo requieran:

<?php

if(!file_exists(‘Interface.php’)) { print “Class ‘Interface’ not loaded, exiting script!”; }@require(‘Interface.php’);

class Example { function Example() { $i = new iExample(); print “My i: “ . $i->samplr(); } }

$example = new Example();

232

?>

Una sentencia if se utiliza para comprobar primero la existencia del archivo, ya que require creará un error fatal, lo que significa que el script puede informar cualquier mensaje de error apropiado. Si por alguna razón el archivo no se encuentra, el mensaje se envía al navegador y el script termina en silencio cuando llega a la línea de exigir (require). La @ se utiliza para silenciar a los errores internos que más a menudo entonces no causa un problema de seguridad porque presentan rutas de archivo crucial. Una forma alternativa para ocultar los errores es para deshabilitar el informe de errores, que se explica en el capítulo 13.

Instanciación

Creación de instancias de clase es el acto de hacer una instancia de clase. La acción es la misma en cualquier lenguaje de programación orientada a objetos, pero cada idioma tiene una forma diferente de que lo crea. En PHP, primero debe crear una variable y luego asignar la clase a esa variable. Una vez que la nueva instancia es creada, puede acceder a los métodos y las propiedades públicas de esa clase.

$myNewInstance = new Example();

FIGURA 10.1 Aquí está el mensaje de error mostrado en el navegador, que es el resultado de la clase que no se encuentra.

233

Métodos en PHP se tiene acceso utilizando:

$instance->methodName();

Sin embargo, cuando se desea acceder a un método dentro de la misma clase, puede sustituir la variable de instancia y el uso de $this. Así que, suponiendo que usted desea tener acceso al método helloWorld en la clase Speak (de hablar), tendría este aspecto:

$this->helloWorld();

También puede usar el operador de resolución de alcance (también llamado Paamayim Nekudotayim, que en hebreo significa dos puntos-dobles) el acceso a los métodos y propiedades. La diferencia está en lugar de usar $this, debería utilizar el nombre de clase real. Este planteamiento hace que el código sea más fácil de leer.

Speak::helloWorld();

Clases múltiples

PHP permite una secuencia de comandos de clase para mantener varias clases. Esto es tanto una buena y mala idea, porque a muchas clases en uno de los resultados de archivo en el código de hinchada que es difícil de manejar. Por otra parte, con las clases de todos en un archivo es más fácil de distribuir. Estoy seguro de que te estás preguntando cómo las clases son exactamente las múltiples definido en un archivo, aquí está un ejemplo de un pseudo-paquete de la clase.

<?php

class Animals { function Animal() {

}public function speak($word) { print $word; } }

class Dog extends Animals { function Dog($word) { $this->speak($word); } }

// Create a new Dog $dog = new Dog(“Hello.. Woof!”); ?>

De hecho, PHP realmente no segui todas las prácticas estándar de programación orientada a objetos, que creo que va a cambiar a medida que las versiones más recientes se han desarrollado. Por ahora, puede crear su propia versión de un paquete y obtener la misma funcionalidad básica. Es importante señalar que un pseudo-

234

paquete no ofrece el mismo nivel de separación y la seguridad de que un paquete real hace, pero con algo de programación creativa y la creación adecuada de sus clases, usted puede mantener el código de seguridad.

CROSS--REF Véase el Capítulo 6 para obtener más información en profundidad sobre la seguridad del código.

Eso es todo lo que hay que utilizar y entender las clases en PHP, hasta el punto necesario para este libro.Usted puede, por supuesto, prorrogar el presente nuevos conocimientos y comenzar a explorar los aspectos más avanzados de las clases en PHP.

NOTA PHP ofrece una gran cantidad de "magia" los métodos y propiedades hacen que las clases sean más divertido y menos doloroso para trabajar.

Uso de clases en Flash

Como se indicó anteriormente, las clases en Flash y PHP son similares en la mayoría de aspectos. Vamos a ver cómo utilizar y modificar las clases en ActionScript Flash.

Importar

Importación de una clase en ActionScript es un poco menos perdonar si la clase no se encuentra. De hecho, el compilador que se ejecuta cuando se exporta una película se detiene si una clase no se encuentra. Esto básicamente significa que usted no necesita mensajes de error si una clase no está cargado, porque la película nunca es capaz de ser visto por el público en general.

La excepción a esta comprobación compilador es si la clase es dinámica, lo que significa que su estructura general puede cambiar, pero que está más allá del alcance de este libro. Ahora, de regreso a la importación de clases, que se crearía como este:

import com.organization.project.Example; var example:Example = new Example(); trace(“Call a method: “ + example.methodName());

Usted puede haber notado el uso de la importación, en vez de exigir o incluir. La diferencia obvia en el ejemplo anterior es: Ejemplo de definición de tipo. Esto realmente no es necesario, pero permite un mejor control de error cuando la película se está compilado o se está ejecutando.

Clase de documento

La clase de documento se utiliza como la clase principal para una aplicación. Piense en ello como la clase de línea de tiempo, similar a los días de la adición de código de base en el fotograma 1 de una película. Esos días han terminado y es una buena cosa, también. Sin embargo, hay algunas cosas que debe saber acerca de cuando se utiliza una clase de documento, como se muestra en la Figura 10.2. En primer lugar, mire lo que una clase de documentos parece:

package { import flash.display.MovieClip; public class DocRoot extends MovieClip { function DocRoot

235

{ trace(“I am the Document Class”); } } }

FIGURA 10.2 La clase de documentos, que se puede encontrar en el inspector de propiedades

La asignación de la clase de documento es bastante singular. Usted puede agregar o editar el archivo de clase utilizando los pasos siguientes:

1. Haga clic en el escenario, para asegurar no hay nada seleccionado. 2. Abra el inspector de propiedades si no está abierto. 3. Haga clic en el cuadro de texto clase de documento y añadir el nombre de la clase.

Usted puede haber notado la clase de documento extiende la clase MovieClip, sino que también puede extender la clase Sprite. De hecho, esta ampliación es necesaria porque la clase de documento es en realidad un MovieClip.

236

Biblioteca de clases

Una biblioteca de clases es la nueva manera de ActionScript para conectar a un MovieClip en la línea de tiempo. En versiones anteriores de Flash que se asigna un identificador de vinculación a su MovieClip. En ActionScript 3, de tomar los mismos pasos básicos de la apertura del inspector de Propiedades, seleccione la opción Exportar para ActionScript, y añadir el nombre de clase, como se muestra en la Figura 10.3.

FIGURA 10.3 El inspector de propiedades con la opción Exportar para ActionScript seleccionados

Al igual que la clase de documento, es necesario asegurarse de que la clase personalizada MovieClip se extiende la clase MovieClip. De hecho, el Documento de la Biblioteca y las clases son muy similares en la que fueron creados.

237

Uso de Flash y PHP para construir clases personalizadas

Usted puede haber notado que hay menos de explicar con el uso de clases en Flash que hay en PHP.Esta sección se centra en una clase completa ejemplo basado en Flash y PHP. Se utiliza para reforzar los conceptos aprendidos en las páginas anteriores.

Vamos a empezar con PHP que se utiliza en este ejemplo. La idea es construir una aplicación básica que permite a PHP y Flash para comunicarse, aprovechando al mismo tiempo de clases personalizadas.

<?php

class Communication {

public $MESSAGE_NOTIFY = “Hi, from PHP! You said: “;

function Communication() {

}

public function respond($str) { return $this->MESSAGE_NOTIFY . $str; } }

$communication = new Communication();

if($_GET[‘a’] == “newMessage”) { // send message back to Flash print “resp=” . $communication->respond(); }?>

La parte de PHP de este ejemplo permite a Flash comunicarse al pasar a lo largo de una petición para llamar el método respond(). Dentro de la clase, PHP y entonces construye una cadena y devuelve a la Flash, en donde en ese momento que se lee y aparece en el escenario.

El siguiente paso es construir la clase de documentos y de llamadas en Flash.Esta es la clase de documento:

package {

import flash.display.MovieClip; import flash.text.TextField;

import Communicator;

public class Document extends MovieClip { function Document()

238

{ makeCall(); }

public function makeCall():void { var mc:MovieClip = new MovieClip(); var txt:TextField = new TextField();

mc.addChild(txt); addChild(mc);

var communicator:Communicator = new Communicator(); communicator.action = “newMessage”; communicator.container = mc; communicator.callServer(); } } }

El constructor es responsable de llamar al método makeCall(). Este método crea un TextField, concede al escenario mediante addChild, y, finalmente, establece la llamada a la clase communicator (comunicador) personalizada.

Como la llamada a la clase del comunicador se está instalando, también es responsable de asignar la instancia de TextField y la acción. La acción en este ejemplo se utiliza para indicar que el código PHP para correr. Por supuesto, en este ejemplo sólo hay una acción asignada. Sin embargo, es fácil de pronto tienen diez o más acciones en una aplicación real.

La clase TextField es similar al método createNewTextField que se han utilizado en ActionScript 2. El cambio en el código de ActionScript 3 se ha hecho para ser coherente con la colección de artículos personalizados, como los de la sección anterior.

El siguiente paso es crear la clase personalizada, que se utiliza para comunicarse con PHP en el servidor Web.

package{

import flash.net.URLRequest; import flash.net.URLLoader; import flash.net.URLVariables; import flash.display.MovieClip; import flash.events.*;

public class Communicator {

private var _action:String; private var _txtBoxContainer:MovieClip;

function Communicator() {}

public function callServer():void {

var variables:URLVariables = new URLVariables();

239

variables.a = _action;

var request:URLRequest = new URLRequest(“http://localhost/flashphp/Communicate.php”); request.data = variables;

var loader:URLLoader = new URLLoader(); loader.addEventListener(Event.COMPLETE, serverHandler); loader.load(request); }

public function serverHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); _txtBoxContainer.text = variables.resp; }

public function set action(a:String):void { _action = a; }

public function set container(mc:MovieClip):void { _txtBoxContainer = mc; } } }

La clase es bastante sencillo y tiene los conceptos que han sido utilizados en los ejemplos anteriores. Los puntos de enfoque principal de esta clase son los métodos callServer y serverHandler, que se encarga de llamar y hacer frente a la respuesta del servidor.

El primer método, CallServer, establece la variable _action que se pasa a PHP usando el valor que se estableció en la clase de documentos en la sección anterior. Usted puede haber notado el _ antes de que el nombre de la variable, que se utiliza para definir claramente una variable privada. No es necesario, pero hace que tu código sea más fácil de leer.

Los dos últimos métodos de esta clase son responsables de establecer el contenedor de TextField y la acción. Estos dos setters son llamados desde la clase de documento.

Como puede ver, la creación de esta aplicación como una clase personalizada ofrece la posibilidad de actualizar rápidamente o ampliarlo a otra aplicación y lo mejor de todo tiene todo seguro. Esta solicitud de base es sólo una muestra de lo que pueden ofrecer las clases, sino que debe darle una mejor comprensión de cómo la clase de documento se establece.

La siguiente tabla 10.1, es una tabla de forma rápida y gráfica que explica las diferencias de clases en PHP y Flash. Siempre puede regresar a esta página si usted tiene una pregunta de si una característica existe en el lenguaje que están trabajando.

240

TABLA 10.1 Diferencias entre Clases en PHP y Flash

Class PHP Flash .Instantiation X X Multiple classes in one file X Importing X X include or require Constructor X X Packages X Static methods and properties X X

Resumen

Una gran cantidad de información se tratan en este capítulo y en este punto usted debe tener un buen entendimiento de cómo funciona programación orientada a objetos y cuándo usarlo. Como usted puede notar, las clases y programación orientada a objetos en general, ofrecen muchas ventajas. Sin embargo, también puede notar el desarrollo OOP tiene más tiempo. Esto no es necesariamente una mala cosa, porque a la larga, te darás cuenta de menos tiempo de desarrollo en futuras actualizaciones. También ofrece la ventaja menos evidente de código más seguro que el desarrollador puede controlar. En este punto, usted sabe cómo configurar y utilizar las clases en PHP y Flash, y es probable que quieran experimentar con algunos de los temas más avanzados que no están cubiertos en este capítulo.

241

Parte IV

Desarrollo deAplicaciones

242

Capitulo 11

Desarrollo de aplicacionesBásicas

En este capítulo, se desarrolla una serie de aplicaciones completas. El objetivo de este capítulo es el de acabar con las aplicaciones completas al explicar los errores comunes y cómo superarlos. Usted investigar algunos conceptos nuevos, así como los controladores de eventos múltiples, clases personalizadas, y servicios a distancia.

En este capítulo también se centra en la mejor forma de trabajar con MySQL de una manera eficiente y segura. El capítulo concluye con la evaluación de las mejores prácticas para el mantenimiento de las aplicaciones y permitiendo la posibilidad de añadir nuevas funcionalidades.

Entender los elementos de una aplicación

Crear aplicaciones no sólo en saltar en Flash o tu editor favorito y la línea de escritura después de la línea de código. El mejor lugar para empezar en el desarrollo de aplicaciones es la etapa de evaluación. Este es el punto para mirar la lista de lo que su aplicación debe hacer, quién es la audiencia, y cómo va a desarrollar la aplicación. Tabla 11.1 ilustra los tres puntos de la etapa de evaluación.

TABLA 11.1 Los tres puntos de la Etapa de Evaluación

Qué Definir lo que hará la aplicación Quién El público objetivo de su aplicación Cómo Técnicas a utilizar para desarrollar su aplicación

Los siguientes ejemplos saltarse el paso "cómo" porque este es un libro de Flash y PHP. Una vez que el "cómo" se define usted puede pensar en el "quién". Esto es, por supuesto, su público objetivo. Una aplicación no siempre tendrá un rígidamente definidas, que, sobre todo si se trata de un servicio de sitio Web, pero es mejor definir uno. La mejor manera de determinar su público objetivo es pensar sobre el tipo de aplicación.Por ejemplo, va a ser una aplicación de comercio electrónico o tal vez un reproductor de vídeo. Saber quién va a utilizar la aplicación es crucial para su éxito.

Ahora que el "cómo" y "quién" se define, se puede pensar acerca qué es exactamente lo que la aplicación va a hacer. Nunca iría a la ferretería, comprar todos los materiales, y luego decidir qué construir.Lo mismo es cierto para el desarrollo de aplicaciones. Al comenzar a seguir estas prácticas se conviertan en una segunda naturaleza.

243

Entender el diseño de una aplicación

Con la fase de evaluación completa, naturalmente, pasar a la fase de diseño. Pero, al igual que la etapa de evaluación, siempre es una buena idea para el primer plan. Este sería un boceto con lápiz y papel o con flash con formas primitivas. Por ejemplo, la figura 11.1 muestra un ejemplo de esquema.

Trabajar con pseudo-código

Después de que haya la disposición general de la aplicación desarrollada, se puede pasar a la funcionalidad.Este sería el punto en empezar a escribir pseudo-código, tales como las funciones, variables, eventos, y cualquier otro concepto que va a utilizar en su aplicación. El siguiente es un ejemplo de pseudocódigo para un programa de gestión de usuarios.

// Pseudo-code

function loadUser(id:uint):void { // make call to server passing // along the id as the user id }function handleServerResponse(e:Event):void { // capture server response // make necessary calls to application }

function drawInterface():void { // paint “draw” the interface that // the user will interact with }

function redraw():void { // redraw interface as info is loaded, // to keep things up to date }

// Assign event handlers

Usted notará que pseudo-código no es una aplicación completa, pero es el esqueleto de la aplicación en general.Esto le permite desarrollar rápidamente la forma en que la aplicación funcionará y lo que hará.Escritura de pseudo-código se convierte en mucho más importante en el desarrollo de aplicaciones a gran escala, pero es una buena práctica para evaluar, dibujo, y el plan no importa cuán grande es el proyecto.

244

FIGURA 11.1 Un bosquejo ejemplo de aplicación con formas primitivas en Flash

Finalización de la etapa de planificación

El último paso para la planificación de una aplicación no es definitiva, ya que puede concluir la etapa de planificación o comenzar el proceso de desarrollo. Esta elección puede a veces ser determinado por el cliente o el director creativo si le ha sido asignado.

En este punto, en el proceso de planificación, que ha determinado lo que hará la aplicación, que va a utilizar, y cómo va a ser construido. También han diseñado un esquema y comenzado el proceso de programación. El siguiente paso depende de usted como el desarrollador. Puede continuar y finalizar el proceso de diseño o de comenzar a desarrollar el código de la aplicación utilizará. Normalmente, se diseño la aplicación suficiente para empezar en la programación, porque las cosas son más que probable que va a cambiar a medida que sigan desarrollándose. Sin embargo, con la cantidad apropiada de la planificación puede minimizar estas fases de revision.

245

Desarrollo de un cliente de ChatAhora que han estudiado las mejores prácticas para el desarrollo de aplicaciones ya puede comenzar a desarrollar su aplicación completa en primer lugar. Esta aplicación será un cliente de chat Flash usando PHP para interactuar con una base de datos MySQL. Después de desarrollar la aplicación de base se seguirá para agregar características y ver la mejor manera de construir una aplicación escalable.

Una aplicación escalable es desarrollado teniendo en cuenta que dos usuarios pueden utilizar la aplicación al principio, pero podría fácilmente ser utilizado por millones en el tiempo. La idea es dar cuenta de esta y desarrollar la aplicación de una manera que permite la expansión.

La porción de Flash

De comenzar este proyecto mediante el diseño de la aplicación. Para esta aplicación, el diseño es siempre, pero se siente libre para modificarlo. De hecho, le animamos a ampliar a todos los ejemplos, que es la forma de familiarizarse con nuevos conceptos y también cómo crecer como desarrollador. La figura 11.2 muestra la interfaz de la aplicación de chat.

Básicamente, la interfaz consta de un componente TextArea, que se utiliza para mostrar los mensajes de chat, dos componentes TextInput para el mensaje y los elementos nombre de usuario y una instancia del botón para el botón de envío.

246

FIGURA 11.2 El diseño de su aplicación de chat construido utilizando componentes precompilados en Flash

Tabla 11.2 muestra los nombres de instancia para cada componente.

TABLA 11.2 Instance Names for the Components

Componente Nombre de instancia Resultado .TextArea messagesTxt Mostrar los mensajes del chat TextInput newMsgTxt Nuevo mensaje TextInput usernameTxt Nombre de la persona del chat Button sendBtn Envía un nuevo mensaje al servidor

Se le hace referencia a los nombres de instancia durante el desarrollo de la ActionScript para su aplicación de chat.

Con la interfaz de usuario "diseño" parte ya realizada o en este caso cargada, se puede comenzar el desarrollo del código.

La primera parte del código de la aplicación de chat es un bloque de variables que se utilizan en todo. La primera variable es la ruta absoluta a los archivos PHP. Luego dos próximas variables son los archivos PHP encargados de enviar y la carga de los mensajes de chat de la base de datos. Después de que son dos variables

247

booleanas para las llamadas de mensajes múltiples no se puede hacer. El último conjunto de variables es una referencia al objeto Timer y el destructor de caché.

var phpPath:String = “http://localhost/ch10/chatClient/”; var phpSendMessage:String = phpPath + “message.php”; var phpLoadMessages:String = phpPath + “getMessages.php”;

var loadingMessages:Boolean = false; var sendingMessage:Boolean = false;

var timer:Timer; var cacheBuster:String = “?cb=1”;

La primera función que vas a construir es el init() o la función de inicialización. Esto se llama una sola vez, cuando se inicia la aplicación. Es responsable de la creación de un controlador de temporizador para la carga de los mensajes del servidor y hacer la primera llamada a un destructor (buster) de la caché, que se explica en la siguiente sección. La última acción de la función init() es llamar a la función loadMessages y rellenar la lista de mensajes.

function init():void { // start timer for loading of messages timer = new Timer(5000, 0); timer.addEventListener(TimerEvent.TIMER, timerHandler); timer.start();

cacheBuster = getCacheBuster(); loadMessages(); // first time }

Los buques de clase Timer con Flash y tiene un montón de grandes aplicaciones. En este ejemplo se aprovecha el evento Timer, que es llamado cada vez que la cuenta regresiva se ha alcanzado. El tiempo de cuenta y el número de repeticiones se pasan al constructor. Establecer la cuenta regresiva a 5000 o 5 segundos y se repite a 0, lo que realmente le dice a ActionScript para repetir continuamente. Después de una instancia de Timer se crea una nueva que asigna el controlador de eventos y de iniciar el temporizador de inmediato. El controlador de temporizador, simplemente hace una llamada a la función de loadMessages.

Esta parte del código podría ser condensado mediante la colocación de la función loadMessages en lugar de la timerHandler, pero hacerlo de esta manera nos permite agregar más funcionalidad en el futuro. Todo es buena práctica de desarrollo para crear controladores de eventos adecuado para lo que el código puede ser actualizado, y lo hace en general mucho más fácil de leer.

function timerHandler(e:TimerEvent):void { loadMessages(); }

La función de loadMessages es responsable de llamar y el manejo de la respuesta del servidor.La llamada al servidor es muy similar a otros ejemplos con algunos elementos nuevos. Un elemento nuevo es la variable CacheBuster, que se utiliza para asegurar que no recibe un resultado almacenado en caché.

248

Detener el almacenamiento en caché con datos dinámicos

Usted acaba de crear una variable para detener el almacenamiento en caché, pero ¿qué es eso? El almacenamiento en caché en el servidor es cuando los datos dinámicos se almacena para su rápida carga en todas las futuras convocatorias. A primera vista parecería una buena idea, y en la mayoría de los casos lo es. Sin embargo, en el ejemplo de la carga de chat de datos que cambia constantemente, es probablemente seguro decir que desea que estos datos sean frescos. Esto se logra mediante la adición de una variable conocida como un "destructor de caché" (“cache buster”), el cual engaña al navegador en el pensamiento de cada llamada para el mismo archivo es diferente.

Aquí hay un ejemplo muy simple de un destructor de la memoria caché y la cadena real que se envía al servidor:

function getRandom(length:uint):void { return Math.round(Math.random() * (length - 1)) + 1; }

var rand:String = “?cb=” + getRandom(8); var php:String = “http://localhost/ch04/getMessages.php” + rand;

trace(“URL: “ + phpFile); // getMessages.php?cb=65378426

PRECAUCIÓN busters caché añade el tiempo de descarga y la fuerza de cualquier archivo con un destructor de caché que se descargan cada vez que se solicita.

Todo después del? en la URL es decir el navegador y el servidor que la llamada es dinámica y los resultados en el archivo no está almacenado en caché.

La siguiente parte del proceso de enviar el mensaje es asegurar el mensaje es por lo menos tres caracteres de largo. Si el mensaje no es por lo menos tres personajes, un mensaje de error. Hay dos maneras que usted puede escribir este control condicional.

La primera opción es:

if(newMsgTxt.text.length > 2) {}

La segunda opción, que es más fácil de entender rápidamente:

if(newMsgTxt.text.length >= 3) {}

Ambas opciones de lograr el mismo resultado, pero la segunda opción es mucho más fácil de leer desde un punto de vista lógico.

Ahora bien, suponiendo que tiene un mensaje de la longitud correcta se puede continuar con el proceso de enviar el mensaje al servidor. La siguiente parte es la construcción de la llamada al servidor.

var variables:URLVariables = new URLVariables(); variables.user = usernameTxt.text;

249

variables.msg = newMsgTxt.text; var urlRequest:URLRequest = new URLRequest(phpSendMessage + getCacheBuster()); urlRequest.method = URLRequestMethod.POST; urlRequest.data = variables;

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, sendMessageHandler); urlLoader.load(urlRequest);

Al llamar al servidor, debe crear un objeto URLVariables con el fin de transmitir el nombre de usuario y el mensaje que se introdujo. Un llamado también a la función personalizada Buster caché para asegurar que los datos siempre es fresco.

El último paso en la función de envío es de inmediato y un mensaje del usuario en lugar de esperar a que la lista de mensajes para actualizar desde el servidor. Esto da a la solicitud de una sensación de mayor capacidad de respuesta y lo hace de modo que el mensaje no parece haber sido ignorada.

addMessage(usernameTxt.text, newMsgTxt.text);

Esta función acepta dos argumentos: el nombre de usuario y el mensaje de recogida de sus respectivos componentes. Esta información es luego incorporarse a una cadena de HMTL que se asigna a la TextArea messagesTxt. El nombre de usuario se encuentra dentro de las etiquetas en negrita para resaltar el nombre. De hecho, usted puede utilizar una gran cantidad de etiquetas comunes HTML dentro de cuadros de texto HTML habilitado.

function addMessage(user:String, msg:String):void { messagesTxt.htmlText += “<b>” + user + “</b>” + “: “ + msg + “\n”; }

Tabla 11.3 muestra las etiquetas HTML compatible que puede ser utilizado.

TABLA 11.3 Etiquetas HTML soportadas

Etiqueta (Label) Etiqueta HTML .Anchor Tag <a> Bold Tag <b> Break Tag <br> Font Tag <font> Image Tag <img> Italic Tag <i> List Item Tag <li> Paragraph Tag <p> Span Tag <span> Underline Tag <u>

La función sendMessageHandler se llama una vez que el mensaje se envió con éxito al servidor. La única parte importante de esta función es la última línea, el que abre el cuadro de mensaje y permite que el usuario escriba un mensaje nuevo. Usted puede borrar el mensaje en la función de envío, pero hacerlo de esta manera se asegura el mensaje permanece intacto hasta que esté seguro de que se ha añadido.

250

NOTA El PHP no le avise a un error si el SQL falla, sólo si la página no se carga.Por supuesto que puede añadir más avanzadas de error de manipulación a este ejemplo.

Por supuesto que puede añadir más avanzadas de error de manipulación a este ejemplo.

function sendMessageHandler(e:Event):void { ... newMsgTxt.text = “”; }

Ahora que ha completado el código de envío y gestión de las llamadas al servidor, usted puede comenzar la función que gestiona los mensajes y los muestra en TextArea.

El loadMessages () es llamado desde dos puntos diferentes. El primer punto es la función init(), que vimos anteriormente, el segundo es el controlador de temporizador.

La función de control para ver si otra llamada ya se ha hecho para cargar los mensajes. La adición de esta verificación asegura que no se pueden inundar el servidor y, potencialmente, la fuerza para que no responda. Si otro de carga ya ha comenzado, simplemente a salir de la función y dejar de procesar.

Suponiendo que otra carga ya no está en curso, se establece la variable loadingMessages, que es similar a cerrar la puerta después de entrar en una habitación. La mayoría de la funcionalidad de loadMessages es similar al proceso de envío.

Es básicamente, definir el archivo PHP correcta para cargar y configurar un controlador de eventos para que el servidor devuelva los datos del mensaje.

function loadMessages():void { if(loadingMessages) return; loadingMessages = true;

var urlRequest:URLRequest = new URLRequest(phpLoadMessages + getCacheBuster()); var urlLoader:URLLoader = new URLLoader();

urlLoader.addEventListener(Event.COMPLETE, loadMessagesHandler); urlLoader.load(urlRequest); }

Manejo de respuesta XML

La función de respuesta de carga es responsable de trabajar con los datos XML y de pasar los mensajes que se mostrarán.

function loadMessagesHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var xml:XML = new XML(loader.data);

messagesTxt.htmlText = “”;

251

for each(var item in xml..message) { addMessage(item.name, item.msg); }

cacheBuster = getCacheBuster(); loadingMessages = false; }

NOTA Los nombres de elementos dentro de la respuesta XML distinguen entre mayúsculas y minúsculas. El caso de la norma está en minúscula, o camello, de múltiples palabras.

Después de que el XML se ha cargado correctamente y listo para usar, configurar un bucle for..each al igual que lo utiliza en el ejemplo al cargar el código XML en el Capítulo 3. El bucle se basa en todos los nodos del “mensaje” encontrado en la respuesta de ejemplo. Una muestra de la respuesta pasa de nuevo sería algo como esto:

<messages> <message id=’29’> <name>guest1</name> <msg>Flash is a lot of fun</msg> </message> <message id=’30’> <name>guest2</name> <msg>PHP and Flash is better</msg> </message> <message id=’32’> <name>guest1</name> <msg>You can do so many things with it</msg> </message> <message id=’33’> <name>guest2</name> <msg>For sure, just look at this cool chat client</msg> </message> </messages>

El paso final de la función de loadMessagesHandler es crear un nuevo destructor de caché y establecer la variable loadingMessages a false, lo que permite a las futuras convocatorias para obtener los últimos mensajes.

Busters caché se ha explicado anteriormente en la sección. Sin embargo, hay varias maneras de crear una cadena única. La fecha está siempre cambiando y ActionScript tiene un método getTime que devuelve los milisegundos desde 1 de enero de 1970. Este método utiliza la fecha, ya que está cambiando constantemente y nunca se repite, lo que deja una cadena única cada vez que se llama.

En este punto, usted ha completado el código ActionScript para su aplicación de chat. Aquí está el código completo de referencia:

var phpPath:String = “http://localhost/ch10/chatClient/”; var phpSendMessage:String = phpPath + “message.php”; var phpLoadMessages:String = phpPath + “getMessages.php”;

var loadingMessages:Boolean = false; var sendingMessage:Boolean = false; var chatMessages:Array = new Array();

252

var timer:Timer; var cacheBuster:String = “?cb=1”;

function init():void { // start timer for loading of messages timer = new Timer(5000, 0); timer.addEventListener(TimerEvent.TIMER, timerHandler); timer.start();

cacheBuster = getCacheBuster();

loadMessages(); // first time }

function sendMessage(e:MouseEvent):void { if(usernameTxt.text == “”) { trace(“Username required”); return; }

if(newMsgTxt.text.length >= 3) { var variables:URLVariables = new URLVariables(); variables.user = usernameTxt.text; variables.msg = newMsgTxt.text;

var urlRequest:URLRequest = new URLRequest(phpSendMessage + getCacheBuster()); urlRequest.method = URLRequestMethod.POST; urlRequest.data = variables;

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, sendMessageHandler); urlLoader.load(urlRequest);

// force message into display addMessage(usernameTxt.text, newMsgTxt.text); } }

function sendMessageHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); trace(“Response: “ + variables.resp);

// clear message box newMsgTxt.text = “”; }

function loadMessages():void { if(loadingMessages) return; loadingMessages = true;

253

var urlRequest:URLRequest = new URLRequest(phpLoadMessages + getCacheBuster()); var urlLoader:URLLoader = new URLLoader();

urlLoader.addEventListener(Event.COMPLETE, loadMessagesHandler); urlLoader.load(urlRequest); }

function loadMessagesHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var xml:XML = new XML(loader.data);

loadingMessages = false; messagesTxt.htmlText = “”;

for each(var item in xml..message) { addMessage(item.name, item.msg); }

cacheBuster = getCacheBuster(); }

function getCacheBuster():String { var date:Date = new Date(); cacheBuster = “?cb=” + date.getTime(); return cacheBuster; }

function addMessage(user:String, msg:String):void { messagesTxt.htmlText += “<b>” + user + “</b>” + “: “ + msg + “\n”; }

function timerHandler(e:TimerEvent):void { trace(“Timer hit”); loadMessages(); }

sendBtn.addEventListener(MouseEvent.CLICK, sendMessage);

init();

PHP para la aplicación de chat

En este punto, usted ha completado la parte de ActionScript de la aplicación de chat. El segundo paso es desarrollar el código PHP, que es llamado desde el código ActionScript.

El código PHP está dividido en tres archivos, que se ilustran en la tabla 11.4.

254

TABLA 11.4 Desglose de los archivos PHP

Archivo de código PH Acción .getMessages.php Coge todos los mensajes en los últimos 15 minutos messages.php Se encarga de la redacción de un nuevo mensaje a la base de datos dbConn.php La conexión de base de datos compartida con los otros archivos

El primer archivo trabajar con getMessages.php. La primera parte de la carga de código o incluye el archivo de conexión de bases de datos, que usted va a mirar en un momento. La siguiente parte es el llamado SQL, que consulta la base de datos MySQL y coge todos los últimos mensajes publicados en los últimos 15 minutos.

$sql = “SELECT * FROM flashChat WHERE dateAdded > “ . (time() - (60 * 15)); $result = mysql_query($sql);

La condición de los últimos 15 minutos se determina por el código siguiente. El time() devuelve un timestamp UNIX que se resta un 60 y multiplicado por 15. El 60 es para los segundos en un minuto y el 15 es la cantidad de minutos que usted se refiere. También puede escribir esta ecuación matemática básica mediante la eliminación de la etapa de multiplicación. Si lo hace, lo hace más difícil de leer el código, sino que también aumenta la velocidad de la aplicación.

time() - 900

Esta cadena SQL se pasa a la función real que hace la llamada al servidor mysql_query(), que se asigna a la variable $result. Ahora que ha realizado con éxito la llamada a la base de datos MySQL, el siguiente paso es generar un bucle que construye los mensajes.La figura 11.3 muestra la pantalla de consultas en MySQL Query Browser, que está disponible de forma gratuita en www.mysql.com.

Este bucle se realiza mediante un tiempo, que tiene una duración prevista hasta que una fila válida no se devuelve desde la base de datos. También puede colocar esto en un bucle y el uso mysql_num_rows() para determinar cuántas filas se devuelven.

255

http://www.mysql.com/

FIGURA 11.3 La consulta SQL devuelto dentro de el MySQL Query Browser

La función mysql_fetch_array() agarra la de una sola fila de la tabla de base de datos en un formato de matriz asociativa y la asigna a la variable $row. El contenido del bucle se crean para generar nodos XML que contienen los datos del mensaje, que se miró en el capítulo anterior.

while($row = mysql_fetch_array($result)) { $xmlData .= “ <message id=’” . $row[‘id’] . “‘>\n”; $xmlData .= “ <name>” . $row[‘username’] . “</name>\n”; $xmlData .= “ <msg>” . $row[‘message’] . “</msg>\n”; $xmlData .= “ </message>\n”; }

En este punto, usted tiene una llamada efectuada SQL en el servidor y un bucle para generar el mensaje de datos XML, que se devuelve a la Actionscript en Flash. Envío de los datos de vuelta a ActionScript es muy sencilla, solo asignar la variable $xmlData a la declaración de impresión.

print $xmlData;

La declaración de impresión envuelve su archivo messages.php, que se muestra en su totalidad aquí.

<?php

256

include ‘dbconn.php’;

$sql = “SELECT * FROM flashChat WHERE dateAdded > “ . ( time() - (60 * 15));

$result = mysql_query($sql); $xmlData = “<messages>\n”;

while($row = mysql_fetch_array($result)) { $xmlData .= “ <message id=’” . $row[‘id’] . “‘>\n”; $xmlData .= “ <name>” . $row[‘username’] . “</name>\n”; $xmlData .= “ <msg>” . $row[‘message’] . “</msg>\n”; $xmlData .= “ </message>\n”; }

$xmlData .= “</messages>”; print $xmlData;

?>

El archivo PHP siguiente que debe ser desarrollado es messages.php, que es responsable de la inserción de nuevos mensajes en la base de datos MySQL. La primera parte de este archivo PHP comienza el mismo que el anterior por la carga del archivo dbconn.php, que es responsable de manejar la información de acceso y conexión a la base de datos MySQL.


El siguiente paso es comprobar que el mensaje enviado desde ActionScript es de hecho mayor que 0 caracteres cadena vacía. En PHP, strlen() devuelve la longitud de una cadena que se pasa como argumento.

if(strlen($_POST[‘msg’]) > 0) { ... }

Asumiendo que tiene un mensaje de longitud válido, asigna tres variables: una es el nombre de usuario, el segundo es el mensaje, y la tercera es la fecha en formato timestamp UNIX.

$username = $_POST[‘user’]; $message = $_POST[‘msg’]; $date = time();

El siguiente paso en el desarrollo de este archivo es tomar realizar la llamada MySQL real, que se realiza utilizando mysql_query(). Esta función tiene la instrucción SQL como argumento y devuelve un identificador de recursos o genera un error.

La instrucción SQL real es bastante similar a otros utilizados en los ejemplos anteriores. Hay una mesa de FlashChat dentro de la base de datos que pasa a tener cuatro columnas, pero una de ellas es una auto_increment y no necesita ser definido en una sentencia INSERT.

NOTA En una aplicación más robusta, que se desea añadir una capa de seguridad en los datos pasados en el de otra fuente. No importa si se trata de Flash, el navegador, o de un servicio de terceros, siempre es importante.

257

mysql_query(“INSERT INTO flashChat (username, message, dateAdded) VALUES ( ‘“ . $username . “‘, ‘“ . $message . “‘, ‘“ . $date . “‘ )”);

PRECAUCIÓN El nombre dateAdded fue utilizado porque la fecha es una palabra reservada en MySQL y se producirá un error en la mayoría de los casos. Nunca es una buena idea utilizar las palabras reservadas para su uso en cualquier otro lenguaje de desarrollo.

El último paso en este archivo es devolver una respuesta a la notificación de Flash que el mensaje se ha añadido otro mensaje y ahora puede ser añadido a partir de ese usuario. En general, el archivo messages.php es bastante simple, pero hace el trabajo.

Aquí está el archivo de messages.php de referencia completa.

<?php


if(strlen($_POST[‘msg’]) > 0) { $username = $_POST[‘user’]; $message = $_POST[‘msg’]; $date = time();

mysql_query(“INSERT INTO flashChat (username, message, dateAdded) VALUES ( ‘“ . $username . “‘, ‘“ . $message . “‘, ‘“ . $date . “‘ )”);

print “resp=MESSAGE_ADDED”; }

?>

Usar PHP para conectar a MySQL

El archivo PHP pasado en su versión de Flash aplicación de chat es el archivo de dbconn.php. Este archivo es responsable de conectar a MySQL y proporcionar un vínculo a las tablas contenidas en la base de datos.

NOTA Sólo puede haber una conexión a una base de datos única a la vez. La mejor práctica es el plan de SQL se conecta a ser más eficientes. Esto le impide tener que ir adelante y atrás.

Este archivo es bastante pequeño, pero tiene un requisito muy importante, que es en honor a las medidas de seguridad en la mayor medida. Una buena parte de estos artículos han señalado que la seguridad es importante. Se veía en muchos ejemplos anteriores, en este ejemplo, la seguridad no se excluye de la simplicidad.

258

La primera parte de el archivo es asignar las variables de la base de datos que se pasarán a lo largo de la conexión. A menudo las aplicaciones más avanzadas tendrán un archivo separado para las variables de configuración. Ese archivo de configuración que se carga sólo cuando la aplicación se inicia y se hace referencia en todo.

Sin embargo, debido a esta aplicación es bastante pequeño, sólo se asignan las variables de la base de datos de conexión dentro de la conexión del archivo dbconn.php.

$host = “HOST_NAME”; $user = “SQL_USERNAME”; $pass = “SQL_PASSWORD”; $database = “SQL_DATABASE_NAME”;

La primera variable es a menudo localhost o la dirección IP del servidor donde MySQL se ejecuta si se pasa a estar en ejecución remota del servidor donde está corriendo PHP. No había que esperar para ver una instalación remota de MySQL en sistemas más pequeños, pero es muy común en aplicaciones de mayor tamaño.

Las otras tres variables son nombre de usuario, contraseña y el nombre de la base de datos a la que desea conectarse. Esta información de conexión proporcionada por su administrador de sistema o de acogida, si no ya lo saben.

NOTA MySQL crea una instalación por defecto con el nombre del usuario "root" y sin contraseña, pero es muy inseguro de esta manera y se debe cambiar inmediatamente.

Ahora que las variables son definidas correctamente, puede realizar una conexión real a MySQL. Esto se logra por la función mysql_connect() dentro del PHP. Esta función acepta tres argumentos: host, nombre de usuario y una contraseña definida hace un momento.

$link = mysql_connect($host, $user, $pass);

La función mysql_connect() devuelve un identificador de recurso que se almacena en la variable $link.Esto se hace referencia a cuando se va a seleccionar la base de datos.

Selección de la base de datos es simplemente una cuestión de hacer referencia el nombre de la base de datos a la que desea conectarse y pasando por el enlace recibido en el paso de la conexión.

mysql_select_db($database, $link);

El paso final y más importante es destruir las variables que contienen la información de conexión de MySQL. La destrucción o eliminación de una variable se hace pasando la la variable de referencia a la función unset(), que elimina la existencia de esa variable.

unset($host); unset($user); unset($pass); unset($database); unset($link);

Es importante que este paso para garantizar que los futuros aspectos de una aplicación no puede obtener acceso a estas variables. Esto es especialmente importante cuando la introducción de aplicaciones de terceros en su aplicación personalizada.

259

Una alternativa más segura que el método anterior es envolver todo esto en una clase. Esto es similar a trabajar con un componente cerrado en Flash. El acceso está permitido sólo a lo que usted quiere que otros vean, y el resto está oculto.

Aquí hay un ejemplo de una conexión de base de datos con una clase:

<?php

// simple mysql connection class

class MysqlConnection {

public $link;

private $host = “localhost”; private $user = “SQL_USERNAME”; private $pass = “SQL_PASSWORD”; private $database = “SQL_DB_NAME”;

function MysqlConnection() {}

public function connect() { $this->link = mysql_connect( $this->host, $this->user, $this->pass ); mysql_select_db($this->database, $this->link); }

public function setConnectionDetails($h=’’, $u=’’, $p=’’, $d=’’) { $this->host = $h; $this->user = $u; $this->pass = $p; $this->database = $d; }

public function getLink() { return $this->link; } }

$sql = new MysqlConnection(); $sql->connect();

?>

A primera vista no parece muy diferente de la conexión de ejemplo anterior, sin embargo, la sección importante es la definición de las variables.

public $link;

260

private $host = “localhost”; private $user = “SQL_USERNAME”; private $pass = “SQL_PASSWORD”; private $database = “SQL_DB_NAME”;

Como vimos en el capítulo 9, las variables de clase de PHP se puede dar una designación pública y privada. En esta clase de ejemplo, las variables de conexión se definen como privadas, el bloqueo con fuerza dentro de la clase. Esto garantiza esas variables no pueden ser descubiertos por accidente, y también ofrece otro beneficio. Digamos que tienes un nuevo proyecto y desea conectarse a una base de datos; hacerlo sería tan simple como el siguiente bloque de código.

<?php

include ‘MysqlConnection.php’;

$mysqlConn = new MysqlConnection(); $mysqlConn-> setConnectionDetails(“host”, “user”, “pass”, “db”); $mysqlConn->connect();

$query = “SELECT * FROM our_table”; $result = mysql_query($query, $mysqlConn->getLink()); ?>

Tenga en cuenta que se utiliza la clase de conexión personalizada, información nueva conexión, y finalmente pasar el enlace de la base de datos en la convocatoria de la consulta. En ningún momento de este código es la información de conexión de acceso o expuestos al público en general.

NOTA Cuando se conecte a una base de datos en un servidor de vivir es una buena idea deshabilitar el informe de errores, o al menos suprimir cualquier error de conexión.

Aquí está el archivo de conexión original en su totalidad:

<?php $host = “localhost”; $user = “SQL_USERNAME”; $pass = “SQL_PASSWORD”; $database = “SQL_DB_NAME”;

$link = mysql_connect($host, $user, $pass); mysql_select_db($database, $link);

unset($host); unset($user); unset($pass); unset($database); unset($link); ?>

Crear una tabla de base de datos

En este punto, todos los ActionScript y PHP es escrito. Sin embargo, si intenta probar la aplicación no se ejecutará porque no se ha definido la tabla de SQL que interactúan con el PHP para enviar y la carga de mensajes.

261

La sintaxis SQL es muy fácil de seguir, pero es importante para construir cuidadosamente. El desempeño de un cuadro de construcción deficiente sufrirá más y más a medida que comienza a crecer. Este SQL crea una tabla de FlashChat, y agrega las filas que se utiliza en el PHP. Notificación de la fila de identificación, que no se utiliza en el código PHP, sino que se utiliza internamente para la indización y la asignación de teclas. Otra forma de pensar acerca de la ID es la llave que abre el misterio para que sus datos se encuentra dentro de esta mesa grande.

El mensaje de la filas que usted usa en el PHP son nombre de usuario, y dateAdded. La fila de mensaje es más importante porque se establece como TEXT, lo que da una composición abierta, la capacidad de longitud. Esto significa básicamente un mensaje puede ser de cualquier longitud. Ese registro también podría haber sido asignado un varchar(), que obliguen a la longitud de un límite previamente determinada, como la:

message varchar(150) NOT NULL default ‘’

Esta nueva definición de la fila mensaje obligaría a cualquier mensaje de chat más de 150 caracteres que se trunca o terminado. Establecer como texto es más conveniente, pero tiene problemas potenciales de rendimiento como la base de datos y mesa de crecer.

CREATE TABLE flashChat ( id int(11) not null auto_increment, username varchar(20) NOT NULL default ‘’, message text NOT NULL, dateAdded int(11) NOT NULL default 0, PRIMARY KEY (id) ) ENGINE=MyISAM;

Tomó un montón de código, pero su PHP-impulsado Flash Chat aplicación está completa. Tome el tiempo para revisar el código y extender el ejemplo, para añadir más características. Aquí están algunas ideas para comenzar.

Característica de la primera y probablemente más evidente que se podría agregar algo de mayor nivel de seguridad entre PHP y Flash. También puede añadir un panel de moderación o como un bono de un script de moderación de base haya sido proporcionada en el contenido adicional disponible para este libro.

En este punto, usted debe tener un buen entendimiento de cómo construir una aplicación completa usando Flash, PHP y MySQL. En la siguiente sección, se utiliza Flash y PHP para construir una galería de fotos completa con las categorías y los controles de navegación.

Uso de PHP para el desarrollo de una galleria de fotos

¿Qué es mejor que una galería de Flash? ¿Qué tal una galería Flash dinámico en PHP alimenta autoupdating archivos XML? Esta sección es una guía paso a paso sobre cómo desarrollar eso. El desarrollo comenzará con el código ActionScript y luego mudarse a la parte de PHP. El último paso será evaluar la aplicación de acabados y explicar la manera de avanzar.

Como aprendimos en el comienzo de este capítulo, cada buena aplicación está diseñada y evaluada antes de que la programación comienza. Tome un momento para mirar a la aplicación de acabado, que está disponible en la fuente de material para este libro. Figura 11.4 se muestra la aplicación completa.

262

FIGURA 11.4 La galería de fotos Flash/PHP completado que muestra contenido cargado

El código ActionScript para la aplicación completa automáticamente para rellenar una lista de categorías.Carga dinámica de las imágenes y permitir una navegación anterior y siguiente a través de cada categoría de las imágenes.

El desarrollo de ActionScript

Ahora que sabes lo que hará la aplicación, puede comenzar a colocar las variables.

var phpPath:String = “http://localhost/ch10/photoGallery/”; var phpFile:String = phpPath + “gallery.php”;

var images:Array = new Array();

var imageHolder:MovieClip; var categoryHolder:MovieClip;

Las dos primeras variables hace referencia al archivo PHP que genera la categoría y los datos de la imagen. La variable de las imágenes se utiliza para almacenar los datos de las imágenes enviadas desde el PHP, que se

263

utiliza para cargar las imágenes. Las dos últimas variables en esta sección son MovieClips titular para la imagen principal y la navegación. Ambas variables se rellenan en tiempo de ejecución una vez que se carga la imagen y los datos de la categoría.

El siguiente conjunto de variables que se necesita es específicamente para navegar alrededor de las imágenes y las categorías.

var currentID:uint; var currentImage:Number = 0; var imageDir:String = “photos/”; var cacheBuster:String = “?cb=1”;

El currentID se usa para recordar que la imagen se está viendo. Esto será utilizado en las funciones de navegación anterior y siguiente. El imageDir es una referencia al directorio de la imagen, que es donde está el directorio de la categoría. La última variable es un destructor de la caché, que como se explicó al comienzo de este capítulo se utiliza para asegurar la carga de datos es siempre fresca y no en caché.

Ahora que ha completado el proceso de establecimiento de todas las variables necesarias, puede pasar al núcleo de la aplicación, que es de las funciones.

La función init() es responsable de crear los dos MovieClips holder (titular). El MovieClips se crean dinámicamente, colocado, y adjunta a la lista de visualización. Esto se hace realizando una llamada a addChild y pasando a lo largo de la referencia de MovieClip. La función init también es donde genera el Buster caché. El último paso de la función de inicio es para hacer una llamada a la loadCategories() la función. Es importante que esta función sólo se le llama en el inicio, porque los objetos y las categorías sería indefinido o duplicado.

function init() { imageHolder = new MovieClip(); imageHolder.x = 212; imageHolder.y = 49; addChild(imageHolder);

categoryHolder = new MovieClip(); categoryHolder.x = 15; categoryHolder.y = 50; addChild(categoryHolder);


loadCategories(); }

Una vez que la fase de inicialización de init se ha completado la función loadCategories() es llamado. Esta función se llama al archivo PHP para cargar en la lista de categorías usando URLRequest y pasando a lo largo de una acción personalizada que le dice a la secuencia de comandos que desea que la lista de categorías. Esto es importante porque la gallery.php maneja tanto las categorías y la selección de fotos. En general, la función de loadCategories es bastante similar a otros cargadores utilizados en este libro.

function loadCategories():void { var action:String = “action=cat”; var urlRequest:URLRequest = new URLRequest(phpFile + getCacheBuster() + “&” + action);

264

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, drawCategories); urlLoader.load(urlRequest); }

La función de drawCategories se llama una vez la lista de categorías se ha enviado desde el PHP.Los datos se cargan en un objeto XML y analizado utilizando un bucle for..each. Para comprender mejor el ciclo, mira un ejemplo de XML resultado pasa de nuevo desde el PHP. Uno de estos nodos XML se crea para cada categoría en la galería.

<category id=”2” name=”Landscapes” copyright=”Other”/>

El texto de la categoría que se muestra en el escenario es un campo de texto dinámico creado en el bucle for..each. También puede adjuntar un clip de película de la biblioteca, pero al hacerlo da lugar a una aplicación más fragmentada y se pierden algunas opciones de formato.

function drawCategories(e:Event):void { ... for each(var item in xml..category) { ... } }

Antes de continuar con la aplicación mirada código específico en lo que exactamente se está haciendo para crear el TextField.

var txt:TextField = new TextField(); txt.selectable = false; txt.width = 200; txt.text = “Sample Text”;

La primera línea es la creación de una nueva instancia de TextField y el establecimiento de una referencia a la variable txt.La siguiente línea es asegurarse de que el texto no se puede seleccionar con el ratón.

NOTA No siempre se establece la propiedad seleccionable en false. Los usuarios a menudo como para copiar el contenido, sobre todo bloques de texto.

La segunda a la última línea de código es responsable de establecer la anchura del TextField a 200 píxeles para acomodar el texto. Luego de la última línea es simplemente aplicar el texto que será visible en el cuadro de texto.

Una vez creado el campo de texto, se adjunta un detector de eventos para cargar una categoría de las imágenes cuando el texto se hace clic.

Funciones Anonimas

Una función anónima está directamente ligado a la llamada addEventListener. Una función anónima no puede ser llamado por su nombre porque no tiene uno, es usado como una alternativa a una función habitual cuando la tarea es sencilla y no requiere una gran cantidad de código. Siendo realistas funciones anónimas se utilizan

265

para hacer el código más compacto, o si necesita acceder a una variable que está en el ámbito local en el método de llamada.

Aquí hay un ejemplo de una función anónima similar a la que se ubica dentro de la función drawCategories.

txtContainer.addEventListener(MouseEvent.CLICK,function(e:Event): void { trace(“Anonymous function here, I don’t have a name.”); });

Usted puede notar una de las razones posibles para evitar las funciones anónimas (aparte de no ser multifuncional) es un código que hace mucho más difícil de leer de un vistazo. Esto se debe principalmente al hecho de la definición de la función está enterrado en el addEventListener. Además, una función anónima no puede ser eliminado, lo que puede causar un potencial de pérdidas de memoria.

La última tarea de la función drawCategories es la de conectar el campo de texto a la etapa mediante addChild, como se hace para la categoría.

txtContainer.addChild(txt); categoryHolder.addChild(txtContainer);

Aquí está la función drawCategories completo de referencia.

function drawCategories(e:Event):void { var loader:URLLoader = URLLoader(e.target); var xml:XML = new XML(loader.data);

for each(var item in xml..category) { var txtContainer:MovieClip = new MovieClip(); var txt:TextField = new TextField(); txt.selectable = false; txt.width = 200; txt.text = item.attribute(‘name’); txt.y = uint(item.attribute(‘id’) + 4) * 2; txt.name = “text_” + item.attribute(‘id’); txtContainer.addEventListener(MouseEvent.CLICK, function(e:Event):void { loadImages(e.target.name.substring(5)); }); txtContainer.addChild(txt); categoryHolder.addChild(txtContainer); } }

La siguiente función es centrarse en loadImages. Esta es la función que carga los datos de imagen desde el PHP. El resultado pasa de nuevo es casi idéntica a la encontrada en la función (category) categoría. La variable de medida se establece para las fotos, y también agregar un id de dejar de PHP saber qué fotos para cargar.

function loadImages(id:uint):void { var action:String = “action=photos&id=” + id; var urlRequest:URLRequest = new URLRequest(phpFile +

266

getCacheBuster() + “&” + action); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, imagesLoaded); urlLoader.load(urlRequest); currentID = id; }

Una respuesta se envía de nuevo cuando se carga el PHP, y la función imagesLoaded es llamada. Los datos de imagen se devuelve en formato XML y manejado con un bucle for..each.

Este ciclo de los procesos de cada nodo de fotos en los datos XML y construye un objeto, que se añade "empujado" (“pushed”) a las imágenes de matriz.

function imagesLoaded(e:Event):void { for each(var item in xml..photo) { images.push({name:’’, src:item.attribute(‘src’)}); }... }

He aquí el objeto por sí mismo y un método alternativo y más legible de la creación del objeto.

{ name:’’, src:item.attribute(‘src’) }

Aquí está el método alternativo para definir el objeto.

var obj:Object = new Object(); obj.name = ‘’; obj.src = item.attribute(‘src’);

La última tarea de la función de imagesLoaded es establecer la variable de currentImage y hacer una llamada a la función DisplayImage pasando la fuente de imagen. El origen de la imagen se carga desde la matriz de imágenes usando currentImage como el índice de la matriz.

function imagesLoaded(e:Event):void { ... currentImage = 0; displayImage(images[currentImage].src); }

Esta es la función imagesLoaded completa:

function imagesLoaded(e:Event):void { var loader:URLLoader = URLLoader(e.target); var xml:XML = new XML(loader.data); images = new Array(); for each(var item in xml..photo) { images.push({name:’’, src:item.attribute(‘src’)}); }currentImage = 0; displayImage(images[currentImage].src);

267

}

Con las categorías y las imágenes cargadas, puede mostrar la imagen. Esto se hace mediante la asignación de un URLRequest construcción del directorio de imagen, id de la categoría actual, y el nombre de la foto. La clase cargador se coloca directamente en una llamada addChild, que maneja la visualización de la imagen una vez que esté completamente cargada. Usted no notará ningún tiempo de carga a nivel local, pero puede ser en línea.

NOTA Es buena práctica colocar preloaders donde los datos se cargan. Esto informa al usuario de que algo está pasando.

function displayImage(src:String):void { var loader:Loader = new Loader(); loader.load(new URLRequest(imageDir + currentID + “/” + src)); imageHolder.addChild(loader); }

Navegacion de galeria de fotos

La parte de navegación de la galería de fotos está construida con dos clips de película en el escenario. Cada uno de los clips se asigna a un controlador de eventos que, o bien de cargar la imagen siguiente o la anterior.

Navegación de Imagen

Usted notará que la función nextImage() tiene algo de lógica condicional. Esta es la comprobación para ver si la variable currentImage es un número mayor que el total de las imágenes, lo que daría lugar a un error de carga. El mismo proceso básico se hace para la función prevImage() con la excepción de que el cheque condicional es garantizar el valor no sea inferior a cero.

NOTA Las funciones de la imagen anterior y siguiente se bloqueará si una categoría no ha sido elegido.

function nextImage(e:MouseEvent):void { currentImage++; if(currentImage > images.length-1) { currentImage = 0; }displayImage(images[currentImage].src); }

function prevImage(e:MouseEvent):void { currentImage--; if(currentImage <= 0) { currentImage = images.length-1; }displayImage(images[currentImage].src); }

268

La última función en el script de galería de fotos se utiliza para generar su buster caché, que se utiliza para asegurar las llamadas al servidor nunca se almacenan en caché. Esta función es idéntica a la utilizada en el Flash aplicación de chat que construyó anteriormente en este capítulo.

La última parte de la aplicación es llamar a init() en el inicio de la aplicación y asignar los manejadores de eventos que utiliza los botones de navegación.


init();

prevMC.addEventListener(MouseEvent.CLICK, prevImage); nextMC.addEventListener(MouseEvent.CLICK, nextImage);

Aquí está el código ActionScript completo para la aplicación galería de fotos:

var phpPath:String = “http://localhost/ch%2010/photoGallery/”; var phpFile:String = phpPath + “gallery.php”;

var images:Array = new Array();

var imageHolder:MovieClip; var categoryHolder:MovieClip;

var currentID:uint; var imageDir:String = “photos/”;

var currentImage:uint = 0;

var cacheBuster:String = “?cb=1”;

function init() { imageHolder = new MovieClip(); imageHolder.x = 212; imageHolder.y = 49; addChild(imageHolder);

categoryHolder = new MovieClip(); categoryHolder.x = 15; categoryHolder.y = 50; addChild(categoryHolder);


loadCategories(); }

function loadCategories():void { var action:String = “action=cat”; var urlRequest:URLRequest = new URLRequest(phpFile +

269

getCacheBuster() + “&” + action);

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, drawCategories); urlLoader.load(urlRequest); }

function drawCategories(e:Event):void { var loader:URLLoader = URLLoader(e.target); var xml:XML = new XML(loader.data);

for each(var item in xml..category) { var txtContainer:MovieClip = new MovieClip();

var txt:TextField = new TextField(); txt.selectable = false; txt.width = 200; txt.text = item.attribute(‘name’); txt.y = uint(item.attribute(‘id’) + 4) * 2; txt.name = “text_” + item.attribute(‘id’); txtContainer.addEventListener(MouseEvent.CLICK, function(e:Event):void { loadImages(e.target.name.substring(5)); });

txtContainer.buttonMode = true;

txtContainer.addChild(txt); categoryHolder.addChild(txtContainer);

} }

function loadImages(id:uint):void { trace(“Load Images: “ + id); var action:String = “action=photos&id=” + id; var urlRequest:URLRequest = new URLRequest(phpFile + getCacheBuster() + “&” + action);

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, imagesLoaded); urlLoader.load(urlRequest); currentID = id; }

function imagesLoaded(e:Event):void { var loader:URLLoader = URLLoader(e.target); var xml:XML = new XML(loader.data); images = new Array();

for each(var item in xml..photo) { images.push({name:’’, src:item.attribute(‘src’)}); }

270

currentImage = 0; displayImage(images[currentImage].src); }

function displayImage(src:String):void { trace(“Load Image: “ + src);

var loader:Loader = new Loader(); loader.load(new URLRequest(imageDir + currentID + “/” + src)); imageHolder.addChild(loader); }

function nextImage(e:MouseEvent):void { currentImage++; if(currentImage > images.length-1) { currentImage = 0; }displayImage(images[currentImage].src); }

function prevImage(e:MouseEvent):void { currentImage--; if(currentImage <= 0) { currentImage = images.length-1; }displayImage(images[currentImage].src); }


init();

prevMC.addEventListener(MouseEvent.CLICK, prevImage); nextMC.addEventListener(MouseEvent.CLICK, nextImage);

PHP para la galleria de fotos

La parte de PHP de esta aplicación galería de fotos está construido de tres archivos. El primer archivo es categories.php, que es una representación estática de las categorías de ser enviado a ActionScript.

La primera parte del código es la categoría en un formato de matriz multidimensional. Los elementos de categoría tienen el nombre, id, y la información de derechos de autor para cada categoría.

$categories = array( array(“Boston”, 1, “M. Keefe”), array(“Landscapes”, 2, “Other”),

271

array(“Las Vegas”, 3, “M. Keefe”), array(“Weddings”, 4, “Other”), );

La primera función GetCategories() se establece una referencia global a la variable $categories. El siguiente paso es definir un bucle que se encargará de construir los datos XML que se reintegrará a ActionScript.

function getCategories() { global $categories;

$xml = “<categories>\n”;

for($i=0; $i < count($categories); $i++) { $xml .= “ <category id=\”” . $categories[$i][1] . “\” name=\”” . $categories[$i][0] . “\” copyright=\”” . $categories[$i][2] . “\” />\n”; }

$xml .= “</categories>”;

return $xml; }

La longitud del bucle está determinado por cuán grande es el array $categories pasa a ser.

count($categories)

El cuerpo del bucle no es más que la construcción de los datos XML, similar a la muestra miró durante la parte de desarrollo de ActionScript.

$xml .= “ <category id=\”” . $categories[$i][1] . “\” name=\”” . $categories[$i][0] . “\” copyright=\”” . $categories[$i][2] . “\” />\n”;

El último paso de esta función es la de devolver los datos XML de ActionScript para el proceso.

return $xml;

Aquí está el archivo categories.php en su totalidad:

<?php

$categories = array( array(“Boston”, 1, “M. Keefe”), array(“Landscapes”, 2, “Other”), array(“Las Vegas”, 3, “M. Keefe”), array(“Weddings”, 4, “Other”), );

function getCategories() {

global $categories;

272

$xml = “<categories>\n”;

for($i=0; $i < count($categories); $i++) { $xml .= “ <category id=\”” . $categories[$i][1] . “\” name=\”” . $categories[$i][0] . “\” copyright=\”” . $categories[$i][2] . “\” />\n”; }

$xml .= “</categories>”;

return $xml; }

?>

El archivo siguiente a desarrollar es getPhotos.php, que abre el directorio de foto y devuelve el archivo XML de población con información de origen para cada una de las fotos.

La carne de este archivo es la función getPhotosFromID(), que acepta un argumento, un id.Usted quiere asegurarse de que una identificación válida se pasa antes de continuar por lo que una sentencia condicional simple trabajará en este caso. Si un número de identificación válido se ha encontrado, entonces se puede continuar con la apertura de las mismas y el bucle while.

<?php

$photo_dir = “photos/”;

function getPhotosFromID($id=null) { global $photo_dir;

if($id == null) { print “ID Not Provided”; return false; }

$xml = “<photos id=\”” . $id . “\”>”;

$dir = opendir($photo_dir . $id); while(false !== ($file = readdir($dir))) { if($file != “.” && $file != “..”) { $xml .= “<photo name=\”” . “” . “\” src=\”” . $file . “\” />\n”; } }closedir($dir);

$xml .= “</photos>”;

return $xml; }

273

?>

El bucle while está configurado para recorrer cada archivo en el directorio hasta que el puntero de archivo es falso, lo que significa que no se encontró archivo válido.

while(false !== ($file = readdir($dir))) { ... }

Se utiliza un condicional si la declaración de exclude .y .. que es punteros de directorio para el directorio actual y directorio padre. Si se excluye este control, habrá al menos dos entradas falsas en el archivo XML, o peor aún, el archivo puede error a cabo todos juntos, ya que podría poner el bucle while en un estado recursiva infinita.

Después de todas las imágenes en el directorio se reunieron, se desea cerrar el directorio para liberar recursos valiosos. Esto es especialmente importante si el archivo puede ser utilizado por otra persona al mismo tiempo.

closedir($dir);

El último paso en este archivo es devolver el XML para el proceso de flash.

Después de haber creado la categoría y los archivos de fotos, puede crear el archivo de gallery.php, que maneja las llamadas de PHP y devuelve el código XML adecuado de acuerdo con lo que se.

<?php

include ‘categories.php’; include ‘getPhotos.php’;

header(‘Content-type: text/xml’);

if($_GET[‘action’] == ‘cat’) { print getCategories(); }else if($_GET[‘action’] == ‘photos’) { print getPhotosFromID($_GET[‘id’]); }

?>

Este archivo se inicia mediante la inclusión de los dos archivos anteriores que has creado. Luego, un cabecera() “header()” es de obligar a la salida de todo el contenido en formato XML apropiado. Esta función de cabecera se puede utilizar para casi cualquier tipo de contenido. Es, básicamente, fijarlo, y desde ese punto de la salida sigue a ese formato. Por ejemplo, suponga que desea exportar contenido como PNG.

header(“Content-type: image/png”);

NOTA Asegúrese de utilizar el tipo de contenido correcto en su aplicación. Usando el incorrecto puede provocar errores y, en raras ocasiones una aplicación de accidente.

274

El último bloque de código se utiliza para determinar el contenido que usted está solicitando. Los dos tipos de contenido disponibles en este ejemplo son la categoría y la lista de fotos. La variable $_GET [ 'action'] se pasa de Flash en la dirección URL como una cadena de consulta. http://localhost/photoGallery/gallery.php?cb=1192408716823&action=cat En este punto, la galería Flash impulsados por PHP es completa. Se puede extender este ejemplo, para añadir páginas, de las transiciones, o quizás algunos títulos y descripciones para cada imagen.

Esa es la cosa fresca sobre ActionScript: se puede extender a partir de ejemplos del libro, o simplemente use a su barco.

Uso de PHP para desarrollar un lector RSSLos lectores de RSS es un tema muy popular, y las aplicaciones se pueden encontrar para casi todos los dispositivos que tengan habilitada su web. Se pueden encontrar de todo, desde un navegador en su escritorio para el teléfono en tu bolsillo.

El RSS es un grupo de canales web utiliza para publicar el contenido frecuentemente actualizado, como las entradas, titulares de noticias, podcasts, o el entretenimiento. Otra forma de pensar de alguien que RSS es la entrega de las noticias diarias directamente a usted, la única diferencia es que no hay límite a la cantidad de alimentos puede suscribirse a. Lo que sigue es un vistazo a la aplicación de RSS que usted desarrollará y cómo va a funcionar, como se muestra en la Figura 11.5.

275

http://localhost/photoGallery/gallery.php?cb=1192408716823&action=cat

FIGURA 11.5 El lector de RSS con un sistema de distribución de PHP

La aplicación está construido con componentes prediseñados que ya han sido colocados en el archivo de partida. Los tres elementos principales que interesan son la lista, TextArea, y componentes Enviar. Cada uno de estos componentes se le ha asignado un nombre de instancia que se hace referencia en el código ActionScript.

Importar clases

La mayoría de las clases que se incluyen con Flash no requieren volver a importarlos. Sin embargo, hay algunas excepciones, una de las cuales es la clase ListEvent.

import fl.events.ListEvent;

276

Cuando el evento es importado puede asignar las variables de la aplicación de RSS. La única variable global que se necesita para esta aplicación es la referencia de PHP.

var phpPath:String = “http://locahost/ch10/rssReader/”; var phpFile:String = phpPath + “rss.php”;

Cargar el PHP

La función utilizada para cargar el PHP, que devuelve XML es muy similar a los ejemplos anteriores. Establecer un URLRequest, un URLLoader, y adjuntar un controlador al evento COMPLETE.

function loadFeeds():void { var urlRequest:URLRequest = new URLRequest(phpFile); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, feedHandler); urlLoader.load(urlRequest); }

La función feedHandler() es responsable de trabajar con la respuesta de la llamada de PHP. En esta aplicación, el PHP devuelve XML, que se utiliza para rellenar el componente List. El RSS de las entradas se colocan en el componente de la lista utilizando la función addItem().

Esta función feedHandler acepta un objeto como argumento. El objeto necesita al menos una etiqueta de propiedad con el fin de añadir el elemento, pero por lo general, se agrega la propiedad de datos, así.

function feedHandler(e:Event):void { ... for each(var item in xml..entry) { topicsList.addItem({label:item..name, data:item..desc}); topicsList.addEventListener(ListEvent.ITEM_CLICK, listClickhandler); } }

Los elementos de la lista de carga el cuerpo del texto cuando se hace clic, de modo de crear la función que se encarga de este evento. El ListEvent se pasa desde el evento ITEM_CLICK, que contiene la propiedad del elemento. La propiedad es el punto donde se almacena la propiedad de datos. En este ejemplo, que los datos es el órgano de RSS, por lo que simplemente puede pasar que los datos directamente a la TextArea feedBody.

function listClickhandler(e:ListEvent):void { feedBody.htmlText = e.item.data; }

La última función en la aplicación de RSS es el controlador de botón, que es llamado cada vez que el componente Button se hace clic. Esta función simplemente hace una llamada a la función loadFeeds.

function submitHandler(e:Event):void { loadFeeds(); }

277

Como puede ver, el ActionScript es bastante simple para este ejemplo. XML realmente acelera el desarrollo de aplicaciones web-enabled, y este es un ejemplo perfecto de ello.

Aquí está el código de la aplicación de RSS en su totalidad por referencia:

import fl.events.ListEvent;

var phpPath:String = “http://localhost/ch10/rssReader/”; var phpFile:String = phpPath + “rss.php”;

function loadFeeds():void { var urlRequest:URLRequest = new URLRequest(phpFile); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, feedHandler); urlLoader.load(urlRequest); }

function feedHandler(e:Event):void { var loader:URLLoader = URLLoader(e.target); var xml:XML = new XML(loader.data);

for each(var item in xml..entry) { topicsList.addItem({label:item..name, data:item..desc}); topicsList.addEventListener(ListEvent.ITEM_CLICK, listClickhandler); } }

function listClickhandler(e:ListEvent):void { feedBody.htmlText = e.item.data; }

function submitHandler(e:Event):void { loadFeeds(); }

loadBtn.addEventListener(MouseEvent.CLICK, submitHandler);

Con la porción de ActionScript del lector RSS terminado usted puede centrarse en el código PHP.

La conexión RSS que está siendo utilizado para este ejemplo, como se muestra en la figura 11.6, viene de Adobe y son las últimas noticias e información sobre Adobe AIR.

<?php $rssFeed = “http://weblogs.macromedia.com/mxna/xml/rss.cfm?” . “query=bySmartCategory&languages=1&smartCategoryId=28&” . “smartCategoryKey=F2DFD9E0-FBB6-4C2D-2AFE6AFD941FDDB1”; ?>

278

FIGURA 11.6 ¿Cómo se ve la fuente RSS en su navegador web, suponiendo que usted no tiene instalado un lector RSS

La variable $feed es un marcador de posición para el XML generado que se construye una vez que la fuente RSS se carga correctamente. El RSS es leída en el uso de la biblioteca SimpleXML que se entrega con PHP 5. Esta no es la única biblioteca de XML de análisis disponibles para PHP, pero es el más eficiente y más fácil de usar.

$feed = “”; $xml = simplexml_load_file($rssFeed);

En este punto, usted puede comenzar a construir el bucle foreach, que es responsable de construir el documento XML se reintegrará al ActionScript.

$feed .= “<items>\n”;

foreach($xml->item as $item) { $desc = $item->description;

279

$desc = preg_replace(‘/[...\[\]]/’, ‘’, $desc);

$feed .= “ <entry>\n”; $feed .= “ <name>” . $item->title . “</name>\n”; $feed .= “ <desc><![CDATA[“ . $desc .”]]></desc>\n”; $feed .= “ </entry>\n”; }

$feed .= “</items>\n”;

El ciclo de tomar cada elemento del XML y los lazos a través de los nodos de elemento.

Usted notará que la descripción no está asignado a una variable $desc. La razón de esto es porque la descripción tiene que ser limpiado antes de devolverlo. El proceso de limpieza se realiza mediante preg_replace(), una función de expresión regular que elimina los caracteres sin escapar e impropio.


NOTA Este libro no ofrece un tutorial en profundidad sobre las expresiones regulares (regex), sin embargo, hay una guía muy bueno encontrar en http://php.net/manual/en/reference.pcre.pattern.syntax.php.

La última parte del código PHP establece el tipo de cabecera y los resultados del XML en ActionScript.

header(‘Content-type: text/xml’); print ‘<?xml version=”1.0” encoding=”UTF-8”?>’ .”\n”; print $feed;

Usted notará que la requerida de PHP para generar la aplicación de RSS no es en profundidad, mucho de eso se debe a SimpleXML ser tan gran biblioteca. Este ejemplo podría extenderse a tirar más de la información contenida en el feed RSS. Por ejemplo, puede mostrar el título de la entrada, la fecha, e incluso la dirección donde se encuentra la entrada original.

Por último, aquí está la referencia completa para PHP:

<?php

$rssFeed = “http://weblogs.macromedia.com/mxna/xml/rss.cfm?” . “query=bySmartCategory&languages=1&smartCategoryId=28&” . “smartCategoryKey=F2DFD9E0-FBB6-4C2D-2AFE6AFD941FDDB1”;

$feed = “”; $xml = simplexml_load_file($rssFeed);

$feed .= “<items>\n”;

foreach($xml->item as $item) { $desc = $item->description;


$feed .= “ <entry>\n”; $feed .= “ <name>” . $item->title . “</name>\n”; $feed .= “ <desc><![CDATA[“ . $desc .”]]></desc>\n”; $feed .= “ </entry>\n”;

280

http://php.net/manual/en/reference.pcre.pattern.syntax.php

}

$feed .= “</items>\n”;

header(‘Content-type: text/xml’); print ‘<?xml version=”1.0” encoding=”UTF-8”?>’ .”\n”; print $feed;

?>

Uso de PHP, Flash, y MySQL para desarrollar un banner dinámico

Muchos de los diseñadores utilizan Flash para crear anuncios para ser colocados en línea. Estos van desde los anuncios de mini dentro de una página de anuncios de toda regla que se la página. El formato de anuncio más común es el anuncio de la bandera, que normalmente es 468 × 60, como se muestra en la Figura 11.7, los píxeles de tamaño. Estas banderas son generalmente secuencias de comandos para cargar un sitio web al hacer clic. ¿Qué pasa con el seguimiento de los clics? Aún mejor, ¿por qué no crear un banner dinámico que carga un anuncio al azar y no requiere que el propietario de actualizar algo más que un archivo XML y directorio de la imagen?

Esta sección será el proceso de desarrollo de un banner dinámico en Flash. A continuación, añadir el seguimiento a este banner utilizando sólo unas pocas líneas de PHP. Este ejemplo no requiere los archivos de partida, porque cualquier imagen de trabajo para la bandera, y la aplicación va a ser desarrollado 100 por ciento en el código ActionScript.

FIGURA 11.7 Ejemplo de la aplicación de anuncios de banner en acción

La primera parte del código es responsable de la inicialización de las variables utilizadas en la aplicación.

var phpPath:String = “http://localhost/ch10/bannerAd/”; var phpFile:String = phpPath + “ads.php”;

var imageHolder:MovieClip; var cacheBuster:String = “?cb=1”; var adURL:String;

Una vez que las variables se definen usted puede construir las funciones. El primero es responsable de la colocación del titular de la imagen, añadiendo el controlador de eventos, y llamando a la función loadImage.

imageHolder = new MovieClip(); imageHolder.x = 0; imageHolder.y = 0; imageHolder.addEventListener(MouseEvent.CLICK, loadAdURL); imageHolder.buttonMode = true;

281

addChild(imageHolder);


loadImage();

La función loadImage() es responsable de cargar el archivo XML que contiene los datos de anuncios de banner.A continuación, asigne una función de controlador que se llama después de que el XML es completamente cargado.

function loadImage():void { var urlRequest:URLRequest = new URLRequest(phpFile + getCacheBuster()); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, imageLoaded); urlLoader.load(urlRequest); }

Después de que el XML es a plena carga, se hace una llamada a imageLoaded. Esta función es responsable de cargar los datos XML, sacando la información de la imagen, y la carga de la imagen. Lo que sigue es un vistazo a cada parte, de una en una.

El siguiente es el proceso de carga de los datos y crear el objeto XML:

function imageLoaded(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data); ...

La siguiente parte de esta función es ayudar a introducir los datos de imagen y asignarle a las variables locales:

var url:String = xml..banner.attribute(‘url’); var name:String = xml..banner.attribute(‘name’); var image:String = xml..banner.attribute(‘src’); var directory:String = xml..banner.attribute(‘dir’);

adURL = url;

El último paso en esta función es la de cargar la imagen y adjuntarlo a la lista de visualización:

var loader:Loader = new Loader(); loader.load(new URLRequest(directory + image)); imageHolder.addChild(loader);

Abrir una ventana del navegador

El proceso de cargar y mostrar el anuncio ha finalizado. El siguiente paso es asignar el controlador de eventos que se llama cuando se hace clic en el banner. Utilice navigateToURL() para abrir una nueva ventana del navegador y vaya a la página de anuncios predeterminados.

function loadAdURL(e:MouseEvent):void { navigateToURL(new URLRequest(adURL));

282

}

La última tarea del ActionScript es llamar a la función init() y comenzar el proceso.

init();

Aquí está el código ActionScript para la referencia completa:

var phpPath:String = “http://localhost/ch10/bannerAd/”; var phpFile:String = phpPath + “ads.php”;

var imageHolder:MovieClip; var cacheBuster:String = “?cb=1”; var adURL:String;

function init() { imageHolder = new MovieClip(); imageHolder.x = 0; imageHolder.y = 0; imageHolder.addEventListener(MouseEvent.CLICK, loadAdURL); imageHolder.buttonMode = true; addChild(imageHolder);


loadImage(); }function loadImage():void { var urlRequest:URLRequest = new URLRequest(phpFile + getCacheBuster()); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, imageLoaded); urlLoader.load(urlRequest); }

function imageLoaded(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

var url:String = xml..banner.attribute(‘url’); var name:String = xml..banner.attribute(‘name’); var image:String = xml..banner.attribute(‘src’); var directory:String = xml..banner.attribute(‘dir’);

adURL = url;

var loader:Loader = new Loader(); loader.load(new URLRequest(directory + image)); imageHolder.addChild(loader); }

function loadAdURL(e:MouseEvent):void { navigateToURL(new URLRequest(adURL)); }

283


init();

Desarrollo del PHP

En este punto, el código ActionScript está completo y usted puede centrarse en el PHP. El archivo ads.php se compone de dos variables globales y una función.

La primera variable global es el directorio donde se encuentran las imágenes del anuncio. La segunda variable es la matriz que contiene los datos de los anuncios.

$adImageDir = “./adImages/”; $bannerAds = array( array(‘Banner Name’, ‘randomimage1.jpg’, ‘http://localhost/’), array(‘Banner Name’, ‘randomimage2.jpg’, ‘http://localhost/’), );

La función getBannerAd asigna las dos variables como globales para que sean accesibles dentro de esta función.

Selección aleatoria El banner solo se elige de la matriz mediante el uso de una clave aleatoria. Esta clave aleatoria se genera mediante la función mt_rand() y la longitud de la matriz $bannerAds ($anunciosdebanner).

$random = (mt_rand() % count($bannerAds));

El archivo XML es construido para dar salida una sola línea de datos de imágenes que ActionScript procesa.

function getBannerAd() { ...

$xml .= “ <banner id=\”” . 0 . “\” dir=\”” . $adImageDir . “\” url=\”” . $bannerAds[$random][2] . “\” name=\”” . $bannerAds[$random][0] . “\” src=\”” . $bannerAds[$random][1] . “\” />\n”;

$xml .= “</banners>”;

return $xml; }

print getBannerAd();

284

El PHP responsable de cargar el anuncio de la bandera ya está completa. Como puede ver, la cantidad de código necesario para crear esta aplicación es bastante pequeño. Este ejemplo básico se puede ampliar fácilmente para agregar en categorías o imágenes, incluso varios que la transición de la película se sienta en un navegador.

Aquí está el código de referencia para completar.

<?php

$adImageDir = “./adImages/”;

$bannerAds = array( array(‘Banner 1’, ‘randomimage1.jpg’, ‘http://localhost/’), array(‘Banner 2’, ‘randomimage2.jpg’, ‘http://localhost/’), array(‘Banner 3’, ‘randomimage3.jpg’, ‘http://localhost/’), array(‘Banner 4’, ‘randomimage4.jpg’, ‘http://localhost/’), array(‘Banner 5’, ‘randomimage5.jpg’, ‘http://localhost/’), array(‘Banner 6’, ‘randomimage6.jpg’, ‘http://localhost/’), array(‘Banner 7’, ‘randomimage7.jpg’, ‘http://localhost/’), array(‘Banner 8, ‘randomimage8.jpg’, ‘http://localhost/’) );

function getBannerAd() { global $bannerAds, $adImageDir;

$xml = “<banners>\n”;

$random = (mt_rand() % count($bannerAds));

$xml .= “ <banner id=\”” . 0 . “\” dir=\”” . $adImageDir . “\” url=\”” . $bannerAds[$random][2] . “\” name=\”” . $bannerAds[$random][0] . “\” src=\”” . $bannerAds[$random][1] . “\” />\n”;

$xml .= “</banners>”;

return $xml; }

print getBannerAd();

?>

Ahora ha creado con éxito un PHP totalmente funcional y de anuncios de banner Flash espectador. Los conceptos aprendidos en esta sección se pueden adaptar fácilmente a otros proyectos. De hecho, le animamos a ampliar el ejemplo y crear una aplicación más robusta.

Esta aplicación también se puede simplificar al cargar un archivo XML estático, sin embargo, esto es más difícil de actualizar y no ofrece el mismo nivel de personalización. La aplicación como PHP significa que usted puede adjuntar una capa de base de datos MySQL a ella y devolver los datos de la imagen de una base de datos, lo más probable es que se actualizará de otra fuente.

285

Uso de PHP para desarrollar un contador de visitas

Un contador de visitas (hit counter) es usada para determinar cuántos visitantes van a un sitio. En general, el contador es visible para los visitantes en forma de texto o un gráfico. Algunos sitios utilizan otras formas de control que no están disponibles al público, para fines de seguimiento de estadísticas. El sorteo de importantes y las características de un golpe contra alguna representación gráfica. Puede utilizar un archivo de texto plano o base de datos SQL para almacenar los datos del contador de visitas. Este ejemplo utiliza una base de datos SQL para un par de razones: la velocidad (la base de datos puede procesar la información mucho más rápido) y el archivo se refiere a permiso. En casos raros, un servidor puede colocar un bloqueo en un archivo, lo que significa que ese archivo no se puede abrir. Esto forzaría el contador de visitas a fallar y no es el resultado ideal que se busca.

Contador de visita lógico

La lógica detrás de el contador de visitas es bastante sencillo. En primer lugar, realizar una llamada a la base de datos para capturar el recuento de visitas actual y se incrementará por 1.

$oldCount = $row[‘amount’]; $newCount = $oldCount + 1;

Cuando tenga el nuevo valor, enviarlo de nuevo en la tabla de SQL. Para ello, la actualización de la fila existente y el establecimiento de la columna de importe que el valor de la variable $newCount.

mysql_query(“UPDATE counter SET amount=” . $newCount);

El último paso en el código PHP es devolver el valor nuevo a Flash para que se muestre.

return “resp=” . $newCount;

Eso es todo el PHP las necesidades de la lógica de contador de visitas. El siguiente es el archivo completo.

<?php

include ‘dbConn.php’;

$query = “SELECT amount from counter”; $result = mysql_query($query); $row = mysql_fetch_array($result); $oldCount = $row[‘amount’]; $newCount = $oldCount + 1;

mysql_query(“UPDATE counter SET amount=” . $newCount);

return “resp=” . $newCount;

?>

Desarrollo de contador de visitas en Flash

Con el PHP hecho, usted puede moverse sobre el desarrollo de Flash, que consiste en una aplicación de todos los ActionScript.

286

El contador tiene que llamar primero al archivo PHP, que sirve a dos propósitos. La primera es llamar al archivo PHP a la carga y el incremento de la cuenta. El segundo objetivo es devolver el nuevo valor, que se pasa a un campo de texto dinámico.

La primera parte consiste en asignar la variable de phpfile, que es una referencia para el contador de archivo que se encuentra en el servidor.

var phpFile:String = “ http://localhost/ch10/hitCounter/”;

La primera función es la de construir loadHitCounter(), que es responsable de llamar al servidor y asignar el manejador de la respuesta.

function loadHitCounter():void { var urlRequest:URLRequest = new URLRequest(phpFile); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, handleServerResp); urlLoader.load(urlRequest); }

Después que la respuesta se ha cargado, el handleServerResp() se llama pasa a lo largo de los datos cargados.Esta información es posteriormente enviada a la clase URLVariables para sacar la propiedad resp. Esta propiedad es donde se encuentra la cuenta actual.

function handleServerResp(e:Event):void { var loader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(loader.data); var count:uint = variables.resp; ... }

El recuento es finalmente colocado en el campo de texto dinámico, que no tiene el formato de este ejemplo, pero usted puede agregar fácilmente esto por su cuenta.

var txt:TextField = new TextField(); txt.selectable = false; txt.width = 200; txt.text = count + “ visitors”; }

La última línea absoluta de código en el ActionScript es la llamada a la función loadHitCounter, que comienza todo de encima.

loadHitCounter();

Resumen

En este capítulo usted aprendió los elementos de desarrollo y diseño de una aplicación. Luego, una vez entendido como la aplicación debe ser construido se construyó un cliente de chat usando PHP y Flash.

287

http://localhost/ch10/hitCounter/

En la siguiente sección usted aprendió a desarrollar una galería de fotos basada en Flash con la categoría dinámica y soporte de imágenes con XML.

La última sección se dedicó al desarrollo de otras aplicaciones que utilicen Flash, PHP y MySQL para comprender mejor los conceptos.

Usted debe ahora tener una buena idea de cómo construir aplicaciones robustas que se aprovechan de los datos dinámicos para la actualización y funcionalidad.

288

Capitulo 12

Desarrollo de las aplicaciones

del mundo real En este capítulo, aprenderá acerca de cómo desarrollar aplicaciones completas de la tierra para arriba. La atención se centra en la clase basado en los diseños que puede actualizar fácilmente más adelante. El aspecto principal de este capítulo será cómo utilizar Flash y PHP para desarrollar estas aplicaciones.

Este capítulo está dividido en cuatro aplicaciones: un carro de PayPal, carrito de la compra personalizado, buscador de Amazon, Flickr y un buscador de galería de fotos. Cada sección se inicia con la solicitud de código PHP y continúa con el ActionScript. Construcción de una aplicación como esta hace que sea más fácil de probar como se construye y reduce la cantidad de tiempo en el proceso de desarrollo.

Los ejemplos en este capítulo son construidos con clases personalizadas, que se tratan en el capítulo 9. Si usted no ha leído el capítulo, sin embargo, os recomiendo que lo hagan antes de continuar en este capítulo. Por supuesto, si usted ha utilizado las clases en el pasado, entonces por todos los medios continuar en.

Entender las aplicaciones del mundo real

Una aplicación real es uno que ha sido diseñado, probado y desplegado con la intención de que los otros usuarios podrán utilizarlo.

Al igual que en una aplicación real que habrá algunos sectores que utilizan una de tercero Application Programming Interface (API) para la carga y búsqueda de datos.Cuando se trabaja con un API es común encontrar una lista de los métodos y las llamadas permitido, como se muestra en la Figura 12.1.

289

FIGURA 12.1 La lista de API de Flickr, que muestra que los métodos y propiedades están públicamente disponibles

Una API abierta no siempre significa que cualquiera puede tener acceso. Por ejemplo, en Flickr que están obligados a pasar a lo largo de una clave que autoriza a una solicitud. Esto no es sólo para bloquear ciertos aspectos de una API, pero también se detiene el correo basura y respuestas automáticas que podría resultar en la API de ser discapacitado.

El Amazon y ejemplos de Flickr en este capítulo utilizan las API, pero la primera cosa a mirar son las normas y requisitos para la API que está utilizando.

Uso de PayPal en Flash

Trabajar con PayPal en Flash es similar al HTML, porque PayPal ofrece un conjunto común de conexión y capacidad de acceso. Sin embargo, una ventaja para desarrollar la solución en Flash es la capacidad para mejorar la experiencia del usuario, Flash ofrece una comunicación más fluida con otros servicios, ya que no es necesario recargar toda la página o abrir las ventanas adicionales.

290

Registrarse en PayPal Premier

Antes de comenzar a escribir el código para interactuar con PayPal, crear una cuenta PayPal Premier, que puede utilizar para el seguimiento de sus ventas y autenticar sus peticiones. Sólo toma unos minutos para crear una cuenta, y no cuesta nada.

Para configurar una cuenta PayPal Premier, siga estos pasos:

1. En el explorador Web, vaya a www.paypal.com. Seleccione Iniciar - Tipos de cuenta. 2. En la página Tipos de cuenta PayPal, haga clic en Regístrese ahora. Seleccione la cuenta de la página que aparezca Tipo. 3. Bajo Cuenta Premier, haga clic en Iniciar ahora. En Crear un formulario de cuenta PayPal que aparece (ver Figura 12.2), escriba la información solicitada. 4. Después de enviar su formulario, usted recibió un correo electrónico de confirmación. Usted debe responder al e-mail para activar su cuenta. 5. Entra y prueba de su nueva cuenta.

NOTA Recuerde, usted debe activar la cuenta a través de e-mail antes de que usted puede usar.

FIGURA 12.2 La pantalla de registro de la cuenta de PayPal

291

En este punto, usted debe tener un inicio de sesión de trabajo de PayPal. Uso de la cuenta que acaba de registrar para que usted puede acceder a PayPal y empiece a configurar los detalles en cuenta.

NOTA El sistema requiere un nombre de usuario y contraseña para generar contenido. Sin embargo, con el fin de presentar una solicitud de datos sólo tiene que proporcionar su dirección de correo electrónico. Esto se utiliza para garantizar la solicitud es correcta. En ningún momento debe colocar la contraseña de PayPal en esta forma.

Haga clic en el enlace de vendedor (Merchant) en la parte superior de la página para visitar la página Compre Ahora generador. Las otras opciones en la primera pantalla no son importantes en este punto. Por último, haga clic en Crear botón, que se trasladará a la siguiente página, donde el código HTML es que el botón Comprar ahora. Copia el código HTML que es generado por PayPal para los botones Comprar ahora.

Este código se utiliza para construir el ejemplo de Flash. Lo que sigue es el código de ejemplo copia de sistema generador de PayPal comerciante que usted acaba de visitar.

<form action=”https://www.paypal.com/cgi-bin/webscr” method=”post”> <input type=”hidden” name=”cmd” value=”_xclick”> <input type=”hidden” name=”business” value=”{email_address}”> <input type=”hidden” name=”item_name” value=”{item_name}”> <input type=”hidden” name=”item_number” value=”{item_number}”>

292

<input type=”hidden” name=”amount” value=”{item_amount}”> <input type=”hidden” name=”currency_code” value=”USD”> <input type=”hidden” name=”weight” value=”1”> <input type=”hidden” name=”weight_unit” value=”lbs”> <input type=”hidden” name=”lc” value=”US”> </form>

NOTA Asegúrese de que usted no tiene botón de encriptación activada, ello hace que sea imposible coger la información necesaria para construir el botón de Flash.

Como puede ver, el código generado por el formulario HTML tiene todas las variables necesarias que se utilizarán para crear un botón de Flash. El siguiente paso es construir el código de Flash que hará que el botón Comprar ahora para la aplicación.

Aquí está el código ActionScript necesario para la interfaz con PayPal, como se puede ver el código es muy similar al código HTML existente que ha generado en la página de PayPal. La primera parte es para centrarse en las variables de URL que se encargará de construir los datos POST. Estos datos POST se pasa a lo largo de PayPal cuando el usuario hace clic en Comprar ahora.

// Paypal variables var pp_cmd:String = “_xclick”; var pp_business:String = “[email protected]”; var pp_item_name:String = “sample product”; var pp_item_number:String = “0001”; var pp_amount:String = “24.99”; var pp_currency:String = “USD”; var pp_weight:String = “1”; var pp_weight_unit:String = “lbs”; var pp_location:String = “US”;

A pesar de que se puede ver claramente los números en el bloque de variables, todos los parámetros se definen como cadenas para ser compatible con el equivalente de HTML. El siguiente tema es el de establecer la dirección, que se usa para la interfaz con PayPal. Esta es esencialmente la misma variable como la acción, que se encuentra en el código HTML original.

var paypalURL:String = “https://www.paypal.com/cgi-bin/webscr”;

Cuando se establecen las variables y los datos de PayPal, usted puede crear el código que se llama cuando el se hace clic en el botón Comprar ahora.

Esta es la función que se utiliza para llamar a PayPal. Este método no requiere que las variables personalizadas a pasar porque ellos se definen fuera de la función. La definición de una variable fuera de una función es de ámbito de lo que cualquier función tiene acceso a ellos. Si esta variable se define dentro de la función que sólo sería visible a la función en la que se define. La excepción es, por supuesto, si la función es global o de la variable se devuelve desde la función creada.

function callPaypal(e:MouseEvent):void { var urlVariables:URLVariables = new URLVariables(); urlVariables.cmd = pp_cmd; urlVariables.business = pp_business; urlVariables.item_name = pp_item_name; urlVariables.item_number = pp_item_number; urlVariables.amount = pp_amount;

293

urlVariables.currency_code = pp_currency; urlVariables.weight = pp_weight; urlVariables.weight_unit = pp_weight_unit; urlVariables.lc = pp_location;

var urlRequest:URLRequest = new URLRequest(paypalURL); urlRequest.method = URLRequestMethod.POST; urlRequest.data = urlVariables; sendToURL(urlRequest); }

Uso de POST data

El método de los datos enviados a PayPal está en formato POST. Esto significa que las variables se incluyen en la convocatoria, pero no en la dirección como se ve con GET. Utilizando el formato POST tiene algunas ventajas, la primera es la dirección está limpio y en realidad no puede ser alterado. El segundo es el nivel adicional de seguridad al pasar moderadamente sensibles a los datos del servidor.

Si usted necesita enviar datos altamente sensibles, como la facturación o tarjeta de crédito, es importante que usted utiliza una llamada de HTTPS. La razón de ello es POST en realidad sólo se convierte en una de Seguridad por oscuridad y no es el resultado más seguro.

Este ejemplo hace uso de la variable POST constante que se encuentra en la URLRequestMethod.Por supuesto, usted puede simplemente utilizar la cadena literal POST porque esto es lo que realmente tiene la constante de una variable.

urlRequest.method = URLRequestMethod.POST;

Uso de sendToURL

En los ejemplos anteriores, usted puede haber notado el uso de navigateToURL, que pide una URL y ofrece la capacidad de enviar datos a través de GET de la URL. En este ejemplo se pide que los datos POST, por lo que el uso de sendToURL es una mejor opción. Es importante entender que el método sendToURL envía la solicitud al servidor, pero ignora cualquier respuesta que se devuelve.

sendToURL(urlRequest);

Establecer una comunicación de communication

El último paso es asignar a la acción del botón que se adjunta al MovieClip Compre Ahora. Simplemente coloque un MovieClip en el escenario y le dan el nombre de instancia buyNowBtn. Si decide tener más de un botón, le recomiendo una estructura de clases que transfiere los datos de PayPal, para minimizar la cantidad de código necesario.

La función callPaypal se inserta en el botón mediante un detector de eventos. El evento Click es utilizada, que se llama cuando el usuario hace clic en el botón.

buyNowBtn.buttonMode = true; byNowBtn.useHandCursor = true; buyNowBtn.addEventListener(MouseEvent.CLICK, callPaypal);

294

El último paso es poner todo el código y probarlo juntos.

// Paypal variables var pp_cmd:String = “_xclick”; var pp_business:String = “[email protected]”; var pp_item_name:String = “sample product”; var pp_item_number:String = “0001”; var pp_amount:String = “24.99”; var pp_currency:String = “USD”; var pp_weight:String = “1”; var pp_weight_unit:String = “lbs”; var pp_location:String = “US”;

var paypalURL:String = “https://www.paypal.com/cgi-bin/webscr”;

function callPaypal(e:MouseEvent):void { var urlVariables:URLVariables = new URLVariables(); urlVariables.cmd = pp_cmd; urlVariables.business = pp_business; urlVariables.item_name = pp_item_name; urlVariables.item_number = pp_item_number; urlVariables.amount = pp_amount; urlVariables.currency_code = pp_currency; urlVariables.weight = pp_weight; urlVariables.weight_unit = pp_weight_unit; urlVariables.lc = pp_location;

var urlRequest:URLRequest = new URLRequest(paypalURL); urlRequest.method = URLRequestMethod.POST; urlRequest.data = urlVariables; sendToURL(urlRequest); }

buyNowBtn.buttonMode = true; byNowBtn.useHandCursor = true; buyNowBtn.addEventListener(MouseEvent.CLICK, callPaypal);

En este punto, usted tiene un ejemplo de trabajo de un botón Comprar ahora de PayPal. Es sólo una cuestión de agregar la información de elementos específicos. También puede crear una clase para que este proceso sea más fácil la creación, como se mencionó anteriormente.

PayPal también ofrece un carrito de la compra un sistema basado en el que puede permitir al usuario elegir varios elementos y las cantidades. Este elemento de información se almacena en el mismo formato de los datos básicos de POST, pero mantiene un registro de cada elemento individual. Ya sea que usted utilice la opción de compra o en un elemento de solución Compre Ahora sólo tiene que enviar una solicitud.

Este ejemplo en realidad no requiere el uso de cualquier PHP. Usted puede extender el ejemplo en primer lugar de enviar la información a fin de PHP y el almacenamiento de las compras para su orden propio sistema. PayPal, incluso ofrece a los desarrolladores de soluciones para conectar directamente a su sistema de pago y confirmación de si el pedido pasa a través de. Este servicio está fuera del alcance del libro, pero PayPal proporciona la documentación adecuada para empezar.

295

Uso de Flash y PHP para construir una cesta de compras

La sección anterior se centró en la construcción de un botón Comprar ahora en Flash utilizando PayPal como sistema de pago. Ese sistema funciona bastante bien, pero realmente no ofrece al diseñador el control total del carro, el pago, y los componentes de almacenamiento. La mayoría de las veces cuando usted decide construir una solución personalizada que acabará con mejores resultados. Esto no quiere decir que todo el mundo puede desarrollar la interfaz de PayPal siguiente, pero ¿cuánto de ese sitio se utilizan? La construcción de una solución personalizada es donde se llega a centrarse en las características que va a utilizar y excluir los que no se.

Esta cesta de la compra se divide en cuatro partes: diseño, MySQL, PHP, y el ActionScript que reúne todo.

Diseño de la cesta de compras

La aplicación de carrito de la compra será construido usando clases para reutilización. Esto también hace que sea más fácil de modificar más adelante.

CROSS--REF Para obtener más información sobre las clases de ActionScript, véase el capítulo 9.

Desarrollar la clase StoreItem

La primera porción de código que se centrará en los elementos individuales de productos que se mostrará a la izquierda de la cesta de la compra. Los artículos de la tienda MovieClip será añadido de forma dinámica al escenario y se le asignará una clase personalizada StoreItem.

La clase es responsable de asignar las variables de la tienda tema y mostrar los valores necesarios. Al igual que el capítulo de clase, estas clases se componen de independiente paquetes para la simplicidad, lo que no hay necesidad de proporcionar una estructura de paquetes

La primera parte del código de las importaciones de las clases MovieClip y TextField. Esta clase personalizada se extiende la clase MovieClip y TextField necesita ser cargado, porque hay cuadros de texto en el movieclip.


Hay cinco variables privadas que se utilizan para sostener el elemento de datos específicos. Estos datos son luego compartidos con el carrito de la compra, pero por ahora los datos sólo tiene que ser almacenado.

private var albumName:String; private var albumDesc:String; private var albumThumb:String; private var albumPrice:String; private var storeItemID:uint;

El método de StoreItem se deja vacía y en realidad no es necesario porque el compilador de ActionScript lo colocará automáticamente, pero para la integridad es una buena idea tenerlo.

function StoreItem() {}

296

El método personalizado primero es responsable de guardar los datos de posición a las variables privadas que se acaba de definir. Los cinco argumentos definidos en esta función se pasan de la persona que llama y se mantendrá los datos de elemento que se utiliza más tarde.

public function setStoreData( id:uint, n:String, d:String, t:String, p:String):void { storeItemID = id; albumName = n; albumDesc = d; albumThumb = t; albumPrice = p; ... }

Los dos cuadros de texto que contienen el nombre y la descripción de cada elemento son la última parte de esta clase de encargo. Los datos que se aprobó se asigna a cada cuadro de texto. Normalmente, es probable que verificar si los datos válidos, pero debido a que se está controlando el PHP que se devuelve puede estar seguro de los datos será válido.

nameTxt.text = albumName; descTxt.text = albumDesc;

El método final de esta clase se utiliza para enviar los datos a quien llama. La acción de retorno devuelve un objeto personalizado que se llena con los datos del elemento en el método anterior.

public function getItem():Object { return { target:this, id:storeItemID, name:albumName, price:albumPrice }; }

El método anterior tiene un tipo especial de retorno definido. El valor devuelto es un objeto en línea que se utiliza para simplificar el código mediante la exclusión de los nombres de variables innecesarias.

Cada uno de los tipos: Array, Object, y String tienen una forma abreviada para definirlos. Por ejemplo, el tipo de objeto puede ser definido simplemente con:

var sampleObj:Object = {name:value};

La tabla 12.1 muestra el tipo y el equivalente a la abreviatura de ella. Usando los valores de taquigrafía puede ahorrar tiempo de desarrollo, ya que tiene que escribir menos.

ADVERTENCIA La forma abreviada puede crear problemas, porque se crea un "débil", escribió objeto.Por lo tanto, no pueden beneficiarse de la comprobación de tipos en tiempo de compilación. Usted puede

297

acceder al objeto dinámico mal y no lo sabremos hasta que tiempo de ejecución. Esto significa que usted debe tener cuidado al crear sus propiedades y las variables en taquigrafía.

TABLA 12.1 Tipos de Taquigrafía y Equivalentes

Array new Array() [] Object new Object() {} String new String() “”

Ambos métodos de aplicación que se crearon son públicos porque son llamados desde clases externas. También puede crear una función intermedia que ofrece un mayor nivel de seguridad, que se encarga de llamar a los métodos privados.

Con la clase StoreItem construido, puede pasar a la ShoppingCartItem, que se adjunta a la partida cesta de la compra de MovieClip.

Desarrollar la clase ShoppingCartItem

Esta clase es básicamente responsable del mantenimiento de la identificación del tema, que será utilizado en la clase ShoppingCart. Al igual que la clase anterior, éste también tiene que importar la clase MovieClip y TextField para alojar los elementos situados en este MovieClip.

package {


public class ShoppingCartItem extends MovieClip { private var cartItemID:uint; function ShoppingCartItem() { }

public function getID():uint { return cartItemID; }

public function setID(id:uint):void { cartItemID = id; } }

}

La última parte de esta clase es responsable de obtener y establecer la cartItemID. Este valor se utiliza para vincular los productos con el carro de artículos.

La clase de ActionScript personalizado última es la ShoppingCart. Esta clase es bastante grande, por lo que se rompa en pedazos para entenderlo mejor. El mejor lugar para empezar es a primera mirada a un esqueleto de clase, que muestra los métodos que se utilizan en esta aplicación. A menudo construir este primer esqueleto, que puede doblar como un esquema.

298

package { public class ShoppingCart extends MovieClip { function ShoppingCart() {}

public function addProduct(product:Object):void {} public function removeProduct(e:MouseEvent):void {} public function updateList():void {} public function updateTotal():void {} public function checkout():void {} public function setGatewayURL(url:String):void {} private function round2D(n:Number):Number {} } }

El lugar más lógico para empezar en esta clase es mediante la asignación de las importaciones de clase que se necesitarán.

import flash.display.MovieClip; import flash.text.TextField; import flash.events.MouseEvent; import flash.net.*;

Las propiedades de esta clase consistirá en todas las variables privadas para que no se puede acceder por otras clases.

private var cartItemCount:uint = 0; private var cartContents:Array;

private var cartItemHeight:uint = 20; private var lineSpacing:uint = 30; private var gateway:String;

El constructor es responsable de la creación en el botón Checkout y la inicialización de la matriz de punto de compra.

function ShoppingCart() { cartContents = new Array(); cont = cartContents; checkoutBtn.addEventListener(MouseEvent.CLICK, function():void { var xml:String = “<?xml version=’1.0’ ?>\n\r”; xml += “<products total=\”” + totalTxt.text + “\”>”; for(var i in cont) { xml += “<product>”; xml += “\t<quantity>” + cont[i].cartItem.quantityTxt.text + “</quantity>”;

xml += “\t<name>” + cont[i].name + “</name>”; xml += “\t<price>” + cont[i].price + “</price>”; xml += “</product>”; }xml += “</products>”;

299

var variables:URLVariables = new URLVariables(); variables.action = “checkout”; variables.xml = xml;

var urlRequest:URLRequest = new URLRequest(gateway); urlRequest.data = variables; urlRequest.method = “GET”;

navigateToURL(urlRequest); }) }

El contenido del botón Checkout puede parecer abrumador, pero se trata simplemente de construir un documento XML personalizado que se pasarán a la PHP. La variable de XML comienza por asignar el código XML apropiado partida. Sin esta partida, PHP asumiría el expediente está incompleto y no cargar.

var xml:String = “<?xml version=’1.0’ ?>\n\r”;

El bucle for.. loop es el responsable de pasar por la matriz cartContents y sacar a cada elemento de la cesta. Una vez dentro del bucle, el cartItem es una referencia a la costumbre ShoppingCartItem que se creó en la sección anterior. Estos elementos tienen la cantidad y la id de elemento, que será colocado en esta costumbre documento XML.

cont = cartContents; for(var i in cont) { ... xml += “\t<name>” + cont[i].name + “</name>”; ... }

Una vez que el ciclo for.. se completa el proceso de construcción del XML, el archivo PHP se encuentra en el servidor puede ser llamado. La petición es una base GET, pasando por los datos XML.



navigateToURL(urlRequest);

El código PHP espera dos variables a ser transmitido. La acción en este caso es obtener, y los datos XML que se generó por los puntos de compra seleccionadas de compras en el carrito de la compra de código.

El siguiente paso es la construcción de los métodos. El primer método es responsable de añadir un producto a la cesta de la compra. El carrito de la compra está formado por instancias de la clase ShoppingCartItem, pero esta clase es en realidad un clip de película en la biblioteca. El primer paso es crear una nueva instancia de este clip de película. Después de crear una nueva instancia, un detector de eventos se agrega al botón removeProduct, que se encuentra dentro del movieclip. La cantidad predeterminada de un nuevo punto se establece en 1, lo que puede ser actualizado, lo que se aprende en la siguiente sección.

public function addProduct(product:Object):void

300

{ ... var cartItem:ShoppingCartItem = new ShoppingCartItem(); cartItem.removeItemBtn.addEventListener(MouseEvent.CLICK, removeProduct); cartItem.quantityTxt.text = “1”; cartItem.nameTxt.text = product.name; ... }

El siguiente paso es crear una identificación falsa que usted puede utilizar para agregar y eliminar la instancia más tarde.

cartItem.setID(cartItemCount); // faux id for removal system

La colocación de un nuevo carro de ejemplo el tema de la compra está determinado por primera multiplicando el cartItemCount por la altura y luego añadir un espacio.

cartItem.y = (cartItemCount * cartItemHeight) + lineSpacing;

Una vez que se coloca la nueva instancia, es temporalmente añadido al producto objeto de modo que las piezas futuro de código puede acceder a ella sin la caza de ella. Luego se añade a la matriz cartContents.

product.cartItem = cartItem; cartContents.push(product);

La siguiente parte del método de addProduct es responsable de añadir la instancia a la lista de visualización, incrementar la cuenta y, finalmente, hacer una llamada a la actualización de precios.

addChild(cartItem); cartItemCount++; updateTotal();

En este momento, si tuviera que añadir un artículo a la cesta de la compra que permitiría a los duplicados que se añade. Cuando el resultado deseado es incrementar la cantidad al bucle for.. se coloca en el principio del método para cuidar de este.

public function addProduct(product:Object):void { // Look for product in list for(var i in cartContents) { if(cartContents[i].id == product.id) {var q:Number = cartContents[i].cartItem.quantityTxt.text; cartContents[i].cartItem.quantityTxt.text = q + 1; updateTotal(); return; } }... }

El bucle se configura para comprobar el carro de un elemento de identificación válida. Si se encuentra una identificación válida, la cantidad se asigna a la variable q. Este se añade al valor del cuadro de texto la cantidad

301

y una llamada a la actualización de precios se hace para asegurar que siempre es correcto. El retorno se utiliza para detener cualquier ulterior ejecución de código situado dentro de esta función.

Este método fue probablemente el más grande, ya que es responsable de gran parte de la funcionalidad de esta aplicación.El código completo se facilite en una presentación final al final de esta sección, y por supuesto, también está disponible en el sitio Web del libro.

El siguiente método se utiliza para eliminar un elemento de la cesta de la compra. El método getID que se creó en la clase ShoppingCartItem se utiliza en esta función para recuperar el ID. La referencia de los padres se usa para tomar la meta (botón Delete) e informar el código de lo que el padre o el objeto superior es. Esto proporciona un vínculo sólido a la instancia de clase ShoppingCartItem y en última instancia el método para recuperar el ID.

public function removeProduct(e:MouseEvent):void { var id:uint = e.target.parent.getID(); ... }

Después del ID, éste puede ser utilizado para eliminar el elemento de la serie de artículos de compra y de la lista de visualización. El método de empalme se utiliza para eliminar el elemento de compra utilizando el ID, que es realmente la posición del elemento puede encontrarse en la matriz. El segundo argumento en el método de empalme es que exista un sólo elemento se elimina.

cartContents.splice(id, 1); removeChild(e.target.parent); cartItemCount--;

NOTA Si el segundo argumento no se proporciona, el método de empalme se eliminarán todos los elementos de ese punto.

El archivo Flash se ha añadido una nota de forma automática que se muestra para informar al usuario de que no hay productos en el carrito. Sin embargo, se elimina esta cuando se añade un elemento. El problema es, si el usuario elimina todos los artículos de la cesta que hay que mostrar una vez más, por lo que una simple declaración de si se añade al final de eliminar el método para controlar este.

if(cartItemCount == 0) { noItemsTxt.visible = true; }

Por último, una llamada a los métodos updateTotal y updateList se hace para asegurar que los datos se mantiene constante y el precio se actualiza.

updateList(); updateTotal();

Los artículos de compra se añadirán a la matriz que el usuario hace clic en el botón Añadir al carro, sin embargo, puede recordar en la sección anterior que el tema de compra se puede encontrar en la matriz mediante el carro de id.El problema es si un elemento se elimina de la lista ahora es mixto y un elemento incorrecto puede ser añadido

302

o quitado. La solución es presentar una identificación nueva como se elimina un elemento. Esto se logra recorriendo todos los elementos restantes de compra y hacer una llamada para establecer una nueva identificación.

public function updateList():void { for(var i:uint=0; i < cartItemCount; i++) { cartContents[i].cartItem.setID(i); } }

El otro efecto secundario a la eliminación de un tema libremente es que puede crear un vacío en la lista. Esto no cambia la forma de las funciones de aplicación, pero visualmente no es el más limpio. La forma de evitar este problema es poco para realinear la lista como se quita un elemento.

public function updateList():void { for(var i:uint=0; i < cartItemCount; i++) { cartContents[i].cartItem.setID(i); }cartContents[i].cartItem.y = (i * cartItemHeight) + lineSpacing; }

En los métodos anteriores no ha habido una llamada a updateTotal. Este método es responsable de mantener el precio total actualizado como elementos añadidos y modificados. El proceso consiste en recorrer los elementos de compra, multiplicar el precio por la cantidad, y mostrar el resultado final. El resultado es entonces la prueba de números válidos y un decimal (.) Se proporciona si es necesario.

public function updateTotal():void { var total:Number = 0;

for(var i:uint=0; i < cartItemCount; i++) { total += Number(cartContents[i].price) * Number(cartContents[i].cartItem.quantityTxt.text); }

totalTxt.text = “$” + String(round2D(total));

// tack on extra 0 if needed or two 0’s if(totalTxt.text.indexOf(‘.’) == -1) { totalTxt.appendText(“.00”); }else if(totalTxt.text.indexOf(‘.’) + 2 == totalTxt.text.length) { totalTxt.appendText(“0”); } }

El método de setGatewayURL establece la propiedad de puerta de enlace que se refiere a la dirección URL que se llama cuando el botón se hace clic en Realizar Pedido.

303

public function setGatewayURL(url:String):void { gateway = url; }

En este punto la clase ShoppingCart ha sido creado. La última porción de código que se necesita será colocado en la línea de tiempo. Este código será responsable de establecer todo y en última instancia el control de los elementos individuales.

La línea de tiempo de ActionScript también podría ser colocado en una clase de documentos, que se explica en el capítulo 9. Sin embargo, para simplificar, se incluirá directamente en el archivo Flash.

La primera parte es para asignar el archivo PHP, que se construirá en la siguiente sección.

var phpFile:String = “http://localhost/ch11/store/flashCart.php”;

La cesta de la compra está ya en el escenario, con el nombre de instancia y se puede asignar a la variable cesta de la que se utilizará en el resto del código. El siguiente paso es crear un movieclip vacío que tiene la tienda de artículos.

var cart:MovieClip = shoppingCart; cart.setGatewayURL(phpFile);

var storeItems:MovieClip = new MovieClip(); storeItems.x = 25; storeItems.y = 80;

La solicitud de que el servidor es más o menos el mismo proceso que se ha utilizado en el pasado. La única porción única es la acción que se adjunta al final de la url.

var urlRequest:URLRequest = new URLRequest(phpFile + “?action=getproducts”); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, productsLoaded); urlLoader.load(urlRequest);

Después de cargar el servidor de datos, se llama la función de respuesta. Esta función se encarga de analizar el XML y agregar el artículo de la tienda al carro de la compra. Aquí tiene un ejemplo del código XML que se devuelve y analiza.

<products> <product id=”1” name=”Cool Tracks” desc=”Another hot release” thumbnail=”” /> </products>

Esta función también es responsable de cargar una nueva instancia del movieclip StoreItem, que contiene la información de cada producto. El botón en este caso también se adjunta a un evento que es responsable de añadir un nuevo elemento a la cesta de la compra.

function productsLoaded(e:Event):void {

304

... var id:uint = 0; for each(var xmlItem in xml..product) { var item:StoreItem = new StoreItem(); item.y = 85 * id; item.setStoreData( id, xmlItem.attribute(‘name’), xmlItem.attribute(‘desc’), xmlItem.attribute(‘thumbnail’)); xmlItem.attribute(‘price’)); item.addToCartBtn.addEventListener(MouseEvent.CLICK, addItemHandler); storeItems.addChild(item); id++; }addChild(storeItems); }

La función addItemHandler agarra el primer objeto único y agrega el producto a la cesta.El objeto se encuentra cargando el objeto desde el contenedor primario, similar al código que se utilizó en la sección anterior. La declaración trace() es simplemente para probar y nunca se muestran al usuario final de la aplicación.

function addItemHandler(e:MouseEvent):void { var prod:Object = e.target.parent.getItem();

trace(“Add Item: “ + e.target.parent); trace(“Item ID: “ + prod.id);

cart.addProduct(prod); }

Me tomó un tiempo y dio lugar a una gran cantidad de código nuevo, pero todo el código ActionScript necesario para este ejemplo se ha completado. La siguiente parte es para centrarse en el código PHP que es llamado por el botón Checkout.

En realidad, el PHP y MySQL, van de la mano, así que es mejor para construir la tabla de SQL necesario antes de que se escriba el PHP. Esto hace que sea más fácil de depurar a largo plazo.

CREATE TABLE flashStore_products ( ìd` int NOT NULL AUTO_INCREMENT, `name` varchar(25), `category` int(3) NOT NULL DEFAULT 0, `description` TEXT, `thumbnail` varchar(200) NOT NULL DEFAULT “”, `price` varchar(10) NOT NULL, àctive` int(1) NOT NULL DEFAULT 1, PRIMARY KEY (ìd`) )

El SQL es responsable de mantener toda la información de cada elemento en la tienda. En una aplicación completa, probablemente sería poblado por un sistema de gestión de contenido. Para este ejemplo, el código de INSERT se proporciona para que usted pueda rápidamente probar el ejemplo.

305

INSERT INTO flashStore_products (name, description,price) VALUES (‘Cooler Music’, ‘Another new one’);

Construir el PHP

Cuando el SQL es configurada el PHP puede ser escrito. El PHP es responsable de la carga de los artículos del almacén y manejo de una solicitud de pago. Estas dos tareas se pueden dividir en varios archivos, y es probablemente mejor de como las clases, pero para simplificar todo esto se encuentra dentro de un archivo PHP Este. Antes de la base de datos se puede utilizar, de una conexión debe ser establecida. Esto se logra mediante la carga de un archivo externo que contiene la información de conexión de base de datos.


El contenido de este archivo dbconn.php se ven aquí.

<?php

$host = “localhost”; $user = “username”; $pass = “password”; $database = “database name”;


unset($host); unset($user); unset($pass); unset($database);

?>

Ahora usted puede determinar qué acción se está solicitando. Hay dos opciones posibles:getproducts, que devuelve un documento XML de artículos de la tienda, o la caja, que carga el XML de Flash y lo muestra.

if($_GET[‘action’] == ‘getproducts’) { print getProducts(); }else if($_GET[‘action’] == ‘checkout’) { $xml = new SimpleXMLElement($_GET[‘xml’]);

$nodeCount = count($xml->product);

print “<table border=\”1\” width=\”500\”>”; print “<tr><td><strong>Quantity</strong></td>”; print “<td><strong>Product</strong></td>”; print “<td><strong>Price</strong></td></tr>”;

for($x=0; $x < $nodeCount; $x++) {

306

print “<tr style=\”background-color:#eeeeee;\”>”; print “<td style=\”width:60px;text-align:center;\”>” . $xml->product[$x]->quantity . “</td>”; print “<td>” . $xml->product[$x]->name . “</td>”; print “<td>” . $xml->product[$x]->price . “</td></tr>”; }

print “<tr>”; print “<td colspan=\”3\”>Total: <strong>”

. getAttribute($xml, ‘total’) . “</strong></td></tr>”;

print “</table>”; print “<br />Checkout code goes here<br />”; }

La acción getproducts simplemente hace una llamada a otra función que devuelve el código XML generados a partir de las entradas de base de datos. La acción de compra, como se muestra en la figura 12.3, es un poco más complicado.Empieza agarrando los datos XML pasado de Flash. Este XML se carga en la biblioteca SimpleXML donde se analiza y cada uno de los artículos de la tienda se recupera.

FIGURA 12.3 Aquí está una muestra de la página de caja, cargada de Flash. Esta página es visible cuando se hace clic en el botón Checkout.

307

Esta función se llama desde la primera acción y es responsable de la construcción de un documento XML de los datos en la base de datos. Los artículos de la tienda se desglosan por id, name, desc, y en miniatura, que son visibles en el archivo de Flash.

El resultado desde el MySQL devuelve cualquier elemento que está activo actualmente. Este resultado se pasa luego a un bucle while, que es donde se construye el de datos XML. Por último, el XML es devuelto a la persona que llama y, en este ejemplo, se imprime en la pantalla para que se ejecute.

function getProducts() { global $link;

$result = mysql_query(“SELECT * FROM flashStore_products WHERE active=1”, $link);

$xml = “<products>\n”; while($row = mysql_fetch_array($result)) { $xml .= “<product id=\”” . $row[‘id’] . “\” name=\”” . $row[‘name’] . “\” desc=\”” . $row[‘description’] . “\” thumbnail=\”” . $row[‘thumbnail’] . “\” />\n”; “\” price=\”” . $row[‘price’] .”\” />\n”;

308

}$xml .= “</products>”;

return $xml; }

La última función es en realidad una función olvidada de SimpleXML. Esta función tiene dos argumentos, el XML y el nombre del atributo que está buscando. Primero se realiza un bucle a través de todos los argumentos y los partidos de los argumentos en contra de la variable passed-in. Se devuelve el valor del atributo o falso, dependiendo de lo que el resultado es.

function getAttribute($xml, $name) { foreach($xml->attributes() as $key=>$val) { if($key == $name) { return (string)$val; } }return false; }

Ahora que todo el código está completo, aquí están las tres clases y el código de línea de tiempo previsto en un solo lugar para facilitar la visualización y la comparación con el código.

ShoppingCart

package {

import flash.display.MovieClip; import flash.text.TextField; import flash.events.MouseEvent; import flash.net.*;

public class ShoppingCart extends MovieClip { private var cartItemCount:uint = 0; private var cartContents:Array;

private var cartItemHeight:uint = 20; private var lineSpacing:uint = 30; private var gateway:String;

function ShoppingCart() { cartContents = new Array();

checkoutBtn.addEventListener(MouseEvent.CLICK, function():void {var xml:String = “<?xml version=’1.0’ ?>\n\r”; xml += “<products total=\”” + totalTxt.text + “\”>”;

for(var i in cartContents)

309

{ xml += “<product>”; xml += “<quantity>” + cartContents[i].cartItem.quantityTxt.text + “</quantity>”; xml += “<name>” + cartContents[i].name + “</name>”; xml += “<price>” + cartContents[i].price + “</price>”; xml += “</product>”; }xml += “</products>”;



navigateToURL(urlRequest); }) }

public function addProduct(product:Object):void { // Look for product in list for(var i in cartContents) { if(cartContents[i].id == product.id) {var quantity:Number = cartContents[i].cartItem.quantityTxt.text;

cartContents[i].cartItem.quantityTxt.text = quantity + 1;

updateTotal(); return; } }

if(cartItemCount == 0) { noItemsTxt.visible = false; }

var cartItem:ShoppingCartItem = new ShoppingCartItem();

cartItem.removeItemBtn.addEventListener( MouseEvent.CLICK, removeProduct); cartItem.quantityTxt.text = String(1); cartItem.nameTxt.text = product.name; cartItem.setID(cartItemCount);

cartItem.y = (cartItemCount * cartItemHeight) + lineSpacing;

310

product.cartItem = cartItem;

cartContents.push(product);

addChild(cartItem);

cartItemCount++;

updateTotal(); }

public function removeProduct(e:MouseEvent):void { var id:uint = e.target.parent.getID();

cartContents.splice(id, 1); removeChild(e.target.parent); cartItemCount--;

if(cartItemCount == 0) { noItemsTxt.visible = true; }

updateList(); updateTotal(); }

public function updateList():void { for(var i:uint=0; i < cartItemCount; i++) { cartContents[i].cartItem.setID(i); cartContents[i].cartItem.y = (i * cartItemHeight) + lineSpacing; } }

public function updateTotal():void { var total:Number = 0; for(var i:uint=0; i < cartItemCount; i++) {total += Number(cartContents[i].price) * Number(cartContents[i].cartItem.quantityTxt.text); }totalTxt.text = “$” + String(round2D(total));

// tack on extra 0 if needed or two 0’s if(totalTxt.text.indexOf(‘.’) == -1) { totalTxt.appendText(“.00”); }else if(totalTxt.text.indexOf(‘.’) + 2 == totalTxt.text.length) { totalTxt.appendText(“0”); }

311

}

public function setGatewayURL(url:String):void { gateway = url; }

private function round2D(n:Number):Number {return Math.round(n * Math.pow(10, 2)) / Math.pow(10, 2); } } }

ShoppingCartItem

package { import flash.display.MovieClip; import flash.text.TextField;

public class ShoppingCartItem extends MovieClip { private var cartItemID:uint;

function ShoppingCartItem() { } public function getID():uint { return cartItemID; }

public function setID(id:uint):void { cartItemID = id; } }

}

StoreItem


public class StoreItem extends MovieClip { private var albumName:String; private var albumDesc:String; private var albumThumb:String; private var albumPrice:String; private var storeItemID:uint;

function StoreItem() {}

public function setStoreData( id:uint, n:String,

312

d:String, t:String, p:String):void { storeItemID = id; albumName = n; albumDesc = d; albumThumb = t; albumPrice = p;

nameTxt.text = albumName; descTxt.text = albumDesc; }

public function getItem():Object { return { target:this, id:storeItemID, name:albumName, price:albumPrice }; } } }

Timeline code

var phpFile:String = “http://localhost/ch11/store/flashCart.php”;

var cart:MovieClip = shoppingCart; cart.setGatewayURL(phpFile);

var storeItems:MovieClip = new MovieClip(); storeItems.x = 25; storeItems.y = 80;

var urlRequest:URLRequest = new URLRequest(phpFile + “?action=getproducts”); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, productsLoaded); urlLoader.load(urlRequest);

function productsLoaded(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

trace(“XML: “ + xml);

var id:uint = 0; for each(var xmlItem in xml..product) { var item:StoreItem = new StoreItem(); item.y = 85 * id; item.setStoreData(id, xmlItem.attribute(‘name’), xmlItem.attribute(‘desc’), xmlItem.attribute(‘thumbnail’)); xmlItem.attribute(‘price’));

313

item.addToCartBtn.addEventListener( MouseEvent.CLICK, addItemHandler); storeItems.addChild(item); id++; }addChild(storeItems); }

function addItemHandler(e:MouseEvent):void { var prod:Object = e.target.parent.getItem();

trace(“Add Item: “ + e.target.parent); trace(“Item ID: “ + prod.id);

cart.addProduct(prod); }

PHP code

<?php

$host = “localhost”; $user = “username”; $pass = “password”; $database = “database name”;



?>

<?php


function getProducts() { global $link;

$result = mysql_query(“SELECT * FROM flashStore_products WHERE active=1”, $link);

$xml = “<products>\n”;

while($row = mysql_fetch_array($result)) { $xml .= “<product id=\”” . $row[‘id’] . “\” name=\”” . $row[‘name’] . “\” desc=\”” . $row[‘description’] . “\” thumbnail=\”” . $row[‘thumbnail’] . “\” />\n”; “\” price=\”” . $row[‘price’] .”\” />\n”;

314

}

$xml .= “</products>”;

return $xml; }

if($_GET[‘action’] == ‘getproducts’) { print getProducts(); }else if($_GET[‘action’] == ‘checkout’) { $xml = new SimpleXMLElement($_GET[‘xml’]);

$nodeCount = count($xml->product);

print “<table border=\”1\” width=\”500\”>”; print “<tr><td><strong>Quantity</strong></td>”; print “<td><strong>Product</strong></td>”; print “<td><strong>Price</strong></td></tr>”;

for($x=0; $x < $nodeCount; $x++) { print “<tr style=\”background-color:#eeeeee;\”>”; print “<td style=\”width:60px;text-align:center;\”>” . $xml->product[$x]->quantity . “</td>”; print “<td>” . $xml->product[$x]->name . “</td>”; print “<td>” . $xml->product[$x]->price . “</td></tr>”; }

print “<tr><td style=\”text-align:right;\” colspan=\”3\”>Total: <strong>” . getAttribute($xml, ‘total’) . “</strong></td></tr>”;

print “</table>”; print “<br />Checkout code goes here<br />”; }

function getAttribute($xml, $name) { foreach($xml->attributes() as $key=>$val) { if($key == $name) { return (string)$val; } }return false; }

?>

El ejemplo se ha completado, es sólo una cuestión de poner el PHP en un servidor Web activo. Desde este punto se puede extender el ejemplo para tener varias categorías, productos, y las imágenes. Siendo realistas, la construcción de la aplicación en un formato de clase que ofrece una mayor capacidad de expansión, pero no acaba de tomar mi palabra para ella. Experimenta y extender el ejemplo.

315

Uso de PHP y Flash para construir una aplicación de busqueda del Amazon

Amazon ofrece un conjunto muy poderoso de herramientas diseñadas para trabajar con los datos de su sitio. Esta sección abarca la construcción de una aplicación de búsqueda utilizando Amazon.com como la fuente de datos. Este ejemplo utiliza el ECS (Amazon E-Commerce Service), que proporciona acceso directo a Amazon increíble la búsqueda y el sistema de inventario.

Con el fin de utilizar la ECS tiene que tener una identificación de acceso válida del Amazon, que se proporciona cuando se crea una cuenta de desarrollador. Este proceso de registro es rápido y gratuito, todo lo que necesita es una dirección válida de correo electrónico y una cuenta activa.

Uso del servicio web de Amazon

Para empezar con los desarrolladores la creación de una cuenta, visite el servicio Web de Amazon (AWS) en la página de www.amazon.com/gp/aws/landing.html.

NOTA Asegúrese de activar la cuenta por correo electrónico antes de empezar a usarlo.

AWS está configurado para ser accesible desde diferentes medios. El formato utilizado para este ejemplo es Representational State Transfer (REST), que es básicamente una dirección URL con formato con toda la información necesaria siempre en la Versión GET.

Aquí está una muestra de enviar a la Amazonía, como se muestra en la figura 12.4, para devolver información acerca del libro de posibles coincidencias para una palabra clave o serie de palabras clave.

http://ecs.amazonaws.com/onca/xml?Service=AWSECommerceService&AWS AccessKeyId={AWS_ACCESS_KEY}&Operation=ItemSearch&SearchIndex= Books&ResponseGroup=Medium&Keywords={SEARCH_TERMS}

El AWS_ACCESS_KEY es la identificación de acceso que es proporcionado por Amazon, y la SEARCH_TERMS sería la palabra clave (s) que se transmiten a lo largo de la búsqueda.

Como te habrás dado cuenta, la respuesta XML de Amazon es bastante complejo. Sin embargo, para este ejemplo, la atención se centrará en el título del libro, autor, y la ruta en miniatura. Amazonas es realmente muy agradable para proporcionar la cantidad de detalle que lo hace. Usted puede construir algunas aplicaciones muy interesantes con el sistema de AWS.

FIGURA 12.4 Aquí está la respuesta XML de Amazon, después de una búsqueda de "PHP".

316

http://www.amazon.com/gp/aws/landing.html

De hecho, la URL enviada a Amazon puede ser modificado para la búsqueda de diferentes elementos o temas todos juntos. AWS está configurado para devolver mensajes de error incluso válido similar a éste si no ofrecen un parámetro de operación.

AWS.InvalidOperationParameterThe Operation parameter is invalid. Please modify the Operation parameter and retry. Valid values for the Operation parameter include TagLookup, ListLookup, CartGet, SellerListingLookup, CustomerContentLookup, ItemLookup, SimilarityLookup, SellerLookup, ItemSearch, VehiclePartLookup, BrowseNodeLookup, CartModify, ListSearch, CartClear...

El sistema de búsqueda ofrece un montón de tipos y modificadores, y usted no tiene que depender de este "create an error " a ver qué hay disponible. Amazon pasa a proporcionar la documentación muy sólido en el centro del desarrollador. Entra en el acceso.

Simplificar la respuesta XML

317

Cuando la respuesta XML se ha cargado en la sección anterior, el resultado fue abrumador. Hay muchos nodos XML y datos que simplemente no son aplicables a esta aplicación. Usted podría pasar estos datos en bruto en Flash, pero lo que si usted quiere almacenar los resultados? Usted tiene un montón de información no utilizada obstruyendo su base de datos.

La idea es construir una respuesta XML personalizada que contiene únicamente los datos necesarios para esta aplicación.

<?php

$terms = “”; define(“AWS_ACCESS_KEY”, “{AWS_KEY_GOES_HERE}”);

Es importante comprobar las etiquetas válidas antes de una respuesta se envía al Amazonas. Realmente no daña nada, pero se podría considerar una solicitud fraudulenta.

if(!empty($_GET[‘terms’])) { ... }

Suponiendo etiquetas válidas encontrado, construir la petición que se enviará a la AWS.

if(!empty($_GET[‘terms’])) { $terms = $_GET[‘terms’]; $request = ‘http://ecs.amazonaws.com/onca/xml’ . ‘?Service=AWSECommerceService&’ . ‘AWSAccessKeyId=’ . AWS_ACCESS_KEY . ‘&Operation=ItemSearch’ . ‘&SearchIndex=Books’ . ‘&ResponseGroup=Medium’ . ‘&Keywords=’ . $terms; }

Tiene la palabra la AWS, pasando por los parámetros de búsqueda.

$rawXml = file_get_contents($request);

La respuesta de la AWS se carga utilizando file_get_contents, que dice en todo el archivo solicitado en una cadena. En este ejemplo, la cadena se guarda en la variable $ rawXML. Una llamada a la biblioteca SimpleXML se hace para construir un objeto XML con formato correcto.

$xmlResponse = simplexml_load_string($rawXml);

El siguiente paso es crear el documento XML personalizado que será enviado de vuelta a Flash cuando se solicita. La variable nodeCount no es modificable a 4 de manera que se guardan sólo cuatro resultados libro.Incluso si vuelve la Amazonía miles, Flash sólo ve cuatro.

$nodeCount = 4;

$xml = “<?xml version=\”1.0\” ?>\n<books>”;

for($i=0; $i < $nodeCount; $i++)

318

{ ... }

$xml .= “</books>”;

El contenido del bucle for.. es donde la mayoría del proceso de construcción se produce XML. Por ejemplo, para cargar el título del libro actual, acceder por primera vez en el nodo Elementos. Una vez dentro de ese nodo, el nodo de elemento seleccionado es acceder utilizando la variable $i para determinar qué niño debe ser de referencia.Dentro del nodo hijo en vigor, hay otro niño con el nombre ItemAttributes de nodo, que contiene un nodo de título y en última instancia se convierte en el nombre del libro para este niño seleccionado.

$xmlResponse->Items->Item[$i]->ItemAttributes->Title

Como puede ver, Amazon paquetes de este archivo XML completo de la información, que en este caso hace que sea difícil especie de carga de la información deseada. El proceso de carga y datos del autor en miniatura es prácticamente el mismo sólo el acceso de cada niño y referencia el nodo deseado.

$xml .= “\t<book>”; $xml .= “\t\t<title><![CDATA[“ . $xmlResponse->Items ->Item[$i]->ItemAttributes->Title . “]]></title>”; $xml .= “\t\t<author><![CDATA[“ . $xmlResponse->Items ->Item[$i]->ItemAttributes->Author . “]]></author>”; $xml .= “\t\t<price><![CDATA[“ . $xmlResponse->Items ->Item[$i]->ItemAttributes->ListPrice ->FormattedPrice . “]]></price>”; $xml .= “\t\t<thumb>” . $xmlResponse->Items->Item[$i] ->SmallImage->URL . “</thumb>”; $xml .= “\t</book>”;

PRECAUCIÓN Los datos para generar el XML es una línea por la variable $xml; el envoltorio es adaptar esta página y, potencialmente, puede romper el código.

La última parte del PHP para este ejemplo crea un tipo de cabecera para que los lectores conocen el formato XML que se está enviando. Entonces, finalmente los resultados a la pantalla.

header(“content-type: text/xml”); print $xml;

El Flash (ActionScript) necesarias para la aplicación en todas las clases externas. Esto se hace porque es más fácil de gestionar y mantener para avanzar.

CROSS--REF Si necesita una explicación más a fondo de las clases, os recomiendo que lea el capítulo 9.

El archivo Flash (FLA) para esta aplicación consta de un diseño simple con un cuadro de búsqueda y el botón. La clase principal, Booksearch, se asigna como la clase de documento y es responsable de la gestión de la aplicación en general. Aquí está el esqueleto de la clase, que da una idea de qué métodos y propiedades se utilizan para crear esta aplicación.

package { import flash.display.MovieClip;

319

import flash.events.*; import flash.net.*;

public class BookSearch extends MovieClip { public var webServiceURL:String; private var bookItems:Array; private var bookItemsContainer:MovieClip;

public function BookSearch() {}

public function searchHandler(e:MouseEvent):void {}

public function loadSearchResults(terms:String):void {}

public function loadedResultsHandler(e:Event):void {}

private function removeOldResults():void {} } }

El método constructor se utiliza para inicializar la matriz, crear un movieclip contenedor, y agregue el detector de eventos para el botón de búsqueda.

public function BookSearch() { bookItems = new Array(); bookItemsContainer = new MovieClip(); bookItemsContainer.y = 100; searchBtn.addEventListener(MouseEvent.CLICK, searchHandler); }

El último paso del método constructor es añadir el contenedor nuevo libro a la lista de visualización, que en última instancia, lo hace visible.

public function BookSearch() { bookItems = new Array(); bookItemsContainer = new MovieClip(); bookItemsContainer.y = 100; searchBtn.addEventListener(MouseEvent.CLICK, searchHandler); addChild(bookItemsContainer); }

El siguiente método es centrarse en la searchHandler (). Este método se llama cuando el usuario hace clic en el botón Buscar. Cuando se llama a este método, primero comprueba la longitud de los datos de la caja de búsqueda para asegurar una búsqueda válida va a suceder. Si el valor es de longitud válido, una llamada a eliminar los resultados de búsqueda de edad se hace.

public function searchHandler(e:MouseEvent):void { if(searchTxt.text.length > 0) { removeOldResults(); loadSearchResults(searchTxt.text); } }

320

Una vez que se encuentra un término de búsqueda válido, el siguiente paso es configurar y realizar la llamada al PHP, que es responsable de la interfaz con la AWS. La convocatoria de este ejemplo es muy similar a los ejemplos anteriores. En primer lugar, establecer las variables de objeto, que asigna a la URLRequest, crear una instancia de cargador nuevo, y, finalmente, asignar un detector de eventos.

public function loadSearchResults(terms:String):void { var urlVariables:URLVariables = new URLVariables(); urlVariables.terms = terms;

var urlRequest:URLRequest = new URLRequest(webServiceURL); urlRequest.data = urlVariables;

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, loadedResultsHandler); urlLoader.load(urlRequest); }

Usted puede haber notado que este método se ha hecho público. Esto se hace lo que otras aplicaciones pueden utilizar la capacidad de buscar, porque eso es lo que la reutilización se trata. Por supuesto, si usted permite que otros para llamar a este método directamente, lo más probable es que quiera colocar otro plazo de verificación para asegurarse de que los datos erróneos no va a ser enviado.

Una vez que devuelve el servidor Web de los datos, se envía al método loadedResultsHandler(). La respuesta se envía en formato XML y, utilizando un bucle for..each cada elemento se extrae y se envía a una instancia única de clase BookItem.

var xml:XML = new XML(urlLoader.data);

for each(var item in xml..book) ...

El BookItem hace referencia a un movieclip en la biblioteca. Este movieclip está precargado con entradas ficticias que se rellenan con los datos reales antes de que se muestran en el escenario.

var bookItem:BookItem = new BookItem(); bookItem.setValues( item..title, item..author, item..price, item..thumb ); bookItem.y = (bookItems.length * (bookItem.height + 30)); bookItems.push(bookItem); bookItemsContainer.addChild(bookItem);

El controlador de eventos siguiente completado:

public function loadedResultsHandler(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

for each(var item in xml..book) 321

{ var bookItem:BookItem = new BookItem(); bookItem.setValues( item..title, item..author, item..price, item..thumb );

bookItem.y = (bookItems.length * (bookItem.height + 30)); bookItems.push(bookItem); bookItemsContainer.addChild(bookItem); } }

El último método para la clase de documento se utiliza para eliminar los casos elemento existente libro. Este método es llamado cada vez que comienza una nueva búsqueda, para asegurar que los datos no accidentalmente apilar hasta.

private function removeOldResults():void { if(bookItems.length > 0) { bookItems = new Array(); removeChild(bookItemsContainer); bookItemsContainer = new MovieClip(); bookItemsContainer.y = 100; addChild(bookItemsContainer); } }

La primera parte del método de los controles para las entradas válidas porque la primera vez que se ejecuta la aplicación, no habría productos existentes en el escenario.

if(bookItems.length > 0) { ... }

Si hay elementos existentes, una nueva matriz se crea que limpia los objetos existentes. Luego, utilizando removeChild, el contenedor de edad se elimina y se crea uno nuevo. Esto se hace para liberar recursos y eliminar los productos existentes.

bookItems = new Array(); removeChild(bookItemsContainer); bookItemsContainer = new MovieClip();

El último paso es añadir el contenedor nuevo libro a la lista de visualización, que se hace llamando addChild() y pasar la nueva instancia del contenedor como un argumento.

addChild(bookItemsContainer);

Ahora puede seguir adelante y crear la clase BookItem, que se utiliza para cada producto que se añade al escenario. Es responsable de almacenar los datos fuera de la carga de los productos y en la miniatura de libro. Antes de que cualquier desarrollo de la clase comienza es una buena idea buscar en el esqueleto, como en el ejemplo anterior. Si lo hace, le permite entender mejor cómo se pretende trabajar.

322

package { import flash.display.MovieClip; import flash.text.TextField; import flash.display.Loader; import flash.net.URLRequest;

public class BookItem extends MovieClip { public function BookItem() { } public function setValues(t:String, a:String, p:String, i:String):void {} public function loadThumb():void {} public function getValues():Object {} } }

El primer método en la mayoría de las clases es el constructor, y esto no es una excepción, salvo por el hecho de que este constructor está vacío. El siguiente método es setValues, que se encarga de almacenar los valores pasados. Estos valores serán los datos del libro que es extraído de Amazon. Usted también puede pasar esta información como un objeto, pero para este ejemplo, es más fácil de entender el uso de variables independientes.

public function setValues(t:String,a:String,p:String,i:String):void { title = t; author = a; price = p; thumb = i;

titleTxt.text = title; authorTxt.text = author; priceTxt.text = price;

loadThumb(); }

Una vez que todas las variables que se almacenan fuera, una llamada a loadThumb hecho es, que es responsable de recuperar la imagen de la portada del libro. Cuando se utiliza la clase Loader, puede pasar que en el addChild, que elimina la necesidad de un detector de eventos, pero más importante aún, se carga por sí sola, porque la portada del libro no es necesario. También puede crear un gestor visual para informar al usuario de que algo es realmente la carga. El resto del método es sólo una URLRequest estándar, que debe estar familiarizado con los de los ejemplos anteriores.

public function loadThumb():void { var thumbLoader:Loader = new Loader(); var thumbURL:String = thumb; var thumbURLRequest:URLRequest = new URLRequest(thumbURL); thumbLoader.load(thumbURLRequest); thumbLoader.x = 10; addChild(thumbLoader); }

323

El último método es para el retorno de los datos BookItem que fue poblada en los métodos anteriores.

public function getValues():Object { return {title:title, author:author, price:price}; }

En este punto, usted ha completado una aplicación de búsqueda de Amazon con PHP y Flash. También han obtenido una gran cantidad de información sobre el sistema de AWS y debe ser bombeado a construir su propio servicio de Web-habilitado.

Algunos proyectos posibles a construir son la aplicación de búsqueda de CD, sistema de concordancia de género, o incluso una galería a la que utiliza la biblioteca de iTunes local o reproductor de música similar a la construcción de una nube visual de música que ha escuchado. Consulte el sitio Web para este libro para ver otros ejemplos de aplicaciones creadas usando el sistema de Amazon AWS.

Desarrollar una galleria de fotos usando flickr

La galería de fotos es una aplicación muy popular que se construye a menudo usando Flash. Ofrece una manera muy única para exhibir su trabajo o en algunos casos se utiliza como una aplicación de entrega de información, como por ejemplo en juegos y sitios de noticias.

En esta sección, usted aprenderá a desarrollar una galería de fotos usando el servicio de fotos en Flickr proporcionados por Yahoo. La aplicación Flash se hace una llamada a PHP, que interactúan con los servicios Web de Flickr y, finalmente, volver de nuevo a que los datos de Flash para mostrarlos.

Antes de comenzar el desarrollo de la aplicación, registrarse para obtener una clave de API de Flickr, que es un proceso de dos pasos. El primer paso es crear una cuenta de Flickr, visite la página de registro en www.flickr.com/signup/.

Una vez que tenga una cuenta de Flickr, solicitur una API, por visitar www.flickr.com/services/api/keys/apply/.

NOTA Si selecciona la opción no comercial que autoriza su solicitud de forma casi instantánea.

En este ejemplo se utiliza una clase de documentos para manejar la mayoría de la carga y visualización de proceso.De hecho, la mayor parte de esta clase es similar al del ejemplo anterior. Si usted completó este ejemplo, puede copiar los archivos de clase y hacer los cambios que sean necesarios.

Aquí está el esqueleto de la clase, que le dará una mejor idea de cómo la clase trabaja.

package { import flash.display.MovieClip; import flash.events.*; import flash.net.*;

public class PhotoGallery extends MovieClip { public var webServiceURL:String; private var photos:Array; private var photosContainer:MovieClip;

324

http://www.flickr.com/services/api/keys/apply/

http://www.flickr.com/signup/

public function PhotoGallery() {} public function searchHandler(e:MouseEvent):void {} public function loadSearchResults(terms:String):void {} public function loadedResultsHandler(e:Event):void {}

private function removeOldPhotos():void {} } }

El primer método es realmente el constructor, que en esta aplicación se encarga de la creación de un nuevo contenedor, y también inicializa la matriz de elemento.

public function PhotoGallery() { photos = new Array(); photosContainer = new MovieClip(); photosContainer.y = 75; }

Después de que se crea un nuevo movieclip, es necesario que se añada a la lista de visualización, y un controlador de eventos debe ser asignada al botón de búsqueda situado en el escenario.

searchBtn.addEventListener(MouseEvent.CLICK, searchHandler); addChild(photosContainer);

El siguiente método es centrarse en searchHandler(). Cuando este método se le llama comprueba en primer lugar por un término de búsqueda válido. Si el valor es válido, una llamada a eliminar las imágenes antiguas que se haga.

public function searchHandler(e:MouseEvent):void { if(searchTxt.text.length > 0) { removeOldPhotos(); loadSearchResults(searchTxt.text); } }

El siguiente método es para llamar al PHP, que es responsable de la interfaz con Flickr. La variable de etiquetas se pasa desde el controlador de búsqueda y se envía al PHP a través de una petición GET.

public function loadSearchResults(tags:String):void { var urlVariables:URLVariables = new URLVariables(); urlVariables.tags = tags;

var urlRequest:URLRequest = new URLRequest(webServiceURL); urlRequest.data = urlVariables;

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, loadedResultsHandler); urlLoader.load(urlRequest); }

325

El PHP está configurado para devolver un conjunto de resultados XML, que es una versión reducida de lo que se devuelve desde Flickr. Esto es muy similar al del ejemplo del Amazon, porque los servicios Web tienden a devolver una gran cantidad de información que no es necesario para una aplicación como esta.

Los datos XML se carga por primera vez en un objeto XML para analizar adecuado para ser posible. Una vez creado el objeto XML, se ejecuta a través de un bucle for..each de sacar cada foto nodo de.

public function loadedResultsHandler(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

for each(var item in xml..photo) { ... } }

Uso de cada foto nodo es necesario crear una instancia de PhotoItem, que es donde se carga la imagen de flickr. Piense en este caso como un contenedor para cada imagen. Esta instancia también es donde los datos de imagen se almacena para uso futuro.

var photoItem:PhotoItem = new PhotoItem(); photoItem.setValues(item..title, item..thumb);

Cuando se crea una nueva instancia de la PhotoItem, debe estar alineado en el contenedor. Esta posición se determina en función de la longitud de la matriz de fotos y multiplicando el resultado por la altura de la photoItem nuevo. Ese valor se incrementó en un 50 pixels para permitir espacio para la imagen en miniatura.

photoItem.y = (photos.length * (photoItem.height + 50));

Otra solución más elegante es la de crear un controlador de eventos que se suman las fotos una vez que se carga. Esto ofrece la posibilidad de tener múltiples imágenes a tamaño y ser más dinámico.

La última tarea de este método consiste en agregar la nueva instancia en la matriz de fotos y finalmente mostrarlo.

photos.push(photoItem); photosContainer.addChild(photoItem);

Cada vez que una nueva búsqueda se lleva a cabo, una llamada al método removeOldPhotos se hace. Este método es responsable de la eliminación de las imágenes existentes y asegurar que los datos no se cruzaron.

private function removeOldPhotos():void { if(photos.length > 0) { photos = new Array(); removeChild(photosContainer); photosContainer = new MovieClip(); photosContainer.y = 75; addChild(photosContainer); } }

326

Este método private se establece en el código para que no pueden borrar accidentalmente las imágenes. Si desea permitir la eliminación externa de las imágenes que puede crear un método que los controles que delega cierto nivel de autorización. Si la petición es válida, las imágenes pueden ser removidos.

La siguiente clase para crear, ahora que se ha completado la clase de documento, es la PhotoItem. Esta clase contiene la información para cada imagen que se carga desde Flickr. También es responsable de cargar la posición de la miniatura de la instancia en el escenario.

package { import flash.display.MovieClip; import flash.text.TextField; import flash.display.Loader; import flash.net.URLRequest;

public class PhotoItem extends MovieClip { private var title:String; private var thumb:String;

public function BookItem() { } public function setValues(t:String, i:String):void {} public function loadThumb():void {} public function getValues():Object {} } }

Cuando una nueva instancia de esta clase se crea, una llamada a la setValues se hace para almacenar los datos de la imagen. Este método acepta dos argumentos: título y la ruta en miniatura. Ambas variables se guardan en variables privadas para que accidentalmente no se pueda acceder y modificar.

title = t; thumb = i;

Una vez que se carguen los datos, el título se añade al componente titleTxt situado en el movieclip. El título también se desplaza a cabo para dar cabida a la imagen en miniatura.

titleTxt.text = title; titleTxt.x = 100;

La pieza final es hacer una llamada al método loadThumb.

loadThumb();

El método de loadThumb es responsable de cargar la imagen que se encuentra en el documento XML.

public function loadThumb():void { var thumbLoader:Loader = new Loader(); var thumbURL:String = thumb; var thumbURLRequest:URLRequest = new URLRequest(thumbURL); thumbLoader.load(thumbURLRequest); thumbLoader.x = 10; addChild(thumbLoader); }

327

El último método es responsable de pasar de nuevo la información de la imagen.

public function getValues():Object { return {title:title}; }

Usted puede haber notado el gestor de miniatura es el mismo código que se utilizó en el libro de ejemplo de la búsqueda. También puede haber notado que el código de gestor a través de todo este libro es muy similar. Lo que debería decir es una clase que se han construido para manejar esta tarea, y una importación sencilla sustituiría diez líneas de código que se han duplicado en todas las aplicaciones.

Esto no es realmente notable para una pequeña aplicación, pero que sería si estuviera desarrollando un proyecto a gran escala largerscale. Reutilización de la clase se explica en mayor detalle en el capítulo 9. Pero básicamente, lo que viene abajo es cuando eres capaz de hacer algo modular, es probablemente una buena idea para hacerlo.

Interfaz con el servicio Web

El siguiente paso en la galería de fotos es para construir el código PHP que se encargará de la conexión a flickr y analizar la respuesta XML.

El primer paso es definir el API clave de Flickr que se proporciona desde Flickr.

<?php

define(“FLICKR_ACCESS_KEY”, “{FLICKR_API_KEY}”);

Flickr tiene una manera única parte de la construcción de las URLs de la imagen. La manera más fácil trabajar con este formato es usando la función sprintf. Esta función acepta una cadena con las variables de marcador de posición que luego se rellenan con las variables reales utilizando valores proporcionados en los otros.

$flickrURLTemplate= “http://farm%s.static.flickr.com/ %s/%s_%s_s.jpg”;

Para evitar solicitudes erróneas, una simple declaración if se utiliza para asegurarse de que las etiquetas de variable que viene de Flash, de hecho, tiene un término de búsqueda. Si por alguna razón, la variable está vacía, el script y no más de código se ejecuta desde ese punto.

if(empty($_GET[‘tags’])) { exit(); }

Si se encuentra un valor de etiqueta válido, el siguiente paso es recoger la información de la etiqueta y hacer la llamada a Flickr para iniciar el proceso de búsqueda.

$apiMethod = “flickr.photos.search”; $request = “http://api.flickr.com/services/rest/” . “?method=” . $apiMethod . “&tags=” . $searchTags . “&api_key=” . FLICKR_ACCESS_KEY.

328

“&per_page=5”;

$rawXml = file_get_contents($request);

El servicio de fotografía devuelve un documento XML que se almacena en la variable $rawXml. Una vez cargado el XML, se pasa a

lo largo del método simplexml_ load_string(), que crea un objeto propio que PHP puede analizar.

$xmlResponse = simplexml_load_string($rawXml);

Cuántas imágenes para mostrar son determinados por la carga del valor que se encuentra en el documento XML.

$nodeCount = getAttribute($xmlResponse->photos, “perpage”);

Construir un document XML personalizado

El proceso de construcción del documento XML personalizado se realiza mediante un bucle que se agarra a cada nodo de fotos y recoge la información requerida.

$xml = “<?xml version=\”1.0\” ?>\n<photos>”;

for($i=0; $i < $nodeCount; $i++) { $farmID= getAttribute($xmlResponse->photos->photo[$i], “farm”); $serverID= getAttribute($xmlResponse->photos->photo[$i], “server”); $photoID= getAttribute($xmlResponse->photos->photo[$i], “id”); $secret= getAttribute($xmlResponse->photos->photo[$i], “secret”);

$xml .= “\t<photo>”; $xml .= “\t\t<title><![CDATA[“ . getAttribute($xmlResponse- >photos ->photo[$i], “title”) . “]]></title>”; $xml .= “\t\t<thumb>” . sprintf($flickrURLTemplate, $farmID, $serverID, $photoID, $secret) . “</thumb>”; $xml .= “ </photo>”; }

La primera parte del circuito es para la construcción de la ruta de la imagen, que se pasa a la función sprintf. Después de que el documento XML en general se crea, el último paso es la salida a la persona que llama, que en este caso sería Flash.

header(“content-type: text/xml”); print $xml;

Ahora que el PHP se ha completado y la aplicación general se ha desarrollado, se puede comprobar, como se muestra en la Figura 12.5.

329

FIGURA 12.5 Aquí está la aplicación final, que muestra las imágenes de una búsqueda usando la etiqueta de color naranja.

Resumen

En este capítulo usted aprendió cómo conectar Flash a los servicios Web de PayPal, para desarrollar un carrito de la compra personalizada. Una vez que se completó la parte de desarrollo de PayPal que aprendió a desarrollar un carrito de la compra personalizado en Flash utilizando clases para simplificar el proceso de desarrollo. A continuación, aprendió a desarrollar un sistema de búsqueda que utiliza la API de búsqueda de Amazon.com, y obtuvo una comprensión de cómo los datos en el tercer partido los servicios de regreso.

En la última parte del capítulo que desarrolló una aplicación de la imagen usando la API de Flickr. En el proceso, que ha aprendido algunas de las características más robustas de PHP para desglosar los datos y construir las solicitudes utilizando sprintf.

El siguiente paso es extender este ejemplo y, posiblemente, crear un script de galería de fotos con las categorías y la posibilidad de añadir/editar fotografías. Incluso podría incluir esta pequeña porción en una

330

aplicación mayor, mientras que a través de Flickr como la interfaz gráfica o el punto de almacenamiento de fotos.

Capitulo 13

Uso Avanzado de las aplicaciones Del mundo real

Aplicaciones del mundo real están destinados a ser productos completos que han sido probados y están listos para ser desplegados para el público en general a disfrutar de ellos. Este capítulo se centra en la construcción de una serie de aplicaciones que hacen precisamente eso. Los archivos de partida se han previsto para que pueda centrarse en el núcleo de las aplicaciones, lo que sería el proceso de desarrollo.

Cada ejemplo se divide en sus clases individuales, archivos, y los paquetes en función de lo que se requiere. Si usted nunca ha trabajado con las clases, te recomiendo que lea el capítulo 10. Esto asegurará los ejemplos y los estilos de codificación son fáciles de seguir.

Construir una aplicación de dibujo en Flash

Esta aplicación toma el dibujo (véase la figura 13.1) y usa PHP para crear un formato de imagen exportable. La primera parte del código es responsable de la parte de dibujo de la aplicación.

331

FIGURA 13.1 Aquí está la aplicación de dibujo terminado.

API de dibujo en Flash

La API de dibujo que se incluye con Flash ofrece una amplia gama de herramientas, como líneas, círculos, cuadrados, y degradados. Este ejemplo se centra en la línea para crear un flash basado en la herramienta de dibujo.

Una vez abierto el archivo de inicio {START_FILE}, se puede comenzar a establecer las variables de inicialización que se mantenga el color del lápiz y el tamaño por defecto, así como el contenedor de referencia.

var penMC:MovieClip; var isDrawing:Boolean = false;

var penTipSize:uint = 1; var penColor:Number = 0x000000;

332

La aplicación de dibujo se creó para elaborar la línea cuando el botón se mantiene presionado y se detendrá cuando se suelta el botón del ratón. Durante el tiempo que el botón del ratón se establece un llamado persistente a una función de desplazamiento del ratón se produce al colocar el punto de la pluma en una ubicación diferente. La pluma está programado para trazar la línea donde se encuentra el puntero del ratón. El siguiente paso es la construcción de los controladores de eventos que se utilizará para determinar el estado de la pluma y habilitar o deshabilitar la capacidad de dibujo. La variable isDrawing se alterna para definir el estado actual de la aplicación. Este método startDrawing () sólo es llamado cuando el ratón hace clic. Es importante que una línea nueva se crea en caso de que el color o el tamaño de las variables han cambiado.

function startDrawing(e:MouseEvent):void { trace(“Start Drawing”); isDrawing = true; penMC.graphics.lineStyle(penTipSize, penColor, 1.0); penMC.graphics.moveTo(mouseX, mouseY); }

Después de la bandera de dibujo se establece que puede comenzar a dibujar el trazo de lápiz reales (s). La posición de la pluma está determinado por la ubicación actual del puntero del ratón.

function drawing(e:MouseEvent):void { if(isDrawing) { penMC.graphics.lineTo(mouseX, mouseY); } }

Ahora que la línea está siendo debidamente elaborados, es una buena idea para evitar que una vez que se suelta el botón del ratón. Esto se hace colocando un controlador para el evento de ratón.

function stopDrawing(e:MouseEvent):void { trace(“Stop Drawing”); isDrawing = false; }

El último método en este ejemplo es bastante complejo. Es responsable de la construcción de la caja de herramientas y de inicializar el evento de controladores de ratón.

function init():void { penMC = new MovieClip(); stage.addEventListener(MouseEvent.MOUSE_DOWN, startDrawing); stage.addEventListener(MouseEvent.MOUSE_UP, stopDrawing); stage.addEventListener(MouseEvent.MOUSE_MOVE, drawing); addChild(penMC); ...

La caja de herramientas está formado por clips de película que ya están en el escenario y convenientemente identificado dentro de un movieclip contenedor.

toolsMC.swatchPurpleMC.addEventListener(MouseEvent.CLICK, function():void {

333

penColor = 0x9999CC; }); toolsMC.swatchBlueMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0x0000FF; }); toolsMC.swatchRedMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0xFF0000; }); toolsMC.swatchGreenMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0x00FF00; }); toolsMC.swatchOrangeMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0xFF9900; }); toolsMC.swatchBlackMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0x000000; });

toolsMC.brushSize1MC.addEventListener(MouseEvent.CLICK, function():void { penTipSize = 1; }); toolsMC.brushSize2MC.addEventListener(MouseEvent.CLICK, function():void { penTipSize = 2; });

toolsMC.brushSize4MC.addEventListener(MouseEvent.CLICK, function():void { penTipSize = 4; });

toolsMC.brushSize6MC.addEventListener(MouseEvent.CLICK, function():void { penTipSize = 6; });

Cuando todas las herramientas están en su lugar, los canjes de contenedores en las profundidades con el movieclip pluma para asegurarse de que no se puede querer aprovechar la interfaz de la herramienta.

swapChildren(toolsMC, penMC); }

Ahora que se establece el código ActionScript para la aplicación de dibujo, aquí está el código completado:

334

var penMC:MovieClip; var isDrawing:Boolean = false;

var penTipSize:uint = 1; var penColor:Number = 0x000000;

function init():void { penMC = new MovieClip(); stage.addEventListener(MouseEvent.MOUSE_DOWN, startDrawing); stage.addEventListener(MouseEvent.MOUSE_UP, stopDrawing); stage.addEventListener(MouseEvent.MOUSE_MOVE, drawing); addChild(penMC);

toolsMC.swatchPurpleMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0x9999CC; }); toolsMC.swatchBlueMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0x0000FF; }); toolsMC.swatchRedMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0xFF0000; }); toolsMC.swatchGreenMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0x00FF00; }); toolsMC.swatchOrangeMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0xFF9900; }); toolsMC.swatchBlackMC.addEventListener(MouseEvent.CLICK, function():void { penColor = 0x000000; });

toolsMC.brushSize1MC.addEventListener(MouseEvent.CLICK, function():void { penTipSize = 1; }); toolsMC.brushSize2MC.addEventListener(MouseEvent.CLICK, function():void { penTipSize = 2; });

toolsMC.brushSize4MC.addEventListener(MouseEvent.CLICK, function():void

335

{ penTipSize = 4; });

toolsMC.brushSize6MC.addEventListener(MouseEvent.CLICK, function():void { penTipSize = 6; }); swapChildren(toolsMC, penMC); }

function startDrawing(e:MouseEvent):void { trace(“Start Drawing”); isDrawing = true; penMC.graphics.lineStyle(penTipSize, penColor, 1.0); penMC.graphics.moveTo(mouseX, mouseY); }

function drawing(e:MouseEvent):void { if(isDrawing) { penMC.graphics.lineTo(mouseX, mouseY); } }

function stopDrawing(e:MouseEvent):void { trace(“Stop Drawing”); isDrawing = false; }

init();

Eso es todo lo que hay es una aplicación de dibujo básico en Flash. Puede ampliar este ejemplo, dando consejos de lápiz diferente o tal vez algunos de diferentes colores para permitir el sombreado de estilos de pintura y otros.

La siguiente sección se basa en este ejemplo y usa PHP para hacer y guardar la imagen en el servidor.

Uso de la libreria GD en PHP

La librería GD de PHP es una colección de funciones que te dan la habilidad para manipular y crear imágenes. GD también tiene soporte de texto siempre que usted haya instalado las bibliotecas correctas. Trabajar con la biblioteca GD es bastante sencillo, ya sea crear una imagen o abrir una imagen existente como base y modificarlo según sea necesario.

Uno de los usos más comunes de la biblioteca GD incluye la creación automática de marcas de agua que se aplican a una galería de imágenes. Algunos lo utilizan para crear miniaturas dinámicas, similar a la forma en que su editor de imágenes locales haría.

http://www.php.net/manual/en/ref.image.php

336

http://www.php.net/manual/en/ref.image.php

La biblioteca GD ofrece una lista enorme de funciones, pero algunos de ellos requieren de librerías adicionales. De hecho, es una buena idea ejecutar un código, como el siguiente, para determinar lo que está instalado.

<?php var_dump(gd_info()); ?>

Este código imprime lo que la situación de los diferentes componentes de GD son, como lo que es y no está instalado. Este es el resultado de la muestra de la llamada var_dump.

array(9) { [“GD Version”] => string(24) “bundled (2.0 compatible)” [“FreeType Support”] => bool(false) [“T1Lib Support”] => bool(false) [“GIF Read Support”] => bool(true) [“GIF Create Support”] => bool(false) [“JPG Support”] => bool(false) [“PNG Support”] => bool(true) [“WBMP Support”] => bool(true) [“XBM Support”] => bool(false) }

El código anterior le permite saber que usted no tiene FreeType (fuente) y JPG (imagen) el apoyo habilitado o instalado. Con esta información, usted puede continuar e instalar las librerías necesarias.Tenga en cuenta que la instalación de aplicaciones en un entorno de línea de comandos no es tan simple como un doble clic. Se trata de construir extensa de herramientas y, a veces requiere de otras bibliotecas, lo que significa que puede tomar un montón de trabajo para obtener el kit completo de trabajo GD.

Si usted es presionado por el tiempo y están trabajando a nivel local se puede echar un vistazo a las opciones de inicio rápido disponible en el capítulo 1, que vienen con una versión completa de PHP y GD. Si está ejecutando desde un sistema remoto lo mejor es ponerse en contacto con su host web para las solicitudes de instalación.

PRECAUCIÓN La biblioteca GD (básicos) no viene con cada versión de PHP. Consulte con su servidor o instalar según sea necesario.

Desde este punto avanza paquete GD debe estar instalado con al menos apoyo JPG a fin de completar los ejemplos. Antes de construir la aplicación final, es mejor para familiarizarse con la biblioteca GD mirando algunos ejemplos.

He aquí un ejemplo GD simple que crea un rectángulo de color rosa y los resultados al explorador como un archivo JPG (véase la figura 13.2).

$image = imagecreate(250, 80); $bgColor = imagecolorallocate($image, 255, 0, 120); header(“Content-Type: image/jpeg”); imagejpeg($image);

337

FIGURA 13.2 Aquí está la imagen que fue generada por la librería GD, utilizando el código simple.

Esta es una continuación del ejemplo anterior, pero esta vez se guarda el archivo JPG al el servidor Web.Al agregar un segundo argumento a la función imagejpeg(), que es un nombre de archivo, la imagen se guarda con el nombre de archivo sample.jpg en lugar de ser una salida en el navegador.

$image = imagecreate(250, 80); $bgColor = imagecolorallocate($image, 255, 0, 120); header(“Content-Type: image/jpeg”); imagejpeg($image, ‘./sample.jpg’);

Si bien estos ejemplos son bastante simples que deben dar una idea de cómo trabajar con la librería GD. Si usted tiene otras bibliotecas instalado, puede representar el texto en las imágenes, entre otros muchos resultados muy interesantes. La biblioteca GD es una gran característica de PHP y ha llegado realmente útil para muchas tareas, no importa cuán grande.

338

Ahora, vamos a pasar a la aplicación real que se inició en la sección anterior. El ActionScript es permitir a los usuarios dibujar una imagen y cambiar la configuración, y todo funciona a la perfección, sin embargo, el usuario no es capaz de guardar la imagen, a menos que lo imprime. La idea es inspeccionar la imagen y enviar los datos a PHP, que será responsable de la creación de un píxel por píxel de la imagen y guardarla en el servidor Web.

Generar una imagen en la libreria GD

Esta sección se centra en el uso de PHP para hacer que la imagen que se dibuja en la aplicación Flash.Normalmente, se comienza con el código PHP en primer lugar, pero en esta aplicación, el PHP se utiliza solamente como un renderizador de lo que tiene sentido comenzar con la parte de Flash.

La mayoría de la aplicación se escribió en la sección anterior, usted simplemente tomar ese código y ampliar para agregar las acciones necesarias.

El código PHP se encarga de la carga del passed-in XML en un objeto que se utiliza para generar, o hacer, la imagen final. La anchura, altura, y XML son todos pasaron a partir de datos POST porque una solicitud GET fracasaria.

$width = $_POST[‘width’]; $height = $_POST[‘height’];

$points = simplexml_load_string($_POST[‘pointData’]);

Cuando los datos se ha cargado correctamente, puede configurar la base de la imagen renderizada. Esto se hace utilizando la función imagecreatetruecolor(), que es parte de la librería GD.

$img = imagecreatetruecolor($width, $height);

La imagen real se genera un bucle a través de todos los datos XML que está sacando los valores de color que fueron capturados en Flash.

$limit = count($points->point);

for($j=0; $j < $limit; $j++) { $x = $points->point[$j]->x; $y = $points->point[$j]->y;

$color = $points->point[$j]->c; $color = hexdec($color);

imagesetpixel($img, $x, $y, $color); }

Los datos de los píxeles se colocan en un patrón de cuadrícula de una línea a la vez, la $x y $y son el punto de cada color se va a colocar. Todos estos datos se pasa a la función Imagesetpixel en cada paso del bucle interior.

El último paso del PHP una vez creada la imagen para representar la imagen como PNG, tal como se muestra en la Figura 13.3, y guárdelo en el sistema de archivos.

header(‘Content-Type: image/png’); imagepng($img, ‘render_’ . time() . ‘.png’);

339

FIGURA 13.3 Una imagen de muestra representa como un PNG

PRECAUCIÓN El proceso de construcción de un píxel de la imagen por píxeles es intensivo del procesador y puede tomar mucho tiempo, dependiendo del tamaño de la imagen.

Aquí está el código PHP completado:

<?php

$width = $_POST[‘width’]; $height = $_POST[‘height’];

$points = simplexml_load_string($_POST[‘pointData’]);

$img = imagecreatetruecolor($width, $height);

340

$limit = count($points->point);

for($j=0; $j < $limit; $j++) { $x = $points->point[$j]->x; $y = $points->point[$j]->y;

$color = $points->point[$j]->c; $color = hexdec($color);

imagesetpixel($img, $x, $y, $color); }

header(‘Content-Type: image/png’); imagepng($img, ‘render_’ . time() . ‘.png’);

?>

Recolección de datos de pixel en Flash

Hay sólo algunas actualizaciones necesarias para el código de Flash de la sección anterior, pero por ahora se centran en la recopilación de los datos de la imagen utilizando la clase BitmapData.

El primer paso en esta función es determinar las dimensiones de la imagen.

var width:uint = penMC.width; var height:uint = penMC.height;

La siguiente variable a definir es la referencia de archivo PHP.

var phpFile:String = “http://localhost/ch12/DrawingGD/ImageGenerator.php”;

El siguiente paso es construir un nuevo mapa de bits utilizando el método draw() de la clase BitmapData. El método draw realiza un argumento, que es el objetivo. Este método toma el argumento y copia los datos de los píxeles al nuevo mapa de bits.

var bmp:BitmapData = new BitmapData(width, height, true, 0xFFFFFF); bmp.draw(penMC);

Después de que el nuevo mapa de bits es creado, usted puede construir un bucle que se analizará el mapa de bits y agarrar el color de cada píxel.

var xml:String = “<points>”;

for(var i:uint=0; i < width; i++) { for(var j:uint=0; j < height; j++) { var color:String = bmp.getPixel(i, j).toString(16);

if(color == “0”) { color = “FFFFFF”; }

341

xml += “<point>”; xml += “\t<x>” + i + “</x>”; xml += “\t<y>” + j + “</y>”; xml += “\t<c>” + color + “</c>”; xml += “</point>”; } }

xml += “</points>”;

Los datos de color se almacena un elemento en el documento XML personalizado que se envía fuera de PHP, una vez escaneado toda la imagen. Las variables se almacenan en una nueva instancia de la URLVariables objeto y se pasa a PHP en el formato de datos POST.

var urlVariables:URLVariables = new URLVariables(); urlVariables.width = width; urlVariables.height = height; urlVariables.pointData = xml;

var urlRequest:URLRequest = new URLRequest(phpFile); urlRequest.method = URLRequestMethod.POST; urlRequest.data = urlVariables; sendToURL(urlRequest);

La respuesta es enviada a PHP usando el método de sendToURL. Este silencio, llama al servidor web y no espera ninguna respuesta. La razón para usar este método es porque la solicitud será bastante grande si la imagen se ha prestado una gran cantidad de datos de píxeles.

Uso de Flash para construir un monitor del sitio web

Cuando se posee u opera un sitio web que a veces puede ir fuera de línea, pero probablemente nunca se sabrá si se establecen sólo por un breve momento, a menos que se esté consultando en el sitio. ¿Qué sucede si usted opera muchos sitios Web y están ocupados trabajando mientras que su sitio se cae? Más probable es que su sitio se desconecta y no son conscientes de ello.

Esta sección contiene la explicación y el desarrollo de un seguimiento basado en Flash de la web que registra los intentos fallidos de acceder al servidor. Incluso puede ser configurado para el administrador de e-mail si el sistema encuentra un sitio que no ha respondido después de cierto punto (configurable por el operador).

El esquema de tabla de MySQL (esquema) es el siguiente:

CREATE TABLE siteMonitor ( id INT NOT NULL AUTO_INCREMENT, name VARCHAR(100) DEFAULT “” NOT NULL, uri TEXT NOT NULL, active VARCHAR(1) DEFAULT 1 NOT NULL, PRIMARY KEY (id) );

CROSS--REF Hay muchas maneras que usted puede cargar el esquema de MySQL en su base de datos. Para obtener una explicación, véase el capítulo 2.

342

Desarrollar el PHP para el monitor del sitio web

La primera parte de la carga en PHP es la información de conexión para la base de datos. Este se coloca en un archivo externo, por lo que puede ser compartida a través de proyectos. De hecho, si usted está utilizando la misma base de datos como ejemplos anteriores de este libro, se puede reutilizar el viejo dbconn.php, porque no será cambiado para esta aplicación.

Si usted aún no ha creado el dbconn.php, aquí están los contenidos. Se llena la información real para su servidor, que se pueden obtener del administrador del servidor Web si usted no es el propietario, o su proveedor de alojamiento si usted es dueño de su servidor.

<?php

$host = “localhost”; $user = “USERNAME”; $pass = “PASSWORD”; $database = “DATABASE_NAME”;



?>

Después de la conexión de la base de datos se establece puede continuar el desarrollo del archivo monitor.php.La $action se pasa a lo largo de la dirección, pero debe ser válido para que la secuencia de comandos para saber qué estado debe estar en ejecución.

$action = (isset($_GET[‘action’])) ? $_GET[‘action’] : “”;

Suponiendo que la acción es válida y el valor es getsites, que está configurado para devolver una lista de los sitios que están siendo monitoreadas. El proceso de recuperar la lista de sitios se lleva a cabo mediante un bucle que se carga en la información de la base de datos MySQL. La lista de sitios se devuelve a Flash como un objeto XML que definen cada uno de los sitios y donde se encuentran.

El SQL para recuperar la lista está configurado para cargar todas las entradas donde el valor de activo es igual a 1.

SELECT * FROM siteMonitor WHERE active=1

Después que los datos de SQL se recupera, se pasa a un bucle while, que es responsable de la apropiación cada fila y la construcción de una línea de XML que define la información del sitio.

$result = mysql_query(“SELECT * FROM siteMonitor WHERE active=1”);

$xml = “<?xml version=\”1.0\” ?>\n”; $xml .= “<sites>\n”; while($row = mysql_fetch_array($result))

343

{ ... }$xml .= “</sites>”;

La línea de XML está construido utilizando los datos $row, que se transmite en la función sprint(). El sprintf se utiliza para rellenar automáticamente el código XML necesario atributos utilizando la fila de datos de SQL.

$xml .= sprintf(“\t<site name=\”%s\” uri=\”%s\” />\n”, $row[‘name’], $row[‘uri’]);

Ahora que se ha construido los datos XML, es enviada al navegador y regresó a Flash. Esto se logra estableciendo el tipo de contenido de la respuesta al texto/xml, que es el tipo de MIME de XML. Entonces, el último paso es utilizar una declaración de hecho la salida de impresión a los datos.

header(“Content-type: text/xml”); print $xml;

Aquí está una muestra de la respuesta que se devolvería a Flash:

<?xml version=”1.0” ?> <sites> <site name=”Adobe” uri=”http://www.adobe.com” /> <site name=”AIRPlayground” uri=”http://www.airplayground.com” /> <site name=”mkeefeDESIGN” uri=”http://www.mkeefedesign.com” /> <site name=”Google” uri=”http://www.google.com” /> </sites>

Uso de PHP para e-mail del administrador

Cuando un sitio ha sido inalcanzable para una cierta cantidad de tiempo, es probablemente una buena idea para notificar a alguien. La notificación se envía utilizando el construido en función mail(). El e-mail alertas al administrador de un servidor de lo que el sitio está experimentando el corte y en qué momento se envió el informe, en el caso raro el correo electrónico se retrasa o no es notado de inmediato.

El primer paso es verificar la acción anterior se establece en e-mail al administrador. De lo contrario, este bloque de código completo sería ignorado.

else if($action == “emailadmin”) { ... }

Si la acción (action) es válido, el siguiente paso es construir el mensaje de correo electrónico y recuperar los valores pasados de Flash que definir el sitio experimentando el apagón.

$from = “[email protected]”; $to = “[email protected]”; $site = $_GET[‘site’]; $siteURI = $_GET[‘siteURI’]; $date = date(“F j, Y \\a\\t h:i a”, time()); // today’s date

344

El cuerpo del e-mail se define como una serie de variables $emailInfo concatenados con el punto (.), Que se utiliza para que PHP conocer esta variable es una continuación.

$emailInfo = “”; $emailInfo .= “**This is an automated response**.\n\n”; $emailInfo .= “The site status monitor has been informed\n”; $emailInfo .= “ the following site is not responding:\n”; $emailInfo .= “-----------------------------------------\n”; $emailInfo .= “Site: “ . $site . “ [“ . $siteURI . “]\n”; $emailInfo .= “Date Sent: “ . $date . “\n\n”; $emailInfo .= “-----------------------------------------\n”;

El encabezado del correo electrónico debe seguir la especificación que define cómo el e-mail se va a construir y el $from de valor tiene que ser válido, a pesar de que la actual dirección de correo electrónico no es utilizada.

// Mail headers, do not alter $mailHeaders = “From: “ . $from . “ <> \n\n”;

Cuando todas las variables y la información de correo electrónico se han creado, el correo electrónico reales pueden ser enviados.Esto se hace realizando una llamada a la función mail(), pasando por la información que fue construido en los pasos anteriores.

if(mail( $to, “Automated response from Site Monitor”, $emailInfo, $mailHeaders)) { print “result=success”; }

NOTA La función mail() devuelve un mensaje de éxito si la función es llamada correctamente. La función no sabe el estado del envío efectivo del e-mail.

Aquí está el código PHP completado para monitor.php:

<?php

require(‘dbconn.php’);

$action = (isset($_GET[‘action’])) ? $_GET[‘action’] : “”;

if($action == “getsites”) { $result = mysql_query(“SELECT * FROM siteMonitor WHERE active=1”);

$xml = “<?xml version=\”1.0\” ?>\n”; $xml .= “<sites>\n”; while($row = mysql_fetch_array($result)) { $xml .= sprintf(“\t<site name=\”%s\” uri=\”%s\” />\n”, $row[‘name’], $row[‘uri’]); }

345

$xml .= “</sites>”;

header(“Content-type: text/xml”);

print $xml; }else if($action == “emailadmin”) { $from = “[email protected]”; $to = “[email protected]”; $site = $_GET[‘site’]; $siteURI = $_GET[‘siteURI’];

$date = date(“F j, Y \\a\\t h:i a”, time()); // today’s date

$emailInfo = “”; $emailInfo .= “**This is an automated response**.\n\n”; $emailInfo .= “The site status monitor has been informed\n”; $emailInfo .= “ the following site is not responding:\n”; $emailInfo .= “-----------------------------------------\n”; $emailInfo .= “Site: “ . $site . “ [“ . $siteURI . “]\n”; $emailInfo .= “Date Sent: “ . $date . “\n\n”; $emailInfo .= “-----------------------------------------\n”;

// Mail headers, do not alter $mailHeaders = “From: “ . $from . “ <> \n\n”;

print $emailInfo; if(mail( $to, “Automated response from Site Monitor”, $emailInfo, $mailHeaders )) { print “result=success”; } }

?>

Desarrollo del ActionScript para el monitor del sitio web

En este punto, el código de PHP ha sido completado, y la siguiente sección se centra en el proceso de desarrollo de ActionScript. El archivo Flash se ha previsto para este ejemplo en el sitio Web del libro, que tiene todos los elementos de diseño en el lugar, como se muestra en la figura 13.4, para que pueda centrarse en el desarrollo.

346

FIGURA 13.4 Aquí está la solicitud completa con uno de los lugares con indicación de un fracaso.

Aquí está el esqueleto de clase para la clase de documento.

package { import flash.display.MovieClip; import flash.net.*; import flash.events.*;

public class SiteMonitor extends MovieClip { public function SiteMonitor() {} private function loadSites():void {} private function loadSiteHandler(e:Event):void {}

347

} }

El constructor de la clase de documento es responsable de asignar el movieclip siteContainer, y agregó que movieclip a la lista de visualización y, finalmente, hacer una llamada al método loadSites().

siteContainer = new MovieClip(); siteContainer.y = 80; siteContainer.x = 20; addChild(siteContainer);

loadSites();

El método loadSites() es el responsable de cargar la lista de sitios para ver. Un evento se une a la secuencia de carga, que se llama cuando los datos de la web es recuperado con éxito.

var variables:URLVariables = new URLVariables(); variables.action = “getsites”;

var urlRequest:URLRequest = new URLRequest(phpFile); urlRequest.data = variables;

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, loadSiteHandler); urlLoader.load(urlRequest);

El siguiente método se llama cuando los datos del sitio se carga correctamente. Un evento es pasado como un argumento que contiene la respuesta de PHP.

private function loadSiteHandler(e:Event):void { ... }

La respuesta es XML, lo que es necesario crear primero un objeto XML que se utiliza un bucle for..each.

var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

var i:uint = 0; for each(var item in xml..site) { ... } }

El contenido del bucle for..each crea una nueva instancia de la clase SiteMonitorItem que se adjunta a un clip de película en la línea de tiempo del mismo nombre.

var siteItem:SiteMonitorItem = new SiteMonitorItem(); siteItem.phpFile = phpFile; siteItem.siteURI = item..attribute(‘uri’); siteItem.siteNameTxt.text = item..attribute(‘name’); siteItem.statusMC.gotoAndStop(2);

siteItem.y = (i * (siteItem.height + 10));

348

siteContainer.addChild(siteItem); i++;

La variable siteItem tiene la instancia de clase de nueva creación, que se utiliza para asignar el phpfile, siteURI, y el nombre del sitio. El uri y el nombre del sitio se analizan desde el objeto XML utilizando el método attribute(), que tiene un argumento que es el nombre del atributo que está buscando. La colocación del objeto siteItem está determinado por una ecuación simple, utilizando la altura del objeto y el valor de la variable i, luego de tomar esa suma y añadiendo un relleno 10px. En este punto se termina la clase de documento. Aquí está el código completado:

package { import flash.display.MovieClip; import flash.net.*; import flash.events.*;

public class SiteMonitor extends MovieClip {

public var siteContainer:MovieClip; public var phpFile:String = “http://localhost/SiteMonitor/monitor.php”;

public function SiteMonitor() { siteContainer = new MovieClip(); siteContainer.y = 80; siteContainer.x = 20; addChild(siteContainer);

loadSites(); }

private function loadSites():void { var variables:URLVariables = new URLVariables(); variables.action = “getsites”;


var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, loadSiteHandler); urlLoader.load(urlRequest); }

private function loadSiteHandler(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

var i:uint = 0; for each(var item in xml..site) { var siteItem:SiteMonitorItem = new SiteMonitorItem();

349

siteItem.phpFile = phpFile; siteItem.siteURI = item..attribute(‘uri’); siteItem.siteNameTxt.text = item..attribute(‘name’); siteItem.statusMC.gotoAndStop(2); siteContainer.addChild(siteItem);

siteItem.y = (i * (siteItem.height + 10));

siteItem.checkSite();

i++; } } } }

La próxima clase a centrarse es SiteMonitorItem, que se asigna al movieclip en la biblioteca del mismo nombre. Aquí está el esqueleto de la clase de esa clase:

package { public class SiteMonitorItem extends MovieClip { public function SiteMonitorItem() {} public function checkSite():void {}

private function noResponse(event:IOErrorEvent):void {} private function siteResponsedHandler(e:Event):void {} private function stopChecking():void {}

public function get attempts():uint {} public function set attempts(num:uint):void {} } }

El constructor de esta clase está vacía, por lo que puede dejar fuera y continúe con el método siguiente, que es checkSite(). Este método es llamado por la clase de documento cuando el temporizador expira esperar. El objetivo de este método consiste en comenzar la acción de control del sitio y el controlador correcto en función de la respuesta recibida.

public function checkSite():void { var urlRequest:URLRequest = new URLRequest(siteURI); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, siteResponsedHandler); urlLoader.addEventListener(IOErrorEvent.IO_ERROR, noResponse); urlLoader.load(urlRequest); }

La mayoría de este método es el mismo que los ejemplos anteriores, con la excepción de que el segundo evento listener (oyente). Este detector de eventos se asigna a la IO_ERROR, que ocurre cuando un archivo no se carga correctamente o llamado. El método noResponse() será llamado cuando el sitio no puede ser cargado, como se muestra aquí:

350

urlLoader.addEventListener(IOErrorEvent.IO_ERROR, noResponse);

El método noResponse() es responsable de incrementar la variable failedAttempts, pero utilizando un método setter en lugar de acceder directamente a la variable.

private function noResponse(event:IOErrorEvent):void { attempts = attempts + 1; }

Si se carga el sitio, una llamada a siteResponsedHandler() se hace para borrar los intentos anteriores fracasaron y, básicamente, restablecer la cuenta de errores.

private function siteResponsedHandler(e:Event):void { failedAttempts = 0; }

Una llamada a stopChecking() se produce cuando un sitio no responde después de un número determinado de veces, fijada por la constante MAX_ATTEMPTS.

private function stopChecking():void { stopCheck = true; }

Los dos últimos métodos de esta clase son el getter y set para la variable failedAttempts.El captador (getter) simplemente devuelve el valor actual del valor failedAttempts. El setter no sólo los incrementos de variable failedAttempts, sino que también determina si todos los controles futuro debe interrumpirse según el recuento actual fracaso.

public function get attempts():uint { return failedAttempts; }

public function set attempts(num:uint):void { if(num == undefined) { failedAttempts++; }else { failedAttempts = num; }

if(failedAttempts == MAX_ATTEMPTS) { statusMC.gotoAndStop(1); stopChecking(); }

}

Si failedAttempts es igual a la constante MAX_ATTEMPTS, una llamada a stopChecking() se hace y se mueve el indicador de estado para el primer cuadro que muestra un círculo rojo.

351

En este punto la clase SiteMonitorItem ya está completo y la película de Flash pueden ser examinados para asegurarse de que funciona correctamente con el código PHP por escrito antes.

Lo que sigue es la clase de archivo completado SiteMonitorItem que se adjunta a la movieclip del mismo nombre:

package { import flash.display.MovieClip; import flash.net.*; import flash.events.*; import flash.text.TextField;

public class SiteMonitorItem extends MovieClip {

public var phpFile:String; public var siteURI:String;

private var stopCheck:Boolean = false;

private var failedAttempts:uint = 0;

private const MAX_ATTEMPTS:uint = 3;

public function SiteMonitorItem() { }

public function checkSite():void { var urlRequest:URLRequest = new URLRequest(siteURI); var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, siteResponsedHandler); urlLoader.addEventListener(IOErrorEvent.IO_ERROR, noResponse); urlLoader.load(urlRequest); }

private function noResponse(event:IOErrorEvent):void { attempts = attempts + 1; }

private function siteResponsedHandler(e:Event):void { failedAttempts = 0; }

private function stopChecking():void { stopCheck = true; }

public function get attempts():uint { return failedAttempts; }

352

public function set attempts(num:uint):void { if(num == undefined) { failedAttempts++; }else { failedAttempts = num; }

if(failedAttempts == MAX_ATTEMPTS) { statusMC.gotoAndStop(1); stopChecking(); } }

} }

Uso de Flash para construer un reproductor de video

Reproductores de vídeo, como el que se ilustra en la figura 13.5, son cada vez más popular como la Internet sigue para llegar más rápido. La idea detrás de esta sección es desarrollar un reproductor de vídeo que se interconecta con PHP para cargar en la lista de vídeos, así como el seguimiento de la obra cuenta.

Flash ya los buques con un muy versátil reproductor de vídeo por componentes, pero aún se puede ampliar, lo que es exactamente lo que esta sección le ayudará a alcanzar.

La aplicación está construida con un componente ComboBox VideoPlayer y que ya se ha colocado en el escenario. El archivo de inicio {START_FILE} se presta para que usted pueda centrarse en el desarrollo y rápidamente puede poner a prueba a medida que avanza.

353

FIGURA 13.5 Un reproductor de vídeo con un vídeo cargado y reproduciendo

NOTA Usted necesita un archivo de vídeo FLV a fin de probar esta aplicación. Uno se incluye con el material encontrado en el sitio Web del libro.

Muchas de las aplicaciones desarrolladas en Flash constará de unos ActionScript. La complejidad de la ActionScript se determinará sobre la base de lo que la aplicación será. En este ejemplo va a utilizar una clase externa para desarrollar el reproductor de vídeo.

La primera parte de la aplicación a desarrollar es el código ActionScript, que se divide en clases de una mayor escalabilidad. El ActionScript principal se adjuntará a la aplicación utilizando la clase de document.

354

Para empezar, examine la estructura de clase, que le dará una mejor idea de cómo la aplicación fluye.

package { public class VideoPlayer extends MovieClip { public function VideoPlayer(){} public function loadData():void {}

private function dataLoaded(e:Event):void {} private function comboHandler(e:Event):void {} } }

El método constructor de la clase de documento es responsable de asignar la instancia VideoPlayer. También es el punto donde se definen los detectores de eventos necesarios.

_player = this[‘player’]; this[‘videoListCombo’].addEventListener(Event.CHANGE, comboHandler);

La última parte del método constructor es llamar al método LoadData y recoger los datos XML.

loadData();

El método LoadData() es para cargar los datos de vídeo, que se devuelve en formato XML.

public function loadData():void { var urlVariables:URLVariables = new URLVariables; urlVariables.a = “getvideos”;

var urlRequest:URLRequest = new URLRequest(phpFile); urlRequest.data = urlVariables;

var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, dataLoaded); urlLoader.load(urlRequest); }

Aquí está una muestra de la respuesta XML, que tiene los atributos de población en lugar de los nodos.

<videos> <video name=”Sample Video 1” src=”color1.flv” playCount=”7” /> <video name=”Sample Video 2” src=”color2.flv” playCount=”3” /> <video name=”Sample Video 3” src=”color3.flv” playCount=”5” /> <video name=”Sample Video 4” src=”color4.flv” playCount=”4” /> <video name=”Sample Video 5” src=”color5.flv” playCount=”1” /> <video name=”Sample Video 6” src=”color6.flv” playCount=”2” /> </videos>

Después de los datos objeto XML se carga, una llamada a dataLoaded() se hace, que es responsable de llenar el ComboBox. Un bucle for..each se utiliza para analizar los datos de vídeo, que se añade al componente ComboBox.

355

this[‘videoListCombo’].addItem({label:’Choose Video...’, data:- 1}); for each(var item in xml..video) { var name:String = item..attribute(‘name’); var src:String = item..attribute(‘src’); this[‘videoListCombo’].addItem({label:name, data:src}); }

El último método de la clase de documento es un controlador de eventos para el componente ComboBox.

private function comboHandler(e:Event):void { if(e.target.selectedItem.data == -1) return; trace(“Load Video: “ + e.target.selectedItem.data); _player.source = ‘videos/’ + e.target.selectedItem.data; }

Este método controlador de eventos se utiliza para cargar el archivo de vídeo, pero sólo si se encuentra un valor de datos válidos. Una simple declaración de if (si) se utiliza para determinar si se selecciona la etiqueta.

if(e.target.selectedItem.data == -1) return;

Eso es todo lo que hay a esta clase. Esta es la clase de documento terminado:

package { import flash.display.MovieClip; import flash.events.*; import flash.net.URLVariables; import flash.net.URLRequest; import flash.net.URLLoader; import flash.media.Video; public class VideoPlayer extends MovieClip { public var phpFile:String = “http://localhost/ ch12/VideoPlayer/videoManager.php”;

private var _player:FLVPlayback;

public function VideoPlayer() { _player = this[‘player’]; this[‘videoListCombo’].addEventListener( Event.CHANGE, comboHandler); loadData(); }

public function loadData():void { var urlVariables:URLVariables = new URLVariables; urlVariables.a = “getvideos”;


356


private function dataLoaded(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

this[‘videoListCombo’].addItem({ label:’Choose Video...’, data:-1}); for each(var item in xml..video) { var name:String = item..attribute(‘name’); var src:String = item..attribute(‘src’);

this[‘videoListCombo’].addItem({ label:name, data:src}); } }

private function comboHandler(e:Event):void { if(e.target.selectedItem.data == -1) return; trace(“Load Video: “ + e.target.selectedItem.data); _player.source = ‘videos/’ + e.target.selectedItem.data; } } }

El siguiente paso es desarrollar el código PHP que se utiliza para devolver un objeto XML. Para este ejemplo, los datos de vídeo es un conjunto estático, pero que puede actualizar fácilmente para utilizar una base de datos MySQL similares a los ejemplos anteriores.

$videos = array( array(“Sample Video 1”, “color.flv”, 0), array(“Sample Video 2”, “color.flv”, 0), array(“Sample Video 3”, “color.flv”, 0), array(“Sample Video 4”, “color.flv”, 0), array(“Sample Video 5”, “color.flv”, 0), array(“Sample Video 6”, “color.flv”, 0) );

Este ejemplo sólo tiene una acción, que es recuperar la lista de vídeo y crear un objeto XML que se pasa de nuevo a Flash.

if($action == “getvideos”) { $xml = “<videos>”; for($i=0; $i < count($videos); $i++) { $xml .= “\t<video”; $xml .= “ name=\”” . $videos[$i][0] . “\””; $xml .= “ src=\”” . $videos[$i][1] . “\””;

357

$xml .= “ playCount=\”” . $videos[$i][2] . “\””; $xml .= “ />\n”; }$xml .= “</videos>”;

Después de que el objeto XML se crea, un tipo de encabezado de XML es emitida, el último paso es la salida el código XML real.

header(“Content-type: text/xml”); print $xml;

Eso es todo el código PHP que se necesita para desarrollar este programa de vídeo. Aquí está el PHP completado:

<?php

$action = (isset($_GET[‘a’])) ? $_GET[‘a’] : “”;

$videos = array( array(“Sample Video 1”, “color.flv”, 0), array(“Sample Video 2”, “color.flv”, 0), array(“Sample Video 3”, “color.flv”, 0), array(“Sample Video 4”, “color.flv”, 0), array(“Sample Video 5”, “color.flv”, 0), array(“Sample Video 6”, “color.flv”, 0) );

if($action == “getvideos”) { $xml = “<videos>”; for($i=0; $i < count($videos); $i++) { $xml .= “\t<video”; $xml .= “ name=\”” . $videos[$i][0] . “\””; $xml .= “ src=\”” . $videos[$i][1] . “\””; $xml .= “ playCount=\”” . $videos[$i][2] . “\””; $xml .= “ />\n”; }$xml .= “</videos>”;

header(“Content-type: text/xml”); print $xml; }

?>

Desarrollar una aplicación de encuesta

Una encuesta es una característica muy común de cualquier sitio Web, pero una persona con frecuencia utiliza un servicio que administra la encuesta en lugar de crear su propia cuenta. El principal problema con este enfoque es que sus datos están en algún otro servidor. Un problema menos común es la falta de libertad con el diseño de la aplicación de encuesta.

Creando el PHP y MySQL

358

Esta aplicación consiste en el diseño, el desarrollo de PHP y ActionScript para desarrollar una aplicación plena de votación funcionales, como la que se muestra en la Figura 13.6. El foco inicial está en el código SQL que almacena los datos de las encuestas.

FIGURA 13.6 Una aplicación de encuesta completa muestra algunos datos del ejemplo

Para ofrecer más de una encuesta, un número de identificación único asignado a cada respuesta que determina que la pregunta que se asocia con.

CREATE TABLE poll ( id INT NOT NULL DEFAULT 0, pollValue TEXT NOT NULL, pollType VARCHAR(20) DEFAULT “” NOT NULL, pollVotes INT(11) NOT NULL, active VARCHAR(1) DEFAULT 1 NOT NULL );

359

Este esquema de la tabla está poniendo las preguntas y respuestas en una tabla de la simplicidad. Sin embargo, en una aplicación más robusta que usted desea colocar las preguntas y respuestas en dos tablas separadas para una mejor escalabilidad. Esta es la manera de hacer una base de datos más eficiente.

Después de escribir el SQL, puede pasar a desarrollar el código PHP. Esta aplicación tiene dos acciones: la capacidad de obtener datos de las encuestas y votar. En una aplicación más avanzado que lo más probable es que tenga un editor y sistema de eliminación.

360

La acción y la encuesta de identificación son aprobadas por la dirección (URL), así que la primera parte del código es responsable de almacenar la información.

$action = (isset($_GET[‘a’])) ? $_GET[‘a’] : “”; $pollID = (isset($_GET[‘id’])) ? $_GET[‘id’] : “”;

El siguiente paso es cargar los datos de una encuesta de la base de datos mediante una instrucción SELECT simple.

$sql = “SELECT * FROM poll WHERE id=” . $pollID; $query = mysql_query($sql);

Cuando se carga los datos de SQL, se pasa en un bucle while que es responsable de la construcción de los datos XML. Una declaración de if se utiliza para determinar si un voto válido está disponible, si lo es, se añade el atributo XML.

$xml = “<poll id=\”” . $pollID . “\”>\n”;

while($row = mysql_fetch_array($query)) { $xml .= “\t<element”; $xml .= “ type=\”” . $row[‘pollType’] . “\””; $xml .= “ value=\”” . $row[‘pollValue’] . “\””;

if($row[‘pollType’] == “answer”) { $xml .= “ votes=\”” . $row[‘pollVotes’] . “\””; }

$xml .= “ />\n”;

La segunda acción consiste en emitir un voto mediante el ID de encuesta y el valor de la pregunta como una manera única de determinar el valor correcto a la encuesta de actualización.

else if($action == “vote”) { $votes = (isset($_GET[‘v’])) ? $_GET[‘v’] : “”; $question = (isset($_GET[‘q’])) ? $_GET[‘q’] : “”;

$votes = $votes + 1;

$sql = “UPDATE poll SET pollValue=” . $votes . “ WHERE id=” . $pollID . “ AND pollValue=” . $question; mysql_query($sql); }

El último paso del PHP es generar una cabecera XML y el objeto XML creado para el navegador, donde Flash, la cargará.


print $xml;

361

Aquí está el archivo PHP concluido que se utilizará en la aplicación de encuesta:

<?php

require ‘dbconn.php’;

$action = (isset($_GET[‘a’])) ? $_GET[‘a’] : “”; $pollID = (isset($_GET[‘id’])) ? $_GET[‘id’] : “”;

if($action == “getpolldata”) { $sql = “SELECT * FROM poll WHERE id=” . $pollID; $query = mysql_query($sql);

$xml = “<poll id=\”” . $pollID . “\”>\n”;

while($row = mysql_fetch_array($query)) { $xml .= “\t<element”; $xml .= “ type=\”” . $row[‘pollType’] . “\””; $xml .= “ value=\”” . $row[‘pollValue’] . “\””;

if($row[‘pollType’] == “answer”) { $xml .= “ votes=\”” . $row[‘pollVotes’] . “\””; }

$xml .= “ />\n”; }

$xml .= “</poll>”;


print $xml; }else if($action == “vote”) { $votes = (isset($_GET[‘v’])) ? $_GET[‘v’] : “”; $question = (isset($_GET[‘q’])) ? $_GET[‘q’] : “”;

$votes = $votes + 1;

$sql = “UPDATE poll SET pollValue=” . $votes . “ WHERE id=” . $pollID . “ AND pollValue=” . $question; mysql_query($sql); }

?>

Desarrollo de ActionScript para la encuesta

El código ActionScript para la aplicación de encuesta está dividida en dos partes. La primera pieza es una clase de documentos que controla la mayoría de la solicitud de votación. El segundo es un PollItem que se duplica por cada respuesta en la encuesta de carga.

362

Los datos que se cargan desde PHP se devuelve en formato XML. Aquí está una muestra de la respuesta:

<poll> <element type=”question” value=”What is your favorite color?” />

<element type=”answer” value=”Black” votes=”0” />

<element type=”answer” value=”Blue” votes=”0” />

<element type=”answer” value=”Orange” votes=”0” />

<element type=”answer” value=”Red” votes=”0” /> </poll>

La primera clase es a centrarse en la PollItem porque va a ser cargado por la clase de documento, y es el siguiente paso para trabajar en un orden lógico. Aquí está el esqueleto de clase para el PollItem:

package { public class PollItem extends MovieClip { public function PollItem() {} public function get data():Object {} public function setData(i:uint, a:String, v:uint):void {} } }

La primera parte de la clase son las variables, que en esta clase son el id, la respuesta, y el valor de la votación para cada elemento de encuesta ejemplo.

private var ID:uint; private var answer:String; private var votes:uint;

Esta clase en realidad sólo había dos métodos. El primer método es un captador que devuelve un objeto lleno con el tema de datos.

public function get data():Object { return {id:ID, answer:””, votes:votes}; }

El segundo método es responsable de asignar los datos a cada partida de la encuesta. Las variables almacenadas se ajustan a privados, lo que permite al desarrollador para controlar el acceso y mantenga consistente durante el proceso de aplicación.

public function setData(i:uint, a:String, v:uint):void { ID = i; answer = a; votes = v; }

363

Eso es todo lo que hay a la clase PollItem, que se muestra aquí completa:


public class PollItem extends MovieClip { private var ID:uint; private var answer:String; private var votes:uint; public function PollItem() {}

public function get data():Object { return {id:ID, answer:””, votes:votes}; }

public function setData(i:uint, a:String, v:uint):void { ID = i; answer = a; votes = v; } } }

La última clase es la clase de documentos, que se adjunta a la etapa de establecer el valor en el inspector de propiedades. Aquí está el esqueleto de la clase:

package { public class Poll extends MovieClip { public function Poll() {} public function loadPollData():void {} public function dataLoaded(e:Event):void {} } }

El primer método se llama desde el constructor y es responsable de cargar los datos de la encuesta en formato XML basado en la encuesta de identificación que se pasa en una petición GET.

public function loadPollData():void { var urlVariables:URLVariables = new URLVariables; urlVariables.a = “getpolldata”; urlVariables.id = POLL_ID;



364

Después de cargar los datos, una llamada al método dataLoaded() se hace, que se encarga de mostrar los datos de encuesta con las instancias PollItem.

La respuesta del servidor se envía en formato XML, que se analiza y se utiliza para construir la encuesta de gráficos. Cada elemento de los datos de la encuesta se almacena como un atributo en lugar de un nodo en un intento de mantener el código de peso ligero.

var type:String = item..attribute(‘type’); var value:String = item..attribute(‘value’); var total:uint = uint(xml..attribute(‘total’));

La variable de type (tipo) se utiliza para determinar si un elemento es una pregunta o una respuesta.

if(type == “question”) { this[‘questionTxt’].text = value; continue; }

if(type == “answer”) { var votes:uint = uint(item..attribute(‘votes’)); }

Las tiendas pollItem variable de la instancia de la clase PollItem, que contiene los gráficos para cada elemento de la encuesta. El porcentaje se determinará con un poco de matemáticas muy básicas, que se divide el recuento de votos por el total y que se multiplica por 100 para generar un porcentaje.

var pollItem:PollItem = new PollItem(); pollItem[‘percentTxt’].text = Math.round(votes / total * 100) + “%”; pollItem[‘barMC’].width = (votes / total * 100) * 4;

El último paso en el método es para la alineación de cada pollItem, adjuntando el pollItem a la lista de visualización, y, finalmente, añadiendo a la matriz pollItems.

pollItem.y = (pollItems.length * (pollItem.height + 20));

container.addChild(pollItem); pollItems.push(pollItem);

En este punto, la clase de documento está construido, y se muestra en su totalidad aquí:

package { import flash.display.MovieClip; import flash.events.*; import flash.net.URLVariables; import flash.net.URLRequest; import flash.net.URLLoader; import flash.text.TextField;

public class Poll extends MovieClip { public var POLL_ID:uint = 1;

365

public var phpFile:String = “http://localhost/ch12/Poll/poll.php”;

public var container:MovieClip; public var pollItems:Array;

public function Poll() { pollItems = new Array(); container = new MovieClip(); container.x = 15; container.y = 100;

addChild(container);

loadPollData(); }

public function loadPollData():void { var urlVariables:URLVariables = new URLVariables; urlVariables.a = “getpolldata”; urlVariables.id = POLL_ID;



public function dataLoaded(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var xml:XML = new XML(urlLoader.data);

for each(var item in xml..element) { var type:String = item..attribute(‘type’); var value:String = item..attribute(‘value’); var total:uint = uint(xml..attribute(‘total’));

if(type == “question”) { this[‘questionTxt’].text = value; continue; }

if(type == “answer”) { var votes:uint = uint(item..attribute(‘votes’)); }

var pollItem:PollItem = new PollItem(); pollItem[‘percentTxt’].text =

366

Math.round(votes / total * 100) + “%”; pollItem[‘barMC’].width = (votes / total * 100) * 4;

pollItem.y = (pollItems.length * (pollItem.height + 20));

container.addChild(pollItem); pollItems.push(pollItem); } } } }

Construir un simple editor de archivosEn este punto usted ha visto una amplia selección de aplicaciones del mundo real, pero todavía hay uno que no se ha hablado. Eso, por supuesto, sería un sistema de gestión de contenidos. Un sistema completo de gestión de contenido sería un proyecto masivo, pero esta sección se centra en un aspecto de la aplicación.

El editor de archivo, que se utiliza para añadir y editar los archivos, es una pieza fundamental para cualquier sistema de gestión de contenido. Es probable que en algún momento el administrador va a necesitar actualizaciones realizadas. En lugar de descargar el material de origen, es mucho más eficiente de utilizar un editor de archivos dinámico.

La aplicación de esta sección es sólo eso: un editor de archivos dinámico que está conectado a PHP para que realmente salvar y cargar los archivos. Normalmente usted puede utilizar el flash para cargar los archivos, pero PHP ofrece la posibilidad de cargar los archivos que no se almacenan en la raíz Web. Esta es una buena idea para los archivos de plantilla, porque no tienen que acceder directamente por un huésped.

El diseño del editor de archivos es un área de texto básicos, el botón Enviar, TextField y ComboBox.Nada de emocionante para diseñar el editor de archivos, en cambio, la verdadera sustancia de la solicitud se encuentra dentro del código ActionScript y PHP.

Comenzando con el código PHP le permite probar la parte de Flash a medida que comienza a desarrollarlo. El PHP es realmente muy simple para este ejemplo. Primero, comprobar que un archivo es válido, porque si usted va guardar o cargar, se necesita un archivo válido.

if(!empty($_GET[‘file’])) { $file = ‘./files/’ . $_GET[‘file’]; ... }

Después de determinar que es un archivo válido, el siguiente paso es comprobar si la acción está en blanco. Si la acción está en blanco, el código cargará automáticamente la acción, si la acción contiene un valor que se compara mediante una declaración if comunicado interno.

if($_GET[‘action’] == ‘save’) { ... }

367

else { ... }

Este ejemplo sólo permite cargar y guardar los archivos. En una aplicación más robusta que lo más probable es que desee tener una acción de eliminar o moverla.

La acción de guardar es responsable de cargar el archivo solicitado, reemplazando el texto actual, y, finalmente, volver a guardar el archivo. Es importante señalar que el ejemplo es con vistas a una pieza fundamental para cualquier aplicación en el mundo real, que es escapar de los datos que se envían desde Flash. Usted también puede agregar una clave de acceso de código de forma arbitraria no puede ejecutarse en el navegador a través de una petición GET.

La variable $fileContents recupera desde el principio los datos enviados por Flash.

$fileContents = $_GET[‘fileContents’];

El archivo se carga mediante la función fopen con acceso de escritura a sobrescribir. Esto significa que el contenido original se elimina y sólo la nueva versión se guarda.

$handle = fopen($file, ‘w+’);

Una vez que el archivo se carga, una llamada a fwrite () se hace, que en realidad escribe el contenido en el archivo y guarda el archivo. El último paso de la acción de guadar es cerrar el archivo de recursos y liberar la memoria.

fwrite($handle, $fileContents); fclose($handle);

La carga de un archivo es mucho más fácil. Básicamente, se hace referencia en el archivo y cargar el contenido mediante file_get_contents(), que devuelve todo el archivo como una cadena, como se muestra en la Figura 13.7.

$loadedFile = file_get_contents($file); print “fileContents=” . $loadedFile;

Aquí está el archivo PHP completo, que debe ser guardado con el nombre fileManager.php:

<?php

error_reporting(0);

if(!empty($_GET[‘file’])) { $file = ‘./files/’ . $_GET[‘file’]; if($_GET[‘action’] == ‘save’) { $fileContents = $_GET[‘fileContents’];

$handle = fopen($file, ‘w+’); fwrite($handle, $fileContents); fclose($handle); }else

368

{ $loadedFile = file_get_contents($file); print “fileContents=” . $loadedFile; } }

?>

El siguiente paso es desarrollar el código ActionScript. La parte de diseño ha sido creado previamente para poder mover directo al código.

El primer paso es definir las variables utilizadas para este ejemplo.

varphpFile:String=”http://localhost/ch12/FileEditor/fileEditor.ph p”; var files:Array = [‘sample.txt’, ‘anotherfile.txt’, ‘readme.txt’]; var storedFileData:String;

FIGURA 13.7 El contenido del archivo en bruto pasó de PHP como se ve desde un navegador Web

369

Una vez definidas las variables, puede pasar a las funciones. La primera función es responsable de llenar la lista de archivos cuadro combinado.

function populateFileList():void {... }

El método AddItem del cuadro combinado (comb box) acepta un objeto como argumento, que define los datos de la etiqueta y los datos. Para esta aplicación, el fichero se utiliza tanto para la etiqueta y el valor de los datos.

for(var i:uint=0; i < files.length; i++) { fileListCombo.addItem({label:files[i], data:files[i]}); }

El método loadFile se llama cuando se hace clic en el loadbtn. Este controlador crea un archivo de solicitud con una variable de archivo que PHP utiliza para cargar el archivo real.

function loadFile(e:MouseEvent):void { var variables:URLVariables = new URLVariables(); variables.file = fileListCombo.selectedItem.data;


var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, fileLoaded); urlLoader.load(urlRequest); }

Después de que el archivo solicitado se carga y se devuelve el contenido de PHP, es enviado en el área de texto bodyTxt y también a la variable storedFileData. Esta variable se utiliza para almacenar en caché los resultados sin modificar. Puede volver a estos resultados más adelante haciendo clic en el botón Restablecer.

function fileLoaded(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(urlLoader.data);

bodyTxt.text = unescape(variables.fileContents); storedFileData = bodyTxt.text; }

El método de restablecimiento simplemente reemplaza el contenido del cuerpo con los datos modificados que se almacena en el archivo original se carga.

function resetHandler(e:MouseEvent):void { bodyTxt.text = storedFileData; }

El último método necesario en esta aplicación es responsable de guardar el contenido editado. Antes de que se guardan los datos, se almacena en caché, lo que elimina la necesidad de volver a cargar los datos.

370

function saveHandler(e:MouseEvent):void { var body:String = bodyTxt.text; storedFileData = body; ... }

Las variables pasadas al PHP definir la acción, el nombre del archivo, y el contenido de primas que reemplazará el archivo de datos existente. El nombre del archivo es obtenida del ComboBox acceso al objeto de selectedItem.

var variables:URLVariables = new URLVariables(); variables.file = fileListCombo.selectedItem.data; variables.action = “save”; variables.fileContents = body;

Esta URLRequest particular, no requiere de un detector de eventos porque el proceso de guardar que pasa por su propia cuenta y se completa una vez que PHP recibe todos los fileContents.

NOTA En una aplicación remota es una buena idea para notificar al usuario del proceso de ahorro, ya que un archivo grande puede tomar tiempo para salvar.


var urlLoader:URLLoader = new URLLoader(); urlLoader.load(urlRequest);

La última tarea del ActionScript es el registro de los eventos de los botones y hacer una llamada a la función populateFileList() para el archivo de perfil ComboBox.

// Register Events loadFileBtn.addEventListener(MouseEvent.CLICK, loadFile); saveBtn.addEventListener(MouseEvent.CLICK, saveHandler); resetBtn.addEventListener(MouseEvent.CLICK, resetHandler); populateFileList();

371

FIGURA 13.8 El editor de archivos completada con una muestra de archivo cargado

La aplicación, como se muestra en la figura 13.8, se ha efectuado. El siguiente es el código fuente de ActionScript completo:

Var

phpFile:String=”http://localhost/ch12/FileEditor/fileEditor.ph p”; var files:Array = [‘sample.txt’, ‘anotherfile.txt’, ‘readme.txt’]; var storedFileData:String;

function populateFileList():void { for(var i:uint=0; i < files.length; i++) { fileListCombo.addItem({label:files[i], data:files[i]}); } }

372

function loadFile(e:MouseEvent):void { var variables:URLVariables = new URLVariables(); variables.file = fileListCombo.selectedItem.data;


var urlLoader:URLLoader = new URLLoader(); urlLoader.addEventListener(Event.COMPLETE, fileLoaded); urlLoader.load(urlRequest); }

function fileLoaded(e:Event):void { var urlLoader:URLLoader = URLLoader(e.target); var variables:URLVariables = new URLVariables(urlLoader.data);

bodyTxt.text = unescape(variables.fileContents); storedFileData = bodyTxt.text; }

function resetHandler(e:MouseEvent):void { bodyTxt.text = storedFileData; }

function saveHandler(e:MouseEvent):void { var body:String = bodyTxt.text; storedFileData = body;

var variables:URLVariables = new URLVariables(); variables.file = fileListCombo.selectedItem.data; variables.action = “save”; variables.fileContents = body;


var urlLoader:URLLoader = new URLLoader(); urlLoader.load(urlRequest); }

// Register Events loadFileBtn.addEventListener(MouseEvent.CLICK, loadFile); saveBtn.addEventListener(MouseEvent.CLICK, saveHandler); resetBtn.addEventListener(MouseEvent.CLICK, resetHandler);

populateFileList();

373

Resumen

En este capítulo usted aprendió cómo desarrollar avanzadas aplicaciones del mundo real, tales como la utilización de Flash y PHP para construir un editor de archivos, reproductor de vídeo y monitor de sitio.

Si bien el desarrollo del sitio monitor que aprendieron los nuevos eventos que hacen que sea más fácil trabajar con datos incorrectos, así como la vinculación de PHP, MySQL y Flash juntos. La aplicación se ha mejorado mediante la adición de acciones personalizadas, tales como el proceso de e-mail al administrador cuando un sitio no responde.

En la aplicación de votación aprendió a desarrollar una aplicación completa usando Flash como medio de visualización. La solicitud general fue escrito para ser muy escalable y, de hecho, cambiar la variable de ID en la clase de documento se carga una pregunta de la encuesta totalmente diferente (siempre existe uno).

En este punto, usted debe entender completamente la forma de desarrollar aplicaciones del mundo real que son fáciles de actualizar y mantener. De hecho, la mayoría de este capítulo pueden sumarse para crear un sistema de gestión o basadas en otro módulo de aplicaciones.

374

Capitulo 14

Depurar AplicacionesCuando se construye una aplicación, es casi seguro que algún elemento que deje de funcionar o tal vez nunca trabajo desde el principio. Esto puede ser un punto en cualquier momento el bono de un ciclo de desarrollo puede tener que desaparecer. La idea es crear su aplicación con la depuración en la mente. La adición de comentarios en realidad puede acelerar la depuración de la línea.

Por supuesto, añadiendo a medida que avanza la depuración es similar a escribir un esquema. Piensa en ello como te das cuenta de que es demasiado tarde. La clave es no dejar que un proyecto de llegar a este punto. Este capítulo se centra en la mejor forma de depurar aplicaciones.Se empieza por las herramientas integradas y luego progresar y algunas aplicaciones externas y prácticas que hacen que sea menos dolorosa.

Uso de informes de errors en PHP

Empecemos con mirar a la depuración de una aplicación PHP. De forma predeterminada, la depuración habilitada de buques PHP con un cierto nivel. Es creado para informar de los errores fatales (accidentes de programa) y las advertencias (archivos que faltan y argumentos). Este nivel de informe de errores está bien para un servidor de desarrollo, pero un gran problema con la instalación por defecto es que los errores se imprimen en la pantalla y cada usuario puede ver.

La alternativa y la opción más segura es permitir el registro de errores en un registro de error de archivo similar a cómo se configura Apache. Habilitar el registro de errores se realiza editando el archivo php.ini. Si usted no tiene acceso de administrador de su servidor, usted necesita ponerse en contacto con alguien que tiene este acceso. El archivo php.ini se encuentra normalmente en el directorio /etc/ en UNIX y C:\WINDOWS\, que es generalmente sólo accesible por el administrador del servidor.

El archivo php.ini se almacena en varios lugares dependiendo de la configuración del servidor. Sin embargo, lo bueno es que PHP puede indicar dónde está almacenado. Basta con crear un nuevo archivo, el nombre de info.php, y agregar el siguiente código:

<?php phpinfo(); ?>

Al ejecutar este archivo en un explorador que se presentan con una gran cantidad de información específica de su versión actual de PHP. Uno de los primeros bloques de información es el camino ini, que se ve algo como esto:

Configuration File (php.ini) Path /usr/local/php5/lib/php.ini

PRECAUCIÓN Modificación incorrecta del archivo php.ini puede resultar en su servidor no funciona. Tenga cuidado al editar este archivo.

375

Después de éxito encontrar el archivo php.ini, y abrirlo en el editor de texto favorito o usar vi si está utilizando la línea de comandos. Usando vi, un comando para abrir un archivo, se ve así:

vi /usr/local/php5/lib/php.ini

Con el archivo abierto, desplazarse a través hasta llegar a una sección que se parece a este:

; Log errors to specified file. ;error_log = filename

Las líneas que comienzan con ; (punto y coma) son comentarios en los archivos ini. Como puede ver, el error_log no está definido y por lo tanto no es salvar a cualquier archivo. El método para activar esta opción es quitar el punto y coma (;) y reemplazar el nombre de archivo con una ruta y el nombre real del archivo, tales como

error_log = /usr/local/debug/php_errors

Después de realizar los cambios y guardar el archivo php.ini, es necesario reiniciar el servidor Web para permitir a PHP para leer el archivo ino. Esto es necesario porque el PHP sólo lee el archivo ini(s) en el inicio para maximizar el rendimiento.

Después de empezar a generar errores del archivo de registro comienza a llenarse. Si usted lee el archivo de registro que debe ver cadenas como la siguiente. Muy probablemente, los errores que usted recibe en realidad le dirá lo que está mal, debido a un error que proporciona información incorrecta no es realmente tan útil.

[18-Jul-2007 20:51:17] PHP Fatal error: file.php on line 30 [09-Aug-2007 21:23:37] PHP Fatal error: file.php on line 13 [03-Nov-2007 23:10:21] PHP Fatal error: file.php on line 56 ...

Un servidor de producción sólo debería registrar los errores, lo que significa que los errores también se debe dar salida con discapacidad en el archivo php.ini. Abra el archivo ini y cambiar el valor a Off output_errors y reiniciar Apache de nuevo.

display_errors = Off

Mostrando los errors para depurar

Con el servidor de registro de errores de forma segura sin mostrar a los usuarios en general, se puede ver lo que los informes de errores en PHP ofrece el promotor. Desde el punto de vista de la depuración, el informe de errores en PHP es muy robusto. Ahí están los errores estándar, tales como errores fatales, los archivos que faltan, advertencias, etc. Aún más importante es la capacidad de crear su propio error.

Con el fin de crear un error personalizado, simplemente llame a trigger_error (), que toma dos argumentos. El primer argumento es la cadena de error para mostrar y el segundo (opcional) El argumento es lo que el nivel de error de error debe ser reportado como. Esta es una llamada trigger_error simple:

trigger_error(“Cannot load non-existent user data”, E_USER_WARNING);

376

Depurar variables

El código de depuración no es siempre acerca de los errores de sintaxis, de hecho, la mayoría de veces no lo es. A menudo se encuentra una variable fuera de alcance o no inicializado, lo que no se producirá un error. Por supuesto, PHP tiene muchas funciones y los métodos que se adapten a la depuración.

Posiblemente se haya impreso o echo antes, pero créanlo o no las funciones son realmente muy útil para depurar una aplicación. Básicamente, usted puede rastrear las variables y tener una mejor idea de cómo está funcionando un programa.

Depurar arrays

Trabajar con una matriz es un poco diferente porque una impresión simple mostrará Array. Sin embargo, puede utilizar la función print_r() para ver una matriz. Incluso se mostrará una matriz dentro de una matriz y así sucesivamente, también conocida como una matriz multidimensional. Aquí es el resultado del ejemplo muestra de la llamada print_r:

Array ( [0] => Array ( [one] => 1 )

[1] => Array ( [two] => 2 ) )

Entender los niveles de error

Si bien usando trigger_error puede observar que el segundo parámetro es una constante. Esta constante se define un nivel de error determinado. PHP ofrece una amplia gama de niveles de error e incluso permite a los desarrolladores para cambiar el nivel como el código avanza.

Aquí es cómo el cambio de manera pragmática el nivel de error, en este caso, haciendo que incluso se informó sobre esto AVISOS:

error_reporting(E_ALL);

Tabla 14.1 muestra los niveles de error y una descripción del nivel de lo que el error se refiere.

TABLE 14.1 Niveles de Error y Descripciones

Error Descripción .E_ERROR Errores fatales en tiempo de ejecución. Estos indican errores que no pueden recuperarse, tales como un problema de asignación de memoria. La ejecución del script se detiene. E_WARNING Advertencias Tiempo de ejecución (errores no fatales). La ejecución del script no se detiene. E_PARSE Errores de compilación analizar el tiempo. Errores de análisis sólo debe ser generada por el analizador. E_NOTICE Anuncios de Tiempo de ejecución. Indica que el guión ha topado con algo que podría indicar un

377

error, pero también podría ocurrir en el curso normal de ejecución de un script. E_CORE_ERROR Errores fatales que ocurren durante el arranque inicial de PHP. Esto es como un E_ERROR, excepto que es generado por el núcleo de PHP. E_CORE_WARNING Advertencias o errores no fatales que ocurren durante el arranque inicial de PHP. Esto es como un E_WARNING, excepto que es generado por el núcleo de PHP. E_COMPILE_ERROR Fatal errores de compilación. Esto es como un E_ERROR, excepto que es generado por el Motor de Scripting de Zend. E_COMPILE_WARNING Advertencias en tiempo de compilación o errores no fatales. Esto es como un E_WARNING, excepto que es generado por el Motor de Scripting de Zend. E_USER_ERROR Mensaje de error generado por el usuario. Esto es como un E_ERROR, excepto que es generado desde código PHP usando la función trigger_error(). E_USER_WARNING Generado por el usuario mensaje de advertencia. Esto es como un E_WARNING, excepto que es generado desde código PHP usando la función trigger_error(). E_USER_NOTICE Generada por el usuario previo aviso. Esto es como un E_NOTICE, excepto que es generado desde código PHP usando la función trigger_error(). E_STRICT Anuncios de Tiempo de ejecución. Habilitar para que PHP sugiera cambios en su código que velarán por la mejor interoperabilidad y por mantener la compatibilidad de su código. E_ALL Todos los errores y advertencias, como el apoyo, excepto por el nivel E_STRICT en PHP < 6.

Como puede ver, PHP ofrece un montón de opciones de depuración dar salida más allá de la básica y la explotación forestal. De hecho, usted puede personalizar un montón de errores que se encuentran en el archivo php.ini para depurar las aplicaciones más diversas.

Si usted desea conseguir un nivel grave de depuración de código y herramientas de observación, entonces puede que desee echar un vistazo a Zend Studio IDE (ver figura 14.1), construido en la cima de la infraestructura Eclipse. Esta aplicación no es gratuito, sin embargo, es el editor de PHP más robusto y un depurador de perfil en el mercado en el momento de escribir este artículo. Una licencia de Zend Studio para rangos de $150 a $300 dependiendo de la versión que usted compra.

NOTA Zend Studio no es el único editor de PHP, sin embargo tiene el depurador más robusto.Además puede utilizar PHPEclipse que tiene características similares a Zend. Sin embargo, el proceso de instalación es un poco más complicado.

378

FIGURA 14.1 El IDE de Zend Studio con los paneles de depuración visible

379

Depurar en Flash

Similar a PHP, Flash ofrece una serie de herramientas muy útiles para la depuración. De hecho, el IDE de Flash tiene un sistema de depuración completo construido en el derecho en el que puede inspeccionar su código (véase la figura 14.2), se aplican puntos de interrupción, y la actividad en torno a un bloque de código para ver los detalles y encontrar un error. FIGURA 14.2 Aquí está el panel que se utiliza para inspeccionar una aplicación.

Flash también tiene un panel de salida (ver figura 14.3) que se utiliza para ver declaraciones trace() los estados llamados desde el código. La sentencia trace es una función básica que acepta una cadena como un argumento. Esto se envía al panel de la producción y ofrece la posibilidad de mostrar los elementos de una aplicación, que se está ejecutando.

trace(“Here is a very basic debug message”);

Una pregunta común con el uso de las instrucciones de seguimiento es la voluntad que siguen a la producción de una película compilado? Lo harán, pero usted puede seleccionar la opción "Omitir acciones de seguimiento" en el cuadro de diálogo Configuración de publicación para deshabilitarlo.

380

El simple método trace (seguimiento) puede ser útil cuando se depuren los ejemplos de código de base. Sin embargo, para las aplicaciones más completa, lo más probable es que quiera construir su propio gestor de depuración. Esto se puede hacer de forma bastante sencilla.

FIGURA 14.3 Este es un ejemplo del panel de salida como se ve en Flash.

En primer lugar, crear un componente de TextArea en el escenario con el nombre de instancia debugTxt. Luego, crear una nueva función de seguimiento que llenarán de que TextArea. Utilizando el método appendText agregará en el texto existente, en lugar de eliminarlo.

function tracer(debug:String):void { debugTxt.text.appendText(debug); }

También podría crear una clase personalizada que cualquier porción de su código es capaz de llamar. Sin embargo, encontrará rápidamente que el nivel de seguimiento no es perfecto. Por ejemplo, no de manera pragmática puede borrar la pantalla o de la prioridad lugar en ciertos eventos.

De hecho, la depuración en Flash no es tan avanzada como las posibilidades en PHP, pero todavía hace el trabajo.

381

En este punto, usted ha visto cómo Flash se puede utilizar para depurar una aplicación y cómo PHP puede ser usado para la misma tarea. Ahora mira algunas opciones de terceros y las bibliotecas para que este proceso sea aún más fácil.La mayoría de los datos que se pasa de ida y vuelta en Flash es hecho utilizando las llamadas remotas, también conocido como Remoting o Flash Remoting. Este método de intercambio de datos se ha vuelto bastante popular, pero no se presta a que se está depurando o visto. Parte de esto es debido al hecho de un objeto es autónomo y también el modo Flash interactúa con un origen remoto.

Utilizando una herramienta de terceros llamado Charles o Charles Web Debugging Proxy, que se puede descargar desde http://xk72.com/charles/, hace que sea muy fácil de ver estos datos a medida que pasa alrededor. Carlos no es freeware, pero ofrece una demostración completa. En el momento de escribir este documento, una licencia es de $50. Para mí, vale la pena.

Figuras 14.4 y 14.5 muestran datos remotos y cómo se ve a Carlos.

FIGURA 14.4 Esta es la solicitud que se envía al servicio remoto.

382

FIGURA 14.5 Esta es la interfaz de Charles normalizado en la que una respuesta XML de un sistema remoto.

Otra gran herramienta es un plug-in para el navegador web Firefox llamada LiveHTTPHeaders que vigila el tráfico de red. La desventaja parcial a esta aplicación es que sólo los relojes de tráfico del explorador. Si está probando o la depuración de la aplicación a nivel local no va a ver las llamadas.

Más información acerca de LiveHTTPHeaders se puede encontrar en http://livehttpheaders.mozdev.org/.

Uso alternativo de Trace

El último tema en este capítulo será la construcción de una nueva traza que permite a los colores, así como otras características. Este trazado alternativo se construye como un stand-alone SWF y puede ser llamado por cualquier otro SWF en el mismo dominio (local es su equipo). El código de seguimiento de esta alternativa se basa en la clase LocalConnection, que es una clase de pre-compilados que permite a varias películas en las comunicaciones de compartir el tiempo que están en el mismo dominio. La primera parte del código es responsable de construir el objeto de conexión local y el registro de la función de devolución de llamada.

var receivingLC:LocalConnection = new LocalConnection(); receivingLC.client = this;

383

function debug(str:String, level:String):void { var debugLevel:String = ((typeof(level) == ‘undefined’) ? ‘NORMAL’ : level); var color:String = null;

switch(debugLevel) { case ‘NORMAL’: color = ‘#000000’; break; case ‘ERROR’: color = ‘#E60000’; break; case ‘NOTE’: color = ‘#77C0FD’; break; case ‘WARNING’: color = ‘#FBF400’; break; case ‘RESPONSE’: color = ‘#27C201’; break; case ‘REGISTER’: color = ‘#FC8AFF’; break; case ‘CLASS’: color = ‘#FD779F’; break; case ‘ATTENTION’: color = ‘#FF6600’; break; case ‘URGENT’: color = ‘#FF0000’; break; case ‘STATUS’: color = ‘#CCFF00’; break; }

if(color == null) { color = ‘#000000’; }

debugTxt.htmlText += (“<font color=\”” + color + “\”>” + str + “</font>” + “\n”);

var scrollPos:uint = debugTxt.verticalScrollPosition var maxScroll:uint = debugTxt.maxVerticalScrollPosition; if(scrollPos + 5 > maxScroll) { debugTxt.verticalScrollPosition = maxScroll; //debugTxt.scroll = max_scroll; }

};

384

Después de la devolución de llamada y el objeto de conexión local están construidas, es el momento para iniciar la conexión. Esto se hace mediante una llamada al método connect() de la instancia local objeto de conexión.

receivingLC.connect(“remoteDebug”);

El resto del código es exclusivamente para la visualización de la ventana de depuración y no es necesario para los propósitos de la funcionalidad.

function clearHandler(e:MouseEvent):void { debugTxt.htmlText = “”; }

clearBtn.addEventListener(MouseEvent.CLICK, clearHandler);

// Resize Code stage.scaleMode = StageScaleMode.NO_SCALE; stage.align = StageAlign.TOP_LEFT; stage.addEventListener(Event.RESIZE, function():void { debugTxt.width = stage.stageWidth - 25; debugTxt.height = stage.stageHeight - 75; clearBtn.x = (stage.stageWidth - 12) - clearBtn.width; clearBtn.y = (stage.stageHeight - 12) - clearBtn.height; });

Eso es todo el código necesario para crear una traza alternativa, y usarlo requiere muy poco código. La llamada al seguimiento personalizado parece un poco a esto. El método send() requiere cuatro argumentos, que son los siguientes. El primero es el objeto de conexión local, el segundo es el método al que llamar, la tercera es la cadena de rastrear, y el cuarto es el nivel de error.

var sendingLC:LocalConnection = new LocalConnection(); sendingLC.send(“remoteDebug”, “debug”, “Object Not Found!”, “ERROR”);

Resumen

Ahora debe tener un conocimiento bastante sólido de las herramientas y prácticas disponibles para depurar correctamente sus aplicaciones en Flash y PHP. Estas no son las únicas herramientas y prácticas disponibles para depurar una aplicación. Los desarrolladores están subiendo con mejores maneras todo el tiempo, en parte porque es una tarea importante y también porque es el más temido en el ciclo de desarrollo.

En este capítulo usted aprendió a crear sus propios errores personalizados y cómo trabajar con los tipos de error estándar que se encuentran en PHP. También ha aprendido a depurar el código dentro de Flash utilizando el panel de salida y las instrucciones de seguimiento.

La última sección del capítulo se centró en el desarrollo de un controlador personalizado de depuración en ActionScript, que muestra los mensajes en un código de color scrollbox para identificar mejor sus mensajes de depuración.

385

Parte V

Mantenimiento del Servidor, Aplicación, y

de la base de datos

386

Capitulo 15Mantenimiento de una

aplicaciónEl proceso de mantenimiento de una aplicación se logra simplemente siguiendo algunas reglas. Estas normas se han establecido a través del tiempo como las aplicaciones siguen desarrollándose a diario.

Este capítulo se centra en estas reglas individuales. Al final del capítulo, usted comprenderá no sólo la manera de seguir, pero también cómo pueden hacer su trabajo más fácil.

La última sección se centra en trabajar en un entorno de equipo, utilizando la nota común que, comentando, y control de versiones desde la perspectiva de un único promotor. Incluso después de que se escribe una aplicación, no es raro que volver y hacer cambios. Si este plan durante el proceso de la escritura original y seguir algunos pasos simples, hace que las actualizaciones mucho más fácil de administrar y ejecutar avanzar.

A menudo, un intento de reescribir se hace en lugar de corregir algunos problemas leves. Esto generalmente se debe a la mala planificación en el inicio y los resultados en el tiempo de desarrollo adicional que no siempre pueden explicarse.

Comentando código

Código de comentar que es más importante como un proyecto sigue creciendo, o como los desarrolladores adicionales se introducen en el proyecto. El proceso de comentar el código no es una parte necesaria de una aplicación por escrito, pero es útil cuando se busca en un proyecto que ha estado en desarrollo durante algún tiempo.

A menudo el estilo de los comentarios es bien definido en un perfil del proyecto o establecidos por el líder del proyecto.

Comentando incluso puede ser beneficioso al escribir el código que usted posee, ya que pueden dejar notas a volver a un pedazo de código en una fecha posterior. Esto es especialmente importante si alguna vez la intención de distribuir el código como un proyecto de código abierto o vender la aplicación.

Comentando el código también hace que sea más fácil escribir o generar la documentación con la modificación adicional escaso o nulo que necesita el desarrollador.

Entender los estilos para comentar código

Cada lenguaje tiene su propio estilo de comentar código. Por ejemplo, una forma muy común de los comentarios es visto en los documentos HTML, que se parece a este:

387



HTML sólo ofrece un estilo de comentar, en otros lenguajes de scripting completa tienen distintos estilos de comentar. Éstos son algunos ejemplos de los estilos de comentarios más comunes que se encuentran en Flash, PHP y MySQL.

Bloque de comentarios

PHP, ActionScript (Flash), y MySQL permite comentarios en bloque.

/* ** This is a block style comment, * which can have any number of lines. **/

Comentarios en línea en MySQL

MySQL permite comentarios en línea usando un -- al comienzo de una línea.

-- This is a MySQL comment; the database will not read this.

Comentarios en lineas

También puede usar un comentario en línea para extraer una determinada sección de código. Esto le permite probar rápidamente una sección de código y localizar errores más rápidamente. Aquí hay un comentario en línea que elimina la cláusula de la sección WHERE de una consulta SQL.

SELECT name, status FROM users/* WHERE id=1004 AND status=’active’*/;

Los resultados de un comentario anterior en la consulta se mostrarán todos los usuarios en la base de datos porque la parte condicional se ha comentado.

NOTA Línea con formato incorrecto y comentarios en línea puede crear en ocasiones difíciles de rastrear los errores a menos que su editor de código se utiliza color resaltado de sintaxis.

Comentarios del compilador

Algunos lenguajes de desarrollo y aplicaciones use los comentarios del compilador. Estos comentarios especializados de decirle a un compilador de aplicaciones de cómo manejar ciertos tipos de datos. Estos comentarios no deben ser removidos manualmente a menos que la intención de eliminar esa funcionalidad.

Comentarios en XML

Algunas de las diversas aplicaciones que se han desarrollado en anteriores capítulos de acuerdo con XML. Es importante darse cuenta de que XML puede actuar de una forma desconocida cuando los comentarios son utilizados indebidamente.

Esto sólo se convierte en un problema cuando un -- se utiliza dentro de un comentario como el siguiente:

388

 <person> <name>Alex</name> <age>27</age> <gender>Male</gender> </person>

Como puede ver, la -- imita la etiqueta de cierre y confundir al analizador XML hasta el punto donde se cree que el XML está mal formado y en algunos casos raros no lo cargará.

Comentarios en Apache

El uso de comentarios en el Apache se limita generalmente a los archivos .htaccess para determinar la configuración del sitio.Es importante tener en cuenta que los comentarios en los archivos de Apache puede causar problemas de renderizado. Si por alguna razón una directiva no está funcionando correctamente, vea los comentarios como el primer culpable de la cuestión.

Aquí hay un ejemplo de un comentario en un archivo .htaccess de.

# Force PHP to render .html files AddType application/x-httpd-php .html .htm

Mezcla de comentarios

Se pueden mezclar varios estilos de comentarios cuando sea necesario. Esto es común a la hora de explicar una sección de código, como una función o definición del método. Como se puede ver, un comentario de bloque se utiliza para describir la función y un comentario de línea explica el código de la función.

/*

@num1: first number @num2: second number @return: sum of two arguments @author: developer’s name @description: static function that multiplies two numbers

*/ static function multiplyBy(num1:Number, num2:Number):Number { // return the sum of num1 & num2 return (num1 * num2); }

Comentar correctamente el código puede tener ventajas evidentes. Más editores de código populares ofrecen características que se pueden ocultar o colapso comentarios por lo que sólo están en el camino cuando se quiere que sean.

Es posible incluso encontrar algunos editores que la sintaxis de comentarios sea resaltado. Algunos editores profesionales utilizan la información para crear archivos de ayuda en línea llamado sugerencias de código (ver figura 15.1).

389

Estas sugerencias son las cajas en línea de código que aparecen a medida que comienza a escribir. Ellos proporcionan los elementos disponibles posibles basadas en el código introducido hasta el momento.

Un editor de ActionScript más avanzado, como FDT por Powerflasher, tiene la capacidad de aprender el código y muestra sus comentarios personalizados en su versión de sugerencias para el código.

FIGURA 15.1 Ejemplo de una pista de código muestra en Flash CS3 para las propiedades de MovieClip

Eliminar comentarios y depurar ayuda

Los comentarios se quitan a menudo debido al tamaño del archivo, que puede ser una preocupación válida en un programa de gran tamaño.Sin embargo, la mayoría de las veces, los comentarios se eliminan automáticamente cuando una aplicación se compila o construiye.

Dependiendo de la aplicación que utilice, instrucciones de depuración también debe ser eliminado. Por ejemplo, el IDE nativo de Flash que se envía con CS3 tiene una opción de configuración en el cuadro de diálogo Configuración de publicación. Si selecciona Omitir acciones de seguimiento, que se encuentra en la ficha Flash de la Configuración de publicación, seguimiento de las llamadas se quitan de la aplicación.

390

NOTA Si las acciones Omitir Trace está habilitado durante la depuración no podrá ver ningún seguimiento de las llamadas que aparece en la ventana de salida.

Si decide utilizar una clase personalizada o depuración de un paquete, entonces puede utilizar Find (Buscar) y Replace (reemplazar) para eliminar esas instancias. Sin embargo, tenga cuidado de no borrar accidentalmente la aplicación de código específico.

Como puede ver, los comentarios pueden ser beneficiosa desde el punto de vista de la legibilidad del código. También sabemos ahora que comentar correctamente el código tiene ventajas adicionales para utilizar algunos de los editores de código disponibles hoy en día más sólida.

Administrar un cambio de registro

Un cambios de los registros es un bloque de formato o entradas de registro colocado en un archivo personalizado. Estos archivos suelen tener los cambios de nombre o actualizaciones. Esta sección se utiliza para tomar notas sobre las características de una aplicación o para comunicar los avances con el resto de un equipo de desarrollo.

Una de las ventajas de utilizar un ChangeLog es que algunas aplicaciones pueden leer este formato de registro y automáticamente, como se muestra en la Figura 15.2. Esto, por supuesto, depende de la aplicación que esté utilizando, pero puede ser muy beneficioso como una aplicación empieza a crecer.

Seguimiento de errores

Hay muchos desarrolladores que utilizan este formato para realizar un seguimiento de cambios dinámicos errores. Este es un proceso que muchas aplicaciones comerciales y gratuitos, tales como Jira y Bugzilla, se utiliza para crear una alternativa más gráfica para el texto básico de archivo.

Uso de seguimiento de errores con los equipos (teams)

El seguimiento de errores es especialmente importante cuando se trata de equipos. Por ejemplo, muchas de las tecnologías de código abierto compuesto por desarrolladores de todo el mundo. Imagínese cómo sería tedioso para rastrear errores en e-mails o llamadas telefónicas a través de todos estos desarrolladores. Aquí es donde el seguimiento de errores es especialmente importante. Eso no significa que un único promotor no puede beneficiarse de un mismo sistema.

391

FIGURA 15.2 Aquí hay una página web que muestra un ChangeLog que se generan de forma dinámica.

Usos adicionales

Un ChangeLog no se limita a unas pocas líneas de texto. Siendo realistas, como se puede ver, puede contener las correcciones de errores, las notas a otros desarrolladores, y la información sobre un elemento específico. Por ejemplo, si usted decide usar un error de seguimiento de la aplicación, es una buena idea incluir el ID del error en la entrada de cambios o dejar que la aplicación para el seguimiento de manejar este.

Correctamente la documentación de los identificadores siguientes hace más fácil el seguimiento de un error más tarde, durante el desarrollo de aplicaciones, o si regresa a un proyecto una vez se haya completado.

Creación dinámica de cambios

Aplicaciones de control de versión, que se discuten en la sección siguiente, incluso tienen la capacidad de generar automáticamente una lista de cambios. La ventaja de este enfoque es que el desarrollador no tiene

392

que gastar el tiempo de edición del proyecto o la actualización del registro. Sin embargo, una desventaja de esto es el archivo se vuelve menos personalizado y, a veces hace más difícil de comprender plenamente.

Administración de múltiples versiones

El control de versiones es la gestión de múltiples versiones de código o archivos de una aplicación. Estas aplicaciones son utilizados en los equipos de desarrollo, pero puede ser fácilmente utilizado por un único promotor.

La ventaja de utilizar el control de versiones es el seguimiento y el código de seguridad que se almacena como a desarrollar o mantener una aplicación. Este nivel adicional de seguridad en un proyecto puede permitir que el desarrollador de experimentar con una idea y todavía tienen la capacidad de volver a una versión estable.

También permite a los desarrolladores mantener el código consistente a través de plataformas de desarrollo. Esta característica es un uso muy común para los desarrolladores que viajan solas y el código en un sistema móvil. Simplemente conecte al servidor de desarrollo, descargar la última versión, y están dispuestos a ir. Cuando regresan, una simple actualización que se haga en el mismo servidor y la aplicación está de vuelta en sincronía.

Aplicación de control de versiones

Existen varias aplicaciones de control de versión disponible para sus entornos de desarrollo de hoy en día.Seleccionar las aplicaciones de control de versiones a utilizar es determinado por mirar a las características y requisitos de su proceso de desarrollo.

El más común es la aplicación de control de versiones SVN (Subversion). Otra aplicación muy popular es CVS (Concurrent Versions System). Soporte para el control de versiones es a menudo construidos directamente en un editor de código, como el editor de código abierto Eclipse.

Apoyar el control de version de CS3

Nuevo para Adobe Flash CS3 es la posibilidad de utilizar Version Cue directamente en Flash. Version Cue (véase la figura 15.3) es el control de Adobe versión de la aplicación que se encuentran dentro de sus otras aplicaciones.

Uso de Version Cue en Flash CS3

Va a encontrar un elemento de menú " Check In..." en el menú Archivo. Este elemento se utiliza para abrir el cuadro de diálogo de gestión de Version Cue y es donde usted puede guardar versiones de su aplicación.

Usted encontrará una entrada de Check In... situado en el menú Archivo.

La ventaja de utilizar Version Cue es que los buques con CS3 y está integrado en la suite de aplicaciones.Esto es especialmente importante si usted es el desarrollo de los activos en una sola aplicación, el código en otro, y la gestión del sitio en un tercero.

393

Usted puede incluso permitir a su equipo para iniciar sesión en el servidor de Version Cue de forma remota y hacer cambios. Esto significa, por ejemplo, el desarrollador puede ser prácticamente en la misma oficina que el resto de su equipo.

FIGURA 15.3 Captura de pantalla de Version Cue, que se suministra con los programas de Creative Suite 3

Configurar el control de versiones

El proceso de creación de control de versiones depende del sistema de su entorno de desarrollo de carreras. Una guía de instalación más completo se incluye, con la aplicación que usted decide utilizar. La instalación básica que incluiría descomprimir el contenido de la solicitud de control de versiones, modificando el archivo de configuración de Apache y alerta a la existencia de la aplicación.

Usar version de control

Normalmente, el proceso de utilización de control de versiones es integrado en su editor de código. Sin embargo, hay aplicaciones disponibles para el uso de control de versiones directamente dentro de su sistema operativo.

Dos gerentes de control de versiones para Windows y Mac OS X se muestran en la tabla 15.1.

TABLA 15.1 394

Gerentes de Control de la versión para Windows y Mac OS XNombre URL OS TortoiseSVN http://tortoisesvn.tigris.org/ Windows SCPlugin http://scplugin.tigris.org/ Mac OS X

NOTA Para una configuración de desarrollo más seguro y final, lo mejor es instalar la aplicación de control de versiones en un equipo diferente.

Copia de seguridad de control de versiones

Los sistemas de control más popular versión de oferta integrada de soluciones de copia de seguridad, pero muchas veces usted encontrará que la copia de seguridad de la aplicación que está escribiendo se incluyen los datos de control de versiones.Normalmente, estos archivos se definen como ocultos y nunca se debería modificar manualmente si por alguna razón no se permite el acceso.

PRECAUCIÓN Edición de un control de versión de archivo de forma manual puede resultar en copias de seguridad de corrupción e incluso dañar la integridad del código de su aplicación.

Uso adicional de control de versión

El uso adicional de control de versiones es la posibilidad de publicar la estructura de archivos a la Web para compartir.Esto no es siempre el resultado deseado, pero puede encontrar compañías como Adobe, Google y Microsoft que este enfoque.

Uso de los cortes de control de versiones abajo en la cantidad de trabajo adicional necesario publicar el código fuente de la aplicación y permite a otros para mantener actualizado el código con sólo conectarlos a su sistema de control de versiones de forma remota.

Uso de librerias personalizadas

Colecciones personalizadas pueden hacer que el código de fácil mantenimiento. En antiguas versiones de ActionScript (antes de AS3), los paquetes en realidad no existía, así que era difícil de mantener adecuadamente y compartir la fuente de una aplicación de código.

ActionScript 3 introdujo una práctica de codificación más común que se llama paquetes. Esto ofrece la posibilidad de crear una instancia de la clase y compartirlo entre todos los proyectos contenidos en una sola carpeta o archivo.

CROSS--REF Una mirada más a fondo de bibliotecas personalizadas se pueden encontrar en el capítulo 9.

Uso de librerias personalizadas con el control de versión

Si se crea una instalación independiente para su sistema de control de versiones puede usar la misma máquina para almacenar bibliotecas personalizadas y luego incluirlos de forma remota en su archivo de Flash (s).

395

http://scplugin.tigris.org/

http://tortoisesvn.tigris.org/

La ventaja de este enfoque es la capacidad de actualizar un paquete y todas las aplicaciones que tienen que utilizar el paquete de actualización, así.

Publicar un SWC

Usted puede crear un SWC en Flash, que le permite distribuir los componentes y las clases de ActionScript. Para publicar un SWC, seleccione la opción de exportación de SWC en el cuadro de diálogo Configuración de publicación.

El archivo contiene un clip de SWC compilado y los archivos de clases de ActionScript que lo apoyan.

NOTA Es una buena idea de documentar los cambios de clase y el paquete ya que las aplicaciones existentes pueden dejar de funcionar.

El proceso de usar las bibliotecas personalizadas no puede parecer un aspecto muy importante de desarrollo de aplicaciones. Sin embargo, una vez que comiencen a desarrollar aplicaciones de mayor escala que compartan atributos comunes que usted se dará cuenta de cuánto se ahorra tiempo al no tener que reescribir el código.

Resumen

En este capítulo usted aprendió a comentar el código y por qué se hace para una mejor aplicación en general. También ha aprendido este aspecto es especialmente importante al desarrollar una aplicación con los demás.

Tienes una introducción sobre cómo incorporar un Registro de cambios en su desarrollo y cómo algunas aplicaciones de terceros pueden utilizar esta información para mostrar de seguimiento de fallos más detallado.

En la última sección aprendió a utilizar el control de versiones y se introdujeron a Version Cue, que es una nueva adición a Flash CS3.

396

Capitulo 16

Mantenimiento de un servidor escalables y más

eficienteEste capítulo se centra en las mejores prácticas para el mantenimiento de su servidor de tiempo que se introducen técnicas de mejora más avanzados de aplicaciones como el almacenamiento en caché, bases de datos eficiente, copias de seguridad, y código escalable.

Después de aprender y aplicar esta información a sus aplicaciones, pronto se dará cuenta de que funcione más eficientemente. Si sigues estos pasos en mente al inicio del proceso de desarrollo de aplicaciones, usted no tendrá que volver a trabajar después de la aplicación.

Ejecutar un servidor actualizado

Uno de los métodos más simples, pero ignorado por el mantenimiento de un servidor más eficaz es mantener las bibliotecas y el servidor central el código del lado actualizado.A menudo estos programas que son responsables de ejecutar las aplicaciones se actualizan a medida que los desarrolladores siguen encontrando maneras de acelerar hacia arriba o hacerlas más eficientes. Este proceso de actualización no se refiere a su código personal, pero las bibliotecas y los servicios depende de su código.

La actualización de su servidor, no sólo ofrece mejoras de rendimiento, pero también puede asegurarse de que su servidor Web es más seguro. PHP, por ejemplo, se actualiza con frecuencia como las mejoras más y se introducen cambios de codificación. Esto es debido a nuevos problemas de seguridad descubiertos, lo que resulta en una mejor aplicación en general.

Antes de actualizar su sistema, asegúrese de sus aplicaciones serán compatibles.Por ejemplo, las aplicaciones desarrolladas en PHP 4 no siempre son compatibles con PHP 5. Usted encontrará algunos casos en que otra pieza de software en el servidor puede requerir una versión específica. Un buen ejemplo de esto es que los clientes de correo, como una versión específica de la multitud (una popular aplicación de correo electrónico) requiere PHP 4 y no simplemente en una versión más reciente.

Esto no significa que no pueda actualizar, sino todo lo contrario en realidad. Sólo hace falta un pequeño trabajo de investigación y antes de instalar las nuevas versiones.

Uso de actuaizaciones automáticas

397

Como ustedes saben, la instalación de nuevas versiones de las aplicaciones en su servidor no es siempre la mejor opción.Usted necesita ser más consciente de esto con los actualizadores automáticos. Por ejemplo, usted encontrará las actualizaciones automáticas son más propensos a ofrecer marca una nueva funcionalidad, pero al mismo tiempo que también ofrecen el código que no se ha probado tan a fondo. Usted encontrará que no todas las aplicaciones de tu lado del servidor ofrecen actualizaciones automáticas, pero lo mejor es comprobar de antemano y asegurarse de que estas opciones están desactivadas.

Algunos proveedores de hosting realizar actualizaciones periódicas de seguridad, a veces sin su permiso, o incluso que le informa de la actualización. Esta es una de las muchas razones que prefiero correr un auto-gestionado, servidor dedicado en lugar de pagar un poco menos y dejar que el proveedor de hosting manejar la seguridad y la versión actualizaciones.

Plataforma Zend

La excepción a no instalar las actualizaciones automáticas es cuando se utiliza la plataforma Zend. Este conjunto de herramientas asegura que su sistema esté correctamente al día con todas las últimas mejoras de seguridad, mientras que asegurarse de que su secuencia de comandos existentes seguirán funcionando correctamente.

El costo de Zend Platform puede causar un dilema para las organizaciones más pequeñas y desarrolladores individuales, pero el tiempo total guardado en el largo plazo es una razón válida para comprarlo.

Trabajar con Development Installs

Instalación de nuevas aplicaciones o bibliotecas no es una práctica bien cuando se trabaja con un servidor en vivo. Sin embargo, esto no significa que no puede experimentar con el nuevo código de la instalación de un sistema de desarrollo.

Usted puede construir o adquirir su alojamiento en un nuevo servidor para obtener una configuración de sistema de desarrollo, pero esto no puede ser la solución más eficaz, especialmente si usted es un hombre de una tienda.

Construir otra version de Apache en el mismo sistema

La alternativa es instalar una versión independiente de Apache en el servidor en vivo. Por defecto, Apache sólo puede tener una versión que se ejecuta porque cada versión que trata de compartir el mismo puerto del servidor.

Sin embargo, puede modificar esta configuración modificando el archivo httpd.conf. Usted encontrará este archivo de configuración en el directorio conf/ de su nueva instalación de Apache.

Abrir este archivo en su editor de texto favorito o vi, si está ejecutando un servidor remoto, y modificar las siguientes categorías:

# Change this to Listen on specific IP addresses as shown below to

398

# prevent Apache from glomming onto all bound IP addresses (0.0.0.0) ##Listen 12.34.56.78:80 Listen 80

La mayor parte de ese bloque de código es un comentario que explica lo que este parámetro es responsable.Usted puede modificar el puerto en el que su sistema de desarrollo se puede encontrar al cambiar este número a algo similar a lo siguiente:

... ##Listen 12.34.56.78:80 Listen 9004

Después de guardar y reiniciar Apache, puede acceder a esta nueva instalación, visite http://localhost:9004.

NOTA Aplicaciones en su equipo utilizan diferentes puertos, así que es mejor para comprobar el puerto antes de elegir uno nuevo.

Trabajar con tecnología de punta

Cuando tenga el nuevo sistema instalado, puede empezar a experimentar con sangrado nueva tecnología de punta sin dañar la configuración de su vida. Sangrado software de borde como se muestra en la figura 16.1 es recién lanzado versiones que no se han probado tanto como versiones estables sería. Esto le permite trabajar con los más avanzados y nuevas características, pero también significa que podrían llegar a los errores y cuestiones de desarrollo utilizando estas versiones. A medida que continúe para probar esta nueva tecnología se puede determinar si se debe utilizar en un entorno viven y se mueven por encima de cuando esté listo.

Dependencias

Muchas bibliotecas y herramientas que utilizará en su servidor Web dependen de otras bibliotecas. Por ejemplo, la librería GD de PHP para la manipulación de imágenes requiere la biblioteca libjpeg con el fin de editar las imágenes correctamente.

Al actualizar el servidor, usted necesita estar consciente de estas dependencias, porque la actualización de una parte puede dar lugar en las instalaciones rotas o incompletas. Frecuentemente usted encontrará información sobre el sitio del desarrollador de actualización en materia de información específica o se puede consultar php.net en la sección de comentarios. Allí usted podrá encontrar a otros desarrolladores para informar de sus resultados en diferentes situaciones de desarrollo.

399

FIGURA 16.1 Un ejemplo de sangrado borde emisiones de php.net

Almacenamiento en cache y optimización

Mantener el servidor hasta la fecha es sólo una manera de ejecutar un servidor eficiente. De hecho, las prácticas, hay mucho más importante para seguir en primer lugar. Una de estas prácticas más importante es la optimización de su código de servidor y el sistema que se ejecute. No sólo hay que seguir las mejores prácticas en el desarrollo de sus aplicaciones, también debe mantener su servidor que se optimiza en función de sus necesidades específicas.

Optimización de PHP

Tras los pasos para la optimización de su instalación de PHP que permite llevar a cabo una mejor general del servidor. Estas medidas de optimización es bastante fácil de seguir y fácilmente se puede repetir como usted trabaja en varios servidores.

400

Procesador versus RAM

A diferencia de la mayoría de aplicaciones que requieren más memoria, PHP se basan más en el procesador en su servidor. Esto significa que un sistema de doble-procesador es más eficiente que un procesador con más memoria. Eso no significa que la memoria no es importante, porque algunas partes de PHP utilizan una cantidad considerable de la memoria.

El búfer de salida y la base de datos de plug-ins requieren más memoria que se accede a ellos, ya que tienden a almacenar la mayoría de la información para un acceso más rápido la próxima vez. Esto significa que la primera solicitud es lento, pero las siguientes solicitudes que son más rápidas si tiene suficiente memoria para manejar adecuadamente las solicitudes para ser almacenados.

Esto no significa que usted debe salir corriendo y de inmediato adquirir más memoria o más procesadores, porque hay maneras de optimizar su servidor sin gastar dinero en software o hardware adicional.

Diez consejos para optimizar el código

La siguiente es una lista de diez consejos a seguir que producir un mejor rendimiento en su código, así como limitar la tensión en el servidor Web. Que aparecen aquí en orden de menor importancia a la más importante.

1. Limite la cantidad de control de errores de sus aplicaciones de manejar. Menos manipulación de error significa un mejor rendimiento general, a menos que están experimentando ya los cuellos de botella. Entonces, el manejo de errores puede ser importante. 2. Usar la funcion included; no crear uno propio. Siempre que sea posible, trate de usar las funciones previstas en PHP, ya que están precompilados y se han optimizado para funcionar más eficientemente. También han sido probados una y otra vez para asegurarse de que el trabaja. 3. Utilice una selecta declaración en lugar de múltiples if/else. No sólo se utiliza un código más limpio, seleccione producir, sino que también resultará en un mejor rendimiento cuando el PHP se ejecuta la parte de su código. 4. Evitar mitos como el eco es más rápido que el de impresión. Como con la mayoría de lenguajes de programación, PHP tiene varios mitos, como todo el código debe estar en una línea. Uno de los mitos más comunes es que el eco es más rápido que el de impresión al enviar el código para el búfer de salida o de la pantalla. Esto simplemente no es cierto. Puede utilizar cualquiera de declaración. Yo personalmente prefiero de impresión, ya que se está imprimiendo a la pantalla o buffer. 5. Conexiones de base de datos Cerrar el uso de funciones como mysql_close (para MySQL) cuando no se utiliza. Conexiones de base de datos final, cuando la secuencia de comandos completa, pero esto no siempre es la mejor manera. Por ejemplo, si usted tiene un programa que realiza llamadas de base de datos y modifica estos resultados, la conexión de bases de datos se mantiene activa (a menos que lo cierre) todo el tiempo que su guión está trabajando en el conjunto de resultados. 6. Utilice unset () para eliminar las variables cuando ya no se utiliza. Eliminación de variables, en grandes series y los objetos cuando ya no esté en uso, se traduce en un mejor rendimiento general. 7. Trate de limitar las expresiones regulares y el uso de funciones de cadena estándar siempre que sea posible.

401

Las expresiones regulares, mientras que más robusto, puede consumir una considerable cantidad de memoria. Frecuentemente usted encontrará una función de cadena sencilla (por ejemplo, strstr) produce el mismo resultado y con un aumento de rendimiento significativo en la mayoría de los casos. 8. Sea inteligente sobre el uso de la clase. Las tareas simples sufrirán de programación orientada a objetos innecesarios. Va a encontrar más simples tareas consumen más memoria que las prácticas desarrolladas con OOP. Es importante no sólo saber que existen técnicas, sino también cuando se debe utilizar. 9. Controla tus aplicaciones para determinar los cuellos de botella. Ralentización en el rendimiento del código se remonta a un lugar específico, conocido como un cuello de botella. Piense en una botella real, donde el cuello se hace más lento el flujo del líquido a medida que los grupos que pasar por la parte superior estrecha de la botella. Lo mismo es cierto para el código como la mayoría de las bibliotecas y los guiones tienen un punto en el que todos deben cumplir.Un cuello de botella en su aplicación pueden existir en el código, pero también podría ser en una llamada de base de datos o un archivo de interacción del sistema. La supervisión de su aplicación se exponen los problemas y le permitirá solucionar el problema de rendimiento. 10. Caché de su código PHP, siempre que sea posible.

Después de optimizar el código, pero todavía necesitamos mejorar más, el caché puede ser una opción. Usted puede desarrollar una solución personalizada o utilizar un sistema existente, tales como memcached, que se examina en la sección siguiente. Usted también puede almacenar en caché el script PHP adquirido precompilar, lo que acelera las solicitudes posteriores.

PHP por defecto compila las páginas de sus archivos .php cada vez que se solicitan. El almacenamiento en caché evita este almacenando el código precompilado. Esto es mucho más eficiente y significa un rendimiento más rápido.

Dichas recomendaciones no son las únicas maneras de optimizar el código, pero proporcionan una lista de desaceleración comunes y mitos en el desarrollo de sus aplicaciones. Como usted puede ver, con pocas modificaciones en el código y la atención a cómo el servidor Web se ocupa de sus secuencias de comandos, usted puede asegurar un mejor desempeño, manteniendo la funcionalidad final.

He visto algunas aplicaciones eliminar funciones cuando el programa comienza a expandirse, y esto es simplemente el enfoque equivocado. Extracción de características de una aplicación lenta es similar a lanzar cantidades salvajes de nuevo hardware para resolver un problema de rendimiento.

Optimizar Zend

El optimizador de Zend es un producto que se utiliza para optimizar y la caché de su código, sino que también proporciona un resultado seguro, ya que el código se compila y cifrado. El cifrado se realiza mediante la ejecución de su código fuente a través de Zend, como se muestra en la Figura 16.2, que ofusca el código abierto.

Esta herramienta no es gratuita, pero a medida que continúe el desarrollo de aplicaciones más robustas, usted aprenderá que el coste se ve compensado por el aumento en el rendimiento a alcanzar.

402

FIGURA 16.2 Zend Guard con un proyecto activo cargado

Zend Studio

Un servidor más optimizado se remonta al proceso de desarrollo de aplicaciones. Zend ofrece un estudio de desarrollo que pueden perfilar y depurar el código, lo que le permite localizar los cuellos de botella antes de implementar el código de.

El Zend Studio, como se muestra en la Figura 16.3, permite incluso la depuración remota, que le permite probar sus aplicaciones en el servidor de vivir al mismo tiempo ser capaces de controlar y depurar cuando sea necesario.

Usted puede encontrar más información acerca de estas herramientas en el sitio web de Zend en www.zend.com/en/products/guard/optimizer/ y www.zend.com/en/products/studio/.

403

http://www.zend.com/en/products/studio/

http://www.zend.com/en/products/guard/optimizer/

FIGURA 16.3 El editor de código se encuentra en el Zend Studio IDE

Optimización de Apache

El proceso de optimización de Apache está dividido en cuatro pedazos. Esto permite al desarrollador a concentrarse en cada paso específico en lugar de obligarlos a modificar todos los aspectos del servidor. En raros casos, sólo verá las actualizaciones de rendimiento mínimo, pero se dará cuenta más que la aplicación y la demanda continuará creciendo.

Hardware

El primer lugar de mirar al tratar de optimizar Apache es el hardware que puede correr. Por ejemplo, Apache consume una gran cantidad de memoria en el tiempo. Más memoria puede ser una ventaja aquí, porque será capaz de mantener adecuadamente la propia.

404

Servidor dedicado

Hacer seguro Apache se ejecuta en un servidor dedicado. Esta técnica incluye el desarrollo de instalar que usted aprendió en la sección anterior. Es importante entender el desarrollo de instalar la versión de Apache que no consume muchos recursos, siendo un producto de un solo usuario. Es mejor dejar que Apache tiene todo el servidor para ejecutar más eficientemente. La empresa (grande) muchas veces las aplicaciones se ejecuta un servidor independiente para gestionar el tráfico web.

Archivos de configuración

Modificación de los archivos de configuración (*.conf) puede producir un aumento de rendimiento si se quita las directivas que no están siendo utilizados. A medida que aprenda el diseño de configuración, puede eliminar los comentarios, que hará más fácil mirar en el largo plazo.

Apache ofrece una serie de archivos de configuración de arranque, pero trate de evitar la versión de alto rendimiento ya que en realidad se vuelve menos eficiente en el largo plazo. La razón es porque esta versión excesivamente optimiza Apache, que lo obliga a correr menos eficaz a menos que esté experimentando un tráfico muy alto.

Registros y los errores

Siempre que sea posible tratar de limitar la cantidad de uso de registro. Usted puede desactivar el registro completo o limitar la cantidad de información que se escribe en los registros. Los errores son más difíciles de rastrear debido a Apache no informar de estas cuestiones. En la mayoría de los casos, sin embargo, cuando un servidor está funcionando correctamente esto no es un problema.

Si decide habilitar el registro, asegúrese de editar los archivos en un equipo diferente, porque el proceso de apertura y análisis de estos archivos a veces muy grandes puede tener un impacto en el rendimiento.

Número maximos de clientes

Puede modificar la directiva MaxClients en el archivo de configuración httpd.conf para aumentar el rendimiento, sino ser conscientes de que cualquier cliente intenta conectarse después de que el límite es alcanzado no podrá ver su sitio. En casos raros, esto puede no ser algo malo porque va a mantener el rendimiento para los usuarios existentes.

<IfModule prefork.c> StartServers 8 MinSpareServers 5 MaxSpareServers 20 MaxClients 150 MaxRequestsPerChild 1000 </IfModule>

NOTA La directiva MaxClients sólo se aplica cuando el módulo prefork está configurado y habilitado.

Hay otras maneras de optimizar Apache, pero corto de agregar hardware adicional y el costo para su organización, esta lista tendrá su servidor en funcionamiento mucho más eficiente.

Optimización de MySQL

405

Ahora que ha optimizado PHP y el servidor Web Apache, el lugar más lógico para optimizar es MySQL. Usted puede optimizar MySQL después de ser instalado, pero hay algunas buenas prácticas a tener en cuenta antes de la instalación, cuando sea posible.

Mejor rendimiento de la instalación

Elegir el mejor compilador para el sistema cuando se genera normalmente MySQL puede conseguirle 10 a 30 por ciento de mejor rendimiento. Compilar MySQL con sólo los conjuntos de caracteres y las opciones que vayan a utilizar. A menudo, una evaluación rápida de su uso previsto puede resultar en un mejor rendimiento, porque a simple vista se puede determinar qué características que usted usa y no va a usar.

La documentación de MySQL tiene varios consejos sobre la mejora del rendimiento, y como seguir aplicando más de ellos tendrá que ejecutar el binario compilado utilizando la prueba de referencia de MySQL para realmente determinar si las modificaciones se traducirá en un mejor rendimiento.

MySQL es una aplicación de largo camino. Esto significa que usted desea un mejor rendimiento general y no sólo para acciones muy rápido. Por ejemplo, suponga que tiene una tabla con 100.000 líneas, que no es poco común en aplicaciones grandes. Realización de una búsqueda en esta tabla llevará algún tiempo, por lo que MySQL en sintonía con un acceso rápido en la mente realmente será el cuello de botella. Es mejor disponer de MySQL en sintonía con los procesos a largo plazo en mente para trabajar con datos en estos volúmenes.

Registro de consultas lentas

Una de las mejores maneras de localizar los cuellos de botella en su base de datos MySQL es habilitar el registro cuando sea necesario. Es importante entender que registros en sí mismo es un asesino en el rendimiento, pero a veces es necesario fijar otras cuestiones.

MySQL registra las consultas de lento a un archivo de registro. Si la cola de este archivo, que se utiliza para vigilar activamente el flujo, se le informó de las consultas lentas. También puede dejar que este registro de relleno y luego pruebe más tarde, dependiendo de qué tan activo es su sistema.

tail -f /var/lib/mysql/192-168-1-107-slow.log

El camino de la lentitud de archivo de registro de consultas será diferente dependiendo de su entorno.

NOTA Windows no ofrece una "cola" de comandos por defecto, pero puede instalar el servidor de las herramientas disponibles en Microsoft.

NOTA Es posible que necesite para que "el registro de consultas lentas" en los archivos de configuración de MySQL.

Comprobación de tablas

Otra manera de asegurar una base de datos se está ejecutando correctamente es para controlar la salud de mesa, al emitir el comando siguiente en el símbolo del sistema. Table_name Reemplazar con el nombre real de la tabla que desea consultar.

CHECK TABLE table_name

406

Por ejemplo:

mysql> check table poll; +-------------+---------+---------------+--------------+ | Table | Op | Msg_type | Msg_text | +-------------+---------+---------------+--------------+ | book.poll | check | status | OK | +-------------+---------+---------------+--------------+ 1 row in set (0.00 sec)

Limitar las opciones de inicio

Otra forma de obtener un mejor rendimiento de MySQL es limitar las opciones que se cargan cuando se inicia.Los buques de MySQL con varias opciones para cada caso de uso, pero es seguro decir que no hará uso de todos ellos. Similar a Apache, si modifica los archivos de configuración de MySQL, usted notará un mejor rendimiento.

Herramientas adicionales

El grupo de desarrollo de MySQL proporciona perfiles libre y herramientas de administración. Estas herramientas pueden ser descargadas desde el sitio web principal de MySQL y le ayudará a optimizar y controlar sus bases de datos de forma remota. La ventaja de usar estas herramientas es no tener que controlar tu servidor usando el comando herramientas de línea de base. Estos interfaz gráfica permite que las herramientas le permiten entender lo que su servidor web está haciendo desde una perspectiva visual, como se muestra en la Figura 16.4.

FIGURA 16.4 The MySQL Query Browser

407

Almacenamiento en cache

El tema de la caché es normalmente una vez que miró a experimentar cuellos de botella en una aplicación, pero se puede instalar las soluciones de almacenamiento en caché antes de que surja algún problema.

Trabajar con memcached

Uno de los cuellos de botella en los scripts de servidor es la base de datos. Usted tiene la habilidad de ajustar la configuración, lo que hizo en la sección anterior. A veces, esto sólo puede ir tan lejos como un sistema sigue creciendo.

La respuesta a este problema es instalar un software para ayudar a lidiar con la desaceleración de base de datos, tales como memcached, que es una memoria de alto rendimiento objeto de sistema de almacenamiento en caché. Este sistema está construido con la intención de acelerar las aplicaciones web dinámicas mediante la eliminación de la carga de base de datos, que se encuentra más a menudo como el sistema sigue creciendo. Puede descargar la última versión de memcached de danga.com en www.danga.com/memcached/.

Instalar memcached en Linux

La siguiente sección cubre el proceso de instalación de memcached en un servidor Web de Linux. Esta versión requiere de otra biblioteca que se instalen, que también estarán cubiertos.

408

http://www.danga.com/memcached/

Instalación de libevent

Antes de instalar memcached, necesita instalar una biblioteca de la dependencia. Esta es la libevent, que puede descargarse en www.monkey.org/~provos/libevent/.

Descomprimir el archivo y realizar los mismos pasos de instalación que ha visto en los ejemplos anteriores, cuando la instalación de aplicaciones.

$ tar -xvf libevent-1.3b.tar.gz

Cambie el directorio actual a la recién creada libevent para continuar el proceso de instalación.

$ cd libevent-1.3b

El último paso para la creación de la dependencia es configurar y construir el necesario instalar los archivos e instalar la biblioteca libevent.

$ ./configure $ make $ make install

Instalación de memcached

Una vez que se instala libevent, puede continuar con la instalación de memcached.

$ gunzip memcached-x.x.x.tar.gz

Empieza por descomprimir el archivo que acaba de descargar.

$ tar -xvf memcached-x.x.x.tar

A continuación, cambiar el directorio actual para continuar la instalación.

$ cd memcached-x.x.x

El último paso del proceso de instalación es la de crear el script de instalación e instalar la aplicación.


Con memcached instalado, ponerlo en marcha y pasar a la extensión de PHP.

$ ./memcached -d -m 2048 -l 127.0.0.1 -p 11211

Descargar la extension memcached para PHP

En este punto, el siguiente paso es instalar la extensión de PHP que se utiliza para interactuar con memcached.

El primer paso es descargar memcached desde el repositorio de paquetes PECL.

$ wget http://pecl.php.net/get/memcache-x.x.x.tgz

409

http://www.monkey.org/~provos/libevent/

NOTA El número de versión se ha eliminado para asegurarse de que descarga la versión correcta, no por la fuerza una versión en el lector. Lo mejor es leer la documentación antes de descargar una versión de.

Instalación de la extensión memcached de PHP

Una vez que el archivo se descarga, descomprimir y desempaquetar el archivo de almacenamiento.

$ gzip -df memcache-x.x.x.tgz $ tar -xvf memcache-x.x.x.tar

Cambie al directorio que el archivo ha creado memcached.

$ cd memcache-x.x.x

Una llamada a phpize se hace para crear los archivos descomprimidos en una extensión de PHP compatibles.

$ phpize

El siguiente paso es configurar la instalación, hacer que los archivos de instalación, y finalmente instalar la aplicación que utiliza los siguientes tres comandos:


Cuando la instalación esté completa, se necesita modificar el archivo php.ini y añadir la nueva extensión.

extension=memcache.so

Instalar memcached en Windows

El primer paso para la instalación de memcached es descargar la versión binaria directamente de http://jehiah.cz/projects/memcached-win32/

1. Descomprimir los archivos binarios en el directorio deseado (e.g., c:\memcached). 2. Instalar el servicio: ‘c:\memcached\memcached.exe -d instalar desde el símbolo del sistema. 3. Inicie el servidor de Microsoft Management Console. 4. Utilice el servidor, por defecto escuchando en el puerto 11211.

Ahora que ha instalado y arrancado memcached, el siguiente paso es configurar PHP. Comience por comprobar las extensiones de directorio de PHP (C:\php\ext) para la extensión memcached (php_memcache.dll).

Si usted no ve la extensión de ese directorio se puede visitar el repositorio de PECL y descargarla desde allí: http://pecl4win.php.net/ext.php/php_memcache.dll

El siguiente paso es abrir el archivo php.ini y añadir la extensión memcached a la lista existente de las extensiones.

extension=php_memcache.dll

El último paso es reiniciar Apache.

410

http://pecl4win.php.net/ext.php/php_memcache.dll

http://jehiah.cz/projects/memcached-win32/

Terminando la instalación para Linux y Windows

El último paso es reiniciar PHP reiniciar Apache y ejecutar la función phpinfo para ver si memcached se ha añadido correctamente.

Guardar los datos en la caché

El poder de memcached no puede ser explicado en una sección pequeña, pero el siguiente es un buen resumen de cómo cargar y guardar datos en el sistema de almacenamiento en caché.

El primer paso es crear una nueva instancia de la biblioteca de objetos Memcache.

$cache = new Memcache;

Después de crear el objeto, crear una nueva conexión. Para este ejemplo, todo lo que se está ejecutando en el mismo servidor, pero memcached realmente brilla cuando está instalado en varios servidores. El segundo argumento en el método connect es el número de puerto en el que se está ejecutando memcached.

$cache->connect(“localhost”, 11211);

Después de realizar la nueva conexión, puede crear algunos datos de la muestra, que probablemente sería un bloque de más avanzada de datos en una aplicación real.

$sampleData = array(“apples”, “oranges” “bananas”, “waffles”);

Después de crear los datos de la muestra, que en este ejemplo es una matriz básica, es necesario enviar los datos al sistema de almacenamiento en caché. Esto se hace realizando una llamada al método conjunto de la clase Memcached.

El primer argumento es el nombre de la clave, que debe ser único, porque es la forma en que usted va a recuperar esta información.

$cache->set(“uniquekey”, $sampleData, false, 86400); El segundo argumento es la muestra de datos para almacenar en la memoria caché.

$cache->set(“uniquekey”, $sampleData, false, 86400);

Memcached tiene la capacidad de almacenar los datos en un formato comprimido, que es fijado por el tercer argumento.Esta opción es una bandera de verdadero o falso.


El cuarto y último argumento determina el tiempo que los datos en caché debe permanecer vivo en segundos.En este ejemplo, los datos se va a quedar por 24 horas.


NOTA La opción caducará de datos memcached no puede exceder de 2592000 (30 días).


411

Como puede ver, el código necesario para guardar los datos en la caché es bastante simple y hace que sea muy fácil de adaptar a las aplicaciones existentes.

Aquí está el script de ejemplo completo para guardar los datos en la caché.

<?php

$cache = new Memcache; $cache->connect(“localhost”, 11211);

$sampleData = array(“apples”, “oranges” “bananas”, “waffles”);


?>

Carga de datos en caché

Una vez que almacenar información en la caché, el proceso para recuperar esa información es una cuestión de llamar a uno de los métodos de la clase Memcache. Este método acepta un argumento, que es la clave que utilizó para guardar los datos en la caché.

$result = $memcache->get(“uniquekey”);

Eso es todo lo que hay que cargar la información almacenada en caché. Como puede ver, la carga de datos de la caché es muy similar al proceso general de trabajo con la base de datos. Esto significa que no es difícil integrar sin problemas en su código.

Adminitrar servidores

El sistema de almacenamiento en caché memcached se puede instalar en la misma máquina que el servidor Web se ejecuta en.Sin embargo, funciona mejor si se añade a una serie de otras máquinas. Estas máquinas adicionales no tienen que estar en el mismo dominio, ubicación, o incluso ser todo lo que de gran alcance, desde una perspectiva de hardware.

Agregar nuevos servidores Usted puede utilizar connect() para agregar nuevos servidores, pero hay una función mejor, addServer (), que no utiliza tantos recursos y sólo establece una conexión de red cuando sea necesario. Puedes añadir tantos servidores como desee, pero sólo se utilizará cuando sea requerido por el sistema.

Cerrar una conexión

El proceso de cierre de una conexión de servidor caché se realiza mediante una llamada al método close(). Este método no cerrará conexiones persistentes. Estas conexiones se cierran sólo cuando el servidor Web se apaga o se reinicia.

$cache = new Memcache; $cache->close();

412

Eliminación de un elemento en la caché

Artículos será automáticamente eliminado de la caché cuando su expiración, pero no es raro que a usted lo desea, puede eliminar los datos inmediatamente. El método delete () acepta dos argumentos. El primer argumento es la clave del partido y eliminar. El segundo argumento es un retraso de tiempo de espera cuando el servicio de almacenamiento en caché a esperar esta cantidad de tiempo antes de extraer el valor.

Usted puede utilizar este método para acelerar el proceso de eliminación de ciertos elementos, estableciendo el tiempo de espera de unos minutos u horas, en el futuro.

Avanzando con memcached

Ahora que tiene una comprensión de cómo instalar, modificar y utilizar memcached debería ver un aumento sustancial del rendimiento. La ventaja de trabajar con memcached se puede añadir más servidores que la carga se vuelve más exigente. Este sigue siendo eliminar el estrés de la base de datos y hace que sus aplicaciones sean más sensibles.

La clase Memcached ofrece algunos otros métodos que pueden ser útiles, dependiendo de su uso previsto. También puede utilizar este sistema de almacenamiento en caché memcached con múltiples lenguajes de programación, pero el foco en esta sección ha sido PHP 5.

Manejo de copias de seguridad (Backups)

Copia de seguridad de sus datos no es sólo una las mejores prácticas para asegurar que sus datos se almacenan de forma segura, copias de seguridad también se puede utilizar para limpiar periódicamente el sistema y limitar los archivos que están disponibles en el sistema.A menudo usted tendrá muchos archivos Oldfilename.php o test.php a través de su servidor como prueba de los conceptos más código. El problema con estos archivos extra se ralentiza el directorio analiza y hace más difícil gestionar los archivos que la material.

Administrar archivos

Ejecutar un servidor más eficiente puede incluir la reducción de lo que está instalado en su servidor. En la siguiente sección usted aprenderá cómo excluir archivos no utilizados para limitar la sobrecarga.

Administra archivos necesarios

Si limita el servidor para que sólo tenga el código de activa y salir de la experimentación de un servidor de desarrollo o de la sección, usted se dará cuenta de un directorio de exploración y la búsqueda de aumentar el rendimiento.

Esto no significa que los archivos innecesarios que debe suprimirse. De hecho, eso es exactamente lo contrario de lo que debe hacer. La mejor práctica es crear copias de seguridad programado que buscan estos archivos o simplemente tener un sistema de copia de seguridad que respalda todo el servidor y lo mueve a una ubicación remota.

Límite de archivos largos

413

Trate de limitar el uso de los archivos más grandes siempre que sea posible. Estos archivos tardan más tiempo para abrir y requieren más memoria cuando se abre. Si no se excluyen, sino que también ralentizar el proceso de copia de seguridad, que obtiene una mirada más a fondo en la siguiente sección.

NOTA No almacene los datos de backup en la misma unidad, ya que tendrá un problema aún mayor de los recursos.

Aministrar copias de seguridad

Ejecutar copias de seguridad en su sistema asegurarse de no perder los archivos necesarios. Esto puede incluir los archivos de usuario cargado o configuraciones de servidor básico.

Copias de seguridad temporizado

Servidores web UNIX ofrecen un servicio llamado cron, que puede ser configurado para ejecutarse en un momento determinado sobre la base de la información de configuración. Usted puede encontrar más información sobre el servicio cron consultando la página de manual para que.

man cron

Este es el formato de un archivo crontab, donde se repite la última línea para cada nuevo comando.

# +---------------- minute (0 - 59) # | +------------- hour (0 - 23) # | | +---------- day of month (1 - 31) # | | | +------- month (1 - 12) # | | | | +---- day of week (0 - 6) (Sunday=0 or 7) # | | | | | * * * * * command to run

Todos los trabajos de cron se encuentran en el mismo archivo, que normalmente se cargan al escribir el siguiente comando:

crontab -e

En Windows, puede usar el Programador de tareas, que pueden proporcionar la misma funcionalidad básica.

Directorios de copia de seguridad usando PHP

Con el sistema de cron, que se puede ejecutar un comando en un momento dado, a su disposición se puede construir un sistema de copia de seguridad automática que es llamado por el cron. Estas copias de seguridad se pueden ejecutar en cualquier momento, pero a menos que haya un requisito especial, es mejor correr cuando el servidor se encuentra con la menor cantidad de estrés.

La primera parte de la secuencia de comandos de copia de seguridad es definir el directorio de copia de seguridad. Esta parte está construido como una matriz, que se utiliza para permitir que más de un directorio a ser respaldada.

414

$dirs = array(“/var/www/vhosts/example.org/myfiles”);

El backupDir define en el archivo de almacenamiento se guarda después de su creación.

$backupDir = “/var/www/vhosts/example.org/backups”;

A la fecha es almacenado que se utiliza como el nombre de archivo. Puede modificar el nombre del archivo para incluir las horas y minutos si decide crear más de una copia de seguridad por día.

$date = date(‘m-d-y’);

El núcleo de la secuencia de comandos de copia de seguridad dentro de un bucle foreach. Este lazo es el responsable de realizar copias de seguridad de cada directorio definido en la matriz. Para este ejemplo, sólo hay un directorio definido, por lo que este ciclo sólo se ejecutará una vez.

foreach($dirs as $dir) {... }

Continuando con la secuencia de comandos, la sección siguiente está todo en el bucle foreach. La primera parte consiste en usar preg_replace para eliminar todos, pero el nombre del directorio de la variable $dir. Esto es pasado a través de otro preg_replace para definir el nombre del archivo.

$dir = preg_replace(‘/\/$/’, ‘’, $dir); $archiveName = preg_replace(‘/^(.*)\/.*?/’, ‘’, $dir);

Después de definir el nombre del archivo, el siguiente paso es construir el comando que creará el archivo de almacenamiento.

$tgzName = “{$archiveName}-{$date}.tgz”; $tgzFile = “{$backupDir}/{$tgzName}”; $backupCmd = “tar czf {$tgzFile} {$archiveName}”;

La variable $backupCmd se pasa al comando del sistema, que informa de PHP para ejecutar el passed-in el mando a nivel de sistema de su servidor Web. Este sería el mismo que ejecutar el comando en la línea de comandos o terminal.

$result = system($backupCmd . “ 2>&1”);

Para propósitos de depuración es posible que desee a la salida del comando en caso de que se produce un error, así como el mando original para asegurar la estructura está bien definida.

print “Command: “ . $backupCmd . “<br />”; print “Result: “ . $result;

Este es el final de la secuencia de comandos de copia de seguridad de archivos. Como puede ver, la estructura de este script es sencillo y el único aspecto importante es la función del sistema, que puede ser desactivado en algunos entornos.

Aquí está el script completo, que se hace referencia en el archivo crontab para automatizar el proceso.

<?php

415

// File Backup

$dirs = array(“/var/www/vhosts/example.org/myfiles”); $backupDir = “/var/www/vhosts/example.org/backups”;

$date = date(‘m-d-y’);

foreach($dirs as $dir) { $dir = preg_replace(‘/\/$/’, ‘’, $dir); $archiveName = preg_replace(‘/^(.*)\/.*?/’, ‘’, $dir);

$tgzName = “{$archiveName}-{$date}.tgz”; $tgzFile = “{$backupDir}/{$tgzName}”;

$backupCmd = “tar czf {$tgzFile} {$archiveName}”;

$result = system($backupCmd . “ 2>&1”);

print “Command: “ . $backupCmd . “<br />”; print “Result: “ . $result; }

?>

Copia de seguridad de tus archivos importantes es una manera de mantener un sistema eficaz. Sin embargo, la base de datos es otro aspecto que debe ser limpiado periódicamente. Usted nunca quiere borrar accidentalmente información importante por lo que es una buena idea de establecer un sistema de copia de seguridad de este, así.

Con la excepción de unos pocos comandos, la secuencia de comandos de copia de seguridad de base de datos es muy similar a la secuencia de comandos de copia de seguridad de archivos y se pueden combinar en un script de copia de seguridad que se explica en la siguiente sección.Si opta por combinar las dos secuencias de comandos que puede limitar los directorios de copia de seguridad. De lo contrario, las copias de seguridad puede resultar en un rendimiento más lento.

Uso de PHP para copia de seguridad de base de datos

Como aprendimos en la sección anterior, se puede asignar scripts de copia de seguridad automática en el fichero crontab. Otro script de copia de seguridad común es la que se ocupa de sus bases de datos. Al igual que la copia de seguridad de archivos, entonces debe mover a un directorio remoto para asegurar el tamaño del archivo añadido no afecta a su servidor en vivo.

Usted encontrará que a medida que el sistema comienza a crecer es posible que desee invertir en un servidor de copia de seguridad que no necesita muchos recursos, ya que se utilizarían exclusivamente para el almacenamiento. Este no es un elemento necesario, pero te da un nivel adicional de protección con sus datos, así como su servidor hace vivir más eficiente.

La primera parte de la secuencia de comandos de copia de seguridad de base de datos es definir los detalles de la conexión MySQL.

$dbHost = “localhost”; $dbUsername = “root”; $dbPassword = “pass”;

416

La base de datos para este ejemplo es una aplicación de tienda de libros, pero puede modificar la base de datos para que coincida con alguna de las muchas bases de datos se puede tener todo en su sistema.

$dbName = “bookStore”;

Si se han definido estas variables en otra parte de su aplicación, usted simplemente puede cargar dicho archivo de configuración para asegurarse de que los únicos valores deben actualizarse una vez. Reemplaza los últimos cuatro líneas con una simple llamada de incluir o requerir.

require “/path/to/configuration/dbConnection.php”;

El directorio de almacenamiento de copia de seguridad de $ backupDir se define como una cadena en este ejemplo, pero usted puede modificarlo para que un arreglo como lo hizo en la secuencia de comandos de copia de seguridad de archivos. Esto es importante si usted tiene más de una base de datos, como la mayoría de los sistemas de hacer.

$backupdir = ‘/var/www/vhosts/example.org/dbBackups’;

NOTA Define el directorio de copia de seguridad fuera de la ruta de acceso del público siempre que sea posible para garantizar el navegador Web no puede tener acceso a las copias de seguridad.

El nombre del archivo debe ser único para los archivos no se escriben uno al otro. Usted puede crear un hash al azar usando el tiempo, que sería único, sino que haría imposible determinar qué archivo ha creado.

Una solución mucho más elegante es anexar partes de la fecha al nombre del archivo, lo que crea un nombre de archivo legible y único. En lugar de hacer llamadas múltiples hasta la fecha se puede utilizar la función getdate(), que devuelve una matriz de información actualizada que se puede hacer referencia a los nombres de las teclas.

$today = getdate();

Para asegurar que la fecha se puede leer en la mejor manera posible, una serie de sentencias if se utiliza para garantizar los valores de fecha son siempre dos dígitos. Esto no es un requisito de programación, pero más importante, una coherencia que hace que sea más fácil de leer la fecha en el nombre de archivo.

$month = $today[mon];

if($month < 10) { $month = “0” . $month; }

$day = $today[mday]; if($day < 10) { $day = “0” . $day; }

$year = $today[year];

417

La creación de archivo real se divide en tres partes, pero todos en el mismo comando. La primera parte hace una llamada a la base de datos mediante la aprobación en la información de acceso necesaria.

$mysqlCommand = “mysqldump --opt -h %s -u %s -p%s %s”;

La segunda parte del comando acepta los datos de MySQL y lo empuja a la función gzip, que es donde se crea el archivo real.

$gzipCommand =”gzip > %s/%s-%s-%s-%s.gz”;

La tercera y última parte del comando tiene las variables definidas en los apartados anteriores y crea la cadena de comandos usando sprintf limpiamente crear el comando. La función sprintf utiliza marcadores de posición y acepta los argumentos adicionales para cubrir los marcadores de posición. Este es el mismo que crear una cadena en línea, sino que crea una cadena más limpio y más fácil.

$run_command = sprintf($mysqlCommand . “ | “ . $gzipCommand, $host, $user, $pass, $db, $backupdir, $db, $month, $day, $year);

El tubo | personaje (pipe | character) es un comando especial que indica al sistema para capturar la salida del comando a la izquierda de la tubería e introducir en la función definida en el lado derecho de la tubería.

En este ejemplo, los datos de MySQL es capturado y pasado en la llamada gzip.

El último paso en la secuencia de comandos de copia de seguridad de base de datos es realmente hacer la llamada al sistema, que reúne los datos de MySQL y crea el archivo de almacenamiento.

system($run_command);

NOTA El comando system() no está disponible si está incapacitado en el archivo php.ini o si está habilitado el modo seguro.

Aquí está el script completo, que usted puede rápidamente modificar y agregar a su crontab existentes. Usted puede incluso combinar las dos secuencias de comandos de copia de seguridad y agregar más funcionalidad. Los ejemplos anteriores son para empezar.

<?php

#!/usr/bin/php

//require ‘connectfile.php’;

$dbHost = “localhost”; $dbUsername = “root”; $dbPassword = “pass”; $dbName = “bookStore”;

$backupdir = ‘/var/www/vhosts/example.org/dbBackups’;

$month = $today[mon];

if($month < 10) { $month = “0” . $month;

418

}

$day = $today[mday];

if($day < 10) { $day = “0” . $day; }

$year = $today[year];

$mysqlCommand = “mysqldump --opt -h %s -u %s -p%s %s”;

$gzipCommand =”gzip > %s/%s-%s-%s-%s.gz”;

$run_command = sprintf($mysqlCommand . “ | “ . $gzipCommand, $host, $user, $pass, $db, $backupdir, $db, $month, $day, $year);

system($run_command);

?>

Resumen

En este capítulo, usted aprendió diversas técnicas sobre cómo mantener un servidor Web escalable y más eficiente. El estudio abarcó los temas de la modificación de los archivos de configuración de Apache, lo que limita lo que se carga, y deshabilitar el registro de errores para mejorar el rendimiento global.

A continuación, aprendió cómo optimizar MySQL, que puede dar cuenta de la gran mayoría de los cuellos de botella en una aplicación y puede incluso suben a consumir los recursos del servidor Web.

En la parte final del capítulo, que se introdujeron para memcached, que fue utilizado para construir un sistema de alto rendimiento que elimina el almacenamiento en caché de la mayoría de los gastos generales de la base de datos.

Uso de cada una de estas técnicas en cualquiera de sus proyectos de desarrollo se traducirá en un mejor rendimiento. Nuevo hardware no tiene por qué ser la única solución, si bien optimizar su servidor Web utilizando estas técnicas.

También aprendió sobre las nuevas herramientas que pueden ayudarle a optimizar su sistema utilizando un método gráfico en lugar del comando del sistema tradicional.

419

Capitulo 17

Construir aplicaciones completamente

avanzadasEn lugar de tener el final libro con una descripción básica, pensé que desarrollar una aplicación reproductor de vídeo que le permiten comprender el proceso de construcción de una aplicación.

En este capítulo se utiliza diversos conceptos y tecnologías aprendidas en los capítulos anteriores. Recomiendo la lectura de esos primero a menos que simplemente tienen curiosidad acerca de los tipos de aplicaciones que puede desarrollar el uso de Flash y PHP o ya tienen alguna familiaridad con Flash y PHP.

Este capítulo está dividido en cinco partes, cada edificio en la sección anterior y que resulta en un reproductor de vídeo completo, PHP conducido. También puede tomar los conceptos y los componentes desarrollados en este capítulo y utilizarlos en sus propios proyectos. Por ejemplo, el componente de acceso será desarrollado como un módulo independiente, que le permite caer en otra aplicación con la modificación de muy poco.

Construir un reproductor de video básico

Flash ofrece una gran variedad de funcionalidad. Las posibilidades de lo que se puede desarrollar la utilización de Flash sólo están limitadas por el tiempo y la imaginación.

El vídeo es un activo muy valioso en la Internet con el avance de las conexiones de banda ancha de alta velocidad. Flash es la mejor manera de transmitir vídeo a causa de la amplia disponibilidad de Flash Player para todos los navegadores web más populares.

Flash permite a los desarrolladores a construir un reproductor de vídeo y estar seguro de que la mayor audiencia posible será capaz de verla. Además, no hace daño que Adobe ha desarrollado un completo y funcional reproductor de vídeo única que permite a los desarrolladores incorporar fácilmente en un proyecto existente.

De hecho, la construcción de un reproductor de vídeo básico en Flash, como se muestra en la Figura 17.1. requiere de muy pocas líneas de código.

Comience arrastrando un componente FLVPlayback del panel Componentes al escenario. Dar a este nuevo jugador el nombre de instancia myPlayer y abrir el panel de Acciones.

Para simplificar, utilice uno de los archivos de muestra de vídeo que Adobe ofrece para las pruebas:

420

www.helpexamples.com/flash/video/water.flv

FIGURA 17.1 Componente de vídeo FLVPlayback aparece en el escenario

El siguiente paso es establecer la propiedad de origen del reproductor de vídeo, señalando la muestra del archivo FLV:

myPlayer.source = “http://helpexamples.com/flash/video/water.flv”;

Pruebe la película y usted debería ver la carga de vídeo de muestra, a continuación, se inicia automáticamente la reproducción.Felicitaciones, ha desempeñado un FLV en Flash, utilizando el reproductor de componentes vídeo prediseñados.

El reproductor de vídeo tiene una colección bastante grande de los métodos y propiedades, pero algunos de los más comunes están relacionados con el control de la reproducción. Por ejemplo, recuerda cómo el video reproduce una vez que se cargó? Esto no puede ser el resultado deseado todo el tiempo, de modo que el reproductor de vídeo te permite modificar este comportamiento, establezca la propiedad autoPlay a false.

myPlayer.source = “http://helpexamples.com/flash/video/water.flv”;myPlayer.autoPlay = false;

Ahora, cuando se carga el vídeo, espera a una llamada al método de juego antes de que comience la reproducción. Esta funcionalidad es más comúnmente utilizado en sitios de Internet interactivos para garantizar el vídeo o el sonido no conseguir a nadie en problemas mientras se visualiza un sitio. Normalmente, iniciado por el usuario hace clic en un botón o algo similar, vamos a mejorar la funcionalidad y añadir un evento de ratón para iniciar el vídeo.

Usted puede empezar por añadir un botón al escenario y le da el nombre de instancia de myPlayBtn. A continuación, modifique el código y añadir la función de controlador de ratón:

myPlayer.source = “http://helpexamples.com/flash/video/

421

http://www.helpexamples.com/flash/video/water.flv

water.flv”;myPlayer.autoPlay = false;

myPlayBtn.addEventListener(MouseEvent.CLICK,beginPlaybackHandler);

function beginPlaybackHandler(e:MouseEvent):void{myPlayer.play();}

También quiere que sus usuarios puedan para detener la reproducción de un vídeo. Esto es casi idéntico al proceso de reproducción de un vídeo.

Empiece por agregar otro botón para el escenario, con el nombre de instancia myStopBtn. Luego se agrega el nuevo controlador de eventos y asignar al botón Stop, tales como:

myPlayer.source =“http://helpexamples.com/flash/video/water.flv”;myPlayer.autoPlay = false;

myPlayBtn.addEventListener(MouseEvent.CLICK,beginPlaybackHandler);

function beginPlaybackHandler(e:MouseEvent):void{myPlayer.play();}

myStopBtn.addEventListener(MouseEvent.CLICK,stopPlaybackHandler);

function stopPlaybackHandler(e:MouseEvent):void{myPlayer.stop();}

Para simplificar, el componente de un reproductor de vídeo tiene la capacidad de ser de piel, lo que significa que usted no tiene que diseñar una interfaz personalizada. Esto carga la costumbre de la piel en un conjunto predeterminado de los controles de reproducción.

De hecho, Adobe ofrece una gran lista de skins, cada una en diferentes colores o con varias selecciones de botones y funcionalidad. Por ejemplo, aquí es el ejemplo más común utilizada. Esta piel es un conjunto completo de controles que se coloca debajo de la componente de reproductor de vídeo. Viendo que esta piel tiene controles de reproducción básica, puede reemplazar el controlador de ratón existentes y utilizar la versión interna:

myPlayer.source = “http://helpexamples.com/flash/video/water.flv”;myPlayer.autoPlay = false;myPlayer.skin = “SkinUnderPlayStopSeekMuteVol.swf”;

NOTA La piel de un reproductor de vídeo debe estar en el mismo directorio que el SWF. También puede establecer la piel utilizando el Inspector de componentes.

422

La piel se puede encontrar en el mismo directorio que la película Flash una vez que seleccione al menos una piel de el inspector de propiedades.

Como puede ver, la funcionalidad del reproductor de vídeo componente permite crear un jugador de base con bastante rapidez. El problema con este componente se encuentra cuando se desea jugar más de un vídeo o incluso añadir categorías de videos.

Afortunadamente, Adobe desarrolló un componente maravilloso e incluso hizo fácil de usar en los proyectos de desarrollo personalizados, que se aprende a hacer más adelante en este capítulo. Va a crear y agregar la funcionalidad adicional que desee.

Construir un reproductor de video en Flash y PHPEn la sección anterior aprendió a desarrollar un reproductor de vídeo de base, con un archivo de fuente no modificable, y ha funcionado bastante bien. El problema no es, este resultado es escalable y realmente no ofrece ningún tipo de reutilización, que es crucial cuando se construye una aplicación.

Como empezar

La aplicación de reproductor de vídeo que se desarrollan en esta sección ha sido diseñada, como se muestra en la figura 17.2, de modo que usted pueda centrarse en la parte de desarrollo.

El reproductor de vídeo precompilados está disponible en el sitio Web del libro, donde también se puede encontrar la aplicación completa para tener una idea de lo que será el edificio como un producto acabado.

Este reproductor de vídeo está dividido en tres partes. La primera parte es el componente de MySQL, que almacena las referencias de vídeo y las categorías.

423

FIGURA 17.2 Ejemplo del diseño del reproductor de vídeo que va a trabajar en este capítulo

Construcción de tablas de la base de datos y MySQL

Comience por abrir el editor de base de datos favorita y crear una nueva base de datos para este proyecto. Usted puede nombrar a esta base de datos nada que usted prefiera. Yo book_videoplayer, pero eso es sólo una sugerencia.

Después que la base de datos es creada, puede empezar a añadir la estructura del esquema de la tabla para los videos y las categorías de datos. Para esta aplicación los cuadros ya han sido definidos, pero no dude en buscar los entregó a una mejor comprensión de lo que son responsables.

Los cuadros de esta aplicación se dividen para asegurarse de que se optimizan y entender fácilmente que el cuadro es el responsable de cada tarea. Es mejor dividir la funcionalidad en varias tablas, también conocida como la normalización. Así, asegura que su base de datos será la más eficiente y le permite ampliar.

La estructura de la tabla en esta aplicación es sencilla. Por ejemplo, el nombre del vídeo, la descripción, y la fuente de referencias se encuentran en la tabla de videos, que se construye similar a la siguiente:

424

CREATE TABLE `videos` (ìd` int(11) NOT NULL auto_increment,`catId` int(11) default NULL,`name` varchar(200) default NULL,`src` varchar(200) default NULL,`description` text,`count` int(11) default 0,àctive` varchar(1) default ‘1’,PRIMARY KEY (ìd`)) ENGINE=MyISAM;

Como puede ver, este cuadro no es nada especial, pero maneja el núcleo de la gestión de aplicaciones.Usted puede agregar más columnas si usted decide que quiere ampliar la aplicación original.

Como puede ver, este cuadro no es nada especial, pero maneja el núcleo de la gestión de aplicaciones.Una base de datos no es la única opción de almacenamiento. Usted puede utilizar un archivo XML o incluso codificar los caminos de vídeo en Flash, pero la idea es desarrollar una aplicación ampliable. Esto significa que la base de datos es la opción más lógica para almacenar el vídeo y los datos de categoría. La base de datos también ofrece la capacidad de expandirse y crecer a medida que agrega más características para su aplicación.

El segundo cuadro tiene que agregar es la tabla de categorías, que almacena un identificador usado en el código PHP en la siguiente sección y el nombre de la categoría que se muestra en la aplicación Flash.

CREATE TABLE `categories` ( ìd` int(11) NOT NULL auto_increment, `name` varchar(100) default NULL, àctive` varchar(1) default ‘1’, PRIMARY KEY (ìd`) ) ENGINE=MyISAM;

Adición de datos de ejemplo para las tablas

Ahora puede rellenar a las tablas a prueba de todo, como se muestra en la Figura 17.3. Usted puede utilizar su editor favorito de la base de datos y agregar los datos de ejemplo a mano, o utilizar el comando INSERT siguiente muestra que añadir unas pocas categorías y vídeos:

INSERT INTO categories (name) VALUES (‘Category 1’);INSERT INTO categories (name) VALUES (‘Category 2’);INSERT INTO videos (catId, name, src, description)VALUES (1, ‘Sample Video 0:1’, ‘sample.flv’, ‘Cool VideoHere’);INSERT INTO videos (catId, name, src, description)VALUES (2, ‘Sample Video 0:2’, ‘sample.flv’, ‘Cool VideoHere’);

425

FIGURA 17.3 Datos de la tabla de ejemplo se muestra en el MySQL Query Browser

Probar la base de datos

Después de cargar los datos en la base de datos que puede probarlo. Esto puede hacerse mediante la creación de un archivo PHP simple que se conecta a la base de datos y ejecuta una consulta muy simple. Usted ha aprendido cómo conectarse a la base de datos en los capítulos anteriores. Para este ejemplo, es necesario definir los detalles de conexión y realizar una llamada a la función mysql_connect.

<?php

$link = mysql_connect(‘localhost’, ‘root’, ‘password’);mysql_select_db(‘book_videoplayer’, $link);

?>

Cuando se establece la conexión, el siguiente paso es construir la consulta SQL.

426

<?php


$catID = 1;$query = sprintf(“SELECT * FROM categories where id=%d”, $catID);

?>

El último paso es devolver algo. Para simplificar, vamos a mostrar uno de los nombres de categoría.

<?php


$catID = 1;$query = sprintf(“SELECT * FROM categories where id=%d”, $catID);

$result = mysql_query($query, $link);$row = mysql_fetch_array($result);

print “Category Name: <strong>” . $row[‘name’] . “</strong>”;

?> Guardar este archivo como sqltest.php en su casa directorio del servidor Web y acceder a ella mediante el navegador de Internet favorito. Cuando se ejecuta el archivo PHP, usted debería ver una salida similar a la siguiente:

Category Name: Category 1

Si usted ve cualquier otra cosa, asegúrese de comprobar los detalles de conexión. Si por alguna razón usted recibe una página en blanco, coloque la siguiente línea en la parte superior de su archivo a la fuerza de PHP para mostrar todos los errores posibles:

error_reporting(E_ALL);

Ahora que usted ha visto una consulta de MySQL, ejecuta utilizando la fecha para esta aplicación, intente llamar a dos tablas y probar la funcionalidad de la aplicación final tendrá. Las dos únicas líneas de código que necesitan ser modificados son la consulta SQL y la salida.

<?php


$catID = 1;$query = sprintf(“SELECT v.name FROM videos v, categories c WHEREv.catId=c.id AND c.id=%d”, $catID);

$result = mysql_query($query, $link);

while($row = mysql_fetch_array($result))

427

{print “Video Name: “ . “<strong>” . $row[‘name’] . “</strong>”;}

?> Al ejecutar este código, debe presentarse una lista de vídeos para esa categoría específica. Este código busca en la categoría de vídeo y tablas y devuelve todos los vídeos que los identificadores comparten la misma. Este es el más básico de unirse a las tablas de MySQL, pero funciona perfectamente para esta aplicación.

Integración remota

El siguiente paso es construir el PHP reales que serán llamados por el uso de Flash Remoting. De hecho, esta sección es similar en el hecho de que va a utilizar AMFPHP. Pero la parte más allá de este desarrollo real es diferente.

CROSS--REF Más información sobre la interacción remota se puede encontrar en el capítulo 8.

La ventaja de la construcción de esta aplicación que utiliza interacción remota es que te da la posibilidad de probar más fácilmente. Esto es porque usted puede construir las clases AMFPHP y luego probarlos mediante el código PHP estándar o el visor de navegador incluido que se incluye con AMFPHP.

Usted también tiene la capacidad de reutilizar estas clases en otros proyectos o con las porciones de código HTML del mismo proyecto. Por ejemplo, suponga que desea crear un panel de usuario que puede mostrar las últimas películas de una categoría específica. Usted puede hacer esto mediante la construcción de una página HTML muy básico y llamar a la clase de interacción remota para devolver los datos necesarios, al igual que lo haría en Flash.

Clase de conector de base de datos

Las clases en esta aplicación dependen de la base de datos. En lugar de definir los detalles de la conexión en todas las clases, es mejor construir una clase de conector de base de datos que es responsable de hacer la conexión inicial y almacenar las credenciales de conexión.

La clase de conector tiene cinco variables privadas. Los cuatro primeros definen la información de conexión.

<?php

class DatabaseConnector{

private $host = “localhost”;private $user = “root”;private $pass = “password”;private $dbName = “book_videoplayer”;

}

?>

La quinta variable se utiliza para almacenar el enlace de la base de datos de identificación de recursos.

private $link = null;

El constructor para esta clase está vacía, porque las variables privadas se definen previamente.428

function DatabaseConnector() { }

El método de conexión privada sólo es llamado cuando una conexión existente no se encuentra. Este método pasa en los detalles de una conexión privada y almacena el identificador de recurso en el $this-> propiedad de enlace, que sólo es visible a esta clase.

private function connect(){$this->link = mysql_connect($this->host, $this->user, $this->pass);mysql_select_db($this->dbName, $this->link);}

El segundo método, getConnection, se establece como pública para otras clases tienen acceso a ella. Sin embargo, los comentarios que lo definen como privado para garantizar las clases remoto no puede acceder a él. Este método comprueba en primer lugar para un recurso de la conexión ya existente, y si uno no se encuentra, se hace una llamada al método connect.

El último paso de esta función es devolver el recurso de conexión activa, que se utiliza en otras clases.

/*** Get database connection* @access private* @returns database link, to be used in other sql calls*/public function getConnection(){if($this->link == null){$this->connect();}

return $this->link;}

Como puede ver, esta clase es muy útil, ya que se encarga de almacenar la conexión de base de datos.Además, si uno no se encuentra, se crea una.

Esta es la clase completa, que debe ser guardado como DatabaseConnector.php en el directorio del proyecto por lo que se puede acceder por las otras clases.

<?php

class DatabaseConnector{

private $host = “localhost”;private $user = “root”;private $pass = “password”;private $dbName = “book_videoplayer”;

private $link = null;

function DatabaseConnector() { }

429

private function connect(){$this->link = mysql_connect($this->host,$this->user,$this->pass);mysql_select_db($this->dbName, $this->link);}

/*** Get database connection* @access private* @returns database link, to be used in other sql calls*/public function getConnection(){if($this->link == null){$this->connect();}

return $this->link;}

}

?>

Clase Video

Ahora que la clase de conector de la base de datos se completa, la próxima clase a desarrollar es la gestión de los videos. Esta clase devuelve la lista de vídeo basado en vídeo o ID de categoría.

La primera parte de esta clase es para cargar en el archivo de conector de base de datos, que esta clase de vídeos se extenderá.

<?php require_once ‘DatabaseConnector.php’; ?>

Usted puede recordar se extiende desde las clases de ActionScript que han desarrollado en los ejemplos anteriores.La sintaxis de PHP es idéntico. Básicamente, definir la clase y cualquier clase que se extenderá, de forma similar a la siguiente:

<?php

require_once ‘DatabaseConnector.php’;

class Videos extends DatabaseConnector {

}

?>

430

La clase de vídeo tiene un método, getVideos. Este método acepta un vídeo y un ID de categoría por separado como argumentos para determinar qué videos para volver.

/** * get videos * @access remote * @returns array of videos */ function getVideos($categoryID=-1, $videoID=-1) { ... }

La primera parte de este método para comprobar las necesidades de identificaciones válidas para garantizar el SQL no se verá comprometida.Este paso no es obligatorio, pero asegura que su aplicación sea más seguro.

if($categoryID == -1 || strlen($categoryID) == 0) { trigger_error(“Category ID required to return video list”); }

Esta declaración pide trigger_error si un identificador de categoría no válido o no se pasa in. La razón para usar el trigger_error es porque AMFPHP graciosamente detiene todo el proceso aún más y devuelve el error deseado para la secuencia de comandos de llamada, en este en este caso, que será de ActionScript.

El siguiente paso es asignar las variables de este método y crear una matriz que contendrá los datos de vídeo que se pasa de nuevo a ActionScript.

$vidSQL = “”; $rows = array();

Una vez que los fundamentos se han definido, el siguiente paso es determinar si la secuencia de comandos debe estar buscando un video único o una lista de ellos. Esto asigna el SQL correcto si el código sólo se debe buscar un vídeo.

// look for specific video? if($videoID != -1 && strlen($videoID) != 0) { $vidSQL = “ AND v.id=” . $videoID; }

El enlace de base de datos puede ser definido simplemente haciendo una llamada al método getConnection de la clase de DatabaseConnector porque la clase de vídeo se está extendiendo. La variable local $link se le asigna la conexión activa que se utiliza en el resto de la interacción dentro de esta función de MySQL.

$link = $this->getConnection();

La consulta de la base de datos es bastante complejo, ya que los controles dos tablas de datos y devuelve una lista de vídeos sobre la base de ese cheque. Esta consulta es similar a la que construyó cuando se prueba la base de datos al comienzo de esta sección. Esta consulta utiliza el $vidSQL, que o bien será una adición válida a la de SQL o una cadena en blanco cuando no buscas un vídeo concreto.

431

$query = sprintf(“SELECT v.name, v.src, v.id as ‘vid’, c.name as ‘cat’, v.description, v.count FROM categories c, videos v WHERE v.catId=c.id AND v.catId=%d AND v.active=1 “ . $vidSQL, $categoryID);

La parte especial de esta consulta SQL es la modificación de los nombres de columna, como la

v.id as ‘vid’

Esto se hace porque el conjunto de resultados tiene el nombre de identificación en las tablas y sólo un nombre pueden ser devueltos. Si se mantiene el estándar de nomenclatura sólo tendrán acceso a una tabla de información de identificación.Saber que uno será devuelto es una cuestión de orden que se les llama en. El cambio de nombre sólo modifica el conjunto de resultados, por lo que no tiene que preocuparse de los datos originales se vean afectados.

El siguiente paso es ejecutar la consulta de MySQL y recuperar los resultados, que luego a través de bucle y se pasa de la función como una matriz multidimensional.


Antes de que se ejecute el bucle, es una buena idea para algunas filas fueron devueltos por la consulta. El incumplimiento de esta comprobación simple podría resultar en un bucle sin fin. Esto puede dañar el servidor Web, ya que muy probablemente no darse cuenta de que está ocurriendo.

Esta sencilla comprobación se hace comprobando el número de registros devueltos con la función mysql_num_rows. Esta función devuelve un valor numérico que representa el número de filas devueltas en la consulta.

if(mysql_num_rows($result) == 0) { trigger_error(“No videos found”); return false; }

Suponiendo que un conjunto de resultados válidos se encuentra, el siguiente paso es recorrer los resultados y llenar la variable de matriz que se definió anteriormente.

while($row = mysql_fetch_array($result, MYSQL_ASSOC)) { array_push($rows, $row); }

El último paso de esta función es devolver la matriz de datos de vídeo. Este método no llegar a este punto, salvo que los datos válidos de vídeo está listo para ser aprobado de nuevo.

432

return $rows;

Eso es todo lo que hay en la clase de vídeo. Este archivo debe ser guardado como Videos.php. Esta es la clase completa, que también se puede encontrar en el código del libro en el sitio Web.

<?php


class Videos extends DatabaseConnector {

/** * get videos * @access remote * @returns array of videos */ function getVideos($categoryID=-1, $videoID=-1) { if($categoryID == -1 || strlen($categoryID) == 0) {trigger_error(“Category ID required to return video list”); }

$vidSQL = “”; $rows = array();

// look for specific video? if($videoID != -1 && strlen($videoID) != 0) { $vidSQL = “ AND v.id=” . $videoID; }


$query = sprintf(“SELECT v.name, v.src, v.id as ‘vid’, c.name as ‘cat’, v.description, v.count FROM categories c, videos v WHERE v.catId=c.id AND v.catId=%d AND v.active=1 “ . $vidSQL, $categoryID);


if(mysql_num_rows($result) == 0) { trigger_error(“No videos found”); return false; }

while($row = mysql_fetch_array($result, MYSQL_ASSOC)) { array_push($rows, $row);

433

}

return $rows; }

}

?>

La segunda clase de este ejemplo es la clase de categoría, que también tiene un método. Este método es responsable de devolver todas las categorías activas para el reproductor de vídeo.

Antes de que se cree el método, debe cargar en la conexión de bases de datos, exactamente igual que lo hizo en la clase de vídeo.


La primera parte del método getCategories es responsable de la creación de una nueva variable $rows que llevará a cabo es regresar de la base de datos las categorías. La variable de enlace se llena con una conexión de base de datos activa, que será utilizado en las llamadas SQL siguiente.

$rows = array(); $link = $this->getConnection();

La consulta SQL básicamente tira en todas las categorías que están activas, es decir, la columna activa se establece en un valor de 1. Esta consulta SQL se pasa luego a mysql_query que es responsable de la ejecución de la llamada realidad de SQL.

$query = “SELECT id, name FROM categories WHERE active=1”; $result = mysql_query($query, $link);

Si en los controles de la declaración de al menos una fila válida antes de continuar y generará un error si no se encuentran filas válida. Suponiendo se encuentran filas válidas, un bucle while se utiliza para llenar las filas de la variable $rows y una vez que el bucle se completa la variable $rows se devuelve.

if(mysql_num_rows($result) == 0) { trigger_error(“No categories found”); return false; }


return $rows;

Eso es todo lo que hay en la clase de categoría y, como se puede ver la estructura de la clase de categoría es bastante similar a la clase de vídeo en la sección anterior.

Esta es la clase Categoría completado:

<?php

434


class Categories extends DatabaseConnector {

/** * get categories * @access remote * @returns array of categories */ function getCategories() { $rows = array();


$query = “SELECT id, name FROM categories WHERE active=1”;


if(mysql_num_rows($result) == 0) { trigger_error(“No categories found”); return false; }


return $rows; } }

?>

Probar las clases

En este punto, ambas clases de servicio AMFPHP se han escrito. Usted puede rápidamente probar el uso de ellos o pasar a la parte de ActionScript el desarrollo de esta aplicación. Prueba de la clase es muy simple: básicamente crear un archivo PHP, llame el vídeo o el método de la categoría, e imprimir el resultado.

Por ejemplo, aquí está una prueba simple, también conocida como unidad de pruebas:

<?php

include ‘amfphp/services/Videos.php’;

$videos = new Videos();

$list = $videos->getVideos(1);

print_r($list);

?>

435

Si ejecuta este ejemplo en su navegador debería ver una salida similar al siguiente ejemplo:

Array ( [0] => Array ( [name] => Sample Video 1:1 [src] => sample.flv [vid] => 1 [cat] => Category A [description] => Really Cool Video Here [count] => 0 )

... )

Ahora debe tener dos clases completas que se pueden utilizar en el código ActionScript para interactuar con el contenido de la base de datos. El siguiente paso es construir la porción de ActionScript de la solicitud, que es manejado por las clases externas para la reutilización.

Desarrollar un reproductor de video avanzado

En las secciones anteriores de este ejemplo, usted desarrolló la base de datos y tablas. Luego construyó los servicios de PHP que interactúan con las tablas de base de datos. El siguiente paso es desarrollar el ActionScript que se encarga de mostrar y gestionar el reproductor de vídeo.

Si nos fijamos en el reproductor de vídeo, como se muestra en la Figura 17.4, en el escenario de Flash te darás cuenta de que hay cuatro partes: el principal componente de reproductor de vídeo, caja de información, lista de vídeos, y el menú desplegable que almacenará las categorías de vídeo. Si desactiva todo haciendo clic en el escenario o presionando la tecla Esc, una clase de documento con el nombre VideoPlayer aparece.

Esta clase es donde la mayoría del reproductor de vídeo es dirigido desde, en lugar de tener el código directamente en la línea de tiempo. Esto también le da la opción de desarrollar en un editor externo, como FDT, o puede utilizar el editor independiente que se incluye con Flash.

Crear la clase de documento

Comience por crear un nuevo archivo de ActionScript con el editor de ActionScript en Flash y el nombre que VideoPlayer.as. Guardar este archivo en el directorio de su aplicación en la FLA está situado a asegurar que el archivo se cargará. También puede utilizar el archivo de ActionScript que se proporciona en la fuente del libro en el sitio Web.

436

FIGURA 17.4 Un reproductor de vídeo que ya ha sido diseñado para usted

Después que este archivo de ActionScript se crea y se guarda, es el momento para empezar a desarrollar el núcleo de secuencias de comandos que controla el reproductor de vídeo. Empezar por construir la clase de esquema y ampliar la clase de la clase MovieClip, que se requiere para una clase de documento.

package { import flash.display.MovieClip; public class VideoPlayer extends MovieClip {} }

Ahora que se construye el esquema básico de clase, puede empezar a construir la funcionalidad actual. Además de la clase MovieClip, necesita importar dos clases. La clase de evento se utilizarán para todos los de gestión de eventos de base, y el paquete net.* incluirá todas las clases necesarias para comunicarse con el servicio remoto.

437

import flash.events.Event; import flash.net.*;

Esta clase VideoPlayer tendrá que tener algunas propiedades definidas, que se almacenan como privado para garantizar que sean protegidos y no pueden ser modificados accidentalmente por clases externas. La segunda propiedad almacenará el NetConnection activa, que se utiliza para interactuar con el servicio remoto. Vas a trabajar con esto en la siguiente sección de código.

private var gatewayURL:String; private var gateway:NetConnection; private var selectedCatID:Number;

VideoPlayer constructor

La función de constructor es responsable de la inicialización de algunas propiedades, que modifica la parte visual de la pantalla del reproductor de vídeo, y llamando al método de la categoría.

function VideoPlayer() { gatewayURL = “http://localhost/amfphp/gateway.php”; getCategories(); videoPlayer.visible = false; videoListCombo.enabled = false; }

Método getCategories

El siguiente método en la clase VideoPlayer es getCategories(), que se llama desde el constructor cuando la aplicación se inicializa. Este método comienza por la creación de una nueva instancia del Responder, que se encarga de la respuesta del servicio remoto.

public function getCategories():void { var responder:Responder = new Responder( categoryResponseHandler, onFault ); }

Una vez definido el respondedor, el siguiente paso es asignar la puerta de entrada a una nueva instancia de la clase NetConnection. Aquí es donde la llamada real al servicio remoto comienza.

public function getCategories():void { var responder:Responder = new Responder( categoryResponseHandler, onFault ); gateway = new NetConnection(); }

438

Después que el gateway ha sido debidamente asignado, el siguiente paso es conectar con el servicio remoto, pasando la ruta de puerta de enlace como el único argumento.

public function getCategories():void { var responder:Responder = new Responder( categoryResponseHandler, onFault );

gateway = new NetConnection(); gateway.connect(gatewayURL); }

El último paso en el método getCategories es hacer la llamada remota. Esto define el servicio que desea conectarse, así como pasa a lo largo de los encuestados que manejan tanto el éxito y el fracaso respuestas.

public function getCategories():void { var responder:Responder = new Responder( categoryResponseHandler, onFault );

gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Categories.getCategories”, responder); }

Método categoryResponseHandler

Ahora que el método getCategories se completa, el siguiente método a desarrollar es el categoryResponseHandler, que se definió en la instancia Responder. Este método se llama cuando un conjunto de registros válidos se devuelve desde el servicio remoto.

private function categoryResponseHandler(response:Object):void { ... }

El contenido de esta clase de manejar la respuesta de los datos del servicio remoto y rellenar el ComboBox usando estos datos de referencia de vídeo. El primer paso es permitir que el ComboBox, de lo contrario no será capaz de añadir nuevos contenidos a la misma.

videoListCombo.enabled = true;

Una vez que el ComboBox está habilitada, el siguiente paso es añadir el primer elemento, que informa al usuario seleccionar una opción. Esta opción por defecto tendrá un valor de -1 para alertar de que no es una identificación válida. Usted podría utilizar 0, aparte del hecho de que es una identificación válida en la base de datos.

videoListCombo.addItem({label:’Choose a Category...’, data:-1});

439

Un bucle for each se construye para manejar todos los elementos de respuesta. Este se encargará de cualquier número de elementos de vídeo, que es esencial porque el servicio remoto no devuelve el mismo número cada vez, ya que no todas las categorías tiene la misma cantidad de videos.

for each(var item in response) { videoListCombo.addItem({label:item.name, data:item.id}); }

Este bucle se toma cada elemento en el objeto de respuesta y le asigna el nombre y la identificacion de los valores ComboBox. Esto llena el ComboBox y permite al usuario seleccionar una categoría de vídeo.

El último paso del método categoryResponseHandler es asignar el detector de eventos para el ComboBox. Este evento se activa cuando el elemento seleccionado de los cambios del componente ComboBox.

videoListCombo.addEventListener(Event.CHANGE, categoryHandler);

Método categoryHandler

El método categoryHandler se llama cuando el usuario selecciona un elemento diferente en la instancia del componente ComboBox.

private function categoryHandler(e:Event):void { ... }

Este método controla el proceso de validación de la categoría seleccionada id. El identificador de categoría real se encuentra en la propiedad selectedItem del el evento passed-in.

var id:Number = e.currentTarget.selectedItem.data;

Este ID de la categoría es validado mediante una sentencia condicional que los controles básicos por un valor de -1, que fue asignado al item por defecto.

if(id == -1) return;

Si el valor no se encuentra, entonces sabes el ID es válido, y el ID de la categoría se asigna a la propiedad selectedCatID facilita el acceso a la categoría actual ID.

selectedCatID = id;

Por último, una llamada al método getVideos se hace para cargar en la lista de vídeo basado en el ID actual.

getVideos();

Método getVideos

El método getVideos se llama cuando se encuentra una categoría válida. Este método se utiliza para hacer la primera llamada al servicio remoto, que se carga la lista correcta de vídeos a partir de la categoría almacenados en el método anterior.

La única parte de este método que es diferente del método getCategories son los parámetros pasados a la llamada al método y el éxito de la función asignada al Responder.

440

public function getVideos():void { var responder:Responder = new Responder( videosResponseHandler, onFault );

gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Videos.getVideos”, responder, selectedCatID, ‘’); }

Usted puede crear un controlador de conexión principal y pasar en estas propiedades diferentes, pero para simplificar, se utilizan varios métodos.

Método videosResponseHandler

Uno de los principales métodos en esta aplicación tendría que ser el videosResponseHandler.

private function videosResponseHandler(response:Object):void { ... }

Esto se debe a que el método es el responsable de cargar la lista de vídeos y poblar el componente ScrollPane con la costumbre de los activos de VideoListItem. Estos activos se encuentran en la biblioteca de Flash para este proyecto ya que se han completado para usted. Más adelante en este proyecto a desarrollar el código ActionScript que se adjunta a los activos.

La primera parte de este método es definir la variable nextY que las compensaciones de cada elemento de la lista de vídeo y crea un MovieClip vacío, que se asigna a la propiedad de origen de la instancia de ScrollPane.

var nextY:uint = 5;

var listItem:MovieClip = new MovieClip(); videoList.source = listItem;

La mayoría de este método se encuentra en el bucle for..each. Este bucle se ejecuta a través de cada elemento de la lista de respuesta de vídeo.

for each(var item in response) { ... }

Cada paso del bucle se crea una instancia VideoListItem nuevo. Estas instancias de obtener un controlador de eventos que se les asignen y una ubicación única en la lista utilizando la variable de nextY previamente definidos.

var videoListItem:MovieClip = new VideoListItem(); videoListItem.y = nextY; videoListItem.x = 2;

441

videoListItem.addEventListener(VideoListItem.ITEM_CLICK, listItemHandler);

La siguiente parte del bucle establece propiedades personalizadas del videoListItem que define el título, la descripción y vídeo a cargar cuando se hace clic en el artículo.

videoListItem.title = item.name; videoListItem.desc = item.description; videoListItem.videoObj = item; videoListItem.setItem(item.vid, ‘’, item.src);

Ahora que la instancia VideoListItem se ha completado, el siguiente paso es añadir a la lista de visualización ListItem, que lo hace visible en el ScrollPane.

listItem.addChild(videoListItem);

Cada paso de los incrementos de la variable de bucle nextY para asegurar que cada elemento de vídeo se coloca en una posición única. Este valor se determina mediante la adición de la altura del elemento de vídeo actual más un relleno ligero a la variable nextY existentes.

nextY += videoListItem.height + 2;

El último paso del método videosResponseHandler es para actualizar el componente ScrollPane llamando al método de actualización. Si usted no llama a este método, la barra de desplazamiento en el ScrollPane no reflejaría el vídeoelemento añadido.

videoList.update();

Como puede ver, el método de videosResponseHandler es responsable de gran parte de la funcionalidad en la lista de vídeo a pesar de que es sólo una parte de la aplicación en general. Se exigía una gran cantidad de código personalizado para crear correctamente.

Método listItemHandler

El método listItemHandler se llama cuando uno de los elementos de vídeo hace clic en el ScrollPane.

private function listItemHandler(e:Event):void { ... }

Este método actualiza la información de vídeo actual en el videoMetaInfo MovieClip encuentran por debajo del reproductor de vídeo.

videoMetaInfo.titleTxt.text = e.currentTarget.videoObj.name; videoMetaInfo.categoryTxt.text = e.currentTarget.videoObj.cat; videoMetaInfo.viewsTxt.text = e.currentTarget.videoObj.count; videoMetaInfo.descTxt.text = e.currentTarget.videoObj.description;

También es responsable de la sustitución de la fuente del reproductor de vídeo y la reproducción del vídeo nuevo.

442

videoPlayer.visible = true; videoPlayer.source = e.currentTarget.source; videoPlayer.play();

Gestión de errores en respuestas de interacción remota

El último método de la clase VideoPlayer es un controlador de errores en el servicio remoto. Este método no tiene que ser único a menos que prefiera para manejar cada error de forma diferente. Prefiero mostrar el contenido del error durante el desarrollo porque, como usted recordará, el trigger_error llamadas en el PHP, que devuelve un mensaje de error del usuario.

private function onFault(responds:Object):void { trace(“Debug::Error”); for(var i in responds) { trace(“ “ + responds[i]); } }

Para esta aplicación, el mensaje de error se traza durante el desarrollo y completamente ignorado cuando se ejecuta el mundo real. Más adelante en este capítulo, se crea un controlador de errores realista que es similar a los encontrados en el vídeo popular de compartir los sitios Web.

Ha completado la clase VideoPlayer entero, que es la mayoría de las aplicaciones de vídeo, al menos para la parte del proyecto de ActionScript.

Esta es la clase VideoPlayer en su totalidad, de esta manera puede mirar por encima de cómo cada uno de los métodos de interacción con los demás. Este código fuente también está disponible en el sitio Web del libro para que usted pueda cortar y pegar.

package { import flash.display.MovieClip; import flash.events.Event; import flash.net.*;

public class VideoPlayer extends MovieClip { private var gatewayURL:String; private var gateway:NetConnection; private var selectedCatID:Number;

function VideoPlayer() { gatewayURL = “http://localhost/amfphp/gateway.php”; getCategories();

videoPlayer.visible = false; videoListCombo.enabled = false;

443

}

public function getCategories():void { var responder:Responder = new Responder(categoryRespHandler, onFault);

gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Categories.getCategories”, responder); }

private function categoryRespHandler(response:Object):void { videoListCombo.enabled = true; videoListCombo.addItem( {label:’Choose a Category...’, data:-1} ); for each(var item in response) { videoListCombo.addItem( {label:item.name, data:item.id} ); }videoListCombo.addEventListener(Event.CHANGE, categoryHandler); }

private function categoryHandler(e:Event):void { var id:Number = e.currentTarget.selectedItem.data; if(id == -1) return;

selectedCatID = id;

trace(“Load Category ID: “ + id); getVideos(); }

public function getVideos():void { var responder:Responder = new Responder(videosResHandler, onFault);

gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Videos.getVideos”, responder, selectedCatID, ‘’ ); }

private function videosRespHandler(response:Object):void { var nextY:uint = 5;

var listItem:MovieClip = new MovieClip(); videoList.source = listItem;

444

for each(var item in response) { var videoListItem:MovieClip = new VideoListItem(); videoListItem.addEventListener( VideoListItem.ITEM_CLICK, listItemHandler ); videoListItem.y = nextY; videoListItem.x = 2;

videoListItem.title = item.name; videoListItem.desc = item.description; videoListItem.videoObj = item; videoListItem.setItem(item.vid,’’, item.src);

listItem.addChild(videoListItem);

nextY += videoListItem.height + 2;

videoList.update(); } }

private function listItemHandler(e:Event):void { var info:Object = e.currentTarget.videoObj; videoMetaInfo.titleTxt.text = info.name; videoMetaInfo.categoryTxt.text = info.cat; videoMetaInfo.viewsTxt.text = info.count; videoMetaInfo.descTxt.text = info.description;

videoPlayer.visible = true; videoPlayer.source = e.currentTarget.source; videoPlayer.play(); }

// Error Handler private function onFault(responds:Object):void { trace(“Debug::Error”); for(var i in responds) { trace(“ “ + responds[i]); } } } }

Construir la clase VideoListItem

El siguiente paso antes de que pueda probar la aplicación es la construcción de la clase VideoListItem. Si intenta ejecutar la aplicación en su forma actual, no sólo se obtiene errores, pero tampoco sería capaz de cargar cualquier video porque los artículos no son seleccionables en el momento.

445

El primer paso es crear un archivo de ActionScript en su editor favorito. Guardar este archivo como VideoListItem.as en el mismo directorio donde se ubica la FLA. Después de que el archivo se crea, usted necesita para construir el esqueleto del archivo de clase, que debe extender la clase MovieClip, ya que se adjunta a una instancia de MovieClip en la biblioteca.

package { import flash.display.MovieClip; public class VideoListItem extends MovieClip {} }

Además de la clase MovieClip que se importa, también deberá importar unas pocas clases de otros con el fin de desarrollar correctamente esta clase. Estas otras clases manejar el texto, eventos, y las partes del ratón sobre instancias del ítem de vídeo.

import flash.display.MovieClip; import flash.text.TextField; import flash.events.Event; import flash.events.MouseEvent;

La clase también debe tener algunas propiedades por defecto definida, que será modificado más tarde en la clase. La mayoría de las propiedades son las definiciones de cadena de base. Sin embargo, la última propiedad, ITEM_CLICK, es una especial constante público que se utiliza en el controlador de eventos. Esto se hace público para que la variable puede ser accedida fuera de la clase.

public var videoObj:Object;

private var _id:uint; private var _title:String; private var _desc:String; private var _thumb:String; private var _src:String;

public static const ITEM_CLICK:String = “onItemClick”;

VideoListItem constructor

El constructor de esta clase simplemente establece el alfa del tema hasta el 50 por ciento, pero debido a alfa es un valor de 0 a 1, el 50 por ciento es en realidad 0.5.

function VideoListItem() { alpha = 0.5; }

Método setItem

El primer método personalizado de esta clase es setItem. Este método se llama en la creación de una nueva instancia y se establece el id, laminiatura y los parámetros de fuente de vídeo. Para este ejemplo, la opción del thumb (miniatura) no se utiliza, pero se puede ampliar el ejemplo, porque ya se ha añadido.

446

function setItem(id:uint, thumb:String, src:String) { _id = id; _thumb = thumb; _src = src; }

La segunda parte del método setItem asigna a los detectores de eventos para el objeto del ratón. Aquí es también donde se habilita el icono del puntero del ratón cuando el usuario pasa el ratón sobre el elemento de vídeo.

function setItem(id:uint, thumb:String, src:String) { _id = id; _thumb = thumb; _src = src;

buttonMode = true; useHandCursor = true; addEventListener(MouseEvent.ROLL_OVER, overHandler); addEventListener(MouseEvent.ROLL_OUT, outHandler); addEventListener(MouseEvent.CLICK, clickHandler); }

Métodos de controlador de ratón

Los métodos de controlador de ratón se utilizan para modificar el valor alfa del elemento de vídeo. En este ejemplo, que básicamente establece el alfa plenamente visible o parcialmente visible. Desde aquí se puede añadir una interpolación a esta propiedad y tienen la propiedad de Alpha sin problemas el cambio.

private function overHandler(e:MouseEvent):void { e.currentTarget.alpha = 1.0; }

private function outHandler(e:MouseEvent):void { e.currentTarget.alpha = 0.5; }

El método clickHandler desencadena el evento ITEM_CLICK que alerta a los objetos de escuchar el clic. En este caso, el acto se notificará al VideoPlayer vídeo específico, y que se cargan.

private function clickHandler(e:MouseEvent):void { dispatchEvent(new Event(ITEM_CLICK)); }

El resto de los métodos de la clase VideoListItem son para obtener y establecer las propiedades previamente definidos. Por ejemplo, el título puede ser recuperado llamando a obtener el título, como el:

public function get title():String { return _title; }

447

También puede establecer la propiedad de título llamando ser title y que pasar en el título del vídeo.

public function set title(val:String):void { _title = val; titleTxt.text = val; }

Definición de los métodos getter y setter

El resto de métodos getter/setter aparecen en el siguiente código y también están en la clase completa disponible en la fuente de código del libro:

public function get id():uint { return _id; }

public function get source():String { return _src; }

public function get desc():String { return _desc; }public function set desc(val:String):void { _desc = val; descTxt.text = val; }

Eso es todo lo que hay en la clase VideoListItem. Como puede ver, es en su mayoría autónomos, que hace que este pequeño objeto reutilizable en otras aplicaciones. En este ejemplo, usted está construyendo un reproductor de vídeo, pero que podría cambiar fácilmente a un visor de productos, visor de documentos, o cualquier cosa que usted puede pensar.

Esta es la clase VideoListItem completa, que se puede estudiar o simplemente copiar y pegar desde el sitio Web del libro.

package { import flash.display.MovieClip; import flash.text.TextField; import flash.events.Event; import flash.events.MouseEvent;

public class VideoListItem extends MovieClip {

public var videoObj:Object;

private var _id:uint;

448

private var _title:String; private var _desc:String; private var _thumb:String; private var _src:String;

public static const ITEM_CLICK:String = “onItemClick”;

function VideoListItem() { alpha = 0.5; }

function setItem(id:uint, thumb:String, src:String) { _id = id; _thumb = thumb; _src = src;

buttonMode = true; useHandCursor = true; addEventListener(MouseEvent.ROLL_OVER, overHandler); addEventListener(MouseEvent.ROLL_OUT, outHandler); addEventListener(MouseEvent.CLICK, clickHandler); }

private function overHandler(e:MouseEvent):void { e.currentTarget.alpha = 1.0; }

private function outHandler(e:MouseEvent):void { e.currentTarget.alpha = 0.5; }

private function clickHandler(e:MouseEvent):void { dispatchEvent(new Event(ITEM_CLICK)); }

public function get id():uint { return _id; }

public function get source():String { return _src; }

public function get title():String { return _title; }public function set title(val:String):void { _title = val; titleTxt.text = val; }

449

public function get desc():String { return _desc; }public function set desc(val:String):void { _desc = val; descTxt.text = val; } } }

En este punto usted ha completado el reproductor de vídeo Flash y PHP. Ahora puede probar la aplicación, y podrás ver la misma interfaz que empezamos. La diferencia es, si selecciona una categoría, el ScrollPane se llenará con los videos de esta categoría.

A continuación, hacer clic en un elemento de vídeo y el vídeo comenzará a reproducirse. Tal como está, el reproductor de vídeo es una aplicación bastante robusto que puede ser ampliado.

En la sección siguiente que usted hará exactamente eso agregando un poco de seguimiento de base. Luego, en una sección posterior, se agrega un componente de entrada de los usuarios que los resultados en una aplicación en el mundo verdaderamente real, manteniendo la funcionalidad original del jugador.

Trabajar con seguimiento de video

En la sección anterior, se construyó un flash completo basado en un reproductor de vídeo de PHP que permite obtener un resultado dinámico. Esta aplicación permite al propietario proceda a actualizar la base de datos, y la aplicación Flash refleja estos cambios la próxima vez que se carga.

El problema viene cuando el dueño quiere saber qué vídeos son populares. Desea que el proyecto para ayudarle a determinar qué contenido de vídeo es muy popular por lo que puede agregar más contenido similar.

La solución es desarrollar el seguimiento de vídeo que registra cuántas veces un vídeo ha sido visto. Esto se hace por tener una columna en la base de datos que mantiene la cuenta activa. A continuación, añadir el apoyo necesario a las clases de PHP y, finalmente, la actualización de Flash para mostrar el número.

La base de datos no necesita ser actualizado, porque la columna de conteo fue agregado en la sección anterior, aunque no se utilizó. Agregar más columnas que va a utilizar para empezar es común para la aplicación tiene la capacidad de crecer. Columnas extra también puede ser el resultado de eliminar temporalmente una característica de una aplicación después de que el esquema de base de datos se crea.

Actualizar la clase de video

La clase de servicio de vídeos se creó en la sección anterior. Todo lo que tienes que hacer ahora es agregar el nuevo método utilizado para modificar el recuento de vídeo:

public function updatePlayCount($vid) { $link = $this->getConnection(); ...

450

}

Este método acepta un parámetro, que es una referencia a la id de vídeo que debe ser actualizada.La primera parte de este método crea un enlace a la base de datos utilizando la clase de base de datos existente, construido en la sección anterior. Esta variable $link se pasa en todas las acciones futuras de SQL en este método.

La segunda parte del método es crear una consulta SQL que agarra el recuento de reproducción actual del vídeo deseado.

public function updatePlayCount($vid) { $link = $this->getConnection(); $query = sprintf(“SELECT count FROM videos WHERE id=%d”, $vid); $result = mysql_query($query, $link); }

Comprobación de registros válidos

Después de que el valor está cargado, el siguiente paso es comprobar que un registro válido utilizando la función familiar mysql_num_rows.

public function updatePlayCount($vid) { $link = $this->getConnection();

$query = sprintf(“SELECT count FROM videos WHERE id=%d”, $vid); $result = mysql_query($query, $link);

if(mysql_num_rows($result) > 0) { ... } }

El contenido de esa declaración condicional cuando el valor se actualiza, según el recuento de determinar en la consulta SQL anterior.

$row = mysql_fetch_row($result); $count = $row[0]; $count++; $queryUpdate = sprintf(“UPDATE videos SET count=%d WHERE id=%d”, $count, $vid); mysql_query($queryUpdate, $link);

La consulta SQL que actualiza la base de datos se ha construido utilizando sprintf para pasar en limpio la cuenta y de identificación de vídeo, en lugar de la construcción de una cadena duro de leer, que es más común. El uso de sprintf es tanto más importante cuando vuelva a un proyecto más tarde.

En este punto, usted ha hecho todos los cambios en el archivo Videos.php y puede continuar con las modificaciones necesarias a las clases de ActionScript.

451

Adición de seguimiento de vídeo a ActionScript

La característica de seguimiento de vídeo puede ser añadido en uno de los dos lugares. Usted puede agregar la actualización que se ejecuta cuando el vídeo comienza a reproducirse, o bien añadir que lo que el recuento sólo se actualiza después de que el vídeo se ha visto totalmente. Cada opción tiene sus ventajas. Para este ejemplo, la llamada de seguimiento se hace cuando se solicita un nuevo vídeo, en lugar de esperar a que el vídeo completo. Esta acción es similar a un contador de visitas en un sitio Web, con la excepción de que no va a ser único en esta aplicación. Sin embargo, usted puede agregar el código necesario de los ejemplos anteriores para garantizar la actualización es única

Método updateVideoTracking

Los métodos de seguimiento se pueden agregar nuevas en cualquier punto de la clase VideoPlayer, sino un lugar lógico es sobre el método de onFault. La primera parte de este nuevo método es crear una nueva instancia de la clase Responder, pasando por el método de control de respuesta como el primer parámetro.

private function updateVideoTracking(vid:uint):void { var responder:Responder = new Responder( updateTrackingHandler, onFault ); ... }

Después que se crea una nueva instancia Responder, el siguiente paso es crear la conexión de puerta de enlace utilizando una nueva instancia de la clase NetConnection. Este proceso es idéntico al de otros remoto llamadas que ha realizado en la sección anterior.

private function updateVideoTracking(vid:uint):void { var responder:Responder = new Responder( updateTrackingHandler, onFault ); gateway = new NetConnection(); gateway.connect(gatewayURL); }

La actualización final para el método updateVideoTracking es donde se realiza la llamada al servicio remoto. La presente convocatoria se pasa a lo largo de la identificación de vídeos al día y la respuesta debe ser el nuevo contador o un error si algo sale mal.

private function updateVideoTracking(vid:uint):void { var responder:Responder = new Responder( updateTrackingHandler, onFault ); gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“Videos.updatePlayCount”, responder, vid); }

452

Una vez que se actualiza el recuento, el recuento de nuevo volvió a Flash. Al igual que las llamadas remoto anteriores, un controlador de respuesta es necesaria para la captura de esta respuesta. En este ejemplo, la cuenta de nuevo se envía a la TextField situado en el MovieClip videoMetaInfo para reflejar la cuenta actual.

private function updateTrackingHandler(response:Object):void { videoMetaInfo.viewsTxt.text = response.count; }

El último paso para agregar la función de rastreo es la de modificar el método de listItemHandler existentes y añadir en la llamada al método de actualización, tales como las siguientes:

private function listItemHandler(e:Event):void { ... updateVideoTracking(e.currentTarget.videoObj.vid); }

En este punto, la adición de seguimiento es completo. Como puede ver, el proceso de creación original en la primera sección permite realmente la capacidad de introducir nuevas funciones con actualizaciones mínimas.

Ahora, el reproductor de vídeo puede seguir correctamente los videos y le informará de qué vídeos son más populares que otros. Desde aquí se puede desarrollar un panel de administración, donde todos estos datos podría ser visto, o usted puede acceder a su editor de SQL y consultar la tabla de vídeos para la cuenta de activos de cada vídeo.

Construir un componente de Login de usuario en Flash

Ahora que el reproductor de video está bastante llena de características, es bastante seguro asumir el sitio Web debe exigir el registro para poder utilizar el reproductor. Agregar el registro es una cuestión de crear una forma básica y la actualización de una tabla de base de datos, nada que unas cuantas líneas de código no se puede lograr.

La parte más avanzada de esta función es necesario Flash para interactuar con el inicio de sesión de usuario. Para empezar, la aplicación Flash necesita para mostrar un panel de inicio de sesión cuando se inicie la aplicación y también tiene que desactivar la interfaz hasta que el usuario inicia la sesión correctamente.

De acuerdo con la idea de hacer el código reutilizable, vamos a desarrollar el componente de inicio de sesión en un archivo Flash y luego simplemente dejarlo en su lugar cuando se haya completado.

Comience por abrir la sesión de archivo de arranque de componentes, que ya tiene el diseño terminado para usted, como se muestra en la Figura 17.5. Todo lo que necesitas para estar preocupados es con el código detrás del componente de inicio de sesión.

453

FIGURA 17.5 El componente de inicio de sesión que ha sido previamente diseñado

Cuando el componente está abierto notará el movieclip en la biblioteca es asignado a una clase con un nombre de LoginWindow. No se puede personalizar esa clase por lo que necesita para crear un nuevo archivo ActionScript y guárdelo en la carpeta del proyecto con la FLA.

Construir la clase LoginWindow

Ahora que el archivo se crea puede empezar a construir el código de acceso. El primer paso es construir el esqueleto de la clase y extender el MovieClip, que es el mismo proceso que hemos seguido en los apartados anteriores.

Esta clase no sólo debe importar la clase MovieClip estándar, pero también va a requerir algunos nuevos. Estas nuevas clases se utilizarán para crear las acciones para deshabilitar la interfaz y el manejo de la interacción con el ratón.

454

package { import flash.display.MovieClip; import flash.geom.Rectangle; import flash.events.Event; import flash.events.MouseEvent; import flash.net.*;

public class LoginWindow extends MovieClip { function LoginWindow() { ... } } }

Las propiedades de esta clase son los responsables de la gestión de eventos y la creación de referencias a la MovieClips creados en tiempo de ejecución.

public var data:Object;

private var _visible:Boolean = false; private var container:MovieClip; private var blocker:MovieClip = null;

public static var LOGIN_ATTEMPT:String = “onLoginAttempt”;

LoginWindow constructor

El constructor de la clase LoginWindow es donde se establece la propiedad de contenedores. Aquí es también donde se encuentran los controladores de eventos para los botones. Esto se hace para asegurar que los botones se les asigna la vez visible para el código es estable.

function LoginWindow() { container = this;

loginMC.resetBtn.addEventListener(MouseEvent.CLICK, resetHandler); loginMC.loginBtn.addEventListener(MouseEvent.CLICK, loginHandler); }

Método redraw

El método redraw se llama cuando la interfaz cambia. Esto es principalmente una preocupación cuando el usuario tiene la posibilidad de redimensionar el escenario, aunque la mayoría de aplicaciones de sitios Web tienen un tamaño fijo. Este método tiene que tener algo de lógica en relación con el clip de bloqueo para asegurar que no se extrae más de una vez. El clip de bloqueo es un movieclip que elimina la interacción de la aplicación que obliga al usuario a iniciar sesión por "bloqueo" de los clics del ratón.

public function redraw():void {

455

if(blocker == null) { ... }else { ... }... }

El contenido de la condicional para cuando el clip de bloqueo es nulo señala a la MovieClip bloqueo real utilizando el incorporado en la API de dibujo.

blocker = new MovieClip(); blocker.alpha = 0.5; blocker.graphics.beginFill(0x000000); blocker.graphics.drawRect(0, 0, stage.stageWidth, stage.stageHeight);

Una vez que el clip ha sido elaborado, el siguiente paso es asignar los controladores de eventos falsos para el clip de bloqueo.Flash no tiene una interfaz nativa que se puede desactivar, porque el código puede ser personalizado.La forma de evitar esto es crear una pseudo-Disabler. Esto no es más que un MovieClip colocado en el escenario, que atrapa a todas las interacciones con el ratón y lo cancela. Esto evita que el interfaz subyacente y la aplicación que se utilice hasta que este clip de bloqueo se retira.

blocker.addEventListener(MouseEvent.ROLL_OVER, dummyHandler); blocker.addEventListener(MouseEvent.ROLL_OUT, dummyHandler); blocker.addEventListener(MouseEvent.CLICK, dummyHandler);

Después de la primera vez que la pantalla se vuelve a dibujar, el bloqueador que ya se han creado. Una anchura simple y ajuste de altura es la única actualización necesaria. De hecho, si se llama al método estándar de volver a dibujar sin la condicional, cada vez que se vería de otro clip de bloqueo a medida que comienzan a acumularse.

blocker.width = stage.stageWidth; blocker.height = stage.stageHeight;

Independientemente de si este es el primer paso del método de volver a dibujar o no, el clip de bloqueo debe ser reubicado. La ventana de inicio de sesión se coloca un punto muerto, lo que significa que puede calcular el relleno alrededor de ella, multiplica esto para crear un número negativo, y coloque el clip de bloqueo utilizando ese cálculo.

// reverse the offset to position blocker blocker.y = y * -1; blocker.x = x * -1;

Cuando todos los cálculos están completos, puede añadir el bloqueador de MovieClip a la DisplayList, que le hace visible en la aplicación.

addChild(blocker);

456

NOTA Hacer que todos los cálculos basados en la posición antes de que el clip se agrega a la lista de visualización minimiza el parpadeo y saltar los objetos en su aplicación.

Colocación de dos MovieClips

ActionScript 3 no tiene ningún tipo de gestión a fondo como lo que se encuentra en ActionScript 2 y sus predecesores. El equivalente está tomando el id de un clip y de intercambio con otro clip. Esta parece ser la gestión de profundidad, excepto por el hecho muy importante que ActionScript se encarga de la reordenación, cuando se intercambian los niños.

En este ejemplo, usted quiere asegurarse de que la casilla de ingreso está por encima del clip de bloqueo, porque si se coloca por debajo de ella, el usuario no es capaz de interactuar o acceder a la aplicación:

container.swapChildren(loginMC, blocker);

Centrar un MovieClip

El último paso del método consiste en volver a dibujar el centro de la casilla de ingreso en el escenario para asegurar que siempre está en el centro. Esta se actualiza constantemente cuando el método redraw (volver a dibujar) se llama, porque cambiar el tamaño de la etapa sería la casilla de ingreso sentarse en una posición no centrado.

loginMC.x = (stage.stageWidth / 2) - (loginMC.width / 2); loginMC.y = (stage.stageHeight / 2) - (loginMC.height / 2);

El cálculo utiliza las dimensiones del escenario y las dimensiones de caja de ingreso para determinar el punto medio. Aquí es donde el loginMC MovieClip se coloca cuando se completa el cálculo.

Método close

El método close tiene una tarea: para eliminar la casilla de ingreso actual y permitir la aplicación para ser utilizado una vez más. El proceso de eliminación se consigue mediante la eliminación del niño contenedor, que contiene el cuadro de acceso y bloqueo de MovieClip.

public function close():void { container.parent.removeChild(container); }

Método resetHandler

El método resetHandler se llama cuando se hace clic el botón de reinicio. Este método borra todos los mensajes de estado y se vacía la información de acceso y campos de contraseña.

private function resetHandler(e:MouseEvent):void { loginMC.username.text = “”; loginMC.password.text = “”; loginMC.responseTxt.text = “”; }

Método loginHandler

457

El método loginHandler se adjunta al evento Click del loginBtn. Este método se llama cuando el loginBtn se hace clic con el ratón.

private function loginHandler(e:MouseEvent):void { ... }

Este método es responsable de comprobar el nombre de usuario y contraseña para campos de datos válidos. Si uno de estos ámbitos está vacía, salir de la función y un mensaje de respuesta aparece debajo del campo de la contraseña.

loginMC.responseTxt.text = “”;

if(loginMC.username.text == “” || loginMC.password.text == “”) { loginMC.responseTxt.text = “username & password required”; return; }

Si el nombre de usuario y contraseña son campos con los valores aceptables, los valores se almacenan en la propiedad data, que será leído por el guión de llamadas en un controlador de eventos personalizados.

data = { username:loginMC.username.text, password:loginMC.password.text };

La última parte de este método es disparar un evento personalizado, alertando a la secuencia de comandos de llamada que un nombre de usuario y contraseña han sido capturados y deben ser validados.

dispatchEvent(new Event(LOGIN_ATTEMPT));

Este componente ha sido desarrollado para separar la pantalla y la lógica de la seguridad, lo que significa que el componente puede ser reutilizado, porque nada está codificada en la lógica de inicio de sesión real.

El último método real es un setter, que se utiliza para establecer la cadena en el exterior de respuesta. Este será llamado desde el loginHandler si la validación falla y no desea mostrar al usuario para que él o ella puede intentar otra contraseña o nombre de usuario.

public function set responseString(s:String):void { loginMC.responseTxt.text = s; }

El método dummyHandler no tiene ninguna funcionalidad. Se utiliza para bloquear los eventos de ratón que se producen en el movieclip de bloqueo. Este método es necesario porque un controlador de eventos necesita una función válida, y si se define un anónimo, se crea una pérdida de memoria lenta.

private function dummyHandler(e:MouseEvent):void { // no action

458

}

En este punto usted ha completado la clase LoginWindow y puede moverse a la siguiente etapa, que es crear alrededor de ActionScript sencillo para probar el componente. Cuando está debidamente probado se puede crear el servicio de PHP y el componente de inicio de sesión para interactuar con la base de datos que realmente buscan los usuarios reales de intentar iniciar sesión.

Esta es la clase LoginWindow completa.

package { import flash.display.MovieClip; import flash.geom.Rectangle; import flash.events.Event; import flash.events.MouseEvent; import flash.net.*;

public class LoginWindow extends MovieClip {

public var data:Object;

private var _visible:Boolean = false; private var container:MovieClip; private var blocker:MovieClip = null;

public static var LOGIN_ATTEMPT:String = “onLoginAttempt”;

function LoginWindow() { container = this;

loginMC.resetBtn.addEventListener(MouseEvent.CLICK, resetHandler); loginMC.loginBtn.addEventListener(MouseEvent.CLICK, loginHandler); }

public function redraw():void { if(blocker == null) { blocker = new MovieClip(); blocker.alpha = 0.5; blocker.graphics.beginFill(0x000000); blocker.graphics.drawRect( 0, 0, stage.stageWidth, stage.stageHeight ); blocker.addEventListener( MouseEvent.ROLL_OVER, dummyHandler );

459

blocker.addEventListener( MouseEvent.ROLL_OUT, dummyHandler ); blocker.addEventListener( MouseEvent.CLICK, dummyHandler ); }else { blocker.width = stage.stageWidth; blocker.height = stage.stageHeight; }

// reverse the offset to position blocker blocker.y = y * -1; blocker.x = x * -1;

addChild(blocker);

container.swapChildren(loginMC, blocker);

loginMC.x = (stage.stageWidth / 2) - (loginMC.width / 2);

loginMC.y = (stage.stageHeight / 2) - (loginMC.height / 2);

_visible = true; }

public function close():void { container.parent.removeChild(container); }

private function resetHandler(e:MouseEvent):void { loginMC.username.text = “”; loginMC.password.text = “”; loginMC.responseTxt.text = “”; }private function loginHandler(e:MouseEvent):void { loginMC.responseTxt.text = “”;

if(loginMC.username.text == “” || loginMC.password.text == “”) { loginMC.responseTxt.text = “username & password required”; return; }

data = { username:loginMC.username.text, password:loginMC.password.text

460

}; dispatchEvent(new Event(LOGIN_ATTEMPT)); }

public function set responseString(s:String):void { loginMC.responseTxt.text = s; }

private function dummyHandler(e:MouseEvent):void { // } } }

Probar el componente de login

El siguiente paso es poner a prueba el componente de inicio de sesión para asegurarse de que todo está funcionando correctamente. El primer paso es crear una nueva instancia del componente LoginWindow de forma autónoma FLA, o puede utilizar la muestra que se encuentra el archivo con el código del libro Código.

var login:LoginWindow = new LoginWindow();

Una vez creada la instancia, el siguiente paso es asignar un controlador de eventos para el evento personalizado LOGIN_ATTMEPT que se llama cuando el usuario escribe los datos en tanto el nombre de usuario y los campos de contraseña y luego haga clic en el botón Iniciar sesión.

login.addEventListener(LoginWindow.LOGIN_ATTEMPT, loginHandler);

Después de cargar el componente de ventana de inicio y el controlador de eventos adecuado es asignado, el siguiente paso es añadir a la lista de visualización, que hace visible.

addChild(login);

Asignar un controlador de evento de escena

Usted quiere asegurarse de que cualquier modificación a la etapa vuelve a dibujar el componente de acceso, o los artículos que están siendo bloqueados accidentalmente pueden situarse más allá del bloqueo de MovieClip.

stage.align = StageAlign.TOP_LEFT; stage.scaleMode = StageScaleMode.NO_SCALE; stage.addEventListener(Event.RESIZE, stageResizeHandler);

Después que el evento se asigna al objeto de escena, es necesario crear la función que se hace referencia en el detector de eventos. Para esta aplicación, el controlador simplemente hace una llamada al método de volver a dibujar el componente de acceso. En una aplicación en el mundo real puede que tenga más funcionalidad en este evento, pero por ahora esto está muy bien para las pruebas.

function stageResizeHandler(e:Event):void { login.redraw(); }

461

Manejo el intento (attempt) de acceso

La siguiente función se usa para manejar los intentos de acceso. Para simplificar, esta función tiene un nombre de usuario y contraseña predefinidos, que posteriormente se sustituye con un servicio remoto en la siguiente sección.

Si se llega a un inicio de sesión válida, se llama el método de cierre de la componente de acceso. Esto elimina el cuadro de inicio de sesión y permite la aplicación de ese período de sesiones.

function loginHandler(e:Event):void { if(login.data.username == “guest” && login.data.password == “pass”) { login.close(); } }

NOTA Esta aplicación no almacena los inicios de sesión, lo que significa el inicio de sesión es válida sólo para la sesión activa. Los usuarios tendrán que iniciar sesión cada vez que visitan la aplicación.

La función de loginHandler se encarga de los inicios de sesión con éxito, pero no notifica al usuario de un intento de acceso incorrecto. Esto se puede solucionar mediante la adición de una declaración más que actualiza el cuadro de respuesta en el cuadro de inicio de sesión.

function loginHandler(e:Event):void { if(login.data.username == “guest” && login.data.password == “pass”) { login.close(); }else { login.responseString = “username and password incorrect”; } }

El último paso es hacer la llamada inicial al evento resize señalar el componente de acceso para la primera vez. Usted también puede llamar al método de volver a dibujar directamente, en lugar de pasar por el evento resize.

stage.dispatchEvent(new Event(Event.RESIZE));

Aquí está el código completado para esta prueba. La mayoría de los componentes de conexión es manejado internamente pero ofrece facilidad de uso final.

var login:LoginWindow = new LoginWindow(); login.addEventListener(LoginWindow.LOGIN_ATTEMPT, loginHandler);

addChild(login);


462


function loginHandler(e:Event):void { trace(“Do Login”); trace(“Username: “ + login.data.username); trace(“Password: “ + login.data.password);

if(login.data.username == “guest” && login.data.password == “pass”) { trace(“user logged in”); login.close(); }else { login.responseString = “username and password incorrect”; } }

stage.dispatchEvent(new Event(Event.RESIZE));

Ahora que ha completado el código ActionScript necesario para la muestra, usted puede probar el componente de acceso. Debe aparecer una pantalla de acceso de inmediato y no ser capaz de interactuar con cualquier parte de la película, con exclusión de la pantalla de conexión, como se muestra en la Figura 17.6, hasta que escriba la dirección de acceso.

FIGURA 17.6 Ejemplo de aplicación que muestra el componente de inicio de sesión

463

Construir la clase de administrador de login en PHP

El siguiente paso en la construcción del sistema de acceso para conectarse a la base de datos de los usuarios, ya que un nombre de usuario y la contraseña codificada no es muy práctico y ciertamente no segura.

Creación de tablas MySQL del usuario

El primer paso es crear la mesa del usuario en la base de datos existente:

CREATE TABLE ùsers` ( ìd` int(11) NOT NULL auto_increment, ùsername` varchar(25) default NULL, `password` varchar(40) default NULL, àctive` varchar(1) default ‘1’, PRIMARY KEY (ìd`) ) ENGINE=MyISAM;

Entonces usted puede rellanar la tabla con algunos de los inicios de sesión de la muestra para realizar pruebas:

INSERT INTO users (username, password) VALUES (‘guest’, MD5(‘pass’));

464

INSERT INTO users (username, password) VALUES (‘timmy’, MD5(‘bird’));

Una clara diferencia de los inicios de sesión predefinidos en Flash es que estos inicios de sesión tienen contraseñas encriptadas como un nivel adicional de seguridad.

Antes de que usted puede agregar la lógica de la conexión al servicio, es necesario crear la clase de PHP. Esta clase de verificación para los usuarios válidos, y si se encuentra uno, se volverá un verdadero, lo que significa que el usuario es válido y el cuadro de inicio de sesión puede ser removido.

Construir la clase de usuario

La clase User.php es como las clases de servicios en que se extiende la clase DatabaseConnector para todas las comunicaciones de base de datos. Aquí está el esqueleto de la clase de usuario:

<?php


class User extends DatabaseConnector { function User() { ... } }

?>

Método login

El primer método, y sólo en esta clase es de acceso. Este método acepta dos argumentos: el nombre de usuario y contraseña para validar. La primera parte de este método es crear una nueva conexión a la base de datos:

/** * Check user auth * @access remote * @returns status of user login attempt */ function login($user, $pass) { $link = $this->getConnection(); }

Cuando se establece la conexión de base de datos, puede marcar el usuario como no conectado. Esto impide cualquier posible intento de hacking que accidentalmente podría hacer un registro de usuario.

$loggedIn = false;

465

Lo siguiente es la consulta SQL que intenta validar el nombre de usuario y contraseña de combo. La contraseña se pasa a la función md5 ya que Flash envía la contraseña en texto claro, pero la base de datos almacena el resultado de md5.

$query = sprintf(“SELECT * FROM users WHERE username=’%s’ AND password=MD5(‘%s’)”, $user, ($pass));

El siguiente paso es hacer la llamada base de datos y almacenar la respuesta en la variable $result, como se muestra en el siguiente código:


Una vez que la respuesta se almacena, una sentencia condicional se usa para determinar si se devuelven filas. Si se devuelve una fila, significa que los datos son válidos y el usuario se ha autenticado basada en las credenciales que él o ella pasa a lo largo.

Cuando una respuesta válida se encuentra, la variable $loggedIn se establece como verdadera para informar a Flash que el usuario es, en realidad, válida y ha ingresado exitosamente.

if(mysql_num_rows($result) > 0) { $loggedIn = true; }

El último paso es devolver el resultado de manera que Flash puede actuar en consecuencia.

return array(‘response’ => $loggedIn);

Ahora que ha completado la clase de PHP, el siguiente paso es probarlo. Para esta prueba se puede utilizar el navegador de servicio que se incluye con AMFPHP. Usted encontrará que en el navegador una URL similar a la siguiente, dependiendo de donde se instaló la fuente de:

http://localhost/flashphp/amfphp/browser/

Por último, aquí es la clase de usuario completa, que debe ser guardado como User.php en el directorio de servicios de la instalación de AMFPHP si no lo han hecho:

<?php


class User extends DatabaseConnector {

/** * Check user auth * @access remote * @returns status of user login attempt */ function login($user, $pass) { $link = $this->getConnection();

466

http://localhost/flashphp/amfphp/browser/

$loggedIn = false;

$query = sprintf(“SELECT * FROM users WHERE username=’%s’ AND password=MD5(‘%s’)”, $user, ($pass)); $result = mysql_query($query, $link);

if(mysql_num_rows($result) > 0) { $loggedIn = true; }

return array(‘response’ => $loggedIn); } }

?>

Agregar remotamente el componete login

Ahora que ha completado la clase de Usuarios de PHP, el paso siguiente es modificar el componente de acceso existentes para utilizar esta clase de servicios nuevos.

El primer paso es agregar la variable de puerta de enlace y la URL de donde el archivo gateway.php se puede encontrar en el servidor de desarrollo.

var gateway:NetConnection; var gatewayURL:String = “http://localhost/amfphp/gateway.php”;

El ejemplo original fue el de validación de usuario directamente en el archivo de Flash. Si bien esto era funcional, no era muy práctico porque sólo un usuario o la contraseña puede ser utilizado.

loginHandler method

Este nuevo sistema modifica la función loginHandler existentes mediante la adición de una llamada de servicio remoto, enviando el nombre de usuario y la contraseña que fue capturado por la ventana de conexión de componentes.

function loginHandler(e:Event):void { trace(“Do Login”); trace(“Username: “ + login.data.username); trace(“Password: “ + login.data.password); var responder:Responder = new Responder(loginRespHandler, onFault); gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“User.login”, responder, login.data.username, login.data.password ); }

467

La clase Responder necesita un controlador de respuesta definida, por lo que la siguiente función controla esta respuesta de servicio. Para este ejemplo, el servicio o bien devuelve un booleano para saber si el usuario está registrado o no, o un error si algo sale mal.

function loginRespHandler(o:Object):void { ... }

Una declaración condicional simple se usa para determinar si el usuario se registra en base a la respuesta del servicio remoto.

Controlar la respuesta de login

Si el usuario está conectado, una llamada al método de cierre del componente de conexión es hecha para ocultar la ventana de acceso y permitir la interfaz de la aplicación.

function loginRespHandler(o:Object):void { if(o.response == true) { login.close(); } }

Una opción más es añadido para manejar los intentos de acceso incorrectos mediante la actualización del mensaje de respuesta del componente de inicio de sesión.

function loginRespHandler(o:Object):void { if(o.response == true) { login.close(); }else { login.responseString = “username and password incorrect”; } }

Manejo de los errores de respuesta

La última función necesaria para el sistema de acceso es la onFault, que controla los errores en las llamadas de servicio. Por ejemplo, si la secuencia de comandos logrado intento de inicio de sesión con un cheque sin nombre de usuario o contraseña, el SQL sería un fracaso. Este error se incrementará en la clase de PHP y enviado de vuelta a Flash, en el supuesto de que está correctamente manejada.

function onFault(responds:Object):void { trace(“Debug::Error”); for(var i in responds) { trace(“ “ + responds[i]);

468

} }

Ahora que el código remoto se ha añadido a la anterior componente de ejemplo de acceso, puede probarlo, y realmente no debería notar ninguna diferencia. El único cambio sería la posibilidad de usar más de un usuario, siempre y cuando se encuentra en la tabla de usuarios que ha creado al comienzo de esta sección.

Aquí está el ejemplo de componentes de entrada con el código adecuado remoto incluido:

var gateway:NetConnection; var gatewayURL:String = “http://localhost/amfphp/gateway.php”;


addChild(login);



function loginHandler(e:Event):void { trace(“Do Login”); trace(“Username: “ + login.data.username); trace(“Password: “ + login.data.password);

var responder:Responder = new Responder(loginRespHandler, onFault); gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“User.login”, responder, login.data.username, login.data.password ); }

function loginRespHandler(o:Object):void { trace(“Response: “ + o.response);

if(o.response == true) { trace(“user logged in”); login.close(); }else { login.responseString = “username and password incorrect”; } }

function onFault(responds:Object):void

469

{ trace(“Debug::Error”); for(var i in responds) { trace(“ “ + responds[i]); } }stage.dispatchEvent(new Event(Event.RESIZE));

Finalizar el reproductor de video

La última sección de este capítulo está ultimando el reproductor de vídeo. Deberá implementar el componente de acceso que construyó en la sección anterior y aprender a utilizar una biblioteca externa.

Uso de un libreria externa

La ventaja de utilizar una biblioteca externa es que sólo tiene que actualizar un sitio y todas las instancias de que el uso de la biblioteca también se actualizan.

Por ejemplo, imagine que tiene un logotipo con un color específico en él y de repente la empresa decide que quiere cambiar el color del logotipo. En lugar de abrir todos los casos del logotipo y editar, usted puede abrir el maestro de FLA, a editar y, a continuación, la actualización de los casos, que reflejen automáticamente los cambios.

Usted puede utilizar este concepto para mucho más que un logotipo simple, porque se le carga el componente de inicio de sesión desde el archivo de ejemplo que construyó en la sección anterior.

Agregar el componente login

Comience por abrir el archivo VideoPlayer.fla si no lo está. A continuación, seleccione Archivo Importar Abrir biblioteca externa.

En este cuadro de diálogo, usted puede navegar hasta el directorio donde el componente de inicio de sesión se almacena y seleccione el archivo. Con el archivo seleccionado, haga clic en Abrir.

Arrastre el LoginWindowMC de esta biblioteca en la biblioteca de la FLA VideoPlayer. Ahora debe ver dos MovieClips nuevo en la biblioteca de su archivo de VideoPlayer. Esto es porque el LoginWindowMC tiene un archivo de apoyo que contiene todo el diseño, que se copia automáticamente cuando se arrastra el padre.

Ahora que se añade el componente de acceso, puede modificar la clase VideoPlayer archivo existente para añadir esta nueva funcionalidad. Para empezar, agregar la creación de componentes, pero olvídate de la lógica de inicio de sesión.

El nuevo código debe ser añadido a la función constructora, similar a la siguiente:

function VideoPlayer() { gatewayURL = “http://localhost/amfphp/gateway.php”; getCategories();

470

videoPlayer.visible = false; videoListCombo.enabled = false;


addChild(login); login.redraw(); }

Antes de probar el código, agregue el método loginHandler para evitar errores de tiempo de ejecución. Puede agregar este método en cualquier punto en el código. Recomiendo en algún lugar hacia la parte inferior de la clase para mantener el flujo general del archivo.

private function updateTrackingHandler(response:Object):void { ... }

private function loginHandler(response:Object):void { ... }

El último paso es importar la clase LoginWindow por lo que la propiedad estática puede ser cargado por el controlador de eventos.

package { import flash.display.MovieClip; import flash.events.Event; import flash.net.*; import LoginWindow;

public class VideoPlayer extends MovieClip { ... } }

Al probar la aplicación que debe consultar inmediatamente a la ventana de inicio de sesión. Porque no agregar ninguna lógica en este momento, no hay manera de cerrar la ventana de acceso, pero se puede ver que está funcionando, lo que puede continuar.

La lógica, que es responsable de llamar al servicio remoto, debe ser añadido a la método loginHandler existente.

function loginHandler(e:Event):void { var responder:Responder = new Responder(loginRespHandler, onFault); gateway = new NetConnection(); gateway.connect(gatewayURL); gateway.call(“User.login”, responder, login.data.username,

471

login.data.password ); }

El siguiente paso es copiar el loginRespHandler y añadir por debajo de loginHandler en la clase VideoPlayer.

function loginRespHandler(o:Object):void { trace(“Response: “ + o.response);

if(o.response == true) { trace(“user logged in”); login.close(); }else { login.responseString = “username and password incorrect”; } }

El código correcto se ha añadido ahora a la clase VideoPlayer, sin embargo, hay una modificación final necesaria antes de que el componente de inicio de sesión funcione correctamente.

La variable de sesión que se define en el constructor debe ser una propiedad global, porque tal y como está ahora, ningún otro método de esta clase tiene acceso a ella.

package {

... public class VideoPlayer extends MovieClip { ... private var selectedCatID:Number; private var login:LoginWindow;

function VideoPlayer() { ... login = new LoginWindow(); } }

}

Ahora que la variable de sesión está definido correctamente, puede probar la aplicación, como se muestra en la Figura 17.7. Usted debe ser capaz de escribir un nombre de usuario y contraseña válidos, y el componente de inicio de sesión debería desaparecer cuando lo haga.

FIGURA 17.7 Reproductor de vídeo con Final caja de ingreso visible

472

Como se puede ver, el componente de inicio de sesión que se está construyendo de esta manera que realmente hace posible añadir a cualquier proyecto existente. Para ampliar sobre este ejemplo, usted podría agregar un objeto compartido que se preserve la sesión y hacer que lo que el usuario no necesita entrar en cada tiempo.

Usted debe ahora tener una gran comprensión de la construcción y de trabajo con tecnología avanzada, las aplicaciones del mundo real. Estoy seguro de que usted está pensando en muchas aplicaciones diversas para construir después de ver cómo funcionan en profundidad.

El siguiente es un cuadro que delinea los nombres de los archivos y donde deben ser almacenados para esta aplicación completa. La ruta de acceso se basa en el directorio del proyecto que debe estar en su directorio de Apache para que la aplicación funcione correctamente.

Ubicaciones de archivos de aplicaciones de códigoNombre de archivo Save Path .LoginWindow.swf / LoginWindow.fla / LoginWindow.as / VideoListItem.as / VideoPlayer.as / SkinOverPlayStopSeekMuteVol.swf / color.flv /videos Categories.php /amfphp/services

473

DatabaseConnector.php /amfphp/services Videos.php /amfphp/services Tracking.php /amfphp/services User.php /amfphp/services

Resumen En este capítulo, se inició la construcción de un reproductor de video muy básicos y amplió ese concepto para construir un reproductor de vídeo multicategory. Uso de PHP para manejar los datos entre Flash y la base de datos ha presentado la solicitud más dinámico.

Una vez que ha completado el reproductor de vídeo, comenzó a expandirse en añadir el seguimiento de vídeo.Usted aprendió lo fácil que era la aplicación de nuevas características en el código existente basado en la forma original de la aplicación del reproductor de vídeo que se desarrolló en la sección anterior.

La cuarta parte del capítulo presenta el proceso de desarrollo de componentes personalizados que pueden ser reutilizados en sus proyectos de futuro. Para este ejemplo, se desarrolló un componente de inicio de sesión que desactive la solicitud hasta que el usuario se conecte.

El quinto y último traía todas estas técnicas en conjunto para desarrollar una aplicación de reproductor de vídeo final en el mundo real con un módulo de acceso y seguimiento de vídeo de las secciones anteriores. Todo lo que tienes que hacer es rellenar la base de datos con datos reales y tendrá un multicategory totalmente ampliable, de seguimiento, garantizar la aplicación reproductor de vídeo.

474