Analice servicios basados en la nube para aplicaciones de Android

Almacenamiento en la nube y consulta de usuarios, objetos de datos y archivos en sus aplicaciones Android

Explore las ventajas de almacenar datos de aplicaciones móviles en nube privada con esta introducción a Parse SDK para Android. El desarrollador de tecnología móvil C. Enrique Ortiz presenta las clases Parse API para almacenamiento en nube y manipulación de usuarios, objetos de datos y archivos para sus aplicaciones móviles.

C. Enrique Ortiz, Developer and author, Independent

C. Enrique Ortiz es un tecnólogo y autor con gran experiencia. Un ex ingeniero en software de transbordadores espaciales que decidió focalizarse en tecnologías móviles más que en trabajar en cohetes peligrosos, asesora a desarrolladores, empresas que recién se inician e inversores sobre cosas móviles: tecnología, estrategia, productos y lanzamientos al mercado.



06-05-2013

Parse mobile SDK proporciona APIs y servicios basados en nube para aplicaciones iOS, Android y Windows® . Parse SDK también proporciona APIs JavaScript y REST. Al usar Parse API, usted puede habilitar en la nube sus aplicaciones móviles muy rápidamente y con un esfuerzo mínimo. Una aplicación móvil que está integrada con Parse API puede almacenar objetos de datos y archivos fácilmente en la nube Parse, enviar y recibir notificaciones de push, gestionar usuarios, manejar datos de geo-ubicación y usar plataformas de medios sociales como Twitter y Facebook. Para las aplicaciones móviles que necesitan escalarse, Parse SDK ofrece toda la elasticidad de una plataforma de nube.

Antes de comenzar

Supongo que para propósitos de este artículo usted ya está familiarizado con los conceptos básicos que se requieren para programar aplicaciones móviles con JSON, Android, y Eclipse. Antes de leer más vaya a Parse.com y defina su aplicación. Simplemente siga las sencillas instrucciones que inician desde la página de inicio de sesión.

Este artículo presenta las clases centrales de Parse API para usuarios Parse, objetos de datos y archivos. Usted aprenderá cómo trabajar con listas de control de acceso (ACLs) y cómo realizar operaciones CRUD en objetos de datos, y cómo almacenar y recuperar archivos en la nube Parse. Los ejemplos están incorporados en Parse SDK for Android (ver Recursos).

El panel de instrumentos de Parse


El panel de instrumentos de Parse ayuda a los desarrolladores a gestionar aplicaciones. El panel de instrumentos proporciona métricas de uso general y específicas de aplicación para APIs, archivos y notificaciones push. Las claves y valores de la aplicación se gestionan vía el panel de instrumentos. El panel de instrumentos también proporciona un navegador de datos que permite a los desarrolladores navegar e incluso editar objetos Parse almacenados. El navegador de datos es muy útil data para depurar. La Figura 1 es una captura de pantalla del panel de instrumentos de Parse:

Figura 1. El panel de instrumentos de Parse
A screenshot of the Parse dashboard.

Las aplicaciones son autenticadas vía un ID de aplicación y un ID de cliente. Para obtener su ID de aplicación y de cliente, usted debe registrar su aplicación vía el panel de instrumentos de Parse. Usted usará estas claves cuando inicialice la bilbioteca Parse en su aplicación.

Objetos de datos Parse

En Parse, los datos son representados usando ParseObject, un contenedor de pares de nombre-valor. ParseObject puede almacenar cualquier dato que sea compatible con JSON, como se muestra en el Listado 1:

Listado 1. Un ejemplo de ParseObject
ParseObject myParseObject = new ParseObject("MyObject"); // Class Name
myParseObject.put("name", "C. Enrique Ortiz");
myParseObject.put("twitterHandle", "eortiz");
myParseObject.put("followers", 123456);

A ParseObject se le da un classname cuando se instancia. El classname en el Listado 1 es "MyObject." Classnames son como nombres de tabla en una base de datos relacional, y los objetos Parse de la misma clase son como filas dentro de una tabla.

ParseObject expone métodos similares a los que se encuentran en la clase de Java Map , como put, httpy remove, más diversos otros métodos que son específicos para ParseObject.

ParseObjectson claves de nombre que deben ser alfanumérica; como guía, use bicapitalización para las claves de nombre. Los valores pueden ser de cualquier tipo de datos que puedan almacenarse en JSON; esto es, números, cadenas de caracteres, booleanos, arrays, JSONObject.NULL, JSONObjects y JSONArrays. Otros tipos de datos con soporte de ParseObject son arrays Java Date y byte[] . Un ParseObject puede incluir también otros ParseObjects.

El Listado 2 muestra algunos de los tipos de datos de valor ParseObject con soporte:

Listado 2. ParseObject: Algunos tipos de datos de valor con soporte

// Byte Array
byte[] byteArray = {1, 2, 3, 4, 5};

// A date
Date d = new Date(); // java.util.Date

// A number
int number = 21;

// A String
String name = "Enrique";

// A JSONArray - any mix of JSONObjects, JSONArrays, Strings, Booleans, 
//   Integers, Longs, Doubles, null or NULL.
JSONArray jArray = new JSONArray();
jArray.put(number);
jArray.put(name);

// A JSONObject 
JSONObject jObject = new JSONObject();
try {
    jObject.put("number", number);
    jObject.put("name", name);
} catch (JSONException e) {
    e.printStackTrace();
}

// A ParseObject
ParseObject pObject = new ParseObject("MyObject"); // Class name
pObject.put("myByteArray", byteArray);
pObject.put("myDate", d);
pObject.put("myString", name);
pObject.put("myNumber", number);
pObject.put("myJsonArray", jArray);
pObject.put("myJsonObject", jObject);
pObject.put("myNull", JSONObject.NULL);

El código en el Listado 2 crea un ParseObject que es almacenado como un objeto en la nube Parse. Muchos MyObjects de la misma clase son posteriormente almacenados como filas de objetos de datos ParseObject que pueden ser guardados, consultados, actualizados, y suprimidos del almacenamienot de la nube de Parse. Es incluso posible guardar datos cuando la aplicación está offline — la bilbioteca Parse simplemente guarda los datos localmente hasta que haya sido restablecida una conexión.

Modificando un ParseObject

Si usted está familiarizado con el desarrollo de aplicaciones móviles, entonces usted sabe qué operaciones largas como operaciones de red deben realizarse típicamente en segundo plano, en una hebra de trabajador y no en la hebra de sistema principal UI. Esto previene que la hebra de sistema principal bloquee y afecte el grado de respuesta de su interfaz de usuario. Más adelante en el artículo, les mostraré cómo los recursos Parse trabajan en plano de fondo para guardar, suprimir y encontrar objetos. Por ahora, considere el siguiente método sincrónico remove() , que es usado para remover una clave de un objeto Parse:

pObject.remove("myNumber"); // remove the field/key "myNumber" from pObject

Después de remover o adcionar campos, o actualizar un campo actual, usted puede guardar (o actualizar) el objeto de datos en la nube al llamar uno de los métodos ParseObject's save...() , que discuto posteriormente en el artículo.

Resumen: ParseObject

ParseObject representa un objeto de datos en la nube Parse. Proporciona métodos para añadir pares nombre-valor, prueba si una clave dada está presente, y suprimir o captar un ParseObject dado del servidor. ParseObject también le permite usar diversos métodos get...() y put...() para manipular datos ParseObject , fusionar ParseObjects, guardar un ParseObject en el servidor, y más.

Usuarios Parse, papeles, y ACLs

Antes de mostrar cómo realizar operaciones CRUD en un objeto Parse, debe saber algunas cosas acerca de los usuarios Parse, papeles, y ACLs (listas de control de acceso). Los tres son muy importantes conceptos y recursos para proteger los objetos de datos de su aplicación.

Usuarios Parse

Una clase llamada ParseUser representa un usuario y proporciona funcionalidad de usuario-cuenta para aplicaciones Parse. Cada aplicación Parse tiene a usuarios Parse asociados con ella. Un ParseUser es un ParseObject pero con las propiedades adicionales de username, password, y email. Usted puede añadir cualquier valor de datos adicional conforme lo considere conveniente.

Usuarios anónimos en Parse

Un usuario anónimo en Parse es uno sin nombre de usuario o contraseña. Los usuarios anónimos son útiles para funcionalidad de aplicación móvil que no requiera autenticación de usuario. Los usuarios anónimos pueden crear objetos de datos, pero dichos objetos tiene una vida corta y no estarán disponibles una vez que el usuario anónimo realice el log-out.

Los usuarios pueden iniciar sesión como usuarios Parse de su aplicación, como se muestra en elListado 3:

Listado 3. ParseUser — signup
ParseUser user = new ParseUser();
user.setUsername("eortiz");
user.setPassword("123456");
user.setEmail("eortiz@nospam.com");
user.put("userType", "Author"); // add another field

// Call the asynchronous background method to sign up 
user.signUpInBackground(new SignUpCallback() {
  public void done(ParseException e) {
    if (e == null) {
      // Successful. Allow access to app.
    } else {
      // Failed....
    }
  }
});

El username y email deben ser únicos. Si un username o email ya está en uso, el llamado de inicio de sesión fallará. Usted debe tener un mecanismo para notificar al usuario si alguno de los campos falla, así como un proceso para intentar de nuevo.

Después del inicio de sesión, los usuarios pueden iniciar sesión en su aplicación, como se muestra en el Listado 4:

Listado 4. Inicio de sesión ParseUser —
ParseUser.logInInBackground("eortiz", "123456", new LogInCallback() {
  public void done(ParseUser user, ParseException e) {
    if (user != null) {
      // Successful. Allow access to app.
    } else {
      // Failed
    }
  }
});

Usted pueda actualizar la información de usuario al llamar a ParseUser.save(). Observe, sin embargo, que solo el propietario de ParseUser puede modificar su contenido; para todos los demás, los datos son de solo lectura.

Parse almacena el usuario actual que inició sesión. Usted puede consultar al usuario actual llamando a ParseUser.currentUser(). El método currentUser le permitirá rápidamente acceder a la información del usuario actual, de manera que usted solo necesita solicitar credenciales si la sesión de usuario actual no está activo. El Listado 5 muestra cómo recuperar un usuario actual en Parse:

Listado 5. ParseUser — getting the current user
ParseUser currentUser = ParseUser.getCurrentUser();
if (currentUser != null) {
  // current user is valid
} else {
  // current user not valid, ask for credentials
}

Restablecimiento de un usuario actual

Usted puede restablecer a un usuario actual en Parse llamando a ParseUser.logOut(), como se muestra en el Listado 6:

Listado 6. ParseUser — resetting current user (log out)
ParseUser.logOut(); // static method

ACLS de Parse

Una ACL es una lista de permisos de acceso (o controles) que son asociados a un objeto de datos. La clase ParseACL le permite definir los permisos para un determinado ParseObject. Con las ACLs, usted puede definir acceso público a sus objetos de datos de aplicaciones y usted puede limitar el acceso a usuarios específicos o grupos de usuarios (via papeles). El Listado 7 demouestra el uso de las Parse ACLs:

Listado 7. Usando ParseACL para permisos de acceso
// Define a Parse user
ParseUser user = new ParseUser();
user.setUsername(username);
:
:

// Define a read/write ACL
ParseACL rwACL = new ParseACL();
rwACL.setReadAccess(user, true); // allow user to do reads
rwACL.setWriteAccess(user, true); // allow user to do writes
:
:

// Define a Parse object and its ACL
ParseObject gameObject = new ParseObject("Game");
gameObject.setACL(rwACL); // allow user do read/writes on gameObject
gameObject.saveInBackground(); // save the ACL'ed object to the cloud
:
:

// You can define a public ACL that gives public access to the object
ParseACL publicACL = new ParseACL();
publicACL.setPublicReadAccess(true);
publicACL.setPublicWriteAccess(true);      
gameObject.setACL(publicACL); // allow public read/writes
gameObject.saveInBackground(); // save the ACL'ed object to the cloud

Usted también puede definir una ACL predeterminada para todos los objetos creados nuevamente. En el Listado 8 yo he configurado la ACL predeterminada para que sea pública para lectura y escritura, conforme se define por publicACL en el Listado 7.

Listado 8. Configuración de la ACL predeterminada
// Set a default ACL for all newly created objects as public access
ParseACL.setDefaultACL(publicACL, true);

Aunque no se muestra aquí, también podríamos usar la clase ParseRole para otorgar permisos de acceso a grupos de usuarios.

Poseriormente, observaremos cómo los objetos de datos Parse son guardados y recuperados de la nube Parse.

Objetos de datos Parse

Una vez que usted haya creado y poblado un ParseObject, usted puede guardarlo en la nube Parse. El guardar objetos de datos en la nube Parse es de hecho una de las cosas más sencillas de hacer en Parse; la complejidad que está usualmente asociada con la representación de datos, ordenación, comunicación y transporte de red, y así sucesivamente, está completamente ocultada por Parse. Usted necesitará usar métodos de ayudante para correlacionar su instancia de objeto de datos en un ParseObject y de regreso, y usted necesitará decidir si desea asignar la operación de guardar de Parse en su propia hebra o usar el método de guardar en segundo plano.

¡Tenga cuidado de no bloquear la hebra del sistema!

Recupere eso en aplicaciones móviles, las operaciones largas como computación de red, archivo, o largos no deben hacerse en la hebra del sistema principal. En vez de eso, ejecútelas bajo una hebra de trabajador separada. Bloquear la hebra del sistema afectaría negativamente el nivel de respuesta de la UI de la aplicación, potencialmente provocando que su aplicación sea forzada a cerrar.

ParseObject proporciona dos tipos de métodos de guardado: save() y saveInBackground(). saveInBackground() es el método de guardar recomendado ya que ejecuta la operación de guardar en su propia hebra de trabajador. Si usted opta por escoger el método sincrónico save() , esté conciente de que es su responsabilidad llamar a este método en su propia hebra de trabajo para prevenir que se bloquee a la UI.

El Listado 9 muestra el código para guardar un objeto de datos Parse en segundo plano:

Listado 9. Guarde ParseObject en segundo plano

// ParseObject
ParseObject pObject = new ParseObject("ExampleObject");
pObject.put("myNumber", number);
pObject.put("myString", name);
pObject.saveInBackground(); // asynchronous, no callback

Y el Listado 10 muestra el código para guardar un objeto de datos Parse en segundo plano con una devolución de llamado:

Listado 10. Guarde en segundo plano con una devolución de llamado
pObject.saveInBackground(new SaveCallback () {
    @Override
    public void done(ParseException ex) {
        if (ex == null) {
            isSaved = true;
        } else {
            // Failed
            isSaved = false;
        }
    }
  });

Las variaciones del métdo save...() incluyen lo siguiente:

  • saveAllinBackground() guarda un ParseObject con o sin una devolución de llamado.
  • saveAll(List<ParseObject> objects) guarda una lista de ParseObjects.
  • saveAllinBackground(List<ParseObject> objects) guarda una lista de ParseObjects en segundo plano.
  • saveEventually() le permite guardar un objeto de datos en el servidor en el futuro; use este método si la nube Parse no está actualmente disponible.


Una vez que un ParseObject ha sido guardado exitosamente en la Nube, se le asigna un ID de Objeto único único. Este ID de Objeto es muy importante ya que identifica de manera única esa instancia de ParseObject . Usted usaría el ID de Objeto, por ejemplo, para determinar si un objeto fue guardado exitosamente en la nube, para recuperar y renovar una instancia dada de objeto Parse, y para suprimir un determinado ParseObject.

Recuparación de objetos de datos de la nube

Esta sección observa los métodos para consultar y recuperar objetos de datos almacenados en la nube Parse. Usted puede consultar un único ParseObject por object-ID, o usted puede consultar uno o más de objetos Parse usando atributos. Si usted ya tiene un ParseObject, usted puede renovar o sincronizar su contenido al captar los últimos valores del servidor. Observaremos todas estas funciones en los siguientes fragmentos de código.

Captando ParseObjects

Para captar un objeto de datos de la nube Parse, use el método ParseObjectfetch() o fetchInBackground(), mostrado en el Listado 11:

Listado 11. Captación (incondicional)
// ParseObject
ParseObject pObject = new ParseObject("ExampleObject");
:
:

// Fetch the parse object unconditionally
try {
    pObject.fetch();
} catch (ParseException e) {
    e.printStackTrace();
}

// Fetch the parse object unconditionally, with Callback
pObject.fetchInBackground(new GetCallback() {
    @Override
    public void done(ParseObject obj, ParseException ex) {
        if (ex == null) {
            // Success
        } else {
            // Failed
        }            
    }
});

Usted también puede captar solo si necesita; por ejemplo, cuando capta un objeto Parse que ha relacionado objetos Parse, como en el Listado 12:

Listado 12. Captando conforme se necesita
ParseObject po = new ParseObject("ExampleObject");
:

ParseObject po2 = po.getParseObject("key");

// Fetch only if needed
try {
    po2.fetchIfNeeded();
} catch (ParseException e) {
    e.printStackTrace();
}

Otra opción es realizar una operación de "captar si es necesario" en segundo plano con una devolución de llamado. Para esto, usted usaría el método de objeto Parse fetchIfNeededInBackground(GetCallback callback).

En algunos casos, usted necesitará captar una colección de objetos Parse una vez, incondicionalmente, o solo si se necesita. ParseObject proporciona un conjunto de métodos estadísticos; cada uno toma como entrada una lista de objetos Parse y luego retorna una lista de objetos Parse:

  • fetchAll(List<ParseObject> objects)
  • fetchAllIfNeeded(List<ParseObject> objects)
  • fetchAllIfNeededInBackground(List<ParseObject> objects, FindCallback callback)
  • fetchAllInBackground(List<ParseObject> objects, FindCallback callback)

Consultado objetos de datos en la nube

Ojalá que ustes hasta ahora ya se haya dado cuenta de que la Parse API es super completa — pero espere, ¡hay más! Además de captar objetos de datos, Parse también le permite consultar objetos de datos usando object-ID o atributos. Paa consultar un objeto de datos desde la nube Parse, use ParseQuery. Usted puede usar ParseQuery tanto para consultas de datos básicas como complejas, recibiendo de regreso un objeto dado o una Lista de objetos que coinciden.

El Listado 13 muestra cómo recuperar un objeto específico de Parse del servidor en una hebra de segundo plano, dado un ID de objeto:

Listado 13. Uso de ParseQuery para recuperar un determinado ParseObject
String myID = "12345";
ParseQuery query = new ParseQuery("Players");
query.getInBackground(myID, new GetCallback() {
    @Override
    public void done(ParseObject object, ParseException e) {
        if (object != null) {
            // Get object
        } else {
            // Not found
        }
    }            
});

Observe que query.getInBackground() no usa la memoria caché ParseQuery .

El Listado 14 muestra una consulta que recupera todos los datos de objetos de clase: Players. (Sin restricción proporcionada).

Listado 14. Usando ParseQuery para todos los ParseObjects de una clase dada
ParseQuery query = new ParseQuery("Players");
query.findInBackground(new FindCallback() {
    @Override
    public void done(List<ParseObject> players, ParseException e) {
        if (players != null) {
            // Get list of players
        } else {
            // No players
        }
    }
});

En el Listado 15 he usado una restricción de consulta para recuperar uno o más objetos de coincidencia de Parse; en este caso Players activos:

Listado 15. Usando ParseQuery para recuperar ParseObjects coincidentes


ParseQuery query = new ParseQuery("Players");
query.whereEqualTo("status", "active");
query.findInBackground(new FindCallback() {
    @Override
    public void done(List<ParseObject> players, ParseException e) {
        if (players != null) {
            // Success - players contain active players 
        } else {
            // Failed
        }
    }
});

ParseQuery también proporciona un método para obtener el conteo de objetos de coincidencia sin recuperar los mismos objetos, lo que es muy útil. El Listando 16 muestra cómo obtener el conteo de participantes activos:

Listado 16. Usando ParseQuery para contar ParseObjects coincidentes
ParseQuery query = new ParseQuery("Players");
query.whereEqualTo("status", "active"); //remove this line to count ALL
query.countInBackground(new CountCallback() {
    @Override
    public void done(int count, ParseException e) {
        if (e == null) {
            // Success, see count variable
        } else {
            // Failed
        }
    }
});

Métodos y restricciones de ParseQuery

ParseQuery da soporte a más de 20 métodos de consulta-restricción; aquí hay algunos ejemplos:

  • whereMatches(String key, String regex) encuentra valores de cadena de caracteres que coinciden con la expresión normal proporcionada.
  • whereStartsWith(String key, String prefix) encuentra valores de cadena de caracteres que inician con una cadena de caracteres proporcionada.
  • whereContains(String key, String substring) encuentra valores que contienen una cadena de caracteres proporcionada.
  • whereGreaterThan(String key, Object value) encuentra valores que son mayores que el valor proporcionado.
  • whereWithinKilometers(String key, ParseGeoPoint point, double maxDistance) encuentra objetos con valores de puntos cerca del punto dado y dentro de la distancia máxima dada.

Los resultados de consulta pueden ser ordenados, como se muestra en el Listado 17. Para ordenar resultados de consulta de pedido, llame a uno de los métodos query orderBy...() , especificando el campo por el cual ordenar.

Listado 17. Ordering query results
query.orderByAscending("name"); 

query.orderByDescending("name");



Por ejemplo:



ParseQuery query = new ParseQuery("Players");
query.whereEqualTo("status", "active");
query.orderByAscending("lastName"); // By lastname ascending order
query.findInBackground(new FindCallback() {
    @Override

  public void done(List<ParseObject> players, ParseException e) {

    if (players != null) {
      // Success - players contain active players

    } else {

      // Failed
		
                          } 

             }	

});

Otra cosa que se debe observar es que ParseQuery los resultados son puestos en memoria caché. Usted puede configurar la política de consulta-memoria caché de diversas maneras dependiendo de las necesidades de su aplicación. L as siguientes políticas de memoria caché cuentan actualmente con soporte:

  • IGNORE_CACHE: No usar la memoria caché; esta es la política de memoria caché predeterminada.
  • CACHE_ONLY: Solo cargar de la memoria caché. Si no hay resultados en memoria caché, habrá una ParseException.
  • NETWORK_ONLY: Siempre ir a la red, pero guardar los resultados en la memoria caché.
  • CACHE_ELSE_NETWORK: Dirigirse a la memoria caché primero. Si eso falla, cargar de la red. Si no hay éxito con la memoria caché o con la red, el resultado será una ParseException.
  • NETWORK_ELSE_CACHE: Dirigirse a la red primero. Si eso falla, cargar de la memoria caché. Si no hay éxito con la red o con la memoria caché, el resultado será una ParseException.
  • CACHE_THEN_NETWORK: Dirigirse a la memoria caché primero, posteriormente cargar de la red. Observe que FindCallback será llamado dos veces: primero con los resultados en memoria caché, posteriormente con resultados de red. Esta política solo puede ser usada asincrónicamente con findInBackground.

Configurar la política de memoria caché es sencillo. Hágalo antes de llamar al método find...() , como se muestra en el Listado 18:

Listado 18. Gestión de CachePolicy
ParseQuery query = new ParseQuery("Players");
query.setCachePolicy(ParseQuery.CachePolicy.NETWORK_ELSE_CACHE);
query.findInBackground(new FindCallback() {
    @Override
    public void done(List<ParseObject> players, ParseException e) {
        if (e == null) {
            // Success - players contain active players 
        } else {
            // Failed
        }
    }
});

La clase ParseQuery proporciona todos los métodos necesitados para consultar objetos de datos que están almacenados en la nube. Con ParseQuery, usted puede especificar restricciones de consulta de todos los tipos, contar objetos de datos coincidentes, establecer límites, saltar objetos de datos, ordenar por, limpiar la memoria caché, y mucho más.


Remoción de objetos de datos

La remoción de un objeto de datos de la nube Parse también es muy sencillo. Una vez que usted tenga la instancia de objeto, usted puede suprimir un ParseObject existente de la nube al llamar al método ParseObjectdelete() o deleteInBackground(). Ambos se muestran en el Listado 19:

Listado 19. Remoción de un objeto Parse de la nube
parseObject.delete();
parseObject.deleteInBackground();

Como puede anticipar, delete() un llamado que bloquea, lo que significa que es responsabilidad de usted asignar adecuadamente este llamado a su propia hebra de trabajador. O usted puede dejar que Parse se encargue de las hebras usando deleteInBackground() con o sin una devolución de llamado.

Trabajo con archivos

Hasta este punto, hemos estado trabajando con objetos Parse y consultas Parse. También lo he introducido a los usuarios Parse, ACLs, y papeles. Concluiré con una demostración de trabajo con funciones de leer, escribir y guardar archivos en Parse.

Recuerde que puede almacenar datos en crudo byte[] dentro de un ParseObject, que está bien para una pequeña cantidad de datos. Cuando almacene ítems mayores como imágenes o documentos, use Parse Files.

Los archivos en la nube Parse son representados usando ParseFile, que proporciona métodos para obtener el nombre de un archivo, su URL, y los datos del mismo archivo, asumiendo que está disponible. Usted también puede descargar y subir archivos y acceder a otros métodos de ayudante.

Los datos de archivos son representados por byte[] . Observe que actualmente un archivo dado no puede ser mayor de 10MB. Cuando nombra un archivo, la biblioteca Parse se encarga de las colisiones potenciales de nombre. Proporcionar una extensión de archivo ayuda a Parse a manejar el contenido de archivos.

El Listado 20 demuestra cómo guardar un archivo JPG:

Listado 20. Saving a ParseFile
// Save image file
Drawable drawable = ...;
Bitmap bitmap = (Bitmap)((BitmapDrawable) drawable).getBitmap();
ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
byte[] data = stream.toByteArray();                
ParseFile imageFile = new ParseFile("image.jpg", data);
imageFile.saveInBackground();

Las sentencias principales en el Listado 20 convierten al bitmap en byte[]. El byte[] es posteriormente guardado usando un método ParseFile saveInBackground() , similar a cómo ParseObject se guarda en el servidor.

Una vez que el archivo ha sido guardado en Parse, debe ser asociado con (colocado en) un ParseOject. En otras palabras, los archivos Parse no son objetos verdaderamente autónomos y para ser recuperados y usados posteriormente, deben asociarse con un determinado ParseObject . Esta limitación puede ser abordada en un release futuro de Parse. El Listado 21 asocia el archivo de imagen con un objeto Player Parse:

Listado 21. Asociación de un ParseFile con un ParseObject
// Associate image with Parse object
ParseObject po = new ParseObject("Players");
po.put("name", "eortiz");
po.put("photo", imageFile);
po.saveInBackground();

Yo he asociado el archivo con el objeto de datos, luego guardado el objeto en el servidor usando saveInBackgroud(), que discutí previamente.

El Listado 22 muestra cómo recuperar un archivo que es asociado con un objeto de datos:

Listado 22. Recuperación de ParseFile
// Retrieving the file 
ParseFile imageFile2 = (ParseFile)po.get("photo");
imageFile2.getDataInBackground(new GetDataCallback() {
  public void done(byte[] data, ParseException e) {
    if (data != null) {
      // Success; data has the file
    } else {
      // Failed
    }
  }
});

Después de recibir una referencia ParseFile de un objeto Parse, llamé a getDataInBackground() para recuperar ParseFile de los servidores. Observe que usé la devolución de llamado GetDataCallback para recuperar los archivos files, en oposición a GetCallback, que es para recuperar objetos Parse con ParseQuery.

En conclusión

La Parse API es muy completa e incluye clases para acceder a servicios móviles como notificación push, uso de geo-datos, integración con plataformas de medios sociales y más. En este artículo, he mostrado solo la superficie de lo que puede hacer con Parse al introducir las Parse APIs para almacenamiento de nube de datos y archivos. El saber cómo almacenar y manipular usuarios, objetos de datos, archivos y ACLs de Parse en la nube Parse es una base buena para explorar más esta plataforma de nube para desarrollo móvil.

Reconocimientos

Muchas gracias a Athen O'Shea por su revisión de este artículo.

Recursos

Aprender

  • Aprenda más acerca de Parse Android SDK; también vea la Guía Rápida de Parse para escoger una plataforma móvil, configurar una aplicación, y descargar e instalar su Parse SDK.
  • Vea una lista completa de las Parse Android APIs.
  • "Desarrolle aplicaciones Android con Eclipse (Frank Ableson, developerWorks, Febrero del 2008): Obtenga más práctica desarrollando aplicaciones Android en el entorno de desarrollo de Eclipse, esta vez usando el plug-in de Android Eclipse.
  • "Introduction to jQuery Mobile" (C. Enrique Ortiz, developerWorks, Mayo del 2012): Aprenda lo básico de jQuery Mobile y cómo escribir una interfaz de usuario funcional de aplicación web móvil. Los ejemplos de trabajo lo guiarán a través de páginas, navegación, barras de herramientas, visualizaciones de lista, controles de forma y efectos de transición en jQuery Mobile.
  • "Resuelva los desafíos de integración de su aplicación móvil para muchos dispositivos en múltiples plataformas" (Olivier Picciotto, developerWorks, octubre de 2012): El desarrollo móvil y la computación en nube son prácticamente inseparables estos días, pero integrar las aplicaciones móviles en la nube todavía es un territorio nuevo. Aprenda cómo la plataforma de aplicación empresarial móvil (MEAP) resuelve algunos de los desafíos de integración de "móvil hacia nube".
  • "DevOps for mobile development" (Michael Rowe, developerWorks, Julio del 2012): Las compañías de todo el mundo desean explotar el mercado móvil al proporcionar a los clientes y usuarios aplicaciones que facilitan la computación móvil. Este artículo reflexiona acerca de los problemas técnicos y de negocios con la integración de desarrollo y operaciones para las plataformas móviles en el lugar de trabajo.
  • Siga a developerWorks en Twitter.
  • Vea las demos on demand de developerWorks que van desde demostraciones sobre instalación y configuración de productos para principiantes, hasta funcionalidades avanzadas pera desarrolladores experimentados.

Comentar

  • Participe de la comunidad developerWorks. Conéctese con otros usuarios de developerWorks mientras explora los blogs dirigidos a desarrolladores, foros, grupos y wikis.

Comentarios

developerWorks: Ingrese

Los campos obligatorios están marcados con un asterisco (*).


¿Necesita un IBM ID?
¿Olvidó su IBM ID?


¿Olvidó su Password?
Cambie su Password

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


La primera vez que inicie sesión en developerWorks, se creará un perfil para usted. La información en su propio perfil (nombre, país/región y nombre de la empresa) se muestra al público y acompañará a cualquier contenido que publique, a menos que opte por la opción de ocultar el nombre de su empresa. Puede actualizar su cuenta de IBM en cualquier momento.

Toda la información enviada es segura.

Elija su nombre para mostrar



La primera vez que inicia sesión en developerWorks se crea un perfil para usted, teniendo que elegir un nombre para mostrar en el mismo. Este nombre acompañará el contenido que usted publique en developerWorks.

Por favor elija un nombre de 3 - 31 caracteres. Su nombre de usuario debe ser único en la comunidad developerWorks y debe ser distinto a su dirección de email por motivos de privacidad.

Los campos obligatorios están marcados con un asterisco (*).

(Por favor elija un nombre de 3 - 31 caracteres.)

Al hacer clic en Enviar, usted está de acuerdo con los términos y condiciones de developerWorks.

 


Toda la información enviada es segura.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=90
Zone=tecnologia Java, Desarrollo móvil, Cloud computing
ArticleID=928864
ArticleTitle=Analice servicios basados en la nube para aplicaciones de Android
publish-date=05062013