Configurando o Ambiente de Desenvolvimento – Tutorial Android 1

Padrão

Desde o último post que explicava a configuração do ambiente de desenvolvimento para Android, tivemos pelo menos uma mudança bem drástica. Se antes utilizávamos o Eclipse, hoje utilizamos o Android Studio, uma versão da poderosa IDE IntelliJ IDEA, desenvolvida pela JetBrains.

Configuração no Windows

O primeiro passo para a instalação do ambiente no Windows, é o download da JDK (Java Development Kit). Ela nos fornecerá a base de ferramentas para o desenvolvimento Java, que será utilizada também para o desenvolvimento dos apps Android também. Você pode baixar a JDK no site da Oracle. A instalação deve ocorrer sem problemas.

O próximo passo consiste em baixarmos o Android Studio. Após baixar o .exe bundle (que já contém os itens básicos de SDK e emulador), basta seguir o procedimento de instalação normalmente como qualquer outro aplicativo.

O último passo é exportarmos as variáveis de ambiente JAVA_HOME ANDROID_HOME, para que possamos, quando necessário, também executar builds e comandos a partir do console. Primeiramente vamos exportar a ANDROID_HOME. Caso você não tenha alterado o local durante a instalação do Android Studio, o valor deve ser:

%LOCALAPPDATA%\Android\sdk

Em seguida, vamos exportar a JAVA_HOME. Novamente, se você não alterou o local da instalação do Java, o valor deve ser:

%ProgramFiles%\Java\jdk1.8.0_111

No momento que escrevo este post, a última versão do Java é a 8, revisão 111. Caso a versão que você instale seja outra, ajuste o caminho de acordo.

Por fim, vamos adicionar os binários ao Path do sistema, para que sejam acessíveis através do console. Adicione ao Path as entradas %ANDROID_HOME%\tools%ANDROID_HOME%\platform-tools%JAVA_HOME%\bin.

Para testar, valide que os comandos adbjavac são acessíveis no console.

Durante a instalação do Android Studio, também deve ter sido instalado o HAXM (caso o seu processador seja compatível). O HAXM permitirá que vocẽ execute o emulador do Android com excelente desempenho. Outra boa opção de emulador é o Genymotion, porém para usos gerais, o emulador que acompanha a SDK do Android é suficiente.

Por fim, opcional mas recomendado, instale o Git, que é hoje a ferramenta de versão mais utilizada.

Configuração no Linux

No Linux, por possuirmos um gerenciador de pacotes, a coisa fica um pouco mais fácil. Caso você esteja utilizando o Ubuntu / Linux Mint, para preparar nosso ambiente, basta instalar os seguintes pacotes:

sudo apt-get install lib32z1 lib32ncurses5 lib32stdc++6 openjdk-8-jdk qemu-kvm libvirt-bin ubuntu-vm-builder bridge-utils

Caso esteja utilizando o Fedora, os pacotes são:

sudo dnf install glibc.i686 glibc-devel.i686 libstdc++.i686 zlib-devel.i686 ncurses-devel.i686 libX11-devel.i686 libXrender.i686 libXrandr.i686 java-1.8.0-openjdk-devel qemu-kvm

Outras distribuições podem ter estes pacotes com outros nomes, mas uma rápida busca pode trazer os correspondentes. O Linux não utiliza o HAXM para aceleração dos emuladores x86 – para isso, temos o KVM, um mecanismo de virtualização ligado ao kernel (caso o seu processador suporte).

Em seguida, vamos baixar o Android Studio. Para Linux, o arquivo tem extensão .tar.gz e deve ser extraído para alguma pasta (como por exemplo, ~/Android). Feito isso, basta executar o arquivo studio.sh que encontra-se dentro da pasta bin. Na primeira execução, serão baixados os pacotes necessários para a SDK. Para encerrar, selecione no menu Configure a opção Create Desktop Entry para facilitar a execução do Android Studio a partir do seu menu de aplicativos (seja UnityGnomeKDE, etc.)

O último passo é exportarmos a variável ANDROID_HOME e colocar os binários no Path. Para isso abra o arquivo ~/.bashrc ou, caso esteja utilizando o zshell, ~/.zshrc, e adicione as seguintes linhas. Caso tenha modificado o local da instalação da SDK do Android, ajuste o caminho:

export ANDROID_HOME="$HOME/Android/Sdk"
export PATH="$PATH:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools"

Por fim, é opcional porém recomendada, a instalação do Git para controle de versão dos nossos projetos.

Configuração no OSX

No OSX (Mac), a instalação é semelhante a que fizemos para o Windows. Primeiramente, baixe a JDK do site da Oracle. A instalação deve ocorrer sem maiores problemas, bastando seguir o wizard com o passo a passo da instalação.

Em seguida, baixe o Android Studio. A partir do arquivo .dmg, a instalação é tranquila, seguindo o padrão para outros aplicativos do Mac. Ao executar pela primeira vez, as ferramentas serão baixadas e o HAXM será instalado.

O último passo é a configuração das variáveis de ambiente. Contando que os caminhos padrão tanto do Java quanto da SDK do Android não foram alterados durante a instalação, adicione o seguinte conteúdo ao arquivo ~/.bash_profile (caso o arquivo não exista, crie-o).

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_111.jdk/Contents/Home
export ANDROID_HOME=$HOME/Library/Android/sdk
export PATH=$PATH:$JAVA_HOME/bin:$ANDROID_HOME/tools:$ANDROID_HOME/platform-tools

Por último, opcionalmente mas fortemente recomendado, instale o Git (opte por utilizar o Homebrew, para instalar a versão mais recente).


E é isso! Aguardem os próximos posts, pois começaremos a colocar a mão na massa 🙂

Exportando Assets de um PSD para Apps (para não-designers como eu)

Padrão

E aí pessoal, beleza?

Bom, hoje fugindo um pouco de programação, vamos para um assunto de muitíssima utilidade: você pegou aquele PSD maneiro com o design do seu app, mas o designer esqueceu ou não pode te gerar os assets no momento… e agora José? Foi esse o meu caso recentemente e, como um ser rústico em se tratando de arte gráfica digital, cuja maior proeza é redimensionar uma imagem usando o Paint (sim, todas as imagens do blog são editadas no PAINT!), bate aquele desespero.

Bom, no meu caso, precisei pesquisar um bocado e, no final, até que o Photoshop faz algumas mágicas pra gente. Aqui estou usando a versão CC 14.2 do Photoshop… se não me engano, essa funcionalidade que vou mostrar apareceu na versão 14.1 (não faço ideia de como funciona em outras versões… se um designer leitor souber, fique a vontade pra entrar em contato que atualizamos o post :)).

Tendo em mãos o seu PSD, você vai abrir e, antes de mexer qualquer coisa, vai em Arquivo -> Gerar -> Recursos de imagem e certifique-se que a opção está marcada!

Captura de tela 2014-08-06 20.18.47

Feito isso, é só alegria. Agora, você pode ir até as suas camadas (ou layers) e renomeá-las, por exemplo, para imagem.png ou imagem.jpg. Existem uns padrões aí nessa nomenclatura para gerar assets de diferentes tamanhos automaticamente (por exemplo retina e normal, no caso do iOS). Um post mais detalhado sobre o assunto pode ser encontrado aqui.

Uma dica que eu, totalmente leigo não sabia, era como mesclar duas camadas pra exportá-las numa mesma imagem. É só segurar o Ctrl para selecionar as camadas que você deseja agrupar, clicar com o botão direito e selecionar a opção Grupo a partir de camadas. Depois, é só dar o nome do recurso a esse grupo que ele criou.

Complementando aqui a dica, recentemente eu descobri um conversor de resources de iOS para Android. Não sei vocês, mas a maioria dos designers que já trabalhei estão acostumados a gerar os resources para iOS, com a nomenclatura @2x para imagens retina e uma outra versão da imagem (por exemplo menu@2x.png menu.png). Para simplificar o nosso trabalho e o trabalho dos designers, achei no Github um projeto chamado ios2android, que nada mais é um script que, usando o ImageMagick, converte esses recursos para Android, redimensionando-os na proporção correta e criando as pastas drawable-hdpidrawable-mdpidrawable-ldpi, etc. Se tiver a versão pra iPad da imagem, ele converte pras dimensões de tablets Android também. Uma maravilha. O link do projeto é este.

As minhas impressões sobre esse script: como ele usa shell script, no Windows você precisa instalar o Cygwin (lembrando de adicionar o pacote do ImageMagick). No Mac, via Homebrew (conforme especificado na própria descrição do repositório), é bem simples (ele foi pensado pra rodar no Mac mesmo). Já no Linux, que tecnicamente seria de boa também, tive o problema de que as imagens ficaram com metade do tamanho que deveriam ficar. Eu não manjo quase nada de shell script… caso alguém saiba e consiga investigar o motivo disso acontecer no nosso amigo Linux, faça um pull request lá no projeto e contribua com o Open Source! 🙂

Bom pessoal, é isso! Fica a dica! 😀

Desenvolvimento com Biometria por Impressão Digital no Linux com a libfprint

Padrão

Olá, pessoal! Hoje vou falar sobre a biblioteca open source para o desenvolvimento de aplicativos utilizando biometria no Linux.

O projeto fprint visa preencher uma lacuna presente hoje nos desktops Linux: o suporte para dispositivos de leitura de impressão digital. Antes deste projeto, o suporte a tais dispositivos estava espalhado entre vários projetos (a grande maioria deles, incompletos) de forma bastante desorganizada, de forma que o desenvolvedor tinha que implementar o suporte para cada um dos dispositivos de maneira separada. O projeto tem como objetivo fornecer suporte a todos os dispositivos que a equipe de desenvolvimento tiver acesso (que promessa, hein!).

O projeto é dividido em 3 vertentes:

  • libfprint: é o núcleo do projeto, onde reside o trabalho pesado, que é conversar com os dispositivos e processar os dados. É a parte que mais interessa a nós programadores.
  • módulo PAM (Pluggable Authentication Module): fornece integração da libfprint com projetos já existentes. Por exemplo, você pode fazer login no seu sistema Linux utilizando sua impressão digital ao invés da sua senha.
  • fprintd: um daemon que fornece a funcionalidade de escanear impressões digitais através de D-Bus.

Hoje, a biblioteca, que se encontra na versão 0.4.0 fornece suporte a uma boa quantidade de leitores, dentre eles:

  • F3Sv Laptop (ASUS)
  • F1F Tablet (ASUS)
  • Z37E Laptop (ASUS)
  • SmartTerminal SFR-1244U (Cherry)
  • Alya (Covardis)
  • Atria (Covardis)
  • U.are.U 4000 Reader (Digital Persona)
  • U.are.U 4000B Reader (Digital Persona)
  • U.are.U Fingerprint Keyboard (Digital Persona)
  • FP-Sensor S26381-K342-V1 (Fujitsu-Siemens)
  • Lifebook S7110 (Fujitsu-Siemens)
  • 2510p, 6510b, 6710b, 6910p, 8710w, nc6400, nx6125, nx6325 e nw9440 (HP)
  • Pavilion dv6640ew, HDX9494nr, tx1302au e tx2108ca (HP)
  • Thinkpad T43p, T61 e X41 (IBM)
  • V100, 3000 N100 e Thinkpad R61i (Lenovo)
  • MD85264 (Medion)
  • Leitor biométrico / teclado (Microsoft)
  • 100 XS (Precise Biometrics)
  • P35 e X65 (Samsung)
  • SZ61VN (Sony)
  • Pangolin (System76)
  • PA460U DEFCON Authenticator (Targus)
  • A-105 (Toshiba)
  • Eikon (UPEK)
  • 5thSense (Veridicon)
  • XM550 e XM570 (Verinex)

Como pode ser percebido, a biblioteca já conta com uma boa quantidade de dispositivos. Além disso, o projeto encontra-se ativo e periodicamente conta com a adição de novos dispositivos.

Neste post, mostrarei como instalar a biblioteca no Ubuntu. Primeiramente, vamos baixar o código-fonte para compilar neste link. O Ubuntu tem a biblioteca em seus repositório, porém na versão 0.0.6. Vamos instalar a versão mais recente (no momento em que escrevo este post, versão 0.4.0).

Antes de compilarmos a biblioteca, é necessário instalarmos as suas dependências. Abra um terminal no Ubuntu e digite:

sudo apt-get install libglib2.0-dev libssl-dev libcrypto++-dev libusb-dev libusb-1.0.0-dev imagemagick libmagick++-dev

Após a instalação dos pacotes, descompacte os arquivos e execute os conhecidos comandos para a instalação da biblioteca:

./configure
make
sudo make install

Pronto! Se tudo correu nos conformes, a biblioteca já deve estar instalada em seu sistema. Para testar, abra o Gedit ou qualquer editor de texto e digite o seguinte código:

#include <libfprint/fprint.h>
#include <stdio.h>

int main(void)
{
    fp_init();

    fp_exit();
    return 0;
}

Para compilar:

gcc -lfprint -oexecutavel main.c

Pronto! Em um outro post eu mostro como realizar operações de autenticação com a biblioteca. Até lá!

Compilando e Instalando a biblioteca Allegro 5 no Ubuntu

Padrão

Olá pessoal! Neste post vou mostrar como obter a nova versão da biblioteca Allegro e como instalá-la em um computador rodando Ubuntu. Realizei os testes utilizando o Ubuntu 11.04, mas o processo deve ser o mesmo em versões anteriores ou mais novas.

Bom, o primeiro passo é instalarmos as dependências para a compilação e execução da biblioteca. Abra uma janela do Terminal. Nela, digite o seguinte comando para instalar as dependências obrigatórias:

sudo apt-get install build-essential subversion cmake xorg-dev libgl1-mesa-dev libglu-dev

Neste processo, será pedido sua senha e a confirmação para iniciar o download dos pacotes. O próximo passo é instalar as bibliotecas necessárias à compilação dos módulos da Allegro 5. Para isso, digite no Terminal:

sudo apt-get install libpng-dev libz-dev libcurl4-gnutls-dev libfreetype6-dev libjpeg-dev libvorbis-dev libopenal-dev libphysfs-dev libgtk2.0-dev libasound-dev libflac-dev libdumb1-dev

Por último, caso queira também construir os arquivos de documentação da biblioteca, execute no Terminal:

sudo apt-get install exuberant-ctags dvi2ps dvipdfmx latex2html pandoc

Após concluir as instalações dos pacotes, vamos baixar o código-fonte da Allegro 5 para compilarmos. Ainda no Terminal, digite o comando:

svn co https://alleg.svn.sourceforge.net/svnroot/alleg/allegro/branches/5.0 allegro-5.0

Este comando baixará o código-fonte dos repositórios oficiais e colocará em uma pasta chamada allegro-5.0. Agora, vamos navegar para a pasta e preparar os arquivos para a instalação. No Terminal, digite os seguintes comandos:

cd allegro-5.0

cmake -DCMAKE_INSTALL_PREFIX=/usr .

Com isso, já teremos os arquivos preparados para realizar a instalação. Para finalizar, digite no Terminal:

make

sudo make install

Pronto! Após a conclusão do processo, já deveremos ter a biblioteca devidamente instalada e pronto para ser utilizada.

Para testarmos se a biblioteca foi instalada corretamente, edite um arquivo no gedit ou no vim com o seguinte código (no meu caso, salvei com o nome de main.c:

#include <stdio.h>
#include <allegro5/allegro.h>

int main(int argc, char *argv[])
{
	ALLEGRO_DISPLAY *janela = NULL;

	if (!al_init())
	{
		fprintf(stderr, "Falha ao inicializar a Allegro 5\n");
		return -1;
	}

	janela = al_create_display(640, 480);
	if (!janela)
	{
		fprintf(stderr, "Falha ao criar a janela\n");
		return -1;
	}

	al_clear_to_color(al_map_rgb(255, 255, 255));

	al_flip_display();

	al_rest(10.0);

	al_destroy_display(janela);

	return 0;
}

Para compilar e executar o programa, basta digitar no Terminal:

gcc -lallegro -oteste main.c

./teste

Pronto! Se deu tudo certo, aparecerá uma janela preenchida de branco que permanecerá na tela por 10 segundos.

Espero que ajude, e aguardem por mais posts sobre a Allegro 5! Até a próxima! 😀

Puppy Linux: a Solução para o Positivo Mobo 2Gb

Padrão

Tudo começou com a necessidade de tornar utilizável um netbook Positivo Mobo que estava parado aqui em casa. O que tornava tal tarefa problemática era o fato dele possuir a unidade de armazenamento com apenas 2Gb – ele não tem HD, só uma memória flash. As demais configurações são relativamente interessantes, ainda mais levando-se em conta que ele apareceu por aqui no final de 2008 – processador de 900MHz (que eu não sei ao certo qual é) e 512Mb de memória RAM.

Originalmente, ele veio com uma instalação do Metasys – uma distribuição Linux amplamente utilizada pelo governo de Minas em telecentros e escolas. Esse ‘netbook’ foi ganho pelo meu irmão em uma premiação. Na versão comercial, ele vinha com o Windows XP Home edition, digamos, enxugado. Mas nenhuma dessas possibilidades me parecia adequada.

Olha ele aí...

Logo de cara, quando ele chegou, tentei instalar o Ubuntu Netbook Remix. Mas, a instalação acabava parando, dizendo que não era possível concluir a instalação por falta de espaço em disco. Depois, tentei instalar o XUbuntu. Instalou, mas o disco ficou com menos de 50Mb livre, o que fazia com que o computador se tornasse extremamente lento.

Após isso, ele acabou ficando encostado por um bom tempo. Até que, algumas semanas, meu irmão pediu pra eu tentar dar um jeito nele. Foi aí que começaram minhas pesquisas.

De 2008 pra cá, minha familiaridade com os sistemas Linux aumentou consideravelmente. Posso não ser um expert, principalmente no poderoso e temido Terminal, mas consigo me virar bem – até já compilei kernel! Hahahaha.

Enfim. Primeiramente, comecei a pesquisar sobre os ambientes gráficos, que na maioria dos casos, eram os devoradores de disco que faziam com que o sistema não coubesse na memória flash do Mobo. De cara, descartei o Gnome e o KDE. Ou seja, os sistemas que eu tinha mais familiaridade – Ubuntu e Kubuntu – já podiam cair fora. X11 então, pareceu-me a saída mais interessante, já que o Xubuntu já havia instalado uma vez.

Outra coisa que me preocupava um pouco era o fato da baixa resolução da tela: apenas 800×480 pixels. Isso muitas vezes ocasionava problemas pelo fato da janela ser maior que a tela, de forma que campos ou mesmo os botões de confirmação acabassem ficando ‘inclicáveis’, ficando fora da janela.

Algumas das tentativas de sistema – que não funcionaram – foram o Lubuntu (versão do Ubuntu usando o ambiente LXDE – Lightweight X11 Desktop Environment) e o Fedora (também com LXDE). O Lubuntu não conseguia completar a instalação por falta de espaço e o Fedora nem sequer começava a instalar, também por falta de espaço.

Foi então que encontrei uma distribuição que parecia ser a resolução de todos os problemas (ou pelo menos praticamente todos): o Puppy Linux.

Comecei a ler sobre ele, e encontrei depoimentos extremamente animadores de pessoas dizendo ter rodado ele em computadores com Pentium 2 com pouco espaço de armazenamento. Então, parti pra baixá-lo.

Logo de cara, me surpreendeu o tamanho da imagem dele: apenas 127Mb. Todas as outras distribuições que eu havia tentado giravam em torno de 650 a 700Mb. Como o Mobo não possui drive de CD/DVD, tive que fazê-lo bootar a partir de um pendrive. Passei a iso para o pendrive usando a ferramenta Universal USB Installer, muito simples de usar, diga-se de passagem.

Logo de cara, ele funciona como um Live CD – criando um desktop totalmente funcional. O processo de instalação eu adaptei daqui. Apesar do sistema ser em inglês, a instalação é bastante intuitiva.

O Puppy Linux possui também um gerenciador de pacotes semelhante ao Synaptic e uma interface legalzinha pra instalar programas facilmente.

No final das contas, depois de instalar o sistema todo, mais o Opera como navegador e o Pidgin pra mensagens instantâneas, o disco ainda ficou com 925Mb livres – isso porque eu coloquei 400Mb de swap!

Imagem ilustrativa do Puppy Linux (clique para ampliar)

Quanto ao problemas das janelas maiores que a tela, ainda me deparo com isso de vez em quando. Mas vou pesquisar um pouco mais – ao que me parece, o Puppeee Linux é uma modificação do Puppy Linux para o netbooks. Aparentemente ele otimiza a interface para telas pequenas. Assim que testar, posto aqui! 🙂

Bom pessoal, é isso. Queria apenas “narrar” a minha história com esse “netbook” (sim, entre aspas mesmo) e talvez ajudar alguém que tenha algum problema parecido ou que queira brincar um pouco (por que não instalar o Puppy Linux naquele Pentium III encostado na sua casa?)

Até a próxima! 😀

Atualização: o Puppeee não ficou legal. Não consegui configurar a resolução correta da tela (800×480) – ele só tem as opções padrão (640×480, 800×600…). Então vou ficar com o Puppy original mesmo. 🙂

Out-of-series #3 – Configurando a biblioteca Allegro no Code::Blocks (Ubuntu)

Padrão

Aow povo! Olha eu aqui de novo. Na verdade antes do que eu planejava, mas é por um post Out-of-Series, quase de utilidade pública.

Comecei a mexer com a biblioteca Allegro em 2008, quando eu estava no primeiro ano da faculdade. Conheci a biblioteca através de um mini-curso ministrado pelo Tulio Faria. Na época eu estava iniciando na programação, começando a mexer com a Linguagem C. Foi nesse ano que eu e minha e equipe fizemos o jogo Deviner (que pode ser visto na seção de projetos, ali em cima), utilizando a Allegro. Na busca por fazer o projeto da melhor maneira possível, alguns dos objetivos não foram atingidos, como utilizar imagens JPG, sons no formato MP3 e utilizar a biblioteca Allegro no Linux.

No ano passado, ao ministrar o curso da biblioteca, consegui utilizar com sucesso os formatos JPG e MP3 em projetos com a biblioteca Allegro (oh, linker…). Mas neste post vou mostrar como colocar pra rodar a biblioteca Allegro no Ubuntu, utilizando a IDE Code::Blocks. Apesar de alguns entusiastas do Linux pregarem a programação sem o uso de IDEs (em casos extremos usando apenas o VI…), elas auxiliam muito no gerenciamento de um projeto, mesmo que de pequeno porte (que é o caso das primeiras aplicações em Allegro).

Então, vamos começar o tutorial. Primeiramente devemos verificar se o compilador GCC está instalado no computador. O Ubuntu, na instalação padrão, o remove do sistema (não sei por que…). Mas podemos facilmente instalá-lo. Abra o Console ou Terminal e digite:

sudo apt-get install build-essential

Confirme o pedido para baixar os pacotes e aguarde a instalação. Após isso, já devemos ter o compilador funcionando.

O próximo passo é instalar o Code::Blocks. Existem duas opções para isso. A primeira é utilizar um gerenciador de pacotes, como o próprio apt-get, ou se você está iniciando no mundo Linux, pela interface gráfica, através do menu Aplicativos -> Central de Programas Ubuntu ou alguma coisa parecida (o nome muda um pouco dependendo da versão do Ubuntu). Se optar pelo apt-get, use o seguinte comando:

sudo apt-get install libwxgtk2.8-0 libcodeblocks0 codeblocks libwxsmithlib0 codeblocks-contrib

Caso utilize a Central de Programas, procure por IDE Codeblocks. A segunda opção é baixar o arquivo já compilado para o Ubuntu no próprio site do Code::Blocks. Procure na seção de downloads e efetue o download. Após concluído, dê um duplo clique no arquivo .deb. A instalação deverá ocorrer sem maiores problemas.

O próximo passo é baixar os pacotes da biblioteca Allegro. Vá até o Terminal e digite:

sudo apt-get install liballegro4.2 liballegro4.2-dev liballegro-doc

Após a instalação, já teremos tudo o que precisamos. Falta somente configurar a biblioteca dentro da IDE.

Abra o Code::Blocks e crie um novo projeto vazio (Empty Project). Configure um nome qualquer e onde o mesmo será salvo. Deixe o compilador como GCC mesmo. (clique nas imagens para ampliar)

Prosseguindo, vamos adicionar um novo arquivo ao projeto. File -> New -> File…, selecione a linguagem como C, escolha o local onde salvá-lo (normalmente a mesma pasta onde você salvou o projeto) com o nome main.c e selecione as opções Debug e Release, para adicionar o arquivo ao projeto atual.

Agora iremos configurar o compilador e o linker para reconhecerem a biblioteca Allegro. Ainda com o Code::Blocks aberto, abra o Terminal e digite os seguintes comandos:

allegro-config –libs

allegro-config –cflags

Voltando ao Code::Blocks, vá em Settings -> Compiler and Debugger… Na aba principal Compiler settings, aba secundária Other options cole o conteúdo retornado pela chamada a allegro-config –cflags.

Agora, vá até a aba principal Linker settings e adicione o conteúdo retornado pela chamada a allegro-config –libs ao campo Other linker options.

Pronto! Agora vamos testar se tudo está funcionando corretamente. Digite o seguinte código no arquivo main.c:

#include <allegro.h>

int main(void)
{
   allegro_init();
   allegro_message("striker07.wordpress.com");
   allegro_exit();

   return 0;
}
END_OF_MAIN()

Dê um F9 para rodar e o resultado deverá ser uma janelinha mostrando a mensagem striker07.wordpress.com 🙂

Você pode perceber que o Code::Blocks exibe uma janela de console junto com a aplicação. Para remover isso, vá ao menu Project -> Properties. Na aba Build targets, troque a opção que está como Console application para GUI application.

Bom, é isso. Quando der um tempinho eu posto aqui como utilizar imagens JPG e arquivos em MP3.

Até a próxima!