golang / go

O subrepositório Go mobile adiciona suporte para plataformas móveis (Android e iOS) e fornece ferramentas para construir aplicativos móveis.

Existem duas estratégias que você pode seguir para incluir Go na sua pilha móvel:

• Escrever aplicativos móveis nativos All-Go.
• Escrever aplicativos SDK gerando bindings a partir de um pacote Go e invocá-los a partir de Java (no Android) e Objective-C (no iOS).

Este artigo conterá guias passo-a-passo para explicar como alcançar estas estratégias.

• Ferramentas
• Aplicações nativas
  • Construir e implantar no Android
  • Construir e implantar no iOS
  • Icone da aplicação
• Aplicações SDK
  • Construindo e implantando no Android
  • Construindo e implantando no iOS
  • Simulador de iOS

Ferramentas

Nota: Você precisa ter Go 1.5 ou superior para instalar ferramentas móveis. (Ou pelo menos Go 1.7.4 se estiver usando macOS Sierra)

Go Mobile introduz uma nova ferramenta, gomobile,para ajudá-lo com a construção e o processo de ligação.

gomobile suporte Go Módulos agora! $ gomobile bind -v -o android.aar -target=android ./package sob o diretório do projeto funciona agora.

Em macOS, você precisará ter as Ferramentas de Linha de ComandoXcode instaladas.

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

(As seções seguintes irão ajudá-lo como usar a ferramenta gomobile.)

Aplicações nativas

A categoria nativa inclui aplicações inteiramente escritas em Go. Atualmente, thegolang.org/x/mobile contém apenas um pequeno conjunto de pacotes que focam:

• Controle e configuração de aplicativos
• Abertura ES 2 e ES 3 bindings
• Gestão de ativos
• Gestão de eventos
• Pacotes experimentais incluem bindings OpenAL, áudio, fonte, sprite e sensores de movimento

Existem vários exemplos de aplicativos nativos em golang.org/x/mobile/example. Vamos construir e implantar o exemplo básico tanto para um dispositivo Android e iOS.

Grab o aplicativo.

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

Construir e implantar para Android

Executar gomobile build para construir um APK Android.

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

ComandoBuild irá construir um APK chamado basic.apk.

Se um AndroidManifest.xml estiver definido no diretório do pacote, ele será adicionado à saída do APK. Caso contrário, um manifesto padrão é gerado.

Se você tiver o comando adb instalado na sua máquina, você pode usar gomobile install para construir e empurrar o APK para o seu dispositivo móvel.

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

Construir e distribuir para iOS

Executar gomobile build para construir o pacote como uma aplicação iOS.

Nota: target=ios requer a máquina host rodando macOS. Você precisa obter uma identidade de assinatura e baixar perfis de provisionamento para continuar.

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

O comando build irá construir um pacote de aplicativos, chamado basic.app.

Você pode implantar arquivos .app arrastando-os e soltando-os no dispositivo.

• No Xcode, abra a Janela > Devices.
• Selecione o dispositivo físico do painel esquerdo.
• Arraste e solte o arquivo .app para a seção “Installed Apps”.
• Cheque a opção “Copy items if needed”

Alternativamente, você pode desdobrar pacotes de aplicativos para o seu dispositivo iOS usando a ferramenta de linha de comando do utilitário ios-deploy. Use ios-deploy para empurrar o aplicativo para o seu dispositivo.

$ ios-deploy -b basic.app

Ícone de aplicativo

É possível definir um ícone de aplicativo criando assets/icon.png.

aplicativos SDK e gerando bindings

Nesta categoria, mostraremos como você pode usar um pacote Go em seu aplicativo Android ou iOS existente.

As vantagens de seguir esta estratégia:

• Você pode reutilizar um pacote Go de um aplicativo móvel sem fazer alterações significativas no seu aplicativo existente.
• Nos casos em que você deseja compartilhar uma base de código comum entre o seu aplicativo Android e iOS, você pode escrever a funcionalidade comum uma vez no Go e colá-los ao código específico da plataforma, invocando o pacote Go através de bindings.

As limitações atuais estão listadas abaixo.

• Apenas um subconjunto de tipos Go são suportados atualmente.
• Bindings de idioma têm uma sobrecarga de desempenho.
• Existem algumas limitações sobre como as APIs exportadas devem ficar devido às limitações do idioma de destino.

Utilizaremos o pacote de exemplo em golang.org/x/mobile/example/bind/hello para gerar bindings e invocar a função Greetings a partir de Java e Objective-C.

Grab o exemplo executando o comando abaixo.

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

Construir e implantar para Android

Nota: Go Mobile roda nas mesmas arquiteturas que Go, o que atualmente significa dispositivos e emuladores ARM, ARM64, 386 e amd64. Notavelmente, o Android em dispositivos MIPS ainda não é suportado.

• Executar o seguinte comando para gerar o arquivo aar que é adequado para importar em projetos Android:

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

• Launch Android Studio.
• Arquivo >Importar projeto… para importar o projeto de referência de $GOPATH/src/golang.org/x/mobile/example/bind/android.

• Build e implantar a aplicação para o dispositivo.

O módulo de aplicação contém a aplicação principal que invoca o hello.Greetings. Quando o aplicativo é iniciado, a visualização de texto é atualizada com o valor da string retornada.

Se você não estiver usando o Android Studio, para trabalhar com bindings para Android, você precisa ter o Android SDK instalado e a variável de ambiente ANDROID_HOME definida para o caminho do SDK. Você também precisa ter o NDK instalado; a maneira mais fácil é executar o comando SDK sdkmanager ndk-bundle.

Alternativamente, se você não está familiarizado com o desenvolvimento androide, e não deseja configurar todo o ambiente necessário (Android SDK, Gradle, etc), você pode usar este Dockerfile para construir o aplicativo no docker em vez disso.

Besides, se você tentar adicionar o yourmodule.aar em seu próprio projeto, depois de copiar o yourmodule.aar e o arquivo yourmodule.jar para a pasta “android\app”, abaixo da edição no arquivo “android\app\build.gradle” deve ser feita para que seu módulo seja importado corretamente.

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

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

Construindo e implantando em iOS

Nota: target=ios requer que a máquina host esteja rodando macOS.

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

Gomobile bind irá gerar um pacote de framework chamado Hello.framework. Abra o projeto Xcode de exemplo executando o comando abaixo.

$ open ios/bind.xcodeproj

Drag and drop the Hello.framework bundle to the Xcode project. Verifique “Copiar itens se necessário” se você precisa de uma cópia diferente do pacote de framework dentro do Xcode caso contrário. Caso contrário, modificar o código fonte do pacote Go e executar novamente gomobile bind irá atualizar o hello.framework.

Se você decidir manter Hello.framework no diretório principal você terá que adicionar o diretório principal no diretório Framework Search Paths nas Configurações de Compilação dos alvos.

>

>

Seu layout de projecto deve parecer-se com o que é mostrado abaixo.

Build e corrê-lo no simulador ou num dispositivo real (Cmd+R). Quando a aplicação é lançada, a etiqueta na vista principal será modificada com a string retornada de GoHelloGreetings que invoca o hello.Greetings function.

Nota que você também pode invocar GoHelloGreetings da Swift importando Hello.

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

iOS Simulator

As of Go 1.5, somente darwin/amd64 funciona no simulador iOS. Para usar o simulador, você precisa configurar o Xcode para tentar executar apenas binários de 64 bits.

Xcode combina com a largura de bit dos binários ARM quando rodando no simulador X86. Ou seja, se você configurar o Xcode para construir binários ARM de 32 e 64 bits (o padrão), ele tentará executar binários de 32 bits do X86 no simulador, o que não funcionará com Go hoje. Modifique as configurações do Xcode para compilar apenas binários ARM de 64 bits, e o simulador executará o binário amd64.