Acceso a Contactos y Calendarios en Windows Phone Mango

Hola a todos!

Hoy vamos a ver una de las novedades que nos traerá Windows Phone Mango a los desarrolladores: el API de contactos y calendarios.

En Windows Phone 7.5 se ha incluido la capacidad de acceder a la información de contactos y de calendarios que el usuario posee en el dispositivo. Este acceso es de solo lectura, pero nos permitirá trabajar con los datos de usuario de una manera más potente que los selectores de los que disponíamos hasta ahora.

Agregado de datos

Windows phone nos ofrece una vista agregada con todas las fuentes de datos que el usuario tenga configuradas en el sistema, esto es, las diferentes cuentas que tenga. No todas las cuentas ofrecen todos los datos que usan de forma pública en el API de contactos y calendarios. Podemos usar el enumerador StorageKind para conocer las posibles fuentes de datos.

En la siguiente tabla tenemos un resumen de los diferentes proveedores y que tipos de datos podemos obtener de cada uno:

Existen ciertas “Buenas prácticas” que debemos seguir al acceder a los agregados de datos:

• El usuario debe dar permiso explicito para acceder a los datos y debemos mostrar una póliza de privacidad que acepte. (Requerimiento 2.11 de las políticas de privacidad de Windows Phone)
• En el manifiesto de nuestra aplicación (WMAppManifest.xml) debemos indicar la capacidad ID_CAP_CONTACTS para que el usuario sepa que accederemos a sus contactos.
• Los datos de contactos se ofrecen como una vista de solo lectura, si necesitamos refrescar los datos debemos volver a realizar la consulta.
• Podemos encontrar listas de datos de contactos muy grandes, debemos estar preparados, mostrando una indicación visual al usuario de que estamos cargando datos.
• Es mejor usar los campos de búsqueda predefinidos en vez de usar LINQ siempre que sea posible, están indexados y son mucho más rápidos.

Contactos

Acceder y mostrar la información de contactos en Windows Phone es realmente sencillo, como veremos en el siguiente ejemplo.

En primer lugar, vamos a realizar un ejemplo que simplemente acceda a los contactos sin filtrar y nos muestre el total de contactos existentes.

Asumimos que tenemos una aplicación de Windows Phone con un botón llamado “btnCountContacts”, debemos incluir un using del namespace Microsoft.Phone.UserData en nuestra clase:

private void btnCountContacts_Click(object sender, RoutedEventArgs e)
{
    Contacts contactos = new Contacts();

    contactos.SearchCompleted += new EventHandler<ContactsSearchEventArgs>(contactos_SearchCompleted);
    contactos.SearchAsync(string.Empty, FilterKind.None, "Prueba de contactos");
}

La búsqueda de contactos se realiza de manera asíncrona, mediante el método SearchAsync, recibiendo la respuesta el manejador de eventos que indiquemos para el evento SearchCompleted:

void contactos_SearchCompleted(object sender, ContactsSearchEventArgs e)
{
    MessageBox.Show(e.Results.Count().ToString());
}

En este caso simplemente mostramos el número total de contactos recuperados.

También del objeto Contacts podemos obtener las diferentes cuentas de las cuales se pueden obtener datos, mediante la propiedad Accounts:

Contacts contactos = new Contacts();
StringBuilder sb = new StringBuilder();
foreach (Account cuenta in contactos.Accounts)
{ 
    string c = string.Format(@"{0}{1}", cuenta.Kind,
                                            cuenta.Name);
    sb.AppendLine(c);
}
MessageBox.Show(sb.ToString());

De esta forma, obtendremos el tipo y nombre de cada cuenta que nos devuelva datos.

El siguiente ejemplo que podemos realizar nos permitirá mostrar los datos obtenidos al usuario, usando enlace a datos de Silverlight.

Partimos del mismo ejemplo anterior, recuperando todos los contactos existentes, recuerda añadir un using de Microsoft.Phone.UserData a tu clase.

En este caso, al recibir la información de contactos en el manejador del evento SearchCompleted la vamos a guardar en una propiedad pública ListaContactos que usaremos para enlazar en XAML.

public partial class MainPage : PhoneApplicationPage
{
    public List<Contact> ListaContactos { get; set; }

    // Constructor
    public MainPage()
    {
        InitializeComponent();
    }

    private void btnVerContacts_Click(object sender, RoutedEventArgs e)
    {
        Contacts contactos = new Contacts();

        contactos.SearchCompleted += new EventHandler<ContactsSearchEventArgs>(contactos_SearchCompleted);
        contactos.SearchAsync(string.Empty, FilterKind.None, "Prueba de contactos");
    }

    void contactos_SearchCompleted(object sender, ContactsSearchEventArgs e)
    {
        ListaContactos = new List<Contact>(e.Results);
        this.DataContext = ListaContactos;
    }
}

Por último podemos usar LINQ TO OBJECTS para filtrar los datos devueltos como si se tratasen de cualquier colección de objetos, por ejemplo para buscar un contacto con un email en concreto:

List<Contact> contactos = (from Contact con in e.Results
                            from ContactEmailAddress mail in con.EmailAddresses
                            where mail.EmailAddress.Contains("example")
                            select con).ToList();
this.DataContext = contactos;

Calendarios

El proceso de trabajo con calendarios es muy parecido al de contactos. Debemos recordar que, al igual que los contactos, los datos del calendario son de solo lectura. Lo primero que necesitamos realizar es añadir un using a Microsoft.Phone.UserData en nuestra clase.

El primer ejemplo que vamos a ver, simplemente obtendrá el acceso a los datos del calendario, y nos mostrará cuantos apuntes existen en los mismos, usando el objeto Appointments.

private void btnCountAppointments_Click(object sender, RoutedEventArgs e)
{
    Appointments apuntes = new Appointments();

    apuntes.SearchCompleted += new EventHandler<AppointmentsSearchEventArgs>(apuntes_SearchCompleted);
    apuntes.SearchAsync(DateTime.Now.AddMonths(-1), DateTime.Now, "Busqueda de apuntes");
}

La única diferencia con contactos es que, en este caso, realizamos la busqueda entre fechas, lo cual nos devolverá los apuntes de los calendarios comprendidos entre la fecha de inicio y de final indicadas, ambas incluidas. Recibimos la respuesta en el manejador del evento SearchCompleted al igual que en los contactos:

void apuntes_SearchCompleted(object sender, AppointmentsSearchEventArgs e)
{
    MessageBox.Show(e.Results.Count().ToString());
}

También del objeto Appointments podemos usar la propiedad Accounts, que contiene todas las cuentas registradas en el teléfono que nos están devolviendo datos:

Appointments apuntes = new Appointments();
StringBuilder sb = new StringBuilder();
foreach (Account cuenta in apuntes.Accounts)
{
    string c = string.Format(@"{0}{1}", cuenta.Kind,
                                            cuenta.Name);
    sb.AppendLine(c);
}
MessageBox.Show(sb.ToString());

Con este código, obtendremos un cuadro de mensaje que contendrá todas las cuentas que nos sirven datos, con su tipo y nombre.

También podemos usar el resultado de la búsqueda en el objeto Appointments para mostrar datos en una lista.

Lo primero que necesitamos realizar es obtener todos los datos entre dos fechas y en el manejador del evento SearchCompleted rellenar nuestra ListaApuntes que se encuentra enlazada a la lista en XAML.

public partial class MainPage : PhoneApplicationPage
{

    public List<Appointment> ListaApuntes { get; set; }
    // Constructor
    public MainPage()
    {
        InitializeComponent();
    }

    private void btnVerApuntes_Click(object sender, RoutedEventArgs e)
    {
        Appointments apuntes = new Appointments();

        apuntes.SearchCompleted += new EventHandler<AppointmentsSearchEventArgs>(apuntes_SearchCompleted);
        apuntes.SearchAsync(DateTime.Now.AddMonths(-6), DateTime.Now.AddMonths(3), "Busqueda de apuntes");
    }

    void apuntes_SearchCompleted(object sender, AppointmentsSearchEventArgs e)
    {
        ListaApuntes = new List<Appointment>(e.Results);
        this.DataContext = ListaApuntes;
    }
}

Por último también podemos usar LINQ TO OBJECTS para filtrar los resultados obtenidos en el manejador de eventos SearchCompleted, por ejemplo, para mostrar solo los eventos que tengan duración de día completo:

List<Appointment> apuntes = (from Appointment ap in e.Results
                                where ap.IsAllDayEvent == true
                                select ap).ToList();
this.DataContext = apuntes;

Tenemos que tener en cuenta, que para probar estos ejemplos necesitaremos hacerlo en un dispositivo de desarrollo, puesto que el emulador no contiene datos de ejemplo para el calendario, aunque sí para los contactos.

A continuación tenéis el código fuente de los dos ejemplos usados aquí, espero que os sea de utilidad y Happy Coding!