golang / go

Go mobile-underlageret tilføjer understøttelse for mobile platforme (Android og iOS) og indeholder værktøjer til at bygge mobile applikationer.

Der er to strategier, du kan følge for at inkludere Go i din mobile stak:

• Skrivning af mobile applikationer, der udelukkende er native Go-applikationer.
• Skrivning af SDK-applikationer ved at generere bindinger fra en Go-pakke og påkalde dem fra Java (på Android) og Objective-C (på iOS).

Denne artikel vil indeholde trinvise vejledninger for at forklare, hvordan man opnår disse strategier.

• Værktøjer
• Native applikationer
  • Bygning og udrulning til Android
  • Bygning og udrulning til iOS
  • App-ikon
• SDK-applikationer
  • Opbygning og implementering til Android
  • Opbygning og implementering til iOS
  • iOS Simulator

Værktøjer

Note: Du skal have Go 1.5 eller derover for at installere mobile værktøjer. (Eller mindst Go 1.7.4, hvis du bruger macOS Sierra)

Go Mobile introducerer et nyt værktøj, gomobile,til at hjælpe dig med opbygningen og bindingsprocessen.

gomobile understøtter Go Modules nu! $ gomobile bind -v -o android.aar -target=android ./package under projektmappen fungerer nu.

På macOS skal du haveXcode Command Line Tools installeret.

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

(De følgende afsnit hjælper dig med at bruge gomobile-værktøjet.)

Native applikationer

Den native kategori omfatter applikationer, der udelukkende er skrevet i Go. I øjeblikket er detgolang.org/x/mobile kun et lille sæt pakker, der fokuserer på:

• App-kontrol og konfiguration
• OpenGL ES 2- og ES 3-bindinger
• Asset management
• Event management
• Experimentelle pakker omfatter OpenAL-bindinger, lyd-, skrifttype-, sprite- og bevægelsessensorer

Der findes forskellige eksempler på native applikationer under golang.org/x/mobile/example. Vi vil bygge og distribuere det grundlæggende eksempel både til en Android- og iOS-enhed.

Grib programmet.

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

Opbygning og distribution til Android

Kør gomobile build for at bygge en Android APK.

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

Build-kommandoen opbygger en APK ved navn basic.apk.

Hvis der er defineret en AndroidManifest.xml i pakkemappen, tilføjes den til APK-uddatoen. Ellers genereres et standardmanifest.

Hvis du har adb-kommandoen installeret på din maskine, kan du bruge gomobile install til at bygge og skubbe APK’en til din mobilenhed.

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

Opbygning og udrulning til iOS

Kør gomobile build for at bygge pakken som et iOS-program.

Bemærk: target=ios kræver, at værtsmaskinen kører macOS. Du skal indhente en signeringsidentitet og downloade provisioneringsprofiler for at kunne fortsætte.

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

Bygningskommandoen bygger en programpakke med navnet basic.app.

Du kan distribuere .app-filer ved at trække og slippe dem til enheden.

• I Xcode skal du åbne Vindue > Enheder i Xcode.
• Vælg den fysiske enhed i venstre rude.
• Træk og slip .app-filen til afsnittet “Installerede apps”.
• Kontroller indstillingen “Copy items if needed”

Alternativt kan du distribuere programbundler til din iOS-enhed ved hjælp af kommandolinjeværktøjet ios-deploy utility. Brug ios-deploy til at skubbe programmet til din enhed.

$ ios-deploy -b basic.app

App-ikon

Det er muligt at indstille et app-ikon ved at oprette assets/icon.png.

SDK-programmer og generere bindinger

I denne kategori vil vi vise dig, hvordan du kan bruge en Go-pakke idin eksisterende Android- eller iOS-applikation.

Fordelene ved at følge denne strategi:

• Du kan genbruge en Go-pakke fra en mobilapplikation uden at foretage væsentlige ændringer i din eksisterende applikation.
• I tilfælde, hvor du ønsker at dele en fælles kodebase mellem din Android- og iOS-applikation, kan du skrive den fælles funktionalitet én gang i Go og lime dem til den platformsspecifikke kode ved at påkalde Go-pakken gennem bindinger.

De nuværende begrænsninger er anført nedenfor.

• Kun en delmængde af Go-typer understøttes i øjeblikket.
• Sprogbindinger har et ydelsesmæssigt overhead.
• Der er nogle få begrænsninger på, hvordan de eksporterede API’er skal se ud på grund af begrænsninger i målsproget.

Vi vil bruge eksempelpakken under golang.org/x/mobile/example/bind/hello til at generere bindinger og påkalde Greetings-funktionen fra Java og Objective-C.

Grib eksemplet ved at køre kommandoen nedenfor.

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

Opbygning og udrulning til Android

Bemærk: Go Mobile kører på de samme arkitekturer som Go, hvilket i øjeblikket betyder ARM-, ARM64-, 386- og amd64-enheder og emulatorer. Især Android på MIPS-enheder understøttes endnu ikke.

• Kør følgende kommando for at generere aar-filen, der er egnet til import i Android-projekter:

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

• Lancér Android Studio.
• Fil > Import Project… for at importere referenceprojektet fra $GOPATH/src/golang.org/x/mobile/example/bind/android.

• Byg og implementer applikationen til enheden.

App-modulet indeholder hovedapplikationen, der påkalder hello.Greetings. Når programmet startes, opdateres tekstvisningen med den returnerede strengværdi.

Hvis du ikke bruger Android Studio, skal du for at kunne arbejde med bindinger til Android have Android SDK installeret og ANDROID_HOME-miljøvariablen indstillet til SDK-stien. Du skal også have NDK installeret; den nemmeste måde er at køre SDK-kommandoen sdkmanager ndk-bundle.

Alternativt, hvis du ikke er bekendt med Android-udvikling, og du ikke ønsker at opsætte alle de nødvendige miljøer (Android SDK, Gradle osv.), kan du bruge denne Dockerfil til at bygge programmet i docker i stedet.

Hvis du forsøger at tilføje dinmodule.aar i dit eget projekt, efter at du har kopieret dinmodule.aar-filen og filen yourmodule.jar til mappen “android\app”, skal nedenstående redigering i filen “android\app\build.gradle” udføres for at få dit modul importeret korrekt.

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

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

Opbygning og udrulning til iOS

Bemærk: target=ios kræver, at værtsmaskinen kører macOS.

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

Gomobile bind vil generere et framework bundle kaldet Hello.framework. Åbn eksempelprojektet Xcode-projektet ved at køre nedenstående kommando.

$ open ios/bind.xcodeproj

Træk og slipHello.framework-bundlen til Xcode-projektet. Marker “Copy items if needed”, hvis du ellers har brug for en anden kopi af framework bundle i Xcode. Ellers vil ændring af Go-pakkens kildekode og genudførelse afgomobile bindopdatere hello.framework.

Hvis du beslutter dig for at beholde Hello.framework i hovedmappen, skal du tilføje hovedmappen til Framework Search Paths i målene Byggeindstillinger.

Din projektlayout skal se ud som vist nedenfor.

Byg og kør det på simulatoren eller en faktisk enhed (Cmd+R). Når programmet startes, ændres etiketten på hovedvisningen med den streng, der returneres fra GoHelloGreetings, som påkalder hello.Greetings-funktionen.

Bemærk, at du også kan påkalde GoHelloGreetings fra Swift ved at importere Hello.

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

iOS-simulator

Som i Go 1.5 fungerer kun darwin/amd64 på iOS-simulatoren. Hvis du vil bruge simulatoren, skal du konfigurere Xcode til kun at forsøge at køre 64-bit binære filer.

Xcode matcher bitbredden for ARM-binære filer, når de kører på X86-simulatoren. Det vil sige, at hvis du konfigurerer Xcode til at bygge både 32-bit og 64-bit ARM-binærfiler (standard), vil den forsøge at køre 32-bit X86-binærfiler på simulatoren, hvilket ikke fungerer med Go i dag. Hvis du ændrer Xcode-bygningsindstillingerne til kun at bygge 64-bit ARM-binærfiler, vil simulatoren køre amd64-binærfilen.