perlandroid - Online na nuvem

PROGRAMA:

NOME

perlandroid - Perl no Android

SINOPSE

As primeiras partes deste documento contêm instruções para compilar Perl para
Android 2.0 e posterior, usando os binários fornecidos pelo Google. A última parte
descreve como construir perl nativo usando um dos conjuntos de ferramentas disponíveis no Play
Armazenar.

DESCRIÇÃO

Este documento descreve como configurar seu ambiente host ao tentar construir Perl
para Android.

Compilação cruzada

Estas instruções assumem um ambiente de construção Unixish em seu sistema host; eles estiveram
testado em Linux e OS X, e pode funcionar em Cygwin e MSYS. Embora o Google também forneça um
NDK para Windows, essas etapas não funcionarão nativas lá, embora seja possível
compilação cruzada por meios diferentes.

Se a arquitetura do seu sistema host é de 32 bits, lembre-se de alterar o "x86_64" abaixo para
"x86". Em uma veia semelhante, os exemplos abaixo usam o conjunto de ferramentas 4.8; se você quiser usar
algo mais antigo ou mais recente (por exemplo, o conjunto de ferramentas 4.4.3 incluído na 8ª revisão do
o NDK), basta alterá-los para a versão relevante.

Get da Android Nativo Desenvolvimento estojo (NDK)
Você pode baixar o NDK em .
Você vai querer a versão normal, não legada.

Determinar da arquitetura você vai be compilação cruzada for
Existem três opções possíveis: arm-linux-androideabi para ARM, mipsel-linux-android para
MIPS e simplesmente x86 para x86. A partir de 2014, a maioria dos dispositivos Android rodam em ARM, então
geralmente uma aposta segura.

Com esses dois em mãos, você deve adicionar

$ ANDROID_NDK / toolchains / $ TARGETARCH-4.8 / prebuilt / `uname | tr '[AZ]' '[az]' `-x86_64 / bin

para seu PATH, onde $ ANDROID_NDK é o local onde você desempacotou o NDK, e
$ TARGETARCH é a arquitetura do seu alvo.

Conjunto up a autônoma toolchain
Isso cria um sysroot de trabalho que podemos alimentar para configurar mais tarde.

$ export ANDROID_TOOLCHAIN ​​= / tmp / my-toolchain- $ TARGETARCH
$ export SYSROOT = $ ANDROID_TOOLCHAIN ​​/ sysroot
$ $ ANDROID_NDK / build / tools / make-standalone-toolchain.sh \
--platform = android-9 \
--install-dir = $ ANDROID_TOOLCHAIN ​​\
--system = `uname | tr '[AZ]' '[az]' `-x86_64 \
--toolchain = $ TARGETARCH-4.8

adb or ssh?
adb é o Android Debug Bridge. Para nossos propósitos, é basicamente uma forma de estabelecer
uma conexão ssh a um dispositivo Android sem ter que instalar nada no dispositivo
em si, contanto que o dispositivo esteja na mesma rede local que o host ou
conectado ao host por meio de USB. Perl pode ser compilado de forma cruzada usando adb ou um
conexão ssh normal; em geral, se você pode conectar seu dispositivo ao host usando um dispositivo USB
porta, ou se você não quiser instalar um aplicativo sshd em seu dispositivo, você pode querer usar
adb, embora você possa ser forçado a mudar para ssh se o seu dispositivo não estiver enraizado e você
azar - mais sobre isso mais tarde. Alternativamente, se você estiver compilando para um emulador,
você terá que usar o adb.

adb

Para usar o adb, baixe o Android SDK em .
A versão "SDK Tools Only" deve ser suficiente - se você baixou o ADT Bundle, pode
encontre o SDK em $ ADT_BUNDLE / sdk /.

Adicione $ ANDROID_SDK / platform-tools ao seu PATH, que deve dar a você acesso ao adb. Você vai
agora tem que encontrar o nome do seu dispositivo usando 'dispositivos adb', e mais tarde passá-lo para Configurar
por meio de '-Dtargethost = $ DEVICE'.

No entanto, antes de chamar Configure, você precisa verificar se o uso de adb é uma escolha viável em
o primeiro lugar. Porque o Android não tem um / Tmp, nem permite executáveis ​​em
o cartão SD, precisamos encontrar algum lugar no dispositivo para configurar para colocar alguns arquivos, como
bem como para que os testes sejam executados. Se o seu dispositivo tiver root, então você está bem. Tente correr
estes:

$ export TARGETDIR = / mnt / asec / perl
$ adb -s $ DEVICE shell "echo sh -c '\" mkdir $ TARGETDIR \ "' | su -"

O que criará o diretório de que precisamos e você pode seguir para a próxima etapa. / mnt / asec
é montado como um tmpfs no Android, mas só pode ser acessado como root.

Se o seu dispositivo não tiver root, você ainda pode estar com sorte. Tente executar este:

$ export TARGETDIR = / data / local / tmp / perl
$ adb -s $ DEVICE shell "mkdir $ TARGETDIR"

Se o comando funcionar, você pode passar para a próxima etapa, mas cuidado: Você vai para remover da
anuário da da dispositivo uma vez Você e guarante que os mesmos estão feito! Diferentemente dos / mnt / asec, / data / local / tmp pode não
ter automaticamente lixo coletado uma vez Você fechar WOW! da telefone.

Se nenhum deles funcionar, você não poderá usar o adb para compilar com o seu dispositivo. Qualquer
tente fazer o root ou siga a rota ssh.

ssh

Para usar o ssh, você precisa instalar e executar um aplicativo sshd e configurá-lo corretamente. Existem
vários aplicativos pagos e gratuitos que fazem isso com bastante facilidade, então você deve ser capaz de identificar um
na loja. Lembre-se de que o Perl requer uma conexão sem senha, então configure um público
chave.

Observe que vários aplicativos vomitam no stderr toda vez que você se conecta, o que pode confundir
Configure. Você pode precisar fazer um monkeypatch na parte do Configure que cria 'run-ssh' para
faça com que ele descarte stderr.

Já que você está usando ssh, você terá que passar alguns argumentos extras para Configure:
-Dtargetrun = ssh -Dtargethost = $ TARGETHOST -Dtargetuser = $ TARGETUSER -Dtargetport = $ TARGETPORT

configurar e para além
Com todo o anterior feito, você agora está pronto para chamar o Configure.

Se estiver usando adb, uma linha de configuração "básica" terá a seguinte aparência:

$ ./Configure -des -Dusedevel -Dusecrosscompile -Dtargetrun = adb \
-Dcc = $ TARGETARCH-gcc \
-Dsysroot = $ SYSROOT \
-Dtargetdir = $ TARGETDIR \
-Dtargethost = $ DEVICE

Se estiver usando ssh, não é muito diferente - nós apenas mudamos targetrun para ssh e passamos
targetuser e targetport. Acaba ficando assim:

$ ./Configure -des -Dusedevel -Dusecrosscompile -Dtargetrun = ssh \
-Dcc = $ TARGETARCH-gcc \
-Dsysroot = $ SYSROOT \
-Dtargetdir = $ TARGETDIR \
-Dtargethost = "$ TARGETHOST" \
-Dtargetuser = $ TARGETUSER \
-Dtargetport = $ TARGETPORT

Agora você está pronto para executar o make e o teste!

Como uma palavra final de advertência, se você estiver usando o adb, o make test pode parecer travar; isto é
porque não produz nada até terminar de executar todos os testes. Você pode verificar seu
progresso fazendo login no dispositivo, movendo para $ TARGETDIR e olhando para o arquivo
saída.stdout.

Notas

· Se você está direcionando x86 para Android, você terá que alterar $ TARGETARCH-gcc para
i686-linux-android-gcc.

· Em alguns dispositivos mais antigos de baixo custo - pense no início da era 2.2 - alguns testes, particularmente
t / re / uniprops, pode travar o telefone, fazendo com que ele se desligue uma vez e depois volte
novamente.

Nativo constrói

Embora o Google não forneça um conjunto de ferramentas nativo para Android, você ainda pode obter um em
a Play Store; por exemplo, há o aplicativo CCTools que você pode obter gratuitamente. Mantenha
lembre-se de que deseja um conjunto de ferramentas completo; alguns aplicativos tendem a instalar por padrão apenas um
versão barebones sem alguns utilitários importantes, como ar ou nm.

Depois de ter o conjunto de ferramentas configurado corretamente, o único obstáculo restante é realmente
localizando onde no dispositivo foi instalado. Por exemplo, CCTools instala seu
conjunto de ferramentas em /data/data/com.pdaxrom.cctools/root/cctools. Com o caminho em mãos,
compilar perl é pouco mais do que:

export SYSROOT =
export LD_LIBRARY_PATH = "$ SYSROOT / lib:` pwd`: `pwd`/ lib: `pwd` / lib / auto: $ LD_LIBRARY_PATH"
sh Configure -des -Dsysroot = $ SYSROOT -Alibpth = "/ system / lib / vendor / lib"

Use perlandroid online usando serviços onworks.net