Question

I need to download thousands of objects. I need to be able to pause and resume downloads and to display the progress. I’m not good in multithreading, so I’ve compiled my code from different sources (I’ve simplified maths and UI but left logic intact):

public class DownloadActivity extends Activity {
    private static final int MSG_FINISH = 1;
    private static final int MSG_PROGRESS = 2;

    private long total;
    private ProgressBar progress;

    private static DownloadThread thread;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.download);

        progress = (ProgressBar) findViewById(R.id.progress);

        total = 10000;
        progress.setMax((int) total);

        if (thread == null)
            thread = new DownloadThread(progressHandler, 15000, 25000);
        else
            thread.setHandler(progressHandler);

        ((Button) findViewById(R.id.start_button)).setEnabled(thread.paused());
        ((Button) findViewById(R.id.pause_button)).setEnabled(! thread.paused());

        ((Button) findViewById(R.id.start_button)).setOnClickListener(startOnClickListener);
        ((Button) findViewById(R.id.pause_button)).setOnClickListener(pauseOnClickListener);
    }

    @Override
    public void onBackPressed()
    {
        thread.pause();
        thread = null;
        super.onBackPressed();
    }

    private OnClickListener startOnClickListener = new OnClickListener() {
        public void onClick(View v) {
            ((Button) findViewById(R.id.start_button)).setEnabled(false);
            thread.unpause();
            ((Button) findViewById(R.id.pause_button)).setEnabled(true);
        }
    };

    private OnClickListener pauseOnClickListener = new OnClickListener() {
        public void onClick(View v) {
            ((Button) findViewById(R.id.pause_button)).setEnabled(false);
            thread.pause();
            ((Button) findViewById(R.id.start_button)).setEnabled(true);
        }
    };

    final Handler progressHandler = new Handler() {
        public void handleMessage(Message msg)
        {
            switch (msg.what)
            {
                case MSG_PROGRESS:
                    if (progress != null)
                    {
                        long current = msg.getData().getLong("current");
                        progress.setProgress((int) current);
                    }
                    break;
                case MSG_FINISH:
                    Button pause = ((Button) findViewById(R.id.pause_button));
                    if (pause != null)
                        pause.setEnabled(false);
                    break;
            }
        }
    };

    private class DownloadThread extends Thread
    {
        Handler handler;
        long current;
        long x;
        long x2;
        LinkedList<Long> pendingList;
        Thread threadA;
        Thread threadB;
        Thread threadC;
        Thread threadD;

        boolean paused = true;

        DownloadThread(Handler h, long x1, long x2)
        {
            current = 0;
            this.x = x1;
            this.x2 = x2;

            pendingList = new LinkedList<Long>();
            handler = h;
            threadA = new Thread(this);
            threadA.start();
            threadB = new Thread(this);
            threadB.start();
            threadC = new Thread(this);
            threadC.start();
            threadD = new Thread(this);
            threadD.start();
        }

        public void run()
        {
            while (! isInterrupted())
            {
                synchronized (this)
                {
                    if (paused)
                    {
                        try {
                            wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        continue;
                    }
                }
                Long l;
                synchronized (pendingList)
                {
                    if (pendingList.size() == 0)
                    {
                        x++;
                        if (x > x2)
                        {
                            continue;
                        }
                        l = new Long(x);
                        pendingList.add(l);
                        synchronized (this)
                        {
                            notifyAll();
                        }
                        continue;
                    }
                    else
                    {
                        l = pendingList.poll();
                        if (l == null)
                        {
                            synchronized (this)
                            {
                                try {
                                    wait();
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                            continue;
                        }
                    }
                }
                Object d = DownloadFactory.download(l);
                if (d != null)
                {
                    synchronized (DownloadActivity.this)
                    {
                        current++;
                        sendProgress();
                    }
                }
                else
                {
                    synchronized (pendingList)
                    {
                        pendingList.add(l);
                    }                   
                }
            }
        }

        public void interrupt()
        {
            threadA.interrupt();
            threadB.interrupt();
            threadC.interrupt();
            threadD.interrupt();
        }

        public synchronized boolean paused()
        {
            return paused;
        }

        public synchronized void pause()
        {
            paused = true;
        }

        public synchronized void unpause()
        {
            sendProgress();
            paused = false;
            notifyAll();
        }

        public synchronized void setHandler(Handler h)
        {
            handler = h;
            sendProgress();
        }

        private void sendProgress()
        {
            Message msg = handler.obtainMessage(MSG_PROGRESS);
            Bundle b = new Bundle();
            b.putLong("current", current);
            msg.setData(b);
            handler.sendMessage(msg);
            if (current == total)
                handler.sendEmptyMessage(MSG_FINISH);
        }
    }
}

This code works fine and does everything I want but I understand that it is ugly and not correct (at least in putting nesting threads). So what is the nice and androidish way to accomplish the same task?

Answer 1

Ok I am not a concurrency professional but using a Thread which contains 4 other threads, too, sounds pretty evil 🙂

If you just want to make a download manager this is way beyond necessary work. If you use API 9 or above, check the DownloadManager.

Otherwise I recommend to use a simple Manager class that contains a queue and handles the add/remove and start/restart/stop of the downloads. If the queue has an element, I would start a AsyncTask which downloads the element and removes it from the queue if successfully downloaded. If not it tries to resume.