Windows 8 Store

Analytics Tools for Windows Store Apps – XAML

segnalo due potenti strumenti per fare Analitics/Performance delle App per Windows Store.

– http://www.distimo.com
tra le svariate funzionalità a disposizione della piattaforma, abbiamo una comoda dashboard completamente configurabile che ci permete di misurare l’andamento di mercato delle App per diversi store (ma a io importa Windows Store) … 🙂
 
– https://developer.omniture.com/en_US/content_page/mobile/c-measuring-mobile-applications
 qui invece il focus si sposta maggiormente sull’analisi delle performance del software.  OnLine è disponibile l’SDK e un Quick Start su come utilizzare al meglio le API.

Enjoy!

Maurizio

Using SQLite in Windows 8 Metro Style Apps

Con grande stupore, visto che all’uscita di Windows 8 non era previsto nessun supporto nativo per database, ora è finalmente disponibile una versione del noto database SQLite (precompiled) sia per WinRT che per Windows Phone 8.  🙂

Da ora in poi saremo in grado di sviluppare applicazioni che possono condividere il layer di accesso ai dati basato su SQLite, quindi semplificare l’integrazione tra le due piattaforme: Windows 8 e Windows Phone 8.

Fatta questa premessa, vediamo i passi da seguire per poter integrare SQLite nelle nostre Windows 8 Apps.

Di cosa abbiamo bisogno?

Inanzitutto dobbiamo andare sul sito ufficiale www.sqlite.org alla sezione download scaricare il package per WinRT che si chiama Precompiled Binaries for Windows Runtime ed eseguire l’installazione.

Una volta completata la fase d’installazione possiamo aprire la nostra Windows 8 App e aggiungere la reference al progetto.
Ecco la screenshot:

SQLite ReferenceSe, a questo punto, la nostra applicazione non dovesse compilare, sarebbe dovuto dal fatto che essendo SQLite una libreria di codice nativo dobbiamo impostare dal Configuration Manager di Visual Studio x86 o x64 (e non AnyCPU)  non essendo ancora supportato ARM.


Adesso non ci rimane che scaricare tramite NuGet una libreria chiamata sqlite-net che ci semplifica la vita e fornisce il supporto LINQ per lavorare con i dati e il supporto all’async pattern.
NuGet scaricarà nella root del nostro progetto 2 files: SQLite.cs (supporto sincrono) e SQLiteAsync.cs (supporto asincrono), che sono appunto le classi che ci vengono in supporto per lo sviluppo.

Ora scriviamo del codice:

In questo post vedremo come iniziare a usare SQLite in un App XAML / C#, come creare un database e eseguire delle operazioni CRUD sui dati.

Il primo passaggio è quello di creare un oggetto SQLiteAsyncConnection, o SQLiteConnection (per la versione sicnrona), che identifica la connessione al database.
Ecco un esempio di creazione Db Sincrona:

Ecco un esempio di Creazione Db Asyncrona:
Ora però ci serve almeno una tabella quindi definiamo una classe e andiamo a decorare le Proprietà in questo modo:

In questo esempio possiamo notare alcuni attributi utili per decorare in modoo opportuno la nostra classe:

– AutoIncrement: utile per dire a SQLite che quella colonna sarà un numero auto incrementato.
– PrimaryKey: serve per identificare una colonna come chiave primaria.

Per creare la tabella appena definita chiamiamo il metodo CreateTableAsync <T>, o CreateTable<T> (per la versione sincrona), per ogni tabella che si desidera creare, dove T è il tipo di dati che andremo a riporre in essa.

Ora ci tocca inserire dei dati e per farlo possiamo usare il metodo InsertAsync, o Insert (nella versione sincrona), che accetta come parametro una istanza di oggetto che andremo a salvare… oppure possiamo usare, in caso di inserimento massivo, InsertAllAsync che accetta come parametro una istanza di un oggetto enumerabile.
Ecco un esempio della versione Asyncrona:
E qui la versione sincrona:

Come si può notare per la versione sincrona ho utilizzato il metodo RunInTransaction che ci permette di scrivere del codice safe e gestire al meglio i nostri dati.

Adesso non ci rimane altro che visualizzare i nostri dati appena inseriti: per farlo possiamo utilizzare il metodo Table<T> e chiamare successivamente  l’extentions ToListAsync (solo nella versione asincrona).
Ecco un esempio della versione asincrona:
E qui la versione sincrona:

….. e ora siamo pronti a integrare SQLite nelle nostre Windows 8 APP! 🙂

Enjoy!

Windows 8, WinRT, Debugging DataBinding Error

Ciao,
giusto oggi mi dicevo… perchè nei progetti Windows Store App non abbiamo a disposizione un meccanismo di debugging per le espressioni di Binding ?

Si, possiamo sempre andare a leggere la finestra di Output per analizzare le segnalazioni che il compilatore ci mette a disposizione così da riuscire a risolvere i nostri problemi, ma possiamo, senza troppa fatica utilizzare le informazioni relative all’errore di binding utilizzando la classe DebugSettings e l’evento BindingFailed.

Il delegato che avremo a disposizione ha come argomento la classe BindingFailedEventArgs che a sua volta espone una proprietà Message che ci permetterà di visualizzare le informazioni sull’errore di data binding.

Ecco un esempio: 


partial class App : Application
 {
     public App()
     {       
         DebugSettings.BindingFailed += OnBindingFailed;
     }

     private void OnBindingFailed(object sender, BindingFailedEventArgs e)
     {
         Debug.WriteLine(e.Message);
     }
 }

Maurizio

Windows 8, WinRT, Advanced AppBar with vector icons in XAML

Ciao a tutti,
in quest’articolo vorrei proseguire il discorso sull’uso delle icone per l’AppBar.
Anche se sembra difficile, potrebbe capitare di non trovare un’icona adatta alle proprie necessità tra le 150 circa disponibili di default nel template di Visual Studio 2012.

Se appunto, non siamo fortunati nella ricerca dell’icona che fa per noi, possiamo pensare di utilizzare Metro Studio 2 di SyncFusion http://www.syncfusion.com/downloads/metrostudio che al momento viene dato in licenza gratuita al posto di 499$ 🙂

Metro Studio 2 è un software che mette a disposizione, suddivise per categorie, moltissime icone adatte alle nostre applicazioni MetroStyle e quindi per la AppBar.

Ecco una screenshoot di Metro Studio 2:

Una volta trovata l’icona che più si adatta alle nostre esigenze possiamo andare a eseguire diverse personalizzazioni, tra qui: dimensioni, colore di sfondo, rotazione, colore della shape, etc etc… e quando abbiamo completato possiamo esportare lo XAML che è stato generato.

Ecco un esempio di personalizzazione:

Io direi solo WOW!!! 🙂 ci troviamo una icona vettoriale pronta da inserire in uno stile nel nostro ResourceDictionary 🙂

Ecco un esempio di XAML pronto da esportare:

Qui invece un esempio di stile completo:

Se non vogliamo scaricare Metro Studio 2 esiste anche
http://www.thexamlproject.com/ che permette di ricercare icone ed esportare lo XAML… l’unica differenza è che qui non possiamo personalizzare la nostra icona.

Bene, ora vi mostro un esempio dell’AppBar con l’icona “Collaps” preparata in precedenza:

Bene, credo di avervi raccontato tutto per oggi 🙂
Buon divertimento con le icone
Maurizio

Using Callisto Library and SettingsFlyout !!!!

Ciao,
vediamo come utilizzare il controllo SettingFlyout messo a disposizione dalla Callisto Library per la nostra Settings Charm.

Partendo dal post precedente dove abbiamo parlato e visto come scaricare la Callisto Library ora proviamo ad utilizzarla per realizzare una
Settings Charm per le nostre Windows 8 Apps.

Qui ci mettiamo in ascolto sulla richiesta da parte dell’utente della Setting Pane:

        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            SettingsPane.GetForCurrentView().CommandsRequested += OnSettingsPane_CommandsRequested;
            base.OnNavigatedTo(e);
        }

        protected override void OnNavigatedFrom(NavigationEventArgs e)
        {
            SettingsPane.GetForCurrentView().CommandsRequested -= OnSettingsPane_CommandsRequested;
            base.OnNavigatedFrom(e);
        }

Nel delegato andiamo a definire la nostra SettingFlyout:

private void OnSettingsPane_CommandsRequested(SettingsPane sender,SettingsPaneCommandsRequestedEventArgs args)
{
SettingsCommand cmd = new SettingsCommand("", "", (x) =>
{
//nuova SettingsFlyout - CallistoLibrary
SettingsFlyout settings = new SettingsFlyout();

//Configurazione
settings.FlyoutWidth = Callisto.Controls.SettingsFlyout.SettingsFlyoutWidth.Wide;
settings.HeaderBrush = new SolidColorBrush(Color.FromArgb(255, 139, 69, 19));
settings.HeaderText = "

"
settings.Background = new ImageBrush { ImageSource = new BitmapImage(new Uri(@"ms-appx:/Assets/BackgroundImage.png")) };

//Contenuto della SettingsFlyout
settings.Content = new SettingContent();

settings.IsOpen = true;
});
args.Request.ApplicationCommands.Add(cmd);
}

Molto rapidamente abbiamo configurato la nostra Settings Charm creando un nuovo SettingsCommand e definendo al suo interno una SettingsFlyout parte della Callisto Library.

In aggiunta come esempio ho creato una page di contenuto dedicata SettingContent fatta in questo modo:

<Page
x:Class=".SettingContent"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d">

<TextBlock Text="" FontSize="28" Margin="10,0,0,0" />
<TextBox x:Name="" Width="400"
HorizontalAlignment="Left" Margin="10,0,0,0" />

Ecco il risultato finale:

Settings Charm

Settings Charm

Windows 8, WinRT, Privacy and Policy!!!

Ciao a tutti,
per esperienza personale pubblico questo POST!!!! 😦

Se state sviluppando un App per Windows 8 o siete pronti per la fase si Certificazione a parte ricordarvi di leggere tutti i “requirements” necessari per l’approvazione vi ricordo vivamente la Privacy.

La “Privacy” deve apparire in due step:

– Description Page pagina di dettaglio del prodotto sullo Store, qui deve comparire un rimando alla Privacy and Policy.

– Settings Charm anche qui deve comparire un rimando alla stessa Privacy.

Tutto queste è necessario se la Vostra App utilizza in qualche informazioni personali, condivisione, memorizzazione, etc etc …

Vi ricordo questo, prima di ricevere un bel “Reject” dell’App dopo l’attesa di 7 giorni.

Maurizio 🙂

Callisto library for Windows Store App

Ciao a tutti,
devo obbligatoriamente segnalare (per chi non fosse a conoscenza) e dopo aver lavorato direttamente con questo toolkit, che arriva in soccorso per lo sviluppo delle nostre Win 8 Apps.

Callisto è un appunto una library scaricabile liberamente da github oppure tramite NuGET.

Al suo interno troveremo oltre alla demo, diversi controlli, helper, converter, nati per semplificarci la vita … 🙂

Un breve elenco delle features presenti:

– Flyout (a primitive that includes positioning and ‘light dismiss’ logic)
– Menu (primarily to be used from AppBar, contains the base for providing, well, a Menu)
– MenuItem (an item for a menu, including separators and contains the command point for the menu item)
– SettingsFlyout (an item to create a custom settings pane UI)
– Rating (a ratings control for Metro UI)
– LiveTile (an in-app tile experience to give you animated or ‘live’ tiles)
– Tilt (an effect to provide the tilt experience when clicked on edges/corners)
– OAuth helpers (a set of helpers to create OAuth 1.0 signatures/headers for those sites that hate OAuth 2.0)
– BooleanToVisibilityConverter
– LengthToBooleanConverter
– RelativeTimeConverter
– Extensions

Onori agli sviluppatori di questo toolkit: Tim Heuer and Morten Nielsen.

Buon Win 8 App a tutti 🙂
Maurizio

Windows 8, WinRT, ApplicationData, Settings Charm

Ciao a tutti,
prima di riprendere con gli articoli legati all’uso del Pattern MVVM sulle Windows 8 Apps, parleremo di come manipolare i settings localmente.

La prima cosa che balza all’occhio quando si è davanti ad un progetto Windows 8 Store App e che non abbiamo più a disposizione il file App.Config, ormai storico compagno da anni 🙂 (che nel bene o nel male ci permetteva di salvare parti di configurazione in modo molto rapido)

Quindi la domanda successiva è: Come posso gestire i miei Settings?

WinRT ci fornisce diverse nuove API pronte all’uso che ci rendono il lavoro molto più semplice è veloce per manipolare, caricare, memorizzare i nostri dati.

Facciamo un passo indietro, prima di vedere come è possibile manipolare dei dati in locale dobbiamo conoscere cosa avviene dietro le quinte durante un Deploy piuttosto che un Download/Installazione dallo Store.

Windows 8 crea per noi una folder dove risiede il nostro Package (App) e una cartella sotto il path: user/appdata/local/packages/ dove possiamo liberamente andare a scrivere, leggere, creare cartelle, manipolare dati.

<code
//Qui la struttura di esempio dopo un Deploy
MyAppFolder
– (installazione dell'App e Folder Dedicata)

// Qui AppDataFolder per MyAppFolder
user/appdata/local/packages/
– LocalState
– RoamingState
– TempState
– Settings

Ecco come accedere alle rispettive Folder/Settings sopra descritte:

//Roaming
Windows.Storage.ApplicationData.Current.RoamingFolder
Windows.Storage.ApplicationData.Current.RoamingSettings

//Local
Windows.Storage.ApplicationData.Current.LocalFolder
Windows.Storage.ApplicationData.Current.LocalSettings

//Temp
Windows.Storage.ApplicationData.Current.TemporaryFolder

– Settings: semplici settaggi accessibili dalla “Settings Charm” che possono essere sincronizzati tra macchine (Roaming)
– LocalSettings: dati persistenti tra le sessioni di un App
– Temporary: dati in cache temporanea utilizzata come area di lavoro, garantiscono ottime prestazioni.

Qui il <link> per il download degli esempi.

Un breve esempio di come scrivere i nostri Settings, l’accesso e tramite IDictionary quindi i tipi base a disposizione in WinRT:

//RoamingSettings
Windows.Storage.ApplicationData.Current.RoamingSettings.Values[“MyRoamingSetting] = MyRoamingValue;

//LocalSettings
Windows.Storage.ApplicationData.Current.LocalSettings.Values[“MyLocalSetting] = MyLocalValue;

Quando usiamo i RoamingSettings è perchè abbiamo pensato ad una possibile installazione dell’App su più Device che accedono con la stessa utenza, a questo punto Windows 8 sincronizzerà per noi il contenuto.

Ora vi mostro un esempio di classe in grado di gestire dei Settings:

// SettingsHelper
public static class SettingsHelper
{
public static ApplicationDataContainer SettingsContainer { get; set; }

static SettingsStore()
{
SettingsContainer = ApplicationData.Current.LocalSettings;

/* SettingsContainer = ApplicationData.Current.RoamingSettings; */
}

///

/// AppName
///

public static string AppName
{
get { return SettingsContainer.Values["AppName"] as string; }
set { SettingsContainer.Values["AppName"] = value; }
}

///

/// RootFolder
///

public static string RootFolder
{
get { return SettingsContainer.Values["RootFolder"] as string; }
set { SettingsContainer.Values["RootFolder"] = value; }
}
}

Come possiamo notare, molto velocemente siamo in grado di cambiare il settings su cui andremo a leggere/scrivere senza modificare la rimanenza del codice.
Questo esempio di classe è utilizzabile con la SettingsCharm, chiaro dovremo aggiungere 2 funzionalità per fare il Load/Save dei dati. 🙂

Buon Windows 8 App a tutti!!! 🙂
Maurizio

Windows 8, WinRT, MVVM and NavigationService

Ciao a tutti,
oggi inizieremo con una serie di post/articoli che parleranno di come applicare MVVM alle Windows 8 Apps.

Chi viene dallo sviluppo di Applicazioni per Windows Phone si sarà già imbattuto e quindi saprà bene come risolvere il problema del NavigationService.

Il NavigationService è quella classe che ci permette di effettuare la navigazione in stile browser nelle nostre applicazioni Windows 8 e Windows Phone (per maggiori dettagli sulla classe visitate il link su MSDN).

Normalmente utilizzeremo il NavigationService quando abbiamo la necessità di cambiare pagina magari al variare di una Proprietà piuttosto che sull’azione associata ad un determinato comando.
L’unico problema che salta subito all’occhio è che il NavigationService è accessibile solo tramite il Code Behind della pagina e quindi non accessibile dal nostro ViewModel.

Per risolvere questo problema ci sono diverse soluzioni, la più elegante è quella di implementare un wrapper del NavigationService… ecco qui un snippet di esempio:

//Interfaccia INavigationService
public interface INavigationService
{
void GoBack();
void GoForward();
bool Navigate(object parameter = null);
bool Navigate(Type source, object parameter = null);
}

//NavigationHelper
public class NavigationService : INavigationService
{
private Frame rootFrame { get; set; }

//Qui passeremo come parametro il Frame initializzato nel App.cs
public NavigationHelper(Frame rootFrame)
{
this.rootFrame = rootFrame;
}

public void GoBack()
{
this.rootFrame.GoBack();
}

public void GoForward()
{
this.rootFrame.GoForward();
}

public bool Navigate(object parameter = null)
{
return this.rootFrame.Navigate(typeof(T), parameter);
}

public bool Navigate(Type source, object parameter = null)
{
return this.Navigate(source, parameter);
}
}

Quindi, abbiamo definito un’interfaccia che in sostanza espone le stesse funzionalità di navigazione che avremmo a disposizione nel NavigationService presente nel Code Behind e di seguito la sua implementazione.

Ora non ci rimane che inizializzare il nostro NavigationService nell’App.xaml.cs tramite Dependency Injection (IOC).
Per quanto rigurda IOC possiamo utilizzare qualsiasi soluzione compatibile con WinRT, io come sempre consiglio Galasoft Toolkit di Laurent Bugnion.

protected override void OnLaunched(LaunchActivatedEventArgs args)
{
var rootFrame = new Frame();
if (args.PreviousExecutionState == ApplicationExecutionState.Running)
{
Window.Current.Activate();
return;
}

if (args.PreviousExecutionState == ApplicationExecutionState.Terminated || args.PreviousExecutionState==ApplicationExecutionState.NotRunning)
{
SimpleIoc.Default.Register(typeof (INavigationService), new NavigationService(rootFrame));
}

if (!rootFrame.Navigate(typeof(MainPage)))
{
throw new Exception("Failed to create initial page");
}

// Place the frame in the current Window and ensure that it is active
Window.Current.Content = rootFrame;
Window.Current.Activate();
}

Nell’esempio andiamo a registrare l’istanza del NavigationService nel momento in cui l’App si trova diciamo “In Stato di Fermo” 😀

“SimpleIoc” fa riferimento all’utilizzo del Galasoft Toolkit dove di “default” introduce il ViewModelLocator con un’implementazione di IOC chiamata appunto SimpleIoc.

Nei nostri ViewModel avremo così a disposizione il nostro NavigationService:

protected INavigationService navigationService;

public MyViewModel(INavigationService navigationService)
{
this.navigationService = navigationService;
}

A questo punto non vi rimane che divertirvi con i vostri ViewModel e le vostre Apps di Windows 8 😀

Credo di aver raccontato tutto 😀
Buon Windows 8 Apps!!!

Maurizio