go-mtpfs: far riconoscere il proprio dispositivo Android a Linux.

Dopo aver letto qui e là numerose guide su come far riconoscere il proprio dispositivo Android al nostro linux ero arrivato ad un punto morto, con mtpfs che richiedeva minuti per la connessione e alla fine quando si andava a visitare la cartella montata si otteneva un bell'errore di socket disconnesso che impediva qualsiasi esplorazione del contenuto del mio cellulare.
Per fortuna poi ho scoperto go-mtpfs e le cose son cambiate. Vediamo come.
Da premettere che io ho un Nexus 4, quindi ovviamente la guida è testata solo ed esclusivamente con quel dispositivo. Però cercherò di farla il più generale possibile sperando di renderla compatibile con tutti.
EDIT: il metodo è stato testato con successo anche da un mio amico su Nexus 7.

1° Passo: attivazione dell'opzione Debug USB.

• Dal vostro dispositivo Android andate su Impostazioni -> Info dispositivo -> cliccate 7 (si, sette) volte sulla voce Numero Build. Un avviso a schermo vi dirà che è stata attivata la modalità sviluppatore.
• Sempre da vostro dispositivo Android andate ora su Impostazioni -> Opzioni sviluppatore e attivare l'opzione Debug USB.

2° Passo: identificazione del dispositivo Android.
Collegate il vostro dispositivo Android al PC. Aprite un terminale e date il comando:

lsusb

Otterrete qualcosa di simile:

Bus 001 Device 007: ID 18d1:4ee2 Google Inc. Nexus 4 (debug)
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
Bus 003 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub
Bus 002 Device 002: ID 192f:0416 Avago Technologies, Pte. ADNS-5700 Optical Mouse Controller (3-button)
Bus 002 Device 001: ID 1d6b:0001 Linux Foundation 1.1 root hub

Ovviamente la voce che ci interessa è quella relativo al nostro device (nel mio caso la prima, riconoscibile dalla dicitura Google Inc. Nexus 4 (debug)).
Segnatevi il codice separato dai due punti (nel mio caso quindi 18d1:4ee2).
Adesso aprite con i permessi di root ed il vostro editor di testo preferito il file /etc/udev/rules.d/51-android.rules:

sudo gedit /etc/udev/rules.d/51-android.rules

e al suo interno scrivete una riga del genere:

# LG Nexus 4
SUBSYSTEM=="usb", ATTR{idVendor}=="XXXX", ATTR{idProduct}=="YYYY", MODE="0666"

con al posto di XXXX la parte a sinistra dei due punti nel codice che ci siamo salvati prima e al posto di YYYY la parte di destra del codice.
Nel mio esempio quindi ottengo:

# LG Nexus 4
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4ee2", MODE="0666"

Salvate il file e chiudetelo.
Adesso non ci resta che dare i permessi di esecuzione a questo file. Da terminale digitare:

sudo chmod +x /etc/udev/rules.d/51-android.rules

Perfetto, ora possiamo passare al passo successivo.

3° Passo: installazione programmi necessari.
Ora andremo ad installare i programmi necessari che svolgeranno il lavoro "sporco" di montaggio del dispositivo Android. Come anticipato prima useremo go-mtpfs che è l'unico che personalmente ha funzionato per me, oltre ad essere, a detta di molti, il più veloce nello scambio di file tra dispositivo e PC (il classico mtpfs infatti pare sia limitato).

• Su Archlinux è tutto molto semplice, basta installare da AUR il pacchetto go-mtpfs-git:
  

  yaourt -S go-mtpfs-git

• Su Debian e derivate (Ubuntu...) dovete prima aggiungere un nuovo repo:
  

  sudo add-apt-repository ppa:webupd8team/unstable
sudo apt-get update

  Dopodiché potrete installare tutto il necessario dando da terminale:
  

  sudo apt-get install go-mtpfs

• Per tutte le altre distro, bisogna procedere compilando il programma. Per fare questo basta seguire le indicazioni scritte nella pagina ufficiale del progetto che potete trovare qui: https://github.com/hanwen/go-mtpfs

Installato go-mtpfs, aprite un terminale e digitate:

sudo groupadd fuse
sudo gpasswd -a [user] fuse

con al posto di [user] il vostro nome utente.
Ora che tutto è pronto riavviate il vostro PC per far in modo che tutti i cambiamenti prendano piede.

4° Passo: collegamento.
Dopo aver riavviato siamo pronti per il collegamento.
Collegate il dispositivo al PC via USB, aprite un terminale e create un punto di mount per il vostro dispositivo. Io vi consiglio di farlo nella vostra home perché a me con sudo ha dato problemi. Per far questo da terminale digitiamo:

mkdir ~/Android

Adesso finalmente possiamo montare il nostro dispositivo! Diamo da terminale:

go-mtpfs ~/Android

e se tutto è andato secondo i piani navigando nella cartella Android appena creata (nella vostra home) potrete accedere alla memoria del vostro dispositivo collegato via USB!

Quando avrete finito di fare quello che volete con i file del vostro dispositivo, per smontarlo correttamente (attenzione a NON scollegare l'USB manualmente e basta, creereste danni al vostro filesystem!) digitare il seguente comando sempre in un terminale:

sudo umount ~/Android

Fatto ciò adesso potrete procedere con la disconnessione manuale del cavo USB.


Nota finale: d'ora in poi quando vorrete collegare il vostro dispositivo Android al PC vi basterà semplicemente collegarlo via USB e utilizzare soltanto gli ultimi 2 comandi per montare e smontare il vostro dispositivo, ossia:

go-mtpfs ~/Android

per montarlo e

sudo umount ~/Android

per smontarlo.

Linux: abilitare il supporto ai magnet in Chromium

In questo minitutorial vedremo come configurare Chromium (Google Chrome) per riuscire ad aprire il link in formato magnet in modo che vengano gestiti da un qualsiasi client Torrent. Io personalmente utilizzo Vuze (il vecchio Azureus per intenderci) ma più per una scelta di compatibilità (è multipiattaforma e accettato da praticamente tutti i tracker privati) che per efficienza.
Comunque, tornando al nostro obiettivo, se proviamo ad aprire (cliccando su) un qualsiasi link magnet in giro per il web otterremo il seguente errore da Chromium:

Per ovviare al problema non dovremo toccare nessuna configurazione nel browser internet, né tantomeno per forza modificare opzioni gconf come consigliato in svariate altre guide. Tutto ciò che dovremo fare è modificare il file xdg-open che Chromium utilizza per aprire i link esterni.
Quindi, senza ulteriori esitazioni, apriamo un terminale e diamo un bel:

sudo gedit /usr/bin/xdg-open

Ovviamente potete sostituire, nel comando sopra, gedit con il vostro editor di testo preferito.
Nel file aperto dovremo andare a cercare la funzione di apertura relativa al vostro ambiente desktop. Io, per esempio, utilizzo XFCE quindi sono andato a cercare la funzione chiamata open_xfce() e mi son trovato difronte al seguente codice:

open_xfce()
{
exo-open "$1"

if [ $? -eq 0 ]; then
exit_success
else
exit_failure_operation_failed
fi
}

A questo punto tutto ciò che ho dovuto fare è aggiungere un'istruzione IF per determinare l'eventuale presenza di magnet ed agire di conseguenza. Nello specifico ho trasformato la funzione sopra in quest'altra:

open_xfce()
{
if (echo "$1" | grep -q '^magnet:'); then
vuze "$1"
if [ $? -eq 0 ]; then
exit_success
fi
fi

exo-open "$1"

if [ $? -eq 0 ]; then
exit_success
else
exit_failure_operation_failed
fi
}

Al posto di vuze potete sostituire il vostro client Torrent preferito (transmission, deluge, ecc...).
Ovviamente ci son funzioni per "quasi" tutti i DE, ad esempio open_gnome(), open_kde(), open_darwin(), open_mate(), quindi scegliete la funzione in base a quale DE usate o in extremis inserite il nuovo pezzo in tutte le funzioni presenti.
Salvate i cambiamenti al file e voilà, adesso potrete aprire tranquillamente anche i link magnet dal vostro Chromium :)

JAVA: installare l'SDK per Android e configurare Netbeans per lavorarci

Oggi piccola miniguida per configurare Netbeans per la programmazione JAVA su Android. Innanzitutto dobbiamo prima scaricare l'SDK ufficiale di Android, cosa che possiamo fare al seguente indirizzo: http://developer.android.com/sdk/index.html
ATTENZIONE: dovremo scaricare la versione sotto il menù "USE AN EXISTING IDE" e non quindi la versione completa "ADT (Android Developer Tools)".
Andate su quella pagina dunque e dopo aver cliccato sulla voce "USE AN EXISTING IDE" scaricate il pacchetto "SDK Tools".
Una volta scaricato bisogna estrarlo col classico:

tar -xfv android-sdk_r21.1-linux.tgz

Ovviamente il nome dell'archivio dell'SDK cambierà a seconda di quale sarà la versione che avrete scaricato.

Una volta estratto otterrete una cartella di nome android-sdk-linux. Prendetela e spostatela in una qualsiasi cartella della vostra home (su cui avete i diritti di scrittura insomma). Io qui per esempio la sposterò all'interno della home direttamente.

A questo punto aprite un terminale e spostatevi nella cartella su indicata, dopodiché avviare l'SDK Manager come segue:

cd ~/android-sdk-linux/tools/
./android sdk

Apparirà la schermata principale dell'SDK Manager:


Ora assicuriamoci di selezionare almeno le prime due voci principali nell'elenco (ossia Tools e Android x.x.x). Dopodiché clicchiamo su "Install x packages...". Vi apparirà una finestra in cui vi chiederà di accettare, per ogni voce selezionata prima, la licenza d'uso. Ovviamente accettatele e proseguite, partirà il download e l'installazione di tutto il necessario per l'SDK (potrebbe richiedere molto tempo, pazientate).

Adesso l'SDK è pronto. Dovremo creare una macchina virtuale con Android su cui testare i nostri programmi in futuro (potete anche saltare questo passaggio se avete un dispositivo Android su cui testare i programmi).
Chiudiamo l'SDK Manager e sempre in un terminale avviamo il gestore di macchine virtuali Android dando:

cd ~/android-sdk-linux/tools/
./android avd

Nella finestra che apparirà clicchiamo sul pulsante New e otterremo la seguente schermata:

Basta compilare i vari campi con le opzioni che vogliamo per crearci il nostro dispositivo Android preferito sui cui vogliamo testare i programmi che creeremo (esempio potremo scegliere di emulare un Nexus 7, di modificare RAM e memoria su SD, ecc...) e cliccare su OK. Tutto qui.

Adesso che avremo anche la nostra macchina virtuale Android su cui testare i nostri futuri programmi e l'SDK installato, non ci resta che l'ultimo passo: configurare Netbeans per lavorare con l'SDK Android. Nulla di più semplice!
Avviamo Netbeans e dal menù Tools scegliamo la voce Plugins.
A questo punto, nella finestra che comparirà, spostiamoci sulla scheda Settings. Qui clicchiamo sul pulsante Add e compiliamo la finestra che apparirà:

inserendo come nome Android SDK e come URL per gli aggiornamenti il seguente http://nbandroid.org/release72/updates/updates.xml
ed accertiamoci che l'opzione "Check for updates automatically" sia spuntata (così otterremo automaticamente eventuali aggiornamenti futuri). Fatto ciò diamo l'OK.
Ritornati quindi alla finestra di prima, spostiamoci ora sulla linguetta Available Plugins e nell'elenco selezioniamo Android e clicchiamo quindi sul pulsante Install.
Partirà l'installazione del nuovo plugin (vi appariranno un paio di avvisi su licenza e verifica del plugin, voi ovviamente confermate tutto), al termine possiamo chiudere tutte queste finestre.
Tornati quindi nella pagina principale di Netbeans torniamo, sempre dalla barra dei menù in alto, su Tools ma stavolta scegliamo la voce Options. Nella finestra che apparirà spostiamoci nella categoria chiamata Miscellaneous e qui troveremo una linguetta chiamata appunto Android. In questa finestra dovremo inserire il path (il percorso) dove si trova la cartella dell'SDK android che abbiamo scaricato in precedenza:

nel nostro esempio quindi sarebbe ~/android-sdk-linux.
Diamo l'OK e abbiamo finalmente finito.
Netbeans è ora pronto per creare tanti bei programmini per Android :)