Top 10 Wordpress tips 2009

Siamo alla fine del 2009 e come si fa in questi casi è tempo di bilanci. Volevo stilare una classifica dei migliori 7 tips (trucchi) per wordpress che ho usato e trovato in rete. Wordpress si sta affermando sempre più come piattaforma di blogging e CMS quindi spero risulti utile a chiunque visiti le pagine del mio sito.
 
 

1. Pubblicare un post su Wordpress dall’esterno di Wordpress

Questo tip è quello che mi è piaciuto più di tutti…non l’ho ancora mai provato ma sicuramente lo farò in futuro. Il codice che segue permette di pubblicare un post su wordpress dall’esterno di wordpress, utilizzando cURL ovvero delle librerie php che permettono di simulare un web browser…più precisamente permettono di utilizzare tra gli altri il protocollo HTTP facendo submit dei dati di un form ad esempio.
Per utilizzare questa funzionalità è necessario attivare XMLRPC all’interno del file php.ini presente nell’installazione di php. Se non la si attiva non sarà possibile inserire il contenuto dei post all’interno del database.
Vediamo il codice:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

function add_post_to_wordpress($title, $body, $rpcurl, $username, $password, $category, $keywords='', $encoding='UTF-8') {
    $title = htmlentities($title,ENT_NOQUOTES,$encoding);
    $keywords = htmlentities($keywords,ENT_NOQUOTES,$encoding);
 
    $content = array(
        'title'=>$title,
        'description'=>$body,
        'mt_allow_comments'=>0,  // 1 to allow comments
        'mt_allow_pings'=>0,  // 1 to allow trackbacks
        'post_type'=>'post',
        'mt_keywords'=>$keywords,
        'categories'=>array($category)
    );
    $params = array(0,$username,$password,$content,true);
    $request = xmlrpc_encode_request('metaWeblog.newPost',$params);
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_POSTFIELDS, $request);
    curl_setopt($ch, CURLOPT_URL, $rpcurl);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_TIMEOUT, 1);
    $results = curl_exec($ch);
    curl_close($ch);
    return $results;
}

2. Visualizzare il numero di parole contenute in un post

E’ possibile contare il numero di parole che compongono un post per visualizzarlo, ad esempio, alla fine del post stesso. Basta aggiungere il seguente pezzo di codice all’interno del file function.php

1
2
3
4
5
6
7
8
9
10

function post_word_count(){
    /* Attiva l'output buffering */
    ob_start();
    /* Ottieni il contenuto del post */
    the_content();
    /* Preleva e ripulisci il contenuto del buffer */
    $content = ob_get_clean();
    /* Calcola il numero delle parole*/
    return sizeof(explode(" ", $content));
}

Al termine per richiamare la funzione è sufficiente effettuare la chiamata:

<?=post_word_count()?>

3. Ottenere la prima immagine di un post e visualizzarla

Questo tip è stato uno dei più quotati del 2009 dal sito WpRecipes. Dall’intero del contenuto di un post è possibile prelevare l’immagine contenuta al suo interno e visualizzarla.

1
2
3
4
5
6
7
8
9
10
11
12
13

function get_first_post_image() {
  global $post, $posts;
  $first_img = '';
  ob_start();
  ob_end_clean();
  $output = preg_match_all(\'//i\', $post->post_content, $matches);
  $first_img = $matches [1] [0];
 
  if(empty($first_img)){ //Defines a default image
    $first_img = "/images/default.jpg";
  }
  return $first_img;
}

Il codice di sopra va inserito all’interno del file function.php in modo che sia disponibile ai file del tema corrente. Al termine è possibile richiamarlo nel seguente modo:

1

<?=get_first_post_image()?>

4. Usare SSL per l’accesso al pannello di amministrazione

Per aumentare la sicurezza durante gli accessi al pannello di amministrazione di wordpress è possibile abilitare il protocollo SSL. SSL è un protocollo crittografico che permette una comunicazione sicura e integrità dei dati trasmessi su reti che utilizzano il protocollo TCP-IP, come internet. Per abilitarlo è sufficiente aggiungere la seguente riga di codice all’interno del file wp-admin.php:

1

define('FORCE_SSL_ADMIN', true);

5. Potenziare la funzionalità di ricerca

E’ possibile aumentare la potenzialità della ricerca integrata all’interno di wordpress evidenziando ad esempio i risultati trovati.

1
2
3
4
5
6

 $title = get_the_title();
 $keys= explode(" ",$s);
 $title = preg_replace('/('.implode('|', $keys) .')/iu',
	'<strong class="search-excerpt">\0</strong>',
	$title);
<br />

Il codice di sopra va inserito all’interno del file search.php del vostro tema corrente. Al termine aggiungete all’interno del vostro foglio di stile il codice per evidenziare i risultati della ricerca:

1

strong.search-excerpt { background: yellow; }

6. Override del nome dell’autore utilizzando un custom field

Se dal vostro blog permette la pubblicazione di post ad utenti guest, allora questo tip può esservi utile. In sostanza si tratta della creazione di un custom field che memorizza il nome dell’autore del post. Quindi in fase di visualizzazione del post se presente il custom field, si preleva il contenuto; altrimenti utilizzando la funziona predefinita di wordpress, si ottiene il nome dell’autore.
Vediamo come:

1
2
3
4
5
6

$author = get_post_meta($post->ID, "guest-author", true);
if ($author != "") {
    echo $author;
} else {
    the_author();
}

7. Riutilizzare i vecchi post

Questo tip permette di riutilizzare i vecchi post cercando di sfruttarli anche se sono stati pubblicare molto tempo fa. Per monetizzare i vecchi post è possibile ad esempio far comparire banner pubblicitari, ad esempio, solo se il post è più vecchio di 15 giorni.
Il codice che segue riconosce se il post è più vecchio di 15 giorni e in caso positivo aggiunge un banner pubblicitario.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

function is_old_post($post_id=null){
   $days = 15;
   global $wp_query;
   if(is_single() || is_page()) {
      if(!$post_id) {
         $post_id = $wp_query->post->ID;
      }
      $current_date = time();
      $offset = $days *60*60*24;
      $post_id = get_post($post_id);
      $post_date = mysql2date('U',$post_id->post_date);
      $cunning_math = $post_date + $offset;
      $test = $current_date - $cunning_math;
      if($test > 0){
         $return = true;
      }else{
         $return = false;
      }
   }else{
      $return = false;
   }
   return $return;
}

Il codice di sopra va inserito all’interno del file function.php in modo che sia disponibile ai file del tema corrente. Al termine è possibile richiamarlo nel seguente modo dall’interno del file singel.php:

1
2
3

<? if(is_old_post()){ ?>
INSERIRE IL CODICE QUI
<? } ?>

Stay tuned!

Generative Programming: yes !!

Oggi volevo parlare di un argomento che mi appassiona molto, ovvero della Generative Programming (Programmazione Generativa).
Mi piacerebbe molto dedicarmi a tempo pieno, ma ahimé il tempo è quello che è ! Cerchiamo di capire di cosa stiamo parlando, o meglio proviamoci.

La Programmazione Generativa è un paradigma di programmazione basato sulla modellazione di famiglie di sistemi software tali che, data una particolare specifica dei requisiti, è possibile generare su richiesta (on-demand) una versione definitiva del software personalizzata in modo automatico.
La programmazione generativa si concentra sulle famiglie di sistemi software piuttosto che su un tipo specifico di sistema. I singoli software appartenenti a famiglie di sistemi, possono essere generati a partire da un modello di dominio generativo (generative domain model), ovvero un modello di una famiglia di sistemi che ha 3 elementi:

1. un mezzo per la specifica dei singoli software
2. un insieme di implementations components capaci di costruire, assemblandoli, i singoli software
3. una specifica di configurazione, che mappa la specifica di un membro con la sua implementazione finale

Un’analogia la si ha quando si ordina un’automobile. C’è un sistema per ordinare l’automobile, ci sono i componenti con i quali si provvede ad assemblare (costruire) l’automobile ed infine c’è una specifica configurazione che indica come assemblare l’automobile secondo l’ordinazione richiesta.
Riepilogando, l’idea è generare in modo automatico singoli sistemi a partire da modelli di famiglie di sistemi. I componenti e la specifica di configurazione vengono riutilizzati per ogni membro generato, riducendo così il costo dello sviluppo per ogni singolo membro.
Esiste realmente un potenziale di riduzione dei costi di realizzazione di singoli software, perchè piuttosto che dover sviluppare da zero l’intero sistema, spesso basta aggiungere solo qualche funzionalità al modello generativo esistente. In sintesi è possibile praticare economie di scala utilizzando la programmazione generativa, riducendo sia i tempi che i costi dello sviluppo di un singolo software.
Non voglio annoiare con troppa teoria, quindi passiamo a vedere un esempio pratico che illustra le potenzialità della generazione automatica del codice, non prima di aver precisato che, prima di avventurarsi alla scrittura di un generatore è necessario effettuare una attenta analisi per determinare quali sono le caratteristiche comuni della famiglia dei software con cui si vuole operare. Questa analisi ha un nome preciso e si chiama: Domain Engineering.
Nell’ultimo post pubblicato su devme, abbiamo visto come rendere più chiara l’organizzazione dei custom fields di wordpress raggruppandoli semanticamente all’interno di un riquadro. L’articolo illustra il codice da scrivere per realizzare il raggruppamento, in particolare analizzando il codice generato si nota come alcune parti di esso sono statiche, o meglio non cambiano nelle varie implementazione; altre invece sono dinamiche, cioè cambiano sulla base di ciò che si sta creando. Vediamo più nel dettaglio. 
La prima parte di codice costituisce la definizione della struttura dati che mappa i custom fields che si vogliono raggruppare con il riquadro. Si definisce il nome del custom fields ed il titolo che comparirà in corrispondenza del campo all’interno del riquadro. La seconda parte consiste nella creazione di funzioni che riferiscono quanto dichiarato nella prima parte e creano il riquadro che verrà visualizzato, in termini di codice HTML, la logica che permette il salvataggio dei dati in fase di inserimento e modifica di un post. Infine si procede con la registrazione all’interno del framework del codice scritto.
Non mi soffermerò molto sul codice dal momento che l’articolo è esaustivo, piuttosto rendo disponibile il codice che realizza il generatore qui ampiamente commentato e la versione demo qui.
Nelle prossime puntate vedremo cosa vuol dire e come si realizza il Domain Engineering passaggio chiave per la realizzazione di software generatori.
Stay tuned.
 

Personalizzare il pannello di admin dei custom fields in Wordpress

Come avrei potuto non avere a che fare con Wordpress !? Provate un pò a dirmelo….il mitico CMS semplice da usare, gestire e facile da installare. Non ho mai parlato sul blog di wordpress, ne di quanto lo usi a lavoro..Tutti i giorni il caro inkiostro mi riempie sempre di nuovi e mirabolanti problemi da risolvere in wordpress, quindi mi sono fatto una discreta cultura.
Quello di cui volevo parlare è di come fare a rendere più chiara l’organizzazione dei custom field all’interno del pannello di amministrazione di wordpress, raggruppandoli semanticamente all’interno di un riquadro. Per intenderci dalla situazione in figura :

passare a questa:

 

Vediamo il codice php per realizzare quanto mostrato in figura:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

$box_dati_devme =
	array(
	    "titolo" => array(
	    "name" => "titolo",
	    "std" => "",
	    "title" => "Titolo",
	    "description" => ""),
 
	"url" => array(
	    "name" => "url",
	    "std" => "",
	    "title" => "URL",
	    "description" => ""),
 
	"argomento" => array(
	    "name" => "argomento",
	    "std" => "",
	    "title" => "Argomento",
	    "description" => ""));

Primo step: definire una variabile di tipo array in cui il primo elemento ha come chiave il nome del campo custom e come valore, un array che definisce il nome alcuni attributi del campo custom, nome, std, title e description.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

function box_dati_devme_boxes() {
	global $post, $box_dati_devme;
	echo '<table style="width:99%">';
	foreach($box_dati_devme as $meta_box) {
		echo '<tr>';
		echo '<td class="left" style="width:25%;">';
		$meta_box_value = get_post_meta($post->ID, $meta_box['name'], true);
		if($meta_box_value == "")
			$meta_box_value = $meta_box['std'];
		echo '<input type="hidden" name="'.$meta_box['name'].'_noncename" id="'.$meta_box['name'].'_noncename" value="'.wp_create_nonce( plugin_basename(__FILE__) ).'" />';
		echo $meta_box['title'];
		echo '<br />';
		echo '<label class="desc" style="font-size:10px;" for="'.$meta_box['name'].'_value">'.$meta_box['description'].'</label>';
		echo '</td>';
		echo '<td>';
		echo '<textarea style="width:99%" rows="2" name="'.$meta_box['name'].'_value">'.$meta_box_value.'</textarea>';
		echo '</td>';
		echo '</tr>';
	}
	echo '</table>';
}

Secondo step: definire una funziona in cui l’unica cosa da fare è aggiungere come variabile globale dopo $post il nome della variabile definita allo step uno e la stessa variabile come iteratore del foreach.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

function create_meta_box() {
    global $theme_name;
 
    if ( function_exists('box_dati_devme_boxes') ) {
        add_meta_box('box_dati_devme', 'Boxe DevMe', 'box_dati_devme', 'post', 'normal', 'high');
    }
}
 
function save_postdata( $post_id ) {
	global $post, $box_dati_devme;
 
	foreach($box_dati_devme as $meta_box) {
		if ( !wp_verify_nonce( $_POST[$meta_box['name'].'_noncename'], plugin_basename(__FILE__) )) {
			return $post_id;
		}
		if ( 'page' == $_POST['post_type'] ) {
			if ( !current_user_can( 'edit_page', $post_id ))
				return $post_id;
		} else {
			if ( !current_user_can( 'edit_post', $post_id ))
				return $post_id;
		}
		$data = $_POST[$meta_box['name'].'_value'];
		if(get_post_meta($post_id, $meta_box['name']) == "")
			add_post_meta($post_id, $meta_box['name'], $data, true);
		elseif($data != get_post_meta($post_id, $meta_box['name'], true))
			update_post_meta($post_id, $meta_box['name'], $data);
		elseif($data == "")
			delete_post_meta($post_id, $meta_box['name'], get_post_meta($post_id, $meta_box['name'], true));
	}
}
 
add_action('admin_menu', 'create_meta_box');
add_action('save_post', 'save_postdata');

Terzo step: nell’ultimo step ho racchiuso un pò di cose tutte assieme. Si definiscono 2 funzioni : la create_meta_box e la save_postdata. La prima viene richiamata dal framework di wordpress per creare il riquadro, contestualmente si definiscono il nome del riquadro che comparirà poi in pagine e si aggiunge il riferimento alla variabile definita nello step uno. La funzione save_postdata viene usata da wordpress per effettuare il salvataggio dei custom field inseriti al momento dell’inserimento e della modifica di un post. Infine si registrano le 2 funzioni php con le add_action di wordpress.
E’ chiaro che in presenza di pochi custom field si può procedere anche senza personalizzare il pannello; al contrario, con un centinaio di campi il tutto diviene più chiaro. Consiglio nel caso usiate questa soluzione, di definire la personalizzare dei campi all’interno di un file .php che terrete all’interno del tema che state usando, quindi importarlo all’interno del file function.php.
Stay tuned.

NFC: qualcosa si muove (part-two)

Seconda parte dell’articolo su come scrivere programma che legge da un tag RFC e scrive su un tag RFC. Qui potete trovare quanto scritto sulla lettura da un tag NFC.
La parte che andremo ad analizzare prevede la scrittura di alcune informazioni su un tag NFC, attraverso l’interfaccia della nostra applicazione. Nello specifico andremo a scrivere i dati di un nuovo contatto della rubrica sul tag e successivamente potremo leggere quanto scritto con la funzionalità vista nell’articolo precedente.

Anche in questo caso la logica che sta dietro alla funzionalità è basata sugli eventi, in particolare, per la classe NFCWriter viene registrato un evento, il Tag Detection, che quanto catturato, esegue il codice contenuto al suo interno. Dall’interfaccia viene richiesto di inserire il testo da scrivere sul tag, si preme su OK e si avvicina il cellulare in prossimità del tag. A quel punto viene gestito l’evento che si preoccupa di stabilire una connessione con il tag NFC ed inviare.

    

Vediamo il codice che realizza quanto detto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class NDEFWriter extends NDEFHandler {
    Form previousScreen = null;
    String fName = "No name";
 
    public NDEFWriter(Form form) {
	previousScreen = form;
    }	
 
    public void targetDetectionMade(TargetProperties[] tProp) {
	previousScreen.append("Target detected.\n");
	if(tProp == null || tProp.length == 0) {
	    previousScreen.append("No TargetProperties found!\n");
	}
	NDEFTagConnection ndefTagConnection = null;
	try {				
	    previousScreen.append("Target mapping:"+tProp[0].getMapping()+"\n");				
	    ndefTagConnection =NDEFUtil.getNDEFTAGConnection(tProp,previousScreen);
	    if(ndefTagConnection == null) {
		previousScreen.append("Could not establish connection to card.\n");
		return;
	    }
	    NDEFUtil.writeNDEFMessage(ndefTagConnection,previousScreen);
	    ndefTagConnection.close();
	} catch (Exception e) {
	    if(ndefTagConnection != null) {
		try {
		    ndefTagConnection.close();
		} catch (IOException e1) {
		    previousScreen.append("Exception in closing connection:"+e1.toString());
		}
	    }
	    previousScreen.append("Exception:\n"+e.toString()+"\n");
	    e.printStackTrace();
	}
 
    }
 
    public String getFormattedName() {
	return fName;
    }
 
    public void setFormattedName(String fName) {
	this.fName = fName;	
    }
}

Come potete vedere non è molto difficile realizzare un programma Java che sfrutti le potenzialità fornite dalla tecnologia NFC, tutta sta a conoscere un pò le API messe a disposizione dalla Nokia. Tutto il resto è Java, gestione degli eventi, ereditarietà, interfacce, etc etc. Un vero (buon) programmatore Java non troverà alcuna difficoltà a realizzare la maggior parte delle funzionalità.
Questo è tutto.
Il codice completo per far girare l’esempio lo trovato nelle SDK del Nokia 6131 NFC è necessario la registrazione sul sito per poter effettuare il download. Dopo di che cercate nella cartella examples.
Stay tuned. yo.
 

Symbian – Autostart di un applicazione su serie 9

Tempo fa in questo post ho scritto come realizzare un programma starter per Symbian serie 8, cioè un launcher di un’applicazione al boot del cellulare. Oggi invece volevo farvi vedere l’analogo su serie 9, la nuova serie di Symbian installata su molti dei cellulari Nokia attualmente in commercio. Premesso che al momento del post precedente la documentazione sull’argomento non era molta, oggi invece esistono molti siti dove è possibile trovare informazioni sull’argomenti, a partire dallo wiki della nokia dove c’è praticamente tutto, per finire sulla pagine di google .
Ma siccome le risorse in italiano non sono mai abbastanza allora volevo illustrare comunque la soluzione

A differenza della precedente versione con Symbian 9 è possibile realizzare l’autostart di un’applicazione usando il meccanismo dello "Startup Management List API" consultabile qui. L’idea di base di questa gestione consiste nel definire un file di risorse attribuendogli come nome l’UID del package che contiene l’applicazione. Tale file conterrà al suo interno alcuni dati di configurazione al fine di poter eseguire l’applicazione indicata all’avvio del programma. Vediamo in cosa consistono questi dati di configurazione:
 

1
2
3
4
5
6

#include <startupitem.rh> 
RESOURCE STARTUP_ITEM_INFO devme 
{ 
    executable_name = "!:\\sys\\bin\\devme.exe"; 
    recovery = EStartupItemExPolicyNone; 
}

Bene. Subito una piccola precisazione. Come vedete il valore di executable_name coincide con un path, quello di installazione dell’applicazione. Ha all’inizio un punto esclamativo che sta ad indicare la destinazione intesa come unità di installazione. Chi ha installato un’applicazione per symbian sa che ad un certo punto viene chiesto di indicare la destinazione su cui installare il programma, se la memoria del telefono o eventuali memorie esterne. Ecco il ! riferisce quella destinazione. Se si vuole, ad esempio, imporre l’installazione sulla memoria del telefono il ! verrà sostituito con C. 
Come vedete i dati di configurazione sono pochi e il commento viene da se.

Prossimo step consiste nell’aggiungere il riferimento del file appena creato all’interno del file di configurazione .mmp.

1
2

START RESOURCE ..\DATA\APP_UID.rss
END

Ed infine aggiungere le informazioni di configurazione nel file .pkg.

1

"$(EPOCROOT)Epoc32\data\z\private\101f875a\import\apps\APP_UID.rsc" -"c:\private\101f875a\import\[APP_UID].rsc"

Dove la prima parte della riga di configurazione indica il percorso delle SDK che si stanno utilizzando per la build corrente. Nel mio caso siccome sto usando Carbide come IDE posso utilizzare le variabili d’ambiente che mette a disposizione. Da notare che, mentre per un qualunque altro programma posso usare il ! per indicare la destinazione, per quanto riguarda l’autostart su serie 9 devo indicare C come destinazione…non solo, in aggiunta l’intero percorso dove vengono memorizzati questi tipi di file "C:\private\101f875a\import\".
Stay tuned, a presto.

NFC: qualcosa si muove (part-one)

Oggi ho visto in tv un servizio che parlava su come usare il proprio cellulare per effettuare piccoli pagamenti, il cosidetto telefonino/bancomat. Il funzionamento si basa sulla tecnologia Near Field Communication, ovvero un’evoluzione dell’ RFID la tecnologia che permette di far comunicare due dispositivi portanto in prossimità l’uno dell’altro. In questo articolo pubblicato sulle pagine di devme poco tempo fa, reperibile qui si parla di questa tecnologia, in particolare è possibile utilizzare il telefonino come fosse bancomato, nella modalità touch-to-pay: "avvicinando il cellulare sarà possibile utilizzarlo come una carta di credito. Le informazioni sensibili della carta sono memorizzate al suo interno in un elemento chiamato secure element. In sostanza funziona come una carta di credito senza contatto.E’ possibile visualizzare le informazioni informative classiche delle proprie transazioni".
Nello specifico in linea di principio basta scrivere i dati del proprio bancomat all’interno del cosidetto secure element e a quel punto sarà possibile, avvicinando il cellulare in prossimità di un dispositivo capace di leggere tag NFC, effettuare un’addebito sul proprio conto corrente. Pensateci, quale migliore comodità !!
Bene, analizziamo ora più da vicino, in un esempio molto semplice, come scrivere un programma che legge da un tag NFC e scrive su un tag NFC. Il programma è scritto in Java, l’IDE che utilizziamo per fare il test è Eclipse sul quale installeremo il plugin eclipseme che permette di sviluppare applicazione utilizzando le librerie J2ME.

Partiamo quindi lo scrivere la nostra midlet, DevMeNFCMidlet:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class DevMeNFCMidlet extends MIDlet {
    Display display;
    MainList list;
    String[] actions = new String[]{"Read","Write","Show contacts"};
    Image[] images = null;
 
    protected void startApp() throws MIDletStateChangeException {
	display = Display.getDisplay(this);
	list = new MainList("Select action to do:", List.EXCLUSIVE,actions,images,this,null);
	display.setCurrent(list);
    }
 
    protected void pauseApp() {}
 
    public void destroyApp(boolean arg0) throws MIDletStateChangeException {
	notifyDestroyed();
    }
 
    /**
     * Helper method to change the current displayable
     * 
    */
    public void setToDisplay(Displayable dspl) {
	display.setCurrent(dspl);
    }
}

Nel caso vi foste persi qualcosa sulle Midlet Java, in breve, è un’applicazione che gira su sistemi su cui è presente la J2ME Virtual Machine. Per creare una Midlet è sufficente estendere la propria classe con la classe Midlet, messa a disposizione dal Wireless Toolkit. L’estensione impone l’implementazione di alcuni metodi dal momento che la classe Midlet è una classe astratta. Il metodo StartApp() viene richiamato al momento del lancio dell’applicazione e nel nostro caso crea una lista con 3 opzioni: Read, Write e Show Contacts. La nostra applicazione legge da un tag NFC virtuale, emulato per intenderci e scrive sullo stesso tag. L’emulazione viene messa a disposizione dalle librerie opzionali, Contactless Communication API scaricabili dal sito della nokia, che sarà dunque necessario rendere disponibili all’interno del progetto in eclipse. Lanciando l’applicazione avremo:

Ciò che si vede è l’interfaccia dell’emulatore con la midlet caricata e pronta per essere eseguita. L’emulatore sostanzialmente è un cellulare, nello specifico il nokia 6131 che possiede al suo interno un tag NFC con le relative librerie. Per avviare l’applicazione è sufficente cliccare il bottone (sul cellulare) in corrispondenza della voce Select.

L’applicazione come detto mostra il menù con 3 voce selezionabili, in particolare se selezioniamo l’opzione Read saremo in grado di leggere da un tag NFC un certo contenuto. Nella nostra simulazione, i tag NFC sono virtuali e vengono mostrati sulla destra nell’interfaccia dell’emulatore. Alcuni di questi sono attivi, connessi altri disconnessi. Per effettuare una simulazione di lettura trasciniamo il tag NFC attivo all’interno del cellulare come mostrato in figura. A quel punto il contenuto del tag viene mostrato all’interno del telefono.

Ma diamo un occhiata al codice che realizza la funzionalità. L’idea che sta dietro alla logica è molto semplice. Si registra la classe del Reader per un determinato evento, ovvero per l’evento Tag Detection. Rilevato il tag viene richiamato un metodo della classe che stabilisce una connessione con il tag e legge il messaggio inviato dal tag. Il contenuto del messagio viene visualizzato sul display del cellulare. Di seguito incollo il codice della classe Reader.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

public class NDEFReader extends NDEFHandler {
    Form previousScreen = null;
    public NDEFReader(Form form) {
        super();
        previousScreen = form;
    }
 
    public void targetDetectionMade(TargetProperties[] tProp) {
	previousScreen.append("Target detected.\n");
	if(tProp == null || tProp.length == 0) {
	    previousScreen.append("No TargetProperties found!\n");
	}
	NDEFTagConnection ndefConnection = null;
	try {			
	    previousScreen.append("Target mapping:"+tProp[0].getMapping()+"\n");				
	    ndefConnection =NDEFUtil.getNDEFTAGConnection(tProp,previousScreen);
	    if(ndefConnection == null) {
		previousScreen.append("Could not establish connection to card.\n");
		return;
	    }
	    NDEFUtil.readNDEFMessage(ndefConnection,previousScreen);
	    ndefConnection.close();
	} catch (Exception e) {
	    if(ndefConnection != null) {
	        try {
		    ndefConnection.close();
	        } catch (IOException e1) {
		    previousScreen.append("Exception in closing connection:"+e1.toString());
	        }
	    }
	    previousScreen.append("Exception:\n"+e.toString()+"\n");
	    e.printStackTrace();
        }
    }
 
    public String getFormattedName() {
        return null;
    }
 
    public void setFormattedName(String fName) {}
 
}

Il metodo targetDetectionMade realizza tutto quello che è stato detto nel paragrafo precedente. Per quanto riguarda il resto del codice rimando ai prossimi articoli. Stay tuned! yo

Crittare l’url di un immagine in jsp con Spring

In questo articolo voglio far vedere come nascondere l’href di un immagine in una pagine JSP, pur visualizzando l’immagine come elemento HTML in modo standard.
Supponiamo di dover sviluppare un’applicazione web in cui ciascun utente mantiene una libreria multimediale, costituita per semplicità da soli elementi immagine. Ogni immagine viene memorizzata all’interno di un database assieme alla relative informazioni dell’utente a cui appartiene.
Affinché l’immagine non sia accessibile semplicemente attraverso l’indirizzo indicato nell’HREF, è necessario offuscare il suo contenuto attraverso una codifica il cui funzionamento è noto al sistema. Lo stesso sistema sarà in grado così di decodificare l’HREF in modo da poter restituire la risorsa e quindi visulalizzarla all’interno della pagina.
Vediamo il seguente esempio:

1
2
3
4
5

   <!-- Immagine in chiaro -->
   <img src="http://host/images/img.jpg" title="Immgine in chiaro" alt="" />
 
   <!-- Immagine offuscata -->
   <img src="http://host/image.htm?a=QVMyJCU0c2Rm%3D&b=QVMyJCU0c2RmMzI0M3NkdzI%3D" title="Immgine in chiaro" alt="" />

Nell’esempio di sopra viene mostrata un’immagine in cui l’href è crittata secondo un algoritmo che ora vedremo. E’ chiaro che nel secondo caso, affinché l’immagine possa essere visualizzata è necessaria la presenza di un elemento capace di interpretarne il contenuto, ottenere e restituire la risorsa.
Nell’ambito di Spring tutto questo può essere tradotto nel modo seguente: è necessario un Controller che venga richiamato ogni volta in cui nella pagina è presente un’immagine.
Il Controller dovrà prelevare il contenuto dell’HREF decodificarlo e restituire l’immagine, se corretto. Procediamo quindi per step.
Primo Step configuriamo il Controller (Servlet) all’interno di Spring…quindi editiamo il file di configurazione di spring ed aggiungiamo le seguenti righe di codice:

1
2
3
4
5
6
7
8

    <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping" id="urlMapping"> 
        <property name="mappings">
	<value>/image.htm=mediaResolver</value>
        <property value="true" name="alwaysUseFullPath"></property>
    </bean> 
    <bean class="it.devme.obfuscator.media.MediaResolver" id="mediaResolver">
        <property name="dbManager"><ref bean="dbManager"></ref></property>     
    </bean>

L’invocazione della risorsa virtuale index.htm provoca l’invocazione del Controller MediaResolver. Vediamo la sua struttura di seguito:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

public class MediaResolver extends BaseCommandController {
 
    private DBManager dbManager;
    public void setDbManager (DBManager dbManager) {
	this.dbManager = dbManager;
    }
 
    @Override
    protected ModelAndView handleRequestInternal(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
	Object mediaid = req.getParameter("a");
	Object uid = req.getParameter("b");
 
	if (mediaid==null || uid==null) 
	    return new ModelAndView(new MediaView("image/jpeg", "no-image.jpg", rs.getString("basePath"), MediaView.USE_DEFAULT_IMAGE));
 
	Encrypter dec = Encrypter.getInstance();
	int idaccount = Integer.parseInt(URLDecoder.decode(dec.decrypt(uid.toString()), "UTF-8"));
	int idelement = Integer.parseInt(URLDecoder.decode(dec.decrypt(mediaid.toString()), "UTF-8"));
 
	MediaBean media = null;
	File f = null;
	String mediaPath = null;
 
	/* Check if media item exists */
	media = dbManager.getImage(idelement, idaccount);
	if (media==null) return new ModelAndView();
	mediaPath = media.getPath();
	f = new File(UPLOAD_PATH + File.separator + mediaPath);
 
	MimetypesFileTypeMap mime = new MimetypesFileTypeMap();
 
	resp.setHeader("Cache-Control", "private,no-cache,no-store");
	resp.setContentType(mime.getContentType(f));
	return new ModelAndView(new MediaView(mime.getContentType(f), mediaPath, rs.getString("basePath"), !MediaView.USE_DEFAULT_IMAGE));
    }
 
}

La classe di sopra estende BaseCommandController e quando invocata viene richiamato l’unico metodo di cui è stato fatto l’override che si occupa di decodificare e restituire la risorsa. Vediamo come.
Sostanzialmente recupera i parametri dalla GET (nel nostro caso sono a e b). Li decodifica utilizzando un algoritmo di crittografia a noi noto (si può usare qualunque algoritmo a nostro piacimento basato su una chiave provata) e quindi ottiene per il parametro a, l’id dell’utente a cui appartiene la risorsa e per il parametro b, l’id della risorsa a cui si vuole accedere. Questi dati vengono passati in input ad un metodo che effettua una query su db (getImage(idelement, idaccount)) e verifica se effettivamente la risorsa richiesta appartiene all’utente corrente.
In caso contrario viene restituita una View vuota, altrimenti si determina il mime-type della risorsa e si restituisce una view creata a partire dalla classe MediaView.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

public class MediaView extends AbstractView {
 
    private String media;
    private String basePath;
    private boolean noImage;
 
    public MediaView(String mime, String media, String basePath, boolean noImage) {
	this.media = media; 
	setContentType(mime);
	this.basePath = basePath;
    }
 
    @Override
    protected void renderMergedOutputModel(Map model, HttpServletRequest request, HttpServletResponse response) throws Exception {
	String rpath = 	null;
 
	rpath = this.basePath + request.getContextPath().substring(1) +
		MediaResolver.UPLOAD_PATH + File.separator + this.media;
 
 
	File f = new File(rpath);
	byte[] bytes = FileUtils.readFileToByteArray(f);
 
 
        // Write content type and also length (determined via byte array).
        response.setContentType(getContentType());
        response.setContentLength(bytes.length);
 
        // Flush byte array to servlet output stream.
        ServletOutputStream out = response.getOutputStream();
        out.write(bytes);
        out.flush();
    }
 
}

La classe MediaView non fa altro che leggere fisicamente i byte dell’immagine e restituirla nella response utilizzando un OutputStream. Il risultato è che l’immagine scritta nella response verrà visualizzata in pagina come un elemento HTML standard, mantenendo perà l’HREF dell’immagine crittato.
Alla prossima.

NFC: tecnologia in un touch !

Pochi giorni fa, sul sito del corriere dell sera ho letto un articolo interessante, in cui il CEO della Nokia, ovvero il numero uno della compagnia finlandese Mr Kallasvuo, affermava che la competizione con gli attuali smartphone, Apple, Blackberry, etc, lì spingerà oltre la telefonia. In futuro si potranno effettuare pagamenti di bollette, acquisti in genere utilizzando il proprio telefonino.
E in effetti, poco tempo prima di leggere l’articolo, avevo esplorato il mondo dei nuovi telefonini Nokia che integrano una nuova tecnologia chiamata NFC.

Near Field Communication (NFC) è una tecnologia che fornisce connettività wireless bidirezionale a corto raggio (fino ad un massimo di 10 cm). La tecnologia NFC si è evoluta da una combinazione di identificazione senza contatto o RFID (Radio Frequency Identification – IDentificazione a Radio Frequenza) e altre tecnologie di connettività. NFC, contrariamente ai più semplici dispositivi RFID, permette una comunicazione bidirezionale: quando due apparecchi NFC (l’Initiator e il Target) vengono accostati entro un raggio di 4 cm, viene creata una rete peer-to-peer tra i due ed entrambi possono inviare e ricevere informazioni (fonte wikipedia). Al momento l’unico cellulare dotato di funzionalità NFC è il Nokia 6131.

Premesso che non mi interessa fare pubblicità del cellulare (non sono ancora sul libro paga della Nokia), al contrario voglio farvi vedere come la tecnologia (forse) cambierà i nostri modi di fare quelle cose che al momento sono scontate. Vediamo quali potrebbero essere:

touch-to-pay: avvicinando il cellulare sarà possibile utilizzarlo come una carta di credito. Le informazioni sensibili della carta sono memorizzate al suo interno in un elemento chiamato secure element. In sostanza funziona come una carta di credito senza contatto.E’ possibile visualizzare le informazioni informative classiche delle proprie transazioni.  

Il cellulare funziona come un biglietto senza il contatto. Basterà avvicinarlo ad un altro dispositivo capace di leggerlo per effettuare la validazione. Le informazioni sul biglietto o travel card sono memorizzate all’interno del secure element. Sarà ossibile ricaricare la propria travel card da dovunque ed in un qualunque momento e visionare la storia delle proprie validazioni.

Ovviamente non poteva mancare un servizio capace di far fruire di contenuti interattivi semplicemente avvicinando il cellulare ai dispositivi capaci di rendere tali servizi. Si pensi ad esempio a servizi di marketing interattivo che vengono attivati senza il contatto.

Ma c’è da fidarsi ?
E se dovessi perdere il cellulare ?
Ma soprattutto, cos’è questo secure element ?
Come ogni dispositivo tecnologico nuovo, secondo me, bisognerà aspettare prima di vedere una diffusione non dico capillare ma degna di nota. Non dimentichiamo, che in particolare il nostro paese, è un pò restio all’utilizzo di dispositivi o mezzi del genere per effettuare pagamenti. Molta gente preferisce il buon vecchio contante. Ciò nonostante sono fiducioso, dopo un’attenta campagna di marketing probabilmente qualcosa comincierà a muoversi. Chiaro che tutto dipende molto anche dalla diffusione dei cellulari che integrano funzionalità NFC, poco tempo fa la Sony Ericsson ha annunciato che dal 2010 tutti i suoi nuovi cellulari includeranno tali funzionalità, a dimostrazione che anche loro ci credono molto.
Il caso in cui si dovesse perdere il cellulare credo che sia molto simile al caso in cui si dovesse smarrire la carta di credito, in cui chiamando il numero verde si blocca la carta. Analogamente credo che chiamando il numero verde dell’operatore si provvederà al blocco del cellulare….sempre che ce né accorgiamo in tempo .

Infine vediamo in che modo i dati sensibili della carta di credito vengono memorizzati. Come già detto i dati vengono memorizzati all’interno del secure element un componente hardware che è integrato all’interno del cellulare. La dimensione della memoria dell’elemento è di 72Kb, in cui una certa dimensione è riservata per le applicazioni specifiche del cellulare. Mentre la memoria disponibile per le applicaizoni nella Java Card è di 65Kb.

Il Secure Element è governato da regole e procedure di sicurezza molto stringenti. Si trova in uno stato SICURO dal momento dell’acquisto del cellulare. Ci sono 2 differenti chiavi di autenticazione per accedere al secure element, una per l’accesso alla Java Card e l’altra per l’accesso alla Mifare 4k. Java Card soddisfa requisiti di sicurezza molto alti derivanti direttamente dal life-cycle dell’elemento stesso. A partire dal silicio usato per la costruzione del chip, al sistema operativo, al processo di costruzione e trasferimento dei dati al suo interno. Quando si acquista un cellulare il secure element contiene solo il dato segreto della chiave specifica del dispositivo.

Bene per ora direi che può bastare. L’argomento mi interessa molto, procedo con le mie esplorazioni di implementazione di applicazioni di prova, così da condividerle con chi, di passaggio o non, si troverà sulle pagine del mio blog. A presto…yo.

X-stream: xml è facile !

Salve a tutti…ebbene sì…si ricomincia. Siccome è passato un pò di tempo dall’ultimo post, inizierò a scrivere così come se niente fosse…così nessuno se né accorgerà  ! Sono alle prese con lo sviluppo di un’applicazione web, che fa uso di XML per la serializzazione dei dati. L’applicazione è scritta in Java, usa Spring come framework di appoggio. La parte fondamentale come dicevo, consiste nella serializzazione dei dati in XML. La struttura XML che deve essere serializzata non è molto complessa, ma neanche troppo semplice…per cui al primo impatto, ho deciso di non appoggiarmi sulle classiche librerie messe a disposizione da Java (xerces) o quelle presenti di default nelle API (javax.xml.parser).
Sono andato così alla ricerca in rete di qualcosa che potesse essermi utile, cercavo qualcosa che fosse facile da usare e al tempo stesso leggero, in modo tale da non appesantire l’applicazione. Ho trovato così XStream, una libreria che permette di serializzare oggetti in XML e viceversa. Il viceversa nel mio caso è fondamentale, dal momento che se possibile inizializzare una struttura dati di oggetti senza dover, materialmente, navigare l’XML mi ha aiutato molto.
Non mi soffermerò molto nel descrivere le caratteristiche della libreria, sopra come avrete notato ho linkato l’URL quindi potete fare da voi…mi concentrerò su qualche feature che mi è sembrata interessante e descriverò qualche esempio pratico.
La creazione di un file XML a partire da un oggetto Java è molto semplice, si parte dalla creazione e inizializzazione dell’oggetto stesso, dopo di ché si procedere richiamando un metodo statico che provvede alla generazione (serializzazione) del file:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public class Blog {
  private String name;
  private String author;
  private Contacts contacts;
  /* getter&setter + constructor */
}
 
public class Contacts {
  private String email;
  private String url;
  /* getter&setter + constructor */
}
 
XStream xstream = new XStream();
XStream xstream = new XStream(new DomDriver());
 
/* GLi alias rendono la serializzazione più chiara */
xstream.alias("person", Blog.class);
xstream.alias("phonenumber", Contacts.class);
 
Blog blog = new Blog("DevMe", "mulp");
blog.setContacts(new Contacts("mulp@devme.it", "http://www.devme.it"));
String xml = xstream.toXML(blog);

<blog>
    <name>DevMe</name>
    <author>mulp</author>
    <contacts>
    	<email>mulp@devme.it</email>
    	<url>http://www.devme.it</url>
    </contacts>
</blog>

Al contrario, dando in input l’XML prodtto, si ottiene l’oggetto inizializzato:

1

Blog blog = (Blog)xstream.fromXML(xml);

L’esempio di prima dimostra la facilità e la flessibilità d’uso della libreria XStream. Unico particolare degno di nota è il fatto di poter definire degli alias per le classi che permette poi, in fase di serializzazione di poter generare tag coincisi dal nome uguale al nome della variabile membro, a meno che non si chieda di cambiarlo. Per intenderci, se non avessi definito gli alias otterei come tag il nome completo della classe per il tag blog assieme al nome del package, nell’esempio quello di default.

XStream usa il meccanimo delle Annotations per definire gli alias, rendendo così la definizione decisamente più pratica. Vediamo un esempio di codice che non definisce alias:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package it.devme.music;
 
public class Police {
    private String songTitle;
    public Police(String songTitle) {
        this.songTitle = songTitle;
    }
}
 
package it.devme.music;
public class JukeBox {
    public static void main(String[] args) {
        XStream stream = new XStream();
	Police song = new Police("Message in a bottle");
	System.out.println(stream.toXML(msg));
    }
}

L’esecuzione del codice produce il seguente XML:

1
2
3

    <it.devme.music.Police>
        <songTitle>Message in a bottle</songTitle>
    </it.devme.music.Police>

Come si può notare, senza l’utilizzo degli alias la serializzazione in XML non è coincisa, in particolare il nome della classe Persona eredita l’intero percorso del suo package di appartenenza. Definiamo ora gli alias usando le Annotations:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package it.devme.music;
 
@XStreamAlias("police-songography")
public class Police {
    @XStreamAlias("song")
    private String songTitle;
    public Police(String songTitle) {
        this.songTitle = songTitle;
    }
}
 
package it.devme.music;
public class JukeBox {
    public static void main(String[] args) {
        XStream stream = new XStream();
	Police song = new Police("Message in a bottle");
	System.out.println(stream.toXML(msg));
    }
}

L’esecuzione del codice produce il seguente XML:

1
2
3

    <police-songography>
        <song>Message in a bottle</song>
    </police-songography>

Notate ora come il file XML è più chiaro e come il nome dei tag non dipende strettamente dai nomi delle classi e/o delle variabili membro, ma dagli alias definiti all’interno della classe stessa.

Come ultima cosa volevo soffermarmi su un’altra caratteristica di questa libreria, i Converter. Questo meccanismo da la possibilità di poter gestire in fase di serializzazione/deserializzazione l’esatta elaborazione che deve essere svolta in modo tale da avere una corretta esecuzione delle procedure. Per poter scrivere il proprio Converter è necessario implementare l’interfaccia Converter ed implementare i metodi proposti:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

package it.devme.music;
public class PoliceConverter implements Converter {
    public boolean canConvert(Class clazz) {
        return false;
    }
 
    public void marshal(Object value, HierarchicalStreamWriter writer,
                        MarshallingContext context) {
        }
 
    public Object unmarshal(HierarchicalStreamReader reader,
                        UnmarshallingContext context) {
        return null;
    }
}

Il metodo canConvert verifica l’applicabilità del converter rispetto alla classe che si desidera pre/post elaborare. Il metodo marshal è una pre elaborazione, mentre unmurshal è una post elaborazione. I casi d’uso di un Converter variano dai più semplici, in cui si applica una trasformazione al tipo di dato che dovrà essere serializzato (si pensi ad esempio ad una data in formato millisecondi da trasformare in gg/mm/aaaa), ai più complessi in cui è necessario elaborare un nodo complesso contenente sottoalberi, ovviamente in entrambe le operazioni di serializzazione/deserializzazione. Vi rimando al tutorial sui Converter per gli esempi del caso.

See U on next post, enjoy !

Singleton pattern: quando e come usarlo.

Traendo ispirazione su un post trovato per la rete, ho deciso di scrivere un piccolo, ma proprio piccolo post, sul pattern Singleton, molto usato durante le sessioni di programmazione per risolvere una certa classe di problemi comuni. Definiamo un singleton come:
una classe per cui esiste una sola istanza nell’applicazione, e per la quale viene fornito un’unico punto globale di accesso.
Vediamo un possibile modo di implementare il singleton:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class DevMeSingleton {
    /* class instance */
    private static DevMeSingleton instance;
    /* Costruttore privato della classe */
    private DevMeSingleton() {}
 
    /* Metodo che permette di ottenere l'istanza della classe */
    public static DevMeSingleton getInstance() {
        if (instance==null) {
            instance = new DevMeSingleton();
        }
        return instance;
    }
}

1. Semplice implementazione singleton pattern

L’implementazione di cui sopra, può causare problemi di performance nel contesto di un applicazione multithreading. E’ possibili che 2 thread ottengano in contemporanea 2 istanze della classe singleton, violando così un presupposto fondamentale della definizione. Per far sì che il comportamento non sia critico in un contesto del genere, si consideri l’utilizzo della tecnica: double-checked locking. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class DevMeSingleton {
        /* class instance */
        private volatile static DevMeSingleton instance;
 
        /* Costruttore privato della classe */
        private DevMeSingleton() {}
 
        /* Metodo che permette di ottenere l'istanza della classe */
        public static DevMeSingleton getInstance() {
            if (instance==null) {
                synchronized(DevMeSingleton.class) {
                    if (instance==null) {
                        instance = new DevMeSingleton();
                    }
                }
            }
        return instance;
    }
}

2. Tecnica double-checked locking

Questa tecnica purtroppo non funziona con la JVM 1.4 a causa della defizione della variabile volatile, la quale non era stata ancora implementata. Per ovviare a questo problema, vediamo l’implementazione successiva. 

1
2
3
4
5
6
7
8
9
10
11
12
13

public class DevMeSingleton {
 
        /* class instance */
        private static DevMeSingleton instance = new DevMeSingleton();
 
        /* Costruttore privato della classe */
        private DevMeSingleton() {}
 
        /* Metodo che permette di ottenere l'istanza della classe */
        public static DevMeSingleton getInstance() {
            return instance;
        }
}

3. Creazione efficiente dell’istanza di una classe Singleton

L’implementazione di cui sopra, garantisce la creazione efficiente dell’istanza della classe singleton, piuttosto di una creazione cosiddetta lazy (pigra). Il singleton viene creato all’atto dell’invocazione della classe, in quel momento vengono istanziate tutte le varibili static, tra cui anche l’istanza del singleton. Spero che possa essere utile. A presto.