Instalando o VLC no Slackware 13.37

Se baixarmos os fontes diretamente do site oficial do VLC e compilarmos, teremos alguns problemas, pois ele vai reclamar de bibliotecas faltantes, plugins e outras coisas que não lembro.. Então devemos instalar a versão que tem em http://connie.slackware.com/~alien/slackbuilds/vlc/, ai não teremos os mesmos problemas, e nossa vida se torna mais facil. Então, basta baixar a versão correspondente a sua versão do Slackware (a minha é 13.37 64 bits)

$ wget http://connie.slackware.com/~alien/slackbuilds/vlc/pkg64/13.37/vlc-2.0.1-x86_64-1alien.txz

$ installpkg vlc-2.0.1-x86_64-1alien.txz

Pronto, já está instalado e funcionando!

Até a próxima! abrass

Padrão Command

Salve galera!!

Agora escrevendo sobre nossos queridos Design Patterns, ou Padrões de Projetos... como preferirem. Nesse post vou tentar demonstrar um uso bem interessante para o padrão Command. Talvez o objetivo desse padrão seja outro, mas desde que comecei a usar com o objetivo de tratamentos de exceções, achei muito pratico, produtivo, coeso e desacoplado. Hoje uso esse padrão em aplicações web, desktop, mobile.. ou seja, em todos os projetos que coloco a mão, aplico esse padrão... Então, vamos ao que interessa..

Uma pequena introdução:

Objetivo: Encapsular uma solicitação como um objeto, desta forma permitindo que clientes parametrizem diferentes solicitações, enfileirem ou façam o registro (log) de solicitações e suportem operações que podem ser desfeitas.

Problema: Algumas vezes é necessário emitir solicitações para objetos nada sabendo sobre a operação que está sendo solicitada ou sobre o receptor da mesma.

Aplicação: A chave deste padrão è uma classe abstrata Command, a qual declara uma interface para execução de operações. Na sua forma mais simples, esta interface inclui uma operação abstrata Execute.

Fonte: http://pt.wikipedia.org/wiki/Command

Agora na pratica, aplicando ele nos meus problemas

Objetivo: Realizar chamada a métodos que lançam exceções, de maneira que todas sejam tratadas em um unico local.

Problema: Quando se pensa na arquitetura de uma aplicação, ou no design, logo pensamos em como vamos tratar as exceções. Então, criamos super exceções para cada camada, ou apenas para camada DAO, e sub-exceções para exceções mais espacificas. Exemplo:

DAOException - Super-exceção
UniqueKeyViolationException - Sub-exceção
PrimaryKeyViolationException  - Sub-exceção
ValidationException - Sub-exceção

Agora temos todas essas exceções para tratarmos com nossos try catch, por toda camada visual, onde vamos consumir os dados da camada BO => DAO ou DAO. Ainda teremos um pequeno problema se uma nova exceção for adicionada a lista, pois ela precisará ser tratada.

Aplicação:  Criar uma classe Chamada CommandDelegate, onde através de um método executar possamos realizar o tratamento de exceções de toda a aplicação de maneira padronizada.

Vamos ao que interessa.. Código fonte!

Interface Command

/**
 * Interface que representa uma operação que
 * deve ter suas exceções tratadas
 * 
 * @author Ricardo Bocchi
 */
public interface Command {

    /**
     * Encapsula um método que deve ser tratado
     * 
     * @throws Exception 
     */
    void operation() throws Exception;
}

Implementação da classe CommandDelegate

/**
 * Exemplo do padrão Command para o tratamento centralizado de exceções 
 *  
 * @author Ricardo Bocchi
 */
public class CommandDelegate {

    private static final Logger logger = Logger.getLogger(CommandDelegate.class.getName());
    private boolean fail;

    /**
     * Executa uma operação que deve ter tratamento de exceções
     * 
     * @param cmd Operação a ser executada
     */
    public void execute(Command cmd) {

        this.fail = true;

        try {
            cmd.operation();
            this.fail = false;
        } catch (PrimaryKeyViolationException e) {
            //Tratar exceção de violação de chave primaria
        } catch (ValidationException e) {
            //Tratar exceção de validação
        } catch (DAOException e) {
            logger.log(Level.SEVERE, e.getMessage(), e);
            //Tratar exceção de banco de dados generica
        } catch (Exception e) {
            logger.log(Level.SEVERE, e.getMessage(), e);
            //Tratar exceção generica
        }
    }

    public boolean isFail() {
        return fail;
    }
}

Uso

        new CommandDelegate().execute(new Command() {

            @Override
            public void operation() throws Exception {
                dao.executeThrowsOperation()
            }
        });

Esse é o uso mais simples possivel. Ainda podemos identificar os seguintes problemas:

Se ocorrer um erro, como posso parar a execução se as exceções estão sendo "caladas" dentro do CommandDelegate? Para identificar erros, podemos chamar o método isFail(), que retorna se ocorreu algum erro na execução. Poderimos altera o método execute na classe CommandDelegate, para:

    public CommandDelegate execute(Command cmd) {

        this.fail = true;

        try {
            cmd.operation();
            this.fail = false;
        } catch (PrimaryKeyViolationException e) {
            //Tratar exceção de violação de chave primaria
        } catch (ValidationException e) {
            //Tratar exceção de validação
        } catch (DAOException e) {
            logger.log(Level.SEVERE, e.getMessage(), e);
            //Tratar exceção de banco de dados generica
        } catch (Exception e) {
            logger.log(Level.SEVERE, e.getMessage(), e);
            //Tratar exceção generica
        }

        return this;
    }

E depois usar assim

        
       CommandDelegate delegate = new CommandDelegate().execute(new Command() {

            @Override
            public void operation() throws Exception {
                dao.executeThrowsOperation()
            }
        });

        if(delegate.isFail()){
          //Ocorreu erro! 
          return;
        }

E se eu precisar passar parametros para o método ou pegar o retorno?
Nesse no caso de parametro, se ele fosse final, não teria problemas. E caso ele não possa ser final, poderiamos criar uma classe Wrapper generica para as chamadas.

Classe Wrapper

    
/**
 * Classe Wrapper
 *  
 * @author Ricardo Bocchi
 */
public class Wrapper {

    public T obj;
}

E usar

   
       Wrapper wrapper = new Wrapper();
     
       CommandDelegate delegate = new CommandDelegate().execute(new Command() {

            @Override
            public void operation() throws Exception {
                wrapper.obj = dao.loadCliente(1);
            }
        });

        if(delegate.isFail()){
          //Ocorreu erro! 
          return;
        }

Então, apresentei aqui um uso interessante para o padrão Command já prevendo algumas complicações que ele geraria. Ainda poderiamos realizar diversas customizações, de modo a facilitar o uso do padrão.

E por hora era isso.. até a próxima! abrass

Site da Mobile Mind no ar

Salve galera... apenas publicando que o site da mais nova empresa de tecnologia, Mobile Mind, está no ar! Segue o link MobileMind.

Para quem está procurandosoluções em tecnologia móvel, é uma boa pedida.

Curtam no face!

Abrasss

Slackware 64 bits multilib

Salve galera.. Meus problemas começaram assim que instalei a versão do Slackware 13.37 64 bits. Depois de instalado, percebi que não conseguia executar programas 32 bits.. então descobri que:

"Slackware for the x86_64 architecture (or "Slackware64" for short) is a pure 64-bit Operating System, but easily upgradable to multilib. Out of the box, Slackware64 is only capable of compiling and running 64bit binaries."

Ou seja, ele só roda programas 64 bits. Mas como tudo sempre tem uma solução, ai vai uma dica de como reverter a situação e transformando o Slackware 13.37 64 bits em multilib, para ai sim conseguirmos rodar programas 32 bits.

Primeiro, vamos fazer o download dos pacotes de compatibilidade:

mkdir ~/multilib
$ cd ~/multilib
$ wget -c -r --no-parent http://connie.slackware.com/~alien/multilib/13.37/

Agora vamos atualizar e instalar os novos pacotes

$ cd connie.slackware.com/~alien/multilib/13.37 

$ upgradepkg --reinstall --install-new *.t?z

$ upgradepkg --install-new slackware64-compat32/*-compat32/*.t?z 

E pronto, seu sistema está apto a executar programas 32 bits.

Para mais informações, veja http://alien.slackbook.org/dokuwiki/doku.php?id=slackware:multilib

Até a próxima!

String Resources WP7

Salve galera! Aqui vai apenas uma dica em como trabalhar com string resource a moda android no WP7.

Android

res/values/string.xml

 
  
    Nome da Aplicação
   

Uso:

WP7

App.xaml

Nome da Aplicação

Uso

Simples não? Até a próxima

Custon Button WP7

Salve galera!! Olhando a data de criação do blog, e a quantidade de postagens existêntes, posso afirmar que não cumpri com o prometido =/. Mas nada está perdido, agora pretendo dedicar um tempo especial para postar novidades e coisas interessantes. Agora de verdade =)
Como não era de de se esperar, vou postar um conteúdo sobre Windows Phone 7 ou conhecido WP7. Alguns dias atrás quebrei a cabeça para fazer um botão personalizado com as seguintes regras.
 
- Deve possuír uma imagem de fundo;
- Quando o botão é pressionado, sua imagem de fundo deve ser alterada;
- Quando o botão é liberado, sua imagem de fundo original deve voltar ao estado original.

E como era de se esperar, foi muito mais facil do que eu imaginava. Tive esse problema, pois estava migrando uma App Androd para WP7. Então, vou postar aqui o componente personalizado na versão android, e depois o equivalente na versão WP7.

Versão Android

res/drawable-hdpi/custon_button.xml - Componente customizado

Uso do componente - Agora podemos usar nosso componente em uma View do Android.

Versão Windows Phone 7

CustonButton.cs - Classe que controla o componente

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace MobileMind.Control
{
    /// 

    /// ImageButton control
    /// 
    public class ImageButton : Button
    {
        /// 

        /// Default Constructor
        /// 
        public ImageButton()
        {
            DefaultStyleKey = typeof(ImageButton);
        }

        /// 

        /// Normal State Image Property Dependency
        /// 
        public static readonly DependencyProperty ImageProperty = DependencyProperty.Register("Image", typeof(ImageSource), typeof(ImageButton), null);

        /// 

        /// Normal State Image Property
        /// 
        public ImageSource Image
        {
            get { return (ImageSource)this.GetValue(ImageProperty); }
            set { this.SetValue(ImageProperty, value); }

        }

        /// 

        /// Pressed State Image Property Dependency
        /// 
        public static readonly DependencyProperty PressedImageProperty = DependencyProperty.Register("PressedImage", typeof(ImageSource), typeof(ImageButton), null);

        /// 

        /// Pressed State Image Property
        /// 
        public ImageSource PressedImage
        {
            get { return (ImageSource)this.GetValue(PressedImageProperty); }
            set { this.SetValue(PressedImageProperty, value); }

        }
        
    }
}

App.xaml -  Template do componente

Visible






Collapsed

Uso do componente Agora podemos usar nosso componente personalizado em alguma Page do WP7.

MainPage.xaml

Basta adaptar para seu código e usar!

Era isso pessoal. Espero que esse exemplo ajude alguém! Até a próxima.