Programação Android e .Net

Usando SQLite em uma Aplicação .NET

2011-12-14T10:49:00.001-02:00

A Base de Dados SQLite é conhecida por ser muito leve, rápida e por ser utilizada em várias aplicações que necessitam de uma base de dados confiável e robusta. Atualmente a base de dados SQLite é muito utilizada em dispositivos móveis como Android, Iphone e Ipad.

Antigamente para utilizar a base de dados SQLite em .NET era um pouco complicado, porque precisavamos utilizar as DLLs do SQLite através do PInvoke em .NET. Agora no site oficial do SQLite foi inserida a biblioteca System.Data.SQLite para ser utilizada em aplicações .NET.

Para este post criei uma Aplicação Console para manipular as informações de uma base de dados de livros. Nesta aplicação o usuário poderá cadastrar, excluir, alterar e visualizar os livros existentes na base de dados.

Para utilizar a biblioteca do SQLite em .NET é necessário fazer o download da biblioteca e instalar na máquina de desenvolvimento. A biblioteca pode ser baixada no site oficial do SQLite.

No projeto Console no Visual Studio é necessário incluir uma referência à Dll System.Data.SQLite.dll, que normalmente é instalada no diretório C:\Arquivos de Programas\System.Data.SQLite\2008\bin.

No projeto Console foi criada a classe SqliteDb que possui os métodos para inserir, alterar e excluir dados da base SQLite, a classe auxiliar Livro (Listagem 1) que é utilizada para armazenar os dados do livro que está sendo utilizado pelos outros métodos e a classe Program que possui o método Main e outros métodos auxiliares para executar a aplicação.

Listagem 1:

    public class Livro
    {
        public long id { get; set; }
        public string titulo { get; set; }
        public string autor { get; set; }
        public string ano { get; set; }
        public string genero { get; set; }
    }

A seguir são detalhados os métodos que fazem parte da classe SqliteDb:

Foram criadas duas constantes, uma para definir o nome da base de dados e a outra para definir a conexão com a base de dados SQLite.

        const string DATABASE_NAME = "livros_classicos.db";
        const string CONNECTION = "Data Source=" + DATABASE_NAME;

O método CreateDatabase() cria a base de dados livros_classicos.db, se não existir e cria a tabela livros:

        public void CreateDatabase()
        {
            SQLiteConnection conn = new SQLiteConnection(CONNECTION);
            try
            {
                if (!File.Exists(DATABASE_NAME))
                {
                    SQLiteConnection.CreateFile(DATABASE_NAME);

                    // Cria a tabela livros
                    conn.Open();
                    SQLiteCommand cmd = new SQLiteCommand();
                    cmd.Connection = conn;
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = "CREATE TABLE livros (" +
                        "id INTEGER NOT NULL PRIMARY KEY," + 
                        "titulo TEXT," + 
                        "autor TEXT," + 
                        "ano_publicacao TEXT," + 
                        "genero TEXT)";

                    cmd.ExecuteNonQuery();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                if (conn != null)
                {
                    conn.Close();
                }
            }
        }

O método InsertLivro(Livro) insere um livro na base:

        public bool InsertLivro(Livro livro)
        {
            bool resultado = false;
            SQLiteConnection conn = new SQLiteConnection();

            try
            {
                conn.ConnectionString = CONNECTION;
                conn.Open();

                SQLiteCommand cmd = new SQLiteCommand();
                cmd.Connection = conn;
                cmd.CommandType = CommandType.Text;

                cmd.Parameters.AddWithValue("@Titulo", livro.titulo);
                cmd.Parameters.AddWithValue("@Autor", livro.autor);
                cmd.Parameters.AddWithValue("@Ano", livro.ano);
                cmd.Parameters.AddWithValue("@Genero", livro.genero);

                cmd.CommandText = "INSERT INTO livros " +
                    "(titulo, autor, ano_publicacao, genero) " +
                    "VALUES (@Titulo, @Autor, @Ano, @Genero)";

                int registro = cmd.ExecuteNonQuery();

                // Verifica se o registro foi inserido
                if (registro == 1)
                {
                    resultado = true;
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                if (conn != null)
                {
                    conn.Close();
                }
            }

O método SearchLivro(string) faz a procura de livros por título e retorna a lista de livros filtrados. Neste método optei em fazer uma busca utilizando o operador LIKE do SQL para fazer uma busca por padrão e não uma busca exata.

        public List<Livro> SearchLivro(string titulo)
        {
            List<Livro> livros = new List<Livro>();

            SQLiteConnection conn = new SQLiteConnection();

            try
            {
                conn.ConnectionString = CONNECTION;
                conn.Open();

                SQLiteCommand cmd = new SQLiteCommand();
                cmd.Connection = conn;
                cmd.CommandType = CommandType.Text;

                cmd.Parameters.AddWithValue("@Titulo", titulo);

                cmd.CommandText = "SELECT * FROM livros WHERE titulo LIKE '%"
                    + titulo + "%'";

                SQLiteDataReader reader = cmd.ExecuteReader();

                while (reader.Read() == true)
                {
                    Livro livro = new Livro();
                    livro.id = (long)reader["id"];
                    livro.titulo = (string)reader["titulo"];
                    livro.autor = (string)reader["autor"];
                    livro.ano = (string)reader["ano_publicacao"];
                    livro.genero = (string)reader["genero"];

                    livros.Add(livro);
                
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                if (conn != null)
                {
                    conn.Close();
                }
            }

            return livros;
        }

O método UpdateLivro(Livro) atualiza os dados do livro.

        public string UpdateLivro(Livro livro)
        {
            string resultado = "";
            SQLiteConnection conn = new SQLiteConnection();

            try
            {

                conn.ConnectionString = CONNECTION;
                conn.Open();

                SQLiteCommand cmd = new SQLiteCommand();
                cmd.Connection = conn;
                cmd.CommandType = CommandType.Text;

                cmd.Parameters.AddWithValue("@Id", livro.id);
                cmd.Parameters.AddWithValue("@Titulo", livro.titulo);
                cmd.Parameters.AddWithValue("@Autor", livro.autor);
                cmd.Parameters.AddWithValue("@Ano", livro.ano);
                cmd.Parameters.AddWithValue("@Genero", livro.genero);

                cmd.CommandText = "UPDATE livros SET titulo=@Titulo, autor=@Autor," +
                    " ano_publicacao=@Ano, genero=@Genero WHERE id=@Id";

                int registroAtualizado = cmd.ExecuteNonQuery();


                if (registroAtualizado == 1)
                {
                    resultado = "O livro foi atualizado com sucesso.";
                }
                else
                {
                    resultado = "O livro não foi atualizado.";
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                if (conn != null)
                {
                    conn.Close();
                }
            }

            return resultado;
        }

O método DeleteLivro(string) apaga o livro filtrado, na base de dados, através do id do livro.

        public string DeleteLivro(string id)
        {
            string resultado = "";
            SQLiteConnection conn = new SQLiteConnection();

            try
            {
                conn.ConnectionString = CONNECTION;
                conn.Open();

                SQLiteCommand cmd = new SQLiteCommand();
                cmd.Connection = conn;
                cmd.CommandType = CommandType.Text;

                cmd.Parameters.AddWithValue("@Id", id);

                cmd.CommandText = "DELETE FROM livros WHERE id=@Id";

                int registroAtualizado = cmd.ExecuteNonQuery();


                if (registroAtualizado == 1)
                {
                    resultado = "O livro foi excluído com sucesso.";
                }
                else
                {
                    resultado = "O livro não foi excluído.";
                }
            }
            catch (Exception ex)
            {
                resultado = ex.Message;
            }

            return resultado;
        }
    }

A seguir são detalhados os métodos que fazem parte da classe Program:

O método Main é o responsável pela inicialização e execução da aplicação:

        static void Main(string[] args)
        {
            ConsoleKeyInfo key = new ConsoleKeyInfo();
            Console.WriteLine("Digite S a qualquer momento" +
                " para sair da aplicação!");

            SqliteDb sqlitedb = new SqliteDb();

            // Cria a base de dados se não existir
            sqlitedb.CreateDatabase();

            while (true)
            {
                Console.WriteLine("Digite I para incluir, A para alterar," +
                    " E para excluir, P para pesquisar e V para visualizar todos os livros:");

                // Lê a tecla digitada
                key = Console.ReadKey(true);

                // Sai da aplicação
                if (key.KeyChar == 'S' || key.KeyChar == 's')
                {                    
                    break;
                }

                // Pesquisa um livro por título
                if (key.KeyChar == 'P' || key.KeyChar == 'p')
                {
                    Console.WriteLine("Digite o título do livro a ser pesquisado:");
                    string titulo = Console.ReadLine();

                    // Exibe as informações do livro
                    BuscarLivro(titulo);
                }

                // Inclui um livro
                if (key.KeyChar == 'I' || key.KeyChar == 'i')
                {
                    // Lê as informações do livro a ser inserido
                    Livro livro = GetLivro();

                    // Insere o livro
                    if (sqlitedb.InsertLivro(livro) == true)
                    {
                        Console.WriteLine("O livro foi incluído com sucesso!");
                    }
                }

                // Exclui um livro
                if (key.KeyChar == 'E' || key.KeyChar == 'e')
                {
                    Console.WriteLine("Digite o título do livro a ser excluído:");
                    string titulo = Console.ReadLine();

                    // Buscar o livro
                    List<Livro> livros = BuscarLivro(titulo);

                    // Obtêm o Id do livro a ser excluído
                    string id = GetId(livros);

                    if (id != "")
                    {
                        // Exclui o livro
                        string resultado = sqlitedb.DeleteLivro(id);
                        Console.WriteLine(resultado);
                    }
                }

                // Altera um livro
                if (key.KeyChar == 'A' || key.KeyChar == 'a')
                {
                    Console.WriteLine("Digite o título do livro a ser alterado:");
                    string titulo = Console.ReadLine();

                    // Buscar livro
                    List<Livro> livros = BuscarLivro(titulo);

                    // Obtêm o Id do livro a ser alterado
                    string id = GetId(livros);

                    if (id != "")
                    {
                        // Lê as novas informações do livro a ser alterado
                        Livro livro = GetLivro();

                        // Atualiza o valor do id
                        livro.id = long.Parse(id); ;

                        // Altera as informações do livro
                        string resultado = sqlitedb.UpdateLivro(livro);
                        Console.WriteLine(resultado);
                    }
                }
            }
        }

O método possui um loop while que apresenta um menu para que o usuário possa selecionar a função que deseja executar ou sair da aplicação. Quando a aplicação é executada é apresentado o seguinte menu:

Digite S a qualquer momento para sair da aplicação!
Digite I para incluir, A para alterar, E para excluir, P para pesquisar e V para
visualizar todos os livros:

Além do método Main a classe Program possui também os métodos BuscarLivro(string), GetId(List<Livro) e GetLivro().

O método BuscarLivro(string) faz a busca dos livros por título e retorna uma lista de livros.

        private static List<Livro> BuscarLivro(string titulo)
        {
            SqliteDb sqlitedb = new SqliteDb();

            List<Livro> livros = sqlitedb.SearchLivro(titulo);
            Console.WriteLine();
            foreach (Livro item in livros)
            {
                Console.WriteLine(item.id + "\t" + item.titulo + "\t" + item.autor + "\t" +
                    item.ano + "\t" + item.genero);
            }
            Console.WriteLine();

            return livros;
        }

O método GetId(List<Livro> livros) faz a busca dos livros e retorna o id do livro.

        private static string GetId(List<Livro> livros)
        {
            // Digitar o id do livro a ser alterado se houver mais de 
            // um livro como resultado
            string id = "";
            if (livros.Count == 0)
            {
                Console.WriteLine("O livro não foi encontrado.");
            }
            else if (livros.Count == 1)
            {
                id = livros[0].id.ToString();
            }
            else
            {
                Console.WriteLine("Digite o id do livro a ser alterado:");
                id = Console.ReadLine();
            }

            return id;
        }

O método GetLivro() retorna um objeto livro com os detalhes do livro.

        private static Livro GetLivro()
        {
            Livro livro = new Livro();
            Console.WriteLine("Digite o título do livro:");
            livro.titulo = Console.ReadLine();
            Console.WriteLine("Digite o autor do livro:");
            livro.autor = Console.ReadLine();
            Console.WriteLine("Digite o ano de publicação do livro:");
            livro.ano = Console.ReadLine();
            Console.WriteLine("Digite o gênero do livro:");
            livro.genero = Console.ReadLine();

            return livro;

        }

Usando HttpURLConnection para Receber Dados no Android

2011-11-23T22:20:00.001-02:00

No Android existem duas formas de enviar e receber dados usando HTTP. Uma é através do Apache HTTP e a outra através de HttpURLConnection.

No post Como Receber Dados de um WebService no Android demonstrei como receber dados de um webservice utilizando o Apache HTTP (DefaultHttpClient).

Recentemente foi publicado no blog do google Android´s HTTP Clients um post informando que a API do Apache HTTP não está mais sendo atualizada, por ser muito grande e difícil de implementar melhorias sem quebrar as compatibilidades. Por esse motivo eles estão trabalhando na API HttpURLConnection.

A API HttpURLConnection é de uso geral, leve, de um tamanho pequeno e atende a maioria das aplicações.

Em dispositivos com a versão 2.2 (Froyo) ou anteriores a API HttpURLConnection tinha alguns bugs. Da versão 2.3 (Gingerbread) para frente esta API é melhor para o Android porque reduz o uso da rede, melhora a velocidade e economiza bateria.

Resumindo até a versão 2.2 (Froyo) é melhor utilizar o Apache HTTP, para as versões 2.3 (Gingerbread) para frente é melhor utilizar a API HttpURLConnection.

Neste post vou utilizar o mesmo webservice e o mesmo projeto do post Como Receber Dados de um webService no Android alterando somente a forma de receber os dados. Ao invés de utilizar a classe DefaultHttpClient vou utilizar a classe HttpURLConnection, portanto substituir a classe WebService.java do post Como Receber Dados de um webService no Android por:

Listagem 1:

public class WebService {
    private static final int TAM_MAX_BUFFER = 10240; // 10Kbytes
    private String urlWebService;
    
    public WebService(String url) {
        this.urlWebService = url;
    }
    
    public String getEstados(){
        String resultado = "";
        HttpURLConnection urlConnection = null;
        
        try {
          URL url = new URL(urlWebService);
          
          urlConnection = (HttpURLConnection) url.openConnection();
          urlConnection.setDoOutput(true);
          urlConnection.setRequestMethod("POST");
          urlConnection.setRequestProperty("Content-Type", 
                  "text/xml; charset=utf-8");
          urlConnection.setRequestProperty("SOAPAction", 
                  "http://tempuri.org/GetEstados");
                    
          String request = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
              "<soap:Envelope " + 
                  "xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " +
                  "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" " +
                  "xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\">" +
              "<soap:Body>" +
              "<GetEstadosResponse xmlns=\"http://tempuri.org/\">" +
              "<GetEstadosResult>string</GetEstadosResult>" +
              "</GetEstadosResponse>" +
              "</soap:Body>" +
              "</soap:Envelope>";
          
          OutputStream out = urlConnection.getOutputStream();
          out.write(request.getBytes());
          
          // Verifica se a resposta está ok antes de solicitar os dados
          if (urlConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {
              InputStream in = new BufferedInputStream(
                      urlConnection.getInputStream());    
              
                BufferedReader reader = new BufferedReader(
                        new InputStreamReader(in,
                                "UTF-8"), TAM_MAX_BUFFER);
                
                StringBuilder builder = new StringBuilder();
                
                for (String line = null ; (line = reader.readLine())!= null;) {
                    builder.append(line).append("\n");
                }
                
                resultado = builder.toString();
                
                // Retira a string <?xml version="1.0" encoding="utf-8" ?> 
                // <string xmlns="http://tempuri.org/"> e a tag </GetEstadosResult> 
                // para obter o resultado em Json, já que o webservice está
                // retornando uma string
                Integer firstTagString = resultado.indexOf("<GetEstadosResult");
                Integer posXml = resultado.indexOf(">", firstTagString);
                Integer posTagString = resultado.indexOf("</GetEstadosResult>");
                resultado = resultado.substring(posXml + 1, posTagString + 1);
          }
          else{
              Log.e("WebService", 
                      "ResponseCode: " + urlConnection.getResponseMessage());
          }

        }
        catch(IOException e){
            Log.e("WebService", e.toString());
        }
        finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
       }
        
        return resultado;
    }
}

No método getEstados() é utilizada a classe HttpURLConnection para obter os dados do webservice. Para utilizar esta classe é necessário configurar os métodos setDoOutput(Boolean) que informa se este HttpURLConnection permite output, no nosso caso deve ser setado como true, no método setRequestMethod(String), e setRequestProperty(String) deve ser passado como parâmetro as informações do webservice. Depois é necessário montar a requisição do webservice e através da classe OutputStream escrever os dados no HttpURLConnection.

Antes de ler os dados verificar através do método getResponseCode() se a resposta do HttpURLConnection está OK.

Como Receber Dados de um WebService no Android

2011-11-03T10:41:00.000-02:00

Neste post vou demonstrar como tratar informações vindas de um webservice desenvolvido em .NET em uma aplicação Android.

O webservice utilizado nesta aplicação é o mesmo publicado no post Retornando Dados em Json com WebService .NET. Este WebService retorna a relação de estados do Brasil juntamente com as informações de área, capital e abreviação em formato Json.

A aplicação Android vai receber as informações do webservice, tratar os dados e exibir a relação de estados em um ListView.

A aplicação possui duas classes Principal.java e WebService.java. Na classe WebService.java foi criado o método getEstados() que se conecta ao WebService e retorna os dados em uma String que contêm as informações formatas em Json. (Listagem 1).

Listagem 1:

public class WebService {
    private static final int TIMEOUT_CONEXAO = 20000; // 20 segundos
    private static final int TIMEOUT_SOCKET = 30000; // 30 segundos
    private static final int TAM_MAX_BUFFER = 10240; // 10Kbytes
    private String url;
    
    public WebService(String url) {
        this.url = url;
    }
    
    public String getEstados(){
        String parserbuilder = "";
        
        try{
            HttpParams httpParameters = new BasicHttpParams();
            
            // Configura o timeout da conexão em milisegundos até que a conexão
            // seja estabelecida
            HttpConnectionParams.setConnectionTimeout(httpParameters, 
                    TIMEOUT_CONEXAO);
            
            // Configura o timeout do socket em milisegundos do tempo 
            // que será utilizado para aguardar os dados
            HttpConnectionParams.setSoTimeout(httpParameters, 
                    TIMEOUT_SOCKET);   
            
            HttpClient httpclient = new DefaultHttpClient(httpParameters);
            HttpPost httppost = new HttpPost(url + "/GetEstados");
    
            HttpResponse response = httpclient.execute(httppost);
            
            BufferedReader reader = new BufferedReader(
                    new InputStreamReader(response.getEntity().getContent(),
                            "UTF-8"), TAM_MAX_BUFFER);
            
            StringBuilder builder = new StringBuilder();
            
            for (String line = null ; (line = reader.readLine())!= null;) {
                builder.append(line).append("\n");
            }
            
            parserbuilder = builder.toString();
            
            // Retira a string <?xml version="1.0" encoding="utf-8" ?> 
            // <string xmlns="http://tempuri.org/"> e a tag </string> 
            // para obter o resultado em Json, já que o webservice está
            // retornando uma string
            Integer firstTagString = parserbuilder.indexOf("<string");
            Integer posXml = parserbuilder.indexOf(">", firstTagString);
            Integer posTagString = parserbuilder.indexOf("</string>");
            parserbuilder = parserbuilder.substring(posXml + 1, posTagString + 1);
        
        }catch(ClientProtocolException e){
            Log.e("WebService", e.toString());
        }
        catch(IOException e){
            Log.e("WebService", e.toString());
        }
        
        return parserbuilder;    
    }
}

No método getEstados() foi utilizada a classe BasicHttpParams() para configurar os timeouts de conexão, e as classes DefaultHttpClient(HttpParams) e HttpPost(String) para fazer uma requisição tipo Post no WebService.

A informação retornada pelo WebService .NET é um Xml que retorna uma String com dados no formato Json. Para facilitar a obtenção das informações no formato Json, optei em tratar a String retornada pelo WebService de modo a ter somente a informação no formato Json.

Na classe Principal.java no método onCreate(Bundle) foi chamada a classe WebService() e feito o tratamento para exibir os estados no ListView. (Listagem 2)

Listagem 2:

public class Principal extends ListActivity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        List<String> estados = new ArrayList<String>();
        
        // o endereço http://localhost no emulador deve
        // se chamado como http://10.0.2.2, porque o
        // endereço http://localhost ou http://127.0.0.1
        // é utilizado pelo próprio emulador
        WebService webService = 
            new WebService("http://10.0.2.2:4362/websitejson/service.asmx");
        
        // Obtêm a resposta do webservice
        String resultado = webService.getEstados();
        
        try {
            // Utiliza a classe JSONArray para obter as
            // informações e separar o campo que será
            // utilizado no listview
            JSONArray json = new JSONArray(resultado);
            
            for (int i = 0; i < json.length(); i++) {
                JSONObject jsonObj = json.getJSONObject(i);
                
                // Insere o estado na lista de estados
                estados.add(jsonObj.getString("Nome"));
            }
            
        } catch (JSONException e) {
            Log.e("WebService", e.toString());
        }
        finally{
            setListAdapter(new ArrayAdapter<String>(this, 
                    android.R.layout.simple_list_item_1, estados));
        }
        
    }
}

O webservice está rodando no localhost (127.0.0.1) porta 4362, mas para chamar o webservice no emulador do android não pode ser utilizado o IP 127.0.0.1 porque este IP é utilizado no emulador, por isso na URL utilizar o IP 10.0.2.2.

Para obter somente os estados utilizei as classe JSONArray e JSONObject para extrair a informação desejada.

Antes de rodar a aplicação não esquecer de dar permissão de acesso à internet no arquivo AndroidManifest.xml.

    <uses-permission android:name="android.permission.INTERNET"></uses-permission>

A aplicação rodando vai exibir a seguinte tela:

A API utilizada HttpDefaultClient é melhor para dispositivos que utilizam a versão 2.2 (Froyo) ou anterior do Android. Para as versões 2.3 (Gingerbread) ou superior é melhor utilizar a API HttpURLConnection. O post Usando HttpURLConnection para Receber Dados no Android demonstra como utilizar esta API.

Utilizando BroadcastReceiver para Iniciar uma Aplicação

2011-09-30T21:35:00.001-03:00

Recentemente necessitei incluir em um projeto Android a possibilidade de fazer a aplicação ser inicializada logo após o boot do dispositivo.

Para este post criei uma aplicação que faz uso da classe BroadcastReceiver para iniciar uma Activity toda vez que o dispositivo faz um boot.

No projeto criei duas classes Principal e IniciarApp.

A classe Principal é a Activity que será exibida logo após o boot do dispositivo. Utilizei a Activity padrão que é criada pelo Eclipse quando criamos um projeto Android, e exibe a mensagem Hello World, Principal!

A classe IniciarApp é a classe que é inicializada quando recebe a mensagem de Boot do sistema. (Listagem 1)

Listagem 1:

public class IniciarApp extends BroadcastReceiver {

    @Override

    public void onReceive(Context ctx, Intent i) {

        // Exibe a Activity Principal após o boot

        // do Android

        Intent intent = new Intent(ctx, Principal.class);

        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);

        ctx.startActivity(intent);

A classe IniciarApp estende a classe BroadcastReceiver. O método onReceive(Context, Intent) é chamado quando a aplicação recebe a mensagem de broadcast de boot do sistema. Neste método é declarada a intent que vai exibir a Activity Principal. Neste caso é necessário configurar o flag Intent.FLAG_ACTIVITY_NEW_TASK, para que a aplicação seja inicializada como uma nova tarefa na pilha do stack das Activities.

Para registrar um BroadcastReceiver podemos utilizar a API ou publicar o receiver no arquivo AndroidManifest.xml. Neste caso é mais simples publicar pelo arquivo AndroidManifest.xml. (Listagem 2)

Listagem 2:

 <!-- Permissão necessária para receber a mensagem de boot completado -->

 <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />

 <application android:icon="@drawable/icon" android:label="@string/app_name">

     <!-- Publicação do Broadcast -->

  <receiver android:name=".IniciarApp">

      <intent-filter>

          <action android:name="android.intent.action.BOOT_COMPLETED" />

          <category android:name="android.intent.category.DEFAULT" />

      </intent-filter>

  </receiver>

     <activity android:name=".Principal"

               android:label="@string/app_name">

         <intent-filter>

             <action android:name="android.intent.action.MAIN" />

             <category android:name="android.intent.category.LAUNCHER" />

         </intent-filter>

     </activity>

 </application>

No arquivo AndroidManifest.xml foi incluída a tag de permissão do usuário para receber a mensagem de boot completado, e também foi incluída a tag <receiver> que registra a classe IniciarApp como a classe que vai ser chamada quando a mensagem de boot do sistema for recebida.

Para testar, primeiro rode a aplicação uma vez no emulador para que o arquivo .apk da aplicação seja instalado, depois feche o emulador do Eclipse e abra novamente.

Quando o emulador finalizar o boot a Activity Principal será exibida apresentando a mensagem Hello World, Principal! Pronto agora a aplicação será inicializada após cada boot do sistema. Após os testes não esqueça de desinstalar a aplicação, senão toda vez que o emulador for inicializado vai apresentar a Activity Principal.

Uma observação importante é que esta utilização do BroadcastReceiver é muito particular e deve ser utilizada com cuidado, para que a experiência do usuário não seja prejudicada, porque desta forma a aplicação não segue o padrão das aplicações do Android.

A utilização recomendada para o BroadcastReceiver é trabalhar em conjunto com a classe Service e Notification. O ideal é que o BroadcastReceiver inicie um serviço em background e informe o usuário utilizando as mensagens de notificação do dispositivo.

Touch Mode no Android

2011-09-13T22:49:00.001-03:00

Neste post vou escrever sobre um assunto que achei bem interessante com relação ao que conhecemos como “foco”. É muito comum em aplicações desktop ter se a preocupação em tratar o posicionamento do “foco” nos controles de uma janela e tratar os eventos relacionados ao “foco”. No Android como existem diversos tipos de aparelhos que permitem uma navegação diferenciada de acordo com o hardware, torna-se necessário conhecer melhor como é o funcionamento do “foco” em aparelhos com tela touch screen, com trackball ou com teclado.

O Android tem uma funcionalidade chamada de Touch Mode. Esta funcionalidade foi criada para diferenciar a forma como um widget é exibido no momento em que é pressionado ou selecionado, seja com um clique através da tela touchscreen ou através do teclado ou um trackball.

Quando um widget é selecionado através da tela touchscreen o Android entre automaticamente em modo Touch Mode e fica neste modo até que uma tecla de navegação ou um trackball seja acionado, fazendo com que o Android saia do modo TouchMode.

Portanto o framework do Android reconhece automaticamente quando um widget é acionado através da tela touchscreen ou através do teclado.

No caso em que o dispositivo esteja em Touch Mode (quando o usuário utiliza a tela touchscreen) os widgets não apresentam o “foco”ou indicação de estarem selecionados. A exceção a esta regra são os widgets que possuem o atributo android:focusableinTouchMode setado como true, como por exemplo o EditText, o ListView quando está configurado para trabalhar com filtro. Neste caso o widget que permite a digitação de texto aparece com foco no local onde o texto vai ser inserido.

Quando um widget é selecionado através da tela touch screen não existe uma dúvida de qual widget foi selecionado, por isso alguns widgets simplesmente respondem ao evento sem dar qualquer indicação na tela, por exemplo button, checkbox, radion button.

No caso do usuário estar utilizando o teclado para navegar ou um trackball, os widgets recebem foco e permanecem selecionados para que fique visível o item selecionado.

Uma situação que causa confusão é quando o usuário seleciona um widget através do teclado, este widget recebe foco, quando o usuário toca a tela, o widget perde o foco e só retorna a ter o foco quando a tecla de navegação é acionada novamente. Isto ocorre porque o dispositivo muda de modo de operação de Touch Mode para não Touch Mode.

Para saber se a aplicação está em modo Touch Mode utilize o método isInTouchMode() da classe View.

View.isInTouchMode()

Quando uma aplicação que possui um ListView e está em modo Touch Mode não é possível obter o item selecionado através do método ListView.getSelectedItemPosition(). Neste caso o método vai retornar INVALID_POSITION. O método só vai retornar a posição do item selecionado se não estiver no modo Touch Mode. Para resolver este problema utilize o click listener da View.

No momento de desenvolver a interface de uma aplicação deve-se levar em consideração a utilização da aplicação e lembrar o padrão de funcionamento do framework. Não desenvolver a aplicação baseando-se em foco e seleção.

Customizando a Cor de Fundo de um Widget no Android

2011-08-23T22:39:00.001-03:00

Neste post vou demonstrar como configurar a cor de fundo de um botão utilizando duas técnicas diferentes. Uma utilizando figuras com cor em degradê, para dar o efeito do botão sendo pressionado, e outra utilizando o mesmo efeito degradê só que, fazendo a configuração do botão utilizando um arquivo xml.

Para este exemplo criei um projeto com dois botões com cor em degradê como demonstrado na Figura 1.

Figura 1

Para montar o layout dois dois botões foi utilizado o seguinte código no arquivo main.xml (Listagem 1):

Listagem 1:

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:orientation="vertical"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    <!-- View utilizada como separador -->

    <View

        android:layout_width="fill_parent"

        android:layout_height="10sp"

        android:id="@+id/view1"

/>

    <Button

        android:id="@+id/btnJpg"

        android:layout_width="200dp"

        android:layout_height="50dp"

        android:layout_centerHorizontal="true"

        android:layout_below="@+id/view1"

        android:text="Design por Figura Jpg"

        android:background="@drawable/botao_azul_selector"

/>

        <!-- View utilizada como separador -->

    <View

        android:layout_width="fill_parent"

        android:layout_height="10sp"

        android:id="@+id/view2"

        android:layout_below="@+id/btnJpg"

/>

    <Button

        android:id="@+id/btnXml"

        android:layout_width="200dp"

        android:layout_height="50dp"

        android:layout_centerHorizontal="true"

        android:layout_below="@+id/view2"

        android:text="Design por Arquivo Xml"

        android:background="@drawable/botao_verde_selector"

/>

</RelativeLayout>

No primeiro botão btnJpg foi utilizado como cor de fundo duas figuras em degradê uma para quando o botão for pressionado e outra para quando o botão for solto. É necessário utilizar duas figuras para dar o efeito dinâmico do botão estar sendo pressionado.

Para configurar este efeito utilizei um recurso chamado de StateListDrawable que é um arquivo xml onde podemos configurar figuras diferentes para cada estado, por exemplo de um botão.

Este arquivo xml deve ser colocado em um diretório \drawable. O arquivo para configurar o primeiro botão é o botão_azul_selector (Listagem 2), configurado no atributo android:background="@drawable/botao_azul_selector".

Listagem 2:

<?xml version="1.0" encoding="utf-8"?>

<selector xmlns:android="http://schemas.android.com/apk/res/android">

    <item

         android:state_pressed="true"

        android:drawable="@drawable/botao_azul_on"

/>

    <item

        android:drawable="@drawable/botao_azul_off"

/>

</selector>

No estado android:state_pressed foi utilizada a figura botao_azul_on para representar o botão quando pressionado e a figura botao_azul_off para representar o botão no estado não pressionado. As figuras do botão devem estar em um diretório \drawable.

No segundo botão btnXml foi utilizada uma outra técnica de configurar a cor de fundo do botão. O princípio é o mesmo, foi utilizado um arquivo Xml para configurar a aparência do botão em cada um dos estados (pressionado ou não), só que desta vez ao invés de utilizar figuras .jpg, foram utilizadas tags para construir a forma geométrica do botão. O arquivo botao_verde_selector também deve ser colocado em um diretório \drawable (Listagem 3):

Listagem 3:

<?xml version="1.0" encoding="utf-8"?>

<selector xmlns:android="http://schemas.android.com/apk/res/android">

    <item android:state_pressed="true" >

        <shape>

            <gradient

                android:startColor="@color/verde_claro"

                android:endColor="@color/verde_escuro"

                android:angle="270" />

            <stroke

                android:width="1dp"

                android:color="@color/verde_escuro" />

            <corners

                android:radius="10dp" />

            <padding

                android:left="10dp"

                android:top="10dp"

                android:right="10dp"

                android:bottom="10dp" />

        </shape>

    </item>

    <item>

       <shape>

            <gradient

                android:startColor="@color/verde_escuro"

                android:endColor="@color/verde_claro"

                android:angle="270" />

            <stroke

                android:width="1dp"

                android:color="@color/verde_escuro" />

            <corners

                android:radius="10dp" />

            <padding

                android:left="10dp"

                android:top="10dp"

                android:right="10dp"

                android:bottom="10dp" />

        </shape>

    </item>

</selector>

A aparência do botão verde é construída através da tag de forma <shape> cujo default é o retângulo. Dentro desta tag temos a tag <gradient> que define a cor degradê, a tag <stroke> que define a largura e a cor do contorno do botão, a tag <corners> que define o ângulo da borda arredondada do nosso botão e a tag <padding> que define o posicionamento do conteúdo e não da forma geométrica do botão.

Observe que foram criadas duas tags <item>, uma para o estado pressionado do botão e outra para o estado default do botão.

Para rodar a aplicação foi criada a Activity Principal (Listagem 4):

Listagem 4:

public class Principal extends Activity {

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

Configurar o Atributo MaxLength Programaticamente no Android

2011-08-15T21:58:00.001-03:00

No Android os atributos utilizados no arquivo xml do layout podem ser programados também no código através de métodos. No caso do atributo android:maxLength a programação via código não é tão direta como para os outros atributos.

Para demonstrar como configurar o número máximo de texto em um widget EditText criei um arquivo de layout xml com dois campos EditText. No primeiro campo editMax1 foi configurado número máximo de texto como 10 (Listagem 1).

Listagem 1

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    android:orientation="vertical"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    <EditText

        android:id="@+id/editMax1"

        android:layout_width="fill_parent"

        android:layout_height="wrap_content"

        android:maxLength="10"

/>

    <EditText

        android:id="@+id/editMax2"

        android:layout_width="fill_parent"

        android:layout_height="wrap_content"

/>

</LinearLayout>

Para o segundo campo editMax2 vamos configurar o comprimento máximo do texto programaticamente (Listagem 2).

Listagem 2

public class Main extends Activity {

    private static final int MAX_LENGTH = 10;

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.main);

        EditText edit2 = (EditText)findViewById(R.id.editMax2);

        // Define o número máximo de caracteres do campo

        // em 10 caracteres programaticamente

        edit2.setFilters(new InputFilter[]

             {new InputFilter.LengthFilter(MAX_LENGTH)});

No método onCreate(Bundle) foi criada a variável edit2 que representa o segundo campo editMax2 do arquivo xml de layout.

Para configurar o número máximo de texto foi utilizado o método setFilters(InputFilter).

Portanto os dois campos EditText estão limitados em no máximo 10 caracteres, o primeiro via arquivo xml e configuração de atributo e o segundo programaticamente. Executando a aplicação teremos os dois campos exatamente com o mesmo comportamento.

Utilizando o ListView para Selecionar Vários Itens no Android

2011-08-09T23:11:00.001-03:00

Neste post vou demonstrar como trabalhar com um ListView que permite a seleção de um ou vários itens, e como tratar o retorno dos itens selecionados.

Criei um projeto onde são exibidas as regiões do Brasil (Figura 1) na Activity principal e quando selecionada uma região é apresentada uma Activity filha (Figura 2) com a relação de estados pertencentes àquela região, com um checkbox que permite a seleção ou não de cada estado (Figura 2).

Quando são selecionados um ou mais estados na Activity filha (Tela com a relação dos estados da região selecionada – Figura 2) e retornamos para a Activity principal (Figura 1) é apresentada uma mensagem com os estados que foram selecionados (Figura 3). No exemplo foi selecionada a região Sudeste na Activity Principal e os estados Minas Gerais, Rio de Janeiro e São Paulo.

No projeto foram criadas duas classes para representar as duas Activities. A primeira classe é a Main.java (Listagem 1)

Listagem 1

public class Main extends ListActivity implements OnItemClickListener {

    private String[] regiao = new String[]{

            "Centro-Oeste", "Nordeste", "Norte",

            "Sudeste", "Sul"};

    private final static int ACTIVITY_STATE = 1;

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setListAdapter(new ArrayAdapter<String>(this,

                android.R.layout.simple_list_item_1, regiao));

        ListView listView = getListView();

        listView.setOnItemClickListener(this);

    @Override

    public void onItemClick(AdapterView<?> parent, View view,

            int position, long id) {

        String regiao = (String) parent.getItemAtPosition(position);

        Intent intent = new Intent(this, StateListActivity.class);

        intent.putExtra("estados", getEstados(regiao));

        startActivityForResult(intent, ACTIVITY_STATE);

    @Override

    protected void onActivityResult(int requestCode, int resultCode, Intent data) {

        super.onActivityResult(requestCode, resultCode, data);

        // Verifica se o retorno veio da Activity chamada

        if (requestCode == ACTIVITY_STATE) {

            if (resultCode == RESULT_OK) {

                if (data != null) {

                    ArrayList<String> estados = data.getStringArrayListExtra("estados");

                    StringBuilder message = new StringBuilder();

                    message.append("Estados selecionados:\n");

                    for (int i = 0; i < estados.size(); i++) {

                            message.append(estados.get(i) + "\n");

                    // Exibe o nome dos estados selecionados

                    Toast.makeText(this, message.toString(), Toast.LENGTH_SHORT).show();

    private String[] getEstados(String regiao){

        if (regiao.equals("Centro-Oeste")) {

            return new String[]{

            "Goiás", "Mato Grosso", "Mato Grosso do Sul",

            "Distrito Federal"};

        if (regiao.equals("Nordeste")) {

            return new String[]{

                    "Maranhão", "Piauí", "Ceará", "Rio Grande do Norte",

                    "Paraíba", "Pernambuco", "Alagoas", "Sergipe",

                    "Bahia};

        if (regiao.equals("Norte")) {

            return new String[]{

                    "Acre", "Amazonas", "Roraima", "Rondônia",

                    "Pará", "Amapá", "Tocantins"};

        if (regiao.equals("Sudeste")) {

            return new String[]{

                    "Minas Gerais", "Espírito Santo", "Rio de Janeiro",

                    "São Paulo"};

        if (regiao.equals("Sul")) {

            return new String[]{

                    "Paraná", "Santa Catarina", "Rio Grande do Sul"};

        return new String[] { "" };

A classe Main.java constroi a tela Principal e trata o retorno dos dados recebidos da Tela dos Estados.

O método onCreate(Bundle) cria um ListView com o layout padrão do Android (android.R.layout.simple_list_item_1) com os dados obtidos da matriz regiao.

O método onItemClick(AdapterView<?>, View, int, long) é chamado quando uma região é selecionada no ListView. Neste método é armazenada a região selecionada na variável local regiao e a Activity dos Estados é exibida através da chamada do método startActivityForResult(intent, int) que exibe a Activity e aguarda o resultado dos estados selecionados quando a Activity chamada retornar para a Activity principal.

O método onActivityResult(int, int, Intent) é chamado quando a Activity de Estados retorna para a Activity Principal. Este método verifica se a Activity que retornou era a Activity esperada através da verificação do parâmetro requestCode, verifica se o resultado está correto através do parâmetro resultCode, obtêm os dados retornados através do parâmetro data e exibe uma mensagem indicando os estados selecionados na Activity de Estados.

O método getEstados(String) retorna uma matriz com os estados de acordo com a região informada no parâmetro regiao.

A segunda classe é a StateListActivity.java (Listagem 2).

Listagem 2

public class StateListActivity extends ListActivity implements OnItemClickListener {

    ListView listView;

    String[] estados;

    ArrayList<String> stateList;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        Intent intent = getIntent();

        if (intent != null) {

            estados = intent.getStringArrayExtra("estados");

            // Exibe o listview com botão tipo checkbox

            setListAdapter(new ArrayAdapter<String>(this,

                    android.R.layout.simple_list_item_multiple_choice,

                    estados));

            listView = getListView();

            // Desabilita o foco no item

            listView.setItemsCanFocus(false);

            // Configura o listview para permitir a seleção de

            // vários itens simultaneamente

            listView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);

            listView.setOnItemClickListener(this);

    @Override

    public void onItemClick(AdapterView<?> parent, View view,

            int position, long id) {

        stateList = new ArrayList<String>();

        // Mapa de Booleans com a informação dos estados selecionados

        SparseBooleanArray status = listView.getCheckedItemPositions();

        // Limpa a lista anterior para manter atualizada

        // a última seleção

        stateList.clear();

        for (int i = 0; i < status.size(); i++) {

            if (status.valueAt(i) == true) {

                stateList.add((String)listView.getItemAtPosition

                        (status.keyAt(i)));

    @Override

    public void onBackPressed() {

        // Verifica se algum estado foi selecionado

        if (stateList != null) {

            // Passa as informações dos estados selecionados para

            // a activity pai

            Intent intent = new Intent();

            intent.putStringArrayListExtra("estados", stateList);

            setResult(RESULT_OK, intent);

        else

            setResult(RESULT_CANCELED);

        super.onBackPressed();

A classe StateListActivity.java é responsável por exibir a tela com a relação de estados e permite a seleção ou não de um ou mais estados.

O método onCreate(Bundle) utiliza o método getIntent() para obter a relação de estados que foi passada pela Activity principal (classe Main.java) e exibe a tela com o layout configurado para exibir um listview com botão tipo checkbox, configurado com a opção de selecionar vários itens simultaneamente.

O método onItemClick(AdapterView, View, int, long) é chamado quando um item do listview é selecionado. Neste método é utilizada a classe SparseBooleanArray que faz o mapeamento de boolean para integer e é utilizada para armazenar as informações de quais itens da relação de estados foi selecionado. Com o método valueAt(int) da classe SparseBooleanArray, obtemos o valor se true ou false para cada item, e com o método keyAt(int) obtemos a chave dentro da lista de itens. Esta chave é utilizada para determinar qual o estado que está com o status selecionado.

O método onBackPressed() é chamado quando é acionado o botão “Voltar” do emulador. Este método passa as informações dos estados selecionados para a Activity principal.

Obtendo as Propriedades de uma Figura em C#

2011-06-09T17:06:00.001-03:00

Existem situações no projeto em que precisamos saber as propriedades de uma figura, como tamanho em Bytes, largura e altura em pixels ou a resolução, para determinarmos se a figura é adequada para a aplicação, ou se possui as propriedades corretas como tamanho, para fazer um download em um website.

Para obter as propriedades da figura podemos utilizar a classe abstrata Image. No código da Listagem 1 obtemos o tamanho em Bytes, a largura x altura em pixels e a resolução horizontal x resolução vertical em dpi.

Listagem 1

    class Program

        static void Main(string[] args)

            // Lê o arquivo da figura

            FileStream stream = new FileStream("imagem1.jpg", FileMode.Open);

            int imageSize = 0;

            int imageWidth = 0;

            int imageHeight = 0;

            float imageHorizontalDpi = 0.0f;

            float imageVerticalDpi = 0.0f;

            // Obtêm as propriedades da figura

            using (Image image = Image.FromStream(stream, false, false))

                imageSize = Convert.ToInt32(stream.Length);

                imageWidth = image.Width;

                imageHeight = image.Height;

                imageHorizontalDpi = image.HorizontalResolution;

                imageVerticalDpi = image.VerticalResolution;

            Console.WriteLine("Tamanho da Figura em Bytes: " +

                imageSize);

            Console.WriteLine("Largura x Altura da Figura: " +

                imageWidth.ToString() + " x " + imageHeight + " pixels");

            Console.WriteLine("Resolução da Figura: " + imageHorizontalDpi + " x " +

                imageVerticalDpi + " dpi");

            Console.ReadLine();

Para a figura utilizada no código da Listagem 1 obtemos o seguinte resultado:

Tamanho da Figura em Bytes: 83794
Largura x Altura da Figura: 800 x 600 pixels
Resolução da Figura: 96 x 96 dpi

Exibindo uma Activity no Android

2011-05-23T21:19:00.001-03:00

No sistema operacional do Android as telas que são apresentadas para o usuário são chamadas de Activity. Este post demonstra como chamar uma Activity “filha” através de uma Activity “pai” e retornar uma resposta quando o usuário retorna para a Activity “pai”.

Para demonstrar a chamada da Activity foi utilizado o mesmo projeto do post Criando um ListAdapter Customizado para o ListView do Android como projeto de partida. No projeto foi criado um ListView que exibe as informações dos Estados do Brasil.

Neste post será implementada a chamada de uma Activity “filha” para exibir os detalhes do Estado que foi selecionado pelo usuário. Na Figura 1 temos a Activity principal que exibe a relação de Estados do Brasil, juntamente com as informações da Capital e Área do Estado. Na Figura 2 temos a Activity “filha” que exibe os detalhes do Estado selecionado pelo usuário. No exemplo o Estado selecionado foi Rio Grande do Norte.

Para exibir a Activity “filha” foi necessário fazer algumas inserções no código do projeto de partida, demonstrado na Listagem 1:

Listagem 1:

   1:  package br.com.romar;

2:

   3:  import java.util.ArrayList;

   4:  import java.util.List;

5:

   6:  import android.app.ListActivity;

   7:  import android.content.Intent;

   8:  import android.os.Bundle;

   9:  import android.view.View;

  10:  import android.widget.AdapterView;

  11:  import android.widget.ListView;

  12:  import android.widget.AdapterView.OnItemClickListener;

13:

  14:  public class Main extends ListActivity implements OnItemClickListener {

  15:      List<State> stateList;

16:

  17:      /** Called when the activity is first created. */

  18:      @Override

  19:      public void onCreate(Bundle savedInstanceState) {

  20:          super.onCreate(savedInstanceState);

21:

  22:          stateList = new ArrayList<State>();

23:

  24:          for (int i = 0; i < states.length; i++) {

  25:              State state = new State();

  26:              state.setState(states[i][0]);

  27:              state.setAbbreviation(states[i][1]);

  28:              state.setCapital(states[i][2]);

  29:              state.setArea(Float.parseFloat(states[i][3]));

  30:              state.setBanner(images[i]);

31:

  32:              stateList.add(state);

  33:          }

34:

  35:          setListAdapter(new StateAdapter(this, stateList));

36:

  37:          ListView listview = getListView();

38:

  39:          listview.setOnItemClickListener(this);

  40:      }

41:

  42:      @Override

  43:      public void onItemClick(AdapterView<?> parent, View view, int position, long id) {

44:

  45:          // Obtêm os detalhes do Estado selecionado

  46:          State state = stateList.get(position);

47:

  48:          // Exibe a Activity com os detalhes dos Estados

  49:          Intent intent = new Intent(this, DetailActivity.class);

  50:          Bundle params = new Bundle();

  51:          params.putString("estado", state.getState());

  52:          params.putString("capital", state.getCapital());

  53:          params.putFloat("area", state.getArea());

  54:          intent.putExtras(params);

55:

  56:          startActivity(intent);

  57:      }

58:

59:

  60:      private String[][] states = new String[][]{

  61:             {"Acre", "AC", "Rio Branco", "152581.4"},

  62:             {"Alagoas", "AL", "Maceió", "27767.7"},

  63:             {"Amapá", "AP", "Macapá", "142814.6"},

  64:             {"Amazonas", "AM", "Manaus", "1570745.7"},

  65:             {"Bahia", "BA", "Salvador", "564692.7"},

  66:             {"Ceará", "CE", "Fortaleza", "148825.6"},

  67:             {"Distrito Federal", "DF", "Brasília", "5822.1"},

  68:             {"Espírito Santo", "ES", "Vitória", "46077.5"},

  69:             {"Goiás", "GO", "Goiânia", "340086.7"},

  70:             {"Maranhão", "MA", "São Luís", "331983.3"},

  71:             {"Mato Grosso", "MT", "Cuiabá", "903357.9"},

  72:             {"Mato Grosso do Sul", "MS", "Campo Grande", "357125.0"},

  73:             {"Minas Gerais", "MG", "Belo Horizonte", "586528.3"},

  74:             {"Pará", "PA", "Belém", "1247689.5"},

  75:             {"Paraíba", "PB", "João Pessoa", "56439.8"},

  76:             {"Paraná", "PR", "Curitiba", "199314.9"},

  77:             {"Pernambuco", "PE", "Recife", "98311.6"},

  78:             {"Piauí", "PI", "Teresina", "251529.2"},

  79:             {"Rio de Janeiro", "RJ", "Rio de Janeiro", "43696.1"},

  80:             {"Rio Grande do Norte", "RN", "Natal", "52796.8"},

  81:             {"Rio Grande do Sul", "RS", "Porto Alegre", "281748.5"},

  82:             {"Rondônia", "RO", "Porto Velho", "237576.2"},

  83:             {"Roraima", "RR", "Boa Vista", "224299.0"},

  84:             {"Santa Catarina", "SC", "Florianópolis", "95346.2"},

  85:             {"São Paulo", "SP", "São Paulo", "248209.4"},

  86:             {"Sergipe", "SE", "Aracaju", "21910.3"},

  87:             {"Tocantins", "TO", "Palmas", "277620.9"}

  88:         };

89:

  90:      private int[] images = new int[]{

  91:              R.drawable.acre,

  92:              R.drawable.alagoas,

  93:              R.drawable.amapa,

  94:              R.drawable.amazonas,

  95:              R.drawable.bahia,

  96:              R.drawable.ceara,

  97:              R.drawable.distritofederal,

  98:              R.drawable.espiritosanto,

  99:              R.drawable.goias,

 100:              R.drawable.maranhao,

 101:              R.drawable.matogrosso,

 102:              R.drawable.matogrossosul,

 103:              R.drawable.minasgerais,

 104:              R.drawable.para,

 105:              R.drawable.paraiba,

 106:              R.drawable.parana,

 107:              R.drawable.pernambuco,

 108:              R.drawable.piaui,

 109:              R.drawable.riojaneiro,

 110:              R.drawable.riograndenorte,

 111:              R.drawable.riograndesul,

 112:              R.drawable.rondonia,

 113:              R.drawable.roraima,

 114:              R.drawable.santacatarina,

 115:              R.drawable.saopaulo,

 116:              R.drawable.sergipe,

 117:              R.drawable.tocatins

 118:      };

 119:

 120:  }

Na linha 14 foi implementada a interface OnItemClickListener.

Na linha 37 foi obtido o widget ListView da Activity através do método getListView().

Na linha 39 foi registrado um callback para ser chamado quando um item no AdapterView é clicado, através do método setOnItemClickListener(AdapterView.OnItemClick listener).

Nas linhas 42 a 57 é sobrescrito o método onItemClick(AdapterView<?> parent, View view, int position, long id), que obtêm o Estado selecionado e as informações a serem exibidas na segunda Activity. Através do método startActivity(Intent) a Activity da Figura 2 é exibida.

Nas linhas 49 a 54 é criado o objeto intent e o objeto params onde são definidas as informações que serão passadas para a Activity “filha”.

Para que seja exibida a Activity “filha” (chamada de DetailActivity) não esquecer de declarar a Activity no arquivo AndroidManifest.xml do projeto.

        <activity android:name=".DetailActivity" android:label="Detalhes do Estado"/>

No arquivo da Activity DetailActivity no método OnCreate(Bundle savedInstanceState) são obtidos os valores das informações passadas pela Activity “pai”, demonstrado na Listagem 2.

Listagem 2:

   1:      @Override

   2:      protected void onCreate(Bundle savedInstanceState) {

   3:          super.onCreate(savedInstanceState);

4:

   5:          // Configura o layout da Activity

   6:          setContentView(R.layout.state_detail);

7:

   8:          // Widgets da Activity

   9:          TextView textEstado = (TextView)findViewById(R.id.textEstado);

  10:          TextView textCapital = (TextView)findViewById(R.id.textCapital);

  11:          TextView textArea = (TextView)findViewById(R.id.textArea);

12:

  13:          // Carrega os valores passados pela Activity Principal (Main)

  14:          Intent intent = getIntent();

15:

  16:          if (intent != null) {

  17:              textEstado.setText(intent.getStringExtra("estado"));

  18:              textCapital.setText(intent.getStringExtra("capital"));

  19:              textArea.setText(String.valueOf(intent.getFloatExtra("area", 0)));

  20:          }

  21:      }

Na linha 14 as informações passadas pela Activity “pai” são obtidas através do método getIntent().

Agora, e se com a apresentação da Activity “filha” quisessemos preencher algum campo e retornar esta informação para a Activity “pai”? Isto pode ser feito utilizando-se o método startActivityForResult(Intent, int) ao invés do método startActivity(Intent) utilizado anteriormente.

O método startActivityForResult(Intent, int) faz a chamada de outra Activity, só que desta vez além do parâmetro Intent é passado como parâmetro um número inteiro utilizado para identificar a chamada.O resultado retornará através do método onActivityResult(int, int, Intent).

Quando saímos de uma Activity, ela pode chamar o método setResult(int) para retornar um dado de volta para a Activity chamadora. A Activity deve fornecer um código, que pode ser os resultados padrão RESULT_CANCELED, RESULT_OK, ou qualquer valor customizado. Opcionalmente ela pode retornar um Intent contendo dados adicionais.

Para demonstrar como retornar dados de uma Activity “filha”, vou utilizar o mesmo projeto fazendo pequenas alterações.

Na classe Main exibida na Listagem 1 acima, incluir a declaração da seguinte constante na classe.

private final static int CALL_SECOND_ACTIVITY = 1;

Esta constante define o valor de identificação a ser passado no segundo parâmetro do método startActivityForResult(Intent, int).

No método onItemClick(AdapterView<?> parent, View view, int position, long id) demonstrado na linha 43 da Listagem 1, substituir a chamada da Activity startActivity(Intent) (linha 56) pela linha abaixo:

startActivityForResult(intent,CALL_SECOND_ACTIVITY);

No código da Listagem 1 incluir o método onActivityResult(int, int, Intent), conforme demonstrado abaixo na Listagem 3:

Listagem 3:

   1:      /**

   2:       * Método chamado quando saímos da DetailActivity

   3:       * @param requestCode O código inteiro originalmente fornecido

   4:       * no método startActivityForResult(), permitindo identificar

   5:       * quem fez a chamada.

   6:       * @param resultCode O código inteiro retornado pela Activity

   7:       * filha através do método setResult().

   8:       * @param data Um Intent que pode retornar dados ao chamador.

   9:       */

  10:      @Override

  11:      protected void onActivityResult(int requestCode,

  12:              int resultCode, Intent data) {

  13:          super.onActivityResult(requestCode, resultCode, data);

14:

  15:          // Verifica se é o código de quem fez a chamada

  16:          if (requestCode == CALL_SECOND_ACTIVITY) {

  17:              // Verifica se o retorno foi com sucesso

  18:              if (resultCode ==RESULT_OK) {

  19:                  if (data != null) {

  20:                      Bundle params = data.getExtras();

  21:                      if (params.getBoolean("visitar") == true) {

  22:                           Toast.makeText(this, "Quero visitar " +

  23:                                   params.getString("estado"),

  24:                                   Toast.LENGTH_SHORT).show();

  25:                      }

  26:                  }

  27:              }

  28:          }

  29:      }

Este método será chamado quando a Activity “filha” for fechada.

Na linha 16 é verificado se o código da identificação representa o mesmo código passado na chamada.

Na linha 21 através da classe Bundle obtemos a informação se o usuário deseja visitar o Estado e o nome do Estado.

Substituir o código da Listagem 2 pelo da Listagem 4:

Listagem 4:

   1:  public class DetailActivity extends Activity implements OnClickListener {

   2:      TextView textEstado;

   3:      TextView textCapital;

   4:      TextView textArea;

5:

   6:      @Override

   7:      protected void onCreate(Bundle savedInstanceState) {

   8:          super.onCreate(savedInstanceState);

9:

  10:          // Configura o layout da Activity

  11:          setContentView(R.layout.state_detail);

12:

  13:          // Widgets da Activity

  14:          textEstado = (TextView)findViewById(R.id.textEstado);

  15:          textCapital = (TextView)findViewById(R.id.textCapital);

  16:          textArea = (TextView)findViewById(R.id.textArea);

17:

  18:          // Carrega os valores passados pela Activity Principal (Main)

  19:          Intent intent = getIntent();

20:

  21:          if (intent != null) {

  22:              textEstado.setText(intent.getStringExtra("estado"));

  23:              textCapital.setText(intent.getStringExtra("capital"));

  24:              textArea.setText(String.valueOf(intent.getFloatExtra("area", 0)));

  25:          }

26:

  27:          final RadioButton rbSim = (RadioButton)findViewById(R.id.rbSim);

  28:          final RadioButton rbNao = (RadioButton)findViewById(R.id.rbNao);

29:

  30:          rbSim.setOnClickListener(this);

  31:          rbNao.setOnClickListener(this);

  32:      }

33:

  34:      @Override

  35:      public void onClick(View v) {

  36:          Intent intent = new Intent();

  37:          // Verifica qual radiobutton foi selecionado

  38:          if (v.getId() == R.id.rbSim) {

  39:              intent.putExtra("visitar", true);

  40:              intent.putExtra("estado", textEstado.getText().toString());

  41:              setResult(RESULT_OK, intent);

  42:          }

  43:      }

  44:  }

Nas linhas 27 e 28 foram incluídas as declarações do botões RadioButton.

Nas linhas 30 3 31 foram registrados os eventos OnClickListener(View.OnClickListener) para os botões Sim e Não.

A partir da linha 35 temos o método que trata o botão selecionado. Através de um Intent, é passado um boolean informando se deseja visitar o Estado e uma String com o nome do Estado.

Na linha 41 é utilizado o método setResult(int, Intent), para poder passar o resultado OK da operação e a Intent com as informações se deseja visitar, e o nome do Estado.

Executando a aplicação com as alterações descritas e selecionando o Estado Rio Grande do Norte com a opção de visitar, quando fechamos a Activity “filha” será apresentada uma mensagem com o nome do Estado que se deseja visitar, como apresentado na Figura 3:

Atualizado: Como comentado por um leitor do post ficou faltando o xml da Activity dos detalhes do estado, que segue abaixo:

<?xml version="1.0" encoding="utf-8"?>

<TableLayout

  xmlns:android="http://schemas.android.com/apk/res/android"

  android:layout_width="match_parent"

  android:layout_height="match_parent"

  android:stretchColumns="2"

  android:padding="5dp"

  <TableRow>

      <TextView

          android:layout_column="1"

          android:text="Estado:"

          android:padding="3dp"

          android:textSize="24sp"

/>

      <TextView

          android:layout_column="2"

          android:hint="Nome do Estado..."

          android:id="@+id/textEstado"

          android:textSize="24sp"

/>

  </TableRow>

  <TableRow>

      <TextView

          android:layout_column="1"

          android:text="Capital:"

           android:textSize="24sp"

/>

      <TextView

          android:layout_column="2"

          android:hint="Nome da Capital..."

          android:id="@+id/textCapital"

          android:textSize="24sp"

/>

  </TableRow>

  <TableRow>

      <TextView

          android:layout_column="1"

          android:text="Área:"

           android:textSize="24sp"

/>

      <TextView

          android:layout_column="2"

          android:hint="Area em Km2..."

          android:id="@+id/textArea"

           android:textSize="24sp"

/>

  </TableRow>

  <TableRow>

      <TextView

          android:layout_column="1"

          android:text="Visitar?"

           android:textSize="24sp"

/>

    <RadioGroup

        android:orientation="horizontal"

        <RadioButton

            android:id="@+id/rbSim"

            android:text="Sim"

            android:layout_height="35dp"

              android:textSize="24sp"

/>

        <RadioButton

            android:id="@+id/rbNao"

            android:text="Não"

            android:layout_height="35dp"

              android:textSize="24sp"

/>

    </RadioGroup>

  </TableRow>

</TableLayout>

Criando um ListAdapter Customizado para o ListView do Android

2011-03-28T12:09:00.001-03:00

Post atualizado em 06/09/2011.

O widget ListView é um componente poderoso e flexível do Android, normalmente utilizado para exibir uma simples lista de dados. Este post descreve como criar um ListAdapter para exibir várias informações e uma figura em cada linha do ListView.

Para demonstrar a criação do ListAdapter customizado foi criado um projeto para exibir em um ListView os estados do Brasil, juntamente com a abreviação, nome da capital, área em km² e a imagem da bandeira do estado. O projeto rodando apresenta a seguinte tela:

O projeto possui somente uma Activity que carrega o ListView no método OnCreate() demonstrado no arquivo Main.java.

public class Main extends ListActivity {

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        List<State> stateList = new ArrayList<State>();

        for (int i = 0; i < states.length; i++) {

            State state = new State();

            state.setState(states[i][0]);

            state.setAbbreviation(states[i][1]);

            state.setCapital(states[i][2]);

            state.setArea(Float.parseFloat(states[i][3]));

            state.setBanner(images[i]);

            stateList.add(state);

        setListAdapter(new StateAdapter(this, stateList));

    private String[][] states = new String[][]{

           {"Acre", "AC", "Rio Branco", "152581.4"},

           {"Alagoas", "AL", "Maceió", "27767.7"},

           {"Amapá", "AP", "Macapá", "142814.6"},

           {"Amazonas", "AM", "Manaus", "1570745.7"},

           {"Bahia", "BA", "Salvador", "564692.7"},

           {"Ceará", "CE", "Fortaleza", "148825.6"},

           {"Distrito Federal", "DF", "Brasília", "5822.1"},

           {"Espírito Santo", "ES", "Vitória", "46077.5"},

           {"Goiás", "GO", "Goiânia", "340086.7"},

           {"Maranhão", "MA", "São Luís", "331983.3"},

           {"Mato Grosso", "MT", "Cuiabá", "903357.9"},

           {"Mato Grosso do Sul", "MS", "Campo Grande", "357125.0"},

           {"Minas Gerais", "MG", "Belo Horizonte", "586528.3"},

           {"Pará", "PA", "Belém", "1247689.5"},

           {"Paraíba", "PB", "João Pessoa", "56439.8"},

           {"Paraná", "PR", "Curitiba", "199314.9"},

           {"Pernambuco", "PE", "Recife", "98311.6"},

           {"Piauí", "PI", "Teresina", "251529.2"},

           {"Rio de Janeiro", "RJ", "Rio de Janeiro", "43696.1"},

           {"Rio Grande do Norte", "RN", "Natal", "52796.8"},

           {"Rio Grande do Sul", "RS", "Porto Alegre", "281748.5"},

           {"Rondônia", "RO", "Porto Velho", "237576.2"},

           {"Roraima", "RR", "Boa Vista", "224299.0"},

           {"Santa Catarina", "SC", "Florianópolis", "95346.2"},

           {"São Paulo", "SP", "São Paulo", "248209.4"},

           {"Sergipe", "SE", "Aracaju", "21910.3"},

           {"Tocantins", "TO", "Palmas", "277620.9"}

};

    private int[] images = new int[]{

            R.drawable.acre,

            R.drawable.alagoas,

            R.drawable.amapa,

            R.drawable.amazonas,

            R.drawable.bahia,

            R.drawable.ceara,

            R.drawable.distritofederal,

            R.drawable.espiritosanto,

            R.drawable.goias,

            R.drawable.maranhao,

            R.drawable.matogrosso,

            R.drawable.matogrossosul,

            R.drawable.minasgerais,

            R.drawable.para,

            R.drawable.paraiba,

            R.drawable.parana,

            R.drawable.pernambuco,

            R.drawable.piaui,

            R.drawable.riojaneiro,

            R.drawable.riograndenorte,

            R.drawable.riograndesul,

            R.drawable.rondonia,

            R.drawable.roraima,

            R.drawable.santacatarina,

            R.drawable.saopaulo,

            R.drawable.sergipe,

            R.drawable.tocatins

};

No método OnCreate() foi criado um ArrayList com as informações dos estados. Normalmente este tipo de informação é carregada de uma base de dados ou de alguma outra fonte de informação, mas como o objetivo é demonstrar a utilização do ListView, foi criado um array com as informações dos estados (states) e outro array com as imagens das bandeiras (images). As imagens foram obtidas dos arquivos colocados na pasta de resource res/drawable-mdpi.

Para montar o ArrayList foi utilizada a classe State, descrita no arquivo State.java:

public class State {

    private String state;

    private String abbreviation;

    private String capital;

    private float area;

    private int banner;

    public String getState() {

        return state;

    public void setState(String state) {

        this.state = state;

    public String getAbbreviation() {

        return abbreviation;

    public void setAbbreviation(String shortening) {

        this.abbreviation = shortening;

    public String getCapital() {

        return capital;

    public void setCapital(String capital) {

        this.capital = capital;

    public float getArea() {

        return area;

    public void setArea(float area) {

        this.area = area;

    public int getBanner() {

        return banner;

    public void setBanner(int banner) {

        this.banner = banner;

O cursor para as informações do ListView é montado utilizando o método setListAdapter(ListAdapter adapter) da classe ListActivity. No parâmetro adapter foi utilizada a classe StateAdapter que recebe como parâmetros o contexto da Activity e o ArrayList com as informações dos estados. O arquivo StateAdapter.java descreve os métodos que são necessários para montar o cursor do ListView.

/**

 * Adapter utilizado para exibir as informações dos Estados

 * no ListView.

 * @author Administrador

*/

public class StateAdapter extends BaseAdapter {

    private Context context;

    private List<State> stateList;

    public StateAdapter(Context context, List<State> statelist){

        this.context = context;

        this.stateList = statelist;

    @Override

    public int getCount() {

        return stateList.size();

    @Override

    public Object getItem(int position) {

        return stateList.get(position);

    @Override

    public long getItemId(int position) {

        return position;

    @Override

    public View getView(int position, View convertView, ViewGroup parent) {

        // Recupera o estado da posição atual

        State state = stateList.get(position);

        // Cria uma instância do layout XML para os objetos correspondentes

        // na View

        LayoutInflater inflater = (LayoutInflater)

            context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

        View view = inflater.inflate(R.layout.listview_states, null);

        // Estado - Abreviação

        TextView textState = (TextView)view.findViewById(R.id.textState);

        textState.setText(state.getState() + " - " + state.getAbbreviation());

        // Capital

        TextView textCapital = (TextView)view.findViewById(R.id.textCapital);

        textCapital.setText(state.getCapital());

        // Área

        TextView textArea = (TextView)view.findViewById(R.id.textArea);

        textArea.setText(String.valueOf(state.getArea()));

        // Bandeira

        ImageView img = (ImageView)view.findViewById(R.id.imageState);

        img.setImageResource(state.getBanner());

        return view;

A classe StateAdapter extende a classe BaseAdapter que deve implementar os métodos:

getCount(): retorna o número de itens.
getItem(int position): retorna o item de uma posição específica.
getItemId(int position): retorna o Id de um item de uma posição específica.
getView(int position, View convertView, ViewGroup parent): retorna a View com as informações posicionadas de acordo com o layout montado no arquivo listview_states.xml

O arquivo listview_states.xml monta o layout que é utilizado em cada linha do ListView, para posicionar as informações em um formato customizado.

<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout

  xmlns:android="http://schemas.android.com/apk/res/android"

  android:layout_width="fill_parent"

  android:layout_height="wrap_content"

  android:padding="5dp"

  android:background="#cccccc"

  <ImageView

      android:id="@+id/imageState"

      android:layout_width="60dp"

      android:layout_height="42dp"

      android:background="#ffffff"

      android:scaleType="centerCrop"

/>

  <TextView

      android:id="@+id/textState"

      android:layout_width="fill_parent"

      android:layout_height="wrap_content"

      android:layout_toRightOf="@+id/imageState"

      android:layout_alignTop="@+id/imageState"

      android:text="São Paulo - SP"

      android:textSize="20sp"

      android:textColor="#333333"

      android:paddingLeft="5dp"

/>

  <TextView

      android:id="@+id/textCapital"

      android:layout_width="wrap_content"

      android:layout_height="wrap_content"

      android:layout_below="@+id/textState"

      android:layout_toRightOf="@+id/imageState"

      android:text="São Paulo"

      android:textColor="#333333"

      android:paddingLeft="5dp"

/>

  <TextView

      android:id="@+id/textArea"

      android:layout_width="wrap_content"

      android:layout_height="wrap_content"

      android:layout_below="@+id/textState"

      android:layout_alignParentRight="true"

      android:text="100000"

      android:textColor="#333333"

/>

</RelativeLayout>

No método getView utilizando a classe LayoutInflater e a classe View podemos associar cada widget do layout à informação que deve ser exibida no ListView.

No exemplo deste post, quando um item do ListView recebe o foco a tradicional cor “Laranja” de fundo não aparece. Isto acontece porque o ListView possui uma cor de fundo opaca, neste caso “cinza”. Na verdade o foco “Laranja” é exibido, mas somente atrás do background do ListView.

Uma possível solução para exibir o fundo “Laranja” neste caso, é fazer uma pequena alteração da definição do layout da tela.

Primeiro precisamos criar um arquivo tipo StateList para definir as cores que serão apresentadas quando o item do ListView for pressionado, selecionado ou receber foco. Para isso foi criado o arquivo list_selector.xml, que deve ser colocado no diretório res/drawable

<?xml version="1.0" encoding="utf-8"?>

<selector

    xmlns:android="http://schemas.android.com/apk/res/android">

     <item

        android:state_pressed="true"

        android:drawable="@android:color/transparent" />

     <item

        android:state_selected="true"

        android:drawable="@android:color/transparent" />

     <item

        android:state_focused="true"

        android:drawable="@android:color/transparent" />

     <item

        android:drawable="@color/cinza" />

 </selector>

Os itens relativos aos estados pressionado, selecionado ou com focus devem ser configurados com o atributo android:drawable com cor transparente, somente o último item que representa o item sem mudança de estado deve ser configurado com a cor cinza. A cor cinza foi declarada no arquivo color.xml que deve ser colocado no diretório res/values.

<?xml version="1.0" encoding="utf-8"?>

<resources>

    <color name="cinza">#cccccc</color>

</resources>

Para que o fundo “laranja” funcione altere no arquivo listview_states.xml o atributo android:drawable da tag RelativeLayout de android:background="#cccccc" para android:background="@drawable/list_selector".

Agora quando um item for clicado teremos a seguinte tela:

Usando uma Figura de Fundo em uma Tela com ListView no Android

2011-03-23T15:50:00.001-03:00

Por padrão o Android apresenta a tela com cor de fundo escuro, e a maioria dos widgets possuem cor de fundo transparente. O widget ListView obedece a mesma regra, normalmente sendo utilizado em uma tela com cor de fundo sólida ou transparente. Caso seja utilizado em uma tela com cor de fundo diferente de uma cor sólida, como por exemplo usando uma figura, é necessário tomar um certo cuidado no projeto, para que o ListView no momento do scroll não apresente um fundo escuro no meio da figura.

Este post descreve como exibir uma figura de fundo em uma tela com ListView e como corrigir o problema ocasionado durante o scroll do ListView. Observe na figura abaixo uma tela com ListView e uma figura de fundo mostrando o efeito do scroll. A figura da esquerda mostra a tela exibida na iniciação da aplicação e a figura da direita mostra a tela no momento é quem é feito o scroll.

Na figura onde é feito o scroll podemos observar que a figura deixa de ser exibida corretamente. Isto ocorre devido a uma otimização de exibição de tela no sistema do Android. Para solucionar este problema, no framework do Android foi criado o método setCacheColorHint(int) que pode ser configurado via código, ou podemos utilizar o atributo android:cacheColorHint no arquivo XML do layout.

Para demonstrar a utilização do ListView com figura de fundo foi criado um projeto para exibir a relação de estados do Brasil em um ListView cuja figura de fundo é o mapa do Brasil.

Para exibir a figura de fundo foi criado um arquivo theme.xml na pasta res/values que configura a figura de fundo na janela do Android.

<?xml version="1.0" encoding="utf-8"?>

<resources>

    <!-- Imagem de fundo da tela do listview -->

    <style name="MapBackground" parent="android:Theme">

        <item name="android:windowBackground">@drawable/mapa</item>

        <item name="android:windowNoTitle">true</item>

    </style>

</resources>

Observe que foi criada a tag <style> com o nome MapBackground, e a janela do Android foi configurada com a figura do mapa através da tag:

<item name="android:windowBackground">@drawable/mapa</item>

Também foi configurado para que a janela não exiba título, através da tag:

<item name="android:windowNoTitle">true</item>

O tema deve ser aplicado na Activity que vai exibir o ListView. Esta configuração pode ser feita no arquivo AndroidManifest.xml.

<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

      package="br.com.romar"

      android:versionCode="1"

      android:versionName="1.0">

    <application android:icon="@drawable/icon" android:label="@string/app_name">

        <activity android:name=".Main"

                  android:label="@string/app_name"

                  android:theme="@style/MapBackground">

            <intent-filter>

                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

    </application>

    <uses-sdk android:minSdkVersion="8" />

</manifest>

No arquivo AndroidManifest.xml na tag <activity> da tela de iniciação (.Main) foi inserido o atributo android:theme="@style/MapBackground" que configura o tema da Activity para exibir a figura do mapa.

No arquivo Main.java no método OnCreate foi inserido o código para exibição dos estados no ListView e a configuração do ListView para corrigir o efeito do scroll.

public class Main extends ListActivity {

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        // Obtêm a relação de estados que está armazenado

        // no arquivo strings.xml

        String[] states = getResources().getStringArray(

                R.array.state_array);

        // Preenche o ListView com os estados

        setListAdapter(new ArrayAdapter<String>(this,

                android.R.layout.simple_list_item_1, states));

        // Obtêm o ListView

        ListView lv = getListView();

        // Configurando o método setCacheColorHint para

        // o valor 0 informamos que a cor de fundo do listview

        // possui não possui cor única, sólida ou opaca

        lv.setCacheColorHint(0);

No método onCreate(Bundle savedInstanceState) foi utilizado como fonte de dados um array chamado state_array, configurado no arquivo strings.xml localizado na pasta res/values.

<?xml version="1.0" encoding="utf-8"?>

<resources>

    <string name="app_name">ListViewI</string>

    <string-array name="state_array">

        <item>Acre</item>

        <item>Alagoas</item>

        <item>Amapá</item>

        <item>Amazonas</item>

        <item>Bahia</item>

        <item>Ceará</item>

        <item>Distrito Federal</item>

        <item>Espírito Santo</item>

        <item>Goiás</item>

        <item>Maranhão</item>

        <item>Mato Grosso</item>

        <item>Mato Grosso do Sul</item>

        <item>Minas Gerais</item>

        <item>Pará</item>

        <item>Paraíba</item>

        <item>Paraná</item>

        <item>Pernambuco</item>

        <item>Piauí</item>

        <item>Rio de Janeiro</item>

        <item>Rio Grande do Norte</item>

        <item>Rio Grande do Sul</item>

        <item>Rondônia</item>

        <item>Roraima</item>

        <item>Santa Catarina</item>

        <item>São Paulo</item>

        <item>Sergipe</item>

        <item>Tocatins</item>

    </string-array>

</resources>

Para exibir o ListView foi utilizado o layout padrão do sistema Android, simple_list_item_1, configurado no método setListAdapter().

Após criado o ListView, foi utilizado o método getListView() para obter o ListView da Activity e poder desabilitar a otimização da tela através do método setCacheColorHint(). O valor utilizado foi 0 que representa cor de fundo transparente.

Com a inserção do método setCacheColorHint() o scroll pode ser feito normalmente sem apresentar o defeito na figura de fundo.

Retornando Dados em Json com WebService .NET

2011-03-17T21:57:00.001-03:00

O webservice .NET retorna as informações utilizando o protocolo SOAP e os dados em formato XML. Este artigo mostra como retornar os dados no formato JSON, utilizando um webservice na versão 3.5 do .NET Framework.

Para mostrar como retornar dados no formato JSON, foi criado um webservice que retorna a relação de Estados do Brasil, juntamente com as informações de capital, área em km² e abreviação de cada estado.

Para que o webservice retorne os dados em JSON é necessário inserir o atributo [System.Web.Script.Services.ScriptService] na classe do webservice (linha 4) e o atributo [ScriptMethod(ResponseFormat=ResponseFormat.Json)] (linha 45) no método que vai retornar os dados, como demonstrado no código abaixo:

   1:  [WebService(Namespace = "http://tempuri.org/")]

   2:  [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

   3:  // To allow this Web Service to be called from script, using ASP.NET AJAX, uncomment the following line.

   4:  [System.Web.Script.Services.ScriptService]

   5:  public class Service : System.Web.Services.WebService

   6:  {

   7:      private string[,] estados = new string[27, 4]

   8:      {

   9:          {"Acre", "AC", "Rio Branco", "152581,4"},

  10:          {"Alagoas", "AL", "Maceió", "27767,7"},

  11:          {"Amapá", "AP", "Macapá", "142814,6"},

  12:          {"Amazonas", "AM", "Manaus", "1570745,7"},

  13:          {"Bahia", "BA", "Salvador", "564692,7"},

  14:          {"Ceará", "CE", "Fortaleza", "148825,6"},

  15:          {"Distrito Federal", "DF", "Brasília", "5822,1"},

  16:          {"Espírito Santo", "ES", "Vitória", "46077,5"},

  17:          {"Goiás", "GO", "Goiânia", "340086,7"},

  18:          {"Maranhão", "MA", "São Luís", "331983,3"},

  19:          {"Mato Grosso", "MT", "Cuiabá", "903357,9"},

  20:          {"Mato Grosso do Sul", "MS", "Campo Grande", "357125,0"},

  21:          {"Minas Gerais", "MG", "Belo Horizonte", "586528,3"},

  22:          {"Pará", "PA", "Belém", "1247689,5"},

  23:          {"Paraíba", "PB", "João Pessoa", "56439,8"},

  24:          {"Paraná", "PR", "Curitiba", "199314,9"},

  25:          {"Pernambuco", "PE", "Recife", "98311,6"},

  26:          {"Piauí", "PI", "Teresina", "251529,2"},

  27:          {"Rio de Janeiro", "RJ", "Rio de Janeiro", "43696,1"},

  28:          {"Rio Grande do Norte", "RN", "Natal", "52796,8"},

  29:          {"Rio Grande do Sul", "RS", "Porto Alegre", "281748,5"},

  30:          {"Rondônia", "RO", "Porto Velho", "237576,2"},

  31:          {"Roraima", "RR", "Boa Vista", "224299,0"},

  32:          {"Santa Catarina", "SC", "Florianópolis", "95346,2"},

  33:          {"São Paulo", "SP", "São Paulo", "248209,4"},

  34:          {"Sergipe", "SE", "Aracaju", "21910,3"},

  35:          {"Tocantins", "TO", "Palmas", "277620,9"}

  36:      };

37:

  38:      public Service () {

39:

  40:          //Uncomment the following line if using designed components

  41:          //InitializeComponent();

  42:      }

43:

  44:      [WebMethod]

  45:      [ScriptMethod(ResponseFormat=ResponseFormat.Json)]

  46:      public string GetEstados() {

  47:          JavaScriptSerializer js = new JavaScriptSerializer();

48:

  49:          List<object> obj = new List<object>();

50:

  51:          for (int i = 0; i < estados.GetUpperBound(0); i++)

  52:          {

  53:              Estados estado = new Estados();

  54:              estado.Nome = estados[i, 0];

  55:              estado.Abreviacao = estados[i, 1];

  56:              estado.Capital = estados[i, 2];

  57:              estado.Area = estados[i, 3];

58:

  59:              obj.Add(estado);

  60:          }

61:

  62:          return js.Serialize(obj);

  63:      }

64:

  65:      private class Estados

  66:      {

  67:          public string Nome { get; set; }

  68:          public string Abreviacao { get; set; }

  69:          public string Capital { get; set; }

  70:          public string Area { get; set; }

  71:      }

  72:  }

No método GetEstados() foi utilizada a classe JavaScriptSerializer (linha 47) para criar um objeto que serializa no formato JSON, a lista de objetos Estados.

Na execução do webservice obtemos o seguinte retorno:

Na figura podemos observar que os dados foram retornados em JSON, mas precisamos ter um cuidado no momento de utilizar o retorno deste webservice, porque mesmo o retorno dos dados estando no formato JSON o webservice na verdade retorna um XML com uma tag <string>, onde no valor da string são retornados os dados no formato JSON.

Para que aplicações possam utilizar os dados é necessário fazer a leitura somente da tag <string>. A aplicação que utilizar os dados deste webservice precisa ler o conteúdo da tag <string> para obter a informação em JSON.

Segue uma figura com os dados já formatados como Json.

Escrita e Leitura de Arquivo no Android–Parte II

2011-03-10T22:02:00.001-03:00

No primeiro post sobre escrita e leitura de arquivos no Android descrevi como ler e escrever na memória interna do Android. Este post descreve como escrever e ler em arquivos armazenados no cartão SD do dispositivo.

Antes de optar em gravar informações no cartão SD do dispositivo, lembre-se que o usuário terá acesso as informações deste arquivo e poderá apagá-lo a qualquer momento. Também não existe a garantia do arquivo não ser apagado durante a conexão ou desconexão do dispositivo com o microcomputador, caso o mesmo seja desconectado de forma incorreta.

Para demonstrar a leitura e escrita no cartão SD, vou utilizar o mesmo layout do projeto da parte I do post:

Antes de criar e escrever em um arquivo no cartão SD de um dispositivo, é necessário verificar se o cartão está inserido, quais são as permissões de escrita e leitura, se o sistema de arquivo é reconhecido pelo dispositivo, entre outras informações.

Foi criada a classe ManageFile com o método getStateSDcard() que verifica o estado do cartão SD, o método WriteFile() que faz a escrita do texto e o método ReadFile() que faz a leitura do texto armazenado no cartão SD.



public class ManageFile {
    private static final String TAG = "ManageFile";
    private Context context;
    private boolean sdCardAvailable;
    private boolean sdCardWritableReadable;
    private boolean sdCardReadableOnly;
    
    public ManageFile(Context context){
        this.context = context;
    }

    /**
     * Escreve no arquivo texto.
     * @param text Texto a ser escrito.
     * @return True se o texto foi escrito com sucesso.
     */
    public boolean WriteFile(String text){
        try {
            File file = new File(context.getExternalFilesDir(null),
                "romar.txt");
            FileOutputStream out = new FileOutputStream(file, true);
            out.write(text.getBytes());
            out.write("\n".getBytes());
            out.flush();
            out.close();    
            return true;
            
        } catch (Exception e) {
            Log.e(TAG, e.toString());
            return false;
        }
    }
    
    /**
     * Faz a leitura do arquivo
     * @return O texto lido.
     * @throws FileNotFoundException
     * @throws IOException
     */
    public String ReadFile() throws FileNotFoundException, IOException{
        File textfile = new File(context.getExternalFilesDir(null),
            "romar.txt");

        FileInputStream input = new FileInputStream(textfile);
        byte[] buffer = new byte[(int)textfile.length()];
        
        input.read(buffer);            
        
        return new String(buffer);
    }
    
    public void getStateSDcard(){
        
        // Obtêm o status do cartão SD
        String status = Environment.getExternalStorageState();
        
        if (Environment.MEDIA_BAD_REMOVAL.equals(status)) {
            // Midia foi removida antes de ser montada
            sdCardAvailable = false;
            sdCardWritableReadable = false;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia removida.");
        }
        else if (Environment.MEDIA_CHECKING.equals(status)) {
            // Midia está presente e está sendo feita a verificação
            sdCardAvailable = true;
            sdCardWritableReadable = false;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia sendo verificada.");
        }
        else if (Environment.MEDIA_MOUNTED.equals(status)) {
            // A midia está presente e montada neste momento com
            // permissão de escrita e leitura
            sdCardAvailable = true;
            sdCardWritableReadable = true;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia com permissão de escrita e leitura.");
        }
        else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(status)) {
            // A midia está presente e montada neste momento com 
            // permissão somente de leitura
            sdCardAvailable = true;
            sdCardWritableReadable = false;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia com permissão somente leitura.");
        }
        else if (Environment.MEDIA_NOFS.equals(status)) {
            // A midia está presente, mas está vazia ou utilizando um
            // sistema de arquivos não suportado    
            sdCardAvailable = false;
            sdCardWritableReadable = false;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia com sistema de arquivos não compatível.");
        }
        else if (Environment.MEDIA_REMOVED.equals(status)) {
            // A midia não está presente
            sdCardAvailable = false;
            sdCardWritableReadable = false;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia não presente.");
        }
        else if (Environment.MEDIA_SHARED.equals(status)) {
            // A midia está presente, não montada e compartilhada 
            // via USB
            sdCardAvailable = false;
            sdCardWritableReadable = false;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia compartilhada via USB.");
        }
        else if (Environment.MEDIA_UNMOUNTABLE.equals(status)) {
            // A midia está presente mas não pode ser montada
            sdCardAvailable = false;
            sdCardWritableReadable = false;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia não pode ser montada");
        }
        else if (Environment.MEDIA_UNMOUNTED.equals(status)) {
            // A midia está presente mas não montada
            sdCardAvailable = false;
            sdCardWritableReadable = false;
            sdCardReadableOnly = false;
            Log.d(TAG, "Midia não montada.");
        }
    }

    public boolean isSdCardAvailable() {
        return sdCardAvailable;
    }

    public void setSdCardAvailable(boolean sdCardAvailable) {
        this.sdCardAvailable = sdCardAvailable;
    }

    public boolean isSdCardWritableReadable() {
        return sdCardWritableReadable;
    }

    public void setSdCardWritableReadable(boolean sdCardWritableReadable) {
        this.sdCardWritableReadable = sdCardWritableReadable;
    }

    public boolean isSdCardReadableOnly() {
        return sdCardReadableOnly;
    }

    public void setSdCardReadableOnly(boolean sdCardReadableOnly) {
        this.sdCardReadableOnly = sdCardReadableOnly;
    }

}

No método getStateSDcard() foi utilizado o método getExternalStorageState() da classe Environment do Android que retorna o estado do cartão SD. Para cada estado retornado é setado um flag para indicar se o cartão está disponível, se permite escrita e leitura, ou se permite somente somente leitura.

No método WriteFile() foi utilizado o método getExternalFilesDir() do Android para obter o diretório do cartão SD. Foi passado o valor null como parâmetro, para que seja retornada a raiz do diretório da aplicação na área de armazenamento externa, no nosso caso o cartão SD (válido para a API 8, vide nota abaixo).

O arquivo vai ser escrito no diretório:

/Android/data/<nome_pacote>/files/

onde nome_pacote é o pacote da aplicação, no nosso caso br.com.romar.

NOTA: O método getExternalFilesDir() deve ser utilizado em projetos que rodam a partir da API 8. Para projetos que rodam na API 7 ou inferior, deverá ser utilizado o método getExternalStorageDirectory(), que irá retornar a raiz do diretório do cartão SD. Neste caso o arquivo será gravado na raiz do cartão e não no diretório da aplicação. No caso da API 8, quando a aplicação for desinstalada os arquivos que estiverem no cartão SD no diretório /Android/data/<nome_pacote>/files serão apagados.

No método ReadFile() foi utilizado o mesmo método getExternalFilesDir() do Android para abrir o arquivo gravado anteriormente para leitura.

Na Activity principal do projeto foi criado um botão para escrita e leitura do arquivo. Segue o código que trata o click em cada um dos botões:



@Override
public void onClick(View v) {
    
try {
    switch (v.getId()) {
    case R.id.btnRead: // Faz a leitura do arquivo    
        
        // Verifica se o sdcard tem permissão para leitura
        if (managefile.isSdCardAvailable() && 
                (managefile.isSdCardReadableOnly() || 
                        managefile.isSdCardWritableReadable())) {
            managefile.getStateSDcard();
            textRead.setText(managefile.ReadFile());                    
        }
        else {
            Toast.makeText(this, 
                "O cartão SD não está disponível, ou não permite" +
                " leitura", Toast.LENGTH_SHORT).show();
        }            
        break;

    case R.id.btnWrite: // Faz a escrita do arquivo
        
        // Verifica se o sdcard tem permissão para escrita
        if (managefile.isSdCardAvailable() &&
                managefile.isSdCardWritableReadable()) {
            // Avisa o usuário se a gravação foi bem sucedida
            if(managefile.WriteFile(editText.getText().toString()) == 
                true){
                Toast.makeText(this, 
                    "Texto gravado com sucesso.",
                    Toast.LENGTH_SHORT).show();
            }
            else{
                Toast.makeText(this, 
                    "Não foi possível escrever o texto.", 
                    Toast.LENGTH_SHORT).show();
            }
        }
        else {
            Toast.makeText(this, 
                    "O cartão SD não está disponível, 
                    ou não permite" +
                    " escrita.", Toast.LENGTH_SHORT).show();                    
        }        
        
        // Reseta o campo do texto
        editText.setText("");
        
        break;
        
    default:
        break;
    }

} catch (FileNotFoundException e) {
    Log.e(TAG, e.toString());
} catch (IOException e) {
    Log.e(TAG, e.toString());
}

}

Antes de fazer a escrita ou leitura no arquivo, o código verifica primeiro se o cartão SD está disponível e permite escrita ou leitura dependendo do caso.

O cartão SD do dispositivo por padrão possui somente permissão de leitura. Para que seja possível escrever no cartão é necessário que no momento da instalação da aplicação o usuário dê a permissão de escrita na área de armazenamento externo. Para que a aplicação tenha a permissão de escrita é necessário inserir no arquivo AndroidManifest.xml da aplicação a seguinte tag:

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

Escrita e Leitura de Arquivo no Android – Parte I

2011-02-24T22:42:00.001-03:00

Os dispositivos com o Android permitem a escrita e leitura de arquivos na memória interna. Este post descreve como criar um arquivo texto, escrever e visualizar o conteúdo do arquivo no próprio dispositivo e como exportar o arquivo do emulador do Eclipse para o computador.

Como cada aplicação do Android roda em seu próprio contexto, o arquivo só pode ser manipulado pela própria aplicação que criou o arquivo. O arquivo não é visualizado por outras aplicações e não pode ser manipulado pelo usuário.

O projeto utilizado para demonstrar a escrita e leitura do arquivo possui uma Activity com o seguinte layout:

Foi criada uma classe chamada ManageFile com os métodos WriteFile e ReadFile, que fazem a escrita e leitura do arquivo.

/**
 * Classe responsável pela escrita e leitura de arquivo.
 * @author Romar Consultoria
 *
 */
public class ManageFile {
    private static final String TAG = "ManageFile";
    private Context context;
    
    public ManageFile(Context context){
        this.context = context;
    }

    /**
     * Escreve no arquivo texto.
     * @param text Texto a ser escrito.
     * @return True se o texto foi escrito com sucesso.
     */
    public boolean WriteFile(String text){
        try {
            // Abre o arquivo para escrita ou cria se não existir
            FileOutputStream out = context.openFileOutput("romar.txt",
                    Context.MODE_APPEND);
            out.write(text.getBytes());
            out.write("\n".getBytes());
            out.flush();
            out.close();    
            return true;
            
        } catch (Exception e) {
            Log.e(TAG, e.toString());
            return false;
        }
    }
    
    /**
     * Faz a leitura do arquivo
     * @return O texto lido.
     * @throws FileNotFoundException
     * @throws IOException
     */
    public String ReadFile() throws FileNotFoundException, IOException{
        File file = context.getFilesDir();
        File textfile = new File(file + "/romar.txt");

        FileInputStream input = context.openFileInput("romar.txt");
        byte[] buffer = new byte[(int)textfile.length()];
        
        input.read(buffer);            
        
        return new String(buffer);
    }
}

Observe que no construtor da classe foi passado o argumento context da aplicação para que seja possível manipular o arquivo no contexto da aplicação.

O método writeFile tem como argumento o texto a ser escrito e utiliza o método openFileOutput para criar se o arquivo não existir ou abrir o arquivo anteriormente criado.

O método readFile busca pelo arquivo (romar.txt) criado anteriormente, faz a leitura do arquivo e retorna uma String com o conteúdo.

Na Activity do projeto foram criados dois botões Ler e Escrever que fazem a chamada dos métodos de escrita e leitura do arquivo:

@Override
public void onClick(View v) {
    
    try {
        switch (v.getId()) {
        case R.id.btnRead:
            // Faz a leitura do arquivo
            ManageFile fileread = new ManageFile(this);
                textRead.setText(fileread.ReadFile());
            break;

        case R.id.btnWrite:
            ManageFile filewrite = new ManageFile(this);
            
            // Avisa o usuário se a gravação foi bem sucedida
            if(filewrite.WriteFile(editText.getText().toString())
                 == true){
                Toast.makeText(this,
                    "Texto gravado com sucesso.",
                    Toast.LENGTH_SHORT).show();
            }
            else{
                Toast.makeText(this, 
                    "Não foi possível escrever o texto.", 
                    Toast.LENGTH_SHORT).show();
            }
            
            // Reseta o campo do texto
            editText.setText("");
            
            break;
            
        default:
            break;
        }
    
    } catch (FileNotFoundException e) {
        Log.e(TAG, e.toString());
    } catch (IOException e) {
        Log.e(TAG, e.toString());
    }

}

A aplicação funcionando apresenta a seguinte tela:

É possível exportar o arquivo (romar.txt) para o computador, através do emulador do Eclipse utilizando a perspectiva DDMS, na aba File Explorer que exibe o conteúdo nos diretórios do dispositivo.

No diretório data/data/nome_do_pacote/files fica localizado os arquivos, criados dentro do contexto da aplicação. Para exportar o arquivo selecionar o botão indicado pela seta e gravar o arquivo no computador. Mas lembre-se o acesso a este arquivo só é possível via emulador, no dispositivo real não é possível acessar este arquivo.

Insert, Update e Delete com LINQ

2010-09-08T22:11:00.001-03:00

Em um dos projetos que estive trabalhando, precisei interagir com uma Base de Dados que possuia tabelas sem chave primária, e por motivos de compatibilidade com projetos anteriores não podia alterar as tabelas para adequar as boas práticas de desenvolvimento e inserir as chaves primárias.

No meu projeto eu precisava inserir, deletar e fazer atualizações nos registros das tabelas. Resolvi utilizar o LINQ para fazer estas operações.

O LINQ não permite a inserção, exclusão e atualização em tabelas que não possuam chave primária, por isso tive que utilizar um recurso para poder trabalhar com estas tabelas.

Criei uma base de dados com uma tabela exemplo sem chave primária, para poder demonstrar uma forma de resolver este tipo de problema. A base de dados chama-se Escola e a tabela Aluno.

Criei a classe DBML no Visual Studio que tem o seguinte formato:

Para inserir o registro de um aluno na tabela podemos utilizar o seguinte código:

        /// <summary>

        /// Executa uma instrucao Insert inserindo um aluno na

        /// base de dados.

        /// </summary>

        static void Insert()

try

                EscolaClassesDataContext context =

                    new EscolaClassesDataContext();

                Aluno aluno = new Aluno();

                aluno.Matricula = "67489";

                aluno.Nome = "Douglas Xavier";

                aluno.Idade = 35;

                aluno.Curso = "SQL Server";

                aluno.Endereco = "Rua Germano Souza, 675";

                context.Alunos.InsertOnSubmit(aluno);

                context.SubmitChanges();

                Console.WriteLine("Aluno inserido com sucesso!");

            catch (Exception ex)

                Console.WriteLine(ex.Message);

Executando o método Insert() o aluno não é inserido na tabela e obtemos a seguinte mensagem de erro:

Can’t perform Create, Update or Delete Operations on Table(Aluno) because it has no primary key.

A mensagem indica que o LINQ não permite a inserção, exclusão ou atualização de registros em tabelas que não possuam chave primária.

Se testarmos o método Delete(), cujo código é exibido abaixo, obtemos a mesma mensagem de erro do método Insert():

        /// <summary>

        /// Executa uma instrucao Delete, apagando os dados de um aluno.

        /// </summary>

        static void Delete()

try

                EscolaClassesDataContext context = new

                    EscolaClassesDataContext();

                Aluno aluno = (from a in context.Alunos

                               where a.Idade == 22

                               select a).First();

                context.Alunos.DeleteOnSubmit(aluno);

                context.SubmitChanges();

                Console.WriteLine("O aluno foi apagado com sucesso!");

            catch (Exception ex)

                Console.WriteLine(ex.Message);

Se testarmos o método Update(), cujo código é exibido abaixo, a atualização não será feita pois o método de Update do LINQ não gera exceção, por isso é muito dificil detectar qual problema está acontecendo, já que a atualização não é feita e nenhuma exceção é indicada.

        /// <summary>

        /// Executa uma instrucao Update atualizando um endereco de

        /// um determinado aluno

        /// </summary>

        static void Update()

try

                EscolaClassesDataContext context = new

                    EscolaClassesDataContext();

                Aluno aluno = (from a in context.Alunos

                               where a.Nome == "Renato Borges"

                               select a).First();

                aluno.Endereco = "Av Otaviano Silva, 47";

                context.SubmitChanges();

                Console.WriteLine("A atualização foi realizada com" +

                    " sucesso!");

            catch (Exception ex)

                Console.WriteLine(ex.Message);

Como resolver este problema se não podemos mexer na estrutura da tabela do banco de dados? A solução é criar uma chave primária na classe DBML. Esta chave pode ser definida em qualquer coluna. Esta definição não afeta a estrutura da tabela na base de dados, é somente um recurso para podermos trabalhar com LINQ em tabelas sem chave primária.

Para inserir uma chave primária em uma coluna da tabela Aluno, devemos alterar a propriedade PrimaryKey de False para True da coluna que servirá como chave primária.

Selecionei a coluna Matricula para servir de chave primária. Veja a figura abaixo de como ficou a definição da classe DBML.

Após a configuração da chave primária os métodos Insert(), Update() e Delete() podem ser executados.

Inseri o código para fazer um Select na tabela e visualizar todos os métodos sendo executados sem erros.

/// <summary>

/// Executa uma instrucao Select na base de dados.

/// </summary>

static void Select()

    // Cria a conexão com a base de dados Escola

    EscolaClassesDataContext context = new EscolaClassesDataContext();

    // Faz um SELECT na base de dados para imprimr a relação de alunos

    var queryAlunos = from a in context.Alunos

                      select a;

    if (queryAlunos.Count() > 0)

        foreach (var item in queryAlunos)

            Console.WriteLine("=========================================");

            Console.WriteLine("Matrícula: " + item.Matricula);

            Console.WriteLine("Nome: " + item.Nome);

            Console.WriteLine("Idade: " + item.Idade);

            Console.WriteLine("Curso: " + item.Curso);

            Console.WriteLine("Endereço: " + item.Endereco);

            Console.WriteLine("=======================================\r\n");

O código que utilizei no projeto para chamar todos os métodos foi:

        static void Main(string[] args)

            Console.WriteLine("Executa o método Insert");

            Insert();

            Console.WriteLine("Executa o método Update");

            Update();

            Console.WriteLine("Executa o método Delete");

            Delete();

            Console.WriteLine("Executa o método Select");

            Select();

            Console.ReadKey();

Segue a tela com o resultado dos métodos executados com sucesso:

Os conceitos utilizados nos métodos Insert(), Update() e Delete() mostrados neste post podem ser utilizados normalmente, apenas acrescentei uma possível solução para o problema de precisar trabalhar com tabelas sem chaves primárias.

Debug de Aplicação ASP.NET 2.0 no IIS7

2010-08-03T22:22:00.001-03:00

Durante o debug de uma aplicação web ocorreu o seguinte erro quando o projeto estava configurado para rodar utilizando o localhost ao invés do servidor web do próprio VS2005 em uma máquina utilizando o IIS7:

"Unable to start debugging on the server. Debugging failed because integrated Windows Authentication is not enabled."

Para habilitar o Windows Authentication no IIS7 proceder da seguinte forma:

Com o IIS7 aberto selecione o website publicado e dê um duplo clique no ícone Autenticações indicado na figura abaixo.
No item Autenticação do Windows selecione a Ação Habilitar.

Isto resolveu o problema da minha aplicação não conseguir rodar em modo Debug.

Depois de efetuada esta configuração quando rodei a aplicação obtive uma página de erro HTTP 403.14 não exibindo a minha aplicação que no caso era um webservice.

Para resolver este problema descobri que faltava a tag <system.webServer> que em aplicações .NET 3.5 já é incluída automaticamente pelo VS2008 e é obrigatória para rodar aplicações ASP.NET AJAX em IIS7, mas descobri que é necessária inclusive para aplicações não AJAX, no meu caso estava trabalhando com um WebService em .NET 2.0.

Portanto para resolver o meu problema inseri a seguinte configuração no meu web.config e a partir daí consegui rodar a aplicação no VS2005 utilizando o IIS7.

  <system.webServer>
    <validation validateIntegratedModeConfiguration="false"/>
    <modules>
      <remove name="ScriptModule"/>
      <add name="ScriptModule" preCondition="managedHandler" type="System.Web.Handlers.ScriptModule, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
    </modules>
    <handlers>
      <remove name="WebServiceHandlerFactory-Integrated"/>
      <remove name="ScriptHandlerFactory"/>
      <remove name="ScriptHandlerFactoryAppServices"/>
      <remove name="ScriptResource"/>
      <add name="ScriptHandlerFactory" verb="*" path="*.asmx" preCondition="integratedMode" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
      <add name="ScriptHandlerFactoryAppServices" verb="*" path="*_AppService.axd" preCondition="integratedMode" type="System.Web.Script.Services.ScriptHandlerFactory, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
      <add name="ScriptResource" preCondition="integratedMode" verb="GET,HEAD" path="ScriptResource.axd" type="System.Web.Handlers.ScriptResourceHandler, System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"/>
    </handlers>
  </system.webServer>

Introdução ao Windows Mobile

2010-03-05T21:54:00.001-03:00

O Windows Mobile é um sistema operacional reduzido e muito eficiente para rodar em dispositivos móveis de pequeno porte. O Windows Mobile é construído sobre o Windows CE. Os fabricantes incluem os seus próprios softwares e add ons como o Internet Explorer, Word, Excel, Power Point, etc.

O Windows Mobile nasceu com a versão 2003 do Visual Studio, onde tinhamos, o .NET Compact Framework 1.1. Atualmente existem algumas versões de Windows Mobile, temos o Windows Mobile 5.0 e o 6.0 que utilizam o .NET Compact Framework 2.0.

Até o Visual Studio 2005, para se desenvolver uma aplicação Windows Mobile era necessário utilizar pelo menos a versão Professional que permitia o desenvolvimento de aplicações Windows Mobile 2003, e para desenvolver aplicações Mobile 5.0 era necessário fazer o download do SDK de desenvolvimento para a plataforma Windows Mobile 5.0. Este SDK permitia o desenvolvimento de aplicações PockePC, Smartphone e Windows CE.

A partir do Visual Studio 2008 já está integrado o ambiente para desenvolvimento de aplicações PocketPC 2003, Windows CE, Windows Mobile 5.0 PocketPC SDK e Windows Mobile 5.0 Smartphone SDK. Para a versão Windows Mobile 6.0 é necessário fazer o download separadamente do SDK.

O Visual Studio 2008 permite o desenvolvimento para plataformas .NET Compact Framework 2.0 ou 3.5.

O desenvolvimento para Windows Mobile se tornou um pouco mais complicado para os desenvolvedores devido à mudança nos termos de licença de uso. Antigamente os termos de licença eram bem restritos, por exemplo o tamanho da tela tinha um padrão de 240 x 320 pixels, atualmente o exigido é manter um mínimo de compatibilidade entre os fabricantes e os softwares devem rodar em qualquer dispositivo.

Para iniciar um projeto Windows Mobile utilizando o Visual Studio 2008 selecione o menu FILE-NEW PROJECT e na tela New Project selecione Smart Device Project.

Após a seleção do Smart Device Project será apresentada a tela Add New Smart Device Project Target Plataform, onde é possível selecionar a plataforma desejada e a versão do .NET Compact Framework que será utilizada.

Entre as plataformas podemos selecionar entre o PocketPC2003, Windows CE, Windows Mobile5.0 Pocket PC SDK ou Windows Mobile 5.0 Smartphone SDK.

Utilizando esta tela também é possível fazer o download do SDK e de emuladores de outras plataformas, tais como o Windows Mobile 6.0. Para verificar as opções e fazer o download de outras plataformas selecione o link Download additional emulator images and smart device SDKs.., no final da tela.

Após selecionada a plataforma e a versão do .NET Compact Framework selecione o template Device Application.

O Visual Studio cria o projeto com a tela da plataforma selecionada. A figura abaixo mostra o formulário de um Pocket PC para o Windows Mobile 5.0.

A aplicação Windows Mobile é similar a aplicação Windows Desktop com alguns diferenciais em termos de programação, capacidade e layout.

Um diferencial importante é quanto à quantia de controles disponíveis para a plataforma Windows Mobile. Se compararmos com a plataforma Windows para Desktop que utiliza o .NET Framework iremos observar que vários controles não estão disponíveis e quando disponíveis normalmente não possuem todas as propriedades que o .NET Framework disponibiliza. Isto ocorre porque o .NET Compact Framework teve que ser reduzido para poder funcionar em dispositivos com menor capacidade de hardware comparado com os computadores e muitos controles realmente não fazem sentido em ser utilizado em dispositivos móveis como,ToolTip, EventLog, controles para Impressão e outros.

Um outro diferencial importante é com relação a forma que a aplicação é “encerrada” em dispositivos móveis. Observando a figura anterior podemos observar a existência de um botão com um “X”, no canto superior direito da tela do dispositivo. Este botão não encerra a aplicação e sim somente minimiza “esconde” a aplicação.

Em dispositivos móveis o padrão de funcionamento é minimizar a aplicação ao invés de encerrar. Isto ocorre porque em dispositivos móveis a iniciação de uma aplicação normalmente demora alguns segundos e o usuário de um dispositivo móvel espera clicar na aplicação e a mesma “aparecer” instantaneamente.

Caso seja absolutamente necessário fechar a aplicação ao invés de minimizar a propriedade MinimizeBox do formulário deve ser configurada como False e neste caso o formulário vai apresentar o botão OK, que fecha a aplicação.

O comportamento descrito acima ocorre em formulários que são exibidos utilizando o método Form.Show(). No caso de utilizar o método Form.ShowDialog() o comportamento do formulário será idêntico ao comportamento do formulário no desktop, ou seja, será apresentado o botão OK e quando acionado o formulário será fechado.

Tipos de LINQ

2009-11-27T22:43:00.001-02:00

O LINQ é um modelo de programação que introduz a consulta e manipulação de dados dentro do conceito da linguagem .NET. Entretanto o suporte completo ao LINQ requer algumas extensões na linguagem utilizada.

O código abaixo exibe um exemplo de utilização do LINQ para fazer uma consulta na tabela Customers da base de dados Northwind.

staticvoid Main(string[] args)             {
            // DataContext utiliza a connectionstring 
            NorthwindDataContext db = new NorthwindDataContext();
 
            // Seleciona a tabela para executar a consulta
            Table<Customer> Customers = db.GetTable<Customer>();
 
            //Consulta clientes da cidade London
            var query =
                from cust in Customers
                where cust.City == "London"
                select cust;
 
            Console.WriteLine("Empresa".PadRight(25) + "Nome".PadRight(25) + "Cidade");
            foreach (var customer in query)
                Console.WriteLine("{0}{1}{2}", customer.CompanyName.PadRight(25),
                    customer.ContactName.PadRight(25), customer.City);
            Console.ReadKey(); 
 
        }

O resultado do código é:

O código traz os dados de todos os Customers cuja cidade seja “London”. A consulta foi feita em uma Base de Dados SQL, mas a mesma consulta poderia ser utilizada se Customer fosse uma tabela em um DataSet ou uma classe que descreve uma tabela.

Um outro aspecto importante da integração da linguagem é a checagem de tipo. A sintaxe das expressões de consulta não tem o compromisso da checagem de tipo, pois os dados são sempre fortemente tipados, incluindo as consultas de coleções ou entidades que são lidas ou retornadas.

Atualmente existem os seguintes tipos de LINQ:

LINQ to Objects
LINQ to ADO.NET que inclui LINQ to SQL, LINQ to Dataset e LINQ to Entities
LINQ to XML

Cada uma destas implementações é definida através de um conjunto de extensões de métodos que implementam os operadores necessários para que o LINQ rode com uma fonte de dados particular. O acesso destas características é controlado por Namespaces.

LINQ to Objects

O LINQ to Object tem o objetivo de manipular coleções de objetos, que podem estar relacionados entre si de forma hierarquica ou gráfica. O LINQ to Object não está limitado a coleções de dados gerados pelo usuário. Como exemplo segue uma consulta de todos os arquivos que estão localizados no diretório temporário maiores de 500KB ordenados de forma decrescente:

staticvoid Main(string[] args)     
        {
            string tempPath = Path.GetTempPath();
            DirectoryInfo dirInfo = new DirectoryInfo(tempPath);
 
            var query =
                from f in dirInfo.GetFiles()
                where f.Length > 500000 // Arquivos maior que 500K
                orderby f.Length descending
                select f;
 
            foreach (var arq in query)
                Console.WriteLine("Name = {0}", arq.Name);
 
            Console.ReadKey();
        }
 

O resultado do código acima é similar a figura abaixo. O resultado vai depender do conteúdo existente no diretório temporário da máquina que está sendo utilizada.

LINQ to ADO.NET

O LINQ to ADO.NET inclui diferentes implementações que compartilham da necessidade de manipular dados relacionais.

LINQ to SQL: é um componente do projeto LINQ que tem a capacidade de executar consultas em uma Base de Dados relacional.
LINQ to Entities: É muito similar ao LINQ TO SQL, entretanto ao invés de usar uma Base de Dados física como uma camada de persistência, ele usa uma entidade conceitual o EDM (Entity Data Model). O resultado da abstração é uma camada independente da camada de dados física.
LINQ to DataSet: Permite fazer consulta em um DataSet.

O código abaixo exemplifica uma consulta feita em um dataset tipado utilizando o LINQ to Dataset:

static void Main(string[] args)

{

// Inicializa o TableAdapter da base de dados Northwind

dsNorthwindTableAdapters.OrdersTableAdapter taNorthwind =

new dsNorthwindTableAdapters.OrdersTableAdapter();

// Declaração do DataSet Tipado da base de dados Northwind

dsNorthwind ds = new dsNorthwind();

taNorthwind.Fill(ds.Orders);

// Consulta que traz o Id e a data do pedido para pedidos

// com data superior a 01/01/1998

var query = from o in ds.Orders

where o.OrderDate >= new DateTime(1998, 01, 01)

select new { o.OrderID, o.OrderDate };

Console.WriteLine("Id do Pedido\t" + "Data do Pedido");

foreach (var order in query)

{

Console.WriteLine("{0}\t\t{1}", order.OrderID,

order.OrderDate);

}

Console.ReadKey();

}

LINQ to XML

O LINQ to XML oferece uma sintaxe um pouco diferente para operar com dados em XML, permitindo consulta e manipulação de dados.

O código abaixo exemplifica uma busca no arquivo XML que possui informações sobre uma coleção de livros.

Arquivo Xml utilizado como fonte da busca:

<?xml version="1.0" encoding="utf-8" ?>
<livros>
  <livro linguagem="csharp">
    <titulo>Introducao ao CSharp</titulo>
    <autor>Antonio Dias</autor>
    <ano>2002</ano>
  </livro>
  <livro linguagem="vb">
    <titulo>Introducao ao Visual Basic</titulo>
    <autor>Marcelo Gomes</autor>
    <ano>2005</ano>
  </livro>
  <livro linguagem="csharp">
    <titulo>CSharp Avancado</titulo>
    <autor>Jose Maria</autor>
    <ano>2008</ano>
  </livro>
</livros>

Código utilizado para trazer os livros cuja linguagem seja vb:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // Carrega o arquivo Xml
            XElement root = XElement.Load("livros.xml");
            // Faz uma busca nos livros cujo atributo linguagem seja vb
            IEnumerable<XElement> linguagem =
                from el in root.Elements("livro")
                where (string)el.Attribute("linguagem") == "vb"
                select el;
            // Exibe o resultado da pesquisa
            foreach (XElement el in linguagem)
                Console.WriteLine(el);
 
            Console.ReadKey();            
        }
    }
}

Resultado obtido:

Como conclusão podemos observar que o LINQ é uma linguagem que permite uma uniformidade para acessar dados em diversas fontes de informações.

Gerar Script SQL para criar Tabelas com Dados

2009-09-07T18:22:00.001-03:00

Na época da base de dados Northwind era comum baixarmos o script da base de dados já com os dados aos invés de um arquivo para restaurar no nosso SQL Server.

Normalmente esta geração de script era feita utilizando-se outras ferramentas. A partir do SQL Server 2008 podemos gerar um script que quando executado cria as tabelas e preenche os dados.

Para gerar este script é bem simples. Vou demonstrar como gerar um script para criar as tabelas já com os dados da base AdventureWorksLT2008.

Com o botão direito do mouse selecione a base AdventureWorksLT2008 e clique no menu TASKS – GENERATE SCRIPTS.

Na tela SELECT DATABASE selecione a base de dados AdventureWorksLT2008 e habilite o campo Script all objects in the selected database. Clique no botão NEXT.

Na tela CHOOSE SCRIPT OPTIONS vá até a opção Table/View Options e altere o campo Script Data para True. Clique no botão NEXT.

Na tela OUTPUT OPTION selecione onde o script deve ser gerado. O script pode ser gerado em um arquivo, na Área de Transferência ou em uma nova janela de consulta no SQL Management Studio. Selecione a opção Script to New Query Window para visualizar o script. Clique no botão NEXT.

Na tela SCRIPT WIZARD SUMMARY certique-se que a opção Script Data esteja como True e clique no botão FINISH para que o script seja gerado.

Com o script gerado basta executar em uma nova base de dados para obter uma cópia da base AdventureWorksLT2008 já com os dados.

Método ShowDialog() em WPF

2009-08-11T22:35:00.001-03:00

A forma de exibir um formulário modal em WPF e obter a informação de qual botão foi acionado, foi alterado um pouco se comparado com o Windows Forms. O conceito é o mesmo mas a forma de verificar se foi acionado o botão Ok ou Cancelar, é um pouco diferente.

Para mostrar como exibir um formulário modal em WPF vou utilizar um exemplo onde temos dois formulários Window1 e Window2, onde no formulário Window1 através do botão Exibir Formulário Modal é exibido formulário Window2 com os botões Ok e Cancelar.

Quando acionado o botão OK (ou tecla ENTER) o formulário é fechado e é exibida uma mensagem informando que o botão Ok foi pressionado. Quando pressionado o botão Cancelar (ou tecla ESC) o formulário também é fechado e é exibida uma mensagem informando que o botão Cancelar foi acionado.

Para demonstrar o exemplo é necessário no formulário Window2 criar os botões Ok e Cancelar. Segue o código XAML para criação do formulário Window2 com os botões:

<Window x:Class="WpfApplicationShowDialog.Window2"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="Formulário Modal" Height="157" Width="300">
    <Grid>
        <Button Name="btnOk" Content="Ok" IsDefault="True" Click="btnOk_Click"
               HorizontalAlignment="Left" Margin="47,53,0,0"  
               VerticalAlignment="Top" Width="75" Height="23" >
        </Button>
        <Button Name="btnCancelar" Content="Cancelar" IsCancel="True" 
                Click="btnCancelar_Click" HorizontalAlignment="Right"
                Margin="0,53,42,0" Width="75"
                Height="23" VerticalAlignment="Top" >
        </Button>
    </Grid>
</Window>

No botão btnOk foi configurada a propriedade IsDefault="True", para que o formulário chame o evento Click do botão quando a tecla ENTER for acionada. Cada formulário pode ter somente um botão com a propriedade IsDefault configurada como True.

No botão btnCancelar foi configurada a propriedade IsCancel="True", para que o formulário chame o evento Click do botão quando a tecla ESC for acionada. Cada formulário pode ter somente um botão com a propriedade IsCancel configurada como True.

Depois de pronta a interface do formulário Window2 é necessário configurar a propriedade DialogResult do formulário como True ou False, dependendo do resultado desejado, ou seja, no WPF o método ShowDialog() retorna um valor booleano, podendo ser nulo (bool?), não existe mais os retornos DialogResult.Ok, DialogResult.Cancel, etc. Portanto precisamos informar o valor do DialogResult via código.

        private void btnOk_Click(object sender, RoutedEventArgs e)
        {
            DialogResult = true;
        }
 
        private void btnCancelar_Click(object sender, RoutedEventArgs e)
        {
            DialogResult = false;
        }

No formulário Window1, no evento Click do botão Exibir Formulário Modal está implementada a chamada do formulário Window2 e dependendo do botão acionado é exibida a mensagem correspondente.

    1         private void btnExibirFrmModal_Click(object sender, RoutedEventArgs e)
    2         {
    3             Window2 tela2 = new Window2();
    4             // Exibe a tela2 em formato modal
    5             tela2.ShowDialog();
    6 
    7             // Verifica se o DialogResult possui valor antes de verificar
    8             // qual o valor
    9             if (tela2.DialogResult.HasValue)
   10             {
   11                 // Verifica após o fechamento da tela2, se foi acionado
   12                 // o botão Ok ou o botão Cancelar
   13                 if (tela2.DialogResult.Value == true)
   14                 {
   15                     MessageBox.Show("Foi acionado o botão OK");
   16                 }
   17                 else
   18                 {
   19                     MessageBox.Show("Foi acionado o botão Cancelar");
   20                 }
   21             }
   22         }

Na linha 5 é chamado o formulário Window2 utilizando o método ShowDialog(). Na linha 9 é verificado se a propriedade DialogResult tem valor antes de ler o mesmo. Se tem valor e é verdadeiro foi acionado o botão OK em caso contrário foi acionado o botão Cancelar.

Teste e Debug de WebService em Máquina Remota

2009-08-06T21:45:00.001-03:00

Durante o desenvolvimento de WebService o Visual Studio facilita o teste e debug na própria Interface de desenvolvimento, mas esta facilidade funciona somente quando estamos fazendo o teste na máquina de desenvolvimento utilizando o http://localhost.

Quando por algum motivo precisamos fazer um teste ou simplesmente verificar se um WebService esta respondendo em uma máquina remota não é possível utilizar o browser com a URL do WebService, pois por questões de segurança os métodos e funções do webService não estão acessíveis na máquina remota.

Podemos fazer uma alteração no arquivo Web.Config do WebService para liberar o acesso aos métodos e funções do WebService em um browser.

Para liberar o acesso para teste dos métodos e funções do WebService basta incluir o HttpGet e HttpPost na tag <system.web> do WebService.

    <system.web>
      <webServices>
        <protocols>
          <add name="HttpPost" />
          <add name="HttpGet" />
        </protocols>
      </webServices>
    </system.web>

Depois de executado todos os testes necessários altere a configuração para remover o acesso ao HttpPost e HttpGet.

    <system.web>
      <webServices>
        <protocols>
          <remove name="HttpPost" />
          <remove name="HttpGet" />
        </protocols>
      </webServices>
    </system.web>

Não esquecer de desabilitar o acesso ao HttpPost e HttpGet depois dos testes. Isto é muito importante por questões de segurança.

Herança Visual em Formulário Windows Mobile

2009-04-29T22:12:00.000-03:00

Tecnologia:	Windows Mobile 5.0 ou superior
Ferramenta:	Visual Studio 2008 Team System

A programação de Windows Forms para a plataforma Windows Mobile é similar a do Windows Forms para Desktop, inclusive podemos utilizar o conceito de herança visual de formulário também em aplicações Windows Mobile.

No caso de utilizar herança visual em formulário nas aplicações mobile, em algumas situações podemos nos deparar com a seguinte mensagem de erro, no momento de criar o formulário herdado:

“Visual inheritance is currently disabled because the base class references a device-specific component or contains P/Invoke.”

Esta mensagem pode ocorrer em aplicações que utilizam um componente específico do dispositivo ou quando chamamos métodos utilizando o PInvoke do .NET nas chamadas de códigos não gerenciados.

A figura a seguir exibe um formulário apresentando a mensagem de erro no momento de criação quando utilizada a herança visual, e o mesmo formulário apresentando corretamente os controles utilizando a herança visual. Inclusive podemos observar na figura que os controles são herdados pela indicação de uma seta em cada controle herdado.

Para corrigir o problema da mensagem de erro descrita acima siga as seguintes instruções:

1. Clique com o botão direito o formulário “pai” no Solution Explorer do Visual Studio e selecione o menu View Class Diagram.

2. Na tela de Diagrama de Classes selecione a classe do formulário “pai”.

3. Nas Propriedades da classe selecione a propriedade Custom Attributes e digite DesktopCompatible(true) na janela de Custom Attributes for Form1.

4. Observe que foi criado o arquivo DesignTimeAttributes.xmta no diretório do projeto com o seguinte conteúdo.

</Class>

</Classes>

5. Após a criação deste arquivo podemos criar formulários que herdem os controles deste formulário “pai”, sem que seja apresentada a mensagem de erro descrita acima.

SelectAll no Controle MaskedTextBox

2009-03-30T22:30:00.001-03:00

Assunto:	Windows Forms
Ferramenta:	Visual Studio 2008 Team System

Recentemente resolvi utilizar um controle MaskedTextBox em uma aplicação Windows Forms, para preencher um campo de data e utilizar a facilidade da máscara de data.

Para facilitar para o usuário, quando o formulário era apresentado na aplicação o campo de data já aparecia preenchido com a data atual. Bastava que o usuário aceitasse a data atual ou se quisesse alterar a data, o campo já apareceria selecionado facilitando assim a inserção da nova data.

Para fazer com que a informação no campo de data apareça selecionada quando o foco está no campo de data normalmente utilizamos o método SelectAll() do controle. No caso do controle MaskedTextBox este método não funciona diretamente como no controle TextBox. Encontrei duas formas de conseguir selecionar o texto como indicado na figura acima:

A primeira forma é através de delegate, chamando o método SelectAll, depois que todas as mensagens do formulário são processadas.

        private void mskDataPublicacao_Enter(object sender, EventArgs e)
        {
            this.BeginInvoke((MethodInvoker)delegate()
            {
                this.mskDataPublicacao.SelectAll();
            });
        }

A segunda forma é chamando o método Focus() antes do método SelectAll().

        private void mskDataPublicacao_Enter(object sender, EventArgs e)
        {
            this.mskDataPublicacao.Focus();
            this.mskDataPublicacao.SelectAll();
        }

Criando uma Assinatura Digital

2009-02-16T20:11:00.006-03:00

Os algoritimos utilizados em assinatura digital mapeiam valores de tamanho arbitrário para valores binários de tamanho fixo. O .NET framework possui várias classes que implementam algorítimos de assinatura digital, tais como:

HMACSHA1
MACTripleDES
MD5CryptoServiceProvider
RIPEMD160
SHA1Managed
SHA256Managed
SHA384Managed
SHA512Managed

Quando utilizamos uma classe que implementa uma assinatura digital temos a garantia de que dois conjuntos de valores idênticos terão o mesmo resultado com tamanho fixo. Qualquer pequena alteração no valor fará com que o resultado seja totalmente diferente.

Segue um exemplo de utilização de uma classe que pode ser utilizada para assinatura digital. O exemplo utiliza a classe SHA256Managed que cria uma assinatura digital para a palavra Romar.

Para que o exemplo funcione é necessário incluir o namespace System.Security.Cryptography.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Cryptography;

    class Program
    {
        static void Main(string[] args)
        {
            byte[] dados = Encoding.ASCII.GetBytes("Romar");
            byte[] resultado;

            // Cria um hash para a palavra Romar
            SHA256 shaM = new SHA256Managed();
            resultado = shaM.ComputeHash(dados);

            // Utilizando a classe Encoding
            string palavraCriptografada1 = Encoding.ASCII.GetString(resultado);
            Console.WriteLine("Resultado com a classe Encoding:");
            Console.WriteLine(palavraCriptografada1);

Console.WriteLine();

            // utilizando a classe BitConverter
            string palavraCriptografada2 = BitConverter.ToString(resultado);
            Console.WriteLine("Resultado com a classe BitConverter:");
            Console.WriteLine(palavraCriptografada2);

            Console.ReadKey();
        }
    }

No exemplo imprimimos o resultado de duas formas; uma exibindo o resultado como uma string utilizando a classe Encoding e a outra utilizando a classe BitConverter. A classe Encoding foi utilizada com o valor ASCII, portanto o resultado é uma string com os valores da assinatura digital exibidos em caracteres que nem sempre são imprimíveis e podem apresentar dificuldade para se armazenar em alguns tipos de arquivos. Uma opção para armazenamento seria trazer o resultado em um formato mais amigável, por exemplo em hexadecimal. A classe BitConverter facilita este trabalho fazendo a conversão do resultado em um array de bytes que pode ser facilmente manipulado e armazenado.

Resultado com a classe Encoding:
k?+??$???►?,?4F
?↨B¶v?e☺\???C

Observando o resultado do exemplo utilizando-se a classe BitConverter podemos observar que temos 32 bytes. A classe SHA256Managed sempre retornará um tamanho fixo de 32 bytes (256 bits).

Resultado com a classe BitConverter:
6B-EC-2B-AE-B9-24-E2-F9-BC-10-D1-2C-D9-34-46-07-0A-87-17-42-14-76-EA-5B-08-65-01
-5C-BD-F1-D5-43