Tutorial de SDL – Parte 52 – Dispositivos móveis

Continuando nossa série de artigos traduzidos do site lazyfoo, agora veremos como criar uma aplicação baseada no SDL para ser executada em dispositivos móveis (smartphones e tablets).
Depois de ter visto o básico sobre desenvolvimento com SDL para computadores desktop, você quer agora criar portes de suas aplicações para telefones e tablets. O SDL 2 felizmente possui portes para Android e iOS que ajudam a tornar o processo menos doloroso.

NÃO INICIE ESSE ARTIGO se já não leu os artigos anteriores dessa série. Os artigos sobre desenvolvimento para dispositivos móveis, assumem que você já tem experiência com o SDL 2. Vá primeiro verificar esses tutoriais antes desse, pois desenvolver para dispositivos móveis é muito mais peculiar do que desenvolvimento para desktop.

Configurando o SDL 2 com o Android Studio no Linux

1) Se prepare para baixar um monte de coisa. Mais de 1 gigabyte de dados. Se você estiver usando uma conexão limitada, desculpe pelo Adnroid SDk ser tão grande, mas é como as coisas são. Eu recomendo assistir um filme ou série enquando o download acontece se for tomar muito tempo para você.

Para começar, você precisa instalar o Java Development Kit (JDK). Usando o apt-get você pode instala-lo usando o comando a seguir:

sudo apt-get install default-jdk

2) Baixe o Android Studio nessa página.

3) Baixe o código fonte do SDL2. Não apenas as bibliotecas de desenvolvimento que você usa para desenvolver para o desktop, o código completo. Você pode encontrar o código fonte nessa página.

4) Para executar a aplicação em um dispositivo Android, você irá precisar do ANdroid Debug Bridge (ADB). Você pode instala-lo com apt-get com o comando:

sudo apt-get install android-tools-adb

5) Extraia a pasta do android-studio do arquivo zip baixa anteriormente. Coloque em algum lugar conveniente. Nesse artigo, vamos assumir que foi colocado no diretório home.

Depois da extração, instale e/ou execute o Android Studio. Instruções em como fazer isso devem estar no arquivo ~/android-studio/Install-Linux-tar.txt

6) Depois de iniciar o Android Studio, vá para Configure -> SDK Manager

7) Em SDK Platforms, marque Show  Package Details e selecione Android SDk Platform 16 para instalação e clique em Apply:

Você pode querer instalar a versão mais recente do Android SDK, mas a menos que você saiba o que está fazendo e realmente precise dos recursos mais recentes, eu recomento a não fazer isso.  SDKs mais recentes significam SDKs menos estáveis.

8) Clique em SDk Tools e certifique-se de instalar:

  • CMake
  • NDK

9) Extraia o código fonte do SDL2 em algum diretório acessível que idealmente seja dedicado a conter bibliotecas Android. Nesse artigo, assumimos que estarão no diretório “~/androidlib/”. Depois de extrair o código fonte do SDL2 você deve ter um Makefile para Android no diretório em “~/androidlib/SDL2-2.0.7/Android.mk”. Dependendo  de sua versão do SDL, pode estar em “~/androidlib/SDL2-2.0.5/Android.mk” ou “~/androidlib/SDL2-2.0.4/Android.mk” e assim em diante.

10) Inicie o Android Studio novamente e importe o projeto Android do código fonte SDL2 que deve estar em “~/androidlib/SDL2-2.0.7/android-project”

11) Configure o destino para um novo diretório que fique dentro de um diretório acessível que seja idealmente dedicado à projetos Andrid. Nesse artigo, vamos assumir que é o diretório “YOUR-HOME-DIRECTORY/androidprojects/SDL_Tutorial”. Selecione o diretório e importe o projeto com as configurações padrão.

12) Vá para Build -> Make Project:

Você verá um erro que diz:

Minimum supported Gradle version is 4.1. Current version is 2.14.1.

Isso significa que nosso projeto está configurado para usar a versão incorreta do Gradle. Para corrigir isso, mude a janela do Projeto para o modo de projeto, e vá para SDL_tutorial -> gradle -> wrapper -> gradle-wrapper.properties e altera

distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip

para

distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip

Tente compilar  oprojeto novamente (pode levar algum tempo enquando Gradle é baixado) e você verá um novo erro:

cannot find symbol class Objects

13) Esse erro ocorre devido ap fato do Android Studio não poder encontrar as classes dos objetos do Java. Não consegue encontrar porque está apontando para uma JDK antiga. Para certifica-se de estar usando a mais recente, vá para File -> Project Structure.

Selecione app em Modules e configure Source/Target Compatibility para a versão mais recente (no momento 1.8):

Tente compilar novamnte para ver o novo erro.

14) Se você tentar compilar novamente com Build -> Make Project você verá o seguinte erro:

Error:Execution failed for task ‘:app:compileDebugNdk’.
> Error: Your project contains C++ files but it is not using a supported native build system.
Consider using CMake or ndk-build integration with the stable Android Gradle plugin:
https://developer.android.com/studio/projects/add-native-code.html
or use the experimental plugin:
https://developer.android.com/studio/build/experimental-plugin.html.

Aqui ele está reclamando que a configuração do NDK está quebrada para o nosso projeto.

Vamos recapitular um pouco para falar coo SDL 2 no Android funciona. O desenvolvimento para Android é em sua maioria baseado em Java e SDl é uma biblioteca escrita em C. O Native Development Kit que permite que o Java se comunique com o código C/C++ nativo usa a Java Native Interface. Com o NDK iremos compilar o SDL2 como um objeto compartilhado que irá se comunicar com o Java, e iremos compilar nosso jogo como um obejto compartilhado que irá se comunicar com o SDL2.

O que precisamos fazer é informar ao Gradle (a ferramenta de compilação usada pelo Android Studio) para usar o Makefile Android de nosso projeto. Abra a janela do projeto, dê um clique com o botão direito em app e selecione “Link C++ with Gradle”.

Configure Build System para ndk-build e configure o caminho do projeto para o local onde o Makefile Android deve estar, que deve ser em “~/androidprojects/SDL_Tutorial/app/src/main/jni/Android.mk”.

Clique em Build -> Make Project e você verá um monte de novos erros dizendo algo como:

Android NDK: Module main depends on undefined modules: SDL2

15) O que o erro anterior está reclamando é que não consegue encontrar o módulo SDL2. O que precisamos fazer é criar um link simbólico para o código fonte do SDL2 que extraimos anteriormente.

Vá para o diretório JNI do projeto com esse comando:

cd ~/androidprojects/SDL_Tutorial/app/src/main/jni

E crie um link simbólico para o código fonte do SDL2 que extraimos (LEMBRETE: Esse caminho pode variar dependendo da versão do SDl2 sendo usada):

ln -s ~/androidlib/SDL2-2.0.7/ SDL2

Tente compilar o projeto novamente. Você verá um novo erro, mas ao menos poderá visualizar o link simbólico no projeto:

16) Esse novo erro do Gradle não nos informa muita coisa, assi mtemos que abrir o console do Gradle:

Role um pouco a tela evocê verá alguns erros do ndk-build. Você provavelmente verá o erro:

make: *** No rule to make target `~/androidprojects/SDL_Tutorial/app/src/main/jni/src/YourSourceHere.c’, needed by `~/androidprojects/SDL_Tutorial/app/build/intermediates/ndkBuild/debug/obj/local/armeabi-v7a/objs-debug/main/YourSourceHere.o’. Stop.
make: *** No rule to make target `~/androidprojects/SDL_Tutorial/app/src/main/jni/src/YourSourceHere.c’, needed by `~/androidprojects/SDL_Tutorial/app/build/intermediates/ndkBuild/debug/obj/local/x86/objs-debug/main/YourSourceHere.o’. Stop.

Nesse caso, o erro “No rule to make target” significana verdade que não consegue encontrar o arquivo que você quer compilar. Está tentando compilar o arquivo “~/androidprojects/SDL_Tutorial/app/src/main/jni/src/YourSourceHere.c”, mas nã encontra porque ele não existe. Esse arquivo é só um nome que precisa ser substituido pelo arquivo que vamos usar. baixe o arquivo fonte desse artigo e coloque o arquivo 52_hello_mobile.cpp em “~/androidprojects/SDL_Tutorial/app/src/main/jni/src/52_hello_mobile.cpp”. Abra o arquivo “~/androidprojects/SDL_Tutorial/app/src/main/jni/src/Android.mk” e altere “YourSourceHere.c” para “52_hello_mobile.cpp”. Tente compilar o projeto e você verá um novo erro.

17) O erro

fatal error: ‘string’ file not found

se deve ao fato de que o projeto não está  configurado para usar a biblioteca padrão do C++. Para corrigir isso, abra “~/androidprojects/SDL_Tutorial/app/src/main/jni/Application.mk” e altere:

# APP_STL := stlport_static

para

APP_STL := stlport_static

para que não esteja mais comentado. Tente compilar e veja os novos erros.

18) Abra “~/androidprojects/SDL_Tutorial/app/src/main/res/values/strings.xml” e altere

<string name=”app_name”>SDL App</string>

para

<string name=”app_name”>SDL Tutorial</string>

Isso irá o nome que está localizado no icone do aplicativo de “SDL App” para “SDL Tutorial”.

19) Nesse ponto, o aplicativo irá executar o nosso código mais falhará porque não consegue carregar os arquivos de m´ídia desse artigo. Arquivos de mídia ficam localizados no diretório asset. Crie um diretório chamado “assets” em “~/androidprojects/SDL_Tutorial/app/src/main/assets”. Copie o diretório que está dentro do arquivo zip que baixamos e coloque ele no diretório asset. Se a aplicação precisar acessar o arquivo “52_hello_mobile/hello.bmp”, precisa estar em
at “~/androidprojects/SDL_Tutorial/app/src/main/assets/52_hello_mobile/hello.bmp” quando for compilar.

20) Nossa aplicação SDL está pronta para ser compilada e executada, mas primeiro precisamos configurar um dispositivo. Podemos usar um emulador Android, mas o emulador pode ser realmente muito lente, assim eu recomendo ter um dispositivo ANdroid se puder.

Primeiro, ativo USB debugging em seu dispositivo. Esse passo é especifico da versão/dispositivo, assim não mostraremos com fazer isso aqui. Pesquise no Google por “android enable usb debugging” com o nome do seu dispositivo e no resultado mostrará como fazer isso.

Depois de configurar seu dispositivo Android, vá para Run -> run App.

Se quiser ver a saída do terminal de sua aplicação, pode ver no Android Monitor:

O Android Monitor pode também mostrar se ocorreu algum erro no ADB.

Hello Mobile: Sua primeira aplicação para dispositivos móveis com o SDL 2

Agora que cobrimos a parte mais dificil de fazer com a aplicação possa ser compilada e executada, vamos ver algum código para desenvolver a aplicação.

//Screen dimensions
SDL_Rect gScreenRect = { 0, 0, 320, 240 };

Como dispositivos móveis variam bastante  em resolução, iremos usar dimensões de tela variáveis ao invés de valores constantes.

        //Get device display mode
        SDL_DisplayMode displayMode;
        if( SDL_GetCurrentDisplayMode( 0, &displayMode ) == 0 )
        {
            gScreenRect.w = displayMode.w;
            gScreenRect.h = displayMode.h;
        }
        //Create window
        gWindow = SDL_CreateWindow( "SDL Tutorial", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, gScreenRect.w, gScreenRect.h, SDL_WINDOW_SHOWN );
        if( gWindow == NULL )
        {
            SDL_Log( "Window could not be created! SDL Error: %s\n", SDL_GetError() );
            success = false;
        }

Aqui, usamos SDl_GetCurrentDisplayMode para obter a resolução do dispositivo móveis. Em seguida criamos uma janela com as dimensões do dispositivo.

Observe que estamos usando SDL_Log ao invés de printf. Isso é porque Android/iOS tem suas maneiras especificas de imprimir para o terminal e assim SDL nos fornece uma maneira de tornar nosso código multiplataforma.

int main( int argc, char* args[] )
{
    //Start up SDL and create window
    if( !init() )
    {
        SDL_Log( "Failed to initialize!\n" );
    }
    else
    {
        //Load media
        if( !loadMedia() )
        {
            SDL_Log( "Failed to load media!\n" );
        }
        else
        {
            //Main loop flag
            bool quit = false;
            //Event handler
            SDL_Event e;
            //While application is running
            while( !quit )
            {
                //Handle events on queue
                while( SDL_PollEvent( &e ) != 0 )
                {
                    //User requests quit
                    if( e.type == SDL_QUIT )
                    {
                        quit = true;
                    }
                }
                //Clear screen
                SDL_SetRenderDrawColor( gRenderer, 0xFF, 0xFF, 0xFF, 0xFF );
                SDL_RenderClear( gRenderer );
                //Render splash
                gSplashTexture.render( ( gScreenRect.w - gSplashTexture.getWidth() ) / 2, ( gScreenRect.h - gSplashTexture.getHeight() ) / 2 );
                //Update screen
                SDL_RenderPresent( gRenderer );
            }
        }
    }
    //Free resources and close SDL
    close();
    return 0;
}

Além do fato de estarmos usando SDL_Log, o código é basicamente o mesmo do desenvolvido nos artigos anteriores.

Baixe os arquivos de mídia e do código fonte para esse artigo aqui.