CanalQb - Python - Criando Py para APK - Tutorial do Inicio Até o FIM (#Windows, #WSL, #Python 3.8, #Buildozer, #Kivy)

---

@CanalQb que Youtube 

---

---

CanalQb - Criando Py para APK Tutorial do Inicio Até o FIM (#Windows, #WSL, #Python 3.8, #Buildozer, #Kivy)

---

---

Sempre crie uma frase de segurança única para jogos, Airdrops e qualquer outra coisa de origem desconhecida, em vez de usar sua carteira principal.

---

Procedimentos passo a passo para converter seu script.py para seu aplicativo.apk

Fala galera, hoje vou apresentar para vocês, meu processo de conversão de script para aplicativo para você distribuir seus aplicativos.

Este procedimento é apenas para converter o Script.py para o arquivo.APK.

Sistemas de certificados para Play Store, e Apple Store, ficam de fora.

Requerimentos:

• Windows PRO.
• Paciencia para maquinas antigas.
• CMD ou PowerShell (Prefira PS em modo Admin)

Se quiser arriscar no Google Colab, segue o Script para usar: https://bit.ly/4dQFBGN

Instale no seu Windows 10 ou 11, os recursos (Hyper-V, Plataforma de Máquina Virtual, Subsistema do Windows para Linux), reinicie seu computador, assim que finalizado.

Se tiver dificuldade de localizar os recursos do Windows, você pode usar o PowerShell, para você quem cria script para reconfigurar a maquina automaticamente, pode usar estes comandos também:

dism.exe /Online /Enable-Feature /FeatureName:Microsoft-Windows-Subsystem-Linux /All

dism.exe /Online /Enable-Feature /FeatureName:VirtualMachinePlatform /All

dism.exe /Online /Enable-Feature /FeatureName:Hyper-V /All

Assim que concluido reinicie o computador.

Proximo passo é instalar o WSL de forma correta.

Este é o comando para instalar o WSL2, só vou deixar aqui por curiosidade:

Mesmo informando maior compatibilidade e desempenho, isso é apenas para maquinas depois da 8 geração.

Invoke-WebRequest -Uri https://aka.ms/wsl2kernel -OutFile wsl_update_x64.msi

Start-Process msiexec.exe -ArgumentList '/i wsl_update_x64.msi /quiet /norestart' -NoNewWindow -Wait

Definir o WSL 2 como padrão:

wsl --set-default-version 2

Definir o WSL 1 como padrão:

wsl --set-default-version 1

Mas como informado o WSL deste tutorial, será o WSL1

Instalando o WSL 1

Abra o PowerShell(ps) ou prompt de comando (cmd), digite:

wsl --install

Se caso não acontecer nada após reinicio, volte para o PowerShell ou cmd e digite novamente wsl --install.

Pronto agora está instalado.

Se quiser outra distribuição, basta fazer:

wsl --list --online

Se desejar outra distribuição Linux apenas escolha no nome pelos dados da esquerda.

wsl --install -d Ubuntu-18.04

Processo de instalação concluido, vamos instalar o que é preciso agora (em uma reinstalação nem sempre irá pedir para reiniciar).

Ao reniciar deve aparecer a tela:

Quando este processo terminar, ele vai pedir login e senha (a senha não é *, ela não digita nada, é oculta ou invisivel, coisa de linux).

Se tudo corret bem, a tela será essa.

Para acessar o Linux, você pode usar o comando WSL tanto no PowerShell quanto no Prompt (CMD)

Digite: WSL

Instalando os aplicativos e módulos necessários

Atualize os repositórios:

sudo apt update -y
sudo apt upgrade -y

Configurando o repositório e instalando do Clang:

sudo add-apt-repository ppa:ubuntu-toolchain-r/ppa -y

sudo apt-get install clang -y

Configurando o repositório do Clang-14 e Clang++-14

sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y

sudo apt update && sudo apt upgrade -y

wget https://apt.llvm.org/llvm.sh

chmod +x llvm.sh

sudo ./llvm.sh 14

sudo apt install clang-14 clang++-14 -y

Criando o atalho (links simbólico) para o Clang-14 e Clang++-14:

sudo ln -sf /usr/bin/clang-14 /usr/bin/clang
sudo ln -sf /usr/bin/clang++-14 /usr/bin/clang++
clang --version
clang++ --version

clang --version e clang++ --version, e ambos mostram "Ubuntu clang version 14.0.6", isso indica que as versões corretas estão ativas e funcionando como esperado.
 

Atualizar alternativas (se necessário)

Se preferir usar update-alternatives, siga estes passos novamente para garantir que as versões estejam configuradas corretamente:

sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-14 100 

sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-14 100

Se previsar voltar ao clang antigo

sudo update-alternatives --config clang 

sudo update-alternatives --config clang++

 Instalar dependencias do Linux para o Python3

sudo apt-get install --reinstall distro-info-data libc6 ubuntu-dev-tools shunit2 libsdl2-dev -y

Instalar o Ccache

O ccache é uma ferramenta que pode ajudar a acelerar o processo de compilação, armazenando em cache os resultados das compilações anteriores. 

sudo apt install ccache

ccache --version

Verificar o Uso do ccache

ccache -s

Quando você for editar o buildozer.spec inclua a linha

# (bool) use ccache to cache compiled files

ccache = True

O uso do ccache pode reduzir significativamente o tempo de compilação, especialmente se você estiver trabalhando em um projeto onde faz muitas compilações.

Instalar o Python 3.8

Configurando o repositório do Python 3.8:

sudo apt install software-properties-common -y

sudo apt list --upgradable software-properties-common 

sudo add-apt-repository ppa:deadsnakes/ppa -y

Atualize a inclusão do repositório:

sudo apt update -y

Instalando o Python 3.8 e suas dependencias:

sudo apt-get install python3.8 -y 

sudo apt-get install -y python3.8 python3.8-dev python3.8-distutils python3.8-venv -y

Instalando o PIP:

sudo apt install -y python-pip 

sudo apt install -y python3-pip 

sudo apt install -y python3-setuptools 

sudo apt install -y python3-wheel 

sudo apt install -y python3-venv

Para garantir o vinculo do pip no python 3.8

python3.8 -m pip install --upgrade pip 

Criando o atalho (links simbólico) para o Python e o PIP:

sudo rm /usr/bin/python
sudo ln -s /usr/bin/python3.8 /usr/bin/python

Precisa corrigir o pip que ainda está para o 3.6

pip --version

pip --version

Agora vamos criar o atalho para o PIP:

find ~/.local/bin -name "pip*"

sudo rm /usr/local/bin/pip

sudo ln -s /home/qb/.local/bin/pip3.8 /usr/local/bin/pip

pip --version

Verifique quais Python's você tem instalado na sua maquina.

ls /usr/bin/python*

 Deixando o Python 3.8 como padrão no Linux:

sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.6 1

sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.8 2

sudo update-alternatives --config python

 

Testando pra ver se está tudo bem:

Mostrar o Python do Linux padrão: 

python3 -V |  pip3 -V

Mostrar o Python 3.8 definido por você: 

python --version | pip --version

Atualize:

sudo apt update -y

Instalando e atualizando dependencias padrões dos módulos:

python -m pip install --user --upgrade wheel

python -m pip install --user testresources 

python -m pip install --user --upgrade setuptools pip

python3 -m pip install --user --upgrade wheel

python3 -m pip install --user --upgrade setuptools pip 

python3 -m pip install --user testresources 

É provavel que um ou mais alertas ao instalar os 2 módulos acima, não é um erro que afete algo, mas para corrigir use a sequencia abaixo.

sudo apt remove --purge distro-info-data -y

sudo apt dist-upgrade -y 

sudo apt install aptitude -y

sudo aptitude install distro-info -y

Exemplo depois de corrigir:

Preparando o Python 3.8 Ubuntu 18.04 para rodar o Buildozer e Kivy

No linux:

sudo apt install -y git zip unzip openjdk-8-jdk python3-pip openssl autoconf libtool pkg-config zlib1g-dev libncurses5-dev libncursesw5-dev libtinfo5 cmake libffi-dev libssl-dev build-essential libpng-dev libjpeg-dev libtiff-dev libwebp-dev automake lld gradle openjdk-11-jdk openjdk-17-jdk ant ccache g++ gcc lbzip2 make patch python3 python3-dev python3-venv sudo wget xclip xsel libmtdev1

Validar Gradle (Se instalar o Gradle vai ter de usar jdk17 e Python superior ao 3.11)
Gradle é uma ferramenta de automação de construção (build automation tool) que é usada principalmente em projetos de software

sudo apt install gradle
gradle  -v 

Dependendo dos modulos do seu Script, você deve usar o jdk8 ou o jdk11 ou o jdk17

sudo update-alternatives --config java
java -version

No Python: 

pip install --upgrade pexpect

pip install --user sh

pip install PySDL2

pip install pep517==0.6.0

pip install python-for-android

pip install buildozer 

pip install --user --upgrade buildozer Cython==0.29.33 virtualenv

pip install --user https://github.com/kivy/buildozer/archive/master.zip 

python3 -m pip install cython

pip install bit 

pip install kivy 

pip install firebase_admin 

python3 -m pip install --upgrade buildozer python-for-android

pip install --upgrade pyOpenSSL cryptography

pip install --upgrade buildozer

pip install https://github.com/kivy/buildozer/archive/master.zip 

pip install pysdl2 pysdl2-dll 

Durante a instalação destes módulos, será pedido para incluir o caminho no PATH, vamos fazer isso mais a frente.

Talvez isso ajude a normalizar alguns problemas com python-for-android

pip uninstall python-for-android

pip install "sh<2.0"

pip install git+https://github.com/kivy/python-for-android.git

Configuração do Git e clonagem do repositório:

git config --global http.postBuffer 524288000 

git clone --depth 1 https://github.com/libjxl/libjxl.git /tmp/libjxl

sudo mv /tmp/libjxl /usr/local/sbin/

Verificar se tudo correu bem:

ls /usr/local/sbin/libjxl

Configurando os PATH's para funcionar corretamente:

sudo nano ~/.bashrc

export PATH=$PATH:$HOME/.local/bin:/usr/local/lib/python3.8/bin:/usr/local/sbin::/usr/local/lib/libjxl

export PYTHON=/usr/bin/python3.8

export PKG_CONFIG_PATH=/usr/lib/x86_64-linux-gnu/pkgconfig:$PKG_CONFIG_PATH

export CC="ccache gcc"

export CXX="ccache g++"

Salvar (CTRL+O) Sair (CTRL+X)

Execute para atualizar os PATH's

source ~/.bashrc

Usando o Buildozer

Abra a pasta onde está seu script.py (dica mantenha seu script.py inicial como main.py)

Configure um Icone para seu novo APK, no meu caso icon.png (no meu caso o icone está em 64x64px).

Agora dentro do banco, vamos iniciar o Buildozer para criar o primeiro buildozer.spec

Abra seu WSL vá até o caminho onde está seu arquivo, para acessar suas unidades faça:

cd /mnt

Digite ls para mostrar as unidades

Estou com meus arquivos no caminho Windows C:\Users\Qb\Desktop\kivy então vou escrever diretamente, não importando onde eu esteja:

cd /mnt/c/users/qb/Desktop/kivy

Iniciar um novo projeto:
Execute este comando quando você estiver começando um novo projeto. Ele cria um arquivo buildozer.spec, que contém todas as configurações do seu projeto, como dependências, informações do aplicativo e opções de compilação.

buildozer init

Link do buildozer.spec: https://bit.ly/3NbkHap

Nota, as configurações do Buildozer não permitem nome de pastas ou arquivos com espaço:

Nome da pasta: "CanalQb Puzzle" está errado e irá dar erro.

Nome de arquivo: "CanalQb Puzzle.py" está errado e irá dar erro.

Nome da pasta: "CanalQb_Puzzle", o _ resolve este problema.

Nome de arquivo: "CanalQb_Puzzle.py" o _ resolve este problema.

Para definir qual versão de Python o buildozer vai usar, inclua e modifique as duas linhas

Incluir: python = /usr/bin/python3.8 (possibilidade de erro)

e em requerimentos inclua a versão que deseja que o APK contenha "requirements = python3==3.8.0"

Dica importante, por padrão o Buildozer instala o hostpython3, mas ele depende exclusivamente do Python-3.11.5 em diante, isso pode causar problemas. 

Para burlar este problema, insira em requerimentos o hostpython3crystax no buildozer.spec

Arquitetura de celulares Android

Arquiteturas vs. Versões do Android:

Arquiteturas: armeabi-v7a (32 bits) e arm64-v8a (64 bits) referem-se ao conjunto de instruções do processador. Dispositivos com processadores que suportam arm64-v8a podem rodar aplicativos de 32 bits (armeabi-v7a) e 64 bits.

Versões do Android: Diferentes versões do Android podem ser executadas em dispositivos com diferentes arquiteturas. Por exemplo, Android 9 (Pie) pode ser executado em dispositivos com arquitetura 32 bits ou 64 bits.

Compatibilidade:

Dispositivos mais novos (geralmente lançados após 2015) tendem a suportar a arquitetura arm64-v8a e podem executar versões mais recentes do Android.

Dispositivos mais antigos frequentemente utilizam armeabi-v7a, mas ainda podem rodar versões mais novas do Android, dependendo da compatibilidade do fabricante.

Exceções:

Existem dispositivos que podem ter versões mais antigas do Android, mas ainda utilizam processadores 64 bits e, portanto, suportam arm64-v8a. O inverso também é verdade: dispositivos com Android mais recente podem ainda utilizar processadores 32 bits.

Editando o buildozer.spec

[app]

Nome do seu aplicaivo, pode ter espaço

title = CanalQb Puzzle 67 

Nome do pacote para instalação, não pode ter espaço

package.name = canalqbpuzzle # (str) Nome do pacote

nome do dominio que você irá usar para registrar no Google e/ou Apple, mesmo assim precisa informar.

package.domain = org.canalqb

# (str) Diretório onde o main.py está localizado

source.dir = .

# (list) Arquivos de origem a serem incluídos (deixe vazio para incluir todos os arquivos)

# source.include_exts = py,png,jpg,kv,atlas

source.include_exts = py,png

# (str) Versionamento da aplicação

version = 0.1

# (list) Requisitos da aplicação, nunca coloque modulos que já exista no python.

 # Correto:

requirements = python3==3.8.0,kivy,kivymd,firebase-admin,requests,bit,plyer,pyjnius,jnius

 # Errado, o Buildozer vai apresentar erro, informando que não irá tentar instalar modulos padrões do python

# requirements = python3==3.8.0,kivy,kivymd,firebase-admin,requests,bit,plyer,pyjnius,jnius, webbrowser, random, hashlib

# (str) Ícone da aplicação

icon.filename = %(source.dir)s/icon.png

# (list) Orientações suportadas

orientation = portrait

# (list) Permissões

android.permissions = INTERNET, WRITE_EXTERNAL_STORAGE, READ_EXTERNAL_STORAGE

# (list) As arquiteturas Android para construir (use para o Android 5.1 armeabi)

# android.archs = arm64-v8a, armeabi-v7a

android.archs = armeabi, armeabi-v7a, arm64-v8a

# (bool) Habilitar o recurso de backup automático do Android (API >=23)

android.allow_backup = True

[buildozer]

# (int) Nível de log (0 = apenas erros, 1 = informações, 2 = debug (com saída de comando))

log_level = 2

# (int) Exibir aviso se o buildozer for executado como root (0 = Falso, 1 = Verdadeiro)

warn_on_root = 1

# (int) API do Android a ser usada

android.api = 22

# (int) API mínima do Android

android.minapi = 22

# (int) API alvo do Android

android.target = 31  # Por exemplo, Android 12 (API 31)

# (int) Ativar o modo de depuração

android.debug = 1

# (str) Versão do NDK a ser usada

android.ndk = 21b

# (str) Python version to use 

python_version = 3.8 

Explicações dos 5 ultimos: 

1. android.api => # (int) API do Android a ser usada

android.api = 22

Descrição: Esta configuração define a versão da API do Android que o seu aplicativo usará. A API 22 corresponde ao Android 5.1 (Lollipop).

Importância: É a versão da API que permite que você utilize recursos e funções disponíveis nessa versão. Se você definir uma versão muito antiga, pode não ter acesso a novos recursos.

2. android.minapi => # (int) API mínima do Android

android.minapi = 22

Descrição: Este parâmetro especifica a versão mínima da API do Android que seu aplicativo suporta. Com a API mínima definida como 22, seu aplicativo só poderá ser instalado em dispositivos que executam Android 5.1 ou superior.

Importância: Isso garante que o seu aplicativo funcione em dispositivos com versões compatíveis da API. Se um usuário tentar instalar o aplicativo em um dispositivo com uma versão anterior à especificada, a instalação será bloqueada.

3. android.target => # (int) API alvo do Android

android.target = 31  # Por exemplo, Android 12 (API 31)

Descrição: Define a versão da API que você está visando durante o desenvolvimento. Neste caso, a API 31 corresponde ao Android 12.

Importância: O target indica que você está desenvolvendo seu aplicativo para funcionar melhor nessa versão, mas ainda pode ser executado em versões anteriores que atendem ao minapi. Essa configuração é útil para tirar proveito de recursos mais recentes da plataforma.

4. android.debug => # (int) Ativar o modo de depuração

android.debug = 1

Descrição: Este parâmetro ativa ou desativa o modo de depuração para o aplicativo. Se definido como 1, o aplicativo será compilado com informações de depuração.

Importância: O modo de depuração é útil durante o desenvolvimento, pois permite que você teste e depure seu aplicativo com mais facilidade. Entretanto, para a versão de produção, é recomendado desativá-lo (android.debug = 0).

5. android.ndk => # (str) Versão do NDK a ser usada

android.ndk = 21b

Descrição: Esta configuração especifica a versão do Android NDK (Native Development Kit) que deve ser utilizada. A versão 21b refere-se a uma versão específica do NDK.

Importância: O NDK é usado para compilar código nativo, geralmente em C ou C++. A versão escolhida pode influenciar a compatibilidade do seu aplicativo com diferentes dispositivos Android e seu acesso a bibliotecas nativas.

 

A versão do Kivy que é compatível com a API 22 do Android (que corresponde ao Android 5.1) geralmente varia dependendo das atualizações e melhorias que ocorrem ao longo do tempo. No entanto, versões mais antigas do Kivy, como a 1.10.x ou 1.11.x, tendem a ser compatíveis com essa API.

Recomendações

Kivy 2.0 e superiores: A partir do Kivy 2.0, muitos recursos novos foram adicionados, mas ele deve ser compatível com APIs mais antigas, incluindo a 22. No entanto, para garantir a melhor compatibilidade, pode ser prudente usar versões estáveis mais antigas se você encontrar problemas.

Kivy

Android 4.4 (KitKat): kivy==1.10.1

Android 5.0 (Lollipop): kivy==1.11.1

Android 5.1 (Lollipop): kivy==1.11.1

Android 6.0 (Marshmallow): kivy==1.11.1 ou kivy==1.12.0

Android 7.0 (Nougat): kivy==1.11.1 ou kivy==1.12.0

Android 8.0 (Oreo): kivy==1.11.1 até kivy==2.0.0

Android 9.0 (Pie): kivy==1.11.1 até kivy==2.0.0

Android 10 e superiores: kivy==2.0.0 ou versões mais recentes (como kivy==2.1.0)

KivyMD

Compatível com Kivy 1.10.1: kivymd==0.1.0 até kivymd==0.4.0

Compatível com Kivy 1.11.1: kivymd==0.4.0 até kivymd==0.5.0

Compatível com Kivy 1.12.0 e superiores: kivymd==0.5.0 até kivymd==1.0.0

Recomendações Gerais

Atualizações: Sempre verifique as notas de versão e a documentação do Kivy e KivyMD para garantir a compatibilidade e quaisquer dependências que possam ser necessárias.

Testes em dispositivos reais: Teste seu aplicativo em dispositivos Android reais para verificar a compatibilidade e o desempenho.

Testes: A melhor maneira de garantir a compatibilidade é testá-lo no seu dispositivo ou em um emulador que roda Android 5.1 com a versão desejada do Kivy.

Documentação: Sempre consulte a documentação do Kivy e as notas de versão para verificar a compatibilidade e as mudanças introduzidas em cada versão.

Exemplo de especificação de versão no buildozer.spec

Se você decidir usar uma versão específica do Kivy, você pode especificar isso no seu arquivo buildozer.spec:

Exemplos: 
requirements = kivy==2.1.0,kivymd==1.0.0,python3==3.8.0,kivy_garden
requirements = python3==3.8.0,kivy==1.11.1,kivymd

Isso garantirá que a versão correta do Kivy seja instalada durante o processo de construção. Se você encontrar problemas, não hesite em perguntar!

Iniciando o Projeto APK:

Atualizar dependencias de projeto:

Este comando é usado para atualizar as dependências do seu projeto Android. Quando você o executa, o Buildozer verifica se há atualizações para os pacotes do Android SDK, NDK, e outras ferramentas necessárias para a construção do seu aplicativo.

buildozer android update

Construir para Android

Após configurar seu projeto no arquivo buildozer.spec, use este comando para compilar seu aplicativo em um APK (Android Package) em modo de depuração. O -v ativa o modo verboso, o que significa que você verá mais detalhes do processo de construção. Isso é útil para identificar erros e entender o que está acontecendo.

buildozer -v android debug

Dica: Medir o tempo de criação:

{ time buildozer -v android debug; } 2> build_time.txt 

Executar o APK no dispositivo

Depois que o APK for construído, você pode usar este comando para instalar o APK no seu dispositivo Android conectado (via USB) e iniciar o aplicativo automaticamente. Isso é especialmente útil durante o desenvolvimento, pois permite que você veja as mudanças rapidamente.

buildozer android deploy run

Limpar build anterior, bom para caso der erro no buildozer

Use este comando se você encontrar problemas durante a construção ou se quiser garantir que a construção comece do zero, sem utilizar arquivos ou caches de construções anteriores. Isso pode ajudar a resolver conflitos ou problemas que surgiram devido a mudanças nas dependências ou no código.

buildozer android clean

rm -rf ~/.buildozer/android/platform/python-for-android

Ver logs

Depois de executar seu aplicativo no dispositivo, você pode usar este comando para ver os logs do Android (logcat). Isso é útil para depuração, pois você pode ver mensagens de erro, exceções e outras saídas do seu aplicativo em tempo real.

buildozer android logcat

Resumo dos Fluxos de Trabalho

Iniciar um novo projeto: Crie a estrutura do projeto com buildozer init.

Configurar o projeto: Edite o arquivo buildozer.spec para definir dependências e configurações.

Construir o APK: Use buildozer -v android debug para compilar o aplicativo.

Instalar e executar no dispositivo: Use buildozer android deploy run para instalar e rodar o aplicativo.

Depurar: Utilize buildozer android logcat para ver os logs enquanto seu aplicativo está em execução.

Limpar builds antigos, se necessário: Se houver problemas, use buildozer android clean para começar de novo.

Configuração do SSH:

Vamos instalar o SSH, bom no meu caso é para que eu possa acessar dados especificos no Linux, mas o contrario funciona tranquilamente, todas suas unidades já estão configuradas dentro do /mnt/

sudo apt install openssh-server

Configuração do arquivo de configuração do SSH:

sudo nano /etc/ssh/sshd_config

Modifique as linhas para, se existir #, remova o # pois representa comentários:

PermitRootLogin no (pode ser que não exista)

PasswordAuthentication yes

ChallengeResponseAuthentication no

Salvar CTRL + O, Sair CTRL + X

Agora execute:

sudo ssh-keygen -A 

sudo systemctl start ssh

sudo systemctl enable ssh

sudo systemctl restart ssh

sudo systemctl status ssh

O Uso do ADB

ADB para acompanhar os erros do APK no seu celular, você vai precisar instalar platform-tools

Link para download: https://developer.android.com/tools/releases/platform-tools?hl=pt-br descompacte para o c:

Se você tiver dificuldade de acessar o ADB no WSL, você pode usar o ADB do Windows em seus projetos dentro do WSL, aprenda a usar: https://bit.ly/4evN9zz

Insira o caminho no PATH do Windows.

Para o WSL use sudo apt install android-tools-adb, mas não funcionou diretamente comigo.

Alguns comandos basico para o ADB

Se você tiver um ou mais ADB vai usar estes comandos aqui

1. adb start-server

Inicia o servidor ADB. Este comando é necessário para permitir que você se conecte a dispositivos Android via ADB.

2. adb devices

Lista todos os dispositivos conectados e em execução com o ADB. Mostra quais dispositivos estão prontos para serem utilizados.

3. adb logcat

Exibe o log de sistema em tempo real. É usado para visualizar as mensagens de log do dispositivo Android, que podem incluir informações de erro, avisos e mensagens de depuração.

4. adb logcat | findstr com.seupacote

Exibe o log de sistema filtrando as mensagens que contêm "com.seupacote". O comando findstr é utilizado para buscar por uma string específica nas mensagens de log.

5. adb logcat *:E

Exibe somente as mensagens de erro (level "E") do log de sistema. O asterisco (*) indica que o filtro é aplicado a todos os componentes.

6. adb logcat *:W

Exibe somente as mensagens de aviso (level "W") do log de sistema. Similar ao anterior, mas aqui estamos focando em avisos.

7. adb logcat | findstr PythonActivity

Exibe o log de sistema filtrando as mensagens que contêm "PythonActivity". Útil para depurar uma atividade específica relacionada a Python.

8. adb logcat > logs.txt

Redireciona todo o log de sistema para um arquivo chamado logs.txt. Isso é útil para análise posterior dos logs.

9. adb -s emulator-5554 install seu_apk.apk

Instala o APK especificado (seu_apk.apk) no emulador identificado por emulator-5554. O parâmetro -s permite especificar qual dispositivo usar se houver mais de um conectado.

10. adb logcat *:E | findstr org.canalqb

Exibe apenas as mensagens de erro do log de sistema filtradas pela string "org.canalqb". Isso ajuda a focar em erros relacionados a esse pacote específico.

11. No Linux: adb logcat | grep python No Windows: adb logcat | findstr python

Exibe o log de sistema filtrando mensagens que contêm "python". O grep é uma ferramenta de busca usada em sistemas Unix, semelhante ao findstr.

12. adb logcat | grep com.seupacote

Exibe o log de sistema filtrando mensagens que contêm "com.seupacote". Também utiliza grep para filtrar o log por um pacote específico.

13. adb kill-server

Para o servidor ADB. É usado quando você deseja encerrar a sessão do ADB ou quando está tendo problemas de conexão e precisa reiniciar o servidor. 

Uso do ADB no WSL (Não recomendo)

O Android Debug Bridge (ADB) pode ser usado no WSL (Windows Subsystem for Linux) e no Windows simultaneamente, mas há algumas considerações e passos a seguir para garantir que funcione corretamente. Aqui estão os detalhes:

Instalação do ADB:
Primeiro, você precisa ter o ADB instalado no WSL. Se você não tiver, você pode instalá-lo com o seguinte comando:

sudo apt update

sudo apt install android-tools-adb

Conectando um Dispositivo:
Conecte seu dispositivo Android ao computador via USB. Você pode verificar se o dispositivo está reconhecido pelo ADB usando:

adb devices

Verificando a Conexão:
Após conectar o dispositivo, execute o seguinte comando no WSL:

adb devices

Isso deve listar seu dispositivo, indicando que ele está conectado corretamente.

O Tutorial termina aqui, abaixo algumas opções que você pode usar ou não

Desinstalar o WSL

Se você não sabe ou não lembra quantas versões linux você possui, use o comando:

wsl --list --verbose

Note na imagem acima que ele retorna o nome de um linux que está instalado no Windows. 

Agora vamos ao comando para desisntalar

wsl --unregister <NomeDaDistribuição>

Use o comando acima e subistitua para o nome do Linux que você escolher da lista, vai ficar assim:

wsl --unregister Ubuntu-18.04

Agora use o comando no PowerShell modo admin

dism.exe /Online /Disable-Feature /FeatureName:Microsoft-Windows-Subsystem-Linux

Para verificar se sobrou residuos da imagem iso do WSL abra os caminhos abaixo:

%USERPROFILE%\AppData\Local\Packages

Procure por pastas que comecem com o nome da distribuição ou Canonical.

%LOCALAPPDATA%\Microsoft\WindowsApps

Pode conter links para executáveis das distribuições ou Canonical.

  

5. Baixar e Configurar o Android SDK (opcional)

Para configurar o Android SDK, baixe e descompacte em C:\platform-tools, e adicione ao seu PATH:

export PATH="$PATH:/home/$USER/.local/bin:/usr/local/lib/python3.8/bin:/home/qb/.local/bin:/usr/local/sbin"

---

Como Resolver Problemas com o ADB no WSL

Se você ativou a "Depuração USB" no dispositivo Android e instalou o android-tools-adb no WSL, mas não consegue ver o dispositivo listado ao executar adb devices, siga estes passos adicionais:

1. Verifique as Configurações de USB

Certifique-se de que o dispositivo está configurado para permitir a depuração. Após conectar o dispositivo ao computador, uma janela deve aparecer perguntando se você deseja permitir a depuração USB. Verifique se você autorizou a conexão.

2. Conecte o Dispositivo e Verifique o Modo de Conexão

• Conecte o dispositivo e veja se ele está em Modo de transferência de arquivos (MTP) ou Modo de depuração. Mudar o modo de conexão pode ajudar.
• Acesse essas configurações na barra de notificações ao tocar na notificação de USB.

3. Reinicie o ADB

No terminal do WSL, tente reiniciar o servidor ADB:

adb kill-server
adb start-server

4. Verifique se o ADB está Rodando no Windows

O ADB que está rodando no Windows pode interferir. Para resolver isso:

1. Abra o Prompt de Comando ou PowerShell e execute:

adb kill-server
adb start-server

2. Depois, volte para o WSL e execute adb devices novamente.

5. Teste com ADB no Windows

Se ainda assim não funcionar, tente usar o ADB diretamente no Windows:

1. Abra o Prompt de Comando ou PowerShell.
2. Execute:

adb devices

Se o dispositivo aparecer, o problema pode estar na comunicação entre o WSL e o Windows.

6. Verifique as Permissões do Dispositivo

A falta de permissões pode ser a causa do problema. Verifique se o seu dispositivo está autorizado a se conectar ao computador e se há alguma solicitação de permissão no dispositivo.

7. Reinicie o Dispositivo

Como último recurso, tente reiniciar o dispositivo Android. Às vezes, isso resolve problemas de conexão.

Se depois de seguir esses passos o problema continuar, compartilhe qualquer mensagem de erro ou comportamento que você observar!

Claro! Vamos focar nas ferramentas e métodos que especificamente convertem scripts Python (.py) em APKs. Aqui estão as opções:

20 formas de converter script.py para aplicativo.apk

1. Kivy + Buildozer: O método mais popular, onde você utiliza o Kivy para criar interfaces e o Buildozer para empacotar seu aplicativo como um APK.

2. BeeWare (Briefcase): Ferramenta que permite criar aplicativos nativos para Android a partir de código Python, gerando APKs.

3. PySide + PyInstaller: Embora menos comum, você pode usar o PyInstaller para empacotar aplicativos PySide em um APK.

4. Chaquopy: Plugin para o Android Studio que permite incluir código Python em aplicativos Android nativos, criando APKs diretamente.

5. Pygame Subset for Android (pgs4a): Permite que jogos feitos com Pygame sejam convertidos em APKs.

6. Ren'Py: Um motor de visual novel que utiliza Python e pode exportar jogos como APKs.

7. KivyMD + Buildozer: Similar ao Kivy, mas com componentes de Material Design, facilitando a criação de interfaces modernas.

8. PyQtDeploy: Empacota aplicativos feitos com PyQt ou PySide para Android, gerando APKs.

9. Flask + WebView: Embora envolva uma aplicação web, você pode empacotar a aplicação Flask em um APK usando WebView.

10. Python-Android: Um projeto que permite rodar aplicações Python como APKs, embora não seja tão popular.

11. SDL2 + Python: Usar a biblioteca SDL2 com um wrapper Python para criar aplicativos que podem ser convertidos em APKs.

12. Toga (parte do BeeWare): Com Toga, você pode desenvolver aplicativos nativos que podem ser empacotados como APKs.

13. PyBee (parte do BeeWare): Facilita a criação de aplicativos nativos com Python e sua conversão em APKs.

14. Pydroid 3: Um IDE para Android que permite rodar scripts Python, mas, com algum esforço, é possível adaptar para gerar APKs.

15. Unity + Python: Embora mais complexo, é possível integrar Python em Unity e exportar como APK.

16. Nuitka: Compilador que transforma scripts Python em executáveis e, com algumas etapas adicionais, pode ser adaptado para gerar APKs.

17. Pyinstaller + Android NDK: Embora envolva configuração avançada, é uma possibilidade para empacotar aplicativos Python em APKs.

18. PyBee (Toga): Usando as ferramentas do PyBee, você pode criar interfaces gráficas e empacotar como APKs.

19. Skulpt: Um interpretador Python em JavaScript que pode ser usado para embutir scripts Python em aplicativos Android, mas não gera APKs diretamente.

20. Kivy + PyJNIus: Utilizando Kivy junto com PyJNIus, você pode acessar APIs Java e gerar APKs.

Essas opções variam em complexidade e em nível de suporte, mas todas são viáveis para converter scripts Python em APKs de alguma forma. O Kivy com Buildozer e o BeeWare são os mais recomendados para simplicidade e documentação.

Atualização importante no Buildozer

Para o Python 3.12 

[DEBUG]: The distutils package is deprecated and slated for removal in Python 3.12. Use setuptools or check PEP 632 for potential alternatives:DeprecationWarning /tmp/tmp642kx0bq.py

O que isso significa?

Depreciação do distutils:

O Python está movendo seu foco para o setuptools, que é uma biblioteca mais robusta para construção e distribuição de pacotes Python. O distutils foi uma parte central do ecossistema Python, mas está sendo gradualmente substituído por abordagens mais modernas.

Impacto em seu projeto:

Embora este aviso não signifique que o seu aplicativo não funcionará agora, é uma boa prática começar a migrar para o uso do setuptools para evitar problemas futuros.

O que fazer?

Verifique seu código:

Se você estiver usando distutils diretamente em seu projeto, substitua por setuptools. Por exemplo:

# Antes

from distutils.core import setup

# Agora

from setuptools import setup

Atualize Dependências:

Certifique-se de que suas dependências (bibliotecas que você está usando) também não estão utilizando distutils. Você pode verificar as versões mais recentes dessas bibliotecas e atualizá-las.

Monitore as Versões do Python:

Fique atento às versões futuras do Python e faça testes em um ambiente de desenvolvimento quando versões novas forem lançadas. Isso ajudará a identificar e resolver potenciais problemas de compatibilidade.

Ignore Avisos em Ambiente de Desenvolvimento:

Para evitar que esse aviso polua seus logs durante o desenvolvimento, você pode ignorá-los usando a variável de ambiente PYTHONWARNINGS. No entanto, é melhor resolver a causa do aviso a longo prazo.

Onde criar seus KV

https://m3.material.io/
Tutoriais: https://www.youtube.com/watch?v=kRWtSkIYPFI&list=PLy5hjmUzdc0nMkzhphsqgPCX62NFhkell&index=3

Instalando o Python 3.10.12

Parece que o Ubuntu 18.04 ainda não está conseguindo encontrar o Python 3.10 nos repositórios. Vamos garantir que o PPA esteja devidamente adicionado e atualizado. Siga estas etapas:

1. Remover PPA (opcional, mas recomendado)

Se houver problemas com o PPA existente, você pode removê-lo e adicioná-lo novamente:

sudo add-apt-repository --remove ppa:deadsnakes/ppa

2. Adicionar o PPA novamente

Adicione o PPA para Python novamente:

sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update

3. Instalar o Python 3.10

Tente instalar o Python 3.10.12 novamente:

sudo apt install python3.10

4. Verificar a Instalação

Depois disso, verifique se o Python 3.10 foi instalado corretamente: 

python3.10 --version 

5. Se ainda não funcionar 

Se o Python 3.10 ainda não estiver disponível, você pode considerar compilar o Python a partir do código-fonte. Aqui estão as etapas resumidas: 

Instalar dependências

sudo apt update
sudo apt install build-essential checkinstall
sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev
sudo apt install libgdbm-dev libc6-dev libbz2-dev
sudo apt install zlib1g-dev

Baixar o código-fonte do Python 3.10.12

cd /usr/src
sudo wget https://www.python.org/ftp/python/3.10.12/Python-3.10.12.tgz
sudo tar xzf Python-3.10.12.tgz 
cd Python-3.10.12
sudo ./configure --enable-optimizations
sudo make altinstall 

6. Finalizar

Após a instalação, verifique a versão instalada novamente: 

python3.10 --version 

 7. Alternar para Python 3.10.12

sudo update-alternatives --install /usr/bin/python python /usr/local/bin/python3.10 3
sudo update-alternatives --config python

Alternar para Pip 3.10.12

which pip3.10

nano ~/.bashrc

export PATH=$PATH:$HOME/.local/bin:/usr/local/lib/python3.8/bin:/usr/local/sbin:/usr/local/lib/libjxl:/usr/local/bin

export PATH=/usr/local/bin:$HOME/.local/bin:/usr/local/lib/python3.8/bin:/usr/local/sbin:/usr/local/lib/libjxl:$PATH:/mnt/c/platform-tools

export PYTHON=/usr/bin/python3.10

export PATH=$PATH:/mnt/c/platform-tools

export ANDROID_SDK_ROOT=/mnt/c/platform-tools

export PATH=$PATH:$ANDROID_SDK_ROOT

alias adb='/mnt/c/platform-tools/adb.exe'

source ~/.bashrc

sudo rm /usr/local/bin/pip

sudo rm -f ~/.local/bin/pip

/usr/local/bin/pip -V

sudo ln -s /usr/local/bin/pip3.10 /usr/local/bin/pip

pip -V

Driver para MTDev comum no Python 3.10
Se acontecer [ERROR  ] [Input       ] MTDev is not supported by your version of linux no seu script 

Faça:

sudo apt-get install python3-dev python3-pip build-essential \

libgl1-mesa-dev libgles2-mesa-dev \

libglew-dev libpng-dev \

libjpeg-dev libtiff-dev \

libgtk2.0-dev libgdk-pixbuf2.0-dev \

libsdl2-dev libsdl2-image-dev \

libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev \

libavformat-dev libavcodec-dev libavdevice-dev \

libswscale-dev libfreetype6-dev \

libx11-dev libxi-dev libxrandr-dev \

libxinerama-dev libxcursor-dev \

libmtdev-dev

Remover Python 3.6

python3.6 --version

sudo apt remove python3.6 -y

sudo apt purge python3.6 -y

sudo apt autoremove -y

rm -rf ~/.local/lib/python3.6

python3.6 --version

Apenas o Python 3.8

sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.8 1

sudo update-alternatives --config python3

rm ~/.local/bin/pip3

ln -s /home/qb/.local/bin/pip /home/qb/.local/bin/pip3

pip3 --version

which pip

python3.8 -m pip install --upgrade --force-reinstall pip

pip3 --version

head -n 1 ~/.local/bin/pip3

python3 --version

python3.8 -m pip uninstall buildozer

python3.8 -m pip install buildozer

ls ~/.local/bin/buildozer

python3.8 -m buildozer android debug

Como Instalar o Android SDK no Ubuntu 18.04

1. Instale as dependências necessárias

Antes de começar, instale algumas dependências que podem ser necessárias:

sudo apt update
sudo apt install openjdk-11-jdk wget unzip

2. Baixe o SDK do Android

Você pode baixar o Android SDK diretamente do site oficial ou usar o SDK Manager. Aqui está como fazer isso:

Baixando o Android Command Line Tools

Baixe o arquivo ZIP:

Acesse a página de download do Android Studio e baixe o arquivo commandlinetools***-linux.tar.gz.

Você pode usar o wget no terminal:

wget https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -O commandlinetools.zip

Extraia o arquivo ZIP:

unzip commandlinetools.zip

Mova para a pasta do SDK:

Crie um diretório para o SDK (caso ainda não tenha):

mkdir -p ~/Android/Sdk/cmdline-tools
mv cmdline-tools ~/Android/Sdk/cmdline-tools/latest

3. Configure as variáveis de ambiente

Adicione as seguintes linhas ao seu arquivo ~/.bashrc ou ~/.profile para configurar as variáveis de ambiente:

export ANDROID_HOME=~/Android/Sdk
export PATH=$PATH:$ANDROID_HOME/cmdline-tools/latest/bin
export PATH=$PATH:$ANDROID_HOME/platform-tools

Depois, recarregue o arquivo de configuração:

source ~/.bashrc

4. Instale as plataformas e ferramentas

Use o SDK Manager para instalar as plataformas e ferramentas necessárias:

cd ~/Android/Sdk/cmdline-tools/latest/bin
ls
sdkmanager --sdk_root=$ANDROID_HOME --update
sdkmanager "platform-tools" "platforms;android-30" "build-tools;30.0.3"

5. Verifique a instalação

Para verificar se o SDK foi instalado corretamente, execute:

sdkmanager --list

6. Instalação do Android Studio (opcional)

Se você também quiser o Android Studio, você pode baixá-lo da página oficial e seguir as instruções de instalação.

Instalação do NDK

Passo 1: Download do NDK

Baixe o NDK: Execute o seguinte comando no terminal para baixar o NDK r27:

wget https://dl.google.com/android/repository/android-ndk-r27-linux.zip

Passo 2: Extraia o NDK

Extraia o arquivo baixado:

unzip android-ndk-r27-linux.zip

Mova o NDK para um diretório desejado (opcional, mas recomendado):

sudo mv android-ndk-r27 /opt/android-ndk-r27

Passo 3: Configure o PATH

Adicione o NDK ao PATH:

Abra o arquivo de configuração do seu shell (como ~/.bashrc ou ~/.bash_profile ou ~/.zshrc se você estiver usando Zsh) e adicione a seguinte linha:

export PATH=$PATH:/opt/android-ndk-r27

Em seguida, carregue as mudanças:

source ~/.bashrc

(ou o arquivo que você editou)

Passo 4: Configure o Buildozer

Atualize o arquivo buildozer.spec:

No seu arquivo buildozer.spec, adicione ou modifique as seguintes linhas:

android.ndk = /opt/android-ndk-r27

Passo 5: Verifique a Instalação

Verifique se o NDK está corretamente instalado e no PATH:

Execute o comando:

ndk-build --version

Você deve ver a versão do NDK se tudo estiver correto.

Passo 6: Compile seu Projeto

Recompile seu projeto usando o Buildozer:

buildozer -v android debug

Instalação e Configuração do CMake

1. Atualizar o Sistema

sudo apt update && sudo apt upgrade

2. Instalar Dependências

sudo apt install build-essential

3. Instalar CMake

3.1. Remover CMake Existente

sudo apt remove --purge cmake

3.2. Baixar o Instalador do CMake

wget https://github.com/Kitware/CMake/releases/download/v3.22.0/cmake-3.22.0-linux-x86_64.sh

3.3. Tornar o Script Executável

chmod +x cmake-3.22.0-linux-x86_64.sh

3.4. Instalar o CMake

sudo ./cmake-3.22.0-linux-x86_64.sh --skip-license --prefix=/usr/local

3.5. Verificar a Instalação

cmake --version 

Instalação e Configuração do SDL_image

1. Baixar o SDL_image

cd /mnt/c/users/qb/desktop/kivy

git clone https://github.com/libsdl-org/SDL_image.git

cd SDL_image

2. Criar o Diretório de Build

mkdir build && cd build

3. Configurar o Projeto com CMake

cmake ..

4. Compilar o Projeto

make

5. Instalar

sudo make install

6. Verificar a Instalação do SDL_image

Verifique se os arquivos do SDL_image estão presentes nos diretórios de instalação padrão.

Como resolver o erro de CMake ao instalar SDL_image

1. Instalar SDL3

Certifique-se de que você tenha o SDL3 instalado. Você pode instalá-lo através do gerenciador de pacotes. Por exemplo, se você estiver usando o Ubuntu, execute:

sudo apt-get install libsdl3-dev

2. Definir CMAKE_PREFIX_PATH

Se o SDL3 estiver instalado, mas o CMake ainda não consegue encontrá-lo, talvez seja necessário definir o CMAKE_PREFIX_PATH para o local onde o SDL3 está instalado. Você pode fazer isso no comando cmake:

cmake -DCMAKE_PREFIX_PATH=/caminho/para/sdl3 ..

Substitua /caminho/para/sdl3 pelo caminho real onde o SDL3 está instalado.

3. Verificar o arquivo SDL3Config.cmake

Se você tem o SDL3 instalado, certifique-se de que o arquivo SDL3Config.cmake exista no diretório de instalação. Este arquivo geralmente é encontrado em lib/cmake/SDL3.

4. Definir SDL3_DIR

Alternativamente, você pode definir a variável SDL3_DIR diretamente:

cmake -DSDL3_DIR=/caminho/para/sdl3/lib/cmake/SDL3 ..

5. Consultar a Documentação

Se você ainda estiver tendo problemas, consulte a documentação do SDL_image para requisitos específicos ou opções de configuração adicionais.

Tentativas Adicionais

1. Verificar se o SDL2 pode ser usado

Se o seu projeto pode funcionar com SDL2 em vez de SDL3, você pode instalá-lo usando:

sudo apt-get install libsdl2-dev

2. Instalar SDL3 a partir do Código Fonte

1. Instalar dependências:

sudo apt-get install build-essential git

2. Clonar o repositório SDL3:

git clone https://github.com/libsdl-org/SDL.git
cd SDL

3. Construir e instalar:

mkdir build && cd build
cmake ..
make
sudo make install

3. Usar um PPA (se disponível)

Às vezes, existem repositórios de terceiros (PPAs) que contêm versões mais recentes das bibliotecas. Verifique se há um PPA para SDL3.

4. Encontrar Binários Pré-compilados

Verifique o site do SDL ou a página do GitHub deles para binários pré-compilados que você pode baixar e instalar.

Após a Instalação

Depois de instalar o SDL3, tente executar seu comando cmake novamente. Se precisar de mais assistência, fique à vontade para perguntar!

Alguns Tratamentos

A Mensagem Recipe build order is ['hostpython3', 'libffi', 'openssl', 'sdl2_image', 'sdl2_mixer', 'sdl2_ttf', 'sqlite3', 'python3', 'sdl2', 'setuptools', 'six', 'pyjnius', 'android', 'kivy']

A mensagem indica que algumas dependências (como certifi, chardet, idna, kivymd, requests e urllib3) não foram encontradas como receitas, então elas serão instaladas via pip.

Tente isso na proxima vez antes de usar o buildozer

pip install certifi chardet idna kivymd requests urllib3

Versões até o momento dia 13/10/2024 

python3 -m pip index versions kivy
WARNING: pip index is currently an experimental command. It may be removed/changed in a future release without prior warning.
kivy (2.3.0)
Available versions: 2.3.0, 2.2.1, 2.2.0, 2.1.0, 2.0.0, 1.11.1, 1.11.0, 1.10.1, 1.10.0, 1.9.1, 1.9.0, 1.8.0, 1.7.2, 1.7.1, 1.7.0, 1.6.0, 1.5.1, 1.5.0, 1.4.1, 1.4.0, 1.3.0, 1.2.0, 1.1.1, 1.1.0, 1.0.9, 1.0.8, 1.0.7, 1.0.6, 1.0.5
  INSTALLED: 2.3.0
  LATEST:    2.3.0

Erro pep517

pip uninstall pep517
pip install pep517==0.6.0
pip check

pip install --upgrade python-for-android

WARNING: Error 2.17.12ubuntu1.1 7.1.8ubuntu1

pip install pysimplesoap
sudo apt-get install --reinstall devscripts reportbug

Pode instalar

python3 -m pip install appdirs

python3 -m pip install colorama>=0.3.3

python3 -m pip install jinja2

python3 -m pip install 'sh>=1.10, <2.0; sys_platform!="win32"'

python3 -m pip install build

python3 -m pip install toml

python3 -m pip install packaging

python3 -m pip install setuptools