golang / go

Il sottorepository Go mobile aggiunge il supporto per le piattaforme mobili (Android e iOS) e fornisce strumenti per costruire applicazioni mobili.

Ci sono due strategie che puoi seguire per includere Go nel tuo stack mobile:

• Scrivendo applicazioni mobili native all-Go.
• Scrivendo applicazioni SDK generando binding da un pacchetto Go e invocandoli da Java (su Android) e Objective-C (su iOS).

Questo articolo conterrà delle guide passo dopo passo per spiegare come realizzare queste strategie.

• Strumenti
• Applicazioni native
  • Costruzione e distribuzione su Android
  • Costruzione e distribuzione su iOS
  • Icona applicazione
• Applicazioni SDK
  • Costruire e distribuire su Android
  • Costruire e distribuire su iOS
  • Simulatore iOS

Strumenti

Nota: Devi avere Go 1.5 o superiore per installare gli strumenti mobili. (O almeno Go 1.7.4 se usi macOS Sierra)

Go Mobile introduce un nuovo strumento, gomobile, per aiutarti nella compilazione e nel processo di binding.

gomobile supporta Go Modules ora! $ gomobile bind -v -o android.aar -target=android ./package sotto la directory del progetto funziona ora.

Su macOS, è necessario avere installato Xcode Command Line Tools.

$ go get golang.org/x/mobile/cmd/gomobile

(Le seguenti sezioni ti aiuteranno a usare lo strumento gomobile.)

Applicazioni native

La categoria native include applicazioni interamente scritte in Go. Attualmente, il sitogolang.org/x/mobilecontiene solo un piccolo insieme di pacchetti che si concentrano su:

• Controllo e configurazione delle applicazioni
• Bindings OpenGL ES 2 e ES 3
• Gestione degli asset
• Gestione degli eventi
• I pacchetti sperimentali includono bindings OpenAL, audio, font, sprite e sensori di movimento

Ci sono vari esempi di applicazioni native sotto golang.org/x/mobile/example. Costruiremo e distribuiremo l’esempio di base sia su un dispositivo Android che iOS.

Prendi l’applicazione.

$ go get -d golang.org/x/mobile/example/basic

Costruire e distribuire su Android

Esegui gomobile build per costruire un APK Android.

$ gomobile build -target=android golang.org/x/mobile/example/basic

Il comando Build costruirà un APK chiamato basic.apk.

Se un AndroidManifest.xml è definito nella directory del pacchetto, viene aggiunto all’output APK. Altrimenti, viene generato un manifesto predefinito.

Se hai il comando adb installato sulla tua macchina, puoi usare gomobile install per costruire e spingere l’APK sul tuo dispositivo mobile.

$ gomobile install golang.org/x/mobile/example/basic

Costruire e distribuire su iOS

Esegui gomobile build per costruire il pacchetto come applicazione iOS.

Nota: target=ios richiede la macchina host con macOS. È necessario ottenere un’identità di firma e scaricare i profili di provisioning per continuare.

$ gomobile build -target=ios golang.org/x/mobile/example/basic

Il comando build costruirà un bundle di applicazioni, chiamato basic.app.

Puoi distribuire i file .app trascinandoli sul dispositivo.

• In Xcode, apri Window > Devices.
• Seleziona il dispositivo fisico dal pannello di sinistra.
• Trascina il file .app nella sezione “Installed Apps”.
• Controlla l’opzione “Copy items if needed”

In alternativa, puoi distribuire bundle di applicazioni sul tuo dispositivo iOS usando lo strumento della linea di comando ios-deploy. Usa ios-deploy per spingere l’applicazione sul tuo dispositivo.

$ ios-deploy -b basic.app

Icona dell’applicazione

È possibile impostare un’icona dell’applicazione creando assets/icon.png.

applicazioni SDK e generando i binding

In questa categoria, ti mostreremo come puoi usare un pacchetto Go nella tua applicazione Android o iOS esistente.

I vantaggi di seguire questa strategia:

• Puoi riutilizzare un pacchetto Go di un’applicazione mobile senza apportare modifiche significative alla tua applicazione esistente.
• Nei casi in cui vuoi condividere una base di codice comune tra la tua applicazione Android e iOS, puoi scrivere le funzionalità comuni una volta in Go e incollarle al codice specifico della piattaforma richiamando il pacchetto Go attraverso i binding.

Le limitazioni attuali sono elencate di seguito.

• Solo un sottoinsieme di tipi Go sono attualmente supportati.
• I binding linguistici hanno un sovraccarico di prestazioni.
• Ci sono alcune limitazioni su come le API esportate dovrebbero apparire a causa delle limitazioni del linguaggio di destinazione.

Useremo il pacchetto example sotto golang.org/x/mobile/example/bind/hello per generare i binding e invocare la funzione Greetings da Java e Objective-C.

Prendi l’esempio eseguendo il comando qui sotto.

$ go get -d golang.org/x/mobile/example/bind/...

Costruire e distribuire su Android

Nota: Go Mobile gira sulle stesse architetture di Go, che attualmente significa dispositivi ed emulatori ARM, ARM64, 386 e amd64. In particolare, Android su dispositivi MIPS non è ancora supportato.

• Esegui il seguente comando per generare il file aar adatto all’importazione in progetti Android:

$ gomobile bind -o app/hello.aar -target=android golang.org/x/mobile/example/bind/hello

• Lancia Android Studio.
• File > Import Project… per importare il progetto di riferimento da $GOPATH/src/golang.org/x/mobile/example/bind/android.

• Costruisci e distribuisci l’applicazione sul dispositivo.

Il modulo app contiene l’applicazione principale che richiama il hello.Greetings. Quando l’applicazione viene lanciata, la vista di testo viene aggiornata con la stringa restituita.

Se non stai usando Android Studio, per poter lavorare con i binding per Android, devi avere Android SDK installato e la variabile d’ambiente ANDROID_HOME impostata sul percorso SDK. Hai anche bisogno dell’NDK installato; il modo più semplice è eseguire il comando SDK sdkmanager ndk-bundle.

In alternativa, se non hai familiarità con lo sviluppo di Android, e non vuoi impostare tutto l’ambiente richiesto (Android SDK, Gradle, ecc.), puoi usare questo Dockerfile per costruire l’applicazione in docker invece.

Inoltre, se cerchi di aggiungere yourmodule.aar nel tuo progetto, dopo aver copiato il file yourmodule.aar e il file yourmodule.jar nella cartella “android\app”, di seguito è necessario modificare il file “android\appbuild.gradle” per importare correttamente il modulo.

+ repositories {+ flatDir {+ dirs '.'+ }+ }

dependencies {...+ implementation (name:'yourmodulename', ext:'aar')}

Costruire e distribuire su iOS

Nota: target=ios richiede che la macchina host stia eseguendo macOS.

$ cd $GOPATH/src/golang.org/x/mobile/example/bind$ gomobile bind -target=ios golang.org/x/mobile/example/bind/hello

Gomobile bind genererà un bundle di framework chiamato Hello.framework. Apri il progetto Xcode di esempio eseguendo il comando sottostante.

$ open ios/bind.xcodeproj

Trascina il bundle Hello.framework nel progetto Xcode. Controlla “Copia gli elementi se necessario” se hai bisogno di un’altra copia del bundle del framework all’interno di Xcode altrimenti. Altrimenti, modificando il codice sorgente del pacchetto Go e rilanciando gomobile bind aggiornerai hello.framework.

Se decidi di mantenere Hello.framework nella directory principale devi aggiungere la directory principale alla Framework Search Paths nelle Build Settings degli obiettivi.

Il layout del tuo progetto dovrebbe essere come quello mostrato qui sotto.

Costruisci ed eseguilo sul simulatore o su un dispositivo reale (Cmd+R). Quando l’applicazione viene lanciata, l’etichetta sulla vista principale sarà modificata con la stringa restituita da GoHelloGreetings che invoca la funzione hello.Greetings.

Nota che puoi anche invocare GoHelloGreetings da Swift importando Hello.

@import Hello// ...let msg = Hello.GoHelloGreetings("gopher")

Simulatore iOS

A partire da Go 1.5, solo darwin/amd64 funziona sul simulatore iOS. Per utilizzare il simulatore, è necessario configurare Xcode per cercare di eseguire solo i binari a 64 bit.

Xcode corrisponde alla larghezza di bit dei binari ARM quando viene eseguito sul simulatore X86. Cioè, se configuri Xcode per costruire sia binari ARM a 32-bit che a 64-bit (il default), tenterà di eseguire i binari X86 a 32-bit sul simulatore, il che non funzionerà con Go oggi. Modifica le impostazioni di compilazione di Xcode per costruire solo binari ARM a 64 bit, e il simulatore eseguirà il binario amd64.