golang / go

Go mobile-underförrådet ger stöd för mobila plattformar (Android och iOS) och tillhandahåller verktyg för att bygga mobila applikationer.

Det finns två strategier som du kan följa för att inkludera Go i din mobila stack:

• Skrivning av mobila applikationer som helt och hållet är inbyggda i Go.
• Skrivning av SDK-applikationer genom att generera bindningar från ett Go-paket och anropa dem från Java (på Android) och Objective-C (på iOS).

Denna artikel kommer att innehålla steg-för-steg-guider för att förklara hur man uppnår dessa strategier.

• Verktyg
• Nativa applikationer
  • Bygga och distribuera till Android
  • Bygga och distribuera till iOS
  • Applikationsikon
• SDK-applikationer
  • Bygga och distribuera till Android
  • Bygga och distribuera till iOS
  • iOS Simulator

Verktyg

Anm: Du måste ha Go 1.5 eller högre för att installera mobila verktyg. (Eller minst Go 1.7.4 om du använder macOS Sierra)

Go Mobile introducerar ett nytt verktyg, gomobile,som hjälper dig med bygg- och bindningsprocessen.

gomobile stöder Go Modules nu! $ gomobile bind -v -o android.aar -target=android ./package under projektkatalogen fungerar nu.

På macOS måste du haXcode Command Line Tools installerat.

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

(Följande avsnitt hjälper dig att använda verktyget gomobile.)

Inhemska applikationer

Den inhemska kategorin omfattar applikationer som är helt skrivna i Go. För närvarande är detgolang.org/x/mobile endast en liten uppsättning paket som fokuserar på:

• Applikationskontroll och konfiguration
• OpenGL ES 2- och ES 3-bindningar
• Assethantering
• Hantering av händelser
• Experimentella paket inkluderar OpenAL-bindningar, ljud-, typsnitts-, sprite- och rörelsesensorer

Det finns olika exempel på inhemska applikationer under golang.org/x/mobile/example. Vi kommer att bygga och distribuera det grundläggande exemplet både till en Android- och iOS-enhet.

Hämta programmet.

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

Bygga och distribuera till Android

Kör gomobile build för att bygga en Android APK.

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

Byggkommandot kommer att bygga en APK med namnet basic.apk.

Om en AndroidManifest.xml definieras i paketkatalogen läggs den till APK-utgången. Annars genereras ett standardmanifest.

Om du har adb-kommandot installerat på din maskin kan du använda gomobile install för att bygga och skicka APK:n till din mobila enhet.

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

Bygga och distribuera till iOS

Kör gomobile build för att bygga paketet som en iOS-applikation.

Anm.: target=ios kräver att värdmaskinen kör macOS. Du måste skaffa en signeringsidentitet och hämta provisioneringsprofiler för att kunna fortsätta.

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

Byggkommandot bygger ett applikationspaket som heter basic.app.

Du kan distribuera .app-filer genom att dra och släppa dem till enheten.

• I Xcode öppnar du Fönster > Enheter.
• Välj den fysiska enheten i den vänstra rutan.
• Släpp och dra .app-filen till avsnittet ”Installerade appar”.
• Kryssa för alternativet ”Kopiera objekt om det behövs”

Alternativt kan du distribuera programbuntles till din iOS-enhet med hjälp av kommandoradsverktyget ios-deploy utility. Använd ios-deploy för att trycka applikationen till din enhet.

$ ios-deploy -b basic.app

App-ikon

Det är möjligt att ställa in en app-ikon genom att skapa assets/icon.png.

SDK-applikationer och generera bindningar

I den här kategorin kommer vi att visa hur du kan använda ett Go-paket i din befintliga Android- eller iOS-applikation.

Fördelarna med att följa den här strategin:

• Du kan återanvända ett Go-paket från en mobilapplikation utan att göra betydande ändringar i din befintliga applikation.
• I de fall du vill dela en gemensam kodbas mellan din Android- och iOS-applikation kan du skriva den gemensamma funktionaliteten en gång i Go och limma dem till den plattformsspecifika koden genom att anropa Go-paketet via bindningar.

De nuvarande begränsningarna anges nedan.

• För närvarande stöds endast en delmängd Go-typer.
• Språksbindningar har en prestandaöverskottstid.
• Det finns några begränsningar för hur de exporterade API:erna ska se ut på grund av begränsningar i målspråket.

Vi kommer att använda exempelpaketet under golang.org/x/mobile/example/bind/hello för att generera bindningar och anropa Greetings funktion från Java och Objective-C.

Hämta exemplet genom att köra kommandot nedan.

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

Bygga och distribuera till Android

Notera: Go Mobile körs på samma arkitekturer som Go, vilket för närvarande innebär ARM-, ARM64-, 386- och amd64-enheter och emulatorer. Android på MIPS-enheter stöds inte ännu.

• Kör följande kommando för att generera en aar-fil som är lämplig att importera till Android-projekt:

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

• Starta Android Studio.
• Fil > Importera projekt… för att importera referensprojektet från $GOPATH/src/golang.org/x/mobile/example/bind/android.

• Bygg och distribuera applikationen till enheten.

App-modulen innehåller huvudapplikationen som åberopar hello.Greetings. När programmet startas uppdateras textvyn med det returnerade strängvärdet.

Om du inte använder Android Studio måste du, för att kunna arbeta med bindningar för Android, ha Android SDK installerat och miljövariabeln ANDROID_HOME inställd på SDK-sökvägen. Du måste också ha NDK installerat; det enklaste sättet är att köra SDK-kommandot sdkmanager ndk-bundle.

Alternativt, om du inte är bekant med Android-utveckling, och du inte vill ställa in alla nödvändiga miljöer (Android SDK, Gradle, etc.), kan du använda den här Dockerfilen för att bygga applikationen i Docker i stället.

Förresten, om du försöker lägga till yourmodule.aar i ditt eget projekt, efter att ha kopierat yourmodule.aar-filen och yourmodule.jar-filen till mappen ”android\app”, bör nedanstående redigering i filen ”android\app\build.gradle” göras för att din modul ska importeras korrekt.

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

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

Bygga och distribuera till iOS

Notera: target=ios kräver att värddatorn kör macOS.

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

Gomobile bind kommer att generera ett rampaket med namnet Hello.framework. Öppna exempelprojektet Xcode genom att köra kommandot nedan.

$ open ios/bind.xcodeproj

SläppHello.framework-paketet till Xcode-projektet. Markera ”Kopiera objekt vid behov” om du behöver en annan kopia av rampaketet i Xcode annars. Om du annars ändrar Go-paketets källkod och körgomobile bindpå nytt kommer hello.framework att uppdateras.

Om du bestämmer dig för att behålla Hello.framework i huvudkatalogen måste du lägga till huvudkatalogen till Framework Search Paths i målen Build Settings.

Din projektlayout bör se ut som nedan.

Bygg och kör det på simulatorn eller en verklig enhet (Cmd+R). När programmet startas kommer etiketten i huvudvyn att ändras med strängen som returneras från GoHelloGreetings som anropar funktionen hello.Greetings.

Notera att du även kan anropa GoHelloGreetings från Swift genom att importera Hello.

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

iOS-simulator

Sedan Go 1.5 fungerar endast darwin/amd64 på iOS-simulatorn. För att använda simulatorn måste du konfigurera Xcode så att det endast försöker köra 64-bitars binärer.

Xcode matchar bitbredden hos ARM-binärerna när de körs på X86-simulatorn. Det vill säga, om du konfigurerar Xcode för att bygga både 32-bitars och 64-bitars ARM binärer (standard), kommer den att försöka köra 32-bitars X86 binärer på simulatorn, vilket inte kommer att fungera med Go idag. Ändra Xcodes bygginställningar så att endast 64-bitars ARM binärer byggs och simulatorn kommer att köra amd64 binärfilen.