Para quem tiver interesse, o vídeo pode ser visto logo abaixo, ou na página do PHP-PB (php-pb.net). E disponibilizei os slides da palestra no meu slideshare: http://www.slideshare.net/jaimecpn.
Link direto para esta palestra: http://www.slideshare.net/jaimecpn/certificao-zend-framework.

Bom, como não há como compará-los em relação ao hardware, já que o iPad Mini é bem mais recente, vou focar nos aspectos mais gerais, e no sistema operacional.

A primeira coisa que me chamou atenção no iPad Mini e que finalmente me fez querer ter um produto da Apple (explico isso mais adiante…) foi o tamanho da tela, a espessura e o peso do tablet. Eu nunca gostei do tamanho o iPad tradicional, 10 polegadas pode ser um tamanho ótimo pra quem só usa ele em casa, mas é muito grande pra quem gosta de estar sempre com seu tablet onde quer que vá.

Quanto a nunca ter tido vontade de ter produtos da Apple, não é que ache que os produtos sejam ruins. Longe disso, sempre soube que são excelentes, mas nunca gostei da filosofia da empresa e de como ela faz pra prender seus consumidores, obrigando você a usar os produtos (sempre caros) dela se quiser ter o máximo do que oferecem. Darei alguns exemplos mais a frente quando for falar sobre os sistemas operacionais.

Um dos pontos que os fanboys da Apple sempre gostam de argumentar é da quantidade de aplicativos disponíveis na iTunes Store em comparação com os aplicativos para Android da Play Store do Google. OK, realmente tem bem mais coisas, não se pode negar. Porém, pelo menos pra mim, nunca teve nada que eu tenha procurado para Android que não tenha achado, então, no fim das contas, não adianta existirem bilhões de aplicativos se você só usa uma centena. Se o Android também tem essa mesma centena de aplicativos, então esse argumento não vale de muita coisa.

Falando em aplicativos, vem aqui a minha maior crítica aos produtos da Apple: iTunes. Como era bom poder passar arquivos de qualquer computador para meu Kindle Fire simplesmente plugando ele no computador e usando como se fosse um pendrive, sem a necessidade de instalar nada. É um saco você só poder passar arquivos através do iTunes, além de muitas vezes inconveniente. Como se não bastasse, o Bluetooth não se conecta com outros aparelhos que não os da Apple, pois é um Bluetooth próprio. Mas nem vou falar muito do Bluetooth, pois o Kindle Fire nem Bluetooth tem (tem no KFHD). Outra personalização que incomoda um pouco é o conector, que não segue os padrões do mercado. Novamente a Apple faz tudo diferente, quando o Kindle Fire usa o já corriqueiro micro USB.

O iPad é mais bonito, sem dúvida, mais atraente e mais fácil de usar. Apesar que a Amazon fez um ótimo trabalho na personalização do Android pro Kindle Fire, tornando ele bem mais prático que o visual padrão do Android, que é legal também, mas é menos atraente e menos prático. Acredito que esse seja um argumento bom pra um usuário comum ou que tenha dificuldade com tecnologia, mas não é bem o caso, já que trabalho com isso.

Um argumento forte em favor do Android, é o leque de opções na hora de escolher seu tablet, você pode mudar do Kindle Fire pra um Samsung Galaxy (ou para um Tablet da Sony, ou qualquer outra marca que use Android, até mesmo um xingue-lingue chinês) e seus aplicativos comprados (na Play Store, não na loja da Amazon) irão servir em qualquer um desses (se o hardware permitir). Isso te permite comprar tablets mais em conta e ainda assim usar os mesmos aplicativos. Já o iPad, você só muda pra outro iPad mais novo, ou perde o que comprou na iTunes Store, sem falar dos preços absurdos, especialmente no Brasil.

Até esse ponto, parece até que me arrependi de comprá-lo, certo? Bom, eu estava decidido a comprar o Kindle Fire HD, até ver pessoalmente o iPad mini… Como falei antes, fiquei super atraído pelo tamanho, espessura e peso dele, e nem cheguei a vê-lo ligado, mas já fui pesquisar o preço na internet, vi que custava o equivalente ao KFHD, e resolvi dar uma chance à Apple. Consegui comprá-lo nos EUA, e, quer saber? Esse danado tem algo inexplicável que encanta mesmo. Eu entendo agora porque a maioria das pessoas que usam viram fanboys e acham que não há comparação. Só sendo um cara de TI, ligado em detalhes, e ainda não convertido a fanboy, pra encontrar tantos argumentos para balancear essa comparação mesmo.

Enfim, se alguém me perguntar hoje qual tablet comprar, a resposta será: se tiver muita grana pra gastar, ou tiver como comprar nos EUA, compre o iPad ou iPad mini. Se não tiver muita grana, compre um Android mais barato que também não decepciona. Mas pô, por melhor que seja o iPad, não vale o preço cobrado no Brasil, manda alguém trazer de lá, que aí sim, compensa!

Pois é, por mais que não goste da filosofia da empresa, a Apple me conquistou com o iPad mini, tem algo nele que dá vontade de ter um iPhone, um iPod e um Mac também. Assim dá pra entender a estratégia da empresa, mesmo que não simpatize com a idéia de ficar preso a ela, mas os caras sabem mesmo o que fazem, e fazem bem feito!

Eis minha sugestão: Vamos criar um novo adapter para Zend_Paginator que é uma variação do Zend_Paginator_Adapter_DbSelect. A diferença é que esse adapter recebe um parâmetro adicional no construtor com o nome da classe modelo que você deseja como retorno na paginação.

class My_Paginator extends Zend_Paginator_Adapter_DbSelect 
{
    protected $_modelClass;
 
    public function __construct(Zend_Db_Select $select, $className) 
    {
        if (!class_exists($className)) {
            throw new Exception("Class '{$className}' not exists");
        } else if(!is_subclass_of($className, 'My_Model_Abstract')) {
            throw new Exception("Class '{$className}' is not subclass " .
                                "of My_Model_Abstract");
        }
        $this->_modelClass = $className;
 
        parent::__construct($select);
    }
 
    public function getModelClass() 
    {
        return $this->_modelClass;
    }
 
    public function getItems($offset, $itemCountPerPage) 
    {
        $results = parent::getItems($offset, $itemCountPerPage);
 
        // É aqui que a mágica acontece. Você pega o resultado padrão do 
        // paginator, e converte para objetos da classe definida no 
        // construtor
        $items = array();
        if ($results) {
            $modelClass = $this->getModelClass();
            foreach ($results as $data) {
                $item = new $modelClass();
                $item->setData($data);
                $items[$item->getId()] = $item;
            }
        }
        return $items;
    }
}

Perceba na classe acima, que, para ela funcionar de uma forma genérica, é preciso que a classe definida seja subclasse de My_Model_Abstract, que poderia ser a base para suas classes modelo. No método getItems() você pode perceber que essa classe deve implementar pelo menos dois métodos: setData() e getId(). Vamos ao código da My_Model_Abstract, então:

abstract class Core_Model_Abstract
{
    protected $_id;
 
    public function getId()
    {
        return $this->_id;
    }
 
    public function setData(array $data)
    {
        foreach($data as $name => $value) {
            if (property_exists($this, $name)) {
                $this->$name = $value;
            }
        }
        return $this;
    }
 
}

Pronto, agora é só criar suas classes modelo herdando desta que ela deve funcionar com o nosso paginator. Lembrando que essa classe é só uma sugestão, você pode (e deve) alterá-la e melhorá-la para atender suas necessidades. Vamos à utilização agora do paginator:

// Vamos considerar que temos uma classe My_Model_Post que herda de
// My_Model_Abstract e que $select é uma instância de Zend_Db_Select
$adapter = new My_Paginator($select, 'My_Model_Post');
 
// Criado o adapter, agora é só passá-lo como parâmetro para o paginator, 
// e usá-lo normalmente
$paginator = new Zend_Paginator($adapter);
$paginator->setCurrentPageNumber($this->_getParam('page', 1));
$paginator->setItemCountPerPage(25);
 
$this->view->paginator = $paginator;

Agora ficou fácil de utilizar o paginator e ainda aproveitar as vantagens de suas classes modelo. Você ainda pode melhorar esse código criando, na classe My_Model_Abstract (ou na sua classe Db_Table, caso costume separar as classes modelo das classes de acesso ao banco de dados) um método para retornar o paginator, sem precisar declará-lo no controller. Enjoy!

Algumas pessoas talvez se perguntem “Por quê fazer uma prova de certificação?”. Há bons motivos para isso. Além de uma realização pessoal, que é o motivo que leva muita gente a fazer (acredite!), uma prova de certificação significa que a empresa que criou ou é responsável por uma linguagem/aplicação/ferramenta garante que você sabe utilizá-la bem, e isso é válido mundialmente. No mínimo é um grande diferencial no seu currículo, que poderá ter nele o selo oficial da certificação (esse que se encontra no site na coluna direita, acima). No caso das certificações da Zend Technologies, você ainda ganha o direito de entrar no grupo de profissionais certificados do LinkedIn e de se cadastrar na http://www.odesk.com, que podem abrir muitas portas.

Bom, vamos voltar para o exame. Para marcar a prova, você deve ir ao site da Pearson Vue, selecionar o local de prova (tem uma lista enorme lá) e escolher uma data disponível na lista que ele irá mostrar. O exame, até a data em que eu fiz, custava 195 dólares. Fiz minha prova em João Pessoa (PB) na Faculdade iDez, o que foi uma ótima surpresa, pois achei que o local mais próximo para mim seria em Recife (PE).

Antes de tudo, é bom se preparar. A primeira coisa a fazer é ter em mente que o exame cobra seus conhecimentos para o Zend Framework versão 1.5.3. Ou seja, toda aquela parte de Zend_Application, Zend_Tool e outras coisas que foram acrescentadas nas versões posteriores ficam de fora. ZF2 então, nem se fala! Sabendo disto, entre no site http://www.zend.com/services/certification/framework/ para ver a lista dos tópicos que são cobrados no exame. A partir daí, você já vai saber o que terá que estudar para ficar preparado.

Alguns materiais bastante úteis para estudar também são os seguintes:

• Zend Framework Certification Study Guide (Requer login);
• Zend Framework Reference Guide – 1.5.3. (O manual oficial)
• Zend Framework Certification a Refresher;

Para estudar, eu fiz o seguinte: criei uma aplicação ZF, e para cada tópico da lista citada acima criei um controller, para cada bullet criei um ou mais actions e saí codificando tudo que era possível e testando tudo o que o ZF oferece relacionado à esses tópicos. Isso me ajudou a conhecer mais de perto muita coisa que eu não usava e ver várias formas alternativas de como utilizar recursos que eu já utilizava.

Fique esperto! É muito importante você estar bem familiarizado com as várias formas de fazer a mesma coisa no ZF, pois isso é bastante cobrado, além, é claro, da sintaxe. Cuidado com as pegadinhas (ou cascas de banana, se preferir), pois tem muitas! Então, leia a prova com muita atenção e sem pressa. Faça com calma que dá tempo! São 75 questões em 1h30 de prova. Como tem questões bem fáceis, sobra bastante tempo para as mais complicadinhas. Mas também não subestime a prova, pois ela pode ser bem difícil, dependendo de quanto você se preparou, pois o assunto é bastante extenso.

Bom, espero que esse post seja útil para aqueles que tenham interesse em fazer o exame. Boa sorte!

Disponibilizei os slides da palestra no meu slideshare: http://www.slideshare.net/jaimecpn.
Link direto para esta palestra: http://www.slideshare.net/jaimecpn/conhecendo-o-zend-framework.

Espero que o pessoal que assistiu, na maioria feras, tenha gostado, e se interessado, e que venham a ser futuros desenvolvedores PHP/ZF, e os slides sejam úteis para quem acessá-los.

Uma das melhores coisas no Kindle Fire sem dúvida é ler, ainda que não seja tão bom quanto no Kindle normal, que a tela não tem reflexo. Pra quem é marinheiro de primeira viagem, é normal ficar meio perdido no começo quando quer adicionar algum livro no Kindle. As questões geralmente são relativas ao melhor formato de e-book a utilizar, e a como adicioná-los ao aparelho.

O meio normal para adicionar e-books ao Kindle é comprá-los diretamente na loja online da amazon. Mas para quem usa o Kindle no Brasil vai encontrar dois problemas conhecidos:

1. Limitação na quantidade de livros em português;
2. Limitação para fazer compras daqui do Brasil (saber mais).

Essas limitações fazem com que a gente vá atrás de opções alternativas, como lojas nacionais. Aí nos deparamos com preços praticamente iguais aos dos livros físicos, o que não faz muito sentido, já que não há custos de impressão ou distribuição, aí acabamos procurando algo na “locadora do Paulo Coelho”, o que não é algo recomendável (por questões legais). Porém há opções de e-books gratuitos por aí, disponibilizados muitas vezes pelos próprios autores, e ainda, há livros de domínio público disponibilizados gratuitamente pelo próprio governo brasileiro no site Domínio Público.

O formato padrão de arquivo de e-book do Kindle é o .azw, que na verdade são arquivos .mobi com uma criptografia definida pela amazon. Mas o arquivos .mobi funcionam muito bem, e, na minha opinião, é o melhor formato. Os outros principais são .epub e o famoso .pdf. Vou falar de cada um deles separadamente.

Arquivos MOBI

Por funcionar no Kindle em seu aplicativo padrão para leitura de livros digitais, esse é meu formato favorito de e-book. Caso você tenha o arquivo do livro e queira adicionar ao seu Kindle, é preciso salvá-lo em uma pasta específica da memória do seu tablet. A pasta em questão é chamada eBooks, e fica dentro do sdcard.

O bom do leitor padrão do Kindle são as opções que ele oferece para melhorar sua leitura.  Entre elas: alterar a fonte, o tamanho da fonte, o espaçamento entre linhas, as margens e o modo de cores. Essa opções permitem que você defina a melhor forma de ler sem cansar muita a vista. Permite ainda grifar o texto, marcar páginas, e acessar os capítulos rapidamente através de um glossário, e fazer buscas no texto. O bom também é que o texto se distribui pela tela de forma uniforme, independente do tamanho da fonte ou da orientação (vertical/horizontal) escolhida por você.

Uma coisa boa de usar o aplicativa padrão do Kindle, que só tem nele mesmo, é que cada livro aberto irá aparecer na tela inicial do Kindle, com a porcentagem lida de cada livro.

Arquivos EPUB

Também um formato de e-book excelente, principalmente pela quantidade de livros disponíveis, que é bem maior que o de arquivos .mobi. Porém, o arquivos .epub não funcionam no leitor padrão do Kindle, forçando você a baixar um outro aplicativo para lê-lo.

Duas boas opções de aplicativos para leitura de arquivos .epub são o Moon+ Reader e o Aldiko Book Reader. Já testei os dois e, apesar do ícone feio, o Moon+ Reader me agradou mais.

O bom desses aplicativos é que eles não te obrigam o colocar todos os e-books numa pasta só. Você pode organizá-los da forma que achar melhor e depois configurar o aplicativo pra adicionar as pastas que os contém.

Quanto às opções que facilitam a leitura, são bem semelhantes aos do padrão do Kindle, mas tive alguns probleminhas com travamento, nada muito grave, mas depois de repetir umas vezes, perde-se a paciência.

Arquivos PDF

O formato .pdf é o mais conhecido de todos, e provavelmente o que tem maior quantidade disponível na internet. Porém, é de todos, o pior formato pra leitura no tablet, principalmente numa tela do tamanho da do Kindle Fire. Isso porque diferente dos formatos .mobi e .epub, o texto dos arquivos .pdf não se ajusta à tela, não tem opção para tamanho de fonte, não permite grifar o texto ou mudar as cores pra melhorar a visualização do texto. A única coisa que ele oferece é a opção de zoom, que aumenta a página toda uniformemente, mas que força você a arrastar a página de um lado para o outro pra conseguir ler uma linha inteira. Isso tudo, considerando o leitor de pdf padrão do Kindle. Não sei se outros leitores oferecem opções melhores, se houver, por favor, deixe o link aí nos comentários deste post. ^__^

Uma coisa legal do .pdf (que na verdade nem sei se funciona pros outros formatos, mas acredito que não) é que você pode autorizar na sua conta da amazon receber arquivos deste tipo por email e ele automaticamente joga lá na sua biblioteca do Kindle. Obviamente que o email em questão é o seu email @kindle.com. Isso muitas vezes facilita pra enviar os arquivos sem a necessidade de ligar seu tablet no computador como cabo.

Drive Virtual

Uma forma bastante prática de transferir seus e-books para o Kindle, ou deixá-los disponíveis para quando você tiver interesse em lê-los, é utilizar o aplicativo de algum drive virtual como o Dropbox ou o Google Drive. Você guarda nele seus e-books e transfere os livros para seu tablet quando precisar deles de forma super prática.

Convertendo formatos

Caso você tenha um e-book num formato qualquer e queira converter para outro formato, por exemplo, você tem um .epub e quer converter para .mobi, existem aplicativos disponíveis na internet que facilitam a conversão, como o Calibre, que foi o que mais me agradou. Além de converter entre os três formatos citados, ele organiza sua biblioteca de e-books de forma bem interessante. É bom saber que a conversão não funciona muito bem em alguns casos, como quando você converte .pdf para outros formatos, mas o contrário é quase sempre satisfatório.

É isso, espero que essas informações sejam úteis a todos.

 
Posts relacionados:

• Usando o Kindle Fire no Brasil

A organização do evento está de parabéns, pois foi muito bem organizado e nós, palestrantes, fomos muito bem recebidos.
Não conhecia a cidade de Patos/PB e gostei muito. É maior e menos quente do que eu pensava – ainda assim, é bem quente!

Disponibilizei os slides da palestra no meu recém-criado slideshare: http://www.slideshare.net/jaimecpn.
Link direto para esta palestra: http://www.slideshare.net/jaimecpn/php-robusto-com-zend-framework.

Espero que o pessoal que assistiu tenha gostado, e que venha a ser útil para quem vier a acessar os slides.

Eis o passo a passo:

1. No Windows 7, clique em Iniciar e, na barra de pesquisa por programas e arquivos, digite: services.msc
   
2. Clique no arquivo que vai aparecer, ou simplesmente aperte o ENTER.
3. Na janela que se abre, procure os serviços de nome: wampapache e wampmysqld
4. Perceba que na coluna “Tipo de Inicialização”, eles estão como “Manual”
5. Clique com botão direito em um deles, e selecione “Propriedades”
6. Mude “Tipo de Inicialização” para “Automático” e clique “OK”
7. Faça o mesmo para o outro serviço.

Prontinho… quando você reiniciar o Windows os serviços já estarão inicializados. Perceba, no entanto, que o que estará sendo iniciado automaticamente são os serviços Apache e Mysql, e não o Wamp em si. Ou seja, o iconezinho dele não vai estar lá do lado do relógio. Mas você vai poder usar os serviços normalmente, e só se realmente precisar mexer no WAMP é que vai ter que iniciá-lo.

Repare que essa dica serve pra o caso de você querer inicializar automaticamente qualquer desses outros serviços da lista. Prático, não? ^__^

Pensei então nas possíveis utilizações para uma classe dessas, e decidi que ela precisava:

1. ser facilmente alterada, visualmente, apenas mexendo no CSS;
2. receber e exibir diferentes formatos de data;
3. ter opções de navegação, para se alterar o mês e ano exibidos;
4. ter datas selecionáveis, para que se altere algo mais na página;
5. poder, de alguma forma, receber conteúdo específico para cada data, como nome dos feriados, por exemplo.

Para resolver o primeiro ponto, decidi que a classe deveria imprimir o HTML com várias classes CSS para cada possível caso de alteração visual que possa ser necessário. Ou seja, classes que diferenciem:

• cada dia da semana;
• dias da semana e dias de fim de semana;
• dia atual, dias passados e dias futuros;
• dia selecionado pelo usuário (ponto 4);
• dias de outro mês, mês passado e mês futuro;
• dias definidos pelo usuário.

O segundo ponto diz respeito a como vai vir a informação que define a data selecionada, por exemplo, e as datas que o usuário irá especificar classes de css (ultimo da lista do ponto 1) e conteúdo específico (ponto 5), e também de como serão exibidos os nomes do mês em exibição, dos meses nas opções de navegação (ponto 3), e os dias da semana.

Os outros pontos são auto-explicativos. Então, vamos ver o resultado:

class My_View_Helper_Calendar extends Zend_View_Helper_Abstract
{
    protected $date;
    protected $now;
    protected $locale = 'pt_BR';
 
    const INSERT_BEFORE = -1;
    const INSERT_PREPEND = 0;
    const INSERT_APPEND = 1;
    const INSERT_AFTER = 2;
 
    protected $options = array(
        'showPrevMonthLink'  => false,
        'showNextMonthLink'  => false,
        'showOtherMonthDays' => false,
        'dateBaseUrl'        => '#',
        'monthBaseUrl'       => '#',
        'insertsPosition'    => -1
    );
 
    protected $protectedCssClasses = array(
        'selected-date', 'today', 'past-day', 'future-day',
        'other-mohth', 'prev-month', 'next-month'
    );
 
    protected $cssClasses = array();
    protected $inserts = array();
 
    static protected $formats = array(
        'input'    => 'yyyy-MM-dd',
        'weekdays' => Zend_Date::WEEKDAY_NARROW,
        'header'   => 'MMMM yyyy',
        'prevAndNextMonth' => Zend_Date::MONTH_NAME_SHORT
    );
 
    static public function getFormat($name)
    {
        return isset(self::$formats[$name])
                ? self::$formats[$name]
                : null;
    }
 
    /**
     * Set object state from options array
     *
     * @param array $options
     * @return My_View_Helper_Calendar
     */
    public function setOptions(array $options)
    {
        foreach($options as $name => $value)
        {
            // Define o formato que a data será inserida
            if ($name == 'format') {
                self::$formats['input'] = $value;
            }
 
            // Define o idioma
            if ($name == 'locale' && Zend_Locale::isLocale($value)) {
                $this->locale = $value;
            }
 
            // Define as classes de css
            if ($name == 'cssClasses') {
                $this->setCssClasses($value);
            }
 
            // Insere conteúdo nas células de acordo com as datas
            if ($name == 'inserts') {
                $this->insertHtml($value);
            }
 
            // Define a posição em que o conteúdo será inserido
            if ($name == 'insertsPosition') {
                $this->setInsertsPosition($value);
            }
 
            $this->setOption($name, $value);
        }
        return $this;
    }
 
    /**
     * Altera alguma configuração do calendário
     *
     * @param string $name
     * @param mixed $value
     * @return My_View_Helper_Calendar
     */
    public function setOption($name, $value)
    {
        if (isset($this->options[$name])) {
            $this->options[$name] = $value;
        }
 
        return $this;
    }
 
    /**
     * Retorna uma configuração pelo nome
     *
     * @param string $name
     * @return mixed
     */
    public function getOption($name)
    {
        return isset($this->options[$name])
                ? $this->options[$name]
                : null;
    }
 
    /**
     * Define as classes de CSS para datas específicas
     *
     * @param array $cssClasses
     * @return My_View_Helper_Calendar
     */
    public function setCssClasses(array $cssClasses)
    {
        foreach($cssClasses as $cssClass => $dates) {
            $this->addCssClass($cssClass, $dates);
        }
        return $this;
    }
 
    /**
     * Adiciona uma classe de CSS para uma data específica
     *
     * @param string $cssClass
     * @param mixed $dates
     * @return My_View_Helper_Calendar
     */
    public function addCssClass($cssClass, $dates)
    {
        if (!in_array($cssClass, $this->protectedCssClasses)) {
            if (is_string($dates)) {
                $dates = array($dates);
            }
            if (is_array($dates)) {
                foreach($dates as $date) {
                    if (is_string($date) && Zend_Date::isDate(
                        $date, $this->getFormat('input')))
                    {
                        $this->cssClasses[$cssClass][] = $date;
                    }
                }
            }
        }
        return $this;
    }
 
    /**
     * Retorna a lista de classes de css definidas
     *
     * @return array
     */
    public function getCssClasses()
    {
        return $this->cssClasses;
    }
 
    /**
     * Retorna todas as classes de css, tanto as padrão quanto 
     * as definidas
     *
     * @return array
     */
    public function getAllCssClasses()
    {
        return array_merge($this->protectedCssClasses,
                           array_keys($this->getCssClasses()));
    }
 
    /**
     * Adiciona conteúdo html a uma data específica
     *
     * @param string $date
     * @param string $html
     * @return My_View_Helper_Calendar
     */
    public function insertHtml($date, $html=null)
    {
        if (is_array($date)) {
            foreach($date as $d => $h) {
                $this->insertHtml($d, $h);
            }
        } else if (Zend_Date::isDate($date, $this->getFormat('input'))) {
            if (is_string($html)) {
                $this->inserts[$date][] = $h;
            } else if (is_array($html)) {
                foreach($html as $h) {
                    if (is_string($h)) {
                        $this->inserts[$date][] = $h;
                    }
                }
            }
        }
 
        return $this;
    }
 
    /**
     * Retorna o conteúdo HTML adicionado para uma data específica
     *
     * @param string $date
     * @return array
     */
    public function getInserts($date=null)
    {
        if ($date) {
            if (isset($this->inserts[$date])) {
                return $this->inserts[$date];
            }
        } else {
            return $this->inserts;
        }
    }
 
    /**
     * Define a posição do conteúdo inserido nas datas
     * -1 = Antes da tag do link da data
     * 0 = Antes da data, dentro da tag do link
     * 1 = Depois da data, dentro da tag do link
     * 1 = Depois da tag do link da data
     *
     * @param int -1 = Before, 0 = Prepend, 1 = Append, 2 = After
     * @return My_View_Helper_Calendar
     */
    public function setInsertsPosition($position)
    {
        if (in_array($position, 
            array(self::INSERT_APPEND, self::INSERT_PREPEND))) 
        {
            $this->setOption('insertsPosition', $position);
        }
        return $this;
    }
 
 
    /**
     * Returna a posição em que o conteúdo será inserido
     *
     * @return int
     */
    public function getInsertsPosition()
    {
        return $this->getOption('insertsPosition');
    }
 
    /**
     * Define a data selecionada
     *
     * @param string $date
     * @return My_View_Helper_Calendar
     */
    public function setDate($date)
    {
        if ($date instanceof Zend_Date) {
            $this->date = $date;
        } else {
            $this->date = new Zend_Date($date, self::getFormat('input'),
                                        $this->locale);
        }
        return $this;
    }
 
    /**
     * Exibe um calendário HTML
     *
     * @param string $date Data selecionada
     * @param array $options
     * @return string
     */
    public function calendar($date=null, array $options=null)
    {
        if ($options) {
            $this->setOptions($options);
        }
 
        $this->now = Zend_Date::now($this->locale);
 
        if ($date) {
            $this->setDate($date);
        } else {
            $this->date = clone $this->now;
        }
 
        return $this->render();
    }
 
    /**
     * Gera o código HTML do calendário
     *
     * @return string
     */
    public function render()
    {
        // Cria um objeto Zend_Date para a data inicial
        $dateInit = clone $this->date;
        $dateInit->setDay(1); // Altera para o primeiro dia do mês
        $weekday = $dateInit->get(Zend_Date::WEEKDAY_DIGIT);
        $month = $this->date->get(Zend_Date::MONTH);
 
        // Calcula o primeiro dia da tabela a ser exibido
        $firstDay = clone $dateInit->subDay($weekday);
 
        // Cria uma div para o calendário com um id único
        $xhtml = '<div class="calendar" '
                . 'id="calendar_' . $this->date->get('yyyy-MM') . '">'
                . '<div class="calendar-header">';
 
        // Verifica se o calendário está configurado para exibir os 
        // links de navegação para exibir o mês anterior
        if ($this->getOption('showPrevMonthLink'))
        {
            $prevMonth = clone $this->date;
 
            // Cria um objeto para o mês anterior
            $prevMonth->subMonth(1); 
 
            $xhtml .= '<span class="prev-month-link">'
                  . '<a href="'
                  . $this->getOption('monthBaseUrl')
                  . $prevMonth->get('yyyy-MM').'" title="'
                  . $prevMonth->get(self::getFormat('header'))
                  .'">'
                  . $prevMonth->get(self::getFormat('prevAndNextMonth'))
                  . '</a></span>';
        }
 
        // Insere o nome do mês atual de acordo com o formato definido
        $xhtml .= '<span class="current-month">'
                . $this->date->get(self::getFormat('header'))
                . '</span>';
 
        // Verifica se o calendário está configurado para exibir os
        // links de navegação para exibir o mês seguinte
        if ($this->getOption('showNextMonthLink'))
        {
            $nextMonth = clone $this->date;
 
            // Cria um objeto para o mês seguinte
            $nextMonth->addMonth(1); 
 
            $xhtml .= '<span class="next-month-link">'
                  . '<a href="'
                  . $this->getOption('monthBaseUrl')
                  . $nextMonth->get('yyyy-MM').'" title="'
                  . $nextMonth->get(self::getFormat('header'))
                  .'">'
                  . $nextMonth->get(self::getFormat('prevAndNextMonth'))
                  . '</a></span>';
        }
 
        // Cria a tabela do calendário
        $xhtml .= '</div><table cellspacing="0" cellpadding="0" '
                . 'border="0"><thead>';
 
        $tmpDate = clone $firstDay;
 
        // Adiciona sete colunas com os nomes dos dias da semana
        for($i=0; $i<=6; $i++) {
            $cssClasses = array();
 
            // Define as classes de CSS da semana e da coluna
            if ($i == 0) {
                // Classe CSS para a primeira coluna
                $cssClasses[] = 'column-first';
            } else if ($i == 6) {
                // Classe CSS para a última coluna
                $cssClasses[] = 'column-last';
            }
 
            // Adiciona classes CSS diferentes para dias da semana
            // e fim-de-semana
            $cssClasses[] = (in_array(
                $tmpDate->get(Zend_Date::WEEKDAY_DIGIT), array(0, 6)))
                ? 'weekend-day' : 'week-day';
 
            // Adiciona uma classe específica para cada dia da semana
            $cssClasses[] = strtolower(
                $tmpDate->get(Zend_Date::WEEKDAY_NAME, 'en_US'));
 
            // Insere as classes CSS na célula e imprime o dia da semana
            // de acordo com o formato definido
            $cssClassesString = $cssClasses 
                ? ' class="'.implode(' ', $cssClasses).'"' 
                : '';
 
            $xhtml .= '<th' . $cssClassesString . '>'
                    . $tmpDate->get(self::getFormat('weekdays'))
                    . '</th>';
 
            // Avança para o dia seguinte e repete o processo
            $tmpDate->addDay(1);
        }
        $tmpDate = $firstDay;
        $xhtml .= '</thead><tbody>';
 
        // Cria sete linhas na tabela para as semanas
        for($i=0; $i<6; $i++) {
            $xhtml .= '<tr>';
 
            // Cria sete colunas para as datas
            for($j=0; $j<=6; $j++) {
                $day = $tmpDate->get(Zend_Date::DAY);
 
                $cssClasses = array();
 
                // Define as classes de CSS da semana e da coluna
                if ($j == 0) {
                    $cssClasses[] = 'column-first';
                } else if ($j == 6) {
                    $cssClasses[] = 'column-last';
                }
 
                // Adiciona classes CSS diferentes para dias da semana
                // e fim-de-semana
                $cssClasses[] = (in_array(
                    $tmpDate->get(Zend_Date::WEEKDAY_DIGIT),array(0,6)))
                    ? 'weekend-day' : 'week-day';
 
                //Adiciona uma classe específica para cada dia da semana
                $cssClasses[] = strtolower(
                        $tmpDate->get(Zend_Date::WEEKDAY_NAME, 'en_US'));
 
                // Adiciona classes CSS diferentes para hoje, dias 
                //passados e futuros
                switch($tmpDate->compareDate($this->now)) {
                    case -1: $cssClasses[] = 'past-day'; break;
                    case 0: $cssClasses[] = 'today'; break;
                    case 1: $cssClasses[] = 'future-day'; break;
                }
 
                // Adiciona uma classe CSS para a data selecionada
                if ($tmpDate->compareDate($this->date) == 0) {
                    $cssClasses[] = 'selected-date';
                }
 
                // Adiciona classes CSS para dias de outros meses
                if ($tmpDate->get(Zend_Date::MONTH) != $month) {
                    $cssClasses[] = 'other-month';
 
                    if (!$this->getOption('showOtherMonthDays')) {
                        $day = '&nbsp;';
                    }
 
                    // Adiciona classes CSS diferentes para dias de 
                    // meses passado e futuro
                    if ($tmpDate->get(Zend_Date::MONTH) < $month) {
                        $cssClasses[] = 'prev-month';
                    } else if ($tmpDate->get(Zend_Date::MONTH)>$month){
                        $cssClasses[] = 'next-month';
                    }
                }
 
                // Insere classes CSS definidos para datas específicas
                $addCssClasses = $this->getCssClasses();
                if ($addCssClasses) {
                    foreach($addCssClasses as $cssClass => $d) {
                        if ((is_string($d) && $tmpDate->get(
                          $this->getFormat('input')) == $d) ||
                          (is_array($d) && in_array(
                          $tmpDate->get($this->getFormat('input')),$d)))
                        {
                            $cssClasses[] = $cssClass;
                        }
                    }
                }
 
                // Insere conteúdo HTML definido para datas específicas
                $htmlInserts = '';
                $inserts = $this->getInserts(
                    $tmpDate->get($this->getFormat('input')));
                if ($inserts) {
                    foreach($inserts as $insert) {
                        $htmlInserts .= $insert . PHP_EOL;
                    }
                }
 
                // Creia a célula da tabela para a data
                $xhtml .= '<td '
                        . 'id="calendar_day_' 
                        . $tmpDate->get('yyyy-MM-dd') . '" '
                        . 'class="' . implode(' ', $cssClasses) . '">'
                        . ($this->getInsertsPosition() == 
                          self::INSERT_BEFORE ? $htmlInserts : '')
                        . '<a class="day" href="'
                        . $this->getOption('dateBaseUrl')
                        . '/'
                        . $tmpDate->get('yyyy-MM-dd')
                        .'">'
                        . ($this->getInsertsPosition() == 
                          self::INSERT_PREPEND ? $htmlInserts : '')
                        . $day
                        . ($this->getInsertsPosition() == 
                          self::INSERT_APPEND ? $htmlInserts : '')
                        . '</a>'
                        . ($this->getInsertsPosition() == 
                          self::INSERT_AFTER ? $htmlInserts : '')
                        . '</td>';
 
                $tmpDate->addDay(1);
            }
            $xhtml .= '</tr>';
        }
 
        $xhtml .= '</tbody></table></div>';
 
        return $xhtml;
    }
}

Bom, a classe é essa aí. Parece muito grande pra uma coisa aparentemente tão simples, mas acredito que o importante é a praticidade que ela proporciona para fazermos o calendário da forma que queremos. Então, vamos ver como utilizá-la:

<?php echo $this->calendar('2012-02-17', array(
    // Faz com que o link para o mês passado seja exibido
    'showPrevMonthLink'  => true,
    // Faz com que o link para o mês seguinte seja exibido
    'showNextMonthLink'  => true,
    // Faz com que os dias de outros meses sejam exibidos
    'showOtherMonthDays' => true,
    // Define a url base para os links das datas
    'dateBaseUrl'        => 'http://www.jaimeneto.com/data/',
    // Define a url base para os links de navegação dos meses
    'monthBaseUrl'       => 'http://www.jaimeneto.com/data/',
    // Define uma classe css "feriado" para as datas no array
    'cssClasses' => array(
        'feriado' => array(
            '2012-02-01', // Dia do Publicitário
            '2012-02-02', // Dia de Iemanjá
            '2012-02-22', // Carnaval
            '2012-02-16',  // Dia do Repórter
            '2012-03-08'  // Dia da Mulher
        )
    ),
    // Dá um destaque maior inserindo o nome do feriado do carnaval
    'inserts' => array(
        '2012-02-22' => array('<div>Carnaval</div>')
    ),
    // Define que o html deve ser inserido dentro do link, após a data
    'insertsPosition'    => My_View_Helper_Calendar::INSERT_APPEND
)) ?>

Vamos decorar o calendário agora com CSS, aproveitando todo o esforço para separar cada parte em classes agora.

body { font-family:arial;font-size:14px }
.calendar { width: 300px;cursor:default; }
.calendar a { text-decoration:none; color:#000; }
.calendar a:hover { text-decoration:underline; }
.calendar .calendar-header { border:1px solid #000;border-bottom:0;
    background-color:#ccc;text-align:center;text-transform:uppercase;
    line-height: 20px; }
.calendar .calendar-header .current-month { font-weight:bold; }
.calendar .calendar-header .prev-month-link { float:left;margin:0 3px; }
.calendar .calendar-header .next-month-link { float:right;margin:0 3px; }
.calendar table { border-collapse:collapse;width:100%; }
.calendar table td, .calendar table th { border:1px solid #000;
    text-align:center; line-height: 20px; }
.calendar table td a { display:block; margin:2px; 
    border: 1px solid transparent; }
.calendar table .weekend-day,.calendar table th {background-color:#eee;}
.calendar table td.other-month a { color:#ccc; }
.calendar table td.today { background-color:orange; }
.calendar table td.selected-date a { background-color:yellow; }
.calendar table td.feriado a { color:blue;border-color:blue; }
.calendar table td.other-month.feriado a {color:#ccc;border-color:#ccc;}

Vamos ver o resultado disso tudo:

Beleza, agora está pronto pra uso. Só pra finalizar, e pra mostrar que dá pra fazer uma coisa realmente elegante com isso, apenas mexendo no CSS, e, neste caso, usando o plugin qTip do Jquery, vou mostrar aqui o resultado do propósito final pra eu trabalhar tanto nessa classe. Ela foi criada para o site de eventos letz.com.br, e queríamos que as datas com eventos marcadas pelo usuário ficassem destacadas no calendário, e que quando ele passasse o cursor sobre a data, aparecece os eventos num balão. Veja como ficou:

Pronto. É isso, galera. Espero que tenham gostado e que seja útil pra alguém! ~__^

Ok, recebido o Kindle Fire, hora de testar. Gostei demais dele, o tamanho é realmente perfeito, o touch screen excelente, super fácil e intuitivo de usar. Gostei muito da personalização que a Amazon deu para o android, apesar de alguns ícones não ficarem muito bons na tela principal, onde aparecem maiores. Achei um pouquinho mais pesado do que eu gostaria, mas nada que comprometa sua utilização. É muito bom pra ler, acho até que seja o melhor dos tablets para isso, mas diferente das outras versões do Kindle, que foram criados especificamente para leitura, este tem brilho na tela, dificultando a leitura se não tiver uma iluminação adequada, ainda assim é excelente, e para ler quadrinhos então… Viciante! Com relação ao uso de internet, fiquei impressionado com o curto espaço de tempo que ele leva pra conectar ao ser ligado, tornando-o ainda mais prático, pois não e preciso esperar muito para estar online. Ah… não posso esquecer da bateria que dura que é uma beleza! Há algumas desvantagens em relação ao Galaxy Tab: não tem 3G, nem GPS, nem Câmera e não roda jogos mais pesados, por exemplo… Mas ainda assim é muito bom, se essas coisas não fazem muita diferença pra você, ou se você não quer pagar uma fortuna pelo concorrente da Samsumg.

Ok… hora de instalar uns aplicativos. Acessando a Amazon store e… opa… que é isso? PôÔÔôôÔÔ!!!! A Amazon não deixa instalar nada a partir de um ip fora dos EUA. Fora isso, pra comprar os aplicativos é preciso ter um cartão de crédito com endereço de cobrança (billing address) estadunidense. E agora? Vamos testar o android market padrão… Humm… ele redireciona para a Amazon store, não deixa nem eu entrar no Android Market. Putz!

Bom, não gosto de fazer isso, mas a situação pede medidas desesperadas: JAILBREAK NELE! Vamos desbloquear esse danado pra poder instalar os aplicativos que eu quero. Não tenho culpa de a Amazon amarrar minhas mãos, né… >:(

Como fazer isso? Eis os passos (leve em conta que quando esse jailbreak foi feito, a versão dele era 6.2.1):

1 – Permitir instalação de software de fontes desconhecidas

Dê um toque no canto superior direito para aparecer as opções de configuração, vá em “More…”,  “Device”, e mude “Allow Installation of Applications From Unknown Sorces” para “ON”, “OK”.

2 – Instale o driver do android no seu computador

Em seu computador baixe o arquivo android.zip e descompacte em C:\Users\NOME_DO_USUARIO\.android (C:\Documents And Settings\NOME_DO_USUARIO\.android para Windows XP).

Conecte o Kindle ao seu Computador via USB (Ah… só lembrando… no meu Kindle não veio cabo nenhum acompanhando ele, veio só o carregador mesmo…, então, você deve usar um que você tenha, ou comprar um. ).

Clique no botão “Iniciar” do windows, clique com o botão direito em “Computador”, e clique em “Gerenciar”. Na janela que vai abrir, vá em “Gerenciador de dispositivos”. Você deverá ver o Kindle lá na lista. Clique com o botão direito nele e selecione “Atualizar Driver”, “Procurar software de driver no computador”, “Permitir que eu escolha em uma lista de drivers de dispositivo no computador”, Clique em “Com Disco…”, “Procurar…” e navegue até a pasta C:\Users\NOME_DO_USUARIO\.android\Driver\ e clique em “Abrir”. “OK”. Você verá o driver chamado “Android Composite ADB Interface”, Clique em “Avançar”, e escolha a opção para instalar de qualquer forma. Aguarde enquanto o driver é instalado. Deverá aparecer uma mensagem de sucesso. Clique em “Fechar”. Na lista de Dispositivos, você deverá ver “Android Phone” e dentro dele “Android Composite ADB Interface”, que é o seu Kindle.

3 – Baixar o Kindle ADB e certifique-se de que o driver do android foi bem instalado

Ainda em seu computador, baixe o arquivo KindleADB.zip e descompacte em C:\KindleADB.

Execute o Prompt de Comando (clicando em “Iniciar” e digite “cmd” + Enter, ou no XP, vá em “Executar” e digite “cmd”), digite as duas linhas de comandos abaixo:

cd c:\KindleADB
adb devices

Aqui deve aparecer “List of devices attatched” e o código correspondente ao seu kindle logo abaixo. Caso não apareça, reinicie o computador, remova o driver do android e tente instalá-lo novamente.

4 – SuperUser e kindleroot

Volte para o navegador e baixe os arquivos kindleroot_androidpolice.apk e superuser-2.zip.  Extraia os arquivos dentro de superuser-2.zip na pasta c:\KindleADB, sem criar uma subpasta.

Plugue novamente o kindle no seu computador (se já estiver plugado, desconecte e plugue novamente). Copie o arquivo kindleroot_androidpolice.apk para dentro da memória do kindle. Disconecte seu kindle.

5 – Instale o “Root Explorer”

Usando o navegador do Kindle Fire, acesse http://bit.ly/kindlerootexplorer, toque em “Download Now”, depois em “Slow Download”, espere 20 segundos, e finalmente em “download file now”. Você verá que aparecerá um número na barra de notificações do Kindle, no topo. Clique lá, e verá que o arquivo está sendo baixado. Quando terminar de baixar, clique nele, e depois em “Install” e em “Done”.

6 -Fazendo o “Root” no Kindle

Vá em “apps” e inicie o “Root Explorer”. Vá em “sdcard”, toque em “kindleroot_androidpolice.apk”, “Install”, “Install” novamente, “Open”, “Agree”, “Root”, “OK”. Conecte o Kindle Fire no seu computador, caso não esteja conectado.

No computador, volte para o “Prompt de comando”, na pasta do KindleADB. Certifique-se de que o kindle ainda está OK, digitando “adb devices” e vendo se ele aparece direitinho lá, e digite a seguinte lista de comandos:

adb root
adb remount
adb push su /system/xbin/su
adb shell chwon 0.0 /system/xbin/su
adb shell chmod 06755 /system/xbin/su
adb install Superuser.apk
adb reboot

Atenção, esses comandos podem mudar. Verifique no guia oficial: http://adf.ly/AQPdS

A partir daqui, seu Kindle Fire já deve estar “Rooted”, ou seja, desbloqueado para instalar aplicações de fontes “alternativas”.

Para se certificar de que funcionou, instale o RootCheck. Baixe o arquivo em http://adf.ly/AQPo1, instale, vá em “apps”, inicie o aplicativo, “Agree”, “Verify Root Access”, “Allow”. Deve aparecer a frase “Congratulations! You have root access!” caso esteja tudo certinho.

7 – Instale o “Android Market“

Para completar o tutorial, vamos instalar o aplicativo que vamos usar para acessar o Android Market, e de lá, baixar os outros aplicativos que queremos. Usando o navegador do Kindle Fire, acesse http://adf.ly/2098272/kindlemarket, clique em “Direct Download”, clique na barra de notificação para acompanhar o download. Quando terminar, toque em “Home”, vá em “Apps”, e inicie o “Root Explorer”. Caso ainda não tenha feito, clique em “Allow” para permitir acesso de superusuário.

Navegue para “sdcard”, “Download” e toque e segure em “KindleFireAndroidMarket.zip”. Selecione “Extract All”, “Go to extracted”, “KindleFireAndroidMarket”, “GoogleServicesFramework.apk”, “Install”, “Install” de novo, “Done”. Toque e segure em “Market.apk”, selecione “Move”, “Back” quadro vezes, entre em “system”, “app”. No topo você verá um botão “Mount r/w”, clique nele, ele vai mudar para “Mount R/O”. Toque em “Paste”. Procure por “Market.apk”, toque e segure, selecione “Permissions”, deixe selecionados apenas os dois primeiros quadros da primeira linha, e o primeiro quadro da segunda e da terceira linha. Toque “OK”. Novamente toque em “Market.apk” (sem segurar, dessa vez), “Install”, “OK”, “Install” novamente, “Done”. Agora faça um reboot no Kindle Fire: Aperte e segure o botão de ligar, e aperte em “Shut Down”, depois ligue novamente. Vá novamente ao “Root Explorer”, “sdcard”, “extracted”, “KindleFireAndroidMarket”, “MarketOpener.apk”, “Install”, “Install” novamente, “Done”. Toque em “Home” para ir para a tela principal, vá em “apps”, e você verá lá o ícone do Android Market. Toque nele. Ele vai pedir pra você adicionar sua conta do Google. Aperte “Yes” e prossiga com os passos. Pode demorar um pouco, então você pode voltar para a “Home” e acessar novamente o Android Market. Ufa… pronto, agora você pode instalar os aplicativos a partir do Android Market.

Caso alguma coisa dê errado, aproveite as fontes de consulta que usei no meu Kindle (vídeos em inglês):

• How to Root – Kindle Fire (6.2.1 & 6.2.2 Read Video Desc)
• How to Root – Kindle Fire 6.2.2 BurritoRoot3
• How to Install Android Market – Rooted Kindle Fire (No ADB, V2) 

Agora, é só desfrutar… ^__^

 
Posts relacionados:

• Ebooks no Kindle Fire