JUCE il framework per Mac OSx, IOs, Linux, Windows ed Android.

Pubblicato: agosto 31, 2012 in Linux
Tag:, ,

Dopo un’interessante chiacchierata con il bravo Luca Calcaterra di qualche giorno fa, ho riscoperto un’interssate framework che avevo già visto e valutato qualche tempo fa ma che ( a questo punto devo dire purtroppo ) dimenticato e probabilmente in un primo momento sottovalutato. Vediamo di cosa si tratta e cerchiamo di capire come poter muovere i primi passi con esso in ambiente Linux.

JUCE (Jules’ Utility Class Extensions), questo è il suo nome del framework in questione, è una libreria onnicomprensiva di classi scritta in C++, pensata per lo sviluppo software ( programmi applicazioni pugins etc..) multi-piattaforma.
In pratica in questa libreria troviamo tutto il necessario per creare la maggior parte delle applicazioni moderne ( giochi, programmi etc..) , ma è soprattutto, troviamo tutto il necessario per lo sviluppo e la realizzazione di interfacce grafiche personalizzate e per la gestione del suono e del MIDI.
Appare evidente che ad un patito software con il pallino della musica come il sottoscritto, già questa breve descrizione, fa “drizzare” le orecchie ma la cosa diventa ancor più eccitante quando si legge la lista delle piattaforme sulle quali è possibile far girare le applicazioni sviluppate con JUCE.

Nella lista troviamo:
Mac OSX
iOS, e quindi iPhone, iPadt etc..
Windows con compatibilità piena per XP e Windows 7
Linux
Android anche se in questo caso gli siluppatori dichiarano che ci stanno ancora lavorando e che non tutte le funzioni sono ancora complete.

Praticamente tutte le piattaforme più in voga del momento!

Cerchiamo di essere più chiari e spiegare cos’è e cosa fa un framework.

Tutti sappiamo che esistono diversi sistemo operativi ( Linux, Windows, OSX, etc.).
Ogni sistema operativo ha un suo modo di funzionare ed un suo sistema di sviluppo.
Un programma, per poter girare ed essere compatibile con un certo sistema operativo, deve essere scritto in modo tale che esso si interfacci e sfrutti le risorse e le possibilità messe a disposizione dal sistema operativo per il quale è sviluppato.
Essendo i vari sistemi operativi ( Windows, Linux, Mac etc..) sviluppati da aziende o gruppi diversi, anche le risorse e le funzioni ( talvolta anche i linguaggi stessi, come nel caso dell’Objective-c del Mac) sono diversi tra loro.
Un programma scritto per Windows, che utilizzi grafica, risorse multimediali etc.. non può ( nella maggior parte dei casi ) essere portato ( o ricompilato) per Linux o Mac ne tanto meno per sistemi IOs. Il più delle volte si è costretti a riscivere quasi completamente il codice per adattarlo da una piattaforma all’altra.

Se al contrario il programma viene scritto non per un particolare sistema operativo ma viene scritto per un framework ( o su un framework ) multi piattaforma come JUCE, esso potrà essere portato da un sistema operativo ad un altro in modo molto più semplice ed immediato perche sarà il framework che si occuperà di “tradurlo“ nel linguaggio dei diversi sistemi operativi.

L’uovo di Colombo della programmazione multipiattaforma.

Detta così sembra semplice ma come funzione questa cosa?
Facciamo un esempio forse un po banale ma che probabilmente può rendere facilmente l’idea del lavoro che c’è dietro.
Supponiamo che per scrivere una riga sullo schermo ( la classica “pippo”) in Windows, si utilizzi un comando (un’API ) così fatto: PrintText(“pippo”).
Su Linux ne esisterà uno simile ma che si chiama in modo differente diciamo: WriteText(“pippo”).
Su Mac un’altro ancora che magari avrà la forma seguente: NSLOutText(“pippo”).
N.B. Stò ovviamente inventano sia i nomi che i parametri delle funzioni quindi non tentate di chiamare queste funzioni nei vari sistemi operativi!

Un programma scritto per Windows, quando vorrà stampare una riga di testo dovrà chiamare la relativa funzione, uno per L’inux l’altra,  per Mac l’altra ancora.
Appare evidente che i programmi non possono essere “scambiati” o portati da un sistema all’altro senza dover riscrivere il codice ed i nomi delle funzioni.

Se però qualcuno ha realizzato un framework ( ovvero una struttura di supporto su cui un software può essere organizzato e progettato) che implementi una funzione che permetta di scrivere sullo schermo dal nome: ScriviTestoSulloSchermo(“pippo”) la quale, a sua volta nel caso in cui ci troviamo su Windows chiami la funzione PintText(“pippo”), su Linux chiami la funzione WriteText(“pippo”) e su Mac la funzione: NSLOutText(), il nostro programma potrà essere scritto una sola volta ed essere compilato per tutti i sistemi operativi.
Il framework pensa a tradurre la funzione (ScriviTestoSulloSchermo (“pippo”) ) nella funzione relativa al sistema operativo targher sul quale vogliamo far girare il programma.
Fate attenzione che il programma dovrà essere sempre ricompilato per la specifica piattaforma ma a partire sempre dalla stessa sorgete e questo non è poco!
Questo è ovviamente solo un esempio, la cosa in realtà è molto molto più complicata ma credo possa comunque rendere bene l’idea.

Quanti e quali framewerk multi piattaforma esistono?
JUCE non è l’unico framework di questo tipo, ne esistono molti altri ognuno con le sue peculiarità e particolarità.
Qt ( di cui abbiamo già parlato in altri post nel blog) ne è un altro esempio anche se per ragioni di licenze ed ingombro, non può funzionare su iPad ne tanto meno su iPhone.
Anche in questo caso è possibile fare un programma ( con finestre, grafica etc…) e poterlo portare tra le varie piattaforme. Ha il vantaggio di avere anche la possibilità di essere adatto per applicazioni embedded ma ( anche se ha metodi e classi di tutto rispetto) non nasce appositamente per sviluppare applicazioni Audio e MIDI.
Inoltre Qt richiede che il framework sia compilato a parte e che sia disponibile per l’applicazione come libreria (SO, DLL, o statica) da caricare o da linkare separatamente.
In poche parole non diventa mai effettivamente parte dell’applicazione stressa ( almeno per i tipi di licenza più comuni) .

JUCE al contrario non richiede la pre-compilazione di librerie (il che significa non preoccuparsi delle dipendenze, delle compatibilità etc… ) , ogni modulo di JUCE può essere incorporato nel progetto in forma di sorgente. Questo è un gran bel vantaggio!

Ma JUCE quanto costa e come lo posso reperire?
Juce è rilasciato sotto la GNU Public Licence il che significa che può essere liberamente copiato e distribuito, e non costa nulla se utilizzato per le applicazioni open-source.
Se al contrario si vuole realizzare un’applicazione chiusa, ovvero di cui non si rilasci il codice, è necessario acquistare delle licenze commerciali dal costo di circa 600 sterline.
Clicca qui per maggiori informazioni.

Chi utilizza JUCE?
Di solito dando uno sguardo alle aziende o alle case che utilizza una cerca risorsa, ci si fa subito un’idea della validità della risorsa stessa.
Nel caso di JUCE la lista che troviamo sul sito contiene nomi eccellenti del tipo:

Korg
M-Audio
Arturia
TC Group
Open Labs

e molti latri. Non vi basta?

Dopo tante chiacchiere mettiamoci al lavoro e magari vediamo come poter lavorare con questo framework.

Il sistema operativo di svilupo.
Le modalità operative ( editing, compilazione etc..) cambiano da sistema operativo a sistema operativo.
Visto che io in questo momento sono davanti ad una desktop Linux,
questa mia prima guida su JUCE, riguarderà come scaricare, installare, compilare, impostare il sistema di sviluppo per JUCE su questa piattaforma.
Appena possibile faro un nuovo articolo riguardante Windows e Mac.

Scarichiamo il Framework.
Possiamo scaricare JUCE in vari modi ma a mio avviso il più semplice è quello di scaricare il file ZIP come indicato in questa pagina: http://www.rawmaterialsoftware.com/downloads.php

Scompattiamo il file ZIP ( ad esempio sulla scrivania); ad operazione terminata dovremmo avere una situazione tipo quella riportata nell’immagine seguente:

Nella cartella docs troviamo il file JUCE readme.html il quale riporta utili informazioni sulle prime operazioni da effettuare ed in particolare sui requisiti che deve avere il sistema per installare il framework correttametne.
Visto che siamo su Linux il file ci ricorda che dobbiamo aver installato il development packages di freetype, X11 e pthreads.
Se non li avete andate nel gestore dei pacchetti ed installateli.
Inoltre ci ricorda che i makefiles generti dal framework possono essere lanciati sia in modalità Debug, (make CONFIG=Debug) che Release (make CONFIG=Release)
inoltre è disponibile anche il Clean (make clean) per cancellare i file intermedi e ricompilare il tutto.
Non stò qui a spiegare cos’è un make file, per maggiori info vi consiglio questo link:
http://www.bo.cnr.it/corsi-di-informatica/corsoCstandard/Lezioni/17Linuxmake.html

Sempre nel file leggiamo che nella cartella juce/extras troviamo una serie di programmi ed esempi demo per iniziare con JUCE.
Sarà nostro obbiettivo compilare, modificare, debbagare il più semplice di tutti, il classico
Hello Word
che trovate nella cartella example projects.

Introjucer e The Jucer
Sempre nella cartella extras trovate due sotto cartelle chiamate: Introjucer e the jucer.
Queste due cartelle non contengono programmai di esempio ma le sorgenti di due programi ( utility ) che ci serviranno per sviluppare e creare nuovi progetti.
Vedremo come compilarli e utilizzarli in seguito.

Il Nostro Hello Word Project.
Focalizziamo l’attenzione sulla cartella extras/example projects.

Nella cartella Source troviamo le sorgenti del programma, nella cartella Builds troviamo una serie di cartelle con i progetti per i vari sistemi operativi.

Dentro la cartella Linux troveremo il Makefile che ci permetterà di compilare il programma per questo sistema operativo.

IDE o linea di comando?
Dopo aver esplorato il nostro progetto, è tempo di compilarlo e farlo girare.
Una delle annose questioni che attanagliano gli sviluppatori ( soprattutto quelli che lavorano in Linux ) e quello di utilizzare la consolle e quindi modificare, compilare etc.. etc.. con la linea di comando o utilizzare un programma che permetta di fare tutto questo in modo grafico.
Io sono per la seconda opzione, IDE forever!

Quindi è tempo di scegliere un sistema per visualizzare, modificare e compilare il nostro progetto.
Tra le varie soluzioni possibili ho pensato di utilizzare il Qt Creator.

Qui qualcuno di voi inizierà a storcere il naso e a chiedersi, ma non avevamo detto che Qt erà un altro framework etc.. etc..
Si tutto vero, ma Qt Creator è un ottimo IDE che può essere facilmente utilizzato anche per compilare e gestire progetti che non si basano su Qt ma che utilizzano altri framework.
Per installare il Qt Creator fate riferimento a questo post.

Impostiamo Qt Creator per lavorare con il nostro progetto Hello word.
Dopo aver lanciato il Qt Creator, clicca sul menù File e successivamente su New File or Project.

Clicca su Other Project, poi su Import Existing Project, e successivamente sul pulsante Choose.

Inserisci un nome per il progetto (JUCE_HelloWord ad esempio), clicca sul pulsante Browse e seleziona la directory Source ( quella con i file cpp ) contenuta nella cartella example_project.
Clicca su Next per andare avanti.

Il programma troverà i file C e Cpp. Clicca su Next per andare avanti.

Clicca su Finish per terminare l’import del progetto.

Qt Creator aprirà il progetto nel proprio Editor.
Potrai i file e modificarli come con dei normali file di testo.

Impostiamo i parametri per la compilazione, il debug e per il Run.

Clicca sull’Icona Projects.
Nella finestra Build Settings, clicca sul tasto Browser e seleziona la cartella Builds/Linux.
Questa sarà la cartella dove verrà salvato il file eseguibile del programma.
Cliccando su Details espandi la sezione Build Steps e togli la spunta su all.
Clicca sull’icona Edit per salvare e tornare alla pagina principale.

Dalla pagina principale clicca sull’Icona Build (a forma di martello) per avviare la compilazione.
Vedrai i file processati comparire nella sezione Compile Output.

Dalla Pagina principale clicca sull’Icona Projects.
Seleziona la pagina Run Settings e clicca sul tasto Browser della sezione Executable.
Seleziona il file HelloWorld che troverai nella cartella
example projects/Builds/Linux/build
Clicca sull’icona Edit per salvare e tornare alla pagina principale.

Dalla pagina principale clicca sull’icona Run ( A Forma di freccia Play) e vedrai comparire il programma al centro dello schermo.

Ora il Debug.
Il passo successivo è quello di “debbagare” il programma ovvero di avviarlo in modo tale da poterlo fermare in un punto, farlo andare avanti passo passo, visualizzare lo stato della memoria e dei registri etc.. etc..

Clicca su una delle prime righe del codice. Vedrai comparire un pallino roso; hai appena impostato un break point.
Clicca sull’Icona Debug in bassi a sinistra, vedrai cambiare lo schermo, il programma si è avviato e fermato nel punto n cui hai impostato il breakpoint.
Clicca sul tasto Step per procedere passo passo.
Ora potrai vedere come il programma gira.

Se non hai pretese di aggiungere nuovi file o modificare il progetto puoi ritenerti operativo!

Appena possibile vdiamo come aggiungere file o fare un novo progetto e come lavorare su  Mac e Windows,

Cioa,
Giorgio.

commenti
  1. tarcello scrive:

    graziee per le belle info giorgio 😉

  2. Salve Giorgio,

    complimenti per l’articolo.
    Anch’io trovo le JUCE particolarmente attraenti.

    Qualora non lo conoscesse, desideravo segnalare il progetto di estensione JUCETICE.
    Saluti.

Lascia un commento

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...