Asynchronous Tasks

fun onClick(v: View?) {
  Thread {
    val bitmap: Bitmap = loadImageFromNetwork("http://example.com/image.png")
    mImageView.post(Runnable { mImageView.setImageBitmap(bitmap) })
  }.start()
}

implementation("androidx.loader:loader:1.1.0")

import android.os.Bundle;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.app.AppCompatActivity;
import androidx.loader.app.LoaderManager;
import androidx.loader.content.Loader;

class MainActivity : AppCompatActivity(), LoaderManager.LoaderCallbacks<String?> {
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val loader: Loader<String?> = supportLoaderManager.initLoader(LOADER_ID, null, this)
    if (loader != null) {
      loader.forceLoad()
    }
  }

  override fun onCreateLoader(id: Int, @Nullable args: Bundle?): Loader<String> {
    return MyDataLoader(this@MainActivity)
  }

  override fun onLoadFinished(loader: Loader<String?>, data: String?) {
    val textView = findViewById<TextView>(R.id.myTextView)
    textView.text = data
  }

  override fun onLoaderReset(loader: Loader<String?>) {
    val textView = findViewById<TextView>(R.id.myTextView)
    textView.text = ""
  }

  companion object {
    private const val LOADER_ID = 42
  }
}

import android.content.Context;
import android.os.SystemClock;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.loader.content.AsyncTaskLoader;

class MyDataLoader(context: Context) :
  AsyncTaskLoader<String?>(context) {
  override fun loadInBackground(): String? {
    //do your long running task here
    SystemClock.sleep(2000)
    return "My loaded data"
  }
}

dependencies {
    def work_version = "2.7.1"

    // (Java only)
    implementation "androidx.work:work-runtime:$work_version"

    // optional - Test helpers
    androidTestImplementation "androidx.work:work-testing:$work_version"

    // optional - Multiprocess support
    implementation "androidx.work:work-multiprocess:$work_version"
}

Constraints constraints = new Constraints.Builder()

    // require to be connected to a WiFi
    .setRequiredNetworkType(NetworkType.UNMETERED)

    // require to be in charging mode
    .setRequiresCharging(true)

    .build();

WorkRequest myWorkRequest = OneTimeWorkRequest.from(MyWork.class);

// or for complex work
WorkRequest uploadWorkRequest = new OneTimeWorkRequest.Builder(MyWork.class)
    // Additional configuration like constraints and retry policies
    .build();

WorkRequest myWorkRequest = new OneTimeWorkRequest.Builder(MyWork.class)
    .setBackoffCriteria(
        BackoffPolicy.LINEAR,
        OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
        TimeUnit.MILLISECONDS
    ).build();

public class WeatherDataWorker extends Worker {
    
  public static final String KEY_LATITUDE = "lat";
  public static final String KEY_LONGITUDE = "long";

  private final Double latitude;
  private final Double longitude;

  public WeatherDataWorker(
          @NonNull Context context,
          @NonNull WorkerParameters params
  ) {
    super(context, params);

    // Get data from params
    latitude = params.getInputData().getDouble(KEY_LATITUDE, 0.0);
    longitude = params.getInputData().getDouble(KEY_LONGITUDE, 0.0);
    
    // Optionally check if data is valid
    // ...
  }

  @Override
  public Result doWork() {

    // Do the work here, e.g. fetch weather data
    try {
      Map<String, Object> weatherData = getWeatherData(latitude, longitude);

      if (weatherData == null) {
        // Weather data could not be fetched, retry
        return Result.retry();
      }

      // Prepare data result (limited to 10KB)
      Data data = new Data.Builder()
              .putAll(weatherData)
              .build();

      // Weather data fetched successfully.
      return Result.success(data);
    } catch (Exception exception) {
      // Some error occurred, abort
      return Result.failure();
    }
  }
  
  // ...
}

// method in activity class
private void loadWeatherData(Double latitude, Double longitude) {

    // Prepare input data
    Data inputData = new Data.Builder()
            .putDouble(KEY_LATITUDE, latitude)
            .putDouble(KEY_LONGITUDE, longitude)
            .build();

    // Define Constraints (require network connectivity)
    Constraints constraints = new Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .build();

    // Create work request
    WorkRequest weatherWorkRequest = new OneTimeWorkRequest.Builder(WeatherDataWorker.class)
            .setInputData(inputData)
            .setConstraints(constraints)
            .setBackoffCriteria(
                    BackoffPolicy.LINEAR,
                    OneTimeWorkRequest.MIN_BACKOFF_MILLIS,
                    TimeUnit.MILLISECONDS)
            .build();

    // Get WorkManager
    WorkManager workManager = WorkManager.getInstance(this);
            
    // Enqueue request and get result
    workManager.enqueue(weatherWorkRequest);

    // Listen with live data to result (listening should happen in ViewModel)
    workManager.getWorkInfoByIdLiveData(weatherWorkRequest.getId())
            .observe(this, info -> {
                if (info != null && info.getState().isFinished()) {
                    // Result data is stored in info.getOutputData()
                }
            });
}