Eu quero que algum código seja executado em segundo plano continuamente. Eu não quero fazer isso em um serviço. Existe alguma outra maneira possível?
Eu tentei chamar a Thread
classe na minha, Activity
mas meus Activity
restos permanecem em segundo plano por algum tempo e depois para. A Thread
turma também para de trabalhar.
class testThread implements Runnable {
@Override
public void run() {
File file = new File( Environment.getExternalStorageDirectory(), "/BPCLTracker/gpsdata.txt" );
int i = 0;
RandomAccessFile in = null;
try {
in = new RandomAccessFile( file, "rw" );
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//String line =null;
while ( true ) {
HttpEntity entity = null;
try {
if ( isInternetOn() ) {
while ( ( line = in.readLine() ) != null ) {
HttpClient client = new DefaultHttpClient();
String url = "some url";
HttpPost request = new HttpPost( url );
StringEntity se = new StringEntity( line );
se.setContentEncoding( "UTF-8" );
se.setContentEncoding( new BasicHeader( HTTP.CONTENT_TYPE, "application/json" ) );
entity = se;
request.setEntity( entity );
HttpResponse response = client.execute( request );
entity = response.getEntity();
i++;
}
if ( ( line = in.readLine() ) == null && entity != null ) {
file.delete();
testThread t = new testThread();
Thread t1 = new Thread( t );
t1.start();
}
} else {
Thread.sleep( 60000 );
} // end of else
} catch (NullPointerException e1) {
e1.printStackTrace();
} catch (InterruptedException e2) {
e2.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}// end of while
}// end of run
}
android
multithreading
user2082987
fonte
fonte
runOnUiThread()
métodoRespostas:
Se você precisar:
executar código em um plano de fundo
executar código que NÃO toque / atualize a interface do usuário
executar código (curto) que levará no máximo alguns segundos para concluir
ENTÃO, use o seguinte padrão limpo e eficiente que usa o AsyncTask:
fonte
Lembre-se de executar o plano de fundo, executar continuamente são duas tarefas diferentes.
Para processos em segundo plano a longo prazo, os Threads não são ideais no Android. No entanto, aqui está o código e faça-o por sua conta e risco ...
Lembre-se de que o Serviço ou o Thread será executado em segundo plano, mas nossa tarefa precisa acionar (chamar várias vezes) para obter atualizações, ou seja, uma vez concluída a tarefa, precisamos recuperar a função para a próxima atualização.
Temporizador (gatilho periódico), Alarme (gatilho da base de tempo), Transmissão (gatilho da base de eventos), a recursão ativará nossas funções.
Usando o serviço: se você iniciar um serviço, ele iniciará, executará a tarefa e será encerrado automaticamente. após a execução da tarefa. rescindido também pode ser causado por exceção, ou o usuário o eliminou manualmente das configurações. START_STICKY (Serviço fixo) é a opção fornecida pelo Android, que o serviço será reiniciado automaticamente se o serviço for encerrado.
Lembre-se da diferença de perguntas entre multiprocessamento e multithreading? O serviço é um processo em segundo plano (assim como a atividade sem interface do usuário). Da mesma maneira que você inicia o encadeamento na atividade para evitar a carga no encadeamento principal (encadeamento de atividades), da mesma maneira que você precisa iniciar encadeamentos (ou tarefas assíncronas) no serviço para evitar carga no serviço.
Em uma única instrução, se você deseja executar uma tarefa em segundo plano continua, é necessário iniciar um StickyService e executar o encadeamento no serviço na base de eventos
fonte
O mecanismo mais provável que você está procurando é
AsyncTask
. É designado diretamente para executar o processo em segundo plano no Thread em segundo plano. Além disso, seu principal benefício é o fato de oferecer alguns métodos que são executados no Thread Principal (UI) e possibilitam a atualização da interface do usuário, se você deseja avisar o usuário sobre algum progresso na tarefa ou atualizar a UI com os dados recuperados do processo em segundo plano.Se você não sabe como começar aqui, é um bom tutorial:
Nota: Também existe a possibilidade de usar
IntentService
comResultReceiver
isso também funciona.fonte
3-Liner simples
Uma maneira simples de fazer isso que encontrei como comentário de @awardak na resposta de Brandon Rude :
Não tenho certeza se, ou como, isso é melhor do que usar,
AsyncTask.execute
mas parece funcionar para nós. Quaisquer comentários sobre a diferença serão apreciados.Obrigado, @awardak !
fonte
Uma alternativa ao AsyncTask é o robospice. https://github.com/octo-online/robospice .
Algumas das características do robospice.
1. executa solicitações de rede de forma assíncrona (em segundo plano, AndroidService) (por exemplo: solicitações REST usando o Spring Android). Notifica seu aplicativo, no segmento da interface do usuário, quando o resultado estiver pronto.
2.é fortemente digitado! Você faz seus pedidos usando POJOs e obtém POJOs como resultados da solicitação.
3. não force restrições nos POJOs usados para solicitações nem nas classes de atividade que você usa em seus projetos.
4.Caches results (no Json com Jackson e Gson, ou Xml, ou arquivos de texto simples ou binários, mesmo usando o ORM Lite).
5. notifica suas atividades (ou qualquer outro contexto) do resultado da solicitação de rede se e somente se ainda estiverem ativas
6. nenhum vazamento de memória, como o Android Loaders, ao contrário do Android AsyncTasks notifica suas atividades no thread da interface do usuário.
7. usa um modelo de tratamento de exceções simples, mas robusto.
Amostras para começar. https://github.com/octo-online/RoboSpice-samples .
Uma amostra do robospice em https://play.google.com/store/apps/details?id=com.octo.android.robospice.motivations&feature=search_result .
fonte
fonte
Se você precisar executar um encadeamento com códigos diferentes, aqui está um exemplo:
Ouvinte:
Classe de Thread
Execute códigos diferentes:
fonte