Como executar código em um encadeamento em segundo plano no Android?

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 Threadclasse na minha, Activitymas meus Activityrestos permanecem em segundo plano por algum tempo e depois para. A Threadturma 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

    }

Se você precisar:

1. executar código em um plano de fundo

2. executar código que NÃO toque / atualize a interface do usuário

3. 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:

AsyncTask.execute(new Runnable() {
   @Override
   public void run() {
      //TODO your background code
   }
});

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.

public static boolean isRecursionEnable = true;

void runInBackground() {
    if (!isRecursionEnable)
        // Handle not to start multiple parallel threads
        return;

    // isRecursionEnable = false; when u want to stop
    // on exception on thread make it true again  
    new Thread(new Runnable() {
        @Override
        public void run() {
            // DO your work here
            // get the data
            if (activity_is_not_in_background) {
                runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        // update UI
                        runInBackground();
                    }
                });
            } else {
                runInBackground();
            }
        }
    }).start();
}

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

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?

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:

• Compreendendo o AsyncTask - Uma vez e sempre

Nota: Também existe a possibilidade de usar IntentServicecom ResultReceiverisso também funciona.

3-Liner simples

Uma maneira simples de fazer isso que encontrei como comentário de @awardak na resposta de Brandon Rude :

new Thread( new Runnable() { @Override public void run() { 
  // Run whatever background code you want here.
} } ).start();

Não tenho certeza se, ou como, isso é melhor do que usar, AsyncTask.executemas parece funcionar para nós. Quaisquer comentários sobre a diferença serão apreciados.

Obrigado, @awardak !

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 .

class Background implements Runnable {
    private CountDownLatch latch = new CountDownLatch(1);
    private  Handler handler;

    Background() {
        Thread thread = new Thread(this);
        thread.start();
        try {
            latch.await();
        } catch (InterruptedException e) {
           /// e.printStackTrace();
        }
    }

    @Override
    public void run() {
        Looper.prepare();
        handler = new Handler();
        latch.countDown();
        Looper.loop();
    }

    public Handler getHandler() {
        return handler;
    }
}

Se você precisar executar um encadeamento com códigos diferentes, aqui está um exemplo:

Ouvinte:

public interface ESLThreadListener {

    public List onBackground();

    public void onPostExecute(List list);

}

Classe de Thread

public class ESLThread extends AsyncTask<Void, Void, List> {


    private ESLThreadListener mListener;

    public ESLThread() {

        if(mListener != null){

            mListener.onBackground();
        }
    }

    @Override
    protected List doInBackground(Void... params) {

        if(mListener != null){

            List list = mListener.onBackground();

            return list;
        }

        return null;
    }

    @Override
    protected void onPostExecute(List t) {
        if(mListener != null){

            if ( t != null) {
                mListener.onPostExecute(t);
            }
        }

    }


    public void setListener(ESLThreadListener mListener){

        this.mListener = mListener;
    }
}

Execute códigos diferentes:

  ESLThread thread = new ESLThread();
                        thread.setListener(new ESLThreadListener() {
                            @Override
                            public List onBackground() {
                                List<EntityShoppingListItems>  data = RoomDB.getDatabase(context).sliDAO().getSL(fId);

                                return data;

                            }

                            @Override
                            public void onPostExecute(List t) {

                                List<EntityShoppingListItems> data = (List<EntityShoppingListItems>)t;
                                adapter.setList(data);
                            }
                        });

                        thread.execute();