Subscribe:

domingo, 23 de agosto de 2015

Android Reconhecimento de voz

E aí pessoal!..
Hoje viemos trazer uma dica de android, para aqueles que desejam aprimorar um app, ou até mesmo, montar um app novo usando esse conceito. Vamos falar sobre o reconhecimento de voz.
Quando fui utilizar o reconhecimento em um app que eu estava construindo, assim como todos fazem, fui pesquisar. Na internet encontrei vários exemplos, mas muitos mostravam de uma maneira complicada, o que dificultava a implementação no projeto, mas depois de alguns testes consegui implementar de uma maneira bem simples.


O teste que vou mostrar aqui funciona da seguinte maneira:
- Na primeira tela será implementada uma ListView (invisible de preferencia), pois é nela que será a comparação da palavra reconhecida.

<ListView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/listView"
android:layout_centerHorizontal="true"
android:visibility="invisible"
android:background="#ffffee8c" 
/>


Ficará mais ou menos dessa maneira.
- Na Action desse seu .xml deverá ser implementado da seguinte maneira:
Na sua classe use o implements OnCompletionListener
De acordo com o app que você estará criando, você fará uma chamada para o método onCompletion. Esse método irá abrir a tela de reconhecimento de voz:

public void onCompletion() {
   Intent i = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
   i.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
   RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
   i.putExtra(RecognizerIntent.EXTRA_PROMPT, "Fale agora");
   startActivityForResult(i, check);
 }
Ela irá mandar para o método que irá implementar na listView o resultado obtido. 

Uma variável pegará o primeiro resultado para comparação da palavra correta.
@Override
protected void onActivityResult ( int requestCode, int resultCode, Intent data){
if (requestCode == check && resultCode == RESULT_OK) {
   ArrayList<String> results = data.getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
   palavra = results.get(0);
   lv.setAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, results));
 }
super.onActivityResult(requestCode, resultCode, data);
palavra = removeAcentos(palavra); //Método que remove acentos da palavra comparada
if (palavra.equals("sim")) {
   respSim();  // Se a palavra for sim irá para o método implementado dizendo o que ele tem que fazer
} else if (palavra.equals("nao")) {
   respNao();//
Se a palavra for não irá para o método implementado dizendo o que ele tem que fazer

}else {
   showSimplePopUp(); //Se não for correto abrirá um pop-up dizendo que a palavra não esta correta.
}
}



Método para remover acentos da palavra:

public String removeAcentos(String str) {
   str = Normalizer.normalize(str, Normalizer.Form.NFD);
   str = str.replaceAll("[^\\p{ASCII}]", ""); return str;
}

Método para mostrar o Pop-up de aviso que a palavra está errada:
private void showSimplePopUp() {
AlertDialog.Builder helpBuilder = new AlertDialog.Builder(this);
helpBuilder.setTitle("Resposta Incorreta");
helpBuilder.setMessage("Responda Sim ou Nao");
helpBuilder.setPositiveButton("Ok",
new DialogInterface.OnClickListener() {
      public void onClick(DialogInterface dialog, int which) {
      // Do nothing but close the dialog
      }
      });
AlertDialog helpDialog = helpBuilder.create();
helpDialog.show();
}

É isso ai pessoal, é um código bem simples e bem legal de conhecer para se implementar em um projeto.
Se foi útil pra você, se você gostou, compartilha ai, curta nossa página no Facebook e qualquer dúvida é só comentar.

Até mais.

sexta-feira, 21 de agosto de 2015

Algoritmos de escalonamento de processos

Olá pessoal, hoje venho falar de alguns algoritmos que podem ser bem chatos de desenvolver, bem são os algoritmos de escalonamentos de processos, esses algoritmos são implementados pelo sistema operacional para escalonar os processos de uma forma que eles possam ser executados no menor tempo possível.

Cada algoritmo a ser mostrado aqui possui critérios para o escalonamento do processo e é isso que veremos.

O primeiro deles é o FCFS( First-Come,First Server), funciona como uma fila normal, o primeiro que entra é o primeiro que sai.

O burst do processo é o tempo que ele precisa para ser executado.

A imagem demonstra a execução dos processos, percebam que esse algoritmo não é bom, pois tem processos que não demoram para serem executados e portanto poderiam ter sidos executados antes.

O próximo é o SJF(Shortest Job First), ele diferentemente do FCFS ele escalona os processos conforme o burst do processo.
Vejam a diferença que dá, os mesmos processos usado no FCFS tiveram média de espera de 3, por isso o SJF é uma opção melhor que o FCFS.

Agora o outro o algoritmo é o SRTF(Shortest-Remaining-Time-First), agora esse ele é preemptivo, ou seja, se um processo com burst menor que o processo que esta sendo executado, ele interrompe o processo atual e como executar o processo que chegou.
No SRTF o tempo de espera é calculado a partir do tempo de chegada, e veja que o processo p1 foi interrompido e p2 começou a ser executado, e assim por diante.

O próximo algoritmo é o Round Robin, nesse algoritmo é definido um quantum de tempo, o quantum ele vai definir o tempo em que o processo pode ser executado, sendo assim se o processo não tiver terminado sua execução e o tempo dele acabar ele volta para a fila de espera até ser executado novamente até ser terminado.


Agora por último o algoritmo Multinível, como o próprio nome fala ele possui vários níveis, mas cada nível pode implementar um algoritmo de escalonamento diferente, um exemplo é no primeiro nível o Round Robin e no segundo FCFS, sendo que se ele não terminar de executar na primeira fila ele vai para a segunda fila.

Agora deixo para vocês darem uma olhada as implementações deles feita por nós do blog, Escalonamento em C e Escalonamento em Java.

Bom isso é tudo pessoal, espero que tenham gostado e não esqueça de curtir nossa página no facebook Hu3Tech, aquele abraço e tchau.