Path refactoring

Also fixed an issue with View recycling

MinimalBible/src/main/java/com/todddavies/components/progressbar/ProgressWheel.java

@@ -0,0 +1,530 @@
+package com.todddavies.components.progressbar;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.Paint.Style;
+import android.graphics.RectF;
+import android.graphics.Shader;
+import android.os.Handler;
+import android.os.Message;
+import android.util.AttributeSet;
+import android.view.View;
+
+import org.bspeice.minimalbible.R;
+
+
+/**
+ * An indicator of progress, similar to Android's ProgressBar.
+ * Can be used in 'spin mode' or 'increment mode'
+ *
+ * @author Todd Davies
+ *         <p/>
+ *         Licensed under the Creative Commons Attribution 3.0 license see:
+ *         http://creativecommons.org/licenses/by/3.0/
+ */
+public class ProgressWheel extends View {
+
+    //Sizes (with defaults)
+    private int layout_height = 0;
+    private int layout_width = 0;
+    private int fullRadius = 100;
+    private int circleRadius = 80;
+    private int barLength = 60;
+    private int barWidth = 20;
+    private int rimWidth = 20;
+    private int textSize = 20;
+    private float contourSize = 0;
+
+    //Padding (with defaults)
+    private int paddingTop = 5;
+    private int paddingBottom = 5;
+    private int paddingLeft = 5;
+    private int paddingRight = 5;
+
+    //Colors (with defaults)
+    private int barColor = 0xAA000000;
+    private int contourColor = 0xAA000000;
+    private int circleColor = 0x00000000;
+    private int rimColor = 0xAADDDDDD;
+    private int textColor = 0xFF000000;
+
+    //Paints
+    private Paint barPaint = new Paint();
+    private Paint circlePaint = new Paint();
+    private Paint rimPaint = new Paint();
+    private Paint textPaint = new Paint();
+    private Paint contourPaint = new Paint();
+
+    //Rectangles
+    @SuppressWarnings("unused")
+    private RectF rectBounds = new RectF();
+    private RectF circleBounds = new RectF();
+    private RectF circleOuterContour = new RectF();
+    private RectF circleInnerContour = new RectF();
+
+    //Animation
+    //The amount of pixels to move the bar by on each draw
+    private int spinSpeed = 2;
+    //The number of milliseconds to wait inbetween each draw
+    private int delayMillis = 0;
+    private Handler spinHandler = new Handler() {
+        /**
+         * This is the code that will increment the progress variable
+         * and so spin the wheel
+         */
+        @Override
+        public void handleMessage(Message msg) {
+            invalidate();
+            if (isSpinning) {
+                progress += spinSpeed;
+                if (progress > 360) {
+                    progress = 0;
+                }
+                spinHandler.sendEmptyMessageDelayed(0, delayMillis);
+            }
+            //super.handleMessage(msg);
+        }
+    };
+    int progress = 0;
+    boolean isSpinning = false;
+
+    //Other
+    private String text = "";
+    private String[] splitText = {};
+
+    /**
+     * The constructor for the ProgressWheel
+     *
+     * @param context
+     * @param attrs
+     */
+    public ProgressWheel(Context context, AttributeSet attrs) {
+        super(context, attrs);
+
+        parseAttributes(context.obtainStyledAttributes(attrs,
+                R.styleable.ProgressWheel));
+    }
+
+    //----------------------------------
+    //Setting up stuff
+    //----------------------------------
+
+    /*
+     * When this is called, make the view square.
+     * From: http://www.jayway.com/2012/12/12/creating-custom-android-views-part-4-measuring-and-how-to-force-a-view-to-be-square/
+     * 
+     */
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+    	// The first thing that happen is that we call the superclass 
+    	// implementation of onMeasure. The reason for that is that measuring 
+    	// can be quite a complex process and calling the super method is a 
+    	// convenient way to get most of this complexity handled.
+    	super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+
+    	// We can’t use getWidth() or getHight() here. During the measuring 
+    	// pass the view has not gotten its final size yet (this happens first 
+    	// at the start of the layout pass) so we have to use getMeasuredWidth() 
+    	// and getMeasuredHeight().
+        int size = 0;
+        int width = getMeasuredWidth();
+        int height = getMeasuredHeight();
+        int widthWithoutPadding = width - getPaddingLeft() - getPaddingRight();
+        int heigthWithoutPadding = height - getPaddingTop() - getPaddingBottom();
+        
+        // Finally we have some simple logic that calculates the size of the view 
+        // and calls setMeasuredDimension() to set that size.
+        // Before we compare the width and height of the view, we remove the padding, 
+        // and when we set the dimension we add it back again. Now the actual content 
+        // of the view will be square, but, depending on the padding, the total dimensions 
+        // of the view might not be.
+        if (widthWithoutPadding > heigthWithoutPadding) {
+            size = heigthWithoutPadding;
+        } else {
+            size = widthWithoutPadding;
+        }
+        
+        // If you override onMeasure() you have to call setMeasuredDimension(). 
+        // This is how you report back the measured size.  If you don’t call
+        // setMeasuredDimension() the parent will throw an exception and your 
+        // application will crash.        
+        // We are calling the onMeasure() method of the superclass so we don’t 
+        // actually need to call setMeasuredDimension() since that takes care 
+        // of that. However, the purpose with overriding onMeasure() was to 
+        // change the default behaviour and to do that we need to call 
+        // setMeasuredDimension() with our own values.
+        setMeasuredDimension(size + getPaddingLeft() + getPaddingRight(), size + getPaddingTop() + getPaddingBottom());
+    }
+
+    /**
+     * Use onSizeChanged instead of onAttachedToWindow to get the dimensions of the view,
+     * because this method is called after measuring the dimensions of MATCH_PARENT & WRAP_CONTENT.
+     * Use this dimensions to setup the bounds and paints.
+     */
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+
+        // Share the dimensions
+        layout_width = w;
+        layout_height = h;
+
+        setupBounds();
+        setupPaints();
+        invalidate();
+    }
+
+    /**
+     * Set the properties of the paints we're using to
+     * draw the progress wheel
+     */
+    private void setupPaints() {
+        barPaint.setColor(barColor);
+        barPaint.setAntiAlias(true);
+        barPaint.setStyle(Style.STROKE);
+        barPaint.setStrokeWidth(barWidth);
+
+        rimPaint.setColor(rimColor);
+        rimPaint.setAntiAlias(true);
+        rimPaint.setStyle(Style.STROKE);
+        rimPaint.setStrokeWidth(rimWidth);
+
+        circlePaint.setColor(circleColor);
+        circlePaint.setAntiAlias(true);
+        circlePaint.setStyle(Style.FILL);
+
+        textPaint.setColor(textColor);
+        textPaint.setStyle(Style.FILL);
+        textPaint.setAntiAlias(true);
+        textPaint.setTextSize(textSize);
+
+        contourPaint.setColor(contourColor);
+        contourPaint.setAntiAlias(true);
+        contourPaint.setStyle(Style.STROKE);
+        contourPaint.setStrokeWidth(contourSize);
+    }
+
+    /**
+     * Set the bounds of the component
+     */
+    private void setupBounds() {
+        // Width should equal to Height, find the min value to steup the circle
+        int minValue = Math.min(layout_width, layout_height);
+
+        // Calc the Offset if needed
+        int xOffset = layout_width - minValue;
+        int yOffset = layout_height - minValue;
+
+        // Add the offset
+        paddingTop = this.getPaddingTop() + (yOffset / 2);
+        paddingBottom = this.getPaddingBottom() + (yOffset / 2);
+        paddingLeft = this.getPaddingLeft() + (xOffset / 2);
+        paddingRight = this.getPaddingRight() + (xOffset / 2);
+
+        int width = getWidth(); //this.getLayoutParams().width;
+        int height = getHeight(); //this.getLayoutParams().height;
+
+        rectBounds = new RectF(paddingLeft,
+                paddingTop,
+                width - paddingRight,
+                height - paddingBottom);
+
+        circleBounds = new RectF(paddingLeft + barWidth,
+                paddingTop + barWidth,
+                width - paddingRight - barWidth,
+                height - paddingBottom - barWidth);
+        circleInnerContour = new RectF(circleBounds.left + (rimWidth / 2.0f) + (contourSize / 2.0f), circleBounds.top + (rimWidth / 2.0f) + (contourSize / 2.0f), circleBounds.right - (rimWidth / 2.0f) - (contourSize / 2.0f), circleBounds.bottom - (rimWidth / 2.0f) - (contourSize / 2.0f));
+        circleOuterContour = new RectF(circleBounds.left - (rimWidth / 2.0f) - (contourSize / 2.0f), circleBounds.top - (rimWidth / 2.0f) - (contourSize / 2.0f), circleBounds.right + (rimWidth / 2.0f) + (contourSize / 2.0f), circleBounds.bottom + (rimWidth / 2.0f) + (contourSize / 2.0f));
+
+        fullRadius = (width - paddingRight - barWidth) / 2;
+        circleRadius = (fullRadius - barWidth) + 1;
+    }
+
+    /**
+     * Parse the attributes passed to the view from the XML
+     *
+     * @param a the attributes to parse
+     */
+    private void parseAttributes(TypedArray a) {
+        barWidth = (int) a.getDimension(R.styleable.ProgressWheel_barWidth,
+                barWidth);
+
+        rimWidth = (int) a.getDimension(R.styleable.ProgressWheel_rimWidth,
+                rimWidth);
+
+        spinSpeed = (int) a.getDimension(R.styleable.ProgressWheel_spinSpeed,
+                spinSpeed);
+
+        delayMillis = a.getInteger(R.styleable.ProgressWheel_delayMillis,
+                delayMillis);
+        if (delayMillis < 0) {
+            delayMillis = 0;
+        }
+
+        barColor = a.getColor(R.styleable.ProgressWheel_barColor, barColor);
+
+        barLength = (int) a.getDimension(R.styleable.ProgressWheel_barLength,
+                barLength);
+
+        textSize = (int) a.getDimension(R.styleable.ProgressWheel_textSize,
+                textSize);
+
+        textColor = (int) a.getColor(R.styleable.ProgressWheel_textColor,
+                textColor);
+
+        //if the text is empty , so ignore it
+        if (a.hasValue(R.styleable.ProgressWheel_text)) {
+            setText(a.getString(R.styleable.ProgressWheel_text));
+        }
+
+        rimColor = (int) a.getColor(R.styleable.ProgressWheel_rimColor,
+                rimColor);
+
+        circleColor = (int) a.getColor(R.styleable.ProgressWheel_circleColor,
+                circleColor);
+
+        contourColor = a.getColor(R.styleable.ProgressWheel_contourColor, contourColor);
+        contourSize = a.getDimension(R.styleable.ProgressWheel_contourSize, contourSize);
+
+
+        // Recycle
+        a.recycle();
+    }
+
+    //----------------------------------
+    //Animation stuff
+    //----------------------------------
+
+    protected void onDraw(Canvas canvas) {
+        super.onDraw(canvas);
+        //Draw the inner circle
+        canvas.drawArc(circleBounds, 360, 360, false, circlePaint);
+        //Draw the rim
+        canvas.drawArc(circleBounds, 360, 360, false, rimPaint);
+        canvas.drawArc(circleOuterContour, 360, 360, false, contourPaint);
+        canvas.drawArc(circleInnerContour, 360, 360, false, contourPaint);
+        //Draw the bar
+        if (isSpinning) {
+            canvas.drawArc(circleBounds, progress - 90, barLength, false,
+                    barPaint);
+        } else {
+            canvas.drawArc(circleBounds, -90, progress, false, barPaint);
+        }
+        //Draw the text (attempts to center it horizontally and vertically)
+        float textHeight = textPaint.descent() - textPaint.ascent();
+        float verticalTextOffset = (textHeight / 2) - textPaint.descent();
+
+        for (String s : splitText) {
+            float horizontalTextOffset = textPaint.measureText(s) / 2;
+            canvas.drawText(s, this.getWidth() / 2 - horizontalTextOffset,
+                    this.getHeight() / 2 + verticalTextOffset, textPaint);
+        }
+    }
+
+    /**
+    *   Check if the wheel is currently spinning
+    */
+    
+    public boolean isSpinning() {
+        if(isSpinning){
+            return true;
+        } else {
+            return false;
+        }
+    }
+    
+    /**
+     * Reset the count (in increment mode)
+     */
+    public void resetCount() {
+        progress = 0;
+        setText("0%");
+        invalidate();
+    }
+
+    /**
+     * Turn off spin mode
+     */
+    public void stopSpinning() {
+        isSpinning = false;
+        progress = 0;
+        spinHandler.removeMessages(0);
+    }
+
+
+    /**
+     * Puts the view on spin mode
+     */
+    public void spin() {
+        isSpinning = true;
+        spinHandler.sendEmptyMessage(0);
+    }
+
+    /**
+     * Increment the progress by 1 (of 360)
+     */
+    public void incrementProgress() {
+        isSpinning = false;
+        progress++;
+        if (progress > 360)
+            progress = 0;
+//        setText(Math.round(((float) progress / 360) * 100) + "%");
+        spinHandler.sendEmptyMessage(0);
+    }
+
+
+    /**
+     * Set the progress to a specific value
+     */
+    public void setProgress(int i) {
+        isSpinning = false;
+        progress = i;
+        spinHandler.sendEmptyMessage(0);
+    }
+
+    //----------------------------------
+    //Getters + setters
+    //----------------------------------
+
+    /**
+     * Set the text in the progress bar
+     * Doesn't invalidate the view
+     *
+     * @param text the text to show ('\n' constitutes a new line)
+     */
+    public void setText(String text) {
+        this.text = text;
+        splitText = this.text.split("\n");
+    }
+
+    public int getCircleRadius() {
+        return circleRadius;
+    }
+
+    public void setCircleRadius(int circleRadius) {
+        this.circleRadius = circleRadius;
+    }
+
+    public int getBarLength() {
+        return barLength;
+    }
+
+    public void setBarLength(int barLength) {
+        this.barLength = barLength;
+    }
+
+    public int getBarWidth() {
+        return barWidth;
+    }
+
+    public void setBarWidth(int barWidth) {
+        this.barWidth = barWidth;
+    }
+
+    public int getTextSize() {
+        return textSize;
+    }
+
+    public void setTextSize(int textSize) {
+        this.textSize = textSize;
+    }
+
+    public int getPaddingTop() {
+        return paddingTop;
+    }
+
+    public void setPaddingTop(int paddingTop) {
+        this.paddingTop = paddingTop;
+    }
+
+    public int getPaddingBottom() {
+        return paddingBottom;
+    }
+
+    public void setPaddingBottom(int paddingBottom) {
+        this.paddingBottom = paddingBottom;
+    }
+
+    public int getPaddingLeft() {
+        return paddingLeft;
+    }
+
+    public void setPaddingLeft(int paddingLeft) {
+        this.paddingLeft = paddingLeft;
+    }
+
+    public int getPaddingRight() {
+        return paddingRight;
+    }
+
+    public void setPaddingRight(int paddingRight) {
+        this.paddingRight = paddingRight;
+    }
+
+    public int getBarColor() {
+        return barColor;
+    }
+
+    public void setBarColor(int barColor) {
+        this.barColor = barColor;
+    }
+
+    public int getCircleColor() {
+        return circleColor;
+    }
+
+    public void setCircleColor(int circleColor) {
+        this.circleColor = circleColor;
+    }
+
+    public int getRimColor() {
+        return rimColor;
+    }
+
+    public void setRimColor(int rimColor) {
+        this.rimColor = rimColor;
+    }
+
+
+    public Shader getRimShader() {
+        return rimPaint.getShader();
+    }
+
+    public void setRimShader(Shader shader) {
+        this.rimPaint.setShader(shader);
+    }
+
+    public int getTextColor() {
+        return textColor;
+    }
+
+    public void setTextColor(int textColor) {
+        this.textColor = textColor;
+    }
+
+    public int getSpinSpeed() {
+        return spinSpeed;
+    }
+
+    public void setSpinSpeed(int spinSpeed) {
+        this.spinSpeed = spinSpeed;
+    }
+
+    public int getRimWidth() {
+        return rimWidth;
+    }
+
+    public void setRimWidth(int rimWidth) {
+        this.rimWidth = rimWidth;
+    }
+
+    public int getDelayMillis() {
+        return delayMillis;
+    }
+
+    public void setDelayMillis(int delayMillis) {
+        this.delayMillis = delayMillis;
+    }
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/MinimalBible.java

@@ -0,0 +1,63 @@
+package org.bspeice.minimalbible;
+
+import android.app.Application;
+import android.content.Context;
+
+import dagger.ObjectGraph;
+
+public class MinimalBible extends Application {
+
+    /**
+     * The graph used by Dagger to track dependencies
+     */
+    private ObjectGraph graph;
+
+    /**
+     * A singleton reference to the Application currently being run.
+     * Used mostly so we have a fixed point to get the App Context from
+     */
+	private static MinimalBible instance;
+
+    /**
+     * Create the application, and persist the application Context
+     */
+	public MinimalBible() {
+		instance = this;		
+	}
+
+    /**
+     * Get the Application Context. Please note, all attempts to get the App Context should come
+     * through here, and please be sure that the Application won't satisfy what you need.
+     * @return The Application Context
+     */
+	public static Context getAppContext() {
+        return instance;
+    }
+
+    /**
+     * Get the Application, rather than just the Application Context. You likely should be using
+     * this, rather than {@link #getAppContext()}
+     * @return The MinimalBible {@link android.app.Application} object
+     */
+    public static MinimalBible getApplication() {
+        return (MinimalBible)getAppContext();
+    }
+
+    /**
+     * Create the {@link android.app.Application}. Responsible for building and
+     * holding on to the master ObjectGraph.
+     */
+    @Override
+    public void onCreate() {
+        graph = ObjectGraph.create(MinimalBibleModules.class);
+        graph.inject(this);
+    }
+
+    /**
+     * Inject a Dagger object
+     * @param o The object to be injected
+     */
+    public void inject(Object o) {
+        graph.inject(o);
+    }
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/MinimalBibleModules.java

@@ -0,0 +1,19 @@
+package org.bspeice.minimalbible;
+
+import org.bspeice.minimalbible.activities.ActivityModules;
+
+import dagger.Module;
+
+/**
+ * Master module for MinimalBible
+ */
+@Module(
+    injects = {
+        MinimalBible.class
+    },
+    includes = {
+        ActivityModules.class
+    }
+)
+public class MinimalBibleModules {
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/ActivityModules.java

@@ -0,0 +1,16 @@
+package org.bspeice.minimalbible.activities;
+
+import org.bspeice.minimalbible.activities.downloader.ActivityDownloaderModule;
+
+import dagger.Module;
+
+/**
+ * Modules for all activities
+ */
+@Module(
+    includes = {
+        ActivityDownloaderModule.class
+    }
+)
+public class ActivityModules {
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/BaseActivity.java

@@ -0,0 +1,30 @@
+package org.bspeice.minimalbible.activities;
+
+import org.bspeice.minimalbible.R;
+
+import com.readystatesoftware.systembartint.SystemBarTintManager;
+
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v7.app.ActionBarActivity;
+
+/**
+ * Wrapper for activities in MinimalBible to make sure we can support
+ * common functionality between them all.
+ */
+public class BaseActivity extends ActionBarActivity {
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Only set the tint if the device is running KitKat or above
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+			SystemBarTintManager tintManager = new SystemBarTintManager(this);
+			tintManager.setStatusBarTintEnabled(true);
+			tintManager.setStatusBarTintColor(getResources().getColor(
+					R.color.statusbar));
+		}
+	}
+
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/BaseFragment.java

@@ -0,0 +1,26 @@
+package org.bspeice.minimalbible.activities;
+
+import android.app.Activity;
+import android.os.Build;
+import android.support.v4.app.Fragment;
+import android.view.View;
+
+import com.readystatesoftware.systembartint.SystemBarTintManager;
+
+/**
+ * Base class that defines all behavior common to Fragments in MinimalBible
+ */
+public class BaseFragment extends Fragment {
+
+    /**
+     * Calculate the offset we need to display properly if the System bar is translucent
+     * @param context The {@link android.app.Activity} we are displaying in
+     * @param view The {@link android.view.View} we need to calculate the offset for.
+     */
+    public static void setInsets(Activity context, View view) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) return;
+        SystemBarTintManager tintManager = new SystemBarTintManager(context);
+        SystemBarTintManager.SystemBarConfig config = tintManager.getConfig();
+        view.setPadding(0, config.getPixelInsetTop(true), config.getPixelInsetRight(), config.getPixelInsetBottom());
+    }
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/BaseNavigationDrawerFragment.java

@@ -0,0 +1,307 @@
+package org.bspeice.minimalbible.activities;
+
+import org.bspeice.minimalbible.R;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+import android.content.res.Configuration;
+import android.os.Build;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.support.v4.app.ActionBarDrawerToggle;
+import android.support.v4.app.Fragment;
+import android.support.v4.view.GravityCompat;
+import android.support.v4.widget.DrawerLayout;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.ActionBarActivity;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+import android.widget.Toast;
+
+import com.readystatesoftware.systembartint.SystemBarTintManager;
+
+/**
+ * Fragment used for managing interactions for and presentation of a navigation
+ * drawer. See the <a href=
+ * "https://developer.android.com/design/patterns/navigation-drawer.html#Interaction"
+ * > design guidelines</a> for a complete explanation of the behaviors
+ * implemented here.
+ */
+public class BaseNavigationDrawerFragment extends Fragment {
+
+	/**
+	 * Remember the position of the selected item.
+	 */
+	private static final String STATE_SELECTED_POSITION = "selected_navigation_drawer_position";
+
+	/**
+	 * Per the design guidelines, you should show the drawer on launch until the
+	 * user manually expands it. This shared preference tracks this.
+	 */
+	private static final String PREF_USER_LEARNED_DRAWER = "navigation_drawer_learned";
+
+	/**
+	 * A pointer to the current callbacks instance (the Activity).
+	 */
+	private NavigationDrawerCallbacks mCallbacks;
+
+	/**
+	 * Helper component that ties the action bar to the navigation drawer.
+	 */
+	private ActionBarDrawerToggle mDrawerToggle;
+
+	private DrawerLayout mDrawerLayout;
+	protected ListView mDrawerListView;
+	private View mFragmentContainerView;
+
+	protected int mCurrentSelectedPosition = 0;
+	private boolean mFromSavedInstanceState;
+	private boolean mUserLearnedDrawer;
+
+	public BaseNavigationDrawerFragment() {
+	}
+
+	@Override
+	public void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+
+		// Read in the flag indicating whether or not the user has demonstrated
+		// awareness of the
+		// drawer. See PREF_USER_LEARNED_DRAWER for details.
+		SharedPreferences sp = PreferenceManager
+				.getDefaultSharedPreferences(getActivity());
+		mUserLearnedDrawer = sp.getBoolean(PREF_USER_LEARNED_DRAWER, false);
+
+		if (savedInstanceState != null) {
+			mCurrentSelectedPosition = savedInstanceState
+					.getInt(STATE_SELECTED_POSITION);
+			mFromSavedInstanceState = true;
+		}
+
+		// Select either the default item (0) or the last selected item.
+		selectItem(mCurrentSelectedPosition);
+	}
+
+	@Override
+	public void onActivityCreated(Bundle savedInstanceState) {
+		super.onActivityCreated(savedInstanceState);
+		// Indicate that this fragment would like to influence the set of
+		// actions in the action bar.
+		setHasOptionsMenu(true);
+	}
+
+	public boolean isDrawerOpen() {
+		return mDrawerLayout != null
+				&& mDrawerLayout.isDrawerOpen(mFragmentContainerView);
+	}
+
+	/**
+	 * Users of this fragment must call this method to set up the navigation
+	 * drawer interactions.
+	 * 
+	 * @param fragmentId
+	 *            The android:id of this fragment in its activity's layout.
+	 * @param drawerLayout
+	 *            The DrawerLayout containing this fragment's UI.
+	 */
+	public void setUp(int fragmentId, DrawerLayout drawerLayout) {
+		mFragmentContainerView = getActivity().findViewById(fragmentId);
+		mDrawerLayout = drawerLayout;
+
+		// set a custom shadow that overlays the main content when the drawer
+		// opens
+		mDrawerLayout.setDrawerShadow(R.drawable.drawer_shadow,
+				GravityCompat.START);
+		// set up the drawer's list view with items and click listener
+
+		ActionBar actionBar = getActionBar();
+		actionBar.setDisplayHomeAsUpEnabled(true);
+		actionBar.setHomeButtonEnabled(true);
+
+		// ActionBarDrawerToggle ties together the the proper interactions
+		// between the navigation drawer and the action bar app icon.
+		mDrawerToggle = new ActionBarDrawerToggle(getActivity(), /* host Activity */
+		mDrawerLayout, /* DrawerLayout object */
+		R.drawable.ic_drawer, /* nav drawer image to replace 'Up' caret */
+		R.string.navigation_drawer_open, /*
+										 * "open drawer" description for
+										 * accessibility
+										 */
+		R.string.navigation_drawer_close /*
+										 * "close drawer" description for
+										 * accessibility
+										 */
+		) {
+			@Override
+			public void onDrawerClosed(View drawerView) {
+				super.onDrawerClosed(drawerView);
+				if (!isAdded()) {
+					return;
+				}
+
+				getActivity().supportInvalidateOptionsMenu(); // calls
+																// onPrepareOptionsMenu()
+			}
+
+			@Override
+			public void onDrawerOpened(View drawerView) {
+				super.onDrawerOpened(drawerView);
+				if (!isAdded()) {
+					return;
+				}
+
+				if (!mUserLearnedDrawer) {
+					// The user manually opened the drawer; store this flag to
+					// prevent auto-showing
+					// the navigation drawer automatically in the future.
+					mUserLearnedDrawer = true;
+					SharedPreferences sp = PreferenceManager
+							.getDefaultSharedPreferences(getActivity());
+					sp.edit().putBoolean(PREF_USER_LEARNED_DRAWER, true)
+							.commit();
+				}
+
+				getActivity().supportInvalidateOptionsMenu(); // calls
+																// onPrepareOptionsMenu()
+			}
+		};
+
+		// If the user hasn't 'learned' about the drawer, open it to introduce
+		// them to the drawer,
+		// per the navigation drawer design guidelines.
+		if (!mUserLearnedDrawer && !mFromSavedInstanceState) {
+			mDrawerLayout.openDrawer(mFragmentContainerView);
+		}
+
+		// Defer code dependent on restoration of previous instance state.
+		mDrawerLayout.post(new Runnable() {
+			@Override
+			public void run() {
+				mDrawerToggle.syncState();
+			}
+		});
+
+		mDrawerLayout.setDrawerListener(mDrawerToggle);
+	}
+
+	public void selectItem(int position) {
+		mCurrentSelectedPosition = position;
+		if (mDrawerListView != null) {
+			mDrawerListView.setItemChecked(position, true);
+		}
+		if (mDrawerLayout != null) {
+			mDrawerLayout.closeDrawer(mFragmentContainerView);
+		}
+		if (mCallbacks != null) {
+			mCallbacks.onNavigationDrawerItemSelected(position);
+		}
+	}
+
+	@Override
+	public void onAttach(Activity activity) {
+		super.onAttach(activity);
+		try {
+			mCallbacks = (NavigationDrawerCallbacks) activity;
+		} catch (ClassCastException e) {
+			throw new ClassCastException(
+					"Activity must implement NavigationDrawerCallbacks.");
+		}
+	}
+
+	@Override
+	public void onDetach() {
+		super.onDetach();
+		mCallbacks = null;
+	}
+
+	@Override
+	public void onSaveInstanceState(Bundle outState) {
+		super.onSaveInstanceState(outState);
+		outState.putInt(STATE_SELECTED_POSITION, mCurrentSelectedPosition);
+	}
+
+	@Override
+	public void onConfigurationChanged(Configuration newConfig) {
+		super.onConfigurationChanged(newConfig);
+		// Forward the new configuration the drawer toggle component.
+		mDrawerToggle.onConfigurationChanged(newConfig);
+	}
+
+	@Override
+	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+		// If the drawer is open, show the global app actions in the action bar.
+		// See also
+		// showGlobalContextActionBar, which controls the top-left area of the
+		// action bar.
+		if (mDrawerLayout != null && isDrawerOpen()) {
+			inflater.inflate(R.menu.global, menu);
+			showGlobalContextActionBar();
+		}
+		super.onCreateOptionsMenu(menu, inflater);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		if (mDrawerToggle.onOptionsItemSelected(item)) {
+			return true;
+		}
+		return super.onOptionsItemSelected(item);
+	}
+
+	/**
+	 * Per the navigation drawer design guidelines, updates the action bar to
+	 * show the global app 'context', rather than just what's in the current
+	 * screen.
+	 */
+	private void showGlobalContextActionBar() {
+		ActionBar actionBar = getActionBar();
+		actionBar.setDisplayShowTitleEnabled(true);
+		actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD);
+		// actionBar.setTitle(R.string.app_name);
+	}
+
+	protected ActionBar getActionBar() {
+		return ((ActionBarActivity) getActivity()).getSupportActionBar();
+	}
+
+	public void setInsets(View view) {
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT)
+			return;
+		SystemBarTintManager tintManager = new SystemBarTintManager(getActivity());
+		SystemBarTintManager.SystemBarConfig config = tintManager.getConfig();
+		view.setPadding(0, config.getPixelInsetTop(true),
+				config.getPixelInsetRight(), config.getPixelInsetBottom());
+	}
+
+	@Override
+	public void onViewCreated(View view, Bundle savedInstanceState) {
+		super.onViewCreated(view, savedInstanceState);
+
+		// This could also be a ScrollView
+		ListView list = (ListView) view.findViewById(R.id.list_nav_drawer);
+		// This could also be set in your layout, allows the list items to
+		// scroll through the bottom padded area (navigation bar)
+		list.setClipToPadding(false);
+		// Sets the padding to the insets (include action bar and navigation bar
+		// padding for the current device and orientation)
+		setInsets(list);
+	}
+
+	/**
+	 * Callbacks interface that all activities using this fragment must
+	 * implement.
+	 */
+	public static interface NavigationDrawerCallbacks {
+		/**
+		 * Called when an item in the navigation drawer is selected.
+		 */
+		void onNavigationDrawerItemSelected(int position);
+	}
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/ActivityDownloaderModule.java

@@ -0,0 +1,46 @@
+package org.bspeice.minimalbible.activities.downloader;
+
+import org.bspeice.minimalbible.MinimalBible;
+import org.bspeice.minimalbible.activities.downloader.manager.BookRefreshTask;
+import org.bspeice.minimalbible.activities.downloader.manager.DownloadManager;
+
+import javax.inject.Singleton;
+
+import dagger.Module;
+import dagger.Provides;
+import de.greenrobot.event.EventBus;
+
+/**
+ * Module mappings for the classes under the Download Activity
+ */
+@Module(
+        injects = {
+            BookListFragment.class,
+            DownloadManager.class,
+            BookRefreshTask.class
+        }
+)
+public class ActivityDownloaderModule {
+
+    /**
+     * Provide a Singleton DownloadManager for injection
+     * Note that we need to annotate Singleton here, only annotating on the
+     * DownloadManager itself is not enough.
+     * @return Global DownloadManager instance
+     */
+    @Provides @Singleton
+    DownloadManager provideDownloadManager() {
+        return new DownloadManager();
+    }
+
+    @Provides
+    EventBus provideBus() {
+        return new EventBus();
+    }
+
+
+    @Provides //@Singleton
+    DownloadPrefs_ provideDownloadPrefs() {
+        return new DownloadPrefs_(MinimalBible.getApplication());
+    }
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/BookListAdapter.java

@@ -0,0 +1,90 @@
+package org.bspeice.minimalbible.activities.downloader;
+
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.BaseAdapter;
+import android.widget.ImageButton;
+import android.widget.TextView;
+
+import com.todddavies.components.progressbar.ProgressWheel;
+import org.bspeice.minimalbible.R;
+import org.crosswire.jsword.book.Book;
+
+import java.util.List;
+
+import butterknife.ButterKnife;
+import butterknife.InjectView;
+import butterknife.OnClick;
+
+/**
+ * Adapter to inflate list_download_items.xml
+ */
+public class BookListAdapter extends BaseAdapter {
+    private List<Book> bookList;
+
+    private LayoutInflater inflater;
+
+    public BookListAdapter(LayoutInflater inflater, List<Book> bookList) {
+        this.bookList = bookList;
+        this.inflater = inflater;
+    }
+
+    @Override
+    public int getCount() {
+        return bookList.size();
+    }
+
+    @Override
+    public Book getItem(int position) {
+        return bookList.get(position);
+    }
+
+    @Override
+    public long getItemId(int i) {
+        return i;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        BookItemHolder viewHolder;
+        // Nasty Android issue - if you don't check the getTag(), Android will start recycling,
+        // and you'll get some really strange issues
+        if (convertView == null || convertView.getTag() == null) {
+            convertView = inflater.inflate(R.layout.list_download_items, null);
+            viewHolder = new BookItemHolder(convertView);
+        } else {
+            viewHolder = (BookItemHolder) convertView.getTag();
+        }
+
+        viewHolder.bindHolder(position);
+        return convertView;
+    }
+
+    public class BookItemHolder {
+
+        @InjectView(R.id.download_txt_item_acronym) TextView acronym;
+        @InjectView(R.id.txt_download_item_name) TextView itemName;
+        @InjectView(R.id.download_ibtn_download) ImageButton isDownloaded;
+        @InjectView(R.id.download_prg_download) ProgressWheel downloadProgress;
+
+        public BookItemHolder(View v) {
+            ButterKnife.inject(this, v);
+        }
+
+        public void bindHolder(int position) {
+            Book b = BookListAdapter.this.getItem(position);
+            acronym.setText(b.getInitials());
+            itemName.setText(b.getName());
+        }
+
+        @OnClick(R.id.download_ibtn_download)
+        public void onDownloadItem(View v) {
+            Log.d("BookListAdapter", v.toString());
+            isDownloaded.setVisibility(View.GONE);
+            downloadProgress.setVisibility(View.VISIBLE);
+            downloadProgress.setProgress(75); // Out of 360
+        }
+    }
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/BookListFragment.java

@@ -0,0 +1,197 @@
+package org.bspeice.minimalbible.activities.downloader;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ListView;
+import android.widget.Toast;
+
+import com.f2prateek.dart.InjectExtra;
+
+import org.bspeice.minimalbible.MinimalBible;
+import org.bspeice.minimalbible.R;
+import org.bspeice.minimalbible.activities.BaseFragment;
+import org.bspeice.minimalbible.activities.downloader.manager.DownloadManager;
+import org.bspeice.minimalbible.activities.downloader.manager.EventBookList;
+import org.crosswire.jsword.book.Book;
+import org.crosswire.jsword.book.BookCategory;
+import org.crosswire.jsword.book.BookComparators;
+import org.crosswire.jsword.book.BookFilter;
+import org.crosswire.jsword.book.FilterUtil;
+
+import java.util.Collections;
+import java.util.List;
+
+import javax.inject.Inject;
+
+import butterknife.ButterKnife;
+import butterknife.InjectView;
+
+/**
+ * A placeholder fragment containing a simple view.
+ */
+
+public class BookListFragment extends BaseFragment {
+    /**
+     * The fragment argument representing the section number for this fragment.
+     * Not a candidate for Dart (yet) because I would have to write a Parcelable around it.
+     */
+    private static final String ARG_BOOK_CATEGORY = "book_category";
+
+    private final String TAG = "BookListFragment";
+
+    @InjectView(R.id.lst_download_available)
+    ListView downloadsAvailable;
+
+    @Inject DownloadManager downloadManager;
+
+    @Inject DownloadPrefs_ downloadPrefs;
+
+	private ProgressDialog refreshDialog;
+    private LayoutInflater inflater;
+
+    /**
+     * Returns a new instance of this fragment for the given section number.
+     * TODO: Switch to AutoFactory/@Provides rather than inline creation.
+     */
+    public static BookListFragment newInstance(BookCategory c) {
+        BookListFragment fragment = new BookListFragment();
+        Bundle args = new Bundle();
+        args.putString(ARG_BOOK_CATEGORY, c.toString());
+        fragment.setArguments(args);
+        return fragment;
+    }
+
+    @Override
+    public void onCreate(Bundle state) {
+        super.onCreate(state);
+        MinimalBible.getApplication().inject(this); // Injection for Dagger goes here, not ctor
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+                             Bundle savedInstanceState) {
+        this.inflater = inflater;
+        View rootView = inflater.inflate(R.layout.fragment_download, container,
+                false);
+        ButterKnife.inject(this, rootView);
+        displayModules();
+        return rootView;
+    }
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+        ((DownloadActivity) activity).onSectionAttached(getArguments()
+                .getString(ARG_BOOK_CATEGORY));
+    }
+
+    /**
+     * Trigger the functionality to display a list of modules. Prompts user if downloading
+     * from the internet is allowable.
+     */
+ 	public void displayModules() {
+		boolean dialogDisplayed = downloadPrefs.showedDownloadDialog().get();
+		
+		if (!dialogDisplayed) {
+			AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+			DownloadDialogListener dialogListener = new DownloadDialogListener();
+			builder.setMessage(
+					"About to contact servers to download content. Continue?")
+					.setPositiveButton("Yes", dialogListener)
+					.setNegativeButton("No", dialogListener)
+					.setCancelable(false).show();
+		} else {
+			refreshModules();
+		}
+	}
+
+    /**
+     * Do the work of refreshing modules (download manager handles using cached copy vs. actual
+     * refresh), and then displaying them when ready.
+     */
+	private void refreshModules() {
+        // Check if the downloadManager has already refreshed everything
+		List<Book> bookList = downloadManager.getBookList();
+		if (bookList == null) {
+            // downloadManager is in progress of refreshing
+            downloadManager.getDownloadBus().register(this);
+            refreshDialog = new ProgressDialog(getActivity());
+            refreshDialog.setMessage("Refreshing available modules...");
+            refreshDialog.setCancelable(false);
+            refreshDialog.show();
+        } else {
+            displayBooks(bookList);
+        }
+	}
+
+    /**
+     * Used by GreenRobot for notifying us that the book refresh is complete
+     */
+    @SuppressWarnings("unused")
+	public void onEventMainThread(EventBookList event) {
+		if (refreshDialog != null) {
+			refreshDialog.cancel();
+		}
+		displayBooks(event.getBookList());
+	}
+
+    /**
+     * Do the hard work of creating the Adapter and displaying books.
+     * @param bookList The (unfiltered) list of {link org.crosswire.jsword.Book}s to display
+     */
+    public void displayBooks(List<Book> bookList) {
+        try {
+            // TODO: Should the filter be applied earlier in the process?
+            List<Book> displayList;
+
+            BookCategory c = BookCategory.fromString(getArguments().getString(ARG_BOOK_CATEGORY));
+            BookFilter f = FilterUtil.filterFromCategory(c);
+            displayList = FilterUtil.applyFilter(bookList, f);
+            Collections.sort(displayList, BookComparators.getInitialComparator());
+
+            downloadsAvailable.setAdapter(new BookListAdapter(inflater, displayList));
+            setInsets(getActivity(), downloadsAvailable);
+        } catch (FilterUtil.InvalidFilterCategoryMappingException e) {
+            // To be honest, there should be no reason you end up here.
+            Log.e(TAG, e.getMessage());
+        }
+    }
+
+	private class DownloadDialogListener implements
+			DialogInterface.OnClickListener {
+		@Override
+		public void onClick(DialogInterface dialog, int which) {
+            downloadPrefs.showedDownloadDialog().put(true);
+
+			switch (which) {
+			case DialogInterface.BUTTON_POSITIVE:
+				// Clicked ready to continue - allow downloading in the future
+                downloadPrefs.hasEnabledDownload().put(true);
+
+				// And warn them that it has been enabled in the future.
+				Toast.makeText(getActivity(),
+						"Downloading now enabled. Disable in settings.",
+						Toast.LENGTH_SHORT).show();
+				refreshModules();
+				break;
+
+			case DialogInterface.BUTTON_NEGATIVE:
+				// Clicked to not download - Permanently disable downloading
+				downloadPrefs.hasEnabledDownload().put(false);
+				Toast.makeText(getActivity(),
+						"Disabling downloading. Re-enable it in settings.",
+						Toast.LENGTH_SHORT).show();
+				refreshModules();
+				break;
+			}
+		}
+	}
+
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/DownloadActivity.java

@@ -0,0 +1,90 @@
+package org.bspeice.minimalbible.activities.downloader;
+
+import org.bspeice.minimalbible.R;
+import org.bspeice.minimalbible.activities.BaseActivity;
+import org.bspeice.minimalbible.activities.BaseNavigationDrawerFragment;
+import org.bspeice.minimalbible.activities.downloader.manager.DownloadManager;
+
+import android.os.Bundle;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.widget.DrawerLayout;
+import android.support.v7.app.ActionBar;
+import android.view.Menu;
+import android.view.MenuItem;
+
+public class DownloadActivity extends BaseActivity implements
+		BaseNavigationDrawerFragment.NavigationDrawerCallbacks {
+
+	/**
+	 * Fragment managing the behaviors, interactions and presentation of the
+	 * navigation drawer.
+	 */
+	private DownloadNavDrawerFragment mNavigationDrawerFragment;
+
+	/**
+	 * Used to store the last screen title. For use in
+	 * {@link #restoreActionBar()}.
+	 */
+	private CharSequence mTitle;
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		setContentView(R.layout.activity_download);
+
+		mNavigationDrawerFragment = (DownloadNavDrawerFragment) getSupportFragmentManager()
+				.findFragmentById(R.id.navigation_drawer);
+		mTitle = getTitle();
+
+		// Set up the drawer.
+		mNavigationDrawerFragment.setUp(R.id.navigation_drawer,
+				(DrawerLayout) findViewById(R.id.drawer_layout));
+	}
+
+	@Override
+	public void onNavigationDrawerItemSelected(int position) {
+		// update the main content by replacing fragments
+        //TODO: Switch to AutoFactory pattern, rather than newInstance()
+		FragmentManager fragmentManager = getSupportFragmentManager();
+		fragmentManager
+				.beginTransaction()
+				.replace(R.id.container,
+						BookListFragment.newInstance(DownloadManager.VALID_CATEGORIES[position])).commit();
+	}
+
+	public void onSectionAttached(String category) {
+		mTitle = category;
+	}
+
+	public void restoreActionBar() {
+		ActionBar actionBar = getSupportActionBar();
+		actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD);
+		actionBar.setDisplayShowTitleEnabled(true);
+		actionBar.setTitle(mTitle);
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		if (!mNavigationDrawerFragment.isDrawerOpen()) {
+			// Only show items in the action bar relevant to this screen
+			// if the drawer is not showing. Otherwise, let the drawer
+			// decide what to show in the action bar.
+			getMenuInflater().inflate(R.menu.download, menu);
+			restoreActionBar();
+			return true;
+		}
+		return super.onCreateOptionsMenu(menu);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		// Handle action bar item clicks here. The action bar will
+		// automatically handle clicks on the Home/Up button, so long
+		// as you specify a parent activity in AndroidManifest.xml.
+		int id = item.getItemId();
+		if (id == R.id.action_settings) {
+			return true;
+		}
+		return super.onOptionsItemSelected(item);
+	}
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/DownloadNavDrawerFragment.java

@@ -0,0 +1,43 @@
+package org.bspeice.minimalbible.activities.downloader;
+
+import org.bspeice.minimalbible.R;
+import org.bspeice.minimalbible.activities.BaseNavigationDrawerFragment;
+import org.bspeice.minimalbible.activities.downloader.manager.DownloadManager;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+public class DownloadNavDrawerFragment extends BaseNavigationDrawerFragment {
+	
+	@Override
+	public View onCreateView(LayoutInflater inflater, ViewGroup container,
+			Bundle savedInstanceState) {
+		mDrawerListView = (ListView) inflater.inflate(
+				R.layout.fragment_navigation_drawer, container, false);
+		mDrawerListView
+				.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+					@Override
+					public void onItemClick(AdapterView<?> parent, View view,
+							int position, long id) {
+						selectItem(position);
+					}
+				});
+		
+		String[] sCategories = new String[DownloadManager.VALID_CATEGORIES.length];
+		for (int i = 0; i < DownloadManager.VALID_CATEGORIES.length; i++) {
+			sCategories[i] = DownloadManager.VALID_CATEGORIES[i].toString();
+		}
+		
+		mDrawerListView.setAdapter(new ArrayAdapter<String>(getActionBar()
+				.getThemedContext(), android.R.layout.simple_list_item_1,
+				android.R.id.text1, sCategories));
+		mDrawerListView.setItemChecked(mCurrentSelectedPosition, true);
+		return mDrawerListView;
+	}
+
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/DownloadPrefs_.java

@@ -0,0 +1,72 @@
+/*
+This is brutally ugly, but until https://github.com/square/dagger/issues/410 is resolved,
+this is the best I can do while making sure that I can easily switch the API later
+ */
+//
+// DO NOT EDIT THIS FILE, IT HAS BEEN GENERATED USING AndroidAnnotations 3.0.1.
+//
+
+
+package org.bspeice.minimalbible.activities.downloader;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+import org.androidannotations.api.sharedpreferences.BooleanPrefEditorField;
+import org.androidannotations.api.sharedpreferences.BooleanPrefField;
+import org.androidannotations.api.sharedpreferences.EditorHelper;
+import org.androidannotations.api.sharedpreferences.LongPrefEditorField;
+import org.androidannotations.api.sharedpreferences.LongPrefField;
+import org.androidannotations.api.sharedpreferences.SharedPreferencesHelper;
+
+public final class DownloadPrefs_
+    extends SharedPreferencesHelper
+{
+
+    private Context context_;
+
+    public DownloadPrefs_(Context context) {
+        super(context.getSharedPreferences("DownloadPrefs", 0));
+        this.context_ = context;
+    }
+
+    public DownloadPrefs_.DownloadPrefsEditor_ edit() {
+        return new DownloadPrefs_.DownloadPrefsEditor_(getSharedPreferences());
+    }
+
+    public BooleanPrefField hasEnabledDownload() {
+        return booleanField("hasEnabledDownload", false);
+    }
+
+    public BooleanPrefField showedDownloadDialog() {
+        return booleanField("showedDownloadDialog", false);
+    }
+
+    public LongPrefField downloadRefreshedOn() {
+        return longField("downloadRefreshedOn", 0L);
+    }
+
+    public final static class DownloadPrefsEditor_
+        extends EditorHelper<DownloadPrefs_.DownloadPrefsEditor_>
+    {
+
+
+        DownloadPrefsEditor_(SharedPreferences sharedPreferences) {
+            super(sharedPreferences);
+        }
+
+        public BooleanPrefEditorField<DownloadPrefs_.DownloadPrefsEditor_> hasEnabledDownload() {
+            return booleanField("hasEnabledDownload");
+        }
+
+        public BooleanPrefEditorField<DownloadPrefs_.DownloadPrefsEditor_> showedDownloadDialog() {
+            return booleanField("showedDownloadDialog");
+        }
+
+        public LongPrefEditorField<DownloadPrefs_.DownloadPrefsEditor_> downloadRefreshedOn() {
+            return longField("downloadRefreshedOn");
+        }
+
+    }
+
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/_DownloadPrefs.java

@@ -0,0 +1,22 @@
+package org.bspeice.minimalbible.activities.downloader;
+
+import org.androidannotations.annotations.sharedpreferences.DefaultBoolean;
+import org.androidannotations.annotations.sharedpreferences.DefaultLong;
+import org.androidannotations.annotations.sharedpreferences.SharedPref;
+
+/**
+ * Renamed while waiting for https://github.com/square/dagger/issues/410 to get resolved.
+ * Once the issue is fixed, this should go back to being DownloadPrefs
+ */
+@SharedPref(value= SharedPref.Scope.UNIQUE)
+public interface _DownloadPrefs {
+
+    @DefaultBoolean(false)
+    boolean hasEnabledDownload();
+
+    @DefaultBoolean(false)
+    boolean showedDownloadDialog();
+
+    @DefaultLong(0)
+    long downloadRefreshedOn();
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/manager/BookRefreshTask.java

@@ -0,0 +1,85 @@
+package org.bspeice.minimalbible.activities.downloader.manager;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+import android.os.AsyncTask;
+import android.util.Log;
+
+import org.bspeice.minimalbible.MinimalBible;
+import org.bspeice.minimalbible.activities.downloader.DownloadPrefs_;
+import org.crosswire.jsword.book.Book;
+import org.crosswire.jsword.book.install.InstallException;
+import org.crosswire.jsword.book.install.Installer;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.inject.Inject;
+
+import de.greenrobot.event.EventBus;
+
+public class BookRefreshTask extends AsyncTask<Installer, Integer, List<Book>> {
+	private static final String TAG = "EventBookRefreshTask";
+
+    // If last refresh was before the below, force an internet refresh
+    private final Long refreshAfter = System.currentTimeMillis() - 604800000L; // 1 Week in millis
+
+    @Inject
+    DownloadPrefs_ downloadPrefs;
+
+	private EventBus downloadBus;
+
+	public BookRefreshTask(EventBus downloadBus) {
+		this.downloadBus = downloadBus;
+        MinimalBible.getApplication().inject(this);
+	}
+
+	@Override
+	protected List<Book> doInBackground(Installer... params) {
+		List<Book> books = new LinkedList<Book>();
+
+		int index = 0;
+		for (Installer i : params) {
+			if (doRefresh()) {
+				try {
+					i.reloadBookList();
+                    downloadPrefs.downloadRefreshedOn().put(System.currentTimeMillis());
+				} catch (InstallException e) {
+					Log.e(TAG,
+							"Error downloading books from installer: "
+									+ i.toString(), e);
+				}
+			}
+
+			books.addAll(i.getBooks());
+			publishProgress(++index, params.length);
+		}
+
+		downloadBus.postSticky(new EventBookList(books));
+		return books;
+	}
+
+	private boolean doRefresh() {
+		// Check if we should refresh over the internet, or use the local copy
+		// TODO: Discover if we need to refresh over Internet, or use a cached
+		// copy - likely something time-based, also check network state.
+		// Fun fact - jSword handles the caching for us.
+
+        return (isWifi() && downloadEnabled() && needsRefresh());
+	}
+
+    private boolean isWifi() {
+        ConnectivityManager mgr = (ConnectivityManager)MinimalBible.getAppContext().getSystemService(Context.CONNECTIVITY_SERVICE);
+        NetworkInfo networkInfo = mgr.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
+        return networkInfo.isConnected();
+    }
+
+    private boolean downloadEnabled() {
+        return downloadPrefs.hasEnabledDownload().get();
+    }
+
+    private boolean needsRefresh() {
+        return (downloadPrefs.downloadRefreshedOn().get() > refreshAfter);
+    }
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/manager/DownloadManager.java

@@ -0,0 +1,110 @@
+package org.bspeice.minimalbible.activities.downloader.manager;
+
+import android.util.Log;
+
+import org.bspeice.minimalbible.MinimalBible;
+import org.crosswire.jsword.book.Book;
+import org.crosswire.jsword.book.BookCategory;
+import org.crosswire.jsword.book.install.InstallManager;
+import org.crosswire.jsword.book.install.Installer;
+
+import java.util.List;
+import java.util.Map;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+
+import de.greenrobot.event.EventBus;
+
+@Singleton
+public class DownloadManager {
+
+	private final String TAG = "DownloadManager";
+
+    /**
+     * Cached copy of modules that are available so we don't refresh for everyone who requests it.
+     */
+    private List<Book> availableModules = null;
+
+    @Inject
+    protected EventBus downloadBus;
+
+	public static final BookCategory[] VALID_CATEGORIES = { BookCategory.BIBLE,
+			BookCategory.COMMENTARY, BookCategory.DICTIONARY,
+			BookCategory.MAPS };
+
+    /**
+     * Set up the DownloadManager, and notify jSword of where it should store files at
+     */
+	public DownloadManager() {
+        MinimalBible.getApplication().inject(this);
+		setDownloadDir();
+		refreshModules();
+	}
+
+    /**
+     * Get the installers available to jSword - this is how we get access to the actual modules
+     * @return All available {@link org.crosswire.jsword.book.install.Installer}s
+     */
+	public Map<String, Installer> getInstallers() {
+		return new InstallManager().getInstallers();
+	}
+
+    /**
+     * Helper method to transform the installers map to an array
+     * @return Array with all available {@link org.crosswire.jsword.book.install.Installer} objects
+     */
+	public Installer[] getInstallersArray() {
+		Map<String, Installer> installers = getInstallers();
+		return installers.values().toArray(new Installer[installers.size()]);
+	}
+
+    /**
+     * Notify jSword that it needs to store files in the Android internal directory
+     * NOTE: Android will uninstall these files if you uninstall MinimalBible.
+     */
+    @SuppressWarnings("null")
+	private void setDownloadDir() {
+		// We need to set the download directory for jSword to stick with
+		// Android.
+		String home = MinimalBible.getAppContext().getFilesDir().toString();
+		Log.d(TAG, "Setting jsword.home to: " + home);
+		System.setProperty("jsword.home", home);
+	}
+
+    /**
+     * Do the work of kicking off the AsyncTask to refresh books, and make sure we know
+     * when it's done.
+     */
+	private void refreshModules() {
+        downloadBus.register(this);
+		new BookRefreshTask(downloadBus).execute(getInstallersArray());
+	}
+
+    /**
+     * When book refresh is done, cache the list so we can give that to someone else
+     * @param event A POJO wrapper around the Book list
+     */
+    @SuppressWarnings("unused")
+    public void onEvent(EventBookList event) {
+        this.availableModules = event.getBookList();
+    }
+
+    /**
+     * Get the cached book list
+     * @return The cached book list, or null
+     */
+    public List<Book> getBookList() {
+        return availableModules;
+    }
+
+    /**
+     * Get the current download bus if you want to know when refresh is done.
+     * Please note that you will not be notified if the book refresh has already
+     * been completed, make sure to check {@link #getBookList()} first.
+     * @return The EventBus the DownloadManager is using
+     */
+	public EventBus getDownloadBus() {
+		return this.downloadBus;
+	}
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/downloader/manager/EventBookList.java

@@ -0,0 +1,22 @@
+package org.bspeice.minimalbible.activities.downloader.manager;
+
+import java.util.List;
+
+import org.crosswire.jsword.book.Book;
+
+/**
+ * POJO class for {@link de.greenrobot.event.EventBus} to broadcast whenever
+ * we've finished updating the book list.
+ */
+public class EventBookList {
+	
+	private List<Book> bookList;
+	
+	public EventBookList(List<Book> bookList) {
+		this.bookList = bookList;
+	}
+	
+	public List<Book> getBookList() {
+		return bookList;
+	}
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/viewer/BibleViewer.java

@@ -0,0 +1,161 @@
+package org.bspeice.minimalbible.activities.viewer;
+
+import org.bspeice.minimalbible.R;
+import org.bspeice.minimalbible.R.id;
+import org.bspeice.minimalbible.R.layout;
+import org.bspeice.minimalbible.R.menu;
+import org.bspeice.minimalbible.R.string;
+import org.bspeice.minimalbible.activities.BaseActivity;
+import org.bspeice.minimalbible.activities.BaseNavigationDrawerFragment;
+import org.bspeice.minimalbible.activities.downloader.DownloadActivity;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.widget.DrawerLayout;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.ActionBarActivity;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import com.readystatesoftware.systembartint.SystemBarTintManager;
+
+public class BibleViewer extends BaseActivity implements
+		BaseNavigationDrawerFragment.NavigationDrawerCallbacks {
+
+	/**
+	 * Fragment managing the behaviors, interactions and presentation of the
+	 * navigation drawer.
+	 */
+	private ViewerNavDrawerFragment mNavigationDrawerFragment;
+
+	/**
+	 * Used to store the last screen title. For use in
+	 * {@link #restoreActionBar()}.
+	 */
+	private CharSequence mTitle;
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		setContentView(R.layout.activity_bible_viewer);
+
+		mNavigationDrawerFragment = (ViewerNavDrawerFragment) getSupportFragmentManager()
+				.findFragmentById(R.id.navigation_drawer);
+		mTitle = getTitle();
+
+		// Set up the drawer.
+		mNavigationDrawerFragment.setUp(R.id.navigation_drawer,
+				(DrawerLayout) findViewById(R.id.drawer_layout));
+	}
+
+	@Override
+	public void onNavigationDrawerItemSelected(int position) {
+		// update the main content by replacing fragments
+		FragmentManager fragmentManager = getSupportFragmentManager();
+		fragmentManager
+				.beginTransaction()
+				.replace(R.id.container,
+						PlaceholderFragment.newInstance(position + 1)).commit();
+	}
+
+	public void onSectionAttached(int number) {
+		switch (number) {
+		case 1:
+			mTitle = getString(R.string.title_section1);
+			break;
+		case 2:
+			mTitle = getString(R.string.title_section2);
+			break;
+		case 3:
+			mTitle = getString(R.string.title_section3);
+			break;
+		}
+	}
+
+	public void restoreActionBar() {
+		ActionBar actionBar = getSupportActionBar();
+		actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD);
+		actionBar.setDisplayShowTitleEnabled(true);
+		actionBar.setTitle(mTitle);
+	}
+
+	@Override
+	public boolean onCreateOptionsMenu(Menu menu) {
+		if (!mNavigationDrawerFragment.isDrawerOpen()) {
+			// Only show items in the action bar relevant to this screen
+			// if the drawer is not showing. Otherwise, let the drawer
+			// decide what to show in the action bar.
+			getMenuInflater().inflate(R.menu.main, menu);
+			restoreActionBar();
+			return true;
+		}
+		return super.onCreateOptionsMenu(menu);
+	}
+
+	@Override
+	public boolean onOptionsItemSelected(MenuItem item) {
+		// Handle action bar item clicks here. The action bar will
+		// automatically handle clicks on the Home/Up button, so long
+		// as you specify a parent activity in AndroidManifest.xml.
+		int id = item.getItemId();
+		if (id == R.id.action_settings) {
+			return true;
+		} else if (id == R.id.action_downloads) {
+			startActivity(new Intent(this, DownloadActivity.class));
+		}
+		return super.onOptionsItemSelected(item);
+	}
+
+	/**
+	 * A placeholder fragment containing a simple view.
+	 */
+	public static class PlaceholderFragment extends Fragment {
+		/**
+		 * The fragment argument representing the section number for this
+		 * fragment.
+		 */
+		private static final String ARG_SECTION_NUMBER = "section_number";
+
+		/**
+		 * Returns a new instance of this fragment for the given section number.
+		 */
+		public static PlaceholderFragment newInstance(int sectionNumber) {
+			PlaceholderFragment fragment = new PlaceholderFragment();
+			Bundle args = new Bundle();
+			args.putInt(ARG_SECTION_NUMBER, sectionNumber);
+			fragment.setArguments(args);
+			return fragment;
+		}
+
+		public PlaceholderFragment() {
+		}
+
+		@Override
+		public View onCreateView(LayoutInflater inflater, ViewGroup container,
+				Bundle savedInstanceState) {
+			View rootView = inflater.inflate(R.layout.fragment_main, container,
+					false);
+			TextView textView = (TextView) rootView
+					.findViewById(R.id.section_label);
+			textView.setText(Integer.toString(getArguments().getInt(
+					ARG_SECTION_NUMBER)));
+			return rootView;
+		}
+
+		@Override
+		public void onAttach(Activity activity) {
+			super.onAttach(activity);
+			((BibleViewer) activity).onSectionAttached(getArguments().getInt(
+					ARG_SECTION_NUMBER));
+		}
+	}
+
+}

MinimalBible/src/main/java/org/bspeice/minimalbible/activities/viewer/ViewerNavDrawerFragment.java

@@ -0,0 +1,38 @@
+package org.bspeice.minimalbible.activities.viewer;
+
+import org.bspeice.minimalbible.R;
+import org.bspeice.minimalbible.activities.BaseNavigationDrawerFragment;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+public class ViewerNavDrawerFragment extends BaseNavigationDrawerFragment {
+
+	@Override
+	public View onCreateView(LayoutInflater inflater, ViewGroup container,
+			Bundle savedInstanceState) {
+		mDrawerListView = (ListView) inflater.inflate(
+				R.layout.fragment_navigation_drawer, container, false);
+		mDrawerListView
+				.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+					@Override
+					public void onItemClick(AdapterView<?> parent, View view,
+							int position, long id) {
+						selectItem(position);
+					}
+				});
+		mDrawerListView.setAdapter(new ArrayAdapter<String>(getActionBar()
+				.getThemedContext(), android.R.layout.simple_list_item_1,
+				android.R.id.text1, new String[] {
+						getString(R.string.title_section1),
+						getString(R.string.title_section2),
+						getString(R.string.title_section3)}));
+		mDrawerListView.setItemChecked(mCurrentSelectedPosition, true);
+		return mDrawerListView;
+	}
+}