DEV Community: Neeyat Lotlikar

Downloads Stalling? Not Anymore. Developing Retry Maniac for Chrome

Neeyat Lotlikar — Fri, 28 Nov 2025 17:44:13 +0000

I'm a Python developer who takes pride in writing code that's more readable and less ambiguous or failure prone. Therefore, it was a never-before seen adventure for me, a journey of treading unknown terrains of JavaScript to get this extension working.

Now, as for the motive that lead to this moment, I was downloading some large files from sites online as a part of my research, and I was disappointed to see that the native download manager wouldn't handle downloads for my use case right. I mean, due to server download speeds, my network's speeds, or whatever else, some of my downloads would stall, and I'd have to manually be there to resume them so they wouldn't give up on me. So, my eyes on the screen most of the time, or they would just fail, and some that wouldn't resume due to the link expiring, maybe. I'm left to now visit the website to get a new download link, some of the files I don't even know from where I started the download for due to ambiguous naming. From here, I knew I needed a manager which would resume my stalled downloads automatically and if they failed, it would retry them for me a couple of times just in case it failed due to a network error. That's how I came to the point of creating an extension of the browsers that would serve this specific use case.

From here on out, I'm going to try my best to describe to you how I made a tool that helped me solve this problem and how you could make a browser extension for yourself, too. I'll also share a link to my code down below so you can refer to the whole thing anytime you like.

To get started, under the root folder, a manifest.json file needs to be defined. Here, we define the permissions we need and tell the browser where all our code files are located. When we load our root folder as an unpackaged extension from the browser's extension page, this file will tell the browser what it needs to know to set things up correctly.

{
  "manifest_version": 3,
  "name": "Retry Maniac: Auto Resume Download",
  "version": "0.1",
  "description": "Automatically resumes interrupted downloads.",
  "permissions": [
    "downloads"
  ],
  "background": {
    "service_worker": "background/sw.js"
  },
  "action": {
    "default_popup": "popup/popup.html"
  },
  "icons": {
    "128": "assets/icon128.png"
  }
}

Under my root folder, I have created directories: popup (containing popup.html file), background (contains sw.js) and assets (carrying the extension's icon's PNG file). As for the permissions, I have added downloads as that's the whole point and notifications which I will generate for really important events.

When you click on the extension's icon, a popup page is displayed, the contents of which are defined in an HTML file. I have issued this page as an informative user description to describe the extension's use cases. The page can be extended further to incorporate dynamic features.

Now for the main event, the star of the show, our code goes in the service worker file, named sw.js, in my case. We define our event listeners here with an intention of overriding the default behavior. In my case, I intend to run my code for resuming an interrupted download.

chrome.downloads.onChanged.addListener(async (delta) => {
    if (!("state" in delta) && !("error" in delta)) return;

    console.log(`Delta: state=${delta.state?.current}, error=${delta.error?.current}`);

    if (delta.state?.current === "interrupted" || delta.error?.current === "NETWORK_FAILED") {
        const [download] = await chrome.downloads.search({ id: delta.id });
        if (!download) return;

        console.log(`Download interrupted: ${download.filename}`);
        await attemptResumeDownload(download);

    } else if (["complete", "cancelled"].includes(delta.state?.current) || delta.exists === false) {
        cleanup(delta.id);
    }
});

In the above snippet, I've added an OnChanged listener to run some code when the state of the download changes. I check here if the download is interrupted or network failed so that if it is, I can attempt to resume this download. I attempt to resume for a set number of tries (five) before finally retrying the download if that fails.

const MAX_RESUME_ATTEMPTS = 5;
const MAX_RETRIES = 3;
const NETWORK_PROBE_INTERVAL = 5000;

The constants initialized at the top of the file are used within the code to assess limits to the number of resumes and retries, and for network probe timeout interval.

async function isNetworkReachable() {
    return navigator.onLine;
}

async function waitForNetwork() {
    while (!(await isNetworkReachable())) {
        console.log(`Network offline, retrying in ${NETWORK_PROBE_INTERVAL}ms`);
        await new Promise(resolve => setTimeout(resolve, NETWORK_PROBE_INTERVAL));
    }
    console.log("Network back online");
}

function chromeDownloadsResumeAsync(downloadId) {
    return new Promise((resolve, reject) => {
        chrome.downloads.resume(downloadId, () => {
            chrome.runtime.lastError ? reject(chrome.runtime.lastError) : resolve();
        });
    });
}

/**
 * Attempt to resume a download if possible, otherwise escalate to retry.
 */
async function attemptResumeDownload(download) {
    if (!(await isNetworkReachable())) {
        console.log(`Network unreachable for ${download.filename}`);
        await waitForNetwork();
    }

    const attempts = (resumeAttempts.get(download.id) || 0) + 1;
    resumeAttempts.set(download.id, attempts);

    if (attempts > MAX_RESUME_ATTEMPTS) {
        console.warn(`Max resume attempts reached for ${download.filename}`);
        await retryDownload(download);
        return;
    }

    try {
        await chromeDownloadsResumeAsync(download.id);
        console.log(`Resumed ${download.filename} (ID: ${download.id}) [Attempt ${attempts}]`);
    } catch (err) {
        console.error(
            `Resume attempt #${attempts} failed for ${download.filename}: ${err.message}`
        );
        // Wait for network and try again unless we've already exhausted
        if (attempts < MAX_RESUME_ATTEMPTS) {
            await waitForNetwork();
            await attemptResumeDownload(download);
        } else {
            console.warn(`Exhausted resume attempts for ${download.filename}, escalating to retry`);
            await retryDownload(download);
        }
    }
}

I use chromium's navigator.onLine browser-native check to determine if the internet is connected or not. If offline, poll every 5 seconds until the network is online again. Once online, resume the download using Chrome’s native downloads.resume() method.

function cleanup(downloadId) {
    resumeAttempts.delete(downloadId);
    retryCounts.delete(downloadId);
    console.log(`Cleaned up state for download ID: ${downloadId}`);
}

So that no memory is occupied pointlessly, I do clear the counts stored in the global maps by using the cleanup function. It is called after a download is successfully completed or canceled to clear space.

/**
 * Attempt to retry by creating a new download, and reset resume count.
 */
async function retryDownload(download) {
    const retries = retryCounts.get(download.id) || 0;
    if (retries >= MAX_RETRIES || !download.url) {
        console.error(`Max retries reached for ${download.filename}`);
        cleanup(download.id);
        return;
    }

    const newRetryCount = retries + 1;

    chrome.downloads.download({
        url: download.url,
        filename: download.filename,
        conflictAction: "overwrite"
    }, newId => {
        if (newId) {
            // Transfer retry count to new download id
            retryCounts.set(newId, newRetryCount);
            retryCounts.delete(download.id);

            // Reset resume attempt count for the fresh download
            resumeAttempts.set(newId, 0);

            console.log(
                `Retry #${newRetryCount} started for ${download.filename}, new ID: ${newId}`
            );
        } else {
            // Retry creation failed — apply exponential backoff
            console.error(`Failed to create retry for ${download.filename}: ${chrome.runtime.lastError?.message}`);
            const delay = Math.min(1000 * (2 ** retries), 30000);
            setTimeout(() => retryDownload(download), delay);
        }
    });
}

Retries attempt a full retry of the download by overwriting or replacing any partial files. By the time I make this blog public, a lot of my code must have dramatically changed. I have documented it well with comments so you can understand if you browse through. Visit my GitHub repo if you want to see the full code.

Retry-Maniac@GitHub

In the future, I intend to store the retry counts persistently across extension reloads through chrome.storage.local usage. Also, implementation of notifications for important events in the download cycle will keep the user informed and make for a better UX.

While I was building this, I learnt that while AI tools make the development process fast, they might introduce unexpected behaviors in the code if you're not careful with the code that it produces. The developer needs to understand the code these assistants produce and make sure it aligns with the requirements of the project. That's just the basic stuff. Some AI generated code may be suboptimal, and it's the developer's responsibility to know when it is as such and make changes to it, accordingly. While it's fast, it may not be correct. AI models may overlook details, it's the developers who need to take care of such things.

I've tested my extension on my downloads and with a few exceptions, the majority of my downloads were completed unlike the last time, without an extension, where the opposite was true. That issue was due to the large number of download tasks running in parallel on the browser and the files also being quite large, but now, my extension saves me from such a mess repeating itself. I must say that now, I can safely leave my PC unattended to download my files knowing well that while download failures may occur due to circumstances that are out of our hands, most of my downloads will be successful because they at least won't stall to death. They will be revived by my extension through automatic resumes. Thank you for reading!

What technologies does the Amazon's Android Shopping App use?

Neeyat Lotlikar — Tue, 28 Jul 2020 13:23:23 +0000

I know that Amazon's Android App is a hybrid app but I wanted to know what exact technology it is built using. Just outta curiosity 🕵️, I tried running a web search but most of the posts on the web are about Amazon's Fire OS. Does anyone know what the Amazon shopping app is built on?

Using Kotlin Coroutines in Android

Neeyat Lotlikar — Wed, 10 Jun 2020 05:50:00 +0000

As we all developers know, conducting heavy processing tasks on the main/UI thread can make our applications lag. When this happens, the users become less patient, and eventually after a long exposure may decide to get rid of the app for good.

Previously, we used AsyncTask to deal with this problem but this approach did have some limitations. For instance, AsyncTask keeps running in the background even after the activity has finished and it has to be stopped manually, also any exceptions caused have to be handled manually, it was unstable, and it is also known to cause memory leaks to name a few. For these reasons, Google is deprecating the AsyncTask API in Android 11.

Now, with that being said, here's why Kotlin Coroutines are a great Alternative. Coroutines are easy to read and understand, they are lightweight, and many coroutines can be run together on the same thread and hence, avoids delays caused due to thread precedence in the processor.

In this post, I will show you how I use coroutines in an Android application development environment. I am in no way an expert but I am good at using them to serve the purpose of background processing. My goal is to covey how one can use coroutines instead of AsyncTask to accomplish the same jobs. So, let's begin!

To enable coroutines in Android, you must add the following dependencies in your build.gradle app module file.

build.gradle(app)

dependencies {
    // Other dependencies...
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.4"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.3"
    // Other dependencies...
}

Now, let's go through some basic coroutines terminology.

CoroutineScope - defines a scope in which new coroutines run
launch - a builder that creates and helps run coroutines
Dispatchers - they are values which can be used to switch between different kinds of coroutine contexts
There are three main types of coroutine contexts:

Dispatchers.IO - used to perform file IO and network calls
Dispatchers.Default - It can be used for performing heavy processing tasks in the background
Dispatchers.Main - is used to switch to the main context to perform UI related operations withContext - is used to switch between different coroutine contexts

Launch a new coroutine using the code:

CoroutineScope(Dispatchers.IO).launch {
    // Code performing IO and network operations
}

Here, a new coroutine with the IO context is created.

To switch to the main context:

withContext(Dispatchers.Main) {
    // Code to execute on the UI thread
}

In the above code, the withContext(Dispatchers.Main) block runs in the UI thread and you can update the UI in this thread. Trying to do so in IO or Default thread will give an error because Android does not support multithreaded UI. User interface changes can only be made in the thread so named.

I have created an app to download a web page. This app uses a function employing coroutines to do so and I will use it as a reference for explaining their use.

fun downloadWebPage(
        urlString: String, progressTextView: TextView, circularProgress: ProgressBar,
        fileName: String = "/storage/emulated/0/Download/download_${System.currentTimeMillis()}.html"
) {
    CoroutineScope(Dispatchers.IO).launch {
        try {
            // Create a URL object
            val url = URL(urlString)
            // Create a buffered reader object using the url object
            val reader = url.openStream().bufferedReader()

            // Enter filename in which you want to download
            val downloadFile = File(fileName).also { it.createNewFile() }
            // Create a buffered writer object for the file
            val writer = FileWriter(downloadFile).buffered()

            // read and write each line from the stream till the end
            var line: String
            while (reader.readLine().also { line = it?.toString() ?: "" } != null)
                writer.write(line)

            // Close all open streams
            reader.close()
            writer.close()

            // Update UI for download is successful
            withContext(Dispatchers.Main) {
                circularProgress.visibility = View.GONE
                progressTextView.apply {
                    text = context.getString(R.string.download_successful)
                    setTextColor(context.getColor(android.R.color.holo_green_light)
                }

                Snackbar.make(
                        progressTextView,
                        R.string.file_downloaded_successfully,
                        Snackbar.LENGTH_LONG
                ).setAction(R.string.view) {
                    it.context.startActivity(Intent.createChooser(
                            Intent(Intent.ACTION_VIEW).apply {
                                setDataAndType(downloadFile.toUri(),
                                        "text/plain")
                            },
                            progressTextView.context
                                    .getString(R.string.open_using)
                    ))
                }.show()
            }

        } catch (e: Exception) {
            // Update UI for download has failed
            withContext(Dispatchers.Main) {
                when (e) {
                    is MalformedURLException ->
                        Snackbar.make(
                            progressTextView,
                            R.string.malformed_url,
                            Snackbar.LENGTH_SHORT
                        ).show()
                    else ->
                        Snackbar.make(
                            progressTextView,
                            R.string.download_failed,
                            Snackbar.LENGTH_SHORT
                        ).show()
                }

                val incompleteFile = File(fileName)
                if (incompleteFile.exists()) incompleteFile.delete()

                circularProgress.visibility = View.GONE
                progressTextView.apply {
                    text = context.getString(R.string.download_failed)
                    setTextColor(context.getColor(android.R.color.holo_red_light))
                }

                e.printStackTrace()
            }
        }
    }
}

The code creates a buffered reader and a buffered file writer respectively. I'm using the while loop to read and write data to the file line-wise.

The UI is updated to show success when no exceptions are caught. Failure is discerned when an exception has occurred thereby interrupting the download. In this case, the UI is updated conveying the same and the incomplete file is deleted.

See the app working. UI is interactive.

Get the full app code here.

neeyatlotlikar / HTML-WebPage-Downloader

An application that downloads a web page given it's web address or it's URL.

HTML-WebPage-Downloader

An application which downloads a web page given it's web address or it's url.

It is a part of a tutorial showing how to use Kotlin Coroutines in Android.

Watch the app in action

Check out the tutorial article at https://dev.to/aurumtechie/using-kotlin-coroutines-in-android-31nh

View on GitHub

I hope this is helpful. Leave any comments and suggestions down below. Happy coding!

Implement Dark/Night Mode in an Android app with a ListPreference toggle

Neeyat Lotlikar — Wed, 13 May 2020 07:48:15 +0000

Cover Photo by Maxim Ilyahov on Unsplash

Hello, friends!

To introduce myself, I am Neeyat Lotlikar, an Android Developer. I am currently working on my portfolio and I'd like to share what I've learned recently while working on it. This is my first post so feel free to make any corrections and suggestions.

Without any further delay, let's get going!

The first step to enable dark mode is to change your app theme to Theme.AppCompat.DayNight or Theme.MaterialComponents.DayNight if you're using the Material Design library.

res/values/styles.xml

<style name="AppTheme" parent="Theme.AppCompat.DayNight">
    <item name="colorPrimary">@color/colorPrimary</item>
    <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
    <item name="colorAccent">@color/colorAccent</item>
</style>

Next, create a Preference activity.
This can be done with the help of the Android Studio templates with ease or you can even do it manually.

SettingsActivity.kt

class SettingsActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.settings_activity)
        supportFragmentManager
            .beginTransaction()
            .replace(R.id.settings, SettingsFragment())
            .commit()
    }

    class SettingsFragment : PreferenceFragmentCompat() {
        override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
            setPreferencesFromResource(R.xml.root_preferences, rootKey)
        }
    }
}

We want a ListPreference in our root_prefernces.xml file and so it should look something like this:

res/values/xml/root_preferences.xml

<PreferenceScreen xmlns:app="http://schemas.android.com/apk/res-auto">

    <PreferenceCategory app:title="@string/ui">

        <ListPreference
            app:defaultValue="@string/dark_mode_def_value"
            app:entries="@array/dark_mode_entries"
            app:entryValues="@array/dark_mode_values"
            app:key="@string/dark_mode"
            app:title="@string/dark_mode" />

    </PreferenceCategory>

</PreferenceScreen>

Here, the app:defaultValue is used to set a default value which is stored in strings.xml. The app:title and app:key attribute values specify the display title of the preference and the key to identify it by respectively.

res/values/strings.xml

<resources>
    <!-- Preference Titles -->
    <string name="ui">UI</string>
    <string name="dark_mode">Dark Mode</string>
    <string name="dark_mode_def_value">MODE_NIGHT_FOLLOW_SYSTEM</string>
</resources>

app:entries and app:entryValues attributes take array values that specify the corresponding display name and the value it carries so make sure they are in the proper order. I have added my arrays to arrays.xml as below:

res/values/arrays.xml

<resources>
    <!-- Dark Mode ListPreference -->
    <string-array name="dark_mode_entries">
        <item>Follow System Dark Mode</item>
        <item>Light Mode Selected</item>
        <item>Dark Mode Selected</item>
        <item>Auto Battery Dark Mode</item>
    </string-array>

    <string-array name="dark_mode_values">
        <item>MODE_NIGHT_FOLLOW_SYSTEM</item>
        <item>MODE_NIGHT_NO</item>
        <item>MODE_NIGHT_YES</item>
        <item>MODE_NIGHT_AUTO_BATTERY</item>
    </string-array>

</resources>

Now that we are done with the layout, let's look at the code.

The AppCompatDelegate class' setDefaultNightMode() function is used to change the night mode settings. Following values can be passed to this method:
AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM - This will toggle the night mode based on whether the system-wide dark mode is enabled or not.
AppCompatDelegate.MODE_NIGHT_NO - Light mode will be enabled.
AppCompatDelegate.MODE_NIGHT_YES - Dark/Night mode will be enabled.
AppCompatDelegate.MODE_NIGHT_AUTO_BATTERY - Dark/Night mode will be enabled when the device is on the battery saving mode.

So where do we use this method?
Implement SharedPreferences.OnSharedPreferenceChangeListener in SettingsActivity and override the onSharedPreferenceChanged() function.

SettingsActivity.kt

override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences?, key: String?) {
        val darkModeString = getString(R.string.dark_mode)
        key?.let {
            if (it == darkModeString) sharedPreferences?.let { pref ->
                val darkModeValues = resources.getStringArray(R.array.dark_mode_values)
                when (pref.getString(darkModeString, darkModeValues[0])) {
                    darkModeValues[0] -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM)
                    darkModeValues[1] -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
                    darkModeValues[2] -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
                    darkModeValues[3] -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_AUTO_BATTERY)
                }
            }
        }
    }

As you can see, I retrieve the preference in the above code and use it to determine which option is selected in the list preference. Using this, the night mode settings are changed.

Now, a very important thing to do is registering and unregistering the OnSharedPreferenceChangeListener. This will ensure that the changes are made almost instantly on user input and it also prevents memory leakage.
Register the listener in the onCreate() function and unregister it in the onDestroy() function.

SettingsActivity.kt

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.settings_activity)
    supportFragmentManager
        .beginTransaction()
        .replace(R.id.settings, SettingsFragment())
        .commit()
    supportActionBar?.setDisplayHomeAsUpEnabled(true)

    PreferenceManager.getDefaultSharedPreferences(this)
        .registerOnSharedPreferenceChangeListener(this)
}

override fun onDestroy() {
    super.onDestroy()
    PreferenceManager.getDefaultSharedPreferences(this)
        .unregisterOnSharedPreferenceChangeListener(this)
}

Now, a provision has to be made to make navigation to the SettingsActivity possible which I did by adding an action to the options menu. You can use whatever works best for you.

It is possible to add separate icons, colors, styles, and other resources to be used in the day and the night mode. You do so by adding these resources in resource folders with the extension of -night. For example, drawable-night or values-night.

And with this, we've successfully got our dark mode toggle working.

There's a problem, however. As you can see, the ListPreference doesn't show which option is currently selected in the summary. How do we fix that? Well, that's very simple actually. There are just two things that need to be done here:
Firstly, set app:useSimpleSummaryProvider attribute value to true in ListPreference.

res/xml/root_preferences.xml

<ListPreference
    app:defaultValue="@string/dark_mode_def_value"
    app:entries="@array/dark_mode_entries"
    app:entryValues="@array/dark_mode_values"
    app:key="@string/dark_mode"
    app:title="@string/dark_mode"
    app:useSimpleSummaryProvider="true" />

Secondly, implement the Preference.SummaryProvider<ListPreference> interface in SettingsActivity and override it's provideSummary() function.

SettingsActivity.kt

override fun provideSummary(preference: ListPreference?): CharSequence =
        if (preference?.key == getString(R.string.dark_mode)) preference.entry
        else "Unknown Preference"

Note that I am using androidx.preference.Preference. SummaryProvider is not available in android.preference.Preference i.e. the android package.

And with this, this tutorial is completed.
Check out the full code on my GitHub here:

neeyatlotlikar / DarkModePreferencesTutorial

A tutorial app as a guide for implementing Night/Dark Mode using ListPreference in Android.

DarkModePreferencesTutorial

A tutorial app as a guide for implementing Night/Dark Mode using ListPreference in Android.

This tutorial blog teaches how to change the app theme using the androidx.appcompat.app.AppCompatDelegate class. It also teaches how to use ListPreference from the androidx.preference package to create a switch in the in-app settings (activity) to allow the user to choose the setting that she/he prefers.

Watch the app in action

See the full tutorial blog post: https://dev.to/aurumtechie/implement-dark-night-mode-in-an-android-app-with-a-listpreference-toggle-2k5i

This is the Kotlin implementation of this app. For it's java version, visit: https://github.com/Aurum1611/DarkModePreferenceTutorialJava

View on GitHub

Upon request, I've created a Java counterpart for the project:

neeyatlotlikar
/
DarkModePreferenceTutorialJava

Part of a tutorial that shows how to create Dark Mode in Android. This project is written in Java and is a counterpart to DarkModePreferenceTutorial, the Kotlin version.

DarkModePreferenceTutorialJava

A tutorial app as a guide for implementing Night/Dark Mode using ListPreference in Android.

Watch the app in action

See the full tutorial blog post: https://dev.to/aurumtechie/implement-dark-night-mode-in-an-android-app-with-a-listpreference-toggle-2k5i

This is the Java implementation of this app. For it's Kotlin version, visit: https://github.com/Aurum1611/DarkModePreferencesTutorial

View on GitHub

I hope this is helpful. Happy coding!

DEV Community: Neeyat Lotlikar

Downloads Stalling? Not Anymore. Developing Retry Maniac for Chrome

What technologies does the Amazon's Android Shopping App use?

Using Kotlin Coroutines in Android

neeyatlotlikar / HTML-WebPage-Downloader

An application that downloads a web page given it's web address or it's URL.

HTML-WebPage-Downloader

Implement Dark/Night Mode in an Android app with a ListPreference toggle

neeyatlotlikar / DarkModePreferencesTutorial

A tutorial app as a guide for implementing Night/Dark Mode using ListPreference in Android.

DarkModePreferencesTutorial

neeyatlotlikar / DarkModePreferenceTutorialJava

Part of a tutorial that shows how to create Dark Mode in Android. This project is written in Java and is a counterpart to DarkModePreferenceTutorial, the Kotlin version.

DarkModePreferenceTutorialJava

neeyatlotlikar
/
DarkModePreferenceTutorialJava