Sobes.tech
Middle

Kako izvršiti asinhrone operacije u čistom Androidu?

sobes.tech АИ

Одговор од АИ

Postoji nekoliko načina:

  1. Niti (Threads): Kreiranje i upravljanje sopstvenim nitima.

    new Thread(new Runnable() {
        @Override
        public void run() {
            // Izvršavanje duže operacije
            // ...
            // Ažuriranje UI (zahteva Handler)
            // handler.post(...)
        }
    }).start();
    
  2. Handler i Looper: Koriste se za razmenu poruka između niti, često za ažuriranje UI iz pozadinske niti.

    Handler handler = new Handler(Looper.getMainLooper());
    // ... u pozadinskoj niti
    handler.post(new Runnable() {
        @Override
        public void run() {
            // Ažuriranje UI
        }
    });
    
  3. AsyncTask (zastareo, ali korisno znati): Jednostavan način za izvršavanje asinhronih zadataka sa ažuriranjem UI. Ne preporučuje se za novi kod.

    private class MyAsyncTask extends AsyncTask<Void, Void, String> {
        @Override
        protected String doInBackground(Void... voids) {
            // Izvršavanje duže operacije
            return "Rezultat";
        }
    
        @Override
        protected void onPostExecute(String result) {
            // Ažuriranje UI sa rezultatom
        }
    }
    // ...
    // new MyAsyncTask().execute();
    
  4. ExecutorService i Future: Fleksibilniji mehanizam za upravljanje bazenima niti.

    ExecutorService executor = Executors.newSingleThreadExecutor();
    Future<String> future = executor.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
            // Izvršavanje duže operacije
            return "Rezultat";
        }
    });
    // Dobijanje rezultata (blokirajuće)
    // String result = future.get();
    
  5. Kotlin Korutine: Savremeni pristup za asinhrono programiranje u Kotlinu, zasnovan na kooperacijama. Zahteva dodavanje zavisnosti.

    import kotlinx.coroutines.*
    
    // ... u okviru korutine (npr. viewModelScope)
    GlobalScope.launch(Dispatchers.IO) { // Izvršavanje u pozadinskom toku IO
        // Izvršavanje duže operacije
        withContext(Dispatchers.Main) { // Prebacivanje na glavni tok za ažuriranje UI
            // Ažuriranje UI
        }
    }
    

Izbor metode zavisi od složenosti zadatka, potrebnog nivoa kontrole nad nitima i preferencija jezika (Java/Kotlin). U savremenom Android razvoju preporučuje se korišćenje Kotlin Korutina ili biblioteka za asinhroni rad poput RxJava ili Flow.