Seguimos viendo las diferentes características y maneras para las cuales podemos usar el Almacenamiento Aislado en Windows Phone 7.

Vale recordar que la captura de imágenes con una cámara en Windows Phone solo nos provee la imagen en un objeto Stream en memoria y no se almacena en ningún lugar, por lo que ya es responsabilidad de nuestras aplicaciones el uso de la imagen de acuerdo a las necesidades, las cuales pueden ser, por ejemplo: enviarla por mail, subirla a un servicio en la nube, almacenarla en el teléfono, etc. En este ejemplo veremos como guardar en el Almacenamiento Aislado una imagen tomada con la cámara, y cómo recuperarla posteriormente desde el mismo lugar.

En un anterior post ya habíamos visto como capturar imágenes con el dispositivo, el cual bien puede servir de base como inicio para el ejemplo de este post.

En primer lugar, crearemos una aplicación Silverlight para Windows Phone en Visual Studio, y editamos un formulario sencillo con dos Botones y un control Image.

Para iniciar, agregamos sentencias Using de varias librerías que necesitaremos para las tareas de la cámara, del Almacenamiento Aislado, y el tratamiento de imágenes.

using System.IO;
using System.IO.IsolatedStorage;
using System.Windows.Media.Imaging;
using Microsoft.Phone;
using Microsoft.Phone.Tasks;

Iniciaremos declarando un par de variables, uno para el nombre de archivo a guardar, y otro para una instancia de la clase CameraCaptureTask, que nos ayudará a capturar la imagen.

// Nombre de imagen a almacenar.
private string nombreImagen = "Imagen1.jpg";
        
// Variable con instancia de task de captura de imagenes con camara.
private CameraCaptureTask camera = null;

En el constructor de la clase, inicializar y matricular el método que manejará el evento Completed del objeto de la cámara.

// Constructor
public MainPage()
{
    InitializeComponent();
 
    // Inicializar el objeto camara.
    camera = new CameraCaptureTask();
 
    // Matricular evento que se ejecutara al completar la captura de imagenes de la camara.
    camera.Completed += new EventHandler<PhotoResult>(camera_Completed);
}

Una vez hecho esto, procedemos a implementar el código del botón "Capturar", con el que procederemos a activar la cámara.

/// <summary>
/// Evento click del boton Capturar.
/// </summary>
/// <param name="sender">Objeto que invoca el evento.</param>
/// <param name="e">Argumentos del evento.</param>
private void btnCapturar_Click(object sender, RoutedEventArgs e)
{
    // Activar camara del dispositivo.
    camera.Show();
}

En el constructor de clase, indicamos un método que manejará el evento Completed del CameraCaptureTask. Este método será el que se ejecute una vez regresemos a la aplicación luego de capturar una foto, por lo que implementamos el código de este método de la siguiente manera:

/// <summary>
/// Metodo que se ejecuta al terminar la captura de imagenes de la camara,
/// obteniendo el resultado del proceso.
/// </summary>
/// <param name="sender">Objeto que invoca el evento.</param>
/// <param name="e">Resultado del evento.</param>
void camera_Completed(object sender, PhotoResult e)
{
    // Si el resultado de la captura de la imagen fue exitoso.
    if (e.TaskResult == TaskResult.OK)
    {
        GuardarEnAlmacenamientoAislado(e.ChosenPhoto);
    }
 
    MessageBox.Show("La imagen fue almacenada!");
}

El anterior fragmento, hará uso del siguiente método, enviándole como parámetro el Stream que se obtiene con la imagen de la cámara, y contiene el código para almacenar la imagen en el Almacenamiento Aislado, haciendo uso de las clases IsolatedStorageFile e IsolatedStorageFileStream, así como de la clase WriteableBitmap.

/// <summary>
/// Guarda imagen en el Almacenamiento Aislado del dispositivo.
/// </summary>
/// <param name="streamImagen">Objeto stream con la imagen a almacenar.</param>
private void GuardarEnAlmacenamientoAislado(System.IO.Stream streamImagen)
{
    // Obtener instancia de Almacenamiento Aislado de la aplicacion.
    using (IsolatedStorageFile isolatedStorage = IsolatedStorageFile.GetUserStoreForApplication())
    {
        // Eliminar la imagen si ya existe.
        if (isolatedStorage.FileExists(nombreImagen))
        {
            isolatedStorage.DeleteFile(nombreImagen);
        }
 
        // Crear imagen en el Almacenamiento Aislado.
        using (IsolatedStorageFileStream streamAlmacenamientoAislado = isolatedStorage.CreateFile(nombreImagen))
        {
            // Obtener mapa de bits a partir del stream.
            BitmapImage bmpImagen = new BitmapImage();
            bmpImagen.SetSource(streamImagen);
 
            // Guardar mapa de bits en el Almacenamiento Aislado.
            WriteableBitmap wb = new WriteableBitmap(bmpImagen);
            wb.SaveJpeg(streamAlmacenamientoAislado, wb.PixelWidth, wb.PixelHeight, 0, 100);                    
        }
    }
}

Hecho esto, tenemos la imagen ya almacenada en el dispositivo... pero ¿ahora qué?... la idea es verla, entonces implementaremos la funcionalidad para recuperar la imagen previamente almacenada.

/// <summary>
/// Obtiene imagen guardada en el almacenamiento aislado.
/// </summary>
private WriteableBitmap ObtenerImagenAlmacenamientoAislado()
{
    WriteableBitmap bitmapImagen = null;
 
    // Obtener instancia de Almacenamiento Aislado de la aplicacion.
    using (IsolatedStorageFile isolatedStorage = IsolatedStorageFile.GetUserStoreForApplication())
    {
        // Verificar si la imagen existe.
        if (isolatedStorage.FileExists(nombreImagen))
        {
            // Obtener stream con la imagen.
            using (IsolatedStorageFileStream stream = isolatedStorage.OpenFile(nombreImagen, FileMode.Open, FileAccess.Read))
            {
                // Obtener imagen a partir del stream y mostrarla en pantalla.
                bitmapImagen = PictureDecoder.DecodeJpeg(stream);                        
            }
        }
    }
 
    return bitmapImagen;
}

Y con este código hecho, implementaremos la funcionalidad del botón "Ver", para mostrar la imagen en pantalla.

/// <summary>
/// Evento click del boton Ver Imagen Guardada.
/// </summary>
/// <param name="sender">Objeto que invoca el evento.</param>
/// <param name="e">Argumentos del evento.</param>
private void btnVer_Click(object sender, RoutedEventArgs e)
{
    WriteableBitmap bitmapImagen = ObtenerImagenAlmacenamientoAislado();
 
    if (bitmapImagen != null)
    {
        imageControl.Source = bitmapImagen;
    }
    else
    {
        MessageBox.Show("La imagen no existe!");
    }
}

Realizados todos estos pasos, podemos proceder a ejecutar la aplicación en el emulador de Windows Phone, o en un dispositivo real, para comprobar su funcionamiento.

Como lo menciono también en mis otros posts, al trabajar con el Almacenamiento Aislado, se recomienda usar siempre la buena práctica de verificar la existencia de archivos para controlar errores, y como lo vemos en los métodos de almacenamiento y lectura de datos, el uso de fragmentos USING para garantizar la correcta liberación y limpieza de recursos de los objetos.

En este enlace se puede descargar el código fuente con el ejemplo de este post. ¡Espero sea util!

@hernandgr