Nella seconda parte della serie “Java ed il protocollo HTTP” abbiamo imparato come scaricare un file da un server HTTP remoto leggendo un flusso sequenziale di dati; in questa terza parte sfrutteremo il capo “Range” dell’header HTTP per scaricare il file remoto dividendolo in più segmenti che saranno scaricati in modo parallelo. La figura seguente può aiutare a capire il procedimento che, normalmente, è definito multi-threading download:

E questo è il risultato finale che otterremo:

SimpleMultithreadDownloader in esecuzione (Fai click per vedere l’immagine a dimensione reale)

Ok, ora che abbiamo un idea di massima di cosa vogliamo ottenere cerchiamo di dare un occhiata a come è organizzato il progetto; i sorgenti ed i file di progetto per l’IDE NetBeans sono disponibili sotto licenza GPL sezione “Riferimenti”.

Struttura

Il progetto chiamato (con scarsissima fantasia) SimpleMultithreadDownloader è costituito da 7 classi:

• Main: crea semplicemente una nuova istanza della finestra principale dell’applicazione dopo aver impostato il Look&Feel dell’applicazione in base a quello predefinito dell’ambiente di esecuzione.
• MainFrame: estende la classe JFrame per implementare la finestra principale dell’applicazione.
• TranferProgressPanel: estende la classe JPanel per implementare un pannello informativo sullo stato del trasferimento. E’ impiegato per monitorare lo stato sia lo stato globale del download e sia per quello di ciascun segmento.
• AddDownloadDialog: estende la classe JDialog ed implementa una semplice finestra per l’inserimento e la validazione del URL del file remoto e del percorso del file di destinazione.
• Utils: Definisce alcuni indici e rende disponibili alcune funzioni utili alle altre classi.
• MainTranferThread: Implementa il thread principale che si occupa di inizializzare i segmenti, avviare e monitorare il download riassemblare i segmenti scaricati in un unico file sul percorso di destinazione al termine del trasferimento.
• SegmentTranferThread: singolo thread che si occupa del download di un segmento.

Le classi sono in relazione fra loro secondo lo schema UML seguente (solo Class Diagram):

Fai click sulla miniatura per vedere l’immagine a dimensione reale

Funzionamento

Come visto dalla struttura il progetto è composto essenzialmente di alcune classi che costituiscono la GUI dell’applicazione, mentre le classi che materialmente eseguono il trasferimento sono MainTranferThread e SegmentTranferThread. Volutamente tralascerò di illustrare le operazioni compiute dalle classi che costituiscono l’interfaccia, piuttosto comprensibili a chi abbia un minimo di esperienza con Swing (grazie anche al codice dettagliatamente commentato ed alla documentazione dell’API generata con Javadoc) per concentrarmi sulle classi che eseguono il download multi-thread.

Una volta che l’utente ha inserito l’indirizzo URL del file da scaricare ed il percorso di destinazione (notare che se gli appunti contengono un indirizzo URL valido il percorso sorgente e destinazione saranno generati automaticamente a partire da tale indirizzo) la finestra principale si occupa di creare una nuova istanza della classe MainTranferThread e la inizializza con i gli indirizzi di sorgente e destinazione inseriti. Il metodo init(String sourceURL, String destinationPath), fornito dalla classe MainTranferThread, si occupa di leggere le informazioni relative al file roto ed a calcolare il numero e la dimensione di segmenti da utilizzare per il download. La dimensione minima di un segmento è fissata a 100KB ed il numero massimo di segmenti utilizzabili è 10:

// Tenta di stabilire una connessione con l'URL sorgente per leggere
// le informazioni relative al file da scaricare.
URLConnection connection = new URL(sourceURL).openConnection();

// Legge e morizza la dimensione totale del file da scaricare...
this.downloadSize = connection.getContentLength();
// ..ed il suo MIME-Type
this.contentType = connection.getContentType();

// Inizia il ciclo per il calcolo del numero di segmenti e la loro dimensione. Il ciclo
// parte da un numero di segmenti pari ad uno solamente ed aggiunge un segmento ogni
// 100 KB di dati da trasferire fino ad arrivare ad un massimo di 10 segmenti.
for (segmentsCount = 1; segmentsCount < = 10; segmentsCount++) {
// Calcola la dimensione media di un segmento
segmentsAvgSize = downloadSize / segmentsCount;

// Se la dimensione media degli "segmentsCount" segmenti è inferirore o uguale
// a 100 KB...
if (segmentsAvgSize <= 102400) {
// ... il numero di segmenti calcolati è sufficiente per eseguire il download ed
// il ciclo può terminare
break;
}
// ..altrimenti aggiunge un ulteriore segmento (se il numero di segmenti è ancora inferirore a 10)
}

Dato che il calcolo della dimensione media di un segmento restituisce un numero intero è possibile che la dimensione dell’ultimo segmento non corrisponda a quella media e quindi deve essere ricalcolata:

// Ricalcola la dimensione dell'ultimo segmento in quanto la dimensione media non
// considera i numeri decimali, quindi fermo restando la dimensione media del segmento
// e' necessario ricalcolare la dimensione dell'ultimo in modo che sia:
//
// dimensione ultimo segmento = dimensione totale - somma della dimensione di tutti i segmenti tranne l'ultimo
int lastSegmentSize = downloadSize - (segmentsAvgSize * (segmentsCount - 1));

Infine vengono create tante istanze della classe SegmentTranferThread quanti sono i segmenti da utilizzare e ciascuna istanza è inizializzata, oltre che con i percorsi di sorgente e destinazione, anche con l’offset del primo byte del segmento all’interno del file originale e con la dimensione del segmento stesso:

// Offset iniziale del primo segmento
int segmentOffset = 0;

// Inizializza l'array dei segmenti di trasferinto al numero di segmenti calcolato.
segmentsThreads = new SegmentTranferThread[segmentsCount];

// Inizia il ciclo di inizializzazione dei singoli segmenti.
for (int segmentIndex = 0; segmentIndex < segmentsCount; segmentIndex++) {
// Crea il nuovo segmento
segmentsThreads[segmentIndex] = new SegmentTranferThread();

boolean result;

// Inizializza il segmento con l'RUL sorgente, il path di destinazione l'offset del primo byte da leggere
// . Controlla se il segmento è l'ultimo, in questo caso passa
// al metodo init la lunghezza dell'ultimo segmento anzichè quella media.
if (segmentIndex == (segmentsCount - 1)) {
result = segmentsThreads[segmentIndex].init(sourceURL, destinationPath, segmentOffset, lastSegmentSize);
} else {
result = segmentsThreads[segmentIndex].init(sourceURL, destinationPath, segmentOffset, segmentsAvgSize);
}

// Controlla se il segmento è stato inizializzato correttamente...
if (result == false) {
// se si è verificato un errore imposta lo stato del trasferimento ad "Errore" e termina
// l'inizializzazione restituendo false.
tranferStatus = Utils.STATUS_ERROR;
return false;
}

// Sposta l'offset del segmento successivo dolo l'ultimo byte
// che deve essere letto dal segmento attuale.
segmentOffset += segmentsAvgSize;
}

Quando un segmento viene inizializzato tramite l’invocazione del metodo init(String sourceURL, String destinationPath, int segmentOffset, int segmentsSize) della classe SegmentTranferThread, viene creato un nuovo file tporaneo per la morizzazione dei dati scaricati dal segmento e tale file è marchiato per essere rimosso automaticamente al termine dell’esecuzione dell’applicazione:

// Crea un file tporaneo con il nome basato sul nome del file da prelevare ed estensione .part
// Il file sarà creato nella cartella tporanea di sista (in linux: /tmp)
File tpFile = File.createTpFile(new File(destinationPath).getName(), ".part");

// Imposta il file tporaneo perchè sia cancellato automaticamente alla chiusura dell'applicazione
tpFile.deleteOnExit();

Tutti i files tporanei generati dai segmenti saranno utilizzati al termine del trasferimento per generare il fie di destinazione.
Se l’inizializzazione va a buon fine l’utente può iniziare il trasferimento. Alla pressione del bottone di avvio del trasferimento sulla toolbar viene eseguito il thread principale che regola il download. L’esecuzione del thread implica l’invocazione del metodo run() della classe MainTranferThread il quale per prima cosa avvia a sua volta l’esecuzione dei threads precedentente inizializzati per il download dei segmenti:

// Avvia tutti i threads dei segmenti di trasferimento.
for (int segmentIndex = 0; segmentIndex < segmentsCount; segmentIndex++) {
segmentsThreads[segmentIndex].start();
}

Fatto ciò, dopo aver inizializzato alcuni contatori utili, inizia il ciclo di monitoraggio del trasferimento; durante tale ciclo il thread principale controlla lo stato di tutti i trasferimenti dei segmenti per rilevare eventuali errori, inoltre calcola il totale dei dati trasferiti. Se viene rilevato un errore in anche solo uno dei segmenti il trasferimento si interrompe. Il ciclo di controllo termina correttamente solamente quando tutti i segmenti sono stati scaricati senza errori:

// Azera il contatore del totale dei bytes scaricati per poi poterlo ricalcolare in base ai
// bytes trasferiti dai segmenti.
bytesDownloaded = 0;

// Imposta il flag di controllo dello stato dei segmenti.
// la variabile allSegmentFinished assumerà il valore "true" sono quando il trasferimento
// di tutti i segmenti sarà completo
boolean allSegmentFinished = false;

// Impsta lo stato del download come "Traferimento"
tranferStatus = Utils.STATUS_RUNNING;

// Controlla ciclicamente lo stato del trasferimento di tutti i segmenti
// fino a quando non sono stati completati tutti o fino al verificarsi
// di un errore.
while (allSegmentFinished == false) {
// Imposta il flag di completamento a "true" per consentire il termine del ciclo
// in caso il trasferimento di tutti i segmenti sia terminato.
allSegmentFinished = true;

// Variabile ausiliaria utilizzata per il calcolo della dimensione totale dei dati
// scaricati.
int segmentsBytesDownloaded = 0;

// Inizia il controllo di ciascun segmento
for (int segmentIndex = 0; segmentIndex < segmentsCount; segmentIndex++) {
// Se si è verificato un errore durante il download del segmento...
if (segmentsThreads[segmentIndex].getTranferStatus() == Utils.STATUS_ERROR) {
// ...imposta lo stato generale ad "Errore" e termina il controllo.
tranferStatus = Utils.STATUS_ERROR;
return;
}

// Aggiunge al contatore ausiliario dei bytes scaricati il totale dei bytes trasferiti
// dal segmento in esame.
segmentsBytesDownloaded += segmentsThreads[segmentIndex].getBytesDownloaded();

// Aggiorna il flag di completamento tramite moperazione logica AND,
// controllando se il segmento in esame è termnato
allSegmentFinished = allSegmentFinished && (segmentsThreads[segmentIndex].getTranferStatus() == Utils.STATUS_COMPLETED);
}

// Aggiorna il totale dei bytes scaricati.
bytesDownloaded = segmentsBytesDownloaded;
}

Se il trasferimento di tutti i segmenti è stato completato senza errori il thread principale si occupa di ricostruire il file di destinazione a partire dai files temporanei creati da ciascun segmento:

// Se il trasferimento dei singoli segmenti è terminato correttamente si procede con la ricostruzione
// del file di destinazione a partire dai singoli segmenti. Lo stato del trasferimento è posto a
// "Ricostruzione"
tranferStatus = Utils.STATUS_REBUILD;

// Utiliziamo la variabile che morizza la dimensione totale dei dati scaricati per monitorare
// lo stato di avanzamento della ricostruzione.
bytesDownloaded = 0;

try {
// Crea una istanza di un oggetto RandomAccessFile per poter scrivere sul file relativo al percorso di destinazione.
RandomAccessFile destinationWriter = new RandomAccessFile(destinationPath, "rw");

// Inizia il ciclo di lettura dei segmenti
for (int segmentIndex = 0; segmentIndex < segmentsCount; segmentIndex++) {
// Crea una istanza di RandomAccessFile per la lettura del file tporaneo contenente i dati trasferiti
// dal segmento in esame.
RandomAccessFile segmentFileReader = new RandomAccessFile(segmentsThreads[segmentIndex].getDestinationTpPath(), "r");

// Legge il primo byte dal file tporaneo del segmento.
int byteReaded = segmentFileReader.read();

while (byteReaded != -1) {
// scrive l'ultimo byte letto nel file di destinazione...
destinationWriter.write(byteReaded);
bytesDownloaded++;

// ...quindi legge il byte successivo.
byteReaded = segmentFileReader.read();
}

// Terminata la lettura di tutti i dati del segmento attuale chiude il file
// tporaneo in lettura
segmentFileReader.close();
}

// Terminata la ricotruzione senza errori chiude il file di destinazione.
destinationWriter.close();
} catch (IOException ex) {
// Se si verifica un errore durante la ricostruzione del file di destinazione avvisa l'utente,
// imposta lo statto di errore prima di terminare.
JOptionPane.showMessageDialog(null, "Si è verificato un errore durante la connessione ricostruzione del file di destinazione.\nIl download non potrà essere eseguito.\n\nDettagli: " + ex.getLocalizedMessage(), "Errore di ricostruzione della destinazione", JOptionPane.ERROR_MESSAGE);
tranferStatus = Utils.STATUS_ERROR;
return;
}

// Se il trasferimento e la ricostruzione sono andati entrambi a buon fine imposta lo stato del
// trasferimento a "Completato"
tranferStatus = Utils.STATUS_COMPLETED;

Il campo “Range”

Ok, fino a qui è tutto abbastanza semplice, no? Però la cosa interessante è: come facciamo a “dire” al server HTTP che vogliamo scaricare un segmento di un file che vada dal byte N al byte N+K? Semplice, utilizziamo il campo Range dell’header HTTP che ci consente di specificare l’intervallo (range, per l’appunto) dei dati che vogliamo scaricare all’interno del file richiesto. La sintassi da utilizzare ‘ la seguente:
…
Range=byte iniziale-byte finale
…

Nel nostro caso ciascun segmento, all’avvio del thread e quindi all’invocazione del metodo run(), stabilisce una connessione con il server all’URL remoto e, prima di aprire uno stream di input per la lettura, aggiunge alla richiesta il campo Range correttamente inizializzato con la posizione del primo byte del segmento e quella dell’ultimo calcolata come posizione del primo byte + lunghezza del segmento:

// Tenta di creare un nuovo oggetto URL dalla stringa passata come indirizzo durante
// l'inizializzazione. Se la creazione va a buon fine apre una connessione con l'indirizzo
URLConnection connection = new URL(sourceURL).openConnection();

// Crea una nuova stringa da passare all'header di richiesta HTTP che sarà inoltrato al server
// prima di richiedere lo stream per il trasferimento.
// La proprietà di richiesta nell'header deve avere la forma:
//
// Range: primo byte da leggere-ultimo byte da leggere
//
// che in questo caso sarà:
//
// Range: segmentOffset-(segmentOffset + segmentsSize)
String bytesRange = "bytes=" + Integer.toString(segmentOffset) + "-" + Integer.toString(segmentOffset + segmentsSize);

// Aggiunge la stringa contente la richiesta del Range da leggere dal file di origine
// all'header HTTP.
connection.addRequestProperty("Range", bytesRange);

// Richiede uno stream di lettura per l'intervallo specificato tramite la connessione stabilita
// in precedenza
InputStream connectionInputStream = connection.getInputStream();

Il “trucco” è tutto quì! Infatti una volta aperto lo stream che legga il giusto intervallo si procede come già visto nel secondo articolo della serie “Java ed il protocollo HTTP”, l’unica differenza è che in questo caso utilizzero un file ad accesso casuale anzichè un FileWriter:

// Azzera il contatatori utilizzati durante il trasferimento.
int byteReaded = 0;
bytesDownloaded = 0;

// Imposta lo stato a "Trasferimento"
tranferStatus = Utils.STATUS_RUNNING;

// Legge il primo bayte del segmento corrispondente al byte "segmentOffset" nel file sorgente
byteReaded = connectionInputStream.read();

// Continua a leggere un byte per volta fino a quando non è stata raggiunta la lunghezza del segmento
// o non c'è più niente da leggere (in realtà non sarebbe necessario, ma evita sovrapposizioni di bytes)
while ((bytesDownloaded < segmentsSize) && (byteReaded != -1)) {
// Scrive l'ultimo byte letto nel file tporaneo di destinazione...
writer.write(byteReaded);
bytesDownloaded++;

// ...e legge il byte successivo.
byteReaded = connectionInputStream.read();
}

// Se il trasferimento va a buon fine chiude il file tporaneo.
writer.close();
// Chiude lo stream di input.
connectionInputStream.close();
// Imposta lo stato di trasferimento del segmento a "Completato"
tranferStatus = Utils.STATUS_COMPLETED;

Conclusioni

L’esempio proposto, proprio in quanto inteso come esempio didattico, di certo non offre ne le prestazioni ottimali possibili e ne le funzionalità solite dei programmi che eseguono download multi-threads. Alcune delle possibilità di ottimizzazione ed implementazione di funzionalità aggiuntive sono, ad esempio:

• Solitamente i software di download multi-thread cercano di sfruttare diversi mirrors per il download dei segmenti in modo da distribuire il carico su più servers.
• Ogni segmento potrebbe scaricare più di un byte per volta in modo da sfruttare la maggior quantità possibile di banda.
• Il file finale, anziché essere ricostruito da thread principale di download, potrebbe essere ricostruito dai vari segmenti in modo parallelo.
• Nonostante sia definito uno stato di “Pausa” questo non è implementato. Lascio a chi interessato l’implementazione (per altro estremamente semplice) della funzionalità.
• Sarebbe opportuno poter salvare lo stato di un download per poterlo sospendere e riprendere in un secondo momento.

La lista potrebbe essere ancora lunga. Chiunque volesse provare ad implementare unove funzionalità più farlo tranquillamente partendo dal codice sorgente dell’esempio che si può trovare nella sezione seguente.

Riferimenti

Per una migliore comprensione il codice è ampiamente commentat, inoltre all’interno della cartella “dist/javadoc” è possibile trovatre la documentazione delle API rese disponibili dalle classi del progetto.

Come per i precedenti articoli, anche in questo caso il codice sorgente ed i files di progetto per l’IDE NetBeans 6.0 sono disponibili per il download coperti da licenza GPL: SimpleMultithreadDownloader (Sorgenti - Files progetto NetBeans 6) (0)

Per quanti volessero approfondire l” argomento HTTP è utile consultare questi siti:

Informazioni sull”HTTP in Wikipedia: Pagina su Wikipedia dedicata al protocollo HTTP

RFC 1945: Specifiche della versione 1.0 del protocollo HTTP

RFC 2616: Specifiche della versione 1.1 del protocollo HTTP

Ok, Gimp è un prodotto ottimo, sicuramente adatto anche ad un uso professionale, gratuito, ricco di plug-ins e scripts, e chi più ne ha più ne metta, ma non per questo chiunque si interessi un po di grafica può snobbare completamente il Re, Imperatore, nonché quasi divinità del settore: Photoshop®!
Visto che in ufficio spesso, per forza di cose, mi trovo ad utilizzare Photoshop®, un po di tempo fa abbiamo optato per un acquisto che all’inizio pareva più una follia che qualcosa di utile, ma che si è in realtà rivelato un ottimo acquisto. Sto parlando di una raccolta di tutorials in DVD, completata da un book a colori, intitolata:Photoshop® Top Secret™.

Photoshop® Top Secret™ è costituito da 4 DVD contenenti  dei video tutorials dettagliatissimi e i materiali necessari per seguire i tutorials presentati. Sfortunatamente il commento ai tutorials è in lingua inglese, ma comunque comprensibilissima, specie perchè le operazioni svolte sono chiaramente visibili sugli screencast che costituiscono il cuore di ciascun tutorial.
Gli argomenti trattati variano dalla grafica per il web, al foto ritocco avanzato, all’applicazione di effetti al testo, alla creazione di landscapes surreali, alla colorazione di immagini vettoriali, alla produzione di locandine da film, e moltissimo altro.  Uno dei tutorial più divertenti, ad esempio, penso dia quello che tratta l’uso del filtro “liquidifica”, il cui risultato finale è circa il seguente:

Di seguito riporto una lista degli argomenti trattati da ciascun tutorial:

La raccolta di tutorials è in vendita sul sito ufficiale per la “modica” cifra di 179$ + 35$ per le spese di spedizione ad di fuori degli stati uniti. Mi rendo conto che la cifra non è esattamente bassa, specie per i semplici amatori che non sono intenzionati ad un uso professionale di Photoshop®, però per tutti quelli che desiderano addentrarsi nei meandri del principale strumento di foto ritocco in circolazione, è sicuramente una spesa ben fatta.

In questa seconda parte vedremo un semplice classe che si occupa di scaricare un file da un indirizzo URL remoto in un file su un percorso locale in modo sequenziale.

Il codice è ampiamente commentato, quindi dovrebbe essere di facile comprensione per chi ha già seguito il primo articolo della serie o ha un minimo di dimestichezza con le api di rete Java.

Inizializzazione del download

Innanzitutto vengono letti i primi due parametri passati come argomenti dalla linea di comando passati al costruttore ella classe SimpleHttpDownloader (anche se non è molto elegante). Il primo parametro è l’indirizzo URL del file da scaricare tramite HTTP, il secondo parametro è il percorso locale su cui l’utente desidera sia salvato il file scaricato.

Il costruttore innanzitutto controlla se i parametri passati sono corretti e validi per eseguire il download cioè se l’URL è malformato o meno, se non lo è apre una connessione all’indirizzo specificato e crea un nuovo oggetto di tipoURLConnection:

URLConnection connection = null;
try {

// Crea un oggetto URL dalla stringa passata come primo parametro…
URL sourceURL = new URL(sourceURLString);
// …se l’URL non è malformato apre una connessione
connection = sourceURL.openConnection();

} catch (MalformedURLException ex) {

// …se l’URL è malformato avvisa l’utente ed esce
System.err.println(“L’URL \”" + sourceURLString + “\” specificato è malformato.\nControllare di aver digitato correttamente l’URL del documento da scaricare.”);
System.err.println(“Descrizione dell’errore: ” + ex.getLocalizedMessage());
System.exit(-1);

} catch (IOException ex) {

// …se non è possibile aprire una connessione all’URL, ad esempio perchè è inesistente
// o il server non è disponibile in quel momento avvisa l’utente fornendo anche una
// descrizione dell’errore ed esce.
System.err.println(“Si è verificato un errore durante la connessione al server.”);
System.err.println(“Descrizione dell’errore: ” + ex.getLocalizedMessage());
System.exit(-1);

}

Instaurata la connessione controlla se il file corrispondente al secondo parametro passato è esistente, se non lo è richiede un handle per la scrittura sul file:

// Crea un oggetto corrispondente al file di destinazione al percorso
// indicato come secondo parametro
File destinationFile = new File(destinationPath);

// Controlla se il file esiste già…
if (destinationFile.exists()) {

// …se esite avverte l’utente ed esce.
//
// NOTA: questa è solo una precauzione per evitare di sovrascrivere un eventuale
// file preesistente, ma potrebbe tranquillamente essere omessa ed il file
// eventualmente già presente sarebbe sovrascritto.
System.err.println(“Il file di destinazione \”" + destinationFile + “\” specificato è già esistente.\nE’ necessario che il file di destinazione non esista.”);
System.exit(-1);

}

FileWriter destinationWriter = null;

try {

// Apre un handle per la scrittura sul file di destinazione
destinationWriter = new FileWriter(destinationFile);

} catch (IOException ex) {

// In caso di errore fornisce una breve descrizione all’utente ed esce.
System.err.println(“Si è verificato un errore durante l’inizializzazione del file di destinazione per la scrittura.”);
System.err.println(“Descrizione dell’errore: ” + ex.getLocalizedMessage());
System.exit(-1);

}

I dati sono letti dalla posizione remota attraverso uno stream di input reso disponibile dall’oggetto URLConnection:

InputStream urlInputStream = null;

try {

// Apre uno stream di input per la lettura dei dati dalla connessione
// instaurata precedentemente.
urlInputStream = connection.getInputStream();

} catch (IOException ex) {

// In caso non sia possibile avverte l’utente ed esce.
System.err.println(“Si è verificato un errore durante la creazione dello stream di lettura.”);
System.err.println(“Descrizione dell’errore: ” + ex.getLocalizedMessage());
System.exit(-1);

}

Prima di poter procedere con il trasferimento è necessario inizializzare alcuni contatori che poi saranno usati per mantenere informato l’utente sullo stato del download.
La variabile totalDownloadSize è inizializzata con la dimensione in bytes del file da scaricare ottenuta tramite invocazione del metodo getContentLength() della claseURLConnection.

int totalDownloadSize = connection.getContentLength();

downloadedSize è il contatore dei bytes scaricati durante il ciclo di trasferimento.

int downloadedSize = 0;

La variabile downloadPrecent rappresenta la percentuale di avanzamento dello scaricamento. E’ utilizzata per scremare l’output delle informazioni mostrate per aggiornare l’utente sullo stato dello scaricamento.

int downloadPrecent = 0;

byteReaded contiene l’ultimo byte letto dallo stream di input.

int byteReaded = -1;

Trasferimento

Terminata l’inizializzazione dei contatori si passa al ciclo di trasferimento vero e proprio che inizia con la lettura del primo byte dallo stream di input.

byteReaded = urlInputStream.read();

Il ciclo legge un singolo byte e lo scrive immediatamente sul file di destinazione

// Il ciclo termina quando tutti i bytes sono stati trasferiti.
while (byteReaded != -1) {

// Scrive il byte appena scaricato sul file di destinazione.
destinationWriter.write(byteReaded);
// Incrementa il contatore dei bytes scaricati.
downloadedSize++;

Per mantenere l’utente informato vengono stampate delle informazioni relative alla percentuale di trasferimento completato ed ai bytes scaricati; le informazioni però vengono stampate solo ed esclusivamente quando varia la percentuale di avanzamento perchè se si stampasse una stringa informativa per ogni byte scaricato il ciclo rallenterebbe molto rendendo downloads di pochi byte molto lunghi. se si desidera provare è sufficiente commentare il la stringa di apertura e chiusura del blocco if

// Confronta la percentuale di avanzamento attuale con l’ultima memorizzata.
// Se sono uguali evita di mostrare l’output…
if (((downloadedSize * 100) / totalDownloadSize) != downloadPrecent) {

// …altrimenti memorizza la percentuale attuale…
downloadPrecent = ((downloadedSize * 100) / totalDownloadSize);
// …ed aggiorna l’utente sullo stato del trasferimento.
System.out.println(“[ " + downloadPrecent + "% ] Scaricati ” + downloadedSize + ” bytes di ” + totalDownloadSize);

}

// Legge il byte successivo.
byteReaded = urlInputStream.read();

}

Terminato il trasferimento vengono chiusi stream ed handle al file di destinazione.

// Forza la scrittura di eventuali dati pendenti nel file di destinazione.
destinationWriter.flush();
// Chiude l’handle al file e lo stream di input.
destinationWriter.close();
urlInputStream.close();

Conclusione

Il codice mostra con quanta facilità è possibile scaricare un file dalla rete, ma indubbiamente non è esattamente un esempio come portare le prestazioni all’estremo. Il codice sarebbe più adatto, infatti, se stessimo prelevando dati da un server FTP in quanto è consentita una sola connessione per scaricare un file ed il download deve essere eseguito in modo sequenziale. A contrario il protocollo HTTP è in grado di accettare richieste multiple per il download di un solo file, in cui ogni richiesta specifica nell’header il range di bytes del file che desidera ottenere, ciò consente di avere più flussi di trasferimento contemporaneamente (multi thread download), che sarà l’argomento della terza parte di questa serie di tutorials  .

Riferimenti

Come per la prima parte della serie di tutorials su Java ed HTTP, il codice sorgente ed i files di progetto per l’IDE NetBeans 6.0 sono disponibili per il download coperti da licenza GPL: SimpleHttpDownloader (Sorgenti – Files progetto NetBeans 6) (0)

Per quanti volessero approfondire l” argomento HTTP è utile consultare questi siti:

Informazioni sull”HTTP in Wikipedia: Pagina su Wikipedia dedicata al protocollo HTTP

RFC 1945: Specifiche della versione 1.0 del protocollo HTTP

RFC 2616: Specifiche della versione 1.1 del protocollo HTTP

Essendo me stesso la persona più curiosa che conosco (almeno fin da quando ero piccolo) potevo forse non provarlo? Naturalmente la risposta è NO (anche perché sennò non sarei qui a scrivere); mi sono armato di SDK prelevato dalla pagina del progetto android, ho installato il plugin per Eclipse seguendo le apposite istruzioni, mi sono armato di caffè a volontà ed ho cominciato a fare conoscenza con questo misterioso androide…

Creazione di un progetto Android

Se c’è una cosa per cui i ragazzi di Google sono famosi, si sa, è quella di fare le cose fatte bene. Il rilascio di un plugin (già di buona fattura) per Eclipse in concomitanza al rilascio della prima versione del Software Development Kit, consente di ridurre al minimo il tempo perso nella preparazione dell’ambiente di sviluppo, concentrandosi fin da subito sullo studio del framework e la scrittura di codice. Infatti, dopo aver seguito la guida per l’installazione dell’SDK e del plugin Eclipse, è sufficiente creare un nuovo progetto, nella finestra di selezione della procedura guidata selezionare “Android Project” e compilare il semplice form:

Un progetto Android è diviso sostanzialmente in due parti: i sorgenti (contenuti nella cartella src) che contengono il codice Java dell’applicazione e le risorse (cartella res) che sono, ad esempio: il file xml che descrive il layout dei widget nello schermo, le icone ed immagini utilizzate, ed altro.
Il nuovo progetto per Android contene l’Activity principale che non è altro che un oggetto rappresentante una singola schermata di una applicazione e contenente uno o più View (i controlli o widgets derivano tutti da una classe View) e i files di risorse necessari per una applicazione di base.

Armatura dell’androide: Disegnare il Layout

Come detto in precedenza il layout dello schermo dell’applicazione è descritto da un documento XML contenuto nella cartella “layout” contenuta in “res”. Nel caso della nostra applicazione il file di layout si chiama “main.xml” e contiene il codice seguente:

<?xml version=”1.0″ encoding=”utf-8″?>
<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
android:gravity=”center_horizontal”
>
<TextView id=”@+id/txtHello”
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”"
/>

<AnalogClock
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
/>

<Button id=”@+id/btnHello”
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:text=”Hello me!”
/>

</LinearLayout>

Innanzitutto è creato un oggetto “LinearLayout” che definisce una disposizione lineare in orizzontale o in verticale per i widget contenuti (una sorta di corrispettivo di un JPanel swing a cui è applicato un box Layout con orientazione verticale):

<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”
android:orientation=”vertical”
android:layout_width=”fill_parent”
android:layout_height=”fill_parent”
android:gravity=”center_horizontal”
>

In questo caso è creato un layout orizzontale definito dall’attributo orientation=”vertical”, inoltre si specifica che il layout occuperà l’intero schermo definendo le proprieta della larghezza: layout_width=”fill_parent” ed altezza: layout_height=”fill_parent” perché occupino tutto lo spazio disponibile nel componente che li ospita (in questo caso lo schermo intero). L’ultimo attributo gravity=”center_horizzontal” definisce l’allineamento al centro per i controlli contenuti nel layout.

In seguito alcuni widget sono aggiunti al layout, in particolare:

<TextView id=”@+id/txtHello”
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
android:text=”"
/>

Aggiunge come primo elemento una label di testo larga come tutto il layout che la ospita e con una altezza che si adatta automaticamente al contenuto della label. Inoltre viene inizializzata con un testo vuoto. Il secondo componente è un orologio analogico (so benissimo che in una applicazione “Hello World” solitamente l’orologio non ci andrebbe…però mi piaceva troppo!):

<AnalogClock
android:layout_width=”fill_parent”
android:layout_height=”wrap_content”
/>

anche in questo caso largo come tutto il layout che lo ospita e con una altezza che si adatta automaticamente al contenuto. Infine un bottone che, guarda caso, servirà per visualizzare una stringa di saluto sulla TextView precedentemente aggiunta:

<Button id=”@+id/btnHello”
android:layout_width=”wrap_content”
android:layout_height=”wrap_content”
android:text=”Hello me !”
/>

Entrambe le dimensioni del bottone sono adattate al contenuto, cioè la scritta “Hello Me !” e, per l’attributo gravity definito nel layout, sarà allineato al centro dello schermo.
E’ interessante notare il fatto che sia per TextView che per Button è definito l’attributo id, questo serve per assegnare un nome identificativo al controllo (nel nostro caso la TextView è chiamata txtHello ed il bottone btnHello…fantasioso eh!?); tale attributo sarà utilizzato nel sorgente Java per riconoscere i componenti ed interagirvi.
Terminata la definizione del layout ci possiamo concentrare sulla scrittura del codice.

Intelligenza artificale: Il Codice Sorgente

Il codice sorgente è costituito principalmente da una classe AndroidExperimentActivity che estende una Activity (quindi una singola schermata). Una Activity implementa diversi metodi corrispondenti ad eventi cui è soggetta; fra i più interessanti ci sono sicuramente:

• onCreate: invocato al momento della creazione dell’activity e che viene utilizzato per la sua inizializzazione come vedremo in seguito.
• onPause: è invocato quando l’utente abbandona l’activity senza però uscirne. E’ utile allo scopo di salvare le informazioni si stato dell’activity per garantirne la persistenza.
• onDestroy: è invocato prima della distruzione dell’activity edè utile per la pulizia dei dati e della memoria.

Ci sono moltissimi altri metodi come onStart, onStop, onFreeze, etc…, per la cui spiegazione rimando al referenece di android per le activity.

Nel nostro caso reimplementiamo il metodo onCreate all’interno del quale inizializziamo i componenti. Il codice sorgente è:

package org.brainspace.android;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

public class AndroidExperimentActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
setContentView(R.layout.main);

final TextView txtHello = (TextView) findViewById(R.id.txtHello);
final Button btnHello = (Button) findViewById(R.id.btnHello);

btnHello.setOnClickListener(new Button.OnClickListener() {
public void onClick(View v) {
txtHello.setText(“hello World, I’m Android!”);
}
});

}
}

Innanzitutto, dopo la definizione del package, sono importate le classi che andremo ad usare in seguito, poi, la dichiarazione della classe AndroidExperimentActivity e quindi l’overriding del metodo onCreate. Dopo aver invocato il metodo onCreate della classe genitore siamo passati ad applicare il layout creato precedentemente, tramite l’invocazione del metodo:

setContentView(R.layout.main);

La classe R è creata dal plugin Eclipse per indicizzare il contenuto della cartella delle risorse. Ogni volta che modifichiamo una o più risorse la classe R.java viene aggiornata automaticamente dal plugin Eclipse. Nel nostro caso il contenuto di R.java è:

/* AUTO-GENERATED FILE. DO NOT MODIFY.
*
* This class was automatically generated by the
* aapt tool from the resource data it found. It
* should not be modified by hand.
*/

package org.brainspace.android;

public final class R {
public static final class attr {
}
public static final class drawable {
public static final int icon=0×7f020000;
}
public static final class id {
public static final int btnHello=0×7f050001;
public static final int txtHello=0×7f050000;
}
public static final class layout {
public static final int main=0×7f030000;
}
public static final class string {
public static final int app_name=0×7f040000;
}
}

In questo caso restituisce l’id del layout definito nel file main.xml, layout che viene caricato come contenuto principale dell’activity.
In seguito vengono create due istanze di oggetti TextView e Button ed inizializzate con le informazioni contenute sempre nel file main.xml recuperate grazie all’id che gli abbiamo assegnato:

final TextView txtHello = (TextView) findViewById(R.id.txtHello);
final Button btnHello = (Button) findViewById(R.id.btnHello);

A questo punto è necessario assegnare un click listener al bottone in modo che alla pressione del bottone la label visualizzi il messaggio di saluto. Similmente a swing è necessario creare una istanza di oggetto OnClickListener() che implementi il metodo onClick() facendogli impostrare la proprietà text dell’oggetto txtHello:

btnHello.setOnClickListener(new Button.OnClickListener() {
public void onClick(View v) {
txtHello.setText(“hello World, I’m Android!”);
}
});

Energia: Eseguire il progetto

Ora non ci resta altro da fare se non testare la nostra Utilissima (proprio con la U maiuscola… )applicazione, perciò apriamo la finestra di esecuzione (Esegui->Esegui…) e creiamo una nuova configurazione per Android (Click con il tasto destro su Android Application->Nuovo) e riempiamo i campi come in figura:

Fatto ciò clickiamo su Esegui e godiamoci il nostro fantastico software (se non altro il fatto che ci sia l’orologio non lo rende proprio completamente inutile…no? ).

Riferimenti

• Sono disponibili per il download i [Download not found]

I riferimenti per i materiali necessari per la realizzazione del progetto sono:

• L’SDK, il plugin per Eclipse e tutta al documentazione su Androi sono reperibili nella pagina principale del progetto
• L’ambiente di sviluppo Eclipse è disponibile sul sito del progetto

Eccoci qua: dopo anni di assoluta fedeltà al draghetto Konqui, in preda al più nero sconforto (e probabilmente anche all’alcool…sinceramente nonricordo…che sia un sintomo ;)) mi sono trasformato in un Gnomo (per la precisione uno gnomo 2.20.1) Umano (umano al 7.10).

Vuoi un po’ perchè mi piace tantissimo lo stile “gommoso” ed estremamente pulito di clearlooks unito alle tango icons, vuoi perchè, dopo anni di fedeltà incondizionata ad Arch Linux, quest’ultima ha cominciato a perdere colpi sui miei PC (mi è capitato più di una vota ultimamente di avere un sistema “inusabile” dopo un aggiornamento, oppure altre piccole sciocchezze che “minano” la mia tranquillità quotidiana), molto più probabilmente per ingannare la spasmodica attesa di KDE 4 (anche se devo dire che sono piuttosto deluso da come procede il lavoro “estetico” appunto su KDE 4: è vero che, poi, come sempre uno potrà cambiare: stile, decorazioni delle finestre, colori, icone, etc…, ma è altrettanto vero che nutritivo grandi aspettative per oxigen, sia per lo stile che per le icone, ed entrambi mi stanno deludendo molto).

Sta di fatto che lo scorso lunedì quando, nonostante la mia Arch sapesse benissimo che avevo delle scadenze al lavoro, ha deciso di andare prematuramente in ferie, ho colto l’occasione per portare una ventata di aria nuova nel mio hard disk. Il primo passo è stato famigliarizzare con gli strumenti per amministrare Ubuntu e per personalizzare il dekstop; il secondo cercare i corrispettivi per Gnome delle applicazioni che ero solito usare sotto KDE.

Gestione e personalizzazione

Grazie ad una ampissima raccolta di strumenti grafici, l’amministrazione di Ubuntu risulta estremamente semplice come, del resto, anche la personalizzazione di Gnome. Sono rimasto particolarmente sorpreso da alcune “chicche, come, ad esempio, il fatto di essere stato avvisato che il server grafico era cambiato quando ho installato il pacchetto Xgl (indispensabile per avere compiz funzionante sulla orrenda scheda video che ho a disposizione su questo PC, una Ati Radeon X1650, oppure del rilevamento e dell’installazione degli opportuni codecs video/audio alla prima apertura di Totem.

Una semplice finestrella denominata “Aspetto” la personalizzazione del desktop e l’abilitazione (estremamente semplice ed immediata) di Compiz fusion, il quale trova il suo compagno ideale in Avant Window Navigator (dopo averlo provato ho finalmente capito perché Felipe lo ha definito addirittura “pornografico“).

Applicazioni

La scelta di applicazioni per GNU/Linux, si sa, può diventare un’impresa epica, specie poi utilizzando Ubuntu la quale offre una scelta di pacchetti enorme, perciò mi sono concentrato da subito su nomi noti nel mondo Gnome. Naturalmente, essendo abituato a KDE, no cercato applicazioni che in qualche modo mi ricordassero quelle che sono solito usare con il draghetto; questa ricerca ha volte ho avuto piacevoli sorprese altre delle mezze delusioni. Dopo ore passate a scaricare ed installare un mezzo trilione di pacchetti, nel mio hard disk hanno trovato riparlo questi software.

Strumenti di sviluppo

E’ strano iniziare la panoramica delle applicazioni con cui mi sono trovato subito a mio agio proprio dagli strumenti di sviluppo, però, essendo un programmatore, se dopo l’installazione di una distro non mi concentro immediatamente sugli strumenti di sviluppo rischio grafi manifestazioni psicosomatiche associate ad un senso profondo di depressione. Innanzitutto non potevo non installare l’SDK Java 6 ufficiale di Sun completo di documentazione, installato comodamente con synaptic, subito seguito da Netbeans (anche se di quest’ultimo, anziché installare la versione 5.5 presente nei repo di Ubuntu, ho preferito la versione 6.0 beta 2 direttamente scaricata dal sito) ed Eclipse. Fin qui, però, nulla di nuovo, ora dovevo cercare un sostituto

valido per KDevelop, impresa più facile a dirsi che a farsi! Naturalemte sono andato diretto su Anjuta, sapendo che dalla versione 2 era stato integrato il supporto Glade ed erano fatti grossi passi avanti. Bhe, la prima sopresa è stata la velocità: rispetto alla versione precedente che avevo provato (la 1.8 o la 1.9, non ricordo bene) è decisamente più veloce nelle varie operazioni ed è ben fatta la pagina di creazione di un nuovo progetto (anche se fa tanto Visual Studio 6), in compenso l’ho trovato un po povero di funzionalità e, inoltre, ogni volta che tento di aprire un file glade con il designer integrato, Anjuta va inspiegabilmente in crash. Ho porvato anche a giocicchiare un po con Glade , che avevo già avuto occasione di usare per lavoro e, come la volta precedente, non mi ha particolarmente esaltato, non tanto per le funzioni di disegno del layout ma per la creazione del codice.

Audio

Niente di meglio di un po’ di musica davanti al PC, ed in questo caso sono stato fortunato: Rhythmbox. Un ottimo player audio con gestione della collezione personale e con tanti plugins che lo rendono molto completo , sia per l’utilizzo di servizi on-line (Last.fm, Podcast, Radio, Jamendo, etc…, sia per la gestione di lettori mp3 portatili (siano essi iPod o di altro genere).

Una cosa che mi ha mandato in visibilio è la notifica dei cambiamenti al volume dell’audio tramite i tasti multimediali sulla tastiera, che avviene tramite un box in semitrasparenza sulla parte bassa dello schermo con una barra ed un’icona che indicano lo stato del volume.

Internet

Bhe, per quanto riguarda navigazione web e posta elettronica c’è poco da dire: Firefox & Thunderbird. Per sfizio però ho provato anche: Epiphany, un buon browser abbastanza simile a firefox e Evolution, che ho trovato eccessivamente “pesante” rispetto a thunderbird. Per quanto riguarda il messaggistica istantanea sono andato sul buon aMSN, mentre pidgin non l’ho neppure provato tanto mi disgusta ancora dai tempi in cui si chiamava Gaim e, comunque, il buon vecchio Kopete non lo batte nessuno! Per quanto riguarda il P2P, oltre ad aMule (quasi una scelto obbligata visto i concorrenti come xMule o lMule), sono stato sorpreso da Deluge: ottimo client BitTorrent, leggero, stabile e con una interfaccia semplice ed immediata (tutte caratteristiche che mancano a KTorrent). Per il VoIP non mi sono complicato più di tanto la vita ed ho installato Skype.

Ripping e Masterizzazione

Fermo restando che non credo esista per GNU/Linux un software migliore di K3B per la masterizzazione dei CD/DVD, il ripping audio e chi più ne ha più ne metta, ho comunque trovato Brasero un buon prodotto, con una interfaccia minimale ma comunque utile a svolgere i compiti più comuni (creare dischi dati e audio, copiare dischi o masterizzare immagini). Per quanto riguarda il rippring di dischi audio mi sono trovato molto bene sia con Serpentine che Sound Juicer.

Grafica

Gimp, Inkscape e Blender! Gimp, Inkscape e Blender! Gimp, Inkscape e Blender! Gimp, Inkscape e Blender! Gimp, Inkscape e Blender! Gimp, Inkscape e Blender! Onestamente non c’è molto altro da aggiungere, se non una menzione particolare al visualizzatore di immagini F-Spot che ho trovato un po lentino in apertura (considerando l’interfaccia minimale) ma poi veloce e comodo durante la navigazione delle immagini.

Conclusioni

Di tempo a “giochicchiare” ne ho speso parecchio e molto altro avrei da scrivere sull’editing video, sugli strumenti per l’ufficio, sui giochi, sugli strumenti di monitoraggio del sistema, su…, però preferisco chiudere qui per dedicarmi ancora all’esplorazione della distro e di gnome. Nel complesso ho trovato Ububntu un buon prodotto con repository ricchissimi di pacchetti in grado di soddisfare quasi tutte le esigenze sia in ambito professionale, sia per l’uso “da casa”, anche se non sono mancate le delusioni, come, ad esempio, il fatto che tracker, nonostante le abbia provate tutte (seguendo howto sulla configurazione e tentando soluzioni proposte nei più svariati forums sul web) non ne voglia sapere assolutamente di indicizzarmi alcunché. Altra nota dolente è la velocità di avvio che, nonostante abbia disattivato i demoni che non desideravo fossero caricati all’avvio, rimane comunque piuttosto lento. Gnome è decisamente cresciuto molto e molto bene rispetto alle ultime volte in cui mi ero preso la briga di installarlo e provarlo, è esteticamente molto appagante (anche se un po troppo Mac in alcuni aspetti) ed ordinato; forse l’unica cosa che non riesco proprio a farmi piacere è Nautilus!

In buona sostanza ritengo che Ubuntu è una buona distribuzione, adatta ad utenti con diversi livelli di conoscenza di GNU/Linux, anche se, forse, con un occhio di riguardo verso i nuovi utenti.

Molti software creati per il sistema operativo Linux sono rilasciati come codice sorgente che l”utente deve compilare ed installare nel proprio sistema.
La necessità di dover ricorrere ad un terminale, spesso, può scoraggiare i nuovi utenti abituati alle interfacce grafiche su sistemi in cui molto raramente si ha l’occasione di compilare un pacchetto sorgente.
I passi di compilazione nella maggior parte dei casi sono sempre gli stessi e cioè:

• - decomprimere l’archivio dei sorgenti (tar -xv(z o j)f )
• - entrare nella directory dei sorgenti (cd )
• - configurare i sorgenti (./configure [eventuali parametri])

• - compilare i sorgenti (make)
• - installare i binari creati (make install)
• - rimuovere la cartella dei sorgenti (cd .. & rm -fvr )

Kompile è sviluppato in C++ utilizzando le API di KDE e delle librerie QT. Il codice sorgente è consultabile e modificabile secondo i termini della licenza GPL.

Attualmente le funzioni implementate nel software sono:
- Installazione con parametri predefiniti di pacchetti sorgente nel sistema.
- Disinstallazione con parametri predefiniti di pacchetti sorgente dal sistema.
- Integrazione nel menù Azioni di Konqueror.
- Minimizzazione nel vassoio di sistema
- Informazioni sul progresso dell”installazione (disintallazione) direttamente dall’icona nel vassoio di sistema.
- Ouput in tempo reale della console durante a procedura di installazione (disinstallazione)
- Possibilità di completare l’installazione anche per utenti senza privilegi di amministrazione specificando una password di root valida o una directory di installazione.
- Chiusura automatica della finestra di installazione (disinstallazione) dopo 20 secondi dal termine.

Screenshots:

Alcuni screenshots della versione 0.3 :

Download ed Installazione:

E’ disponibile sia il codice sorgente che i binari per alcune delle distribuzioni Linux più diffuse:

[Download not found]
[Download not found]
[Download not found]
[Download not found]
[Download not found]

Licenza

Il software è rilasciato sotto licenza GPL (GNU General Public License).
E’ possibile trovare copia della licenza (in lingua inglese) nel file COPYING all’interno dell’archivio dei sorgenti o nell’apposita pagina presso il sito GNU.


Changelog:

Changelog

versione 0.3

Miglioramenti:

- Aggiunta interfaccia grafica per accedere alla funzioni di Kompile (collegamento all ‘interno del menù “Sistema”
- Aggiunta la possibilità di cambiare le impostazioni principali di Kompile come:

• Selezione del tipo di integrazione con Konqueror (link nel menù azioni/menù indipendente di Kompile)
• Riprodurre un suono quando l ‘installazione/rimozione termina
• Impostare il tempo di attesa prima della chiusura automatica della finestra di installazione/rimozione
• Abilitare o disabilitare la chiusura automatica della finestra di installazione/rimozione come azione predefinita
• Definire il profilo predefinito per le operazioni di installazione/rimozione

- Aggiunto il sistema dei profili. Le impostazioni modificabili di un profilo sono:

• Abilitazione della copia di backup automatica del tarball sorgente per le future disinstallazioni.
• Informazioni sul pacchetto (nome, versione, release, licenza, descrizione)
• Percorso della cartella temporanea di decompressione dei sorgenti
• Politiche di rimozione della cartella temporanea di decompressione dei sorgenti
• Opzioni di configurazione dei sorgenti (prefix, abilita/disabilita warnings, abilita/disabilita librerie supplementari come, ad esempio, Qtopia, etc.)
• Opzioni dei compilatori (flags dei compilatori c/c++/fortran, path eseguibili compilatori, flags dei preprocessori, flags del linker, etc.)

• Opzioni di installazione per l ‘utente semplice (= non root)
• Uso di checkinstall anziché make install (ed opzioni di checkinstall)

- Ricerca di un profilo compatibile prima dell ‘installazione predefinita
- Pulsante di sospensione e ripresa delle operazioni di installazione/rimozione
- Visualizzatore integrato dei files README, INSTALL e CHANGELOG di un pacchetto in installazione/rimozione (se presenti nel pacchetto)
- Visualizzazione del file “config.log” in caso di fallimento della configurazione dei sorgenti
- Strumenti per la rimozione o il ripristino dei pacchetti già installati nel sistema
- Traduzione in lingua italiana
- Statistiche delle singole operazioni nei processi di installazione o rimozione di un pacchetto

Bugs Fixed e Cambiamenti:

• - Uso di KProcess anziché QProcess (KDE-compilance)
• - Uso di KDialogBase anziché QDialog (KDE-compilance)
• - Uso di KPushButton anziché QPushButton (KDE-compilance)
• - Aggiunto il supporto per la localizzazione in altre lingue
• - Rimossa l ‘icona nel vassoio di sistema

Ringraziamenti

Vorrei ringraziare alcune persone che hanno contribuito attivamente oltre che con consigli, suggerimenti ed idee, anche spendendo del tempo nel progetto Kompile. Grazie.

- Urs Wolfer
- Taralluccio
- KesieV
- Chris G
- Pablo F.
- Marco E.V.
- Roberto F.
- Alfredo B.
- Vincenzo C.

Segnalazioni

Attualmente la versione 0.3 di Kompile è in beta testing ed è quindi molto probabile rilavare bugs o malfunzionamenti generici. Chiunque volesse aiutarmi nel cercare di migliorare questo software può farlo segnalando i bacchi riscontrati come commenti a questo post o inviandomi una E-Mail.

Informazioni

Links delle componenti utilizzate per la realizzazione:

• Moodin KDE Splash Engine
• Nuvola Icons (by David Vignoni)
  
• Think Linux Wallpaper (by Bandar Hassan Raffa)

Screenshot

Download

E’ possibile scaricare Tux n’ Tosh Spash Screen da:

Installazione

Per l’installazione:

1. Aprire il centro di controllo KDE
2. Aprire la scheda “Schermata d’avvio” nella sezione “Aspetto e Temi”
3. Premere il pulsante “Aggiungi…”
4. Selezionare il file scaricato “TuxToshSplash.tar.bz2″
5. Nella lista delle shermate d’avvio disponibili selezionare TuxToshSplash
6. Premere il pulsante “Applica” (in basso a destra)

Al successivo avviodi KDE sarà visualizzato lo spash screen Tux n’ Tosh.

Note

Chiunque avesse problemi nell’installazione oppure avesse richieste di altro genere può lasciare un commento a questo post oppure scrivere al mio indirizzo:
tommaso.frazzetto@gmail.com.

Informazioni

Links delle componenti utilizzate per la realizzazione:

• Moodin KDE Splash Engine
• Umicons (icone di progresso)
• Breeze Comunication System Emoticons

Screenshots

Download

E’ possibile scaricare Spooky Splash Screen direttamente dal link seguente:

Installazione

Per installare ed attivare lo splash screen:

1. Aprire il centro di controllo KDE
2. Aprire la scheda “Schermata d’avvio” nella sezione “Aspetto e Temi”
3. Premere il pulsante “Aggiungi…”
4. Selezionare il file scaricato “SpookySplash.tar.bz2″
5. Nella lista delle schermate d’avvio disponibili selezionare SpookySplash
6. Premere il pulsante “Applica” (in basso a destra)

Al successivo avvio di KDE sarà visualizzato lo spash screen Spooky.

Note

Chiunque avesse problemi nell’installazione oppure avesse richieste di altro genere può lasciare un commento a questo post oppure scrivere al mio indirizzo:
tommaso.frazzetto@gmail.com.

Informazioni

I materiali utilizzati per la realizzazione sono

KDM Theme based on moodwrod’s “LoveKDE” Splash Screen (you can find it at http://www.kde-look.org/content/show.php?content=25945).

• Wallpaper originale disponibilie quì
• Robot disponibile quì
• Icone Nuvola (le mie preferite in assoluto) disponibili quì

Screenshot

Download

Archivio LoveKDE v0.1:

Installazione

Per installare ed attivare il tema:

1. Aprire il centro di controllo KDE
2. Aprire la scheda “KDM Theme” nella sezione “Sistema”
3. Premere il bottone “Modalità Amministrazione” ed autenticarsi con i dati di un utente con diritti di amministrazione
4. Attivare l’utilizzo dei temi con l’apposito checkbox
5. Selezionare il file scaricato
6. Premere il pulsante “Applica” (in basso a destra)

Al successivo avvio di KDM sarà usato il tema LoveKDE.

Note

Chiunque avesse problemi nell’installazione oppure avesse richieste di altro genere può lasciare un commento a questo post oppure scrivere al mio indirizzo:
tommaso.frazzetto@gmail.com