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 🙂

Learning Windows Store App?

Ciao a tutti,
per tutti quelli che hanno vogliono imparare a sviluppare App per Windows 8 eccovi un paio di link utili:

Download Windows 8 Camp in a Box!

Win 8 App Samples

Risorse risorse per imparare a conoscere Windows 8, WinRT, HTML5, XAML, etc etc …. 🙂

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

Visualstudio 2012 Color Theme

Ciao,
dopo i primi sviluppi su VisualStudio 2012 sento le prime lamentele per la scelta della colorazione dell’IDE, delle label tutte in maiuscolo, piuttosto che delle icone minimaliste 😀

Sinceramente io mi sono adattato abbastanza velocemente alla cosa, anche se ammetto che la colorazione Light tutto sommato è buona, la Dark dopo un pò ha del fastidioso.

Comunque se avete la necessità di avere un IDE in stile VisualStudio 2010 aprendo VisualStudio 2012:
Tools -> Extentions and Updates è possibile scaricare da NUGET una comoda estensione:
VisualStudio 2012 Color Theme Editor che vi permette di scegliere diverse tonalità per il Vostro IDE.

Dopo è sufficiente andare sotto: Tools -Options- General e scegliere dalla combo Color Themes il colore preferito o meno fastidioso.

Maurizio

TFS: Update Machine Name / UserName

Ciao a tutti,

Oggi l’argomento (anche se molto breve) è TFS (Team Foundation Server).

Mai avuto la necessità di modificare il nome del Computer piuttosto che quello dello User?
Detto questo come facciamo a dire al server di TFS di aggiornare questi dati?

Tramite riga di comando possiamo utilizzare:
tf.exe, con due opzioni, / updateComputerName e / updateUserName.

Senza questo aggiornamento se abbiamo progetti/files in checkout anche effettuando correttamente l’accesso con la nostra utenza ma con un ComputerName diverso non sarà possibile effettuare le classiche operazioni tipo “Undo Pending Changes” (giusto per fare un esempio).

Qui la sintassi completa:
tf workspace / updateComputerName: NomeComputerPrecedente / s: http://Tfs_server:8080

PS.
Sull’MSDN sembra che queste informazioni in realtà non siamo aggiornabili o simile ma dire che è un errore di documentazione….. 😦

Maurizio

MetroNote App for Windows Store – Release 2

MetroNote App for Windows 8 Store
E’ ufficialmente pubblicata la nuova major release di MetroNote, l’Applicazione che permette la completa gestione dei vostri Post-it/Memo che ora è diventata GRATUITA.

Quali sono le nuove funzionalità? MetroNote consentirà di:
– cambiare tema (“metal” o “wood”) dello sfondo
– cambiare il colore delle note
– inserire un mark sulle note più importanti
– condividere le note tramite la Share Charm
– aggiungere le note alla Start
… e altro ancora! Aspettate e vedrete!

Ecco il link per vederla sul Windows Store: MetroNote

Maurizio

Single && Double – come utilizzare il .NaN????

Ciao a tutti,
Oggi parleremo delle strutture Single && Double, visto le richieste avute in questo periodo da parte di amici e colleghi …
Le strutture Single e Double contengono al suo interno delle proprietà chiamate:
PositiveInfinity
NegativeInfinity
NaN
utilizzate dal .NET Framework per rappresentare questi stessi valori.

Questi valori corrispondono a sequenze di bit, specifiche dello standard IEEE. IEEE Standard
Tuttavia, questi schemi di bit non sono univoci, quindi non è raccomandato utilizzare questi campi per le operazioni di confronto.
Prendiamo per esempio, che la variabile d è un NaN. (ricordo che un NaN si può diciamo “generare” sommando un PositivoInfinito su un NegativoInfinito).
Il controllo comparativo:

 d == Double.NaN 

restituisce false se lo schema di bit di d non corrisponde esattamente con quella di Double.NaN.
Per conoscere lo “status” di un particolare numero, è raccomandato l’utilizzo dei metodi statici messi a disposizione dal .NET Framework:

 Double.IsNaN (d)

Maurizio