LaercioRedes

Os conceitos básicos de otimização para mecanismos de pesquisa inclui construir um bom conteúdo e que seja fácil de encontrar. Algumas tecnologias ajudam a garantir mais visibilidade à página. Veja sugestões.

Os princípios do Search Engine Optimization (SEO), otimização de sites em português, incluem criar um conteúdo que os leitores vão querer vincular nas mídias sociais, blogs ou outros sites e contar com um conteúdo fácil de encontrar com palavras-chave relevantes. O mecanismo também garante que seu site não tem questões técnicas que podem impedir os motores de busca de indexar o conteúdo.

Mas como fazer isso e ainda medir o sucesso da iniciativa? Diversas ferramentas SEO podem ajudar nessa tarefa. A seguir você encontra 20 tecnologias, listadas sem nenhuma ordem particular, recomendados por três especialistas: Jill Whalen, consultora SEO da High Rankings; Nicole Munoz, CEO e fundadora da StartRankingNow; e Matt McGee, editor-chefe do Search Engine Land and Marketing…

Ver o post original 1.166 mais palavras

Android – Desabilitar o desligamento automático de tela (Disable screen sleep)

Cópia fiel de: http://zarelli.wordpress.com/

– Não permitir que a tela durma
– Disable screen timeout
– Disable screen turning off
– Disable screen automatically turns off
– Disabling screen sleep
– Disable screen sleep
– Disable sleep activity
– Disable turn off activity

Esse é um termo muito difícil de se encontrar (pelo menos para min), acho que é o post mais complicado de se dar um titulo, afinal como desabilitar o desligamento automatico da tela em sua activity?

Existe somente uma maneira (correta) sem a necessidade de mexer nas configurações do visor. Veja como.

Ou você define no XML da tela ou no código fonte:

android:keepScreenOn=”true”
ou
setKeepScreenOn(true);

Exemplo:

No XML (maneira mais simples e acredito que a melhor):

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:keepScreenOn="true"
    >
<TextView  
    android:layout_width="match_parent" 
    android:layout_height="wrap_content" 
    android:text="Hello World, MainActivity"
    />
</LinearLayout>

no codigo fonte (lembre-se de ter definido o id na tag root do layout):

@Override
public void onCreate(Bundle savedInstanceState)
{
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);

    findViewById(R.id.main).setKeepScreenOn(true);
}

Pronto, sua tela/activity não vai mais dormir/desligar.

Fonte:http://developer.android.com/reference/android/view/View.html#setKeepScreenOn%28boolean%29

Buscando dispositivos bluetooth no Android

Cópia fiel de: http://zarelli.wordpress.com/

Bluetooth

A plataforma Android inclui suporte para a pilha de rede Bluetooth, que permite que um dispositivo troque dados com outros dispositivos Bluetooth. A estrutura do framework fornece acesso à funcionalidade Bluetooth através do Bluetooth Android APIs. Essas APIs permitem que as aplicações estabeleção comunicação sem fio com outros dispositivos Bluetooth.

Usando as APIs de Bluetooth, uma aplicação Android pode executar o seguinte:

  • Verificar se há outros dispositivos Bluetooth
  • Consultar o adaptador Bluetooth local para dispositivos Bluetooth emparelhados
  • Estabelecer canais RFCOMM
  • Conectar a outros dispositivos através do serviço de descoberta
  • Transferir dados para e de outros dispositivos
  • Gerenciar conexões múltiplas

Abaixo vamos mostrar algumas funcionalidades como a busca de dispositivos.

Buscando dispositivos

Antes de tudo, lembre-se de inserir as permissões no seu Manifest.xml. A primeira permissão é para a busca de dispositivos e outras coisas relacionadas ao bluetooth (como transferência). A segunda permissão é utilizada para controle do dispositivo, ex: ativar o bluetooth.

android:name="android.permission.BLUETOOTH"/>
android:name="android.permission.BLUETOOTH_ADMIN"/>

Como o exemplo vai ser bem simples, vamos mostrar os itens em um ListView, assim teremos apenas um Layout “main.xml”

<!--?xml <span class="hiddenSpellError" pre="xml "-->version="1.0" encoding="utf-8"?>
xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="match_parent"
              android:layout_height="match_parent"
>
    <ListView
        android:id="@+idMain/listview"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
    />
</LinearLayout>

Agora vamos mostrar a classe responsável por TUDO a Bluetooth.java, essa classe extende BroadcastReceiver porque ela vai ser um receiver do sistema, vamos definir alguns filtros sobre o que ela vai “ouvir” e implementar o que vamos fazer com isso. Caso você não saiba o que é um Broadcast tentem ler algo sobre pois vai facilitar o entendimento.

public class Bluetooth extends BroadcastReceiver
{
    [...]
    private BluetoothListener listener;
    private ArrayList lista;
    private BluetoothAdapter dispositivo;

    private Bluetooth(BluetoothListener listener)
    {
        this.listener = listener;
        lista = new ArrayList();
    }
    [...]
}

Como a classe é muito grande vou explica-la por partes para nao ficar muito confuso. No final do topico vou inserir um link do projeto também.

Tudo que irei mostrar vai estar dentro da classe Bluetooth.
Abaixo defini um listener que vai ser responsável em informar as ações da busca.

public static interface BluetoothListener
{
        public static final String ACTION_DISCOVERY_STARTED = BluetoothAdapter.ACTION_DISCOVERY_STARTED;
        public static final String ACTION_FOUND = BluetoothDevice.ACTION_FOUND;
        public static final String ACTION_DISCOVERY_FINISHED = BluetoothAdapter.ACTION_DISCOVERY_FINISHED;

        public void action(String action);
}

No método abaixo é realizado o registro dos broadcast para ler as ações do bluetooth e iniciar a busca.

public static Bluetooth startFindDevices(Context context, BluetoothListener listener) throws IOException
{
    Bluetooth bluetooth = new Bluetooth(listener);

    //Pego o adapter
    bluetooth.dispositivo = BluetoothAdapter.getDefaultAdapter();

    // verifico se o bluetooth esta desabilitado, se tiver habilito
    //retorno null pois esta ação demora para ser concluida. (tratar)
    if (!bluetooth.dispositivo.isEnabled())
    {
        bluetooth.dispositivo.enable();
        return null;
    }

     // Registro os Broadcast necessarios para a busca de dispositivos
    IntentFilter filter = new IntentFilter(BluetoothListener.ACTION_FOUND);
    IntentFilter filter2 = new IntentFilter(BluetoothListener.ACTION_DISCOVERY_FINISHED);
    IntentFilter filter3 = new IntentFilter(BluetoothListener.ACTION_DISCOVERY_STARTED);
    context.registerReceiver(bluetooth, filter);
    context.registerReceiver(bluetooth, filter2);
    context.registerReceiver(bluetooth, filter3);

    //inicio a busca e retorno o objeto que vai ter alista de dispositivos
    bluetooth.dispositivo.startDiscovery();
    return bluetooth;
}

Beleza, estamos iniciando a busca, mas como vamos descubrir o que está chegando? você deve sobrescrever o método onReceive do BroadcastReceiver. Abaixo vamos tratar cada Broadcast que foi registrado e chamar o listener para informar o que está acontecendo.

@Override
public void onReceive(Context context, Intent intent)
{
    String action = intent.getAction();

    //caso encontre um dispositivo:
    if ( action.compareTo(BluetoothDevice.ACTION_FOUND) == 0 )
    {
        //pega as o dispositivo encontrado:
        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);

        //se a lista já tiver esse dispositivo eu retorno para o proximo
        //isso permite que sejá mostrado somente uma vez meu dispositivo
        //problema muito comum em exemplos
        if ( lista.contains(device) )
        {
            return;
        }

        //adiciono o dispositivo na minha lista:
        lista.add(device);
    }
    else if ( action.compareTo(BluetoothAdapter.ACTION_DISCOVERY_FINISHED) == 0 )
    {
        //caso o discovery chegue ao fim eu desregistro meus broadcasts
        //SEMPRE FAÇA ISSO quando terminar de usar um broadcast
        //(aqueles IntentFilter que criei anteriormente)
        context.unregisterReceiver(this);
    }

    if (listener != null)
    {
        //se foi definido o listener eu aviso a quem ta gerenciando.
        listener.action(action);
    }
}

Pronto, agora como usar essa classe ?
abaixo temos a Main do projeto:
Resumindo, implementei o Listener da classe Bluetooth para que podemos ler a ação, no onCreate damos o start na busca e definimos um adapter para o listview.
no método do listener (action) vamos tratar as ações do Bluetooth. quando chega no fim da busca pegamos os dispositivos da classe bluetooth e exibimos no listview.

public class MainActivity extends Activity implements Bluetooth.BluetoothListener
{
    private static final String TAG = "BuscaBluetooth";
    private Bluetooth bluetooth;
    private ArrayAdapter arrayAdapter;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        try
        {
            bluetooth = Bluetooth.startFindDevices(this, this);
        }
        catch (Exception e)
        {
            Log.e(TAG, "Erro: ", e);
        }

        arrayAdapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1);
        ListView listView = (ListView) findViewById(R.idMain.listview);
        listView.setAdapter(arrayAdapter);
    }

    public void action(String action)
    {
        if ( action.compareTo(ACTION_DISCOVERY_STARTED) == 0 )
        {
            arrayAdapter.add("-Busca iniciada");
        }
        else if ( action.compareTo(ACTION_DISCOVERY_FINISHED) == 0 )
        {
            preencherLista();
            arrayAdapter.add("-Fim de busca.");
        }
    }

    private void preencherLista()
    {
        for (BluetoothDevice device : bluetooth.getDispositivos())
        {
            arrayAdapter.add(device.getName() + "\n" + device.getAddress());
        }
    }
}

Se rodarmos a aplicação veremos algo como:
busca-bluetooth
Como opcional inseri um método na classe Bluetooth que pega os dispositivos já pareados.

public static Bluetooth getBondedDevices(Context applicationContext) throws IOException
{
    Bluetooth bluetooth = new Bluetooth(null);

    // Pega o dispositivo
    bluetooth.dispositivo = BluetoothAdapter.getDefaultAdapter();

    if ( !bluetooth.dispositivo.isEnabled() )
    {
        bluetooth.dispositivo.enable();
    }

    // Pega a lista de dispositivos pareados
    Set pairedDevices = bluetooth.dispositivo.getBondedDevices();

    // Adiciono na lista e depois retorno a mesma.
    if ( pairedDevices.size() > 0 )
    {
        for (BluetoothDevice device : pairedDevices)
        {
            bluetooth.lista.add(device);
        }
    }

    return bluetooth;
}

Talvez para leigos(ou nao) fica um pouco complicado para entender o conceito do listener dos Broadcasts e da minha pouca explicação, no link abaixo coloquei o projeto completo.

LINK DO PROJETO (DropBox)

Fonte: http://goo.gl/D7ekO

AsyncTask – Executando tarefas em segundo plano

Cópia fiel de: http://zarelli.wordpress.com/

Android AsyncTask

AsyncTask um Substituto de Threads e Handles

Como todo desenvolvedor Android sabe, é bem chato mexer com Threads, ainda mais quando há necessidade de atualizar a interface, para isso atualmente usamos a famosa ThreadUI ou Handler.

Pesquisando, encontrei uma maneira de trabalhar com essas Threads distintas facilmente utilizando a classe AsyncTask, com ela nos não precisamos nos preocupar com o tal de Handler. Nela executamos qualquer processo paralelamente e temos um método responsável por atualizar a interface.

Quando estendemos a AsyncTask ele nos obriga a definir três tipos de classes:

(defini esses tipos como exemplo)

extends AsyncTask<string, object, integer>

    1. O primeiro tipo ira definir o tipo que será passado para o método doInBackground(String… paramss), esses parâmetros vão ser passados ao executarmos o processo.
    2. O segundo tipo ira definir o tipo que será passado para o método onProgressUpdate(Object… values).
    3. O terceiro tipo ira definir o retorno do método doInBackground, assim que termina a execução do doInBackground esse tipo será retornado para o método onPostExecute(Integer… values).

Ao implementar uma classe que extend a AsyncTask podemos sobrescrever os seguintes métodos:

1 – onPreExecute.

É chamado antes de executar o processo (doInBackground), Podemos utilizar para criarmos um ProgressDialogo. Este método roda em Thread de interface.

2 – doInBackground

É responsável pelo processo. ex: uma busca em um webservice, algum download, qualquer processo que demanda tempo e processamento.

Não podemos utilizar este método para atualizarmos nossa interface, para isso temos a onProgressUpdate, MAS NÃO CHAMAREMOS ELA DIRETAMENTE para isso temos o métodopublishProgress que fica responsável por chamar a onProgressUpdate.

3 – onPostExecute

Este método recebera um parâmetro do doInBackground, ele é responsável em terminar a execução do processo, por exemplo finalizar um ProgressDialogo.

4 – onProgressUpdate

Este método é responsável em atualizar nossa interface. Chamamos ele atravéz do método publishProgress

Na pratica isso facilita e muito, acabando com os problemas de atualizar interface fora de um handler! mensagem de erro muito comum acredito!.

Segue um exemplo de como implementar um processo que demanda tempo, sempre atualizando a interface.

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.Context;
import android.os.AsyncTask;
import android.os.Bundle;

public class MainActivity extends Activity
{
    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        /** Chamando o Processo AsyncTask
         *  Os parametros passado no método execute, vão para o método
         *  doInBackground(Integer... params).
         */
        Processo processo = new Processo(this);
        processo.execute(3000, 2000, 4000);
    }

    public class Processo extends AsyncTask<integer, string,="" integer="">
    {

        private ProgressDialog progress;
        private Context context;

        public Processo(Context context)
        {
            this.context = context;
        }

        @Override
        protected void onPreExecute()
        {
            //Cria novo um ProgressDialogo e exibe
            progress = new ProgressDialog(context);
            progress.setMessage("Aguarde...");
            progress.show();
        }

        @Override
        protected Integer doInBackground(Integer... paramss)
        {
            for (int i = 0; i < paramss.length; i++)
            {
                try
                {
                    //Simula processo...
                    Thread.sleep(paramss[i]);
                    //Atualiza a interface através do onProgressUpdate
                    publishProgress(i + "...");
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            }
            return 1;
        }

        @Override
        protected void onPostExecute(Integer result)
        {
            //Cancela progressDialogo
            progress.dismiss();
        }

        @Override
        protected void onProgressUpdate(String... values)
        {
            //Atualiza mensagem
            progress.setMessage(values[0]);
        }
    }
}

Android Criando um ListView Personalizado

Cópia fiel de: http://zarelli.wordpress.com/

Custom ListView

Para criar um listView personalizado não é difícil porem é um trabalho chato de se fazer.
O conceito é, preencher uma lista de objetos que contem os dados de seu item e passar essa lista para um adapter que irá preencher o ListView, através desse adapter nós poderemos ter o controle sobre a lista, podendo remover item adicionar e pegar o selecionado.

Primeiro crie o layout de onde ficara seu listView, para isso criei o “main.xml”:

<?xml version="1.0" encoding="UTF-8"?>
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent"
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:background="#FFFFFFFF"
>
        <ListView
        android:id="@+id/list"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:divider="#ECECEC"
        android:dividerHeight="1sp"
        />
</LinearLayout>

Após a criação do layout de apresentação criaremos o Item, vou criar um item bem simples, com uma texto e uma imagem. “item_listview.xml”:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="horizontal">
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal"
        android:padding="5sp">
        <ImageView
            android:id="@+id/imagemview"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            />

        <TextView
            android:id="@+id/text"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:layout_marginLeft="5sp"
            android:gravity="center_vertical"
            android:textColor="#FF000000"
        />
    </LinearLayout>
</LinearLayout>

Pronto a parte do XML está feita! agora vamos implementar no código.

Primeiramente criaremos nosso Objeto de acordo com nosso item.

public class ItemListView
{
    private String texto;
    private int iconeRid;

    public ItemListView()
    {
    }

    public ItemListView(String texto, int iconeRid)
    {
        this.texto = texto;
        this.iconeRid = iconeRid;
    }

    public int getIconeRid()
    {
        return iconeRid;
    }

    public void setIconeRid(int iconeRid)
    {
        this.iconeRid = iconeRid;
    }

    public String getTexto()
    {
        return texto;
    }

    public void setTexto(String texto)
    {
        this.texto = texto;
    }
}

Após criado o Objeto vamos criar o Adapter, o coração do ListView.
Vejá como é simples:

public class AdapterListView extends BaseAdapter
{
    private LayoutInflater mInflater;
    private ArrayList<ItemListView> itens;

    public AdapterListView(Context context, ArrayList<ItemListView> itens)
    {
        //Itens que preencheram o listview
        this.itens = itens;
        //responsavel por pegar o Layout do item.
        mInflater = LayoutInflater.from(context);
    }

    /**
     * Retorna a quantidade de itens
     *
     * @return
     */
    public int getCount()
    {
        return itens.size();
    }

    /**
     * Retorna o item de acordo com a posicao dele na tela.
     *
     * @param position
     * @return
     */
    public ItemListView getItem(int position)
    {
        return itens.get(position);
    }

    /**
     * Sem implementação
     *
     * @param position
     * @return
     */
    public long getItemId(int position)
    {
        return position;
    }

    public View getView(int position, View view, ViewGroup parent)
    {
        //Pega o item de acordo com a posção.
        ItemListView item = itens.get(position);
        //infla o layout para podermos preencher os dados
        view = mInflater.inflate(R.layout.item_list, null);

        //atravez do layout pego pelo LayoutInflater, pegamos cada id relacionado
        //ao item e definimos as informações.
        ((TextView) view.findViewById(R.id.text)).setText(item.getTexto());
        ((ImageView) view.findViewById(R.id.imagemview)).setImageResource(item.getIconeRid());

        return view;
    }
}

Pronto. Toda estrutura está feita, agora vamos colocar para funcionar.
Segue o código de implementação na nossa Activity principal:

public class MainActivity extends Activity implements OnItemClickListener
{
    private ListView listView;
    private AdapterListView adapterListView;
    private ArrayList<ItemListView> itens;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        //carrega o layout onde contem o ListView
        setContentView(R.layout.main);

        //Pega a referencia do ListView
        listView = (ListView) findViewById(R.id.list);
        //Define o Listener quando alguem clicar no item.
        listView.setOnItemClickListener(this);

        createListView();
    }

    private void createListView()
    {
        //Criamos nossa lista que preenchera o ListView
        itens = new ArrayList<ItemListView>();
        ItemListView item1 = new ItemListView("Guilherme Biff", R.drawable.biff);
        ItemListView item2 = new ItemListView("Lucas Volgarini", R.drawable.volgarini);
        ItemListView item3 = new ItemListView("Eduardo Ricoldi", R.drawable.ricoldi);
        ItemListView item4 = new ItemListView("Felipe Panngo", R.drawable.panngo);

        itens.add(item1);
        itens.add(item2);
        itens.add(item3);
        itens.add(item4);

        //Cria o adapter
        adapterListView = new AdapterListView(this, itens);

        //Define o Adapter
        listView.setAdapter(adapterListView);
        //Cor quando a lista é selecionada para ralagem.
        listView.setCacheColorHint(Color.TRANSPARENT);
    }

    public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3)
    {
        //Pega o item que foi selecionado.
        ItemListView item = adapterListView.getItem(arg2);
        //Demostração
        Toast.makeText(this, "Você Clicou em: " + item.getTexto(), Toast.LENGTH_LONG).show();
    }
}

Observação: As imagens foram inseridas na pasta res/drawable/ para quem não saiba, após inserida as imagens lá podemos pegar sua referencia pelo ResId.

Para quem quiser o projeto:
http://dl.dropbox.com/u/15643399/CustomListView.zip