Ubuntu (I’m using 11.04)
Jenkins (I’m using v1.4.21)
Android SDK (I’m using r12)
Git

Installing Xvnc

We need to run Android’s emulator to test the interface. For such, we need a X server running on the machine. The easier way to do so on a headless box is using Xvnc. To install it, do:

$ sudo apt-get install vnc4server

If you don’t have a window manager (GNOME, KDE, etc.), install fluxbox, a lightweight WM:

$ sudo apt-get install fluxbox

After this, we have to set a password for the vncserver.

$ sudo su jenkins
$ vncserver

You will require a password to access your desktops.

Password:
Verify:

New 'luna:1 (jenkins)' desktop is luna:1

Creating default startup script /var/lib/jenkins/.vnc/xstartup
Starting applications specified in /var/lib/jenkins/.vnc/xstartup
Log file is /var/lib/jenkins/.vnc/luna:1.log

Configuring git

We need to configure Jenkins’ user git name and e-mail. To do so, open a terminal and do:

$ sudo su jenkins
$ git config --global user.name "Jenkins"
$ git config --global user.email "jenkins@no-email.com"

Configuring Jenkins

If you haven’t changed Jenkins’ configurations, it’s server is listening at http://localhost:8080. Open it and click into Manage Jenkins -> Configure System. Scroll down to the Android subsection, and write your Android SDK path into the text input. Then, find the Maven subsection, click into Add Maven and set the values as:

Also, go to Jenkins’ main page then Manage Jenkins -> Manage Plugins and, at the Available tab, look for the plugins Hudson Xvnc, Jenkins Zentimestamp, Android Emulator and Jenkins GIT. Check every one of them and click Install. At the following screen, check Restart Jenkins when installation is complete and no jobs are running.

Adding a project to Jenkis

We’re going to add the morseflash example from maven-android-plugin samples to our Jenkis, to check if everything is configured properly.

• Download the samples from https://github.com/jayway/maven-android-plugin-samples/tarball/alpha;
• Extract into /tmp (or any other folder) and rename jayway-maven-android-plugin-samples-3fe4aed to samples (just to make it easier);
• Create a git repository inside the morseflash subfolder using:

  $ git init
  $ git add *
  $ git commit -a -m "Initial commit."
  

• Edit the line 16 in pom.xml, changing from ${maven.build.timestamp} to ${BUILD_ID};
• Open http://localhost:8080 and click in New Job;
• Write “morseflash” in Job name, select Build a maven2/3 project and click OK;
• Configure it like the following image and click Save:
  

After this, you can wait a little bit and Jenkins will automatically build the first version, or you can click in Build Now. Either way, a new build will appear at the Build History block in the bottom left of the page:

Click on its link, then click in Console Output. You should see a lot of messages passing by and, in the end, you should see something like:

[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] MorseFlash Parent ................................. SUCCESS [1.319s]
[INFO] MorseFlash - Library .............................. SUCCESS [5.048s]
[INFO] MorseFlash - App .................................. SUCCESS [4.028s]
[INFO] MorseFlash - Instrumentation Test ................. SUCCESS [12.702s]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 25.714s
[INFO] Finished at: Thu Jul 21 14:05:31 BRT 2011
[INFO] Final Memory: 19M/197M
[INFO] ------------------------------------------------------------------------
channel stopped
[android] Stopping Android emulator
[android] Archiving emulator log
Terminating xvnc.
$ vncserver -kill :10
Killing Xvnc4 process ID 25580
Finished: SUCCESS

Bingo! You now have a Continuous Integration infrastructure for Android apps. Every minute Jenkins pools git and, if it finds something new, rebuilds everything. If something goes wrong, check if you did all the steps of the tutorial. If you can’t figure it out, ask a question in the comments section and I’ll try to help.

References

• Installing the Android SDK
• Installing Jenkins on Ubuntu
• Maven Android Plugin
• Run UI tests on a headless Jenkins / Hudson Continuous Integration server running Ubuntu

Como tudo começou

O @pizzariaze @alexandrend lançou no dia 17 15 de outubro uma cartela com algumas pérolas do candidato Zé Maranhão. A ideia era que você imprimisse e fosse marcando ao assistir aos debates.

Achei genial. Teve uma boa repercussão no Twitter e, no dia seguinte, Alan Kelon, um professor da UFPB e amigo, lançou um desafio na lista de estudantes de Computação da federal: fazer uma aplicação web com a ideia do bingo. Fiquei com isto na cabeça.

Naquele dia estava com insônia. Já eram mais de 2 da manhã e não tinha sono algum. Então Samara, minha namorada, me liga. Também estava lesando no computador. Contei pra ela sobre o bingo e, depois de rirmos bastante, veio a proposta: bora fazer agora?

Ela disse sim

Primeira versão

Três horas da manhã de uma terça-feira, estávamos eu e ela com o notebook na cama e um modem 3G. Primeiro passo: procurar algo já pronto. Rapidamente encontrei este post que mostrava como fazer um bingo “padrão” com JavaScript, JQuery e CSS.

Perfeito! Só precisaria modificar pra usar frases ao invés de números e estilizá-lo. Depois de pouco mais de uma hora chegamos a isso:

Alguns detalhes técnicos

Houve duas sacadas que acho interessante falar. Se você não for de computação ou não estiver interessado em saber como funciona o bingo, aguarde pela parte 2 deste post.

Gerando uma URL única para cada cartela

Fiz algumas funções pra compartilhar o bingo no twitter. Uma delas é que, quando você fecha uma linha ou coluna (exceto a central) ou a cartela toda, você pode enviar uma mensagem do tipo “Fiz 2 colunas no #BingoDoZe!”. Mas, pra ficar mais interessante, queria adicionar o link da sua cartela nesse tweet. Mas como?

O sistema é feito todo só com JavaScript. Não consigo (facilmente) usar um banco de dados. Primeiro pensei em reescrevê-lo em Ruby ou PHP, mas fiquei com preguiça. Pensei mais um pouco, fiquei olhando o código para ver se surgia alguma ideia, então me veio a luz. Antes de tudo, deixe-me explicar como funciona o código.

Eu tenho um array com as pérolas. Para gerar a cartela, eu o embaralho e coloco os 25 primeiros termos e nos campos do bingo. A solução que encontrei para gerar sempre a mesma é adicionar uma semente ao algoritmo do Math.random().

1
2
3
4
5
6
7
8
9
10
11
12
13

function fillCards(seed){
    Math.seedrandom(seed);
    var shuffle = function() { return 0.5 - Math.random(); };
    var termos_shuffled = termos.sort(shuffle);
 
    for(var i = 0; i <= 24; i++){
        // Pula a imagem de Maranhão
        if (i == 12)
            continue;
 
        $('#cell'+i).html(termos_shuffled[i]);
    }
}

Uma linguagem de programação gera números (pseudo-)aleatórios a partir de diversos cálculos em cima de um valor inicial. Se você puder definir qual é esse valor, então a função sempre retornará os mesmos resultados. O que faz isso é a linha 2, Math.seedrandom(seed).

Infelizmente, não tem como fazer isso nativamente em JavaScript. Mas basta adicionar o seedrandom.js, criado pelo David Bau e disponibilizado no seu blog. Funcionou perfeitamente.

Como seed usei um hash na URL, na forma http://labs.vitorbaptista.com/bingodoze/#367660 (neste caso, o seed é #367660). Ao entrar em http://labs.vitorbaptista.com/bingodoze, se já houver um hash, usa ele como seed. Caso contrário, gera um aleatoriamente.

Salvando que campos foram marcados

Depois do passo anterior os jogadores conseguem compartilhar suas cartelas. Mas quem acessar meu link vai encontrá-la vazia. Como persistir os campos marcados?

Seguindo a ideia de adicionar os dados à URL, tive a ideia de codificar o que foi marcado em um inteiro. Bem simples: tenho um número com 25 bits, cada um representando uma célula. Os que estiverem em 1, estão ativos; em 0, desativos.

Para isso, há duas funções principais: cartelaToMask() e maskToCartela(mask). A primeira retorna um inteiro que representa a cartela, e a segunda faz o caminho inverso, recebendo um inteiro e preenchendo a cartela. Vejamos:

1
2
3
4
5
6
7
8
9
10

function cartelaToMask() {
    var mask = 0;
 
    for (var i = 0; i <= 24; i++) {
        if ($('#cell'+i).hasClass('ativo'))
            mask |= masks[i];
    }
 
    return mask;
}

Bem simples. Há o inteiro mask inicializado com 0 e, para cada célula, checo se ela tem a classe CSS “ativo”. Se sim, eu coloco o bit correspondente em 1. No final, retorno o mask.

O array masks usado no algoritmo possui as potências de 2 já calculadas. Ou seja, masks[0] == 1, masks[1] == 2, masks[2] == 4, e por aí vai. É uma solução muito deselegante. O ideal seria gerar esses valores provavelmente usando bit shifting.

1
2
3
4
5
6

function maskToCartela(mask) {
    for (var i = 0; i <= 24; i++) {
        if (mask & masks[i])
            $('#cell'+i).addClass('ativo');
    }
}

O caminho contrário é bem parecido. Eu faço um laço de 0 até 24 pegando o bit correspondente (mask & masks[i]). Se ele estiver ativo, adiciono a classe “ativo” à célula. Pronto.

Esse inteiro é codificado em hexadecimal e adicionado a URL. Assim temos algo como http://labs.vitorbaptista.com/bingodoze/#367660-1d50170, onde #367660 é a semente e 1d50170 é a máscara.

Se você faz computação e teve problemas em entender a lógica dos operadores bit-a-bit usados nesse código, dê uma lida aqui. É simples e pode ser bem útil.

Eu pretendia só falar das estatísticas do Bingo do Zé, mas acabei me empolgando e falando demais. Vou deixá-las para a parte 2 deste post. Se você estiver curioso, pode ir vendo as estatísticas de tweets em http://summarizr.labs.eduserv.org.uk/?keyword=bingodoze

Há alguns meses a ABR Telecom trocou o captcha por outro bem mais forte. Logo, o site não funciona mais. Se alguém precisar dessa funcionalidade, basta comprar o acesso por meros R$ 4.372,21 mensais

Desde março de 2009, há no Brasil a portabilidade numérica para telefones fixos e celulares. Isto quer dizer que podemos trocar de operadora de telefonia sem trocar de número. Assim, se outra empresa oferecer um plano mais vantajoso, podemos migrar para ela sem precisar avisar a todos nossos contatos que trocamos de número.

Mas isso também gera um problema: antes, cada operadora tinha uma faixa de números. Na Paraíba, a gente sabia que um celular era da Oi se começasse com 88, da Claro se fosse com 93, etc. Com a portabilidade não dá mais pra saber assim, é preciso consultar o número no site da ABR Telecom.

Até aí tudo bem. Mas eu tenho quase 500 contatos no meu celular, toda vez que eu quiser saber se posso ligar para um número sem ter que pagar minutos extra (tenho bônus pra Oi), vou ter que consultar nessa página? Preciso de uma maneira melhor.

Eu tenho um celular com Android, o Nexus One. De cara, pensei em fazer um aplicativo que consultasse os dados da ABR Telecom e me mostrasse qual é a operadora de cada contato, quem sabe com um ícone ao lado da foto. Não deve ser muito complexo. Mas, quando fui ver, me deparei com o primeiro problema: o CAPTCHA.

CAPTCHA são aquelas letras distorcidas que a gente tem que digitar em alguns sites. Ele serve para evitar que uma pessoa automatize uma determinada tarefa, como tentar logar em um site, criar contas no orkut. Desta forma, ele evita que alguém crie um programa para testar todas as possibilidades de sua senha no GMail, por exemplo. Idealmente, as letras são muito difíceis de um computador detectar, mas fáceis para um humano.

O site da ABR Telecom tem um CAPTCHA. Do jeito que ele está, eu não consigo fazer um programa para checar a operadora dos meus 500 contatos. A não ser que eu consiga quebrar esse CAPTCHA. Hum…

Foi isso que eu fiz (explico em outro post). Não foi difícil, eles usam um CAPTCHA muito simples. Daí nasceu o http://qualeaoperadora.de, um site que tem a mesma funcionalidade que o ABR Telecom (inclusive usa ele por baixo dos panos), mas sem o CAPTCHA. Assim, você pode criar novos softwares e sites usando as informações do meu. Isto está bem na moda, e se chama mashup.

Eu não parei por aí. Além de você poder acessar as informações digitando no site, ou adicionando diretamente o telefone na URL (como em http://qualeaoperadora.de/6132160000), você também pode pegar em dois formatos diferentes: YAML e JSONP. Para o primeiro, basta adicionar .yml ao final (http://qualeaoperadora.de/6132160000.yml); para o segundo, adicione .json (http://qualeaoperadora.de/6132160000.json). Se quiser especificar a função pra callback, também pode fazer http://qualeaoperadora.de/6132160000.json?callback=minhaFuncao. Em JSONP, eu também retorno uma URL para o logotipo da operadora e a UF do Estado.

Ainda não fiz o software para buscar isso no meu Android, nem sei se vou fazer. Mas, com esse site, você mesmo pode fazê-lo. Esteja à vontade, mashups são divertidas. Se fizer algo, não deixe de me avisar

Ah! Se você quiser dar uma olhada no código do http://qualeaoperadora.de, ele é livre e está disponível em http://www.gitorious.com/vitorbaptista/qualeaoperadora-de

O LAViD está nos apoiando nisto. Vamos ter uma câmera HD para gravar algumas palestras e transmitir a do RMS para as outras 2 salas. Só que, pensando com o pessoal, decidimos que o áudio a ser transmitido não vai ser o do Stallman, mas o do tradutor. Aí vem o problema: como transmitir o áudio da cabine de trasmissão para as outras duas salas? Lembrava que dava pra fazer isso com o SSH, então fui testar.

Fazer localmente é fácil. Basta executar:

dd if=/dev/dsp of=/dev/dsp

O que isto faz? Simples. Lembre-se que nos sistemas POSIX tudo é um arquivo. E /dev/dsp é o arquivo que representa a placa de som. Numa linguagem natural, o comando acima quer dizer “Copie o que tem em /dev/dsp para /dev/dsp.”

Como assim? Se eu copiar um arquivo para ele mesmo, o resultado não deveria ser… o mesmo arquivo? Depende. Neste caso, por exemplo, ler da placa de som (/dev/dsp) significa “capturar o audio que vem do microfone.” E escrever significa “tocar.” Juntando, você está “capturando o audio que vem do microfone e tocando.”

Fácil. Agora, como fazer isso em dois computadores diferentes? Eu sei que vou ter que ler do /dev/dsp de um computador e escrever no /dev/dsp do outro, mas como?

Vamos por partes. Primeiro, para ler o /dev/dsp, usamos:

dd if=/dev/dsp

O dd vai ler o arquivo e escrever na saída padrão. Neste caso, a tela. Então, precisamos redirecionar isso para o outro computador. É aí que entra o SSH. Se fizermos:

ssh [destino]

Ele vai abrir um shell no destino. Não é o que queremos. Temos a opção de usar:

ssh [destino] dd of=/dev/dsp

Ao invés de abrir um shell, o SSH vai executar o comando que passamos (dd of=/dev/dsp). Neste caso, o dd escreve tudo que receber da entrada padrão (teclado) para o arquivo /dev/dsp. Se você escrever algumas coisas aleatórias, vai ouvir uns barulhos na caixa de som. Ele está interpretando o que você está escrevendo como som. Ótimo! Estamos chegando perto. Agora só precisamos ligar a saída do primeiro comando, que lê do /dev/dsp de uma máquina, a entrada do ssh. Como? Usando pipes, é claro!

dd if=/dev/dsp | ssh [destino] dd of=/dev/dsp

O que essa barrinha discreta aí faz é conectar a saída padrão do comando a esquerda com a entrada padrão do da direita. Pronto! Executando isso, já conectamos o microfone de um PC com a caixa de som de outro. Para melhorar um pouco, podemos pedir pro SSH comprimir o tráfego, adicionando a opção -C.

dd if=/dev/dsp | ssh -C [destino] dd of=/dev/dsp

Mesmo assim, ainda não fica muito bom. Aqui, apesar dele usar só 5 KB/s de banda e as máquinas estarem na mesma rede wifi, fica uma latência muito grande. Talvez seja culpa do SSH ou do dd, e não da velocidade da conexão. Não sei.

Mas pode dizer. Muito foda, não é?

Tentei usar o GIMP para resolver, usando a Magic Wand, mas ele não consegue pegar tudo, pois parte do fundo não é 100% branco. Colocando sobre um fundo preto, ficou assim:

Como resolver? Sei que, se eu diminuísse a precisão da Magic Wand, fazendo ela pegar não só 100% branco, mas entre 90% e 100%, por exemplo, melhoraria. Quiçá, resolvesse. Mas, como? Não encontrei essa configuração. Sei que poderia criar um plugin em Python pro GIMP que resolveria, mas como nunca fiz isso, iria demorar.

Então eu vi a luz.

Relembrando as aulas de PDI – Processamento Digital de Imagens -, que paguei semestre passado. Uma das cadeiras mais interessantes até agora, uma pena que, por uma razão qualquer, não aproveitei tanto. Mas aprendi a programar usando o Octave.

O GNU Octave é uma linguagem para fazer cálculos matemáticos, muito parecida com o MatLab. Nela a gente consegue trabalhar com matrizes sem problema algum. Por exemplo, se você tiver uma matriz 3×3 e quer somar com uma outra de mesmo tamanho o que faz? Um for por cada elemento da matriz somando um com o outro? Não! Simplesmente matrizA + matrizB. E o que são imagens que não grandes matrizes de pixels?

A idéia é: passar por cada pixel da imagem e, se ele for mais claro que um determinado valor, transformo ele em magenta. Daí nasceu o Magentinizator!

Fazer isto em Octave é trivial. O código comentado é:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# Magentinizator v 0.42 - 2009
# ----------------------------------------------------------------------------
# "THE BEER-WARE LICENSE" (Revisão 42):
# <vitor@vitorbaptista.com> escreveu este arquivo. Contanto que mantenha este 
# texto, você pode fazer o que quiser com esse software. Se nos conhecermos
# algum dia, e você achar que esse programa vale, você pode me pagar uma cerveja
# em troca.
#                                                               Vitor Baptista
# ----------------------------------------------------------------------------
 
path = "uepb.png";                # Caminho para a imagem
threshold = 0xB4;                 # Pixels com cor maior que 0xB4B4B4
                                  # se tornarão 0xFF00FF
 
im = imread(path);                # Lê a imagem. im agora tem uma matriz
                                  # Largura x Altura x 3 (RGB)
 
tam = size(im);                   # Pega o tamanho da imagem
 
for i = 1:tam(1)                  # De 1 até a largura
  for j = 1:tam(2)                # De 1 até a altura
 
    if (im(i, j, 1) > threshold   # Se o R for maior que o threshold, e
        && im(i,j,2) > threshold  # se o G for maior, e
        && im(i,j,3) > threshold) # se o B for maior.
 
      im(i,j,1) = 255;            # Torna aquele pixel
      im(i,j,2) = 0;              # em
      im(i,j,3) = 255;            # magenta!
    end
  end
end
 
imwrite([path, ".magentinized"], # Concatena strings
        im(:,:,1),               # R
        im(:,:,2),               # G
        im(:,:,3));              # B

O resultado ficou ótimo. Não perfeito, mas bem melhor que usando o GIMP e mais que o suficiente pro site do ENSOL.

Se precisar tirar mais o branco, só diminuir o threshold. Lembrando que vai chegar um momento que vai tornar outras partes da imagem também magenta.

Você pode baixar o Magentinizator aqui.

O que é análise?

“É o estudo das características que o sistema deverá ter para atender às necessidades e expectativas do cliente.” [1] Usualmente são usados modelos para representar graficamente os componentes do sistema e as relações entre si e com o ambiente.

Pra que serve?

Antes de codificarmos, é importante entendermos o que queremos fazer. Para isto, análise nos dá uma visão geral do sistema e dos relacionamentos de seus componentes entre si e com os usuários. Com isto, conseguimos estimar melhor a complexidade, custos (de tempo e dinheiro), e detectar erros, além de gerar um documento com o qual podemos comparar as funcionalidades finais do sistema com as propostas, para determinar se ele cumpre ou não com seu objetivo.

Análise Estruturada

Nela construímos o sistema de forma top-down (do geral para o particular) criando um Diagrama de Fluxo de Dados (DFD) e refinando-o sucessivamente. Inicialmente obtemos uma visão geral do sistema, então decompomos cada módulo detalhando suas funcionalidades. Com isto, começamos a ter pistas sobre os processos e as entidades, os quais, estruturaremos usando o Diagrama Entidade Relacionamento (DER).

Desenvolvimento de software pelo método da Análise Estruturada

Uma técnica comumente usada é, na descrição dos requisitos, separar os verbos e os substantivos, como candidatos para tornarem-se processos e entidades, respectivamente. A conexão entre eles se dá através de um fluxo dos dados.

Análise Essencial

É um melhoramento da análise estruturada. Nela, o problema é inicialmente estudado concentrando-se na identificação das funcionalidades lógicas, sem se preocupar com as exigências físicas de como o sistema será implementado. Para isso, definimos o modelo essencial, que é subdividido em ambiental, que vai definir a fronteira entre ele e o ambiente; comportamental, que descreve as partes internas necessárias para interagir com o ambiente, e; de informação, que nos dá os dados necessários as atividades do sistema. Assim, tem-se a solução ideal do problema, a qual desejaríamos se não tivéssemos limites de custos, velocidade, armazenamento, etc..

Depois, definimos o modelo de implementação, que é quem vai trazer o modelo essencial para dentro de nossas limitações e requisitos físicos. É nele que definimos o modelo lógico de dados, a interface homem-máquina, a plataforma de execução, a linguagem, etc.. Enfim, tudo que diga respeito a implementação de nosso sistema.

Referências

1. http://pt.wikipedia.org/wiki/Análise_de_requisitos
2. http://www.creupiapostilas.hpg.ig.com.br/analise_estruturada.doc
3. http://www.noginfo.com.br/arquivos/AES_Aula_05.pdf
4. http://www.creupiapostilas.hpg.ig.com.br/AnaliseEssencial.doc

Ruby é uma linguagem dinamicamente tipada de altíssimo nível, semelhante a Python. Apesar de seu uso ter se popularizado pelo framework web Rails, ela não se limita a isso. Neste minicurso você aprenderá um pouco de Ruby e vai utilizá-la em uma das partes mais divertidas da computação: o desenvolvimento de jogos.

Download PDF

Pela manhã estava com a sala lotada, ~40 pessoas, e pela tarde tinham ~10. Muito obrigado a todos que se inscreveram e participaram do minicurso, foi uma ótima experiência, a minha primeira. Espero que tenha dado para aprender um pouco de Ruby e desenvolvimento de jogos com o Gosu. Os slides estão aí em cima e o jogo desenvolvido foi o do tutorial oficial do Gosu, só pegar em http://code.google.com/p/gosu/wiki/RubyTutorial.

Parabéns aos organizadores do evento! Em especial, pois é o que eu conheço mais, é meu amigo, e foi quem eu aperriei para fazer o FLISOL, o Joseph.

Se alguém tiver alguma sugestão em como melhorá-lo, adoraria ler. A primeira parte da palestra, que é apresentando Ruby, achei meio chatinha, já que quase não há prática, é só uma palestra normal. Mas, quando começa o desenvolvimento do jogo, fica bem legal. Depois dos minicursos pensei que pudesse ser melhor que o jogo fosse sendo construído intercalando com o aprendizado da linguagem, sem ter essa divisão parte 1/parte 2. Difícil, mas vou tentar

Certo, mas o que é um emulador mesmo?

E como eu faço isso?

ADD x,n

x = x + n

sudo aptitude install ttyrec

stty columns 80 rows 24 ttyrec -e nethack

1

#include "SDL/SDL_gfxPrimitives.h"

2
3

//Desenha uma linha com anti-aliasing, para aumentar a qualidade
aalineRGBA(tela, 500, 20, 550, 150, 0, 0, 0, 255);

4
5

//Desenha um círculo
filledCircleRGBA(tela, 50, 50, 30, 0, 0, 255, 255);

6
7

//Desenha uma elipse
filledEllipseRGBA(tela, 200, 300, 100, 50, 125, 125, 255, 255);

8
9

//Desenha um retângulo
boxRGBA(tela, 400, 300, 600, 350, 255, 0, 0, 255);

10
11

//Desenha um triângulo
filledTrigonRGBA(tela, 200, 20, 300, 20, 240, 90, 255, 255, 0, 255);

12
13

//Desenha uma string
stringRGBA(tela, 100, 400, "www.vitorbaptista.com", 0, 0, 0, 255);

Baixe os fontes deste exemplo aqui.