How to Fix ‘android.os.NetworkOnMainThreadException’ in Android: A Complete Guide

Encountering the android.os.NetworkOnMainThreadException error in your Android app? This common issue occurs when you attempt to perform network operations on the main UI thread, which Android strictly prohibits to ensure smooth user experiences. In this guide, we’ll explain why this error happens and provide step-by-step solutions to resolve it using modern best practices.

Why Does NetworkOnMainThreadException Occur?

Android enforces a policy where long-running operations (like network calls, file I/O, or database queries) cannot run on the main thread. Blocking the main thread can cause app freezes, leading to poor user experiences or even “Application Not Responding” (ANR) errors.

In your code, the line url.openStream() triggers this exception because it executes a network request on the main thread.

How to Fix NetworkOnMainThreadException

Here are four effective solutions to resolve this error while maintaining app responsiveness.

1. Use Kotlin Coroutines (Recommended for Modern Apps)

For projects using Kotlin, coroutines provide a clean way to handle background tasks without blocking the UI.

Step 1: Add Dependencies

In build.gradle:

dependencies {
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.0'
}

Step 2: Launch a Coroutine

lifecycleScope.launch {
    try {
        val feed = withContext(Dispatchers.IO) {
            fetchRssFeed(urlToRssFeed)
        }
        // Update UI with feed
    } catch (e: Exception) {
        // Handle error
    }
}

private suspend fun fetchRssFeed(url: String): RSSFeed {
    val url = URL(url)
    val factory = SAXParserFactory.newInstance()
    val parser = factory.newSAXParser()
    val xmlReader = parser.xmlReader
    val handler = RssHandler()
    xmlReader.contentHandler = handler
    InputSource(url.openStream()).use { source ->
        xmlReader.parse(source)
    }
    return handler.getFeed()
}

Pros:

• Lightweight and easy to read.
• Automatically manages threading.

2. Use Executors (Java)

For Java projects, ExecutorService offers fine control over background threads.

ExecutorService executor = Executors.newSingleThreadExecutor();
executor.execute(() -> {
    try {
        URL url = new URL(urlToRssFeed);
        SAXParserFactory factory = SAXParserFactory.newInstance();
        SAXParser parser = factory.newSAXParser();
        XMLReader xmlReader = parser.getXMLReader();
        RssHandler handler = new RssHandler();
        xmlReader.setContentHandler(handler);
        InputSource is = new InputSource(url.openStream());
        xmlReader.parse(is);
        RSSFeed feed = handler.getFeed();
        
        // Update UI on the main thread
        runOnUiThread(() -> {
            // Use feed to update UI
        });
    } catch (Exception e) {
        e.printStackTrace();
    }
});

Pros:

• Flexible thread management.
• Avoids deprecated APIs like AsyncTask.

3. Use WorkManager (For Background Tasks)

WorkManager handles persistent background tasks, even if the app exits.

Step 1: Define a Worker

public class RssWorker extends Worker {
    public RssWorker(@NonNull Context context, @NonNull WorkerParameters params) {
        super(context, params);
    }

    @NonNull
    @Override
    public Result doWork() {
        try {
            String url = getInputData().getString("url");
            // Fetch RSS feed here
            return Result.success();
        } catch (Exception e) {
            return Result.failure();
        }
    }
}

Step 2: Schedule the Work

WorkRequest request = new OneTimeWorkRequest.Builder(RssWorker.class)
        .setInputData(new Data.Builder().putString("url", urlToRssFeed).build())
        .build();
WorkManager.getInstance(context).enqueue(request);

Pros:

• Guarantees task execution.
• Compatible with Android’s battery optimizations.

4. Avoid Quick Fixes: Why Disabling StrictMode Is a Bad Idea

Some solutions suggest bypassing the error by disabling StrictMode:

StrictMode.ThreadPolicy policy = new StrictMode.ThreadPolicy.Builder().permitAll().build();
StrictMode.setThreadPolicy(policy);

Do not do this! This hides the problem and risks app crashes or ANRs. Always offload network calls to background threads.

Common Pitfalls & Best Practices

1. Add Internet Permission: Ensure your AndroidManifest.xml includes: <uses-permission android:name="android.permission.INTERNET" />
2. Update UI Safely: Use runOnUiThread() or LiveData to modify UI elements after background work.
3. Handle Exceptions: Always catch network errors to prevent crashes.

FAQs

Why is AsyncTask deprecated?

AsyncTask was deprecated in Android 11 (API 30) due to memory leaks and inconsistent behavior across OS versions. Use coroutines or Executors instead.

Can I use RxJava for this?

Yes! RxJava’s Schedulers.io() is excellent for offloading tasks:

Observable.fromCallable(() -> fetchRssFeed(url))
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(feed -> { /* Update UI */ });

Conclusion

To fix NetworkOnMainThreadException, always perform network operations off the main thread. For modern apps, Kotlin coroutines or WorkManager are ideal. Java projects can use ExecutorService or RxJava. Avoid deprecated APIs like AsyncTask and never disable StrictMode.

By following these solutions, you’ll ensure your app remains responsive, stable, and compliant with Android’s best practices.