venerdì 6 dicembre 2013

Manipolazione di immagini con CodeIgniter


CodeIgniter permette di manipolare le immagini con una apposita libreria, eseguendo le seguenti operazioni:
  • ridimensionamento
  • cropping
  • rotazione
  • aggiunta di watermark

Ridimensionamento

La image library viene caricata dal framework mediante l'apposita funzione del framework (load), con parametro un array di configurazione. A seconda della configurazione utilizzata può essere richiamata una funzione di manipolazione immagini. Ad esempio, per eseguire un ridimensionamento devono essere specificati i parametri width e height:
$config['image_library'] = 'gd2';
$config['source_image'] = '/percorso/mypic.jpg';
$config['maintain_ratio'] = TRUE;
$config['width'] = 75;
$config['height'] = 50;
//Carico la libreria con la configurazione
$this->load->library('image_lib', $config);
//Ridimensiono l'immagine /percorso/mypic.jpg
$this->image_lib->resize();
Il listato precedente ridimensiona l'immagine sovrascrivendola. Se si preferisce mantenere l'immagine originale, creando una nuova immagine ridimensionata, è possibile utilizzare il parametro di configurazione new_image:
$config['new_image'] = '/percorso/nuovaimmaginediversa.jpg';

Rotazione

Una rotazione di una immagine può essere eseguita con 5 opzioni diverse:
  • 90 gradi
  • 180 gradi
  • 270 gradi
  • "hor'' (inversione orizzontale)
  • "vrt'' (inversione verticale)
Di seguito un esempio di codice per l'inversione orizzontale dell'immagine:
$config['image_library'] = 'gd2';
$config['source_image'] = '/percorso/mypic.jpg';
$config['rotation_angle'] = 'hor';

//Carico la libreria con la configurazione
$this->load->library('image_lib', $config);
$this->image_lib->rotate();

Cropping

Per ritagliare una immagine si può utilizzare la funzione crop specificando gli assi X e Y lungo i quali eseguire il cropping:
$config['image_library'] = 'gd2';
$config['source_image'] = '/percorso/mypic.jpg';
$config['x_axis'] = '100';
$config['y_axis'] = '60';
//Carico la libreria con la configurazione
$this->load->library('image_lib', $config);
//Eseguo il cropping 
$this->image_lib->crop();

Watermark

L'aggiunta di un watermark (filigrana) può avvenire attraverso due modalità, text (aggiunta di un testo all'immagine) e overlay (aggiunta di una piccola immagine in overlay all'immagine originale). Vediamo un esempio dell'ultimo caso, con una piccola immagine da inserire in basso a destra, con un padding di 5 pixel dai vertici:
$config['image_library'] = 'gd2';
$config['source_image'] = '/percorso/mypic.jpg';
$config['wm_vrt_alignment'] = 'bottom';
$config['wm_hor_alignment'] = 'right';
$config['wm_padding'] = '5';
$config['wm_overlay_path'] = '/percorso/watermark.png';
//Carico la libreria con la configurazione
$this->load->library('image_lib', $config);
//Eseguo l'aggiunta del watermark
$this->image_lib->watermark();

Ora la risposta ad un problema che mi ha fatto sbattere un po' la testa prima di comprenderne la (ovvia) soluzione. Se voglio manipolare due immagini di fila, ma con una configurazione diversa? Notiamo nei listati precedenti come la libreria venga caricata dal metodo load con l'array di configurazione, ma questo deve avvenire solo una volta, dopodiché la libreria è già stata caricata all'interno dell'esecuzione di codeigniter. La risposta è l'utilizzo delle funzioni clear ed initialize, vediamone un esempio concreto:
//Impostazioni cropping
$config['image_library'] = 'gd2';
$config['source_image'] = '/percorso/mypic.jpg';
$config['x_axis'] = '100';
$config['y_axis'] = '60';
//Carico la libreria con la configurazione
$this->load->library('image_lib', $config);
//Eseguo il cropping
$this->image_lib->crop();

//Cancello le impostazioni della libreria
$this->image_lib->clear();
//Impostazioni per rotazione orizzontale
$config['image_library'] = 'gd2';
$config['source_image'] = '/percorso/mypic.jpg';
$config['rotation_angle'] = 'hor';

//Carico la libreria con la configurazione
$this->image_lib->initialize($config);
//Eseguo la rotazione
$this->image_lib->rotate();

giovedì 28 novembre 2013

API RESTful con Codeigniter usando codeigniter-restserver


Nel post precedente ho mostrato come creare un semplice sistema API con il solo metodo GET. Ma se volessimo un server API che risponda secondo lo standard RESTful, dovremmo gestire anche i metodi POST, PUT e DELETE.
In particolare, lo standard consiglia di utilizzare:
  • GET per richieste di lettura di una risorsa
  • POST per richieste di creazione di una risorsa
  • PUT per richieste di modi ca di una risorsa
  • DELETE per richieste di eliminazione di una risorsa 
 Per fare questo velocemente e possibile appoggiarsi ad una libreria di terze parti, codeigniter-restserver.

Installazione

Il primo passo è ovviamente scaricare il pacchetto dalla pagina github della libreria. Il pacchetto includerebbe anche CodeIgniter, ma è molto probabile che si voglia integrare restserver in un progetto codeigniter gi à esistente. In questo caso è su fficiente copiare i files
application/libraries/Format.php
application/libraries/REST_Controller.php
application/config/rest.php
nella propria directory application, e ricordarsi di caricare automaticamente la classe REST_Controller come libreria nel fi le di con gurazione
application/config/autoload.php
Per personalizzare le opzioni di restserver, basta modi care l'apposito fi le precedentemente copiato:
application/config/rest.php

Funzionamento di base

Per il buon funzionamento del sistema è necessario creare controller che estendono la classe base REST_Controller. La libreria elabora le richieste sulla base del metodo HTTP utilizzato e della risorsa (controller), eseguendo la funzione corrispondente all'insieme dei due elementi, sempre seguendo la logica CodeIgniter. Per spiegarmi meglio, ipotizziamo di avere il seguente controller:
class News extends REST_Controller
{
    public function index_get()
    {
        // Lettura delle news
    }

    public function index_post()
    {
        // Crea una news
    }
 
 public function index_put()
    {
        // Modifica una news
    }
 public function index_delete()
    {
        // Elimina una news
    }
}
Una richiesta del tipo
GET http://www.example.com/news
comporterà l'esecuzione della funzione index_get, index perché l'url è senza una funzione specificata (news è direttamente il controller) e get perché il metodo HTTP utilizzato è, appunto, GET.

L'accesso ai parametri è garantito dalle funzioni get, post e put.
$this->get('id'); //mappatura di $this->input->get()
$this->post('id'); //mappatura di $this->input->post() 
$this->put('id'); 
Per i parametri del metodo DELETE, poiché lo standard non li prevede, è sufficiente gestirli direttamente dalla funzione richiamata dal controllore:
public function index_delete($id)
    {
        $this->response(array(
            'returned from delete:' => $id,
        ));         
    }

E' possibile inviare in output una struttura dati con la funzione response, gestendo anche la risposta HTTP direttamente (opzionale). In questo modo la libreria si preoccuperà di formattare la risposta a seconda dello standard impostato nella configurazione (io consiglio JSON). Inoltre, gestendo le risposte HTTP, è possibile utilizzare codici appropriati come il 201 per HTTP 201 Created e 404 per HTTP 404 Not Found (in quest'ultimo caso il primo parametro sarà una risorsa vuota, come ad esempio un array senza elementi).
public function index_post()
{
    // ...crea una news

    $this->response($news, 201); // Manda la risposta HTTP 201
}
Queste sono i tips principali per lo sviluppo di un sistema API con codeigniter-restserver. Non ho parlato per motivi di tempo delle altre caratteristiche della libreria, quali la gestione di API Keys, la gestione dell'autenticazione ecc. per le quali rimando direttamente al sito ufficiale.

mercoledì 27 novembre 2013

Un semplice sistema API GET CodeIgniter con risposta JSON

In questo post volevo descrivere una implementazione relativa ad un sistema API che usa esclusivamente il metodo HTTP GET, sempre in ottica di progetti web strutturati con una netta separazione tra vista (lato client) e controllo (lato server).
Il mio framework php preferito (CodeIgniter) gestisce in modo nativo le richieste con metodo HTTP GET, quindi creare un semplice sistema di API a sola lettura è molto semplice. Ipotizziamo di creare una sottocartella chiamata api nella cartella controller, e di posizionarvi dentro i vari controller che rispecchieranno le risorse delle API.

application
   |- controllers
      |- api
         |- news.php

A questo punto sappiamo che CodeIgniter gestirà che richieste del tipo
http://www.example.com/api/news/getAll
http://www.example.com/api/news/getSingle/12
richiedendo l'esecuzione del controller news.php che compare nell'albero di esempio, con i metodi getAll senza parametri e getSingle con un parametro GET valorizzato a "12".
Vediamo quindi il codice del controller:
class News extends CI_Controller {

 public function getAll()
 {
  $query = $this->db->get('news');
  $elenco_news = array();
  foreach ($query->result() as $row)
  {
       $news = new stdClass();
       $news->id = $row->id;
       $news->titolo = $row->titolo;
       $news->contenuto = $row->contenuto;
       array_push($elenco_news, $news);
  }
  echo json_encode($elenco_news);
 }
 
 public function getSingle(id)
 {
  $this->db->from('news')->where('id',$id);
  $query = $this->db->get();
  $row = $query->row(); 
  $news = new stdClass();
  $news->id = $row->id;
  $news->titolo = $row->titolo;
  $news->contenuto = $row->contenuto;
  echo json_encode($news);
 }

}
Sarà sufficiente quindi creare un controller per ogni tipo di risorsa (ad esempio news, eventi, banner) ed i relativi metodi, ricordandosi di strutturare le risposte in formato JSON come da esempio.

martedì 19 novembre 2013

Chiamate AJAX cross domain JQuery ad API JSON

Ultimamente i progetti web-based sono strutturati tutti in modo simile, ossia con un backend API e un frontend che interroga le API, solitamente in ajax.
In particolare i miei progetti sono caratterizzati da PHP + CodeIgniter lato API (con risposte JSON), e jQuery lato frontend.
Il jQuery si comporta magnificamente con le chiamate Ajax, ma qualche giorno fa mi è capitato il caso di interrogare le API da un dominio diverso da quello del server dove risiedono. Il problema è relativo al fatto che jQuery non permette chiamate ajax cross-domain con tipologia JSON oppure testo normale, come restrizione di sicurezza.
Leggendo la documentazione, viene specificato che le chiamate cross-domain sono possibili solo per la tipologia di scambio dati JSONP.
Ma che diavolo è JSONP? Il fantomatico JSON with Padding è un formato di interscambio dati basato su due semplici punti:
- una funzione di callback
- come parametro della precedente, il JSON che intendiamo trasmettere.
Ad esempio, questo è JSONP
funzionecallback({"status":"ok"})
Mentre il rispettivo JSON sarebbe
{"status":"ok"}
La funzione di callback lato client si può specificare mediante un apposito comando di configurazione di $.ajax oppure lasciare che sia jQuery a decidere il nome della callback ed a inviarlo come parametro GET (chiamato appunto, callback) alle API.
Vediamo quindi nel dettaglio come gestire le nozioni precedentemente apprese. Lato API, vediamo un semplice esempio in cui vogliamo come output un oggetto di prova contenente id e descrizione:
$obj = new stdClass();
$obj->id = "56321564";
$obj->descrizione = "Prova di descrizione";

if ($_GET['callback']!='') {
    echo $_GET['callback'].'('.json_encode($obj).')';
} 
else {
    echo json_encode($obj);
}
In questo modo siamo in grado di capire in maniera molto semplice (senza header http) in che formato mostrare il risultato: se esiste un parametro GET chiamato callback, lo script deve utilizzare il formato JSONP, altrimenti il JSON normale.
Ed ora la parte frontend, in jQuery:
var apiUrl = "http://www.example.com/api/example.php";
$( document ).ready(function() {
    $.ajax({
        type: "GET",
        url: apiUrl,
        dataType: "jsonp" ,
        crossDomain: true,
    }).done(function( json_response ) {
        console.log(JSON.stringify(json_response));
    }).fail(function(jqXHR, textStatus) {
        $('#result').html( "Request failed: " + textStatus + " " + jqXHR.status );
    });

});
La quale produrrà il risultato voluto in console:
{"id":"56321564", "descrizione": "Prova di descrizione"}
Importanti sono l'opzione dataType nella chiamata Ajax impostata su jsonp e crossDomain impostato su true.

domenica 4 agosto 2013

Come far parlare il Raspberry Pi tramite php


Qualche tempo fa ho cominciato a divertirmi con il mio Raspberry Pi. Una delle prime cose che ho voluto fare è stata quella di far parlare il raspPi attraverso il sintetizzatore vocale. In che modo? Con una pagina php richiamata dall'utente.
Per realizzare il tutto, basta installare un webserver (lighttpd nel mio caso) con interprete php5 e il sintetizzatore vocale (espeak), configurando i diritti della www-root:

sudo apt-get install lighttpd
sudo apt-get install php5-common php5-cgi php5
sudo lighty-enable-mod fastcgi-php
sudo service lighttpd force-reload
sudo chown www-data:www-data /var/www
sudo chmod 775 /var/www
sudo apt-get install espeak
Facciamo una prova, poi eseguiamo visudo per dare i diritti di esecuzione all'utente www-data attraverso visudo
espeak -vit "Prova di testing"
sudo visudo
Lo so che è un incredibile errore di sicurezza, ma tanto il mio RaspberryPi sta solo in casa e quindi per facilità ho abilitato l'utente a poter eseguire con sudo e senza password qualsiasi comando. Aggiungiamo quindi la seguente riga nel visudo
www-data ALL=(ALL) NOPASSWD: ALL
Creiamo una pagina php sotto la cartella /var/www con il seguente contenuto:
<?php 
echo exec(" sudo /usr/bin/espeak -vit \"Questo messaggio viene riprodotto ogni volta che si visita la pagina da un browser\"", $out, $out2);
?>
Questo ovviamente apre uno scenario fantastico relativo alla domotica :-)

sabato 3 agosto 2013

C# - programma per l'update automatico degli eseguibili

Ho creato qualche tempo fa un piccolo e semplice programma in C# che si occupa di fare da "loader" per le applicazioni. Ad esempio ipotizziamo di avere una applicazione HelloWorld; il loader (un altro eseguibile) si comporterà come segue:
  • appena viene eseguito, controlla sul server (tramite un percorso di rete windows) se la versione dell'applicazione HelloWorld presente in locale sia meno recente di quella sul server. Se così è, scarica la versione più recente dal percorso (è possibile specificare dalla configurazione se aggiornare una intera cartella o solo l'eseguibile).
  • una volta finito il primo punto, esegue l'applicazione HelloWorld che si è copiato in locale.
Tutto il comportamento è racchiuso dentro un BackgroundWorker (un semplice oggetto per gestire un thread in C#). Vediamo nel dettaglio il comportamento:
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            try
            {
                FileInfo fi1 = 
                         new FileInfo(Properties.Settings.Default.eseguibileRemoto);
                FileInfo fi2 = 
                         new FileInfo(Properties.Settings.Default.eseguibileLocale);
                //Se la directory locale non esiste, la creo
                if (!(Directory.Exists(Properties.Settings.Default.cartellaLocale)))
                {
                    Directory.CreateDirectory(Properties.Settings.Default.cartellaLocale);
                }
                //Controllo che il timestamp di modifica del file eseguibile remoto sia
                //più recente di quello locale
                if (fi1.LastWriteTime.Ticks > fi2.LastWriteTime.Ticks)
                {
                    if (Properties.Settings.Default.copiaTutto)
                    {
                        //Devo copiare tutto il contenuto della directory in locale
                        foreach (string fileTrovato in Directory.GetFiles(Properties.Settings.Default.cartellaRemota))
                        {
                            FileInfo FTEMP = new FileInfo(fileTrovato);
                            //Copio il file remoto in locale
                            File.Copy(fileTrovato, Properties.Settings.Default.cartellaLocale + FTEMP.Name, true);
                        }
                    }
                    else
                    {
                        //Procedura per la copia solo di alcuni files (ad esempio, eseguibili Visual Fox)
                        foreach (string nomeFile in Properties.Settings.Default.copiaSoloQuestiFiles)
                        {
                            FileInfo FTEMP = new FileInfo(nomeFile);
                            File.Copy(Properties.Settings.Default.cartellaRemota + nomeFile, Properties.Settings.Default.cartellaLocale + nomeFile, true);
                        }
                    }

                }
   
            }
            catch (Exception ex) { }
        }
Appena terminato il lavoro (RunWorkerCompleted), l'applicazione verrà eseguita e il loader verrà terminato:

        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            //Al termine della copia, mi preparo ad eseguire il programma
            ProcessStartInfo p = new ProcessStartInfo();
            p.FileName = Properties.Settings.Default.eseguibileLocale;
            p.Arguments = Properties.Settings.Default.parametri;
            //Se è impostato "eseguiDa" (ad esempio per JT) eseguo il programma dal percorso impostato
            if (Properties.Settings.Default.eseguiDa.Length > 0) p.WorkingDirectory = Properties.Settings.Default.eseguiDa;
            //Altrimenti uso la cartella locale
            else p.WorkingDirectory = Properties.Settings.Default.cartellaLocale;
            try
            {
                //Eseguo il programma
                Process.Start(p);
            }
            catch (Exception exep)
            {
                MessageBox.Show("Impossibile avviare il programma richiesto\r\n" + exep.Message);
            }
            Application.Exit();
        }
Le impostazioni possibili nella configurazione del loader sono le seguenti:


Il codice sorgente può essere liberamente scaricabile da Github (qui il link del progetto sul mio sito personale)

sabato 27 luglio 2013

Android: backup e restore di un database sqlite

Per l'applicazione Mie Ricette mi sono trovato a risolvere un problema: dare la possibilità all'utente di eseguire un backup del database delle ricette.
Il database usato nello sviluppo Android è Sqlite, quindi è essenzialmente un file che può essere copiato in una posizione "sicura" come la scheda SD, o comunque un percorso accessibile collegando il telefono al computer.
Nello script quindi sono presenti due funzioni, backupDatabase e restoreDatabase. Il primo l'ho trovato in qualche blog (perdonatemi, non mi ricordo quale). Entrambi utilizzano i FileChannel, ma mentre il cuore del funzionamento del primo si ha nella funzione nativa FileChannel.transferFrom, nel secondo specularmente si ha in FileChannel.transferTo.

package net.stefanobianchini.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
import net.stefanobianchini.ricette.R;

import android.app.Activity;
import android.content.res.Resources;
import android.os.Environment;
import android.util.Log;
import android.widget.Toast;

public class backupdb {

 public static void backupDatabase(String dbPath, String nomeFileBackup,
   Activity act, Resources res) {

  try {
    File currentDB = new File(dbPath);// path del db su telefono
    File backupDB = new File(sd, nomeFileBackup);// file di destinazione
    @SuppressWarnings("resource")
    FileChannel src = new FileInputStream(currentDB)
       .getChannel();// apriamo un filechannel sul db e sul
           // file di destinazione
    @SuppressWarnings("resource")
    FileChannel dst = new FileOutputStream(backupDB)
       .getChannel();
    dst.transferFrom(src, 0, src.size());// trasferiamo il contenuto
    src.close();
     dst.close();
     Toast.makeText(
       act.getBaseContext(),

         res.getString(R.string.msg_db_location) + "\n " +
         backupDB.getAbsolutePath(),
       Toast.LENGTH_LONG).show();

  } catch (IOException e) {
   Toast.makeText(act.getBaseContext(), e.toString(),
     Toast.LENGTH_LONG).show();
  }
 }

 @SuppressWarnings("resource")
 private static void copyFile(File src, File dst) throws IOException {
  FileChannel inChannel = new FileInputStream(src).getChannel();
  FileChannel outChannel = new FileOutputStream(dst).getChannel();
  try {
   inChannel.transferTo(0, inChannel.size(), outChannel);
  } finally {
   if (inChannel != null)
    inChannel.close();
   if (outChannel != null)
    outChannel.close();
  }
 }

 public static void restoreDatabase(String dbPath, String percorsoFileBackup,
   Activity act, Resources res) {

  try {
   File currentDB = new File(dbPath);// path del db su telefono
   File backupDB = new File(percorsoFileBackup);// file di backup sorgente

   copyFile(backupDB, currentDB);

   Toast.makeText(
     act.getBaseContext(),
     String.format(res.getString(R.string.restore_done),
       backupDB.toString()), Toast.LENGTH_LONG).show();

  } catch (IOException e) {
   Toast.makeText(act.getBaseContext(), e.toString(),
     Toast.LENGTH_LONG).show();
  }
 }

}
Ora siamo pronti per eseguire il backup. Da notare che prima di eseguire il backup viene chiuso per sicurezza il db mediante il SQLiteOpenHelper (nel mio caso chiamato db_help);
//Backup del DB sqlite
db_help.close();
backupdb.backupDatabase(db_help.getReadableDatabase().getPath(), "backup_mie_ricette.db", HomeActivity.this, res);