sabato 3 dicembre 2011

Android: fai vibrare la tua app

In questo post parleremo di come far vibrare la tua applicazione in uno specifico momento, ad esempio per segnalare un determinato evento.
La prima cosa da fare e quella di aggiungere i permessi nel manifesto dell'applicazione.


<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="...">
 <uses-permission android:name="android.permission.VIBRATE"/>
 <application android:label="...">
  ...
 </application>
</manifest>
Invece nel codice dell'applicazione va richiamato quanto segue

// Ottieni un istanza di Vibrator dal contesto corrente
Vibrator v = (Vibrator) getSystemService(Context.VIBRATOR_SERVICE);
 
// Attiva la vibrazione per 1 secondo
v.vibrate(1000);

La prima riga di codice  richiede un istanza dell'oggetto Vibrator dal contesto corrente e la memorizza nella variabile v. La seconda riga invece attiva semplicemente la vibrazione per 1 secondo.

Vedremo un utilizzo pratico della vibrazione in un post successivo dedicato alla gestione degli sms.

martedì 22 novembre 2011

Interview question: differenza tra architettura a 2 tier e achitettura a 3 tier

Partiamo col dire che quando si parla di tier la ment va subito a un'applicazione di tipo client-server. Per spiegare la differenza tra queste due architetture partiamo da un esempio.

Supponiamo di voler scrivere un programma che permetta in una scuola agli studenti di sapere la media dei voti nelle diverse materie. Il programma è strutturato in modo che i voti degli alunni siano memorizzati nel database che risiede sul server, mentre l'applicazione che permette di accedere ai voti e alla media risiede lato client. Quando gli studenti vogliono sapere la media dei loro voti utilizzano il programma (cliccando sui pulsanti, aprendo le fineste ecc.) inviando cosi una query al database che risiede sul server. Il database risponderà con i dati richiesti e l'applicazione calcolerà cosi la media. 
Questo è un esempio di architettura a 2 tier. I 2 tier sono:
  1. Data server, dove girà il database contenente le informazioni
  2. L'applicazione client
Questa architettura va bene se la scuola avesse solo una cinquantina di studenti. Ma supponiamo che la scuola abbia 10000 studenti. Ora la situazione inizia a farsi più problematica...
Ogni volta che uno studente, attraverso l'applicazione client, effettua una query il data server dovrà gestire questa query. Questo diventa un enorme lavoro per una risorsa di rete.
Per ovviare a tale problema si utilizza l'architettura a 3 tier, inserendo un altro programma a livello server, chiamato server application. In questo modo l'applicazione client non farà più riferimento al database ma passerà prima attraverso l'application server che poi girerà le queries al database.
Ora ogni studente per sapere la sua media dovrà eseguire i seguenti passi:
  1. Lo studente interroga l'applicazione client
  2. L'applicazione client interroga l'applicazione server
  3. L'applicazione server effettua la query sul data server
  4. Il data server restituisce un recordset contenente i voti dello studente
  5. L'applicazione server effettuerà tutti i calcoli per determinare la media
  6. L'applicazione server restituisce la media calcolata all'applicazione client
  7. L'applicazione client mostra la media allo studente
Anche se il processo sembra più lungo su carta, in realtà è molto più veloce. Questo perchè al paso 6 all'applicazione client non viene più resitutito un recordset (che generà un grande ammontare di traffico di rete) ma solo un semplice numero!



Ovviamente esistono altri vantaggi di un'architettura a 3 tier ma in questo articolo ho solo voluto dare un'idea generale sulle 2 architetture.


Questo articolo prende spunto principalmente da link


mercoledì 16 novembre 2011

Interview question: SOLID

Questo è il primo di una lunga serie di post dove parleremo di possibili domande a cui un informatico potrebbe andare incontro.

  • Cos'è SOLID?
SOLID sta per Single responsibility, Open-closed, Liskov substitution, Interface segregation and Dependency inversion. Il termine è stato introdotto per la prima volta da Robert C. Martin agli inizi dell'anno 2000 per indicare un nuovo principio di programmazione e design object-oriented. Quando è applicato il principio permette di avere un sistema facile da manutenere e da estendere col tempo. Andiamo ad analizzare ogni singolo concetto di questo nuovo principio.

  • Single responsibility principle (SRP)
Ogni oggetto dovrebbe avere un sola singola responsabilità. In pratica ogni classe dovrebbe concentrarsi sul fare una sola cosa.

  • Open/closed principle (OCP)
Le entità software dovrebbero essere aperte per l'estensioni ma chiuse per le modifiche. Supponiamo di avere la classe OrderValidation con il metodo Validate (Order order) che contiene tutte le regole per validare un'ordine. Se tali regole cambiano siamo costretti a modificare la classe violando il principio OCP. Se avessimo invece l'oggetto IValidationRule contenente tutte le regole, allora potremmo basare il metodo Validate su questo oggetto e nel caso di cambio di regole basterà creare un nuovo IValidationRule e passarlo all'istanza di OrderValidation al run time.

  • Liskov substitution principle (LSP)
Gli oggetti in un programma dovrebbe essere rimpiazzati con instanze del loro sottotipo senza alterare la correttezza del programma. In pratica le sottoclassi dovrebbero comportarsi correttamente quando usate al posto delle loro classi base.


  • Interface segregation principle (ISP)
Diverse interfacce client specifiche sono meglio di una interfaccia con scopo generale. In pratica mantenere le interfacce piccole e coese.



  • Dependency inversion principle (DIP)
Dipendere dall'astrazione, non dipendere dalle concrezioni. Il metodo di Dependency injection è un modo per seguire questo principio. Tale metodo è un design pattern per la programmazione orientata agli oggetti per cui una classe o un sistema non è responsabile circa l'inizializzazione delle proprie dipendenze. Per maggiore informazioni dare un'occhiata su questo blog.



Per maggiori approfondimenti consultare il seguente link.

mercoledì 9 novembre 2011

Riprodurre audio in background nella tua App


Come riprodurre un file audio come sottofondo della propria applicazione? In android è molto semplice ovviamente! Prima di tutto android supporta 2 formati: MP3 e WAV. Creiamo una sottocartella chiamata "raw" nella cartella "res" del progetto. Copiamo i file audio nella cartella raw oppure se si usa Eclipse importiamoli con l'apposito comando.
Ora nell'Activity dove vogliamo venga riprodotto l'audio dichiariamo il seguente codice:

import android.media.MediaPlayer;

quindi importiamo per prima cosa la libreria "MediaPlayer". Dichiariamo poi una variabile come riferimento alla libreria MediaPlayer. La variabile va dichiarata subito dopo la definizione della classe

private MediaPlayer mp = null;

creiamo il metodo "playSound". Tale metodo crea un nuovo Thread in modo che l'audio sia riprodotto senza bloccare il Thread principale. Il metodo prende in input il nome del file da riprodurre.

    private void playSound(int sFile)
    {
    //set up MediaPlayer  
    final int medFile = sFile;
    Thread thread = new Thread(new Runnable()      
    {
          public void run()
          {
                mp = MediaPlayer.create(getApplicationContext(), medFile);
                mp.start();
          }
    });
    thread.start();      
    }
           
per far partire la riproduzione dell'audio copiamo il seguente frammento di codice nel punto dove vogliamo parta la riproduzione

playSound(R.raw.mysoundfile);

infine per fermare la riproduzione dell'audio basta utilizzare la seguente istruzione

mp.stop();

martedì 6 settembre 2011

Gesture in Windows Phone 7


Windows Phone 7 a differenza di altri sistemi operativi mobili non gestisce in maniera nativa le gesture. Esistono diverse possibilità per gestirle per vie esterne. In particolare:

• Un particolare toolkit messo a disposizione dalla Microsoft e dagli sviluppatori di Silverlight (http://silverlight.codeplex.com/)
• Attraverso l’uso delle librerie XNA
Questa seconda possibilità è consigliata in particolare nel caso si vogliano sviluppare giochi. Spieghiamo brevemente come è possibile farlo.





1. Supporto XNA

Fare riferimento al precedente post


2. Toolkit Silverlight

Per prima cosa occorre scaricare l’apposito toolkit al seguente indirizzo web http://silverlight.codeplex.com/ . Una volta installato il plugin aggiungere come reference al proprio progetto l’assembly “Microsoft.Phone.Controls.Toolkit”. Successivamente occorre referenziare l’assembly nell’XAML: namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls.Toolkit" Aggiungere un’istanza del GestureListener all’elemento Grid principale della pagina nella quale si vogliono catturare le gesture:


<Grid x:Name="LayoutRoot" Background="Transparent">

   <toolkit:GestureService.GestureListener>


      <toolkit:GestureListener Flick="OnFlick" />

   </toolkit:GestureService.GestureListener>


   ....

</Grid>


Basta poi aggiungere il metodo OnFlick nella classe associata alla pagina:



        private void OnFlick(object sender, FlickGestureEventArgs e)
        {
            if (e.HorizontalVelocity < 0)

this.NavigationService.Navigate(new Uri("/Send_Message.xaml",      UriKind.Relative));
            else
this.NavigationService.Navigate(new Uri("/MainPage.xaml", UriKind.Relative));
        }


In questo caso si sta gestendo l’evento scroll orizzontale. Se l’attributo HorizontalVelocity ha un valore minore di zero indica che lo scroll è da sinistra a destra altrimenti per un valore maggiore di zero indica uno scroll da destra a sinistra.
Gli altri eventi gestibili sono ad esempio il singolo tocco (tap), il doppio tocco (double tap), scroll orizzontale (horizontaldrag), scroll vertical (verticaldrag) e molti altri.

domenica 4 settembre 2011

WP7 : spostarsi da una pagina ad un'altra con scroll orizzontale

Il codice mostrato qui sotto permette di gestire lo scroll orizzontale utilizzandolo per passare da una pagina all'altra della vostra applicazione.

Per prima cosa aggiungiamo al nostro progetto i riferimenti a due librerie:

-using Microsoft.Xna.Framework;
-using Microsoft.Xna.Framework.Input.Touch;

il percorso delle due librerie solitamente è già suggerito nell'apposita schermata di inserimento delle referenze.


Poi aggiungiamo il seguente codice nel costruttore della classe:

Touch.FrameReported += new TouchFrameEventHandler(Touch_FrameReported);
TouchPanel.EnabledGestures = GestureType.Tap
| GestureType.DoubleTap
| GestureType.Flick
| GestureType.Pinch
| GestureType.HorizontalDrag
| GestureType.VerticalDrag
| GestureType.PinchComplete
| GestureType.DragComplete
| GestureType.Hold
| GestureType.FreeDrag;


E infine creiamo il metodo per la gestione dell'evento:

void Touch_FrameReported(object sender, TouchFrameEventArgs e)
{
if (TouchPanel.IsGestureAvailable)
{
GestureSample gesture = TouchPanel.ReadGesture();


if (gesture.GestureType == GestureType.HorizontalDrag)
{
//next page
}

}
}



Allo stesso modo è possibile gestire anche le altre gesture. Per ulteriori informazioni dare un'occhiata al seguente link

Aggiungere un nuovo utente a TFS 2010

Team foundation server 2010 utilizza la gestione degli utenti di Windows per gestire i propri utenti. In pratica ogni utente Tfs deve essere un’utente del sistema operativo sul quale Tfs è in esecuzione. Quindi il primo passo è quello di creare un nuovo utente attraverso la gestione degli utenti di windows. Per tale scopo basta consultare il sito web della microsoft e la pagina relativa al proprio sistema operativo.
Ecco i passi da seguire per aggiungere un nuovo utente a un progetto esistente:
1- Aprire Tfs Administrator console



In basso a destra cliccare sulla voce “Group Membership” che permette l’accesso alla schermata di gestione degli utenti.

2- Nella schermata successiva sono mostrati le varie tipologie di account utente che è possibile gestire



Selezionare l’ultima voce “Project Collection Valid Users” che permette di gestire tutti i permessi per le collection dei diversi Team Project

3- In questa schermata bisogna selezionare il tipo di privilegio che si vuole assegnare all’utente.




Ad esempio in questo caso assegniamo all’utente il privilegio di builders.

4- Verrà visualizzata ora una schermata con l’elenco degli utenti a cui sono già stati assegnati tali privilegi. Da questa schermata è possibile gestire sia singoli utenti ma anche gruppi di utenti.





Selezionamo in basso a sinistra “Windows User or Group” e clicchiamo sul pulsante Add.

5- Inseriamo ora il nome dell’utente Windows a cui vogliamo concedere i privilegi di builders. Basta inserire anche solo le prime lettere e poi cliccare sul pulsante Check Names



In automatico verrà visualizzato il nome completo che sarà memorizzato da Tfs. Cliccare su Ok



6- L’utente è ora stato aggiunto ed è presente nell’elenco insieme a gli altri utenti precedentemente creati