Fill I2PTunnel list with a Loader

Until changes to the list of TunnelControllers can be monitored, the Loader
refreshes the view every 10 seconds.

src/net/i2p/android/router/fragment/I2PTunnelFragment.java

 package net.i2p.android.router.fragment;
 
-import java.util.ArrayList;
 import java.util.List;
 
 import net.i2p.android.router.R;
 import net.i2p.android.router.adapter.TunnelControllerAdapter;
+import net.i2p.android.router.loader.TunnelControllerLoader;
 import net.i2p.i2ptunnel.TunnelController;
 import net.i2p.i2ptunnel.TunnelControllerGroup;
 import android.os.Bundle;
 import android.support.v4.app.ListFragment;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.Loader;
 import android.view.Menu;
 import android.view.MenuInflater;
 import android.view.MenuItem;
 
-public class I2PTunnelFragment extends ListFragment {
+public class I2PTunnelFragment extends ListFragment
+        implements LoaderManager.LoaderCallbacks<List<TunnelController>> {
     public static final String SHOW_CLIENT_TUNNELS = "show_client_tunnels";
 
+    private static final int CLIENT_LOADER_ID = 1;
+    private static final int SERVER_LOADER_ID = 2;
+
     private TunnelControllerGroup mGroup;
     private TunnelControllerAdapter mAdapter;
+    private boolean mClientTunnels;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
@@ -29,6 +36,7 @@ public class I2PTunnelFragment extends ListFragment {
     public void onActivityCreated(Bundle savedInstanceState) {
         super.onActivityCreated(savedInstanceState);
         mAdapter = new TunnelControllerAdapter(getActivity());
+        mClientTunnels = getArguments().getBoolean(SHOW_CLIENT_TUNNELS);
 
         String error;
         try {
@@ -39,36 +47,45 @@ public class I2PTunnelFragment extends ListFragment {
             error = iae.toString();
         }
 
-        boolean clientTunnels = getArguments().getBoolean(SHOW_CLIENT_TUNNELS);
         if (mGroup == null) {
             setEmptyText(error);
         } else {
-            if (clientTunnels)
+            if (mClientTunnels)
                 setEmptyText("No configured client tunnels.");
             else
                 setEmptyText("No configured server tunnels.");
         }
-        mAdapter.setData(getControllers(clientTunnels));
+
         setListAdapter(mAdapter);
+        setListShown(false);
+
+        getLoaderManager().initLoader(mClientTunnels ? CLIENT_LOADER_ID
+                : SERVER_LOADER_ID, null, this);
+    }
+
+    public Loader<List<TunnelController>> onCreateLoader(int id, Bundle args) {
+        return new TunnelControllerLoader(getActivity(), mGroup, mClientTunnels);
     }
 
-    private List<TunnelController> getControllers(boolean clientTunnels) {
-        List<TunnelController> ret = new ArrayList<TunnelController>();
-        for (TunnelController controller : mGroup.getControllers())
-            if ( (clientTunnels && isClient(controller.getType())) ||
-                 (!clientTunnels && !isClient(controller.getType())) )
-                ret.add(controller);
-        return ret;
+    public void onLoadFinished(Loader<List<TunnelController>> loader,
+            List<TunnelController> data) {
+        if (loader.getId() == (mClientTunnels ?
+                CLIENT_LOADER_ID : SERVER_LOADER_ID)) {
+            mAdapter.setData(data);
+
+            if (isResumed()) {
+                setListShown(true);
+            } else {
+                setListShownNoAnimation(true);
+            }
+        }
     }
 
-    private static boolean isClient(String type) {
-        return ( ("client".equals(type)) ||
-                 ("httpclient".equals(type)) ||
-                 ("sockstunnel".equals(type)) ||
-                 ("socksirctunnel".equals(type)) ||
-                 ("connectclient".equals(type)) ||
-                 ("streamrclient".equals(type)) ||
-                 ("ircclient".equals(type)));
+    public void onLoaderReset(Loader<List<TunnelController>> loader) {
+        if (loader.getId() == (mClientTunnels ?
+                CLIENT_LOADER_ID : SERVER_LOADER_ID)) {
+            mAdapter.setData(null);
+        }
     }
 
     @Override

src/net/i2p/android/router/loader/TunnelControllerLoader.java

+package net.i2p.android.router.loader;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.i2p.i2ptunnel.TunnelController;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+
+import android.content.Context;
+import android.os.Handler;
+import android.support.v4.content.AsyncTaskLoader;
+
+public class TunnelControllerLoader extends AsyncTaskLoader<List<TunnelController>> {
+    private TunnelControllerGroup mGroup;
+    private boolean mClientTunnels;
+    private List<TunnelController> mData;
+    private Handler mHandler;
+    private TunnelControllerMonitor mMonitor;
+
+    public TunnelControllerLoader(Context context, TunnelControllerGroup tcg, boolean clientTunnels) {
+        super(context);
+        mGroup = tcg;
+        mClientTunnels = clientTunnels;
+        mHandler = new Handler();
+    }
+
+    @Override
+    public List<TunnelController> loadInBackground() {
+        List<TunnelController> ret = new ArrayList<TunnelController>();
+        for (TunnelController controller : mGroup.getControllers())
+            if ( (mClientTunnels && isClient(controller.getType())) ||
+                 (!mClientTunnels && !isClient(controller.getType())) )
+                ret.add(controller);
+        return ret;
+    }
+
+    private static boolean isClient(String type) {
+        return ( ("client".equals(type)) ||
+                 ("httpclient".equals(type)) ||
+                 ("sockstunnel".equals(type)) ||
+                 ("socksirctunnel".equals(type)) ||
+                 ("connectclient".equals(type)) ||
+                 ("streamrclient".equals(type)) ||
+                 ("ircclient".equals(type)));
+    }
+
+    @Override
+    public void deliverResult(List<TunnelController> data) {
+        if (isReset()) {
+            // The Loader has been reset; ignore the result and invalidate the data.
+            if (data != null) {
+                releaseResources(data);
+                return;
+            }
+        }
+
+        // Hold a reference to the old data so it doesn't get garbage collected.
+        // We must protect it until the new data has been delivered.
+        List<TunnelController> oldData = mData;
+        mData = data;
+
+        if (isStarted()) {
+            // If the Loader is in a started state, have the superclass deliver the
+            // results to the client.
+            super.deliverResult(data);
+        }
+
+        // Invalidate the old data as we don't need it any more.
+        if (oldData != null && oldData != data) {
+            releaseResources(oldData);
+        }
+    }
+
+    @Override
+    protected void onStartLoading() {
+        if (mData != null) {
+            // Deliver any previously loaded data immediately.
+            deliverResult(mData);
+        }
+
+        // Begin monitoring the underlying data source.
+        mMonitor = new TunnelControllerMonitor();
+        mHandler.postDelayed(mMonitor, 50);
+
+        if (takeContentChanged() || mData == null) {
+            // When the observer detects a change, it should call onContentChanged()
+            // on the Loader, which will cause the next call to takeContentChanged()
+            // to return true. If this is ever the case (or if the current data is
+            // null), we force a new load.
+            forceLoad();
+        }
+    }
+
+    @Override
+    protected void onStopLoading() {
+        // The Loader is in a stopped state, so we should attempt to cancel the 
+        // current load (if there is one).
+        cancelLoad();
+
+        // Note that we leave the observer as is. Loaders in a stopped state
+        // should still monitor the data source for changes so that the Loader
+        // will know to force a new load if it is ever started again.
+    }
+
+    @Override
+    protected void onReset() {
+        // Ensure the loader has been stopped.
+        onStopLoading();
+
+        // At this point we can release the resources associated with 'mData'.
+        if (mData != null) {
+            releaseResources(mData);
+            mData = null;
+        }
+
+        // The Loader is being reset, so we should stop monitoring for changes.
+        if (mMonitor != null) {
+            mHandler.removeCallbacks(mMonitor);
+            mMonitor = null;
+        }
+    }
+
+    @Override
+    public void onCanceled(List<TunnelController> data) {
+        // Attempt to cancel the current asynchronous load.
+        super.onCanceled(data);
+
+        // The load has been canceled, so we should release the resources
+        // associated with 'data'.
+        releaseResources(data);
+    }
+
+    private void releaseResources(List<TunnelController> data) {
+        // For a simple List, there is nothing to do. For something like a Cursor, we 
+        // would close it in this method. All resources associated with the Loader
+        // should be released here.
+    }
+
+    private class TunnelControllerMonitor implements Runnable {
+        public void run() {
+            // There is no way (yet) to monitor for changes to the list of
+            // TunnelControllers, so just force a refresh every 10 seconds.
+            onContentChanged();
+            mHandler.postDelayed(this, 10 * 1000);
+        }
+    }
+}