“Sviluppare Universal Windows app per Windows Phone e Windows” ora in libreria

Print Content | More

In realtà non è una vera e propria novità, ma una serie di impegni (nonchè un cambio di vita professionale, che però vi racconterò nel prossimo post) mi ha costretto a posticipare questo post. Da poco più di un mese, è disponibile in tutte le librerie e in formato digitale il mio nuovo libro in italiano, intitolato “Sviluppare Universal Windows App per Windows Phone e Windows con XAML e C#”. Nel corso di poco più di 600 pagine, articolate in 12 capitoli, il lettore sarà introdotto allo sviluppo di applicazioni di nuova generazione per le piattaforme Microsoft, ovvero Windows 8.1 e Windows Phone 8.1. I primi capitoli affrontano i concetti base (i tool di sviluppo, lo XAML, la navigazione, ecc.) per poi approfondire temi più specifici come lo storage, l’uso della rete, l’interazione con i sensori, la gestione delle tile e delle notifiche push, ecc. L’ottica è quella delle Universal app, quindi gli argomenti affrontati sono attuabili sia per lo sviluppo di applicazioni Windows Phone che Windows 8.1. Il libro non da nulla per scontato per quanto riguarda lo sviluppo della nuova tipologia di applicazioni basata sul Windows Runtime, perciò è rivolto sia a chi è alle prime armi, sia a chi ha già avuto esperienza nello sviluppo di applicazioni usando Silverlight. Unica eccezione: è richiesta una conoscenza almeno base della programmazione ad oggetti del linguaggio C#, in quanto viene data per acquisita. Inoltre, il libro prende in considerazione le novità di Windows Phone 8.1 solo dal punto di vista del Windows Runtime e delle Universal Windows app: la maggior parte delle novità trattate sono valide anche per chi sceglie la strada di Sivlerlight 8.1, ma questo percorso non viene approfondito.

Trovate il libro nelle migliori librerie sia tradizionali, che online: potete acquistarlo, ad esempio, sia in formato cartaceo (al prezzo di 38, 17 euro) che digitale (al prezzo di 31,99) su Amazon. A breve saranno pubblicati, su questo blog, anche tutti gli esempi di codice.


Windows Phone , Windows 8

0 comments

Le novità di Windows Phone 8.1 per gli sviluppatori

Print Content | More

Martedì ha avuto inizio a San Francisco BUILD, la più importante conferenza per gli sviluppatori Microsoft. Il keynote introduttivo è stata l’occasione per lanciare ufficialmente Windows Phone 8.1, la nuova versione della piattaforma, che ha introdotto tantissime novità sia per gli utenti finali che per gli sviluppatori. Quella principale è sicuramente l’allineamento del Windows Runtime, che rende possibile lo sviluppo delle Universal Windows app, ovvero applicazioni in grado di funzionare su Windows Phone, Windows 8 e, in futuro, anche su XBox One. Si tratta, comunque, di applicazioni e progetti Visual Studio separati: la novità è che, grazie al runtime comune, saremo in grado di scrivere la logica una volta sola e di concentrarci soprattutto sulla definizione dell’interfaccia utente (visto che, anche se con parecchie similitudini, si tratta comunque di dispositivi differenti).

Trovare un riepilogo di tutte le novità presentate nel mio articolo pubblicato su ASPItalia, disponibile all’indirizzo http://www.winphoneitalia.com/articoli/windows-phone/windows-phone-8.1.aspx. Buona lettura!

 


Windows Phone , Windows 8 , Microsoft

0 comments

Windows Phone 8 Development Succintly: una risorsa gratuita per gli sviluppatori

Print Content | More

E’ con piacere che vi segnalo che Syncfusion, una società molto popolare tra gli sviluppatori grazie alle ottime suite di controlli da loro distribuite, ha rilasciato da poco il mio nuovo libro in inglese, intitolato Windows Phone 8 Development Succinctly. Si tratta di un e-book (disponibile perciò esclusivamente in versione digitale) completamente gratuito composto da 243 pagine e che copre i principali aspetti dello sviluppo di applicazioni per Windows Phone, da quelli base (come lo XAML, il ciclo di vita delle applicazioni, ecc.) fino ad arrivare a quelli più avanzati (come i background task, la geo localizzazione, le speech API, etc.).

Di seguito trovate l’elenco completo (in inglese) dei capitoli di cui è composto il libro:

  1. Introduction
  2. The User Interface: Basic XAML Concepts
  3. Core Concepts
  4. Data Access: Storage
  5. Data Access: Network
  6. Integrating with the Hardware
  7. Integrating with the Operating System
  8. Multimedia Applications
  9. Live Apps: Tiles, Notifications, and Multitasking
  10. Distributing the Application: Localization, the Windows Phone Store, and In-App Purchases

Il libro viene distribuito gratuitamente da Syncfusion, è necessario solamente registrarsi sul sito, dopodichè sarete in grado di scaricarlo sia in formato PDF e che Kindle. Spero che il libro possa essere un’ottima risorsa sia per i nuovi sviluppatori, che vogliono imparare le basi di Windows Phone, sia per gli sviluppatori più esperti, che possono usare il libro come punto di riferimento per approfondire le varie caratteristiche della piattaforma.

Per registrarvi e ottenere la vostra copia gratuita l’indirizzo è http://www.syncfusion.com/resources/techportal/ebooks/windowsphone8

 

Vi


Windows Phone , Syncfusion

0 comments

Integrare Facebook nelle vostre applicazioni tramite l’applicazione ufficiale

Print Content | More

Se, oltre che sviluppatori, siete anche utenti Windows Phone, saprete probabilmente che Microsoft offre due versioni dell’applicazione ufficiale di Facebook: una standard e una beta. La seconda funge semplicemente da “ambiente di test allargato” per le nuove feature che, periodicamente, vengono aggiunte all’applicazione dal team di sviluppo: dopo un certo periodo di tempo, tali feature vengono considerate stabili e portate nell’applicazione ufficiale. Qualche mese fa Microsoft ha aggiunto alla versione beta una feature molto interessante per gli sviluppatori: la possibilità di usarla come un “ponte” per integrare Facebook nelle applicazioni di terze parti. Tale feature è comunque basata sull’attuale Facebook SDK for .NET (una libreria disponibile su NuGet che funge da wrapper alle API REST di Facebook) ma, invece di costringere lo sviluppatore a implementare e gestire il flusso di login, consente di appoggiarsi all’applicazione ufficiale. In questo modo, il flusso sarà il seguente:

  • L’applicazione inizia la procedura di login.
  • L’applicazione di Facebook viene aperta: l’utente dovrà immettere le proprie credenziali (se non l’ha mai fatto in precedenza) e confermare i permessi richiesti.
  • L’applicazione iniziale viene riaperta, ricevendo in input l’Access Token richiesto dall’SDK di Facebook per effettuare qualsiasi tipo di operazione (come pubblicare un messaggio o recuperare i dati dell’utente collegato).

I vantaggi principali di questo approccio è che dovremo scrivere meno codice e che, nella maggior parte dei casi, l’utente dovrà semplicemente confermare i permessi richiest: dato che, probabilmente, l’utente usa regolarmente l’applicazione per accedere a Facebook, sarà già loggato e quindi non dovrà inserire le credenziali tutte le volte. E se l’utente non dovesse avere l’applicazione? Nessun problema: dato che il metodo è basato sulla funzionalità introdotta in Windows Phone 8 che consente alle applicazioni di registrare un protocollo per condividere i dati con altre applicazioni, l’utente sarà semplicemente invitato a scaricare l’applicazione dallo Store nel caso non l’avesse già installata.

Fino a qualche giorno fa, tale feature era disponibile solo per scenari di testing: la maggior parte degli utenti usa l’applicazione ufficiale, non la versione beta. Inoltre, dato che l’applicazione beta risulta nascosta sullo Store (è possibile trovarla solo tramite il link specifico), nel caso l’utente non ce l’abbia gli sarà comunque richiesto di scaricarla dallo Store, ma non sarà in grado di trovarla. Pochi giorni fa, però, l’applicazione ufficiale è stata aggiornata includendo tutti i miglioramenti recentemente introdotti nella versione beta (come le nuove tile), compreso il supporto a questo nuovo metodo di autenticazione. Non avete perciò più scuse per non usarlo!

Questa feature è stata dettagliata in un post sul blog ufficiale del team qualche tempo fa, che ho usato come base di partenza per scrivere questo post. Il post ufficiale è molto valido, ma può essere complicato da capire se non avete parecchia esperienza con lo sviluppo di applicazioni Windows Phone, in quanto da per scontato molti concetti come la registrazione di un protocollo e l’uso della classe UriMapper.

Vediamo perciò come integrare la nostra applicazione con Facebook con questo nuovo approccio.

Pubblicare la propria applicazione

Probabilmente vi starete chiedendo perchè la pubblicazione dell’app, che solitamente è l’ultima fase del lavoro, sia qui indicata come primo passaggio da effettuare. Per configurare correttamente il processo di autenticazione avrete la necessità di conoscere l’Application Id assegnato alla vostra applicazione. Il problema è che, quando create un nuovo progetto con Visual Studio, vi viene assegnato un Application Id casuale: nel momento in cui l’applicazione viene inviata sullo Store, viene generato e assegnato il vero Application Id, che va a sovrascrivere quello fittizio presente nel file di manifest. Il primo passaggio, però, è chiedere al Dev Center di generare un application id reale per la nostra applicazione: per farlo, dovete semplicemente iniziare il processo di pubblicazione di una nuova app e caricare lo XAP (anche non definitivo) nello Step 2. A questo punto, annullate semplicemente il processo tornando alla Dashboard principale: trovetere la vostra app nella sezione In-progress submissions. Cliccateci sopra e andate nella sezione Details: trovere il campo App ID popolato con l’Application Id reale che vi è stato assegnato. Segnatevelo da qualche parte: ci servirà più avanti.

Importante! Quando la vostra app è terminata e siete pronti a pubblicarla, ricordatevi di riutilizzare la submission che avete appena creato e non di crearne una nuova; altrimenti all’applicazione sarà assegnato un nuovo Application Id, “rompendo” perciò il processo di autenticazione su Facebook che stiamo per configurare.

Registrare l’applicazione su Facebook

Il secondo passaggio è quello di registrare la vostra applicazione su Facebook: tutte le app che hanno la necessità di interagire con le API di Facebook, infatti, devono essere registrate sul portale dedicato per gli sviluppatori. In questo modo avrete accesso ad una serie di dati che sono indispensabili per utilizzare l’SDK di Facebook (come l’Application Id assegnato da Facebook). Per effettuare questo passaggio andate su https://developers.facebook.com, cliccate su Apps (posizionato nel menu in alto) e scegliete Create new app. Per interagire con un’applicazione Windows Phone sono solamente due i campi da compilare:

  • Il nome dell’applicazione, che deve essere impostato nel campo Display name.
  • La modalità con cui l’applicazione si deve integrare con Facebook: selezionate Windows App dalla lista e nel campo Windows Phone Store ID [BETA] inserite l’Application Id che avete precedentemente ottenuto dal Dev Center (dovrete rimuovere i trattini perciò se, per esempio, l’id che vi è stato assegnato è b94ca943-21f1-4ef7-9895-b44a32dc1230, dovrete inserire come valore b94ca94321f14ef79895b44a32dc1230).

image_thumb8

Registrare il protocollo nel file di manifest

La possibilità di registrare un protocollo da parte di un’applicazione di terze parti è stata introdotta in Windows Phone 8 e consente di registrare uno specifico protocollo (ad esempio, foo:/), così che altre applicazioni possano interagire con la vostra. Questa tecnica viene utilizzata per gestire il login tramite Facebook: dopo aver completato la procedura, l’applicazione ufficiale richiamerà la vostra app tramite un Uri specifico. In questo modo, sarete in grado di intercettare la chiamata e recuperare il risultato dell’operazione. Per registrare un protocollo è necessario modificare il file di manifest: dovrete farlo manualmente, però, dato che questo scenario non è supportato dall’editor visuale. Fate clic con il tasto destro sul file di manifest (il file chiamato WMAppManifest.xml incluso all’interno della cartella Properties) e scegliete View code: avrete accesso direttamente all’XML che definisce il file.

Sotto la sezione Tokens dovrete aggiungerne una nuova (se non esiste già) chiamata Extensions nel seguente modo:

<Extensions>
  <Protocol Name="msft-b94ca94321f14ef79895b44a32dc1230" NavUriFragment="encodedLaunchUri=%s" TaskID="_default" />
</Extensions>

L’unica cosa che dovrete cambiare è il valore dell’attributo Name: deve essere uguale a msft- seguito dallo stesso Application Id che avete recuperato dal Dev Center e che avete specificato in precedenza nel portale per gli sviluppatori di Facebook (come potete notare, anche in questo caso dovete rimuovere i trattini).

E’ ora di scrivere un po’ di codice!

Ora siete pronti per scrivere un po’ di codice e iniziare a gestire realmente il processo di login. Il primo passaggio è installare due librerie da NuGet, che forniscono l’accesso alle API per interagire con Facebook: la prima è già stata citata in precedenza e si chiama Facebook for .NET SDK, mentre la seconda si chiama Facebook Client for .NET SDK, la quale aggiunge una serie di librerie specifiche per le applicazioni Windows Phone e Windows 8. Nota bene: per trovare il secondo pacchetto su NuGet dovete estendere la ricerca anche alle librerie in pre-release.

Il secondo passaggio, che non è obbligatorio ma vi aiuterà a rendere le cose più semplici, è quello di utilizzare una classe creata da Microsoft per l’occasione chiamata SessionStorage: si tratta di un semplice wrapper alla classe IsolatedStorageSettings, che aggiunge però la possibilità di criptare i dati memorizzati. In questo modo, saremo in grado di salvare in maniera sicura l’access token restituito da Facebook. Per utilizzare questo helper, semplicemente create una nuova classe, chiamatela SessionStorage e incollate il codice seguente:

public class SessionStorage
{
    /// <summary>
    /// Key used to store access token in app settings
    /// </summary>
    private const string AccessTokenSettingsKeyName = "fb_access_token";

    /// <summary>
    /// Key used to store access token expiry in app settings
    /// </summary>
    private const string AccessTokenExpirySettingsKeyName = "fb_access_token_expiry";

    /// <summary>
    /// Key used to state in app settings
    /// </summary>
    private const string StateSettingsKeyName = "fb_login_state";

    /// <summary>
    /// Tries to retrieve a session
    /// </summary>
    /// <returns>
    /// A valid login response with access token and expiry, or null (including if token already expired)
    /// </returns>
    public static FacebookSession Load()
    {
        // read access token
        string accessTokenValue = LoadEncryptedSettingValue(AccessTokenSettingsKeyName);

        // read expiry
        DateTime expiryValue = DateTime.MinValue;
        string expiryTicks = LoadEncryptedSettingValue(AccessTokenExpirySettingsKeyName);
        if (!string.IsNullOrWhiteSpace(expiryTicks))
        {
            long expiryTicksValue = 0;
            if (long.TryParse(expiryTicks, out expiryTicksValue))
            {
                expiryValue = new DateTime(expiryTicksValue);
            }
        }

        // read state
        string stateValue = LoadEncryptedSettingValue(StateSettingsKeyName);

        // return true only if both values retrieved and token not stale
        if (!string.IsNullOrWhiteSpace(accessTokenValue) && expiryValue > DateTime.UtcNow)
        {
            return new FacebookSession()
            {
                AccessToken = accessTokenValue,
                Expires = expiryValue,
                State = stateValue
            };
        }
        else
        {
            return null;
        }
    }

    /// <summary>
    /// Saves an access token an access token and its expiry
    /// </summary>
    /// <param name="session">A valid login response with access token and expiry</param>
    public static void Save(FacebookSession session)
    {
        SaveEncryptedSettingValue(AccessTokenSettingsKeyName, session.AccessToken);
        SaveEncryptedSettingValue(AccessTokenExpirySettingsKeyName, session.Expires.Ticks.ToString());
        SaveEncryptedSettingValue(StateSettingsKeyName, session.State);
    }

    /// <summary>
    /// Removes saved values for access token and expiry
    /// </summary>
    public static void Remove()
    {
        RemoveEncryptedSettingValue(AccessTokenSettingsKeyName);
        RemoveEncryptedSettingValue(AccessTokenExpirySettingsKeyName);
        RemoveEncryptedSettingValue(StateSettingsKeyName);
    }

    /// <summary>
    /// Removes an encrypted setting value
    /// </summary>
    /// <param name="key">Key to remove</param>
    private static void RemoveEncryptedSettingValue(string key)
    {
        if (IsolatedStorageSettings.ApplicationSettings.Contains(key))
        {
            IsolatedStorageSettings.ApplicationSettings.Remove(key);
            IsolatedStorageSettings.ApplicationSettings.Save();
        }
    }

    /// <summary>
    /// Loads an encrypted setting value for a given key
    /// </summary>
    /// <param name="key">The key to load</param>
    /// <returns>
    /// The value of the key
    /// </returns>
    /// <exception cref="KeyNotFoundException">The given key was not found</exception>
    private static string LoadEncryptedSettingValue(string key)
    {
        string value = null;
        if (IsolatedStorageSettings.ApplicationSettings.Contains(key))
        {
            var protectedBytes = IsolatedStorageSettings.ApplicationSettings[key] as byte[];
            if (protectedBytes != null)
            {
                byte[] valueBytes = ProtectedData.Unprotect(protectedBytes, null);
                value = Encoding.UTF8.GetString(valueBytes, 0, valueBytes.Length);
            }
        }

        return value;
    }

    /// <summary>
    /// Saves a setting value against a given key, encrypted
    /// </summary>
    /// <param name="key">The key to save against</param>
    /// <param name="value">The value to save against</param>
    /// <exception cref="System.ArgumentOutOfRangeException">The key or value provided is unexpected</exception>
    private static void SaveEncryptedSettingValue(string key, string value)
    {
        if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(value))
        {
            byte[] valueBytes = Encoding.UTF8.GetBytes(value);

            // Encrypt the value by using the Protect() method.
            byte[] protectedBytes = ProtectedData.Protect(valueBytes, null);
            if (IsolatedStorageSettings.ApplicationSettings.Contains(key))
            {
                IsolatedStorageSettings.ApplicationSettings[key] = protectedBytes;
            }
            else
            {
                IsolatedStorageSettings.ApplicationSettings.Add(key, protectedBytes);
            }

            IsolatedStorageSettings.ApplicationSettings.Save();
        }
        else
        {
            throw new ArgumentOutOfRangeException();
        }
    }
}

Ora possiamo iniziare a implementare la vera procedura di login, che viene effettuata usando la classe FacebookSessionClient: per crearne una nuova instanza vi sarà richiesto, come parametro, l’Application Id assegnato da Facebook, che potrete trovare sul portale per gli sviluppatori, come evidenziato nel seguente screenshot.

image_thumb4

Ecco un esempio di codice completo per effettuare il login:

private void OnLoginClicked(object sender, GestureEventArgs e)
{
    FacebookSessionClient fb = new FacebookSessionClient("563659977051507");
    fb.LoginWithApp("basic_info,publish_actions,read_stream", "custom_state_string");
}

Il metodo da utilizzare si chiama LoginWithApp e richiede due parametri:

  • Il primo è l’elenco completo di permessi che volete utilizzare. Potete trovare tutti quelli disponibili sulla documentazione ufficiale: il codice di esempio precedente consente di avere accesso al profilo dell’utente, alla sua timeline e ci abilita a pubblicare post a suo nome.
  • Il secondo parametro è una stringa personalizzata che viene restituita dall’applicazione una volta che la procedura di login è terminata: lo utilizzeremo per implementare la logica necessaria quando l’applicazione viene riaperta al termine del login.

Come descritto in precedenza, questo nuovo approccio per il login è basato sulla possibilità per le applicazioni di terze parti di registrare un protocollo: una volta che il login è stato completato, l’applicazione di Facebook invocherà nuovamente la nostra tramite un Uri speciale, che dovremo intercettare per recuperare, dai parametri in query string, l’Access Token e determinare se la procedura sia andata a buon fine o no. Il modo migliore per raggiungere il nostro scopo è usare la classe UriMapper: si tratta di un approccio che vi sarà famigliare se avete già lavorato con scenari simili, come l’utilizzo delle Speech API. In parole povere, questa classe funge da intermediario in tutte le richiste di navigazione: ogni volta che l’utente si sposta da una pagina all’altra dell’applicazione (o da un’altra applicazione alla vostra), questa classa sarà in grado di intercettare la navigazione e analizzare l’Uri di provenienza, così da poter eventualmente modificare il flusso di navigazione.

Per creare un UriMapper dovete semplicemente creare una nuova classe, la quale dovrà ereditare dalla classe base UriMapperBase. Sarete obbligati a implementare il metodo MapUri(), che viene invocato ad ogni navigazione. Ecco il codice completo:

public class FacebookUriMapper: UriMapperBase
{
    private bool facebookLoginHandled;

    public override Uri MapUri(Uri uri)
    {
        if (AppAuthenticationHelper.IsFacebookLoginResponse(uri))
        {
            FacebookSession session = new FacebookSession();
            try
            {
                session.ParseQueryString(HttpUtility.UrlDecode(uri.ToString()));

                // Handle success case
                // do something with the custom state parameter
                if (session.State != "custom_state_string")
                {
                    MessageBox.Show("Unexpected state: " + session.State);
                }
                else
                {
                    // save the token and continue (token is retrieved and used when the app
                    // is launched)
                    SessionStorage.Save(session);
                }
            }
            catch (Facebook.FacebookOAuthException exc)
            {
                if (!this.facebookLoginHandled)
                {
                    // Handle error case
                    MessageBox.Show("Not signed in: " + exc.Message);
                    this.facebookLoginHandled = true;
                }
            }
            return new Uri("/MainPage.xaml", UriKind.Relative);
        }
        // by default, navigate to the requested uri
        return uri;
    }
}

Tale codice verifica se l’Uri con cui è stata aperta l’app è quello utilizzato dall’applicazione di Facebook: in tal caso, recuperiamo le informazioni sulla sessione di login e le salviamo in maniera criptata nello storage tramite la classe SessionStorage.

L’ultimo passaggio è abilitare l’UriMapper, registrandolo nel frame dell’applicazione: aprite il file App.xaml.cs e cercate il metodo chiamato InitializePhoneApplication() (che, tipicamente, è nascosto all’interno di una regione chiamata Phone application initialization). Subito dopo l’inizializzazione dell’oggetto RootFrame create semplicemente una nuova instanza della vostra classe UriMapper e assegnatela alla proprietà UriMapper, come nell’esempio seguente:

RootFrame = new PhoneApplicationFrame();
RootFrame.Navigated += CompleteInitializePhoneApplication;
RootFrame.UriMapper = new FacebookUriMapper();

Integragrsi con Facebook: recuperare le informazioni dell’utente

Ora che siete in possesso di un token di Facebook valido, potete utilizzarlo per interagire con le API offerte dal social network tramite la classe FacebookClient fornita dall’SDK di Facebook per .NET. Tale classe funge da wrapper alle API REST di Facebook e offra una serie di metodi che sfruttano i comandi standard del protocollo HTTP (ad esempio, per recuperare dati si effettuano delle GET, mentre per pubblicare degli aggiornamenti si effettua una POST).

Il seguente codice di esempio mostra come recuperare il nome dell’utente che ha effettuato il login:

private async void OnShowNameClicked(object sender, GestureEventArgs e)
{
    FacebookSession session = SessionStorage.Load();
    FacebookClient client = new FacebookClient(session.AccessToken);

    dynamic result = await client.GetTaskAsync("me");
    string name = result.name;
    MessageBox.Show(name);
}

Il primo passo è caricare la sessione che abbiamo precedentemente memorizzato, sfruttando il metodo Load() della classe SessionStorage. Una volta in possesso dell’oggetto di tipo FacebookSession possiamo sfruttarlo per accedere alle informazioni che ci servono: nello specifico, utilizziamo la proprietà AccessToken per passarla come parametro del costruttore della classe FacebookClient.

Dato che recuperare le informazioni da Facebook significa effettuare un’operazione di GET, utilizziamo il metodo GetTaskAsync(), che è basato sulle Open Graph API di Facebook. Come parametro in ingresso è necessario specificare il percorso definito dalle Open Graph API: nello specifico, me è il percorso necessario per recuperare le informazioni sull’utente loggato.

Il metodo restituisce un dizionario, ovvero una collezione di dati identificati in maniera univoca da una chiave: nello specifico, ogni chiave identifica una delle informazioni relative all’utente (ad esempio, la chiave name contiene il nome completo). Nel codice di esempio precedente trovate una dimostrazione di un approccio diverso dal solito per gestire questo scenario: invece che lavorare con la classe Dictionary<string, object>, utilizziamo la parola chiave dynamic; in questo modo possiamo trattare il risultato del metodo GetTaskAsync() come se fosse un oggetto dinamico e non statico (in modo simile a quello che avviene quando si lavora con linguaggi dinamici come Javascript). In questo modo, siamo in grado di ottenere il nome dell’utente semplicemente richiedendo il valore della proprietà name. Possiamo usare lo stesso approccio per ottenere altre informazioni, come surname per il cognome o birthday per la data di nascita: qui trovate un elenco di tutti i valori disponibili. Come accorgersi che state lavorando con un oggetto dinamico? Semplicemente provate ad attivare l’Intellisense una volta posizionati sull’oggetto result che avete dichiarato come dynamic: vi accorgerete di come non sarete in grado di vedere le proprietà disponibili proprio perchè non sono statiche e dichiarate in fase di compilazione, ma vengono risolte dinamicamente.

Integrarsi con Facebook: pubblicare un post

Un altro scenario comune nell’integrazione con Facebook è la pubblicazione di nuovi post. Ecco un esempio di codice che pubblica un nuovo messaggio sulla timeline dell’utente:

private async void OnPostMessageClicked(object sender, GestureEventArgs e)
{
    FacebookSession session = SessionStorage.Load();
    FacebookClient client = new FacebookClient(session.AccessToken);

    var parameters = new Dictionary<string, object>();
    parameters.Add("message", "First test post using Facebook login");

    await client.PostTaskAsync("me/feed", parameters);
}

La prima porzione di codice è la stessa vista in precedenza: tramite la classe SessionStorage recuperiamo il token necessario per creare una nuova instanza della classe FacebookClient.

La differenza principale rispetto al codice precedente è che dobbiamo inviare un parametro in input: lo facciamo creando un nuovo set di parametri (rappresentato dalla collezione di tipo Dictionary<string, object>) con, al suo interno, una proprietà di nome message. Il valore assegnato è semplicemente il testo del messaggio da pubblicare. Infine, utilizziamo il metodo PostTaskAsync() per effettuare la pubblicazione vera e propria (dato che, in questo caso, è una operazione di POST): anche in questo caso dobbiamo specificare il percorso delle API Open Graph (me/feed) e, in più, il set di parametri definito in precedenza.

In conclusione

Ci sono molte altre operazioni che potete fare per integrare Facebook nella vostra applicazione: trovate molti esempi relativi all’utilizzo della libreria Facebook SDK for .NET sul sito ufficiale; dovete però considerare che tali esempi sono basati su una versione precedente della libreria, che utilizza un approccio asincrono basato su callback anzichè quello più attuale basato sul pattern async e await.

Il vantaggio principale di questo approccio è che vi permette di risparmiare parecchio tempo nell’integrazione di Facebook nella vostra applicazione: la fase di login, infatti, è probabilmente l’aspetto più complesso e articolato da gestire. Inoltre, dal punto di vista dell’utente, l’esperienza d’uso offerta sarà superiore: dato che l’applicazione di Facebook è di uso comune, non avrà bisogno di inserire le credenziali di login tutte le volte. L’unico svantaggio è che è basato su un’applicazione di terze parti, anche se ufficiale: nel caso in cui l’utente non la utilizzi (perchè, ad esempio, preferisce utilizzarne una non ufficiale o direttamente la versione mobile del sito) sarà costretto a scaricarla per utilizzare l’integrazione con Facebook. Tale requisito potrebbe far cambiare idea all’utente e convincerlo a non usare più la nostra applicazione.


Windows Phone , Facebook

1 comments

Nuovi emulatori GDR3 per Windows Phone

Print Content | More

Qualche giorno fa Microsoft ha rilasciato un nuovo set di emulatori allineati con l’ultimo aggiornamento di Windows Phone, GDR3, il quale è disponibile da qualche tempo per gli sviluppatori e che sarà distribuito a breve a tutti gli utenti. Una delle novità principali è l’aggiunta di un nuovo emulatore con il supporto alla nuova risoluzione 1080p (1080x1920). E’ importante però sottolineare come risoluzione e dimensione dello schermo siano due parametri differenti. Se la vostra applicazione è in esecuzione su un device che utilizza la risoluzione 1080p, non significa necessariamente che sia dotato anche di uno schermo di grandi dimensioni. Prendete, per esempio, il Lumia 1320: supporta la stessa risoluzione di altri dispositivi sul mercato (ovvero la 720p) come l’HTC 8X, ma offre uno schermo molto più grande (6 pollici).

Questo significa che conoscere la risoluzione del dispositivo non è sufficiente: se volete ottimizzare la vostra applicazione per i dispositivi dotati di schermi molto grandi (mostrando, ad esempio, più informazioni), dovete scoprire la reale dimensione dello schermo. Tutti gli emulatori inclusi nell’SDK simulano un dispositivo standard: potete notare, infatti, che l’emulatore 1080p offre l’interfaccia standard con due colonne di tile, mentre dispositivi come il Lumia 1520 o il Lumia 1320 ne offrono tre di colonne.

Come fare, perciò, ad ottimizzare le nostre applicazioni per i dispositivi di grandi dimensioni senza essere costretti ad acquistarne uno? Rudy Huyn, lo sviluppatore di molte celebri applicazioni come 6tag o 6sec, ha sviluppato una semplice classe che può essere utilizzata per “simulare” la presenza di un grande schermo anche utilizzando uno degli emulatori standard.

Ecco due articoli che vi possono aiutare nell’ottimizzare le vostre applicazioni:

Vi segnalo, infine, che a fine Febbraio si terranno a Milano i Community Days, l’appuntamento community più importante dell’anno che si articolerà nell’arco di tre giorni. In tale occasione proporrò una sessione dedicata proprio all’ottimizzazione delle applicazioni per i nuovi schermi. Vi aspetto!


Windows Phone

0 comments

MVP per un altro anno!

Print Content | More

Il primo giorno dell’anno per il sottoscritto è sempre un po’ speciale: non solo perchè è l’occasione per fare il punto della situazione su quanto accaduto nell’anno precedente e per guardare con speranza all’anno nuovo ma anche perchè, dal 2011, è il giorno in cui il mio MVP giunge al termine. Nel caso in cui non abbiate famigliarità con il programma MVP, si tratta di un riconoscimento dato da Microsoft a chi si distingue per il proprio impegno e la propria passione verso le community e la condivisione delle proprie conoscenze e competenze sulle tecnologie Microsoft (nel mio caso, relative alla categoria Windows Phone Development). Non si tratta, però, di un riconoscimento “a vita”: va “riconquistato” ogni anno, dimostrando che si è ancora meritevoli di tale onore. Per il sottoscritto, il giorno della “scadenza” è il 1° Gennaio: ed è un grandissimo piacere per me condividere con tutti che Microsoft ha confermato, anche per quest’anno, la sua fiducia nel sottoscritto, rinnovando il riconoscimento anche per il 2014!

Il 2013 è stato un anno decisamente intenso per me: ho partecipato a 2 summit, ho pubblicato il mio primo libro, ho contribuito ad organizzare la Windows Phone Week e la prima serie di webinar italiani in collaborazione con Nokia, ecc. Sono veramente tante le persone che devo ringraziare per tutte le soddisfazioni avute quest’anno! La prima è sicuramente mia moglie Angela, che continua a supportarmi nelle mie attività, nonostante spesso e volentieri portino via un po’ del tempo che potremmo trascorrere insieme. Vorrei ringraziare anche, in ordine sparso:

  • Lorenzo Barbieri, non solo per la sua amicizia ma anche perchè, come Windows Phone Champ ed evangelist, assieme a tutto il team di DPE Italia, offre un grande supporto alle attività community che vengono organizzate.
  • Daniele Pagani, Luca De Bernardi e Frangino Lucarini, che fanno parte del team di Nokia Italia che sta svolgendo un lavoro eccellente nel supportare gli sviluppatori italiani e le nostre attività come Nokia Champion.
  • Desiree Lockwood, la nostra referente come MVP nella categoria Windows Phone Development. Oltre ad essere una persona eccezionale, sta facendo un lavoro enorme nel supportare le nostre attività. Senza di lei, la Windows Phone Week (nonchè moltre altre iniziative) sarebbero solamente un’idea fuori di testa.
  • La famiglia degli MVP nella categoria Windows Phone Development (con una citazione speciale per Joost Van Schaik): sono la prova vivente che essere parte della famiglia degli MVP non significa solamente conoscere dei grandi professionisti, ma anche trovare amici importanti, indipendentemente dalla distanza che ci separa.
  • Ugo Lattanzi: se oggi ho l’onore di far parte della famiglia degli MVP, è tutta colpa sua Smile Cinque anni fa ormai mi ha fatto scoprire il mondo community, convincendomi ad aprire il mio primo blog e a tenere la mia prima sessione su Windows Phone. Tutto è iniziato da lì Smile
  • Funambol e il mio team: sono entrato a far parte dell’azienda da più di un anno ed è stata una delle occasioni più importanti della mia vita. Ho conosciuto molte persone e amici speciali e ho la fortuna di lavorare per una società che da grande valore al ruolo delle community e che supporta le mie attività. Sono veramente orgoglioso di farne parte!

Ma, ovviamente, il mio ringraziamento più grande va a tutti gli sviluppatori e alle community che continuano a supportarmi (e sopportarmi Smile), a credere in me e ad incoraggiarmi a dare sempre il massimo. Non vedo l’ora di poter lavorare nuovamente con voi nel 2014!


MVP

2 comments

WP Dev Fusion: una nuova iniziativa community!

Print Content | More

Una delle più belle e inaspettate soddisfazioni del 2013 è sicuramente stata l’organizzazione della Windows Phone Week: nata come un’idea un po’ pazza con il supporto di 2 amici MVP, si è trasformata nel giro di poco tempo in un’iniziativa globale che ha portato all’organizzazione di più di 20 eventi in tutto il mondo, a cui hanno partecipato più di 2000 persone. Dopo aver visto il successo dell’iniziativa, una cosa era chiara: dovevamo sfruttare le potenzialità della Windows Phone Week, per poter continuare a supportare il lavoro degli sviluppatori Windows Phone e, allo stesso tempo, per migliorare e imparare dagli errori commessi.

La “scintilla” per iniziare a pensare al futuro della Windows Phone Week è arrivata grazie ad un altro amico MVP, Peter Nowak, che durante il summit ha condiviso con noi una sua idea: perchè non estendere la Windows Phone Week anche a tutte le persone che non hanno la possibilità di partecipare di persona agli eventi per motivi logistici? Perchè non trovare il modo di coinvolgere il più persone possibile nelle iniziative su Windows Phone? Da questa discussione è nato WP Dev Fusion, il successore della Windows Phone Week.

Di cosa si tratta di preciso? Di una nuova iniziativa community, con l’obiettivo di continuare il lavoro iniziato con la Windows Phone Week e di estenderlo e migliorarlo ancora di più, così da raggiungere ancora più persone. WP Dev Fusion continuerà a supportare l’approccio tradizionale iniziato con la Windows Phone Week: sicuramente nel 2014 ci sarà occasione per organizzare diversi eventi in tutto il mondo, grazie al supporto di Microsoft e Nokia, così da avere la possibilità non solo di condividere conoscenze e contenuti, ma anche e soprattutto di far incontrare gli sviluppatori Windows Phone tra di loro. Avremo però anche un’anima “online”, con lo scopo di raggiungere a chi non ha la possibilità di partecipare agli eventi tradizionali: non ci limiteremo solamente a condividere le notizie più interessanti sullo sviluppo per Windows Phone tramite i nostri canali social, ma organizzeremo anche diverse conferenze virtuali, che avrete la possibilità di seguire comodamente da casa vostra.

E quale modo di inaugurare questa nuova iniziativa se non con una conferenza? Ho il piacere, perciò, di presentarvi il primo evento targato WP Dev Fusion, che si terrà online il 22 Gennaio a partire dalle ore 18 (ora italiana). Dopo una breve introduzione, la parola andrà agli speaker, che presenteranno una serie di sessioni dedicati ad alcuni degli argomenti più “caldi” legati allo sviluppo di applicazioni per Windows Phone, come App Studio, l’uso delle mappe e le Speech API. Avrò il piacere di tenere una sessione anche io, dedicata all’accesso ai dati locali in Windows Phone (storage, database, ecc.). Ovviamente, dato che WP Dev Fusion è un’iniziativa di stampo internazionale, tutte le sessioni saranno in inglese. Al termine, ci sarà anche una sessione di “Ask The Expert”, dove potrete porre le vostre domande agli speaker.

Cosa aspettate a iscrivervi? Vi lascio al sito ufficiale, dove trovate l’agenda completa e tutti i dettagli. Le iscrizioni ci serviranno per capire il numero indicativo di persone che parteciperanno, così da preparare un’infrastruttura adatta a reggere il carico.

Vi aspettiamo!


WP Dev Fusion

0 comments

Un nuovo processo di registrazione unico per Windows Phone e Windows 8

Print Content | More

Nella giornata di ieri Microsoft ha annunciato una grossa novità per gli sviluppatori mobile: l’unificazione del progesso di registrazione per la pubblicazione di applicazioni sugli store di Windows Phone e Windows 8. FIno ad oggi, infatti, i due processi erano completamente separati: due flussi di registrazione differenti, due costi di iscrizione separati, due verifiche dell’idendità dello sviluppatore indipendenti. Da oggi, invece, esiste un’unica registrazione, che vi offrirà la possibilità di pubblicare applicazioni sia per Windows Phone che per Windows 8.

Questa importante novità porta con sè anche un abbassamento del costo di iscrizione, che ora è di soli 19 $ per i privati e di 99 $ per le aziende. Se siete studenti con accesso al programma Dreamspark o avete un account MSDN, nulla cambia: il token che vi viene fornito vi permetterà di registrarvi gratuitamente ad entrambi gli Store.

Se siete già in possesso di uno dei due account, sarete automaticamente abilitati per entrambi gli Store: se siete sviluppatori Windows Phone, potete perciò iniziare a pubblicare applicazioni per Windows 8 senza sostenere alcun costo aggiuntivo; viceversa, se avete già pubblicato delle applicazioni per Windows 8, ora avrete la possibilità di portarle e di pubblicarle anche sullo store di Windows Phone.

E se avete già entrambi? Microsoft ha pensato anche a voi: in questo caso, avrete a disposizione un token per un rinnovo gratuito di un altro anno nel momento in cui uno dei due account scadrà (farà fede quello che ha la data di scadenza più lontana nel tempo).

Se stavate pensando di portare la vostra applicazione da Windows Phone a Windows 8 o viceversa, questa è un’ottima occasione per farlo! A tal proposito, vi consiglio la visione della serie di webinar proposta da Ben Riga sulla condivisione di codice tra applicazioni per entrambe le piattaforme.

Happy coding!


Windows Phone , Store

0 comments

Nokia World e le novità per gli sviluppatori

Print Content | More

Ieri Nokia ha presentato, durante il Nokia World, diverse novità riguardanti Windows Phone e la famiglia dei Lumia. Nokia ha infatti annunciato due nuovi telefoni che rientrano nella categoria dei “phablet” (entrambi condividono uno schermo da 6 pollici), un tablet (basato su Windows 8.1 RT) e diverse applicazioni che usciranno nelle prossime settimane, come Instagram, Vine e Flipboard.

Si tratta di notizie molto importanti per gli sviluppatori: sono sicuro, infatti, che aiuteranno a spingere ulteriormente l’ecosistema di Windows Phone e un maggior numero di telefoni sul mercato significa più opportunità per noi sviluppatori Smile

Se volete saperne di più sui nuovi prodotti e applicazioni, vi consiglio di visitare il blog ufficiale di Nokia, Nokia Conversations, dove trovate una serie di post che coprono in dettaglio tutte le novità. Nel corso di questo post vorrei focalizzarmi sulle novità più interessanti per gli sviluppatori.

Lumia 1320 and Lumia 1520

I nuovi arrivati nella famiglie dei Lumia fanno parte della cosiddetta categoria dei “phablet”: sono telefoni, ma con uno schermo molto grande (6 pollici). Il Lumia 1520 è un telefono di fascia alta, che supporta la nuova risoluzione 1080p (1080x1920) introdotta con GDR3, unito ad un processore quad core (un’altra nuova feature per quanto riguarda i dispositivi Windows Phone) e una fotocamera da 20 MPixel. Il Lumia 1320, invece, è un telefono di fascia media, con specifiche tecniche inferiori ma decisamente più economico. Offre uno schermo con risoluzione di 720p (720x1280), che non è una novità per Windows Phone (è una delle risoluzioni introdotte da Windows Phone 8), ma è nuova per la famiglia dei Lumia, dato che tutti gli altri modelli utilizzano la WVGA (480x800) e la WXGA (768x1280).

E, proprio parlando di risoluzione, troviamo la prima novità per gli sviluppatori: le risoluzioni 720p e 1080p sono diverse dalle altre, dato che hanno una proporzione di 16:9, contro i 15:9 delle altre. Questo significa che:

  • Se avete utilizzato un layout rigido nella vostra applicazione (usando, ad esempio, margini e dimensioni fisse), c’è la possibilità che l’applicazione abbia qualche problema di visualizzazione sui nuovi device. La soluzione più semplice è quella di utilizzare un layout fluido, in grado di adattarsi alla dimensione dello schermo. Ad esempio, se utilizzate un controllo Grid, cercate di non utilizzare dimensioni fisse per righe e colonne.
  • Le applicazioni Windows Phone 7 non supportano le nuove risoluzioni: se per i telefoni WXGA non è un problema (le proporzioni sono le stesse, quindi il layout viene semplicemente adattato e non distorto), lo stesso non si può dire per i telefoni 720p e  1080p. Dato che le proporzioni sono differenti, c’è la possibilità che la resa finale non sia buona: di conseguenza, le applicazioni Windows Phone 7 che vengono eseguite su un telefono 720p o 1080p vengono “tagliate” in cima, con l’aggiunta di una barra nera (o bianca, a seconda del tema), così da mantenere le proporzioni di 15:9. L’unica soluzione a questo problema è aggiornare il vostro progetto a Windows Phoen 8: solo in questo modo sarete in grado di supportare pienamente i nuovi device.

Se, in passato, gli sviluppatori non si sono preoccupati troppo di supportare correttamente la 720p, data che era supportata da pochi telefoni con un ridotto market share, ora è arrivato il momento di aggiornare i nostri progetti, se vogliamo garantire la migliore esperienza utente anche a chi acquisterà il Lumia 1320 o il Lumia 1520.

Per l’occasione, Nokia ha organizato due webinar, che saranno proposti in due date e orari differenti (6 Novembre e 7 Novembre) su come adattare le applicazioni per supportare le nuove risoluzioni. Non perdetevelo!

Infine, se avete letto il mio post sul blog di MSDN Italia, dovreste sapere già che Microsoft sta per rilasciare a breve un aggiornamento dell’SDK, che includerà un nuovo emulatore aggiornato a GDR3 con il supporto alla risoluzione 1080p. Comunque, dato che le proporzioni sono lo stesse, potete iniziare sin da subito a testare le vostre applicazioni per i nuovi Lumia utilizzando l’emulatore a 720p. Se la vostra applicazione si vede bene su un telefono 720p, non avrà problemi neanche su quelli a 1080p (a meno che non abbiate usato immagini a bassa qualità, in quel caso potrebbero vedersi male su un telefono ad alta risoluzione).

imageimage

Lumia 2520

Nokia ha annunciato inoltre il suo primo tablet, un dispositivo basato su Windows 8.1 RT con un design molto simile a quello degli smartphone Lumia. Ha un processore ARM Quad Core e uno schermo con risoluzione 1080p. Come ogni altro device basato su Windows RT (come il Surface), è ottimizzato per le nuove Windows Store app introdotte in WIndows 8: le applicazioni desktop non possono essere utilizzate, ad eccezione di quelle fornite da Microsoft (come la suite di Office).

Dal punto di vista di noi sviluppatori, si tratta di una nuova opportuntità: se avete già un’applicazione Windows Phone che potrebbe avere un senso utilizzata su uno schermo di grandi dimensioni, potete iniziare a pensare a farne un porting per Windows 8. C’è un po’ di lavoro da fare, ma ci sono molte classi ed API condivise tra il Windows Runtime di Windows 8 e il Windows Runtime di Windows Phone. Come punto di partenza, vi consiglio questa serie di webinar pubblicata su Channel 9 a cura di Ben Riga, che introduce alcuni concetti importanti come Model-View-ViewModel (di cui abbiamo abbondantemente parlato anche in questo blog) e Portable Class Libraries, che sono due degli strumenti che vi aiuteranno a riutilizzare il più possibile il codice della vostra applicazioni Windows Phone in un’applicazione Windows 8.

imageimage

Nokia Developer Offers

La notizia più interessante per gli sviluppatori è, probabilmente, il lancio di un nuovo programma chiama Nokia Developers Offers, che fornisce agli sviluppatori gratuitamente una serie di risorse e tool molto utili:

  • Un token per iscriversi allo Store o rinnovare un account in scadenza
  • Una licenza per la piattaforma di analisi e tracciamento di statistiche BugSense Performance Monitoring Solution
  • Una licenza annuale per i controlli Telerik per Windows Phone
  • Una licenza annuale per i controlli Ingrafistics per Windows Phone

Ci sono una serie di requisit che devono però essere soddisfatti per poter entrare nel programma:

  • Dovete essere iscritti a DVLUP.
  • Se siete nuovi sviluppatori, dovete aver pubblicato almeno 2 applicazioni su qualsiasi piattaforma mobile: non solo Windows Phone o Asha, ma anche Android, iOS, ecc.
  • Se, in passato, vi siete già iscritti al Nokia Developer Premium program, dovete aver rilasciato almeno una nuova applicazione in seguito all’iscrizione.

Il team di Nokia impiegherà qualche giorno per verificare che rispettiate i requisiti richiesti. Una volta entrati nel programma, è importante sapere che, in futuro, potrete avere accesso ad altri benefit (ad esempio, sconti sui punti XP necessari per ottenere i premi di DVLUP): per continuare a far parte del programma, però, dove impegnarvi a pubblicare una nuova app o un’aggiornamento ad un’app già esistente entro 6 mesi dall’iscrizione.

Se siete interessati, cosa aspettate a iscrivervi?


Windows Phone , Nokia

0 comments

Windows Phone Day: il materiale dell’evento

Print Content | More

Come anticipato da un mio precedente post, Lunedì 30 Settembre si è svolto a Milano presso il Microsoft Innovation Campus il Windows Phone Day, una giornata dedicata agli sviluppatori Windows Phone che si è inserita nel contesto della Windows Phone Week, un’iniziativa a livello globale in cui diversi paesi del mondo organizzeranno un evento dedicato a Windows Phone durante il mese di Ottobre.

La giornata è andata molto bene: le sessioni sono state tutte interessanti e i numerosi partecipanti attenti e curiosi, nonostante i disagi per arrivare in Microsoft dovuti all’intenso traffico e alle condizioni atmosferiche avverse. Se avete partecipato, avete già avuto modo di dare un feedback all’evento tramite i fogli che avete consegnato al termine della giornata: se avete comunque consigli o suggerimenti, non esitate a contattarmi tramite il form di contatto del blog!

Stiamo raccogliendo il materiale delle sessioni da parte degli speaker: appena saranno online, pubblicheremo un articolo sul blog MSDN (http://blogs.msdn.com/b/italy/) che li raccoglierà tutti. Nel frattempo, di seguito, trovate le slide del keynote e slide e demo della mia sessione dedicata a MVVM e Caliburn Micro.

Alla prossima occasione!

Scarica la demo


Windows Phone , MVVM , Caliburn , Windows Phone Week

2 comments