Merge branch 'release/1.5.0'

This was causing problems, since some launchers completely
ignore minimum widget sizes. When widgets were too small,
the text started to overflow.

.gitignore

@@ -33,3 +33,4 @@ build/
 *.iml
 
 art/
+*.actual.png

CHANGELOG.md

@@ -0,0 +1,85 @@
+# Changelog
+
+### 1.5.0 (May 15, 2016)
+
+* Add night mode, with AMOLED support
+* Backport material design to older devices
+* Display more information on statistics screen
+* Display score on main screen and checkmark widget
+* Make widgets react immediately to touch
+* Reschedule reminders after reboot
+* Pick first day of the week according to country
+* Add option to reverse order of days on main screen
+* Add option to change notification sounds
+* Add Catalan, Indonesian, Turkish, Ukrainian translations
+* Switch between Simplified/Traditional Chinese according to country
+
+### 1.4.1 (April 9, 2016)
+
+* Show error message on widgets, instead of crashing
+* Complete French translation
+* Minor fixes to other translations
+
+### 1.4.0 (April 7, 2016)
+
+* Ability to import data from third-party apps
+* Ability to save and restore full database backup
+* Show more information on streak chart
+* Simplify interface for creating habits
+* Add link to Frequently Asked Questions (FAQ)
+* Reduce app loading time and lag on widgets
+* Generate bug reports on crash and from settings screen
+* Disable vibration according to phone settings
+* Add Czech translation
+* Fix wrong month names for some languages
+
+### 1.3.3 (March 20, 2016)
+
+* Add Spanish and Korean translations
+* Make small corrections to other translations
+* Fix incorrect date in history calendar
+
+### 1.3.2 (March 18, 2016)
+
+* Add Arabic, Italian, Polish, Russian and Swedish translations
+* Minor fixes to German and French translations
+* Minor bug fixes
+
+### 1.3.1 (March 15, 2016)
+
+* Fixes crash on devices with large screen, such as the Nexus 10
+* Fixes crash when clicking widgets and reminders of deleted habits
+* Other minor bug fixes
+
+### 1.3.0 (March 12, 2016)
+
+* New frequency plot: view total repetitions per day of week
+* New history editor: put checkmarks in the past
+* Add German, French and Japanese translations
+* Add about screen, with credits to all contributors
+* Fix small bug that prevented habit from being reordered
+* Fix small bug caused by rotating the device
+
+### 1.2.0 (March 4, 2016)
+
+* Ability to export habit data as CSV
+* Widgets (checkmark, history, score and streaks)
+* More natural scrolling on data views (fling)
+* Minor UI improvements on pre-Lollipop devices
+* Fix crash on Samsung Galaxy TabS 8.4
+* Other minor bug fixes
+
+### 1.1.1 (February 24, 2016)
+
+* Show reminder only on chosen days of the week
+* Rearrange habits by long-pressing then dragging
+* Select and modify multiple habits simultaneously
+* 12/24 hour format according to phone preferences
+* Permanently delete habits
+* Usage hints during startup
+* Translation to Brazilian Portuguese and Chinese
+* Other minor fixes
+
+### 1.0.0 (February 19, 2016)
+
+* Initial release

NOTICE.md

@@ -0,0 +1,110 @@
+# Copyright Notices
+
+### ActiveAndroid
+
+<https://github.com/pardom/ActiveAndroid>
+
+    Copyright (C) 2010 Michael Pardo
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+### Android Open Source Project
+
+<https://source.android.com/>
+
+    Copyright (C) 2013 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+### FontAwesome
+
+<http://fontawesome.io>
+
+Font Awesome is a full suite of 605 pictographic icons for easy scalable
+vector graphics on websites, created and maintained by Dave Gandy. Licensed
+under the SIL OFL 1.1.
+
+    The goals of the Open Font License (OFL) are to stimulate worldwide
+    development of collaborative font projects, to support the font creation
+    efforts of academic and linguistic communities, and to provide a free and
+    open framework in which fonts may be shared and improved in partnership
+    with others.
+
+    The OFL allows the licensed fonts to be used, studied, modified and
+    redistributed freely as long as they are not sold by themselves. The
+    fonts, including any derivative works, can be bundled, embedded,
+    redistributed and/or sold with any software provided that any reserved
+    names are not used by derivative works. The fonts and derivatives,
+    however, cannot be released under any other type of license. The
+    requirement for fonts to remain under this license does not apply
+    to any document created using the fonts or their derivatives.
+
+
+### DragSortListView
+
+<https://github.com/bauerca/drag-sort-listview>
+
+    A subclass of the Android ListView component that enables drag
+    and drop re-ordering of list items.
+
+    Copyright 2012 Carl Bauer
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+### Material Design Icons
+
+<https://github.com/google/material-design-icons>
+
+Material design icons are the official icon set from Google that are designed
+under the material design guidelines. Available under the Creative Common
+Attribution 4.0 International License (CC-BY 4.0).
+
+### Android Flow Layout
+
+<https://github.com/ApmeM/android-flowlayout>
+
+Extended linear layout that wrap its content when there is no place in the current line.
+
+    Copyright 2011, Artem Votincev (apmem.org)
+
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not
+    use this file except in compliance with the License. You may obtain a copy
+    of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+    License for the specific language governing permissions and limitations
+    under the License.

README.md

@@ -1,16 +1,51 @@
 # Loop Habit Tracker
+<a href="https://circleci.com/gh/iSoron/uhabits/tree/dev">
+  <img src="https://img.shields.io/circleci/project/iSoron/uhabits/dev.svg">
+</a>
+<a href="https://codecov.io/github/iSoron/uhabits?branch=dev">
+  <img src="https://img.shields.io/codecov/c/github/iSoron/uhabits.svg" alt="Coverage via Codecov" />
+</a>
 
-Loop is a simple Android app that helps you create and maintain good habits. Detailed graphs and statistics show you how your habits improved over time. It is completely ad-free and open source, with no intrusive permissions. Join the open beta at [Google Play Store](https://play.google.com/apps/testing/org.isoron.uhabits).
+Loop is a simple Android app that helps you create and maintain good habits,
+allowing you to achieve your long-term goals. Detailed graphs and statistics
+show you how your habits improved over time. It is completely ad-free and open
+source.
+
+<p align="center">
+<a href="https://play.google.com/store/apps/details?id=org.isoron.uhabits&utm_source=global_co&utm_medium=prtnr&utm_content=Mar2515&utm_campaign=PartBadge&pcampaignid=MKT-AC-global-none-all-co-pr-py-PartBadges-Oct1515-1"><img alt="Get it on Google Play" src="https://play.google.com/intl/en_us/badges/images/apps/en-play-badge-border.png" height="75px"/></a>
+<a href="http://f-droid.org/app/org.isoron.uhabits"><img alt="Git if on F-Droid" src="http://i.imgur.com/baSPE7X.png" height="75px"/></a>
+</p>
 
 ## Features
 
-* Simple and beautiful interface, following the Material Design guidelines.
-* Advanced algorithms for calculating the strength of your habits. Every repetition makes your habit stronger, and every missed day makes it weaker. A few missed days after a long streak, however, will not completely destroy your entire progress.
-* Detailed graphs and statistics, showing how did you habits improve over time. Scroll back to see the complete history of your habit.
-* Support for both daily habits and habits with more complex schedules, such as 3 times every week; one time every other week; or every other day.
-* Habit reminders at a chosen hour of the day.
-* Support for Android Wear. Reminders can be checked or dismissed from the watch.
-* Completely ad-free and open source. There are absolutely no advertisements, annoying notifications or intrusive permissions in this app, and there will never be. The complete source code is available under the GPLv3.
+* **Simple, beautiful and modern interface.** Loop has a minimalistic interface
+  that is easy to use and follows the material design guidelines.
+
+* **Habit score.** In addition to showing your current streak, Loop has an
+  advanced algorithm for calculating the strength of your habits. Every
+  repetition makes your habit stronger, and every missed day makes it weaker. A
+  few missed days after a long streak, however, will not completely destroy
+  your entire progress.
+
+* **Detailed graphs and statistics.** Clearly see how your habits improved over
+  time with beautiful and detailed graphs. Scroll back to see the complete
+  history of your habits.
+
+* **Flexible schedules.** Supports both daily habits and habits with more
+  complex schedules, such as 3 times every week; one time every other week; or
+  every other day.
+
+* **Reminders.** Create an individual reminder for each habit, at a chosen hour
+  of the day. Easily check, dismiss or snooze your habit directly from the
+  notification, without opening the app.
+
+* **Optimized for smartwatches.** Reminders can be checked, snoozed or
+  dismissed directly from your Android Wear watch.
+
+* **Completely ad-free and open source.** There are absolutely no
+  advertisements, annoying notifications or intrusive permissions in this app,
+  and there will never be. The complete source code is available under the
+  GPLv3.
 
 ## Screenshots
 
@@ -18,12 +53,71 @@ Loop is a simple Android app that helps you create and maintain good habits. Det
 [![Edit habit][screen2th]][screen2]
 [![Habit strength][screen3th]][screen3]
 [![Habit history and streaks][screen4th]][screen4]
+[![Widgets][screen5th]][screen5]
+[![Night mode][screen6th]][screen6]
+
+## Installing
+
+The easiest way to install Loop is through the [Google Play Store][playstore] or [F-Droid][fdroid].
+You may also download and install the APK from the [releases page][releases];
+note, however, that the app will not be updated automatically.  To build this
+app from the source code, see [building instructions][build].
+
+## Contributing
+
+Loop is an open source project developed entirely by volunteers. If you would
+like to contribute to the project, you are very welcome. There are many ways to
+contribute, even if you are not a software developer.
+
+* **Report bugs, suggest features.** The easiest way to contribute is to simply
+  use the app and let us know if you find any problems or have any suggestions
+  to improve it. You can either use the link inside the app, or open an issue
+  at GitHub. If you would like to receive the newest versions of the app
+  earlier than everyone else, [join our open beta on Google Play][beta].
+
+* **Spread the word.** If you like the app, share it with your family, friends
+  and colleagues. You can also rate and review the app on Google Play Store, to help
+  other users find it more easily.
+
+* **Translate the app into your own language.** If you are not a native English
+  speaker, and would like to see the app translated into your own language,
+  please join our [open translation project at POEditor][poedit]. If the translation
+  is already completed, you are also very welcome to join and proofread it.
+
+* **Write some code.** If you are an Android developer, you are very welcome to
+  contribute with code. Please, see the [developer guidelines][dev-guide] for more details.
+
+## License
+
+    This program is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the Free
+    Software Foundation, either version 3 of the License, or (at your option)
+    any later version.
+
+    This program is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+    more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 [screen1]: screenshots/original/uhabits1.png
 [screen2]: screenshots/original/uhabits2.png
 [screen3]: screenshots/original/uhabits3.png
 [screen4]: screenshots/original/uhabits4.png
+[screen5]: screenshots/original/uhabits5.png
+[screen6]: screenshots/original/uhabits6.png
 [screen1th]: screenshots/thumbs/uhabits1.png
 [screen2th]: screenshots/thumbs/uhabits2.png
 [screen3th]: screenshots/thumbs/uhabits3.png
 [screen4th]: screenshots/thumbs/uhabits4.png
+[screen5th]: screenshots/thumbs/uhabits5.png
+[screen6th]: screenshots/thumbs/uhabits6.png
+[poedit]: https://poeditor.com/join/project/8DWX5pfjS0
+[playstore]: https://play.google.com/store/apps/details?id=org.isoron.uhabits
+[releases]: https://github.com/iSoron/uhabits/releases
+[fdroid]: http://f-droid.org/app/org.isoron.uhabits
+[dev-guide]: https://github.com/iSoron/uhabits/wiki/Developer-guidelines
+[build]: https://github.com/iSoron/uhabits/wiki/Developer-guidelines#building
+[beta]: https://play.google.com/apps/testing/org.isoron.uhabits

app/build.gradle

@@ -2,12 +2,18 @@ apply plugin: 'com.android.application'
 
 android {
     compileSdkVersion 23
-    buildToolsVersion "21.1.2"
+    buildToolsVersion "23.0.3"
 
     defaultConfig {
         applicationId "org.isoron.uhabits"
         minSdkVersion 15
         targetSdkVersion 23
+
+        buildConfigField "Integer", "databaseVersion", "14"
+        buildConfigField "String", "databaseFilename", "\"uhabits.db\""
+
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        //testInstrumentationRunnerArgument "size", "small"
     }
 
     buildTypes {
@@ -15,6 +21,9 @@ android {
             minifyEnabled false
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
         }
+        debug {
+            testCoverageEnabled = true
+        }
     }
 
     lintOptions {
@@ -23,9 +32,40 @@ android {
 }
 
 dependencies {
-    compile 'com.android.support:support-v4:23.1.1'
+    compile 'com.android.support:support-v4:23.3.0'
+    compile 'com.android.support:appcompat-v7:23.3.0'
+    compile 'com.android.support:design:23.3.0'
+    compile 'com.android.support:preference-v14:23.3.0'
     compile 'com.github.paolorotolo:appintro:3.4.0'
+    compile 'org.apmem.tools:layouts:1.10@aar'
+    compile 'com.opencsv:opencsv:3.7'
     compile project(':libs:drag-sort-listview:library')
     compile files('libs/ActiveAndroid.jar')
+
+    androidTestCompile 'com.android.support:support-annotations:23.3.0'
+    androidTestCompile 'com.android.support.test:runner:0.5'
+    androidTestCompile 'com.android.support.test:rules:0.5'
+
+    androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.1') {
+        exclude group: 'com.android.support'
     }
 
+    androidTestCompile('com.android.support.test.espresso:espresso-intents:2.2.1') {
+        exclude group: 'com.android.support'
+    }
+
+    androidTestCompile('com.android.support.test.espresso:espresso-contrib:2.2.1') {
+        exclude group: 'com.android.support'
+    }
+}
+
+
+task grantAnimationPermission(type: Exec, dependsOn: 'installDebug') {
+    commandLine "adb shell pm grant org.isoron.uhabits android.permission.SET_ANIMATION_SCALE".split(' ')
+}
+
+tasks.whenTaskAdded { task ->
+    if (task.name.startsWith('connected')) {
+        task.dependsOn grantAnimationPermission
+    }
+}

app/src/androidTest/assets/habitbull.csv

@@ -0,0 +1,19 @@
+HabitName,HabitDescription,HabitCategory,CalendarDate,Value,CommentText
+Breed dragons,with love and fire,Diet & Food,2016-03-18,1,
+Breed dragons,with love and fire,Diet & Food,2016-03-19,1,
+Breed dragons,with love and fire,Diet & Food,2016-03-21,1,
+Reduce sleep,only 2 hours per day,Time Management,2016-03-15,1,
+Reduce sleep,only 2 hours per day,Time Management,2016-03-16,1,
+Reduce sleep,only 2 hours per day,Time Management,2016-03-17,1,
+Reduce sleep,only 2 hours per day,Time Management,2016-03-21,1,
+No-arms pushup,Become like water my friend!,Fitness,2016-03-15,1,
+No-arms pushup,Become like water my friend!,Fitness,2016-03-16,1,
+No-arms pushup,Become like water my friend!,Fitness,2016-03-18,1,
+No-arms pushup,Become like water my friend!,Fitness,2016-03-21,1,
+No-arms pushup,Become like water my friend!,Fitness,2016-03-15,1,
+No-arms pushup,Become like water my friend!,Fitness,2016-03-16,1,
+No-arms pushup,Become like water my friend!,Fitness,2016-03-18,1,
+No-arms pushup,Become like water my friend!,Fitness,2016-03-21,1,
+Grow spiritually,"transcend ego, practice compassion, smile and breath",Meditation,2016-03-15,1,
+Grow spiritually,"transcend ego, practice compassion, smile and breath",Meditation,2016-03-17,1,
+Grow spiritually,"transcend ego, practice compassion, smile and breath",Meditation,2016-03-21,1,

app/src/androidTest/assets/pull_failed

@@ -0,0 +1,5 @@
+#!/bin/bash
+P=/sdcard/Android/data/org.isoron.uhabits/cache/Failed/
+
+adb pull $P Failed/
+adb shell rm -r $P

app/src/androidTest/java/org/isoron/uhabits/BaseTest.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits;
+
+import android.content.Context;
+import android.os.Build;
+import android.os.Looper;
+import android.support.test.InstrumentationRegistry;
+
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.helpers.UIHelper;
+import org.isoron.uhabits.tasks.BaseTask;
+import org.junit.Before;
+
+import java.util.concurrent.TimeoutException;
+
+public class BaseTest
+{
+    protected Context testContext;
+    protected Context targetContext;
+    private static boolean isLooperPrepared;
+
+    public static final long FIXED_LOCAL_TIME = 1422172800000L; // 8:00am, January 25th, 2015 (UTC)
+
+    @Before
+    public void setup()
+    {
+        if(!isLooperPrepared)
+        {
+            Looper.prepare();
+            isLooperPrepared = true;
+        }
+
+        targetContext = InstrumentationRegistry.getTargetContext();
+        testContext = InstrumentationRegistry.getContext();
+
+        UIHelper.setFixedTheme(R.style.AppBaseTheme);
+        DateHelper.setFixedLocalTime(FIXED_LOCAL_TIME);
+    }
+
+    protected void waitForAsyncTasks() throws InterruptedException, TimeoutException
+    {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN)
+        {
+            Thread.sleep(1000);
+            return;
+        }
+
+        BaseTask.waitForTasks(10000);
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/ui/HabitMatchers.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.ui;
+
+import android.preference.Preference;
+import android.view.View;
+import android.widget.Adapter;
+import android.widget.AdapterView;
+
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.hamcrest.TypeSafeMatcher;
+import org.isoron.uhabits.models.Habit;
+
+public class HabitMatchers
+{
+    public static Matcher<Habit> withName(final String name)
+    {
+        return new TypeSafeMatcher<Habit>()
+        {
+            @Override
+            public boolean matchesSafely(Habit habit)
+            {
+                return habit.name.equals(name);
+            }
+
+            @Override
+            public void describeTo(Description description)
+            {
+                description.appendText("name should be ").appendText(name);
+            }
+
+            @Override
+            public void describeMismatchSafely(Habit habit, Description description)
+            {
+                description.appendText("was ").appendText(habit.name);
+            }
+        };
+    }
+
+    public static Matcher<View> containsHabit(final Matcher<Habit> matcher)
+    {
+        return new TypeSafeMatcher<View>()
+        {
+            @Override
+            protected boolean matchesSafely(View view)
+            {
+                Adapter adapter = ((AdapterView) view).getAdapter();
+                for (int i = 0; i < adapter.getCount(); i++)
+                    if (matcher.matches(adapter.getItem(i))) return true;
+
+                return false;
+            }
+
+            @Override
+            public void describeTo(Description description)
+            {
+                description.appendText("with class name: ");
+                matcher.describeTo(description);
+            }
+        };
+    }
+
+    public static Matcher<?> isPreferenceWithText(final String text)
+    {
+        return (Matcher<?>) new BaseMatcher()
+        {
+            @Override
+            public boolean matches(Object o)
+            {
+                if(!(o instanceof Preference)) return false;
+                return o.toString().contains(text);
+            }
+
+            @Override
+            public void describeTo(Description description)
+            {
+                description.appendText(String.format("is preference with text '%s'", text));
+            }
+        };
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/ui/HabitViewActions.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.ui;
+
+import android.support.test.espresso.UiController;
+import android.support.test.espresso.ViewAction;
+import android.support.test.espresso.action.CoordinatesProvider;
+import android.support.test.espresso.action.GeneralClickAction;
+import android.support.test.espresso.action.GeneralLocation;
+import android.support.test.espresso.action.Press;
+import android.support.test.espresso.action.Tap;
+import android.support.test.espresso.matcher.ViewMatchers;
+import android.view.View;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import org.hamcrest.Matcher;
+import org.isoron.uhabits.R;
+
+import java.security.InvalidParameterException;
+import java.util.Random;
+
+public class HabitViewActions
+{
+    public static ViewAction toggleAllCheckmarks()
+    {
+        final GeneralClickAction clickAction =
+                new GeneralClickAction(Tap.LONG, GeneralLocation.CENTER, Press.FINGER);
+
+        return new ViewAction()
+        {
+            @Override
+            public Matcher<View> getConstraints()
+            {
+                return ViewMatchers.isDisplayed();
+            }
+
+            @Override
+            public String getDescription()
+            {
+                return "toggleAllCheckmarks";
+            }
+
+            @Override
+            public void perform(UiController uiController, View view)
+            {
+                if (view.getId() != R.id.llButtons)
+                    throw new InvalidParameterException("View must have id llButtons");
+
+                LinearLayout llButtons = (LinearLayout) view;
+                int count = llButtons.getChildCount();
+
+                for (int i = 0; i < count; i++)
+                {
+                    TextView tvButton = (TextView) llButtons.getChildAt(i);
+                    clickAction.perform(uiController, tvButton);
+                }
+            }
+        };
+    }
+
+    public static ViewAction clickAt(final int x, final int y)
+    {
+        return new GeneralClickAction(Tap.SINGLE, new CoordinatesProvider()
+        {
+            @Override
+            public float[] calculateCoordinates(View view)
+            {
+                int[] locations = new int[2];
+                view.getLocationOnScreen(locations);
+
+                final float locationX = locations[0] + x;
+                final float locationY = locations[1] + y;
+
+                return new float[]{locationX, locationY};
+            }
+        }, Press.FINGER);
+    }
+
+    public static ViewAction clickAtRandomLocations(final int count)
+    {
+        return new ViewAction()
+        {
+            @Override
+            public Matcher<View> getConstraints()
+            {
+                return ViewMatchers.isDisplayed();
+            }
+
+            @Override
+            public String getDescription()
+            {
+                return "clickAtRandomLocations";
+            }
+
+            @Override
+            public void perform(UiController uiController, View view)
+            {
+                int width = view.getWidth();
+                int height = view.getHeight();
+                Random random = new Random();
+
+                for(int i = 0; i < count; i++)
+                {
+                    int x = random.nextInt(width);
+                    int y = random.nextInt(height);
+
+                    ViewAction action = clickAt(x, y);
+                    action.perform(uiController, view);
+                }
+            }
+        };
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/ui/MainActivityActions.java

@@ -0,0 +1,225 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.ui;
+
+import android.support.test.espresso.NoMatchingViewException;
+import android.support.test.espresso.contrib.RecyclerViewActions;
+
+import org.isoron.uhabits.R;
+import org.isoron.uhabits.models.Habit;
+
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import static android.support.test.espresso.Espresso.onData;
+import static android.support.test.espresso.Espresso.onView;
+import static android.support.test.espresso.Espresso.pressBack;
+import static android.support.test.espresso.action.ViewActions.click;
+import static android.support.test.espresso.action.ViewActions.longClick;
+import static android.support.test.espresso.action.ViewActions.replaceText;
+import static android.support.test.espresso.assertion.ViewAssertions.matches;
+import static android.support.test.espresso.matcher.RootMatchers.isPlatformPopup;
+import static android.support.test.espresso.matcher.ViewMatchers.Visibility.VISIBLE;
+import static android.support.test.espresso.matcher.ViewMatchers.hasDescendant;
+import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed;
+import static android.support.test.espresso.matcher.ViewMatchers.withClassName;
+import static android.support.test.espresso.matcher.ViewMatchers.withContentDescription;
+import static android.support.test.espresso.matcher.ViewMatchers.withEffectiveVisibility;
+import static android.support.test.espresso.matcher.ViewMatchers.withId;
+import static android.support.test.espresso.matcher.ViewMatchers.withParent;
+import static android.support.test.espresso.matcher.ViewMatchers.withText;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.startsWith;
+import static org.isoron.uhabits.ui.HabitMatchers.containsHabit;
+import static org.isoron.uhabits.ui.HabitMatchers.withName;
+
+public class MainActivityActions
+{
+    public static String addHabit()
+    {
+        return addHabit(false);
+    }
+
+    public static String addHabit(boolean openDialogs)
+    {
+        String name = "New Habit " + new Random().nextInt(1000000);
+        String description = "Did you perform your new habit today?";
+        String num = "4";
+        String den = "8";
+
+        onView(withId(R.id.action_add))
+                .perform(click());
+
+        typeHabitData(name, description, num, den);
+
+        if(openDialogs)
+        {
+            onView(withId(R.id.buttonPickColor))
+                    .perform(click());
+            pressBack();
+            onView(withId(R.id.inputReminderTime))
+                    .perform(click());
+            onView(withText("Done"))
+                    .perform(click());
+            onView(withId(R.id.inputReminderDays))
+                    .perform(click());
+            onView(withText("OK"))
+                    .perform(click());
+        }
+
+        onView(withId(R.id.buttonSave))
+                .perform(click());
+
+        onData(allOf(is(instanceOf(Habit.class)), withName(name)))
+                .onChildView(withId(R.id.label));
+
+        return name;
+    }
+
+    public static void typeHabitData(String name, String description, String num, String den)
+    {
+        onView(withId(R.id.input_name))
+                .perform(replaceText(name));
+        onView(withId(R.id.input_description))
+                .perform(replaceText(description));
+
+        try
+        {
+            onView(allOf(withId(R.id.sFrequency), withEffectiveVisibility(VISIBLE)))
+                    .perform(click());
+            onData(allOf(instanceOf(String.class), startsWith("Custom")))
+                    .inRoot(isPlatformPopup())
+                    .perform(click());
+        }
+        catch(NoMatchingViewException e)
+        {
+            // ignored
+        }
+
+        onView(withId(R.id.input_freq_num))
+                .perform(replaceText(num));
+        onView(withId(R.id.input_freq_den))
+                .perform(replaceText(den));
+    }
+
+    public static void selectHabit(String name)
+    {
+        selectHabits(Collections.singletonList(name));
+    }
+
+    public static void selectHabits(List<String> names)
+    {
+        boolean first = true;
+        for(String name : names)
+        {
+            onData(allOf(is(instanceOf(Habit.class)), withName(name)))
+                    .onChildView(withId(R.id.label))
+                    .perform(first ? longClick() : click());
+
+            first = false;
+        }
+    }
+
+    public static void assertHabitsDontExist(List<String> names)
+    {
+        for(String name : names)
+            onView(withId(R.id.listView))
+                    .check(matches(not(containsHabit(withName(name)))));
+    }
+
+    public static void assertHabitExists(String name)
+    {
+        List<String> names = new LinkedList<>();
+        names.add(name);
+        assertHabitsExist(names);
+    }
+
+    public static void assertHabitsExist(List<String> names)
+    {
+        for(String name : names)
+            onData(allOf(is(instanceOf(Habit.class)), withName(name)))
+                    .check(matches(isDisplayed()));
+    }
+
+    public static void deleteHabit(String name)
+    {
+        deleteHabits(Collections.singletonList(name));
+    }
+
+    public static void deleteHabits(List<String> names)
+    {
+        selectHabits(names);
+        clickMenuItem(R.string.delete);
+        onView(withText("OK"))
+                .perform(click());
+        assertHabitsDontExist(names);
+    }
+
+    public static void clickMenuItem(int stringId)
+    {
+        try
+        {
+            onView(withText(stringId)).perform(click());
+        }
+        catch (Exception e1)
+        {
+            try
+            {
+                onView(withContentDescription(stringId)).perform(click());
+            }
+            catch(Exception e2)
+            {
+                clickHiddenMenuItem(stringId);
+            }
+        }
+    }
+
+    private static void clickHiddenMenuItem(int stringId)
+    {
+        try
+        {
+            // Try the ActionMode overflow menu first
+            onView(allOf(withContentDescription("More options"), withParent(withParent(
+                    withClassName(containsString("Action")))))).perform(click());
+        }
+        catch (Exception e1)
+        {
+            // Try the toolbar overflow menu
+            onView(allOf(withContentDescription("More options"), withParent(withParent(
+                    withClassName(containsString("Toolbar")))))).perform(click());
+        }
+
+        onView(withText(stringId)).perform(click());
+    }
+
+    public static void clickSettingsItem(String text)
+    {
+        onView(withClassName(containsString("RecyclerView")))
+                .perform(RecyclerViewActions.actionOnItem(
+                        hasDescendant(withText(containsString(text))),
+                        click()));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/ui/MainTest.java

@@ -0,0 +1,346 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.ui;
+
+import android.app.Activity;
+import android.app.Instrumentation;
+import android.content.Context;
+import android.content.Intent;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.espresso.NoMatchingViewException;
+import android.support.test.espresso.intent.rule.IntentsTestRule;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.LargeTest;
+
+import org.isoron.uhabits.MainActivity;
+import org.isoron.uhabits.R;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.models.Habit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Random;
+
+import static android.support.test.espresso.Espresso.onData;
+import static android.support.test.espresso.Espresso.onView;
+import static android.support.test.espresso.Espresso.pressBack;
+import static android.support.test.espresso.action.ViewActions.click;
+import static android.support.test.espresso.action.ViewActions.longClick;
+import static android.support.test.espresso.action.ViewActions.scrollTo;
+import static android.support.test.espresso.action.ViewActions.swipeLeft;
+import static android.support.test.espresso.action.ViewActions.swipeRight;
+import static android.support.test.espresso.action.ViewActions.swipeUp;
+import static android.support.test.espresso.assertion.ViewAssertions.matches;
+import static android.support.test.espresso.intent.Intents.intended;
+import static android.support.test.espresso.intent.Intents.intending;
+import static android.support.test.espresso.intent.matcher.IntentMatchers.hasAction;
+import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed;
+import static android.support.test.espresso.matcher.ViewMatchers.isRoot;
+import static android.support.test.espresso.matcher.ViewMatchers.withClassName;
+import static android.support.test.espresso.matcher.ViewMatchers.withId;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.endsWith;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.startsWith;
+import static org.isoron.uhabits.ui.HabitMatchers.withName;
+import static org.isoron.uhabits.ui.HabitViewActions.clickAtRandomLocations;
+import static org.isoron.uhabits.ui.HabitViewActions.toggleAllCheckmarks;
+import static org.isoron.uhabits.ui.MainActivityActions.addHabit;
+import static org.isoron.uhabits.ui.MainActivityActions.assertHabitExists;
+import static org.isoron.uhabits.ui.MainActivityActions.assertHabitsDontExist;
+import static org.isoron.uhabits.ui.MainActivityActions.assertHabitsExist;
+import static org.isoron.uhabits.ui.MainActivityActions.clickMenuItem;
+import static org.isoron.uhabits.ui.MainActivityActions.clickSettingsItem;
+import static org.isoron.uhabits.ui.MainActivityActions.deleteHabit;
+import static org.isoron.uhabits.ui.MainActivityActions.deleteHabits;
+import static org.isoron.uhabits.ui.MainActivityActions.selectHabit;
+import static org.isoron.uhabits.ui.MainActivityActions.selectHabits;
+import static org.isoron.uhabits.ui.MainActivityActions.typeHabitData;
+import static org.isoron.uhabits.ui.ShowHabitActivityActions.openHistoryEditor;
+
+@RunWith(AndroidJUnit4.class)
+@LargeTest
+public class MainTest
+{
+    private SystemHelper sys;
+
+    @Rule
+    public IntentsTestRule<MainActivity> activityRule = new IntentsTestRule<>(
+            MainActivity.class);
+
+    private Context targetContext;
+
+    @Before
+    public void setup()
+    {
+        Context context = InstrumentationRegistry.getInstrumentation().getContext();
+        sys = new SystemHelper(context);
+        sys.disableAllAnimations();
+        sys.acquireWakeLock();
+        sys.unlockScreen();
+
+        targetContext = InstrumentationRegistry.getTargetContext();
+
+        Instrumentation.ActivityResult okResult = new Instrumentation.ActivityResult(
+                Activity.RESULT_OK, new Intent());
+
+        intending(hasAction(equalTo(Intent.ACTION_SEND))).respondWith(okResult);
+        intending(hasAction(equalTo(Intent.ACTION_SENDTO))).respondWith(okResult);
+        intending(hasAction(equalTo(Intent.ACTION_VIEW))).respondWith(okResult);
+
+        skipTutorial();
+    }
+
+    @After
+    public void tearDown()
+    {
+        sys.releaseWakeLock();
+    }
+
+    public void skipTutorial()
+    {
+        try
+        {
+            for (int i = 0; i < 10; i++)
+                onView(allOf(withClassName(endsWith("AppCompatImageButton")),
+                        isDisplayed())).perform(click());
+        }
+        catch (NoMatchingViewException e)
+        {
+            // ignored
+        }
+    }
+
+    /**
+     * User opens the app, creates some habits, selects them, archives them, select 'show archived'
+     * on the menu, selects the previously archived habits and then deletes them.
+     */
+    @Test
+    public void testArchiveHabits()
+    {
+        List<String> names = new LinkedList<>();
+
+        for(int i = 0; i < 3; i++)
+            names.add(addHabit());
+
+        selectHabits(names);
+
+        clickMenuItem(R.string.archive);
+        assertHabitsDontExist(names);
+
+        clickMenuItem(R.string.show_archived);
+
+        assertHabitsExist(names);
+        selectHabits(names);
+        clickMenuItem(R.string.unarchive);
+
+        clickMenuItem(R.string.show_archived);
+
+        assertHabitsExist(names);
+        deleteHabits(names);
+    }
+
+    /**
+     * User opens the app, clicks the add button, types some bogus information, tries to save,
+     * dialog displays an error.
+     */
+    @Test
+    public void testAddInvalidHabit()
+    {
+        onView(withId(R.id.action_add))
+                .perform(click());
+
+        typeHabitData("", "", "15", "7");
+
+        onView(withId(R.id.buttonSave)).perform(click());
+        onView(withId(R.id.input_name)).check(matches(isDisplayed()));
+    }
+
+    /**
+     * User creates a habit, toggles a bunch of checkmarks, clicks the habit to open the statistics
+     * screen, scrolls down to some views, then scrolls the views backwards and forwards in time.
+     */
+    @Test
+    public void testAddHabitAndViewStats() throws InterruptedException
+    {
+        String name = addHabit(true);
+
+        onData(allOf(is(instanceOf(Habit.class)), withName(name)))
+                .onChildView(withId(R.id.llButtons))
+                .perform(toggleAllCheckmarks());
+
+        Thread.sleep(1200);
+
+        onData(allOf(is(instanceOf(Habit.class)), withName(name)))
+                .onChildView(withId(R.id.label))
+                .perform(click());
+
+        onView(withId(R.id.scoreView))
+                .perform(scrollTo(), swipeRight());
+
+        onView(withId(R.id.punchcardView))
+                .perform(scrollTo(), swipeRight());
+    }
+
+    /**
+     * User creates a habit, selects the habit, clicks edit button, changes some information about
+     * the habit, click save button, sees changes on the main window, selects habit again,
+     * changes color, then deletes the habit.
+     */
+    @Test
+    public void testEditHabit()
+    {
+        String name = addHabit();
+
+        onData(allOf(is(instanceOf(Habit.class)), withName(name)))
+                .onChildView(withId(R.id.label))
+                .perform(longClick());
+
+        clickMenuItem(R.string.edit);
+
+        String modifiedName = "Modified " + new Random().nextInt(10000);
+        typeHabitData(modifiedName, "", "1", "1");
+
+        onView(withId(R.id.buttonSave))
+                .perform(click());
+
+        assertHabitExists(modifiedName);
+
+        selectHabit(modifiedName);
+        clickMenuItem(R.string.color_picker_default_title);
+        pressBack();
+
+        deleteHabit(modifiedName);
+    }
+
+    /**
+     * User creates a habit, opens statistics page, clicks button to edit history, adds some
+     * checkmarks, closes dialog, sees the modified history calendar.
+     */
+    @Test
+    public void testEditHistory()
+    {
+        String name = addHabit();
+
+        onData(allOf(is(instanceOf(Habit.class)), withName(name)))
+                .onChildView(withId(R.id.label))
+                .perform(click());
+
+        openHistoryEditor();
+        onView(withClassName(endsWith("HabitHistoryView")))
+                .perform(clickAtRandomLocations(20));
+
+        pressBack();
+        onView(withId(R.id.historyView))
+                .perform(scrollTo(), swipeRight(), swipeLeft());
+    }
+
+    /**
+     * User opens menu, clicks settings, sees settings screen.
+     */
+    @Test
+    public void testSettings()
+    {
+        clickMenuItem(R.string.settings);
+    }
+
+    /**
+     * User opens menu, clicks about, sees about screen.
+     */
+    @Test
+    public void testAbout()
+    {
+        clickMenuItem(R.string.about);
+        onView(isRoot()).perform(swipeUp());
+    }
+
+    /**
+     * User opens menu, clicks Help, sees website.
+     */
+    @Test
+    public void testHelp()
+    {
+        clickMenuItem(R.string.help);
+        intended(hasAction(Intent.ACTION_VIEW));
+    }
+
+    /**
+     * User creates a habit, exports full backup, deletes the habit, restores backup, sees that the
+     * previously created habit has appeared back.
+     */
+    @Test
+    public void testExportImportDB()
+    {
+        String name = addHabit();
+
+        clickMenuItem(R.string.settings);
+
+        String date = DateHelper.getBackupDateFormat().format(DateHelper.getLocalTime());
+        date = date.substring(0, date.length() - 2);
+
+        clickSettingsItem("Export full backup");
+        intended(hasAction(Intent.ACTION_SEND));
+
+        deleteHabit(name);
+
+        clickMenuItem(R.string.settings);
+        clickSettingsItem("Import data");
+
+        onData(allOf(is(instanceOf(String.class)), startsWith("Backups")))
+                .perform(click());
+
+        onData(allOf(is(instanceOf(String.class)), containsString(date)))
+                .perform(click());
+
+        selectHabit(name);
+    }
+
+    /**
+     * User creates a habit, opens settings, clicks export as CSV, is asked what activity should
+     * handle the file.
+     */
+    @Test
+    public void testExportCSV()
+    {
+        addHabit();
+        clickMenuItem(R.string.settings);
+        clickSettingsItem("Export as CSV");
+        intended(hasAction(Intent.ACTION_SEND));
+    }
+
+    /**
+     * User opens the settings and generates a bug report.
+     */
+    @Test
+    public void testGenerateBugReport()
+    {
+        clickMenuItem(R.string.settings);
+        clickSettingsItem("Generate bug report");
+        intended(hasAction(Intent.ACTION_SENDTO));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/ui/ShowHabitActivityActions.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.ui;
+
+import android.support.test.espresso.matcher.ViewMatchers;
+
+import org.isoron.uhabits.R;
+
+import static android.support.test.espresso.Espresso.onView;
+import static android.support.test.espresso.action.ViewActions.click;
+import static android.support.test.espresso.action.ViewActions.scrollTo;
+
+public class ShowHabitActivityActions
+{
+    public static void openHistoryEditor()
+    {
+        onView(ViewMatchers.withId(R.id.btEditHistory))
+                .perform(scrollTo(), click());
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/ui/SystemHelper.java

@@ -0,0 +1,105 @@
+package org.isoron.uhabits.ui;
+
+import android.app.KeyguardManager;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.IBinder;
+import android.os.PowerManager;
+import android.support.test.runner.AndroidJUnitRunner;
+import android.util.Log;
+
+import java.lang.reflect.Method;
+
+public final class SystemHelper extends AndroidJUnitRunner
+{
+    private static final String ANIMATION_PERMISSION = "android.permission.SET_ANIMATION_SCALE";
+    private static final float DISABLED = 0.0f;
+    private static final float DEFAULT = 1.0f;
+
+    private final Context context;
+    private PowerManager.WakeLock wakeLock;
+
+    SystemHelper(Context context)
+    {
+        this.context = context;
+    }
+
+    void acquireWakeLock()
+    {
+        PowerManager power = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+        wakeLock = power.newWakeLock(PowerManager.FULL_WAKE_LOCK |
+                PowerManager.ACQUIRE_CAUSES_WAKEUP |
+                PowerManager.ON_AFTER_RELEASE, getClass().getSimpleName());
+        wakeLock.acquire();
+    }
+
+    void releaseWakeLock()
+    {
+        if(wakeLock != null)
+            wakeLock.release();
+    }
+
+    void unlockScreen()
+    {
+        Log.i("SystemHelper", "Trying to unlock screen");
+        try
+        {
+            KeyguardManager mKeyGuardManager =
+                    (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
+            KeyguardManager.KeyguardLock mLock = mKeyGuardManager.newKeyguardLock("lock");
+            mLock.disableKeyguard();
+            Log.e("SystemHelper", "Successfully unlocked screen");
+        } catch (Exception e)
+        {
+            Log.e("SystemHelper", "Could not unlock screen");
+            e.printStackTrace();
+        }
+    }
+
+    void disableAllAnimations()
+    {
+        Log.i("SystemHelper", "Trying to disable animations");
+        int permStatus = context.checkCallingOrSelfPermission(ANIMATION_PERMISSION);
+        if (permStatus == PackageManager.PERMISSION_GRANTED) setSystemAnimationsScale(DISABLED);
+        else Log.e("SystemHelper", "Permission denied");
+
+    }
+
+    void enableAllAnimations()
+    {
+        int permStatus = context.checkCallingOrSelfPermission(ANIMATION_PERMISSION);
+        if (permStatus == PackageManager.PERMISSION_GRANTED)
+        {
+            setSystemAnimationsScale(DEFAULT);
+        }
+    }
+
+    private void setSystemAnimationsScale(float animationScale)
+    {
+        try
+        {
+            Class<?> windowManagerStubClazz = Class.forName("android.view.IWindowManager$Stub");
+            Method asInterface =
+                    windowManagerStubClazz.getDeclaredMethod("asInterface", IBinder.class);
+            Class<?> serviceManagerClazz = Class.forName("android.os.ServiceManager");
+            Method getService = serviceManagerClazz.getDeclaredMethod("getService", String.class);
+            Class<?> windowManagerClazz = Class.forName("android.view.IWindowManager");
+            Method setAnimationScales =
+                    windowManagerClazz.getDeclaredMethod("setAnimationScales", float[].class);
+            Method getAnimationScales = windowManagerClazz.getDeclaredMethod("getAnimationScales");
+
+            IBinder windowManagerBinder = (IBinder) getService.invoke(null, "window");
+            Object windowManagerObj = asInterface.invoke(null, windowManagerBinder);
+            float[] currentScales = (float[]) getAnimationScales.invoke(windowManagerObj);
+            for (int i = 0; i < currentScales.length; i++)
+                currentScales[i] = animationScale;
+
+            setAnimationScales.invoke(windowManagerObj, new Object[]{currentScales});
+            Log.i("SystemHelper", "All animations successfully disabled");
+        }
+        catch (Exception e)
+        {
+            Log.e("SystemHelper", "Could not change animation scale to " + animationScale + " :'(");
+        }
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/HabitFixtures.java

@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit;
+
+import android.content.Context;
+import android.support.annotation.Nullable;
+import android.util.Log;
+
+import org.isoron.uhabits.helpers.DatabaseHelper;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.tasks.BaseTask;
+import org.isoron.uhabits.tasks.ExportDBTask;
+import org.isoron.uhabits.tasks.ImportDataTask;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.Random;
+
+import static org.junit.Assert.fail;
+
+public class HabitFixtures
+{
+    public static boolean NON_DAILY_HABIT_CHECKS[] = { true, false, false, true, true, true, false,
+            false, true, true };
+
+    public static Habit createShortHabit()
+    {
+        Habit habit = new Habit();
+        habit.name = "Wake up early";
+        habit.description = "Did you wake up before 6am?";
+        habit.freqNum = 2;
+        habit.freqDen = 3;
+        habit.save();
+
+        long timestamp = DateHelper.getStartOfToday();
+        for(boolean c : NON_DAILY_HABIT_CHECKS)
+        {
+            if(c) habit.repetitions.toggle(timestamp);
+            timestamp -= DateHelper.millisecondsInOneDay;
+        }
+
+        return habit;
+    }
+
+    public static Habit createEmptyHabit()
+    {
+        Habit habit = new Habit();
+        habit.name = "Meditate";
+        habit.description = "Did you meditate this morning?";
+        habit.color = 3;
+        habit.freqNum = 1;
+        habit.freqDen = 1;
+        habit.save();
+        return habit;
+    }
+
+    public static Habit createLongHabit()
+    {
+        Habit habit = createEmptyHabit();
+        habit.freqNum = 3;
+        habit.freqDen = 7;
+        habit.color = 4;
+        habit.save();
+
+        long day = DateHelper.millisecondsInOneDay;
+        long today = DateHelper.getStartOfToday();
+        int marks[] = { 0, 1, 3, 5, 7, 8, 9, 10, 12, 14, 15, 17, 19, 20, 26, 27, 28, 50, 51, 52,
+                53, 54, 58, 60, 63, 65, 70, 71, 72, 73, 74, 75, 80, 81, 83, 89, 90, 91, 95,
+                102, 103, 108, 109, 120};
+
+        for(int mark : marks)
+            habit.repetitions.toggle(today - mark * day);
+
+        return habit;
+    }
+
+    public static void generateHugeDataSet() throws Throwable
+    {
+        final int nHabits = 30;
+        final int nYears = 5;
+
+        DatabaseHelper.executeAsTransaction(new DatabaseHelper.Command()
+        {
+            @Override
+            public void execute()
+            {
+                Random rand = new Random();
+
+                for(int i = 0; i < nHabits; i++)
+                {
+                    Log.i("HabitFixture", String.format("Creating habit %d / %d", i, nHabits));
+
+                    Habit habit = new Habit();
+                    habit.name = String.format("Habit %d", i);
+                    habit.save();
+
+                    long today = DateHelper.getStartOfToday();
+                    long day = DateHelper.millisecondsInOneDay;
+
+
+                    for(int j = 0; j < 365 * nYears; j++)
+                    {
+                        if(rand.nextBoolean())
+                            habit.repetitions.toggle(today - j * day);
+                    }
+
+                    habit.scores.getTodayValue();
+                    habit.streaks.getAll(1);
+                }
+            }
+        });
+
+        ExportDBTask task = new ExportDBTask(null);
+        task.setListener(new ExportDBTask.Listener()
+        {
+            @Override
+            public void onExportDBFinished(@Nullable String filename)
+            {
+                if(filename != null)
+                    Log.i("HabitFixture", String.format("Huge data set exported to %s", filename));
+                else
+                    Log.i("HabitFixture", "Failed to save database");
+            }
+        });
+        task.execute();
+
+        BaseTask.waitForTasks(30000);
+    }
+
+    public static void loadHugeDataSet(Context testContext) throws Throwable
+    {
+        File baseDir = DatabaseHelper.getFilesDir("Backups");
+        if(baseDir == null) fail("baseDir should not be null");
+
+        File dst = new File(String.format("%s/%s", baseDir.getPath(), "loopHuge.db"));
+        InputStream in = testContext.getAssets().open("fixtures/loopHuge.db");
+        DatabaseHelper.copy(in, dst);
+
+        ImportDataTask task = new ImportDataTask(dst, null);
+        task.execute();
+
+        BaseTask.waitForTasks(30000);
+    }
+
+    public static void purgeHabits()
+    {
+        for(Habit h : Habit.getAll(true))
+            h.cascadeDelete();
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/HabitsApplicationTest.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit;
+
+import android.os.Build;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.HabitsApplication;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class HabitsApplicationTest
+{
+    @Test
+    public void test_getLogcat() throws IOException
+    {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN)
+            return;
+
+        String msg = "LOGCAT TEST";
+        new RuntimeException(msg).printStackTrace();
+
+        String log = HabitsApplication.getLogcat();
+        assertThat(log, containsString(msg));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/commands/ArchiveHabitsCommandTest.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.commands;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.commands.ArchiveHabitsCommand;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.Collections;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ArchiveHabitsCommandTest extends BaseTest
+{
+
+    private ArchiveHabitsCommand command;
+    private Habit habit;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        habit = HabitFixtures.createShortHabit();
+        command = new ArchiveHabitsCommand(Collections.singletonList(habit));
+    }
+
+    @Test
+    public void testExecuteUndoRedo()
+    {
+        assertFalse(habit.isArchived());
+
+        command.execute();
+        assertTrue(habit.isArchived());
+
+        command.undo();
+        assertFalse(habit.isArchived());
+
+        command.execute();
+        assertTrue(habit.isArchived());
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/commands/ChangeHabitColorCommandTest.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.commands;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.commands.ChangeHabitColorCommand;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.LinkedList;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ChangeHabitColorCommandTest extends BaseTest
+{
+    private ChangeHabitColorCommand command;
+    private LinkedList<Habit> habits;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        habits = new LinkedList<>();
+
+        for(int i = 0; i < 3; i ++)
+        {
+            Habit habit = HabitFixtures.createShortHabit();
+            habit.color = i+1;
+            habit.save();
+            habits.add(habit);
+        }
+
+        command = new ChangeHabitColorCommand(habits, 0);
+    }
+
+    @Test
+    public void testExecuteUndoRedo()
+    {
+        checkOriginalColors();
+
+        command.execute();
+        checkNewColors();
+
+        command.undo();
+        checkOriginalColors();
+
+        command.execute();
+        checkNewColors();
+    }
+
+    private void checkOriginalColors()
+    {
+        int k = 0;
+        for(Habit h : habits)
+            assertThat(h.color, equalTo(++k));
+    }
+
+    private void checkNewColors()
+    {
+        for(Habit h : habits)
+            assertThat(h.color, equalTo(0));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/commands/CreateHabitCommandTest.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.commands;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.commands.CreateHabitCommand;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+
+import static junit.framework.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class CreateHabitCommandTest extends BaseTest
+{
+
+    private CreateHabitCommand command;
+    private Habit model;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        model = new Habit();
+        model.name = "New habit";
+        command = new CreateHabitCommand(model);
+
+        HabitFixtures.purgeHabits();
+    }
+
+    @Test
+    public void testExecuteUndoRedo()
+    {
+        assertTrue(Habit.getAll(true).isEmpty());
+
+        command.execute();
+
+        List<Habit> allHabits = Habit.getAll(true);
+        assertThat(allHabits.size(), equalTo(1));
+
+        Habit habit = allHabits.get(0);
+        Long id = habit.getId();
+        assertThat(habit.name, equalTo(model.name));
+
+        command.undo();
+        assertTrue(Habit.getAll(true).isEmpty());
+
+        command.execute();
+        allHabits = Habit.getAll(true);
+        assertThat(allHabits.size(), equalTo(1));
+
+        habit = allHabits.get(0);
+        Long newId = habit.getId();
+        assertThat(id, equalTo(newId));
+        assertThat(habit.name, equalTo(model.name));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/commands/DeleteHabitsCommandTest.java

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.commands;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.commands.DeleteHabitsCommand;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+
+import java.util.LinkedList;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class DeleteHabitsCommandTest extends BaseTest
+{
+    private DeleteHabitsCommand command;
+    private LinkedList<Habit> habits;
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        habits = new LinkedList<>();
+
+        // Habits that shuold be deleted
+        for(int i = 0; i < 3; i ++)
+        {
+            Habit habit = HabitFixtures.createShortHabit();
+            habits.add(habit);
+        }
+
+        // Extra habit that should not be deleted
+        Habit extraHabit = HabitFixtures.createShortHabit();
+        extraHabit.name = "extra";
+        extraHabit.save();
+
+        command = new DeleteHabitsCommand(habits);
+    }
+
+    @Test
+    public void testExecuteUndoRedo()
+    {
+        assertThat(Habit.getAll(true).size(), equalTo(4));
+
+        command.execute();
+        assertThat(Habit.getAll(true).size(), equalTo(1));
+        assertThat(Habit.getAll(true).get(0).name, equalTo("extra"));
+
+        thrown.expect(UnsupportedOperationException.class);
+        command.undo();
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/commands/EditHabitCommandTest.java

@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *  
+ * This file is part of Loop Habit Tracker.
+ *  
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *  
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *  
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.commands;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.commands.EditHabitCommand;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static junit.framework.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.greaterThan;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class EditHabitCommandTest extends BaseTest
+{
+
+    private EditHabitCommand command;
+    private Habit habit;
+    private Habit modified;
+    private Long id;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        habit = HabitFixtures.createShortHabit();
+        habit.name = "original";
+        habit.freqDen = 1;
+        habit.freqNum = 1;
+        habit.save();
+
+        id = habit.getId();
+
+        modified = new Habit(habit);
+        modified.name = "modified";
+    }
+
+    @Test
+    public void testExecuteUndoRedo()
+    {
+        command = new EditHabitCommand(habit, modified);
+
+        int originalScore = habit.scores.getTodayValue();
+        assertThat(habit.name, equalTo("original"));
+
+        command.execute();
+        refreshHabit();
+        assertThat(habit.name, equalTo("modified"));
+        assertThat(habit.scores.getTodayValue(), equalTo(originalScore));
+
+        command.undo();
+        refreshHabit();
+        assertThat(habit.name, equalTo("original"));
+        assertThat(habit.scores.getTodayValue(), equalTo(originalScore));
+
+        command.execute();
+        refreshHabit();
+        assertThat(habit.name, equalTo("modified"));
+        assertThat(habit.scores.getTodayValue(), equalTo(originalScore));
+    }
+
+    @Test
+    public void testExecuteUndoRedo_withModifiedInterval()
+    {
+        modified.freqNum = 1;
+        modified.freqDen = 7;
+        command = new EditHabitCommand(habit, modified);
+
+        int originalScore = habit.scores.getTodayValue();
+        assertThat(habit.name, equalTo("original"));
+
+        command.execute();
+        refreshHabit();
+        assertThat(habit.name, equalTo("modified"));
+        assertThat(habit.scores.getTodayValue(), greaterThan(originalScore));
+
+        command.undo();
+        refreshHabit();
+        assertThat(habit.name, equalTo("original"));
+        assertThat(habit.scores.getTodayValue(), equalTo(originalScore));
+
+        command.execute();
+        refreshHabit();
+        assertThat(habit.name, equalTo("modified"));
+        assertThat(habit.scores.getTodayValue(), greaterThan(originalScore));
+    }
+
+    private void refreshHabit()
+    {
+        habit = Habit.get(id);
+        assertTrue(habit != null);
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/commands/ToggleRepetitionCommandTest.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.commands;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.commands.ToggleRepetitionCommand;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ToggleRepetitionCommandTest extends BaseTest
+{
+
+    private ToggleRepetitionCommand command;
+    private Habit habit;
+    private long today;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        habit = HabitFixtures.createShortHabit();
+
+        today = DateHelper.getStartOfToday();
+        command = new ToggleRepetitionCommand(habit, today);
+    }
+
+    @Test
+    public void testExecuteUndoRedo()
+    {
+        assertTrue(habit.repetitions.contains(today));
+
+        command.execute();
+        assertFalse(habit.repetitions.contains(today));
+
+        command.undo();
+        assertTrue(habit.repetitions.contains(today));
+
+        command.execute();
+        assertFalse(habit.repetitions.contains(today));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/commands/UnarchiveHabitsCommandTest.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.commands;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.commands.UnarchiveHabitsCommand;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.Collections;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class UnarchiveHabitsCommandTest extends BaseTest
+{
+
+    private UnarchiveHabitsCommand command;
+    private Habit habit;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        habit = HabitFixtures.createShortHabit();
+        Habit.archive(Collections.singletonList(habit));
+
+        command = new UnarchiveHabitsCommand(Collections.singletonList(habit));
+    }
+
+    @Test
+    public void testExecuteUndoRedo()
+    {
+        assertTrue(habit.isArchived());
+
+        command.execute();
+        assertFalse(habit.isArchived());
+
+        command.undo();
+        assertTrue(habit.isArchived());
+
+        command.execute();
+        assertFalse(habit.isArchived());
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/io/HabitsCSVExporterTest.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.io;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.helpers.DatabaseHelper;
+import org.isoron.uhabits.io.HabitsCSVExporter;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import static junit.framework.Assert.assertTrue;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class HabitsCSVExporterTest extends BaseTest
+{
+    private File baseDir;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        HabitFixtures.createShortHabit();
+        HabitFixtures.createEmptyHabit();
+
+        Context targetContext = InstrumentationRegistry.getTargetContext();
+        baseDir = targetContext.getCacheDir();
+    }
+
+    private void unzip(File file) throws IOException
+    {
+        ZipFile zip = new ZipFile(file);
+        Enumeration<? extends ZipEntry> e = zip.entries();
+
+        while(e.hasMoreElements())
+        {
+            ZipEntry entry = e.nextElement();
+            InputStream stream = zip.getInputStream(entry);
+
+            String outputFilename = String.format("%s/%s", baseDir.getAbsolutePath(),
+                    entry.getName());
+            File outputFile = new File(outputFilename);
+
+            File parent = outputFile.getParentFile();
+            if(parent != null) parent.mkdirs();
+
+            DatabaseHelper.copy(stream, outputFile);
+        }
+
+        zip.close();
+    }
+
+    @Test
+    public void testExportCSV() throws IOException
+    {
+        List<Habit> habits = Habit.getAll(true);
+
+        HabitsCSVExporter exporter = new HabitsCSVExporter(habits, baseDir);
+        String filename = exporter.writeArchive();
+        assertAbsolutePathExists(filename);
+
+        File archive = new File(filename);
+        unzip(archive);
+
+        assertPathExists("Habits.csv");
+        assertPathExists("001 Wake up early");
+        assertPathExists("001 Wake up early/Checkmarks.csv");
+        assertPathExists("001 Wake up early/Scores.csv");
+        assertPathExists("002 Meditate/Checkmarks.csv");
+        assertPathExists("002 Meditate/Scores.csv");
+    }
+
+    private void assertPathExists(String s)
+    {
+        assertAbsolutePathExists(String.format("%s/%s", baseDir.getAbsolutePath(), s));
+    }
+
+    private void assertAbsolutePathExists(String s)
+    {
+        File file = new File(s);
+        assertTrue(String.format("File %s should exist", file.getAbsolutePath()), file.exists());
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/io/ImportTest.java

@@ -0,0 +1,173 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.io;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.helpers.DatabaseHelper;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.io.GenericImporter;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.GregorianCalendar;
+import java.util.List;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ImportTest extends BaseTest
+{
+    private File baseDir;
+    private Context context;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+        DateHelper.setFixedLocalTime(null);
+
+        HabitFixtures.purgeHabits();
+        context = InstrumentationRegistry.getInstrumentation().getContext();
+        baseDir = DatabaseHelper.getFilesDir("Backups");
+        if(baseDir == null) fail("baseDir should not be null");
+    }
+
+    private void copyAssetToFile(String assetPath, File dst) throws IOException
+    {
+        InputStream in = context.getAssets().open(assetPath);
+        DatabaseHelper.copy(in, dst);
+    }
+
+    private void importFromFile(String assetFilename) throws IOException
+    {
+        File file = new File(String.format("%s/%s", baseDir.getPath(), assetFilename));
+        copyAssetToFile(assetFilename, file);
+        assertTrue(file.exists());
+        assertTrue(file.canRead());
+
+        GenericImporter importer = new GenericImporter();
+        assertThat(importer.canHandle(file), is(true));
+
+        importer.importHabitsFromFile(file);
+    }
+
+    private boolean containsRepetition(Habit h, int year, int month, int day)
+    {
+        GregorianCalendar date = DateHelper.getStartOfTodayCalendar();
+        date.set(year, month - 1, day);
+        return h.repetitions.contains(date.getTimeInMillis());
+    }
+
+    @Test
+    public void testTickmateDB() throws IOException
+    {
+        importFromFile("tickmate.db");
+
+        List<Habit> habits = Habit.getAll(true);
+        assertThat(habits.size(), equalTo(3));
+
+        Habit h = habits.get(0);
+        assertThat(h.name, equalTo("Vegan"));
+        assertTrue(containsRepetition(h, 2016, 1, 24));
+        assertTrue(containsRepetition(h, 2016, 2, 5));
+        assertTrue(containsRepetition(h, 2016, 3, 18));
+        assertFalse(containsRepetition(h, 2016, 3, 14));
+    }
+
+    @Test
+    public void testRewireDB() throws IOException
+    {
+        importFromFile("rewire.db");
+
+        List<Habit> habits = Habit.getAll(true);
+        assertThat(habits.size(), equalTo(3));
+
+        Habit habit = habits.get(0);
+        assertThat(habit.name, equalTo("Wake up early"));
+        assertThat(habit.freqNum, equalTo(3));
+        assertThat(habit.freqDen, equalTo(7));
+        assertFalse(habit.hasReminder());
+        assertFalse(containsRepetition(habit, 2015, 12, 31));
+        assertTrue(containsRepetition(habit, 2016, 1, 18));
+        assertTrue(containsRepetition(habit, 2016, 1, 28));
+        assertFalse(containsRepetition(habit, 2016, 3, 10));
+
+        habit = habits.get(1);
+        assertThat(habit.name, equalTo("brush teeth"));
+        assertThat(habit.freqNum, equalTo(3));
+        assertThat(habit.freqDen, equalTo(7));
+        assertThat(habit.reminderHour, equalTo(8));
+        assertThat(habit.reminderMin, equalTo(0));
+        boolean[] reminderDays = {false, true, true, true, true, true, false};
+        assertThat(habit.reminderDays, equalTo(DateHelper.packWeekdayList(reminderDays)));
+    }
+
+    @Test
+    public void testHabitBullCSV() throws IOException
+    {
+        importFromFile("habitbull.csv");
+
+        List<Habit> habits = Habit.getAll(true);
+        assertThat(habits.size(), equalTo(4));
+
+        Habit habit = habits.get(0);
+        assertThat(habit.name, equalTo("Breed dragons"));
+        assertThat(habit.description, equalTo("with love and fire"));
+        assertThat(habit.freqNum, equalTo(1));
+        assertThat(habit.freqDen, equalTo(1));
+        assertTrue(containsRepetition(habit, 2016, 3, 18));
+        assertTrue(containsRepetition(habit, 2016, 3, 19));
+        assertFalse(containsRepetition(habit, 2016, 3, 20));
+    }
+
+    @Test
+    public void testLoopDB() throws IOException
+    {
+        importFromFile("loop.db");
+
+        List<Habit> habits = Habit.getAll(true);
+        assertThat(habits.size(), equalTo(9));
+
+        Habit habit = habits.get(0);
+        assertThat(habit.name, equalTo("Wake up early"));
+        assertThat(habit.freqNum, equalTo(3));
+        assertThat(habit.freqDen, equalTo(7));
+        assertTrue(containsRepetition(habit, 2016, 3, 14));
+        assertTrue(containsRepetition(habit, 2016, 3, 16));
+        assertFalse(containsRepetition(habit, 2016, 3, 17));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/models/CheckmarkListTest.java

@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.models;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.io.StringWriter;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.isoron.uhabits.models.Checkmark.CHECKED_EXPLICITLY;
+import static org.isoron.uhabits.models.Checkmark.CHECKED_IMPLICITLY;
+import static org.isoron.uhabits.models.Checkmark.UNCHECKED;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class CheckmarkListTest extends BaseTest
+{
+    Habit nonDailyHabit;
+    private Habit emptyHabit;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        nonDailyHabit = HabitFixtures.createShortHabit();
+        emptyHabit = HabitFixtures.createEmptyHabit();
+    }
+
+    @After
+    public void tearDown()
+    {
+        DateHelper.setFixedLocalTime(null);
+    }
+
+    @Test
+    public void test_getAllValues_withNonDailyHabit()
+    {
+        int[] expectedValues = { CHECKED_EXPLICITLY, UNCHECKED, CHECKED_IMPLICITLY,
+                CHECKED_EXPLICITLY, CHECKED_EXPLICITLY, CHECKED_EXPLICITLY, UNCHECKED,
+                CHECKED_IMPLICITLY, CHECKED_EXPLICITLY, CHECKED_EXPLICITLY };
+
+        int[] actualValues = nonDailyHabit.checkmarks.getAllValues();
+
+        assertThat(actualValues, equalTo(expectedValues));
+    }
+
+    @Test
+    public void test_getAllValues_withEmptyHabit()
+    {
+        int[] expectedValues = new int[0];
+        int[] actualValues = emptyHabit.checkmarks.getAllValues();
+
+        assertThat(actualValues, equalTo(expectedValues));
+    }
+
+    @Test
+    public void test_getAllValues_moveForwardInTime()
+    {
+        travelInTime(3);
+
+        int[] expectedValues = { UNCHECKED, UNCHECKED, UNCHECKED, CHECKED_EXPLICITLY, UNCHECKED,
+                CHECKED_IMPLICITLY, CHECKED_EXPLICITLY, CHECKED_EXPLICITLY, CHECKED_EXPLICITLY,
+                UNCHECKED, CHECKED_IMPLICITLY, CHECKED_EXPLICITLY, CHECKED_EXPLICITLY };
+
+        int[] actualValues = nonDailyHabit.checkmarks.getAllValues();
+
+        assertThat(actualValues, equalTo(expectedValues));
+    }
+
+    @Test
+    public void test_getAllValues_moveBackwardsInTime()
+    {
+        travelInTime(-3);
+
+        int[] expectedValues = { CHECKED_EXPLICITLY, CHECKED_EXPLICITLY, CHECKED_EXPLICITLY,
+                UNCHECKED, CHECKED_IMPLICITLY, CHECKED_EXPLICITLY, CHECKED_EXPLICITLY };
+
+        int[] actualValues = nonDailyHabit.checkmarks.getAllValues();
+
+        assertThat(actualValues, equalTo(expectedValues));
+    }
+
+    @Test
+    public void test_getValues_withInvalidInterval()
+    {
+        int values[] = nonDailyHabit.checkmarks.getValues(100L, -100L);
+        assertThat(values, equalTo(new int[0]));
+    }
+
+    @Test
+    public void test_getValues_withValidInterval()
+    {
+        long from = DateHelper.getStartOfToday() - 15 * DateHelper.millisecondsInOneDay;
+        long to = DateHelper.getStartOfToday() - 5 * DateHelper.millisecondsInOneDay;
+
+        int[] expectedValues = { CHECKED_EXPLICITLY, UNCHECKED, CHECKED_IMPLICITLY,
+                CHECKED_EXPLICITLY, CHECKED_EXPLICITLY, UNCHECKED, UNCHECKED, UNCHECKED, UNCHECKED,
+                UNCHECKED, UNCHECKED };
+
+        int[] actualValues = nonDailyHabit.checkmarks.getValues(from, to);
+
+        assertThat(actualValues, equalTo(expectedValues));
+    }
+
+    @Test
+    public void test_getTodayValue()
+    {
+        travelInTime(-1);
+        assertThat(nonDailyHabit.checkmarks.getTodayValue(), equalTo(UNCHECKED));
+
+        travelInTime(0);
+        assertThat(nonDailyHabit.checkmarks.getTodayValue(), equalTo(CHECKED_EXPLICITLY));
+
+        travelInTime(1);
+        assertThat(nonDailyHabit.checkmarks.getTodayValue(), equalTo(UNCHECKED));
+    }
+
+    @Test
+    public void test_writeCSV() throws IOException
+    {
+        String expectedCSV =
+                "2015-01-16,2\n" +
+                "2015-01-17,2\n" +
+                "2015-01-18,1\n" +
+                "2015-01-19,0\n" +
+                "2015-01-20,2\n" +
+                "2015-01-21,2\n" +
+                "2015-01-22,2\n" +
+                "2015-01-23,1\n" +
+                "2015-01-24,0\n" +
+                "2015-01-25,2\n";
+
+        StringWriter writer = new StringWriter();
+        nonDailyHabit.checkmarks.writeCSV(writer);
+
+        assertThat(writer.toString(), equalTo(expectedCSV));
+    }
+
+    private void travelInTime(int days)
+    {
+        DateHelper.setFixedLocalTime(FIXED_LOCAL_TIME +
+                days * DateHelper.millisecondsInOneDay);
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/models/HabitTest.java

@@ -0,0 +1,378 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.models;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.hamcrest.MatcherAssert;
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class HabitTest extends BaseTest
+{
+    @Before
+    public void setup()
+    {
+        super.setup();
+        HabitFixtures.purgeHabits();
+    }
+
+    @Test
+    public void testConstructor_default()
+    {
+        Habit habit = new Habit();
+        assertThat(habit.archived, is(0));
+        assertThat(habit.highlight, is(0));
+
+        assertThat(habit.reminderHour, is(nullValue()));
+        assertThat(habit.reminderMin, is(nullValue()));
+
+        assertThat(habit.reminderDays, is(not(nullValue())));
+        assertThat(habit.streaks, is(not(nullValue())));
+        assertThat(habit.scores, is(not(nullValue())));
+        assertThat(habit.repetitions, is(not(nullValue())));
+        assertThat(habit.checkmarks, is(not(nullValue())));
+    }
+
+    @Test
+    public void testConstructor_habit()
+    {
+        Habit model = new Habit();
+        model.archived = 1;
+        model.highlight = 1;
+        model.color = 0;
+        model.freqNum = 10;
+        model.freqDen = 20;
+        model.reminderDays = 1;
+        model.reminderHour = 8;
+        model.reminderMin = 30;
+        model.position = 0;
+
+        Habit habit = new Habit(model);
+        assertThat(habit.archived, is(model.archived));
+        assertThat(habit.highlight, is(model.highlight));
+        assertThat(habit.color, is(model.color));
+        assertThat(habit.freqNum, is(model.freqNum));
+        assertThat(habit.freqDen, is(model.freqDen));
+        assertThat(habit.reminderDays, is(model.reminderDays));
+        assertThat(habit.reminderHour, is(model.reminderHour));
+        assertThat(habit.reminderMin, is(model.reminderMin));
+        assertThat(habit.position, is(model.position));
+    }
+
+    @Test
+    public void test_get_withValidId()
+    {
+        Habit habit = new Habit();
+        habit.save();
+
+        Habit habit2 = Habit.get(habit.getId());
+        assertThat(habit, equalTo(habit2));
+    }
+
+    @Test
+    public void test_get_withInvalidId()
+    {
+        Habit habit = Habit.get(123456L);
+        assertThat(habit, is(nullValue()));
+    }
+
+    @Test
+    public void test_getAll_withoutArchived()
+    {
+        List<Habit> habits = new LinkedList<>();
+        List<Habit> habitsWithArchived = new LinkedList<>();
+
+        for(int i = 0; i < 10; i++)
+        {
+            Habit h = new Habit();
+
+            if(i % 2 == 0)
+                h.archived = 1;
+            else
+                habits.add(h);
+
+            habitsWithArchived.add(h);
+            h.save();
+        }
+
+        assertThat(habits, equalTo(Habit.getAll(false)));
+        assertThat(habitsWithArchived, equalTo(Habit.getAll(true)));
+    }
+
+    @Test
+    public void test_getByPosition()
+    {
+        List<Habit> habits = new LinkedList<>();
+
+        for(int i = 0; i < 10; i++)
+        {
+            Habit h = new Habit();
+            h.save();
+            habits.add(h);
+        }
+
+        for(int i = 0; i < 10; i++)
+        {
+            Habit h = Habit.getByPosition(i);
+            if(h == null) fail();
+            assertThat(h, equalTo(habits.get(i)));
+        }
+    }
+
+    @Test
+    public void test_count()
+    {
+        for(int i = 0; i < 10; i++)
+        {
+            Habit h = new Habit();
+            if(i % 2 == 0) h.archived = 1;
+            h.save();
+        }
+
+        assertThat(Habit.count(), equalTo(5));
+    }
+
+
+    @Test
+    public void test_countWithArchived()
+    {
+        for(int i = 0; i < 10; i++)
+        {
+            Habit h = new Habit();
+            if(i % 2 == 0) h.archived = 1;
+            h.save();
+        }
+
+        assertThat(Habit.countWithArchived(), equalTo(10));
+    }
+
+    @Test
+    public void test_updateId()
+    {
+        Habit habit = new Habit();
+        habit.name = "Hello World";
+        habit.save();
+
+        Long oldId = habit.getId();
+        Long newId = 123456L;
+        Habit.updateId(oldId, newId);
+
+        Habit newHabit = Habit.get(newId);
+        if(newHabit == null) fail();
+        assertThat(newHabit, is(not(nullValue())));
+        assertThat(newHabit.name, equalTo(habit.name));
+    }
+
+    @Test
+    public void test_reorder()
+    {
+        List<Long> ids = new LinkedList<>();
+
+        int n = 10;
+        for (int i = 0; i < n; i++)
+        {
+            Habit h = new Habit();
+            h.save();
+            ids.add(h.getId());
+            assertThat(h.position, is(i));
+        }
+
+        int operations[][] = {
+                {5, 2},
+                {3, 7},
+                {4, 4},
+                {3, 2}
+        };
+
+        int expectedPosition[][] = {
+                {0, 1, 3, 4, 5, 2, 6, 7, 8, 9},
+                {0, 1, 7, 3, 4, 2, 5, 6, 8, 9},
+                {0, 1, 7, 3, 4, 2, 5, 6, 8, 9},
+                {0, 1, 7, 2, 4, 3, 5, 6, 8, 9},
+        };
+
+        for(int i = 0; i < operations.length; i++)
+        {
+            int from = operations[i][0];
+            int to = operations[i][1];
+
+            Habit fromHabit = Habit.getByPosition(from);
+            Habit toHabit = Habit.getByPosition(to);
+            Habit.reorder(fromHabit, toHabit);
+
+            int actualPositions[] = new int[n];
+
+            for (int j = 0; j < n; j++)
+            {
+                Habit h = Habit.get(ids.get(j));
+                if (h == null) fail();
+                actualPositions[j] = h.position;
+            }
+
+            assertThat(actualPositions, equalTo(expectedPosition[i]));
+        }
+    }
+
+    @Test
+    public  void test_rebuildOrder()
+    {
+        List<Long> ids = new LinkedList<>();
+        int originalPositions[] = { 0, 1, 1, 4, 6, 8, 10, 10, 13};
+
+        for (int p : originalPositions)
+        {
+            Habit h = new Habit();
+            h.position = p;
+            h.save();
+            ids.add(h.getId());
+        }
+
+        Habit.rebuildOrder();
+
+        for (int i = 0; i < originalPositions.length; i++)
+        {
+            Habit h = Habit.get(ids.get(i));
+            if(h == null) fail();
+            assertThat(h.position, is(i));
+        }
+    }
+
+    @Test
+    public void test_getHabitsWithReminder()
+    {
+        List<Habit> habitsWithReminder = new LinkedList<>();
+
+        for(int i = 0; i < 10; i++)
+        {
+            Habit habit = new Habit();
+            if(i % 2 == 0)
+            {
+                habit.reminderDays = DateHelper.ALL_WEEK_DAYS;
+                habit.reminderHour = 8;
+                habit.reminderMin = 30;
+                habitsWithReminder.add(habit);
+            }
+            habit.save();
+        }
+
+        assertThat(habitsWithReminder, equalTo(Habit.getHabitsWithReminder()));
+    }
+
+    @Test
+    public void test_archive_unarchive()
+    {
+        List<Habit> allHabits = new LinkedList<>();
+        List<Habit> archivedHabits = new LinkedList<>();
+        List<Habit> unarchivedHabits = new LinkedList<>();
+
+        for(int i = 0; i < 10; i++)
+        {
+            Habit habit = new Habit();
+            habit.save();
+            allHabits.add(habit);
+
+            if(i % 2 == 0)
+                archivedHabits.add(habit);
+            else
+                unarchivedHabits.add(habit);
+        }
+
+        Habit.archive(archivedHabits);
+        assertThat(Habit.getAll(false), equalTo(unarchivedHabits));
+        assertThat(Habit.getAll(true), equalTo(allHabits));
+
+        Habit.unarchive(archivedHabits);
+        assertThat(Habit.getAll(false), equalTo(allHabits));
+        assertThat(Habit.getAll(true), equalTo(allHabits));
+    }
+
+    @Test
+    public void test_setColor()
+    {
+        List<Habit> habits = new LinkedList<>();
+
+        for(int i = 0; i < 10; i++)
+        {
+            Habit habit = new Habit();
+            habit.color = i;
+            habit.save();
+            habits.add(habit);
+        }
+
+        int newColor = 100;
+        Habit.setColor(habits, newColor);
+
+        for(Habit h : habits)
+            assertThat(h.color, equalTo(newColor));
+    }
+
+    @Test
+    public void test_hasReminder_clearReminder()
+    {
+        Habit h = new Habit();
+        assertThat(h.hasReminder(), is(false));
+
+        h.reminderDays = DateHelper.ALL_WEEK_DAYS;
+        h.reminderHour = 8;
+        h.reminderMin = 30;
+        assertThat(h.hasReminder(), is(true));
+
+        h.clearReminder();
+        assertThat(h.hasReminder(), is(false));
+    }
+
+    @Test
+    public void test_writeCSV() throws IOException
+    {
+        HabitFixtures.createEmptyHabit();
+        HabitFixtures.createShortHabit();
+
+        String expectedCSV =
+                "Name,Description,NumRepetitions,Interval,Color\n" +
+                "Meditate,Did you meditate this morning?,1,1,#AFB42B\n" +
+                "Wake up early,Did you wake up before 6am?,2,3,#00897B\n";
+
+        StringWriter writer = new StringWriter();
+        Habit.writeCSV(Habit.getAll(true), writer);
+
+        MatcherAssert.assertThat(writer.toString(), equalTo(expectedCSV));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/models/RepetitionListTest.java

@@ -0,0 +1,191 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.models;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.models.Repetition;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.Random;
+
+import static junit.framework.Assert.assertFalse;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class RepetitionListTest extends BaseTest
+{
+    private Habit habit;
+    private Habit emptyHabit;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        habit = HabitFixtures.createShortHabit();
+        emptyHabit = HabitFixtures.createEmptyHabit();
+    }
+
+    @After
+    public void tearDown()
+    {
+        DateHelper.setFixedLocalTime(null);
+    }
+
+    @Test
+    public void test_contains()
+    {
+        long current = DateHelper.getStartOfToday();
+
+        for(boolean b : HabitFixtures.NON_DAILY_HABIT_CHECKS)
+        {
+            assertThat(habit.repetitions.contains(current), equalTo(b));
+            current -= DateHelper.millisecondsInOneDay;
+        }
+
+        for(int i = 0; i < 3; i++)
+        {
+            assertThat(habit.repetitions.contains(current), equalTo(false));
+            current -= DateHelper.millisecondsInOneDay;
+        }
+    }
+
+    @Test
+    public void test_delete()
+    {
+        long timestamp = DateHelper.getStartOfToday();
+        assertThat(habit.repetitions.contains(timestamp), equalTo(true));
+
+        habit.repetitions.delete(timestamp);
+        assertThat(habit.repetitions.contains(timestamp), equalTo(false));
+    }
+
+    @Test
+    public void test_toggle()
+    {
+        long timestamp = DateHelper.getStartOfToday();
+        assertThat(habit.repetitions.contains(timestamp), equalTo(true));
+
+        habit.repetitions.toggle(timestamp);
+        assertThat(habit.repetitions.contains(timestamp), equalTo(false));
+
+        habit.repetitions.toggle(timestamp);
+        assertThat(habit.repetitions.contains(timestamp), equalTo(true));
+    }
+
+    @Test
+    public void test_getWeekDayFrequency()
+    {
+        Random random = new Random();
+        Integer weekdayCount[][] = new Integer[12][7];
+        Integer monthCount[] = new Integer[12];
+
+        Arrays.fill(monthCount, 0);
+        for(Integer row[] : weekdayCount)
+            Arrays.fill(row, 0);
+
+        GregorianCalendar day = DateHelper.getStartOfTodayCalendar();
+
+        // Sets the current date to the end of November
+        day.set(2015, 10, 30);
+        DateHelper.setFixedLocalTime(day.getTimeInMillis());
+
+        // Add repetitions randomly from January to December
+        // Leaves the month of March empty, to check that it returns null
+        day.set(2015, 0, 1);
+        for(int i = 0; i < 365; i ++)
+        {
+            if(random.nextBoolean())
+            {
+                int month = day.get(Calendar.MONTH);
+                int week = day.get(Calendar.DAY_OF_WEEK) % 7;
+
+                if(month != 2)
+                {
+                    if (month <= 10)
+                    {
+                        weekdayCount[month][week]++;
+                        monthCount[month]++;
+                    }
+                    emptyHabit.repetitions.toggle(day.getTimeInMillis());
+                }
+            }
+
+            day.add(Calendar.DAY_OF_YEAR, 1);
+        }
+
+        HashMap<Long, Integer[]> freq = emptyHabit.repetitions.getWeekdayFrequency();
+
+        // Repetitions until November should be counted correctly
+        for(int month = 0; month < 11; month++)
+        {
+            day.set(2015, month, 1);
+            Integer actualCount[] = freq.get(day.getTimeInMillis());
+            if(monthCount[month] == 0)
+                assertThat(actualCount, equalTo(null));
+            else
+                assertThat(actualCount, equalTo(weekdayCount[month]));
+        }
+
+        // Repetitions in December should be discarded
+        day.set(2015, 11, 1);
+        assertThat(freq.get(day.getTimeInMillis()), equalTo(null));
+    }
+
+    @Test
+    public void test_count()
+    {
+        long to = DateHelper.getStartOfToday();
+        long from = to - 9 * DateHelper.millisecondsInOneDay;
+        assertThat(habit.repetitions.count(from, to), equalTo(6));
+
+        to = DateHelper.getStartOfToday() - DateHelper.millisecondsInOneDay;
+        from = to - 5 * DateHelper.millisecondsInOneDay;
+        assertThat(habit.repetitions.count(from, to), equalTo(3));
+    }
+
+    @Test
+    public void test_getOldest()
+    {
+        long expectedOldestTimestamp = DateHelper.getStartOfToday() - 9 * DateHelper.millisecondsInOneDay;
+
+        assertThat(habit.repetitions.getOldestTimestamp(), equalTo(expectedOldestTimestamp));
+
+        Repetition oldest = habit.repetitions.getOldest();
+        assertFalse(oldest == null);
+        assertThat(oldest.timestamp, equalTo(expectedOldestTimestamp));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/models/ScoreListTest.java

@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.models;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.helpers.DatabaseHelper;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.models.Score;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.io.StringWriter;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ScoreListTest extends BaseTest
+{
+    private Habit habit;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        habit = HabitFixtures.createEmptyHabit();
+    }
+
+    @After
+    public void tearDown()
+    {
+        DateHelper.setFixedLocalTime(null);
+    }
+
+    @Test
+    public void test_invalidateNewerThan()
+    {
+        assertThat(habit.scores.getTodayValue(), equalTo(0));
+
+        toggleRepetitions(0, 2);
+        assertThat(habit.scores.getTodayValue(), equalTo(1948077));
+
+        habit.freqNum = 1;
+        habit.freqDen = 2;
+        habit.scores.invalidateNewerThan(0);
+
+        assertThat(habit.scores.getTodayValue(), equalTo(1974654));
+    }
+
+    @Test
+    public void test_getTodayStarValue()
+    {
+        assertThat(habit.scores.getTodayStarStatus(), equalTo(Score.EMPTY_STAR));
+
+        int k = 0;
+        while(habit.scores.getTodayValue() < Score.HALF_STAR_CUTOFF) toggleRepetitions(k, ++k);
+        assertThat(habit.scores.getTodayStarStatus(), equalTo(Score.HALF_STAR));
+
+        while(habit.scores.getTodayValue() < Score.FULL_STAR_CUTOFF) toggleRepetitions(k, ++k);
+        assertThat(habit.scores.getTodayStarStatus(), equalTo(Score.FULL_STAR));
+    }
+
+    @Test
+    public void test_getTodayValue()
+    {
+        toggleRepetitions(0, 20);
+        assertThat(habit.scores.getTodayValue(), equalTo(12629351));
+    }
+
+    @Test
+    public void test_getValue()
+    {
+        toggleRepetitions(0, 20);
+
+        int expectedValues[] = { 12629351, 12266245, 11883254, 11479288, 11053198, 10603773,
+                10129735, 9629735, 9102352, 8546087, 7959357, 7340494, 6687738, 5999234, 5273023,
+                4507040, 3699107, 2846927, 1948077, 1000000 };
+
+        long current = DateHelper.getStartOfToday();
+        for(int expectedValue : expectedValues)
+        {
+            assertThat(habit.scores.getValue(current), equalTo(expectedValue));
+            current -= DateHelper.millisecondsInOneDay;
+        }
+    }
+
+    @Test
+    public void test_getAllValues_withoutGroups()
+    {
+        toggleRepetitions(0, 20);
+
+        int expectedValues[] = { 12629351, 12266245, 11883254, 11479288, 11053198, 10603773,
+                10129735, 9629735, 9102352, 8546087, 7959357, 7340494, 6687738, 5999234, 5273023,
+                4507040, 3699107, 2846927, 1948077, 1000000 };
+
+        int actualValues[] = habit.scores.getAllValues(1);
+        assertThat(actualValues, equalTo(expectedValues));
+    }
+
+    @Test
+    public void test_getAllValues_withGroups()
+    {
+        toggleRepetitions(0, 20);
+
+        int expectedValues[] = { 11434978, 7894999, 3212362 };
+
+        int actualValues[] = habit.scores.getAllValues(7);
+        assertThat(actualValues, equalTo(expectedValues));
+    }
+
+    @Test
+    public void test_writeCSV() throws IOException
+    {
+        HabitFixtures.purgeHabits();
+        Habit habit = HabitFixtures.createShortHabit();
+
+        String expectedCSV =
+                "2015-01-16,0.0519\n" +
+                "2015-01-17,0.1021\n" +
+                "2015-01-18,0.0986\n" +
+                "2015-01-19,0.0952\n" +
+                "2015-01-20,0.1439\n" +
+                "2015-01-21,0.1909\n" +
+                "2015-01-22,0.2364\n" +
+                "2015-01-23,0.2283\n" +
+                "2015-01-24,0.2205\n" +
+                "2015-01-25,0.2649\n";
+
+        StringWriter writer = new StringWriter();
+        habit.scores.writeCSV(writer);
+
+        assertThat(writer.toString(), equalTo(expectedCSV));
+    }
+
+    private void toggleRepetitions(final int from, final int to)
+    {
+        DatabaseHelper.executeAsTransaction(new DatabaseHelper.Command()
+        {
+            @Override
+            public void execute()
+            {
+                long today = DateHelper.getStartOfToday();
+                for (int i = from; i < to; i++)
+                    habit.repetitions.toggle(today - i * DateHelper.millisecondsInOneDay);
+            }
+        });
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/models/ScoreTest.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.models;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.models.Checkmark;
+import org.isoron.uhabits.models.Score;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ScoreTest extends BaseTest
+{
+    @Before
+    public void setup()
+    {
+        super.setup();
+    }
+
+    @Test
+    public void test_compute_withDailyHabit()
+    {
+        int checkmark = Checkmark.UNCHECKED;
+        assertThat(Score.compute(1, 0, checkmark), equalTo(0));
+        assertThat(Score.compute(1, 5000000, checkmark), equalTo(4740387));
+        assertThat(Score.compute(1, 10000000, checkmark), equalTo(9480775));
+        assertThat(Score.compute(1, Score.MAX_VALUE, checkmark), equalTo(18259478));
+
+        checkmark = Checkmark.CHECKED_IMPLICITLY;
+        assertThat(Score.compute(1, 0, checkmark), equalTo(0));
+        assertThat(Score.compute(1, 5000000, checkmark), equalTo(4740387));
+        assertThat(Score.compute(1, 10000000, checkmark), equalTo(9480775));
+        assertThat(Score.compute(1, Score.MAX_VALUE, checkmark), equalTo(18259478));
+
+        checkmark = Checkmark.CHECKED_EXPLICITLY;
+        assertThat(Score.compute(1, 0, checkmark), equalTo(1000000));
+        assertThat(Score.compute(1, 5000000, checkmark), equalTo(5740387));
+        assertThat(Score.compute(1, 10000000, checkmark), equalTo(10480775));
+        assertThat(Score.compute(1, Score.MAX_VALUE, checkmark), equalTo(Score.MAX_VALUE));
+    }
+
+    @Test
+    public void test_compute_withNonDailyHabit()
+    {
+        int checkmark = Checkmark.CHECKED_EXPLICITLY;
+        assertThat(Score.compute(1/3.0, 0, checkmark), equalTo(1000000));
+        assertThat(Score.compute(1/3.0, 5000000, checkmark), equalTo(5916180));
+        assertThat(Score.compute(1/3.0, 10000000, checkmark), equalTo(10832360));
+        assertThat(Score.compute(1/3.0, Score.MAX_VALUE, checkmark), equalTo(Score.MAX_VALUE));
+
+        assertThat(Score.compute(1/7.0, 0, checkmark), equalTo(1000000));
+        assertThat(Score.compute(1/7.0, 5000000, checkmark), equalTo(5964398));
+        assertThat(Score.compute(1/7.0, 10000000, checkmark), equalTo(10928796));
+        assertThat(Score.compute(1/7.0, Score.MAX_VALUE, checkmark), equalTo(Score.MAX_VALUE));
+    }
+
+    @Test
+    public void test_getStarStatus()
+    {
+        Score s = new Score();
+
+        s.score = Score.FULL_STAR_CUTOFF + 1;
+        assertThat(s.getStarStatus(), equalTo(Score.FULL_STAR));
+
+        s.score = Score.FULL_STAR_CUTOFF;
+        assertThat(s.getStarStatus(), equalTo(Score.FULL_STAR));
+
+        s.score = Score.FULL_STAR_CUTOFF - 1;
+        assertThat(s.getStarStatus(), equalTo(Score.HALF_STAR));
+        
+        s.score = Score.HALF_STAR_CUTOFF + 1;
+        assertThat(s.getStarStatus(), equalTo(Score.HALF_STAR));
+
+        s.score = Score.HALF_STAR_CUTOFF;
+        assertThat(s.getStarStatus(), equalTo(Score.HALF_STAR));
+        
+        s.score = Score.HALF_STAR_CUTOFF - 1;
+        assertThat(s.getStarStatus(), equalTo(Score.EMPTY_STAR));
+
+        s.score = 0;
+        assertThat(s.getStarStatus(), equalTo(Score.EMPTY_STAR));
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/tasks/ExportCSVTaskTest.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.tasks;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.widget.ProgressBar;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.tasks.ExportCSVTask;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.util.List;
+
+import static junit.framework.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.core.IsNot.not;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ExportCSVTaskTest extends BaseTest
+{
+    @Before
+    public void setup()
+    {
+        super.setup();
+    }
+
+    @Test
+    public void testExportCSV() throws Throwable
+    {
+        HabitFixtures.createShortHabit();
+        List<Habit> habits = Habit.getAll(true);
+        ProgressBar bar = new ProgressBar(targetContext);
+
+        ExportCSVTask task = new ExportCSVTask(habits, bar);
+        task.setListener(new ExportCSVTask.Listener()
+        {
+            @Override
+            public void onExportCSVFinished(String archiveFilename)
+            {
+                assertThat(archiveFilename, is(not(nullValue())));
+
+                File f = new File(archiveFilename);
+                assertTrue(f.exists());
+                assertTrue(f.canRead());
+            }
+        });
+
+        task.execute();
+        waitForAsyncTasks();
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/tasks/ExportDBTaskTest.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.tasks;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.widget.ProgressBar;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.tasks.ExportDBTask;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+
+import static junit.framework.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
+import static org.hamcrest.core.IsNot.not;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ExportDBTaskTest extends BaseTest
+{
+    @Before
+    public void setup()
+    {
+        super.setup();
+    }
+
+    @Test
+    public void testExportCSV() throws Throwable
+    {
+        Context context = InstrumentationRegistry.getContext();
+
+        ProgressBar bar = new ProgressBar(context);
+        ExportDBTask task = new ExportDBTask(bar);
+        task.setListener(new ExportDBTask.Listener()
+        {
+            @Override
+            public void onExportDBFinished(String filename)
+            {
+                assertThat(filename, is(not(nullValue())));
+
+                File f = new File(filename);
+                assertTrue(f.exists());
+                assertTrue(f.canRead());
+            }
+        });
+
+        task.execute();
+        waitForAsyncTasks();
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/tasks/ImportDataTaskTest.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.tasks;
+
+import android.support.annotation.NonNull;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.widget.ProgressBar;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.helpers.DatabaseHelper;
+import org.isoron.uhabits.tasks.ImportDataTask;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.fail;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class ImportDataTaskTest extends BaseTest
+{
+    private File baseDir;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        baseDir = DatabaseHelper.getFilesDir("Backups");
+        if(baseDir == null) fail("baseDir should not be null");
+    }
+
+    private void copyAssetToFile(String assetPath, File dst) throws IOException
+    {
+        InputStream in = testContext.getAssets().open(assetPath);
+        DatabaseHelper.copy(in, dst);
+    }
+
+    private void assertTaskResult(final int expectedResult, String assetFilename) throws Throwable
+    {
+        ImportDataTask task = createTask(assetFilename);
+
+        task.setListener(new ImportDataTask.Listener()
+        {
+            @Override
+            public void onImportFinished(int result)
+            {
+                assertThat(result, equalTo(expectedResult));
+            }
+        });
+
+        task.execute();
+        waitForAsyncTasks();
+    }
+
+    @NonNull
+    private ImportDataTask createTask(String assetFilename) throws IOException
+    {
+        ProgressBar bar = new ProgressBar(targetContext);
+        File file = new File(String.format("%s/%s", baseDir.getPath(), assetFilename));
+        copyAssetToFile(assetFilename, file);
+
+        return new ImportDataTask(file, bar);
+    }
+
+    @Test
+    public void testImportInvalidData() throws Throwable
+    {
+        assertTaskResult(ImportDataTask.NOT_RECOGNIZED, "icon.png");
+    }
+
+    @Test
+    public void testImportValidData() throws Throwable
+    {
+        assertTaskResult(ImportDataTask.SUCCESS, "loop.db");
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/views/CheckmarkWidgetViewTest.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.views;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.R;
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.helpers.UIHelper;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.isoron.uhabits.views.CheckmarkWidgetView;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class CheckmarkWidgetViewTest extends ViewTest
+{
+    private CheckmarkWidgetView view;
+    private Habit habit;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+        UIHelper.setFixedTheme(R.style.TransparentWidgetTheme);
+
+        habit = HabitFixtures.createShortHabit();
+        view = new CheckmarkWidgetView(targetContext);
+        view.setHabit(habit);
+        refreshData(view);
+        measureView(dpToPixels(100), dpToPixels(200), view);
+    }
+
+    @Test
+    public void testRender_checked() throws IOException
+    {
+        assertRenders(view, "CheckmarkView/checked.png");
+    }
+
+    @Test
+    public void testRender_unchecked() throws IOException
+    {
+        habit.repetitions.toggle(DateHelper.getStartOfToday());
+        view.refreshData();
+
+        assertRenders(view, "CheckmarkView/unchecked.png");
+    }
+
+    @Test
+    public void testRender_implicitlyChecked() throws IOException
+    {
+        long today = DateHelper.getStartOfToday();
+        long day = DateHelper.millisecondsInOneDay;
+        habit.repetitions.toggle(today);
+        habit.repetitions.toggle(today - day);
+        habit.repetitions.toggle(today - 2 * day);
+        view.refreshData();
+
+        assertRenders(view, "CheckmarkView/implicitly_checked.png");
+    }
+
+    @Test
+    public void testRender_largeSize() throws IOException
+    {
+        measureView(dpToPixels(300), dpToPixels(300), view);
+        assertRenders(view, "CheckmarkView/large_size.png");
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/views/HabitFrequencyViewTest.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.views;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.isoron.uhabits.views.HabitFrequencyView;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class HabitFrequencyViewTest extends ViewTest
+{
+    private HabitFrequencyView view;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        Habit habit = HabitFixtures.createLongHabit();
+
+        view = new HabitFrequencyView(targetContext);
+        view.setHabit(habit);
+        refreshData(view);
+        measureView(dpToPixels(300), dpToPixels(100), view);
+    }
+
+    @Test
+    public void testRender() throws Throwable
+    {
+        assertRenders(view, "HabitFrequencyView/render.png");
+    }
+
+    @Test
+    public void testRender_withTransparentBackground() throws Throwable
+    {
+        view.setIsBackgroundTransparent(true);
+        assertRenders(view, "HabitFrequencyView/renderTransparent.png");
+    }
+
+    @Test
+    public void testRender_withDifferentSize() throws Throwable
+    {
+        measureView(dpToPixels(200), dpToPixels(200), view);
+        assertRenders(view, "HabitFrequencyView/renderDifferentSize.png");
+    }
+
+    @Test
+    public void testRender_withDataOffset() throws Throwable
+    {
+        view.onScroll(null, null, -dpToPixels(150), 0);
+        view.invalidate();
+
+        assertRenders(view, "HabitFrequencyView/renderDataOffset.png");
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/views/HabitHistoryViewTest.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.views;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.isoron.uhabits.views.HabitHistoryView;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class HabitHistoryViewTest extends ViewTest
+{
+    private Habit habit;
+    private HabitHistoryView view;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        habit = HabitFixtures.createLongHabit();
+
+        view = new HabitHistoryView(targetContext);
+        view.setHabit(habit);
+        measureView(dpToPixels(400), dpToPixels(200), view);
+        refreshData(view);
+    }
+
+    @Test
+    public void testRender() throws Throwable
+    {
+        assertRenders(view, "HabitHistoryView/render.png");
+    }
+
+    @Test
+    public void testRender_withTransparentBackground() throws Throwable
+    {
+        view.setIsBackgroundTransparent(true);
+        assertRenders(view, "HabitHistoryView/renderTransparent.png");
+    }
+
+    @Test
+    public void testRender_withDifferentSize() throws Throwable
+    {
+        measureView(dpToPixels(200), dpToPixels(200), view);
+        assertRenders(view, "HabitHistoryView/renderDifferentSize.png");
+    }
+
+    @Test
+    public void testRender_withDataOffset() throws Throwable
+    {
+        view.onScroll(null, null, -dpToPixels(150), 0);
+        view.invalidate();
+
+        assertRenders(view, "HabitHistoryView/renderDataOffset.png");
+    }
+
+    @Test
+    public void tapDate_withEditableView() throws Throwable
+    {
+        view.setIsEditable(true);
+        tap(view, 340, 40); // today's square
+        waitForAsyncTasks();
+
+        long today = DateHelper.getStartOfToday();
+        assertFalse(habit.repetitions.contains(today));
+    }
+
+    @Test
+    public void tapDate_atInvalidLocations() throws Throwable
+    {
+        int expectedCheckmarkValues[] = habit.checkmarks.getAllValues();
+
+        view.setIsEditable(true);
+        tap(view, 118, 13); // header
+        tap(view, 336, 60); // tomorrow's square
+        tap(view, 370, 60); // right axis
+        waitForAsyncTasks();
+
+        int actualCheckmarkValues[] = habit.checkmarks.getAllValues();
+        assertThat(actualCheckmarkValues, equalTo(expectedCheckmarkValues));
+    }
+
+    @Test
+    public void tapDate_withReadOnlyView() throws Throwable
+    {
+        view.setIsEditable(false);
+        tap(view, 340, 40); // today's square
+        waitForAsyncTasks();
+
+        long today = DateHelper.getStartOfToday();
+        assertTrue(habit.repetitions.contains(today));
+    }
+
+}

app/src/androidTest/java/org/isoron/uhabits/unit/views/HabitScoreViewTest.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.views;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.util.Log;
+
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.isoron.uhabits.views.HabitScoreView;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class HabitScoreViewTest extends ViewTest
+{
+    private Habit habit;
+    private HabitScoreView view;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        habit = HabitFixtures.createLongHabit();
+
+        view = new HabitScoreView(targetContext);
+        view.setHabit(habit);
+        view.setBucketSize(7);
+        refreshData(view);
+        measureView(dpToPixels(300), dpToPixels(200), view);
+    }
+
+    @Test
+    public void testRender() throws Throwable
+    {
+        Log.d("HabitScoreViewTest", String.format("height=%d", dpToPixels(100)));
+        assertRenders(view, "HabitScoreView/render.png");
+    }
+
+    @Test
+    public void testRender_withTransparentBackground() throws Throwable
+    {
+        view.setIsTransparencyEnabled(true);
+        assertRenders(view, "HabitScoreView/renderTransparent.png");
+    }
+
+    @Test
+    public void testRender_withDifferentSize() throws Throwable
+    {
+        measureView(dpToPixels(200), dpToPixels(200), view);
+        assertRenders(view, "HabitScoreView/renderDifferentSize.png");
+    }
+
+    @Test
+    public void testRender_withDataOffset() throws Throwable
+    {
+        view.onScroll(null, null, -dpToPixels(150), 0);
+        view.invalidate();
+
+        assertRenders(view, "HabitScoreView/renderDataOffset.png");
+    }
+
+    @Test
+    public void testRender_withMonthlyBucket() throws Throwable
+    {
+        view.setBucketSize(30);
+        view.refreshData();
+        view.invalidate();
+
+        assertRenders(view, "HabitScoreView/renderMonthly.png");
+    }
+
+    @Test
+    public void testRender_withYearlyBucket() throws Throwable
+    {
+        view.setBucketSize(365);
+        view.refreshData();
+        view.invalidate();
+
+        assertRenders(view, "HabitScoreView/renderYearly.png");
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/views/HabitStreakViewTest.java

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.views;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.unit.HabitFixtures;
+import org.isoron.uhabits.views.HabitStreakView;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class HabitStreakViewTest extends ViewTest
+{
+    private HabitStreakView view;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        HabitFixtures.purgeHabits();
+        Habit habit = HabitFixtures.createLongHabit();
+
+        view = new HabitStreakView(targetContext);
+        measureView(dpToPixels(300), dpToPixels(100), view);
+
+        view.setHabit(habit);
+        refreshData(view);
+    }
+
+    @Test
+    public void testRender() throws Throwable
+    {
+        assertRenders(view, "HabitStreakView/render.png");
+    }
+
+    @Test
+    public void testRender_withTransparentBackground() throws Throwable
+    {
+        view.setIsBackgroundTransparent(true);
+        assertRenders(view, "HabitStreakView/renderTransparent.png"); 
+    }
+
+    @Test
+    public void testRender_withSmallSize() throws Throwable
+    {
+        measureView(dpToPixels(100), dpToPixels(100), view);
+        refreshData(view);
+
+        assertRenders(view, "HabitStreakView/renderSmallSize.png");
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/views/NumberViewTest.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.views;
+
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.R;
+import org.isoron.uhabits.helpers.ColorHelper;
+import org.isoron.uhabits.views.NumberView;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class NumberViewTest extends ViewTest
+{
+    private NumberView view;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        view = new NumberView(targetContext);
+        view.setLabel("Hello world");
+        view.setNumber(31);
+        view.setColor(ColorHelper.CSV_PALETTE[0]);
+        measureView(dpToPixels(100), dpToPixels(100), view);
+    }
+
+    @Test
+    public void testRender_base() throws IOException
+    {
+        assertRenders(view, "NumberView/render.png");
+    }
+
+    @Test
+    public void testRender_withLongLabel() throws IOException
+    {
+        view.setLabel("The quick brown fox jumps over the lazy fox");
+
+        measureView(dpToPixels(100), dpToPixels(100), view);
+        assertRenders(view, "NumberView/renderLongLabel.png");
+    }
+
+    @Test
+    public void testRender_withDifferentParams() throws IOException
+    {
+        view.setNumber(500);
+        view.setColor(ColorHelper.CSV_PALETTE[5]);
+        view.setTextSize(targetContext.getResources().getDimension(R.dimen.tinyTextSize));
+
+        measureView(dpToPixels(200), dpToPixels(200), view);
+        assertRenders(view, "NumberView/renderDifferentParams.png");
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/views/RingViewTest.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.views;
+
+import android.graphics.Color;
+import android.support.test.runner.AndroidJUnit4;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import org.isoron.uhabits.helpers.ColorHelper;
+import org.isoron.uhabits.views.RingView;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+
+@RunWith(AndroidJUnit4.class)
+@SmallTest
+public class RingViewTest extends ViewTest
+{
+    private RingView view;
+
+    @Before
+    public void setup()
+    {
+        super.setup();
+
+        view = new RingView(targetContext);
+        view.setPercentage(0.6f);
+        view.setText("60%");
+        view.setColor(ColorHelper.CSV_PALETTE[0]);
+        view.setBackgroundColor(Color.WHITE);
+        view.setThickness(dpToPixels(3));
+    }
+
+    @Test
+    public void testRender_base() throws IOException
+    {
+        measureView(dpToPixels(100), dpToPixels(100), view);
+        assertRenders(view, "RingView/render.png");
+    }
+
+    @Test
+    public void testRender_withDifferentParams() throws IOException
+    {
+        view.setPercentage(0.25f);
+        view.setColor(ColorHelper.CSV_PALETTE[5]);
+
+        measureView(dpToPixels(200), dpToPixels(200), view);
+        assertRenders(view, "RingView/renderDifferentParams.png");
+    }
+}

app/src/androidTest/java/org/isoron/uhabits/unit/views/ViewTest.java

@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.unit.views;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.SystemClock;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.View;
+
+import org.isoron.uhabits.BaseTest;
+import org.isoron.uhabits.helpers.DatabaseHelper;
+import org.isoron.uhabits.helpers.UIHelper;
+import org.isoron.uhabits.tasks.BaseTask;
+import org.isoron.uhabits.views.HabitDataView;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import static junit.framework.Assert.fail;
+
+public class ViewTest extends BaseTest
+{
+    protected static final double SIMILARITY_CUTOFF = 0.09;
+    public static final int HISTOGRAM_BIN_SIZE = 8;
+
+    protected void measureView(int width, int height, View view)
+    {
+        int specWidth = View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY);
+        int specHeight = View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY);
+
+        view.measure(specWidth, specHeight);
+        view.layout(0, 0, view.getMeasuredWidth(), view.getMeasuredHeight());
+    }
+
+    protected void assertRenders(View view, String expectedImagePath) throws IOException
+    {
+        StringBuilder errorMessage = new StringBuilder();
+        expectedImagePath = getVersionedViewAssetPath(expectedImagePath);
+
+        view.setDrawingCacheEnabled(true);
+        view.buildDrawingCache();
+        Bitmap actual = view.getDrawingCache();
+        Bitmap expected = getBitmapFromAssets(expectedImagePath);
+
+        int width = actual.getWidth();
+        int height = actual.getHeight();
+        Bitmap scaledExpected = Bitmap.createScaledBitmap(expected, width, height, true);
+
+        double distance;
+        boolean similarEnough = true;
+
+        if ((distance = compareHistograms(getHistogram(actual), getHistogram(scaledExpected))) > SIMILARITY_CUTOFF)
+        {
+            similarEnough = false;
+            errorMessage.append(String.format(
+                    "Rendered image has wrong histogram (distance=%f). ",
+                    distance));
+        }
+
+        if(!similarEnough)
+        {
+            saveBitmap(expectedImagePath, ".expected", scaledExpected);
+            String path = saveBitmap(expectedImagePath, "", actual);
+            errorMessage.append(String.format("Actual rendered image " + "saved to %s", path));
+            fail(errorMessage.toString());
+        }
+
+        actual.recycle();
+        expected.recycle();
+        scaledExpected.recycle();
+    }
+
+    private Bitmap getBitmapFromAssets(String path) throws IOException
+    {
+        InputStream stream = testContext.getAssets().open(path);
+        return BitmapFactory.decodeStream(stream);
+    }
+
+    private String getVersionedViewAssetPath(String path)
+    {
+        String result = null;
+
+        if (android.os.Build.VERSION.SDK_INT >= 21)
+        {
+            try
+            {
+                String vpath = "views-v21/" + path;
+                testContext.getAssets().open(vpath);
+                result = vpath;
+            }
+            catch (IOException e)
+            {
+                // ignored
+            }
+        }
+
+        if(result == null)
+            result = "views/" + path;
+
+        return result;
+    }
+
+    private String saveBitmap(String filename, String suffix, Bitmap bitmap)
+            throws IOException
+    {
+        File dir = DatabaseHelper.getSDCardDir("test-screenshots");
+        if(dir == null) dir = DatabaseHelper.getFilesDir("test-screenshots");
+        if(dir == null) throw new RuntimeException("Could not find suitable dir for screenshots");
+
+        filename = filename.replaceAll("\\.png$", suffix + ".png");
+        String absolutePath = String.format("%s/%s", dir.getAbsolutePath(), filename);
+
+        File parent = new File(absolutePath).getParentFile();
+        if(!parent.exists() && !parent.mkdirs())
+            throw new RuntimeException(String.format("Could not create dir: %s",
+                    parent.getAbsolutePath()));
+
+        FileOutputStream out = new FileOutputStream(absolutePath);
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, out);
+
+        return absolutePath;
+    }
+
+    private int[][] getHistogram(Bitmap bitmap)
+    {
+        int histogram[][] = new int[4][256 / HISTOGRAM_BIN_SIZE];
+
+        for(int x = 0; x < bitmap.getWidth(); x++)
+        {
+            for(int y = 0; y < bitmap.getHeight(); y++)
+            {
+                int color = bitmap.getPixel(x, y);
+                int[] argb = new int[]{
+                        (color >> 24) & 0xff, //alpha
+                        (color >> 16) & 0xff, //red
+                        (color >>  8) & 0xff, //green
+                        (color      ) & 0xff  //blue
+                };
+
+                histogram[0][argb[0] / HISTOGRAM_BIN_SIZE]++;
+                histogram[1][argb[1] / HISTOGRAM_BIN_SIZE]++;
+                histogram[2][argb[2] / HISTOGRAM_BIN_SIZE]++;
+                histogram[3][argb[3] / HISTOGRAM_BIN_SIZE]++;
+            }
+        }
+
+        return histogram;
+    }
+
+    private double compareHistograms(int[][] actualHistogram, int[][] expectedHistogram)
+    {
+        long diff = 0;
+        long total = 0;
+
+        for(int i = 0; i < 256 / HISTOGRAM_BIN_SIZE; i ++)
+        {
+            diff += Math.abs(actualHistogram[0][i] - expectedHistogram[0][i]);
+            diff += Math.abs(actualHistogram[1][i] - expectedHistogram[1][i]);
+            diff += Math.abs(actualHistogram[2][i] - expectedHistogram[2][i]);
+            diff += Math.abs(actualHistogram[3][i] - expectedHistogram[3][i]);
+
+            total += actualHistogram[0][i];
+            total += actualHistogram[1][i];
+            total += actualHistogram[2][i];
+            total += actualHistogram[3][i];
+        }
+
+        return (double) diff / total / 2;
+    }
+
+    protected int dpToPixels(int dp)
+    {
+        return (int) UIHelper.dpToPixels(targetContext, dp);
+    }
+
+    protected void tap(GestureDetector.OnGestureListener view, int x, int y) throws InterruptedException
+    {
+        long now = SystemClock.uptimeMillis();
+        MotionEvent e = MotionEvent.obtain(now, now, MotionEvent.ACTION_UP, dpToPixels(x),
+                dpToPixels(y), 0);
+        view.onSingleTapUp(e);
+        e.recycle();
+    }
+
+    protected void refreshData(final HabitDataView view)
+    {
+        new BaseTask()
+        {
+            @Override
+            protected void doInBackground()
+            {
+                view.refreshData();
+            }
+        }.execute();
+
+        try
+        {
+            waitForAsyncTasks();
+        }
+        catch (Exception e)
+        {
+            throw new RuntimeException("Time out");
+        }
+    }
+}

app/src/debug/AndroidManifest.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+  ~
+  ~ This file is part of Loop Habit Tracker.
+  ~
+  ~ Loop Habit Tracker is free software: you can redistribute it and/or modify
+  ~ it under the terms of the GNU General Public License as published by the
+  ~ Free Software Foundation, either version 3 of the License, or (at your
+  ~ option) any later version.
+  ~
+  ~ Loop Habit Tracker is distributed in the hope that it will be useful, but
+  ~ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+  ~ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+  ~ more details.
+  ~
+  ~ You should have received a copy of the GNU General Public License along
+  ~ with this program. If not, see <http://www.gnu.org/licenses/>.
+  -->
+<manifest
+    package="org.isoron.uhabits"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-permission android:name="android.permission.SET_ANIMATION_SCALE"/>
+    <uses-permission android:name="android.permission.DISABLE_KEYGUARD"/>
+    <uses-permission android:name="android.permission.WAKE_LOCK"/>
+
+    <uses-permission
+        android:name="android.permission.READ_EXTERNAL_STORAGE"
+        tools:replace="maxSdkVersion"
+        android:maxSdkVersion="99" />
+
+    <uses-permission
+        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        tools:replace="maxSdkVersion"
+        android:maxSdkVersion="99" />
+
+</manifest>

app/src/main/AndroidManifest.xml

@@ -1,27 +1,49 @@
 <?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+  ~
+  ~ This file is part of Loop Habit Tracker.
+  ~
+  ~ Loop Habit Tracker is free software: you can redistribute it and/or modify
+  ~ it under the terms of the GNU General Public License as published by the
+  ~ Free Software Foundation, either version 3 of the License, or (at your
+  ~ option) any later version.
+  ~
+  ~ Loop Habit Tracker is distributed in the hope that it will be useful, but
+  ~ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+  ~ or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+  ~ more details.
+  ~
+  ~ You should have received a copy of the GNU General Public License along
+  ~ with this program. If not, see <http://www.gnu.org/licenses/>.
+  -->
+
 <manifest
     package="org.isoron.uhabits"
     xmlns:android="http://schemas.android.com/apk/res/android"
-    android:versionCode="6"
-    android:versionName="1.1.0">
+    android:versionCode="16"
+    android:versionName="1.5.0">
+
+    <uses-permission android:name="android.permission.VIBRATE"/>
 
     <uses-permission
-        android:name="android.permission.VIBRATE"/>
+        android:name="android.permission.READ_EXTERNAL_STORAGE"
+        android:maxSdkVersion="18" />
+
+    <uses-permission
+        android:name="android.permission.WRITE_EXTERNAL_STORAGE"
+        android:maxSdkVersion="18" />
+
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
 
     <application
-        android:name="com.activeandroid.app.Application"
+        android:name="HabitsApplication"
+        android:allowBackup="true"
+        android:backupAgent=".HabitsBackupAgent"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/main_activity_title"
         android:theme="@style/AppBaseTheme"
-        android:backupAgent=".HabitsBackupAgent">
-
-        <meta-data
-            android:name="AA_DB_NAME"
-            android:value="uhabits.db"/>
-
-        <meta-data
-            android:name="AA_DB_VERSION"
-            android:value="11"/>
+        android:supportsRtl="true">
 
         <meta-data
             android:name="com.google.android.backup.api_key"
@@ -30,20 +52,16 @@
         <activity
             android:name=".MainActivity"
             android:label="@string/main_activity_title">
-            <intent-filter
-                android:label="@string/app_name">
+            <intent-filter android:label="@string/app_name">
                 <action android:name="android.intent.action.MAIN"/>
+
                 <category android:name="android.intent.category.LAUNCHER"/>
             </intent-filter>
         </activity>
 
-        <receiver
-            android:name=".ReminderAlarmReceiver" />
-
         <activity
             android:name=".ShowHabitActivity"
-            android:label="@string/title_activity_show_habit"
-            android:parentActivityName=".MainActivity">
+            android:label="@string/title_activity_show_habit">
             <meta-data
                 android:name="android.support.PARENT_ACTIVITY"
                 android:value="org.isoron.uhabits.MainActivity"/>
@@ -51,16 +69,99 @@
 
         <activity
             android:name=".SettingsActivity"
-            android:label="@string/settings"
-            android:parentActivityName=".MainActivity">
+            android:label="@string/settings">
             <meta-data
                 android:name="android.support.PARENT_ACTIVITY"
                 android:value="org.isoron.uhabits.MainActivity"/>
         </activity>
 
-        <activity android:name=".IntroActivity"
+        <activity
+            android:name=".IntroActivity"
             android:label=""
             android:theme="@style/Theme.AppCompat.Light.NoActionBar"/>
+
+        <activity
+            android:name=".widgets.HabitPickerDialog"
+            android:theme="@style/Theme.AppCompat.Light.Dialog">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_CONFIGURE"/>
+            </intent-filter>
+        </activity>
+
+        <activity
+            android:name=".AboutActivity"
+            android:label="@string/about">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value=".MainActivity" />
+        </activity>
+
+        <receiver
+            android:name=".widgets.CheckmarkWidgetProvider"
+            android:label="@string/checkmark">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/widget_checkmark_info"/>
+        </receiver>
+
+        <receiver
+            android:name=".widgets.HistoryWidgetProvider"
+            android:label="@string/history">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/widget_history_info"/>
+        </receiver>
+
+        <receiver
+            android:name=".widgets.ScoreWidgetProvider"
+            android:label="@string/habit_strength">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/widget_score_info"/>
+        </receiver>
+
+        <receiver
+            android:name=".widgets.StreakWidgetProvider"
+            android:label="@string/streaks">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/widget_streak_info"/>
+        </receiver>
+
+        <receiver
+            android:name=".widgets.FrequencyWidgetProvider"
+            android:label="@string/frequency">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/widget_frequency_info"/>
+        </receiver>
+
+        <receiver android:name=".HabitBroadcastReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+
     </application>
 
 </manifest>

app/src/main/assets/migrations/12.sql

@@ -0,0 +1,3 @@
+delete from Score;
+delete from Streak;
+delete from Checkmarks;

app/src/main/assets/migrations/13.sql

@@ -0,0 +1,4 @@
+create index idx_score_habit_timestamp on score(habit, timestamp);
+create index idx_checkmark_habit_timestamp on checkmarks(habit, timestamp);
+create index idx_repetitions_habit_timestamp on repetitions(habit, timestamp);
+create index idx_streak_habit_end on streak(habit, end);

app/src/main/assets/migrations/14.sql

@@ -0,0 +1,14 @@
+update habits set color=0 where color=-2937041;
+update habits set color=1 where color=-1684967;
+update habits set color=2 where color=-415707;
+update habits set color=3 where color=-5262293;
+update habits set color=4 where color=-13070788;
+update habits set color=5 where color=-16742021;
+update habits set color=6 where color=-16732991;
+update habits set color=7 where color=-16540699;
+update habits set color=8 where color=-10603087;
+update habits set color=9 where color=-7461718;
+update habits set color=10 where color=-2614432;
+update habits set color=11 where color=-13619152;
+update habits set color=12 where color=-5592406;
+update habits set color=0 where color<0 or color>12;

app/src/main/java/com/android/colorpicker/ColorPickerDialog.java

@@ -16,24 +16,24 @@
 
 package com.android.colorpicker;
 
-import org.isoron.uhabits.R;
-
 import android.app.Activity;
-import android.app.AlertDialog;
 import android.app.Dialog;
-import android.app.DialogFragment;
 import android.os.Bundle;
+import android.support.v7.app.AlertDialog;
+import android.support.v7.app.AppCompatDialogFragment;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.widget.ProgressBar;
 
 import com.android.colorpicker.ColorPickerSwatch.OnColorSelectedListener;
 
+import org.isoron.uhabits.R;
+
 /**
  * A dialog which takes in as input an array of palette and creates a palette allowing the user to
  * select a specific color swatch, which invokes a listener.
  */
-public class ColorPickerDialog extends DialogFragment implements OnColorSelectedListener {
+public class ColorPickerDialog extends AppCompatDialogFragment implements OnColorSelectedListener {
 
     public static final int SIZE_LARGE = 1;
     public static final int SIZE_SMALL = 2;

app/src/main/java/com/android/datetimepicker/time/TimePickerDialog.java

@@ -23,12 +23,14 @@ import java.util.Locale;
 import org.isoron.uhabits.R;
 
 import android.animation.ObjectAnimator;
+import android.annotation.SuppressLint;
 import android.app.ActionBar.LayoutParams;
 import android.app.DialogFragment;
 import android.content.Context;
 import android.content.res.ColorStateList;
 import android.content.res.Resources;
 import android.os.Bundle;
+import android.support.v7.app.AppCompatDialogFragment;
 import android.util.Log;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
@@ -48,7 +50,7 @@ import com.android.datetimepicker.time.RadialPickerLayout.OnValueSelectedListene
 /**
  * Dialog to set a time.
  */
-public class TimePickerDialog extends DialogFragment implements OnValueSelectedListener{
+public class TimePickerDialog extends AppCompatDialogFragment implements OnValueSelectedListener{
     private static final String TAG = "TimePickerDialog";
 
     private static final String KEY_HOUR_OF_DAY = "hour_of_day";
@@ -132,6 +134,7 @@ public class TimePickerDialog extends DialogFragment implements OnValueSelectedL
         // Empty constructor required for dialog fragment.
     }
 
+    @SuppressLint("Java")
     public TimePickerDialog(Context context, int theme, OnTimeSetListener callback,
             int hourOfDay, int minute, boolean is24HourMode) {
         // Empty constructor required for dialog fragment.

app/src/main/java/org/isoron/helpers/ColorHelper.java

@@ -1,60 +0,0 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package org.isoron.helpers;
-
-import android.graphics.Color;
-
-public class ColorHelper
-{
-    public static final int[] palette =
-    {
-            Color.parseColor("#D32F2F"), // red
-            Color.parseColor("#E64A19"), // orange
-            Color.parseColor("#F9A825"), // yellow
-            Color.parseColor("#AFB42B"), // light green
-            Color.parseColor("#388E3C"), // dark green
-            Color.parseColor("#00897B"), // teal
-            Color.parseColor("#00ACC1"), // cyan
-            Color.parseColor("#039BE5"), // blue
-            Color.parseColor("#5E35B1"), // deep purple
-            Color.parseColor("#8E24AA"), // purple
-            Color.parseColor("#D81B60"), // pink
-            Color.parseColor("#303030"), // dark grey
-            Color.parseColor("#aaaaaa")  // light grey
-    };
-
-    public static int mixColors(int color1, int color2, float amount)
-    {
-        final byte ALPHA_CHANNEL = 24;
-        final byte RED_CHANNEL = 16;
-        final byte GREEN_CHANNEL = 8;
-        final byte BLUE_CHANNEL = 0;
-
-        final float inverseAmount = 1.0f - amount;
-
-        int a = ((int) (((float) (color1 >> ALPHA_CHANNEL & 0xff) * amount) +
-                ((float) (color2 >> ALPHA_CHANNEL & 0xff) * inverseAmount))) & 0xff;
-        int r = ((int) (((float) (color1 >> RED_CHANNEL & 0xff) * amount) +
-                ((float) (color2 >> RED_CHANNEL & 0xff) * inverseAmount))) & 0xff;
-        int g = ((int) (((float) (color1 >> GREEN_CHANNEL & 0xff) * amount) +
-                ((float) (color2 >> GREEN_CHANNEL & 0xff) * inverseAmount))) & 0xff;
-        int b = ((int) (((float) (color1 & 0xff) * amount) +
-                ((float) (color2 & 0xff) * inverseAmount))) & 0xff;
-
-        return a << ALPHA_CHANNEL | r << RED_CHANNEL | g << GREEN_CHANNEL | b << BLUE_CHANNEL;
-    }
-}

app/src/main/java/org/isoron/helpers/Command.java

@@ -1,34 +0,0 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package org.isoron.helpers;
-
-public abstract class Command
-{
-    public abstract void execute();
-
-    public abstract void undo();
-
-    public Integer getExecuteStringId()
-    {
-        return null;
-    }
-
-    public Integer getUndoStringId()
-    {
-        return null;
-    }
-}

app/src/main/java/org/isoron/helpers/DialogHelper.java

@@ -1,68 +0,0 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package org.isoron.helpers;
-
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.DialogInterface.OnClickListener;
-import android.content.SharedPreferences;
-import android.graphics.Typeface;
-import android.os.Vibrator;
-import android.preference.PreferenceManager;
-import android.view.View;
-import android.view.inputmethod.InputMethodManager;
-import android.widget.TextView;
-
-import org.isoron.uhabits.R;
-
-public abstract class DialogHelper
-{
-
-    private static Typeface fontawesome;
-
-    public interface OnSavedListener
-    {
-        void onSaved(Command command, Object savedObject);
-    }
-
-    public static void showSoftKeyboard(View view)
-    {
-        InputMethodManager imm = (InputMethodManager) view.getContext()
-                .getSystemService(Context.INPUT_METHOD_SERVICE);
-        imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT);
-    }
-
-    public static void vibrate(Context context, int duration)
-    {
-        Vibrator vb = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
-        vb.vibrate(duration);
-    }
-
-
-    public static void incrementLaunchCount(Context context)
-    {
-        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
-        int count = prefs.getInt("launch_count", 0);
-        prefs.edit().putInt("launch_count", count + 1).apply();
-    }
-
-    public static int getLaunchCount(Context context)
-    {
-        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
-        return prefs.getInt("launch_count", 0);
-    }
-}

app/src/main/java/org/isoron/helpers/ReplayableActivity.java

@@ -1,115 +0,0 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package org.isoron.helpers;
-
-import android.app.Activity;
-import android.app.backup.BackupManager;
-import android.os.AsyncTask;
-import android.os.Bundle;
-import android.widget.Toast;
-
-import org.isoron.uhabits.R;
-
-import java.util.LinkedList;
-
-abstract public class ReplayableActivity extends Activity
-{
-    private static int MAX_UNDO_LEVEL = 15;
-
-    private LinkedList<Command> undoList;
-    private LinkedList<Command> redoList;
-    private Toast toast;
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState)
-    {
-        super.onCreate(savedInstanceState);
-
-        undoList = new LinkedList<>();
-        redoList = new LinkedList<>();
-    }
-
-    public void executeCommand(Command command, Long refreshKey)
-    {
-        executeCommand(command, false, refreshKey);
-    }
-
-    protected void undo()
-    {
-        if (undoList.isEmpty())
-        {
-            showToast(R.string.toast_nothing_to_undo);
-            return;
-        }
-
-        Command last = undoList.pop();
-        redoList.push(last);
-        last.undo();
-        showToast(last.getUndoStringId());
-    }
-
-    protected void redo()
-    {
-        if (redoList.isEmpty())
-        {
-            showToast(R.string.toast_nothing_to_redo);
-            return;
-        }
-        Command last = redoList.pop();
-        executeCommand(last, false, null);
-    }
-
-    public void showToast(Integer stringId)
-    {
-        if (stringId == null) return;
-        if (toast == null) toast = Toast.makeText(this, stringId, Toast.LENGTH_SHORT);
-        else toast.setText(stringId);
-        toast.show();
-    }
-
-    public void executeCommand(final Command command, Boolean clearRedoStack, final Long refreshKey)
-    {
-        undoList.push(command);
-
-        if (undoList.size() > MAX_UNDO_LEVEL) undoList.removeLast();
-        if (clearRedoStack) redoList.clear();
-
-        new AsyncTask<Void, Void, Void>()
-        {
-            @Override
-            protected Void doInBackground(Void... params)
-            {
-                command.execute();
-                return null;
-            }
-
-            @Override
-            protected void onPostExecute(Void aVoid)
-            {
-                ReplayableActivity.this.onPostExecuteCommand(refreshKey);
-                BackupManager.dataChanged("org.isoron.uhabits");
-            }
-        }.execute();
-
-
-        showToast(command.getExecuteStringId());
-    }
-
-    public void onPostExecuteCommand(Long refreshKey)
-    {
-    }
-}

app/src/main/java/org/isoron/uhabits/AboutActivity.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits;
+
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.TextView;
+
+import org.isoron.uhabits.helpers.UIHelper;
+
+public class AboutActivity extends BaseActivity implements View.OnClickListener
+{
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState)
+    {
+        super.onCreate(savedInstanceState);
+
+        setContentView(R.layout.about);
+        setupSupportActionBar(true);
+
+        int color = UIHelper.getStyledColor(this, R.attr.aboutScreenColor);
+        setupActionBarColor(color);
+
+        TextView tvVersion = (TextView) findViewById(R.id.tvVersion);
+        TextView tvRate = (TextView) findViewById(R.id.tvRate);
+        TextView tvFeedback = (TextView) findViewById(R.id.tvFeedback);
+        TextView tvSource = (TextView) findViewById(R.id.tvSource);
+
+        tvVersion.setText(String.format(getResources().getString(R.string.version_n),
+                BuildConfig.VERSION_NAME));
+        tvRate.setOnClickListener(this);
+        tvFeedback.setOnClickListener(this);
+        tvSource.setOnClickListener(this);
+    }
+
+    @Override
+    public void onClick(View v)
+    {
+        switch (v.getId())
+        {
+            case R.id.tvRate:
+            {
+                Intent intent = new Intent();
+                intent.setAction(Intent.ACTION_VIEW);
+                intent.setData(Uri.parse(getString(R.string.playStoreURL)));
+                startActivity(intent);
+                break;
+            }
+
+            case R.id.tvFeedback:
+            {
+                Intent intent = new Intent();
+                intent.setAction(Intent.ACTION_SENDTO);
+                intent.setData(Uri.parse(getString(R.string.feedbackURL)));
+                startActivity(intent);
+                break;
+            }
+
+            case R.id.tvSource:
+            {
+                Intent intent = new Intent();
+                intent.setAction(Intent.ACTION_VIEW);
+                intent.setData(Uri.parse(getString(R.string.sourceCodeURL)));
+                startActivity(intent);
+                break;
+            }
+        }
+    }
+}

app/src/main/java/org/isoron/uhabits/BaseActivity.java

@@ -0,0 +1,204 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits;
+
+import android.app.backup.BackupManager;
+import android.graphics.Color;
+import android.graphics.drawable.ColorDrawable;
+import android.os.AsyncTask;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.Toolbar;
+import android.view.View;
+import android.widget.Toast;
+
+import org.isoron.uhabits.commands.Command;
+import org.isoron.uhabits.helpers.ColorHelper;
+import org.isoron.uhabits.helpers.UIHelper;
+
+import java.util.LinkedList;
+
+abstract public class BaseActivity extends AppCompatActivity implements Thread.UncaughtExceptionHandler
+{
+    private static int MAX_UNDO_LEVEL = 15;
+
+    private LinkedList<Command> undoList;
+    private LinkedList<Command> redoList;
+    private Toast toast;
+
+    Thread.UncaughtExceptionHandler androidExceptionHandler;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState)
+    {
+        super.onCreate(savedInstanceState);
+
+        UIHelper.applyCurrentTheme(this);
+
+        androidExceptionHandler = Thread.getDefaultUncaughtExceptionHandler();
+        Thread.setDefaultUncaughtExceptionHandler(this);
+
+        undoList = new LinkedList<>();
+        redoList = new LinkedList<>();
+    }
+
+    public void executeCommand(Command command, Long refreshKey)
+    {
+        executeCommand(command, false, refreshKey);
+    }
+
+    protected void undo()
+    {
+        if (undoList.isEmpty())
+        {
+            showToast(R.string.toast_nothing_to_undo);
+            return;
+        }
+
+        Command last = undoList.pop();
+        redoList.push(last);
+        last.undo();
+        showToast(last.getUndoStringId());
+    }
+
+    protected void redo()
+    {
+        if (redoList.isEmpty())
+        {
+            showToast(R.string.toast_nothing_to_redo);
+            return;
+        }
+        Command last = redoList.pop();
+        executeCommand(last, false, null);
+    }
+
+    public void showToast(Integer stringId)
+    {
+        if (stringId == null) return;
+        if (toast == null) toast = Toast.makeText(this, stringId, Toast.LENGTH_SHORT);
+        else toast.setText(stringId);
+        toast.show();
+    }
+
+    public void executeCommand(final Command command, Boolean clearRedoStack, final Long refreshKey)
+    {
+        undoList.push(command);
+
+        if (undoList.size() > MAX_UNDO_LEVEL) undoList.removeLast();
+        if (clearRedoStack) redoList.clear();
+
+        new AsyncTask<Void, Void, Void>()
+        {
+            @Override
+            protected Void doInBackground(Void... params)
+            {
+                command.execute();
+                return null;
+            }
+
+            @Override
+            protected void onPostExecute(Void aVoid)
+            {
+                BaseActivity.this.onPostExecuteCommand(refreshKey);
+                BackupManager.dataChanged("org.isoron.uhabits");
+            }
+        }.execute();
+
+
+        showToast(command.getExecuteStringId());
+    }
+
+    protected void setupSupportActionBar(boolean homeButtonEnabled)
+    {
+        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
+        if(toolbar == null) return;
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+            toolbar.setElevation(UIHelper.dpToPixels(this, 2));
+
+        setSupportActionBar(toolbar);
+
+        ActionBar actionBar = getSupportActionBar();
+        if(actionBar == null) return;
+
+        if(homeButtonEnabled)
+            actionBar.setDisplayHomeAsUpEnabled(true);
+    }
+
+    public void onPostExecuteCommand(Long refreshKey)
+    {
+    }
+
+    @Override
+    public void uncaughtException(Thread thread, Throwable ex)
+    {
+        try
+        {
+            ex.printStackTrace();
+            HabitsApplication.generateLogFile();
+        }
+        catch(Exception e)
+        {
+            // ignored
+        }
+
+        if(androidExceptionHandler != null)
+            androidExceptionHandler.uncaughtException(thread, ex);
+        else
+            System.exit(1);
+    }
+
+    protected void setupActionBarColor(int color)
+    {
+        ActionBar actionBar = getSupportActionBar();
+        if(actionBar == null) return;
+
+        if (!UIHelper.getStyledBoolean(this, R.attr.useHabitColorAsPrimary)) return;
+
+        ColorDrawable drawable = new ColorDrawable(color);
+        actionBar.setBackgroundDrawable(drawable);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+        {
+            int darkerColor = ColorHelper.mixColors(color, Color.BLACK, 0.75f);
+            getWindow().setStatusBarColor(darkerColor);
+        }
+    }
+
+    @Override
+    protected void onPostResume()
+    {
+        super.onPostResume();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+            hideFakeToolbarShadow();
+    }
+
+    protected void hideFakeToolbarShadow()
+    {
+        View view = findViewById(R.id.toolbarShadow);
+        if(view != null) view.setVisibility(View.GONE);
+
+        view = findViewById(R.id.headerShadow);
+        if(view != null) view.setVisibility(View.GONE);
+    }
+}

app/src/main/java/org/isoron/uhabits/HabitBroadcastReceiver.java

@@ -0,0 +1,274 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits;
+
+import android.app.Activity;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.os.Handler;
+import android.preference.PreferenceManager;
+import android.support.v4.app.NotificationCompat;
+import android.support.v4.app.TaskStackBuilder;
+import android.support.v4.content.LocalBroadcastManager;
+
+import org.isoron.uhabits.helpers.DateHelper;
+import org.isoron.uhabits.helpers.ReminderHelper;
+import org.isoron.uhabits.models.Checkmark;
+import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.tasks.BaseTask;
+
+import java.util.Date;
+
+public class HabitBroadcastReceiver extends BroadcastReceiver
+{
+    public static final String ACTION_CHECK = "org.isoron.uhabits.ACTION_CHECK";
+    public static final String ACTION_DISMISS = "org.isoron.uhabits.ACTION_DISMISS";
+    public static final String ACTION_SHOW_REMINDER = "org.isoron.uhabits.ACTION_SHOW_REMINDER";
+    public static final String ACTION_SNOOZE = "org.isoron.uhabits.ACTION_SNOOZE";
+
+    @Override
+    public void onReceive(final Context context, Intent intent)
+    {
+        switch (intent.getAction())
+        {
+            case ACTION_SHOW_REMINDER:
+                createNotification(context, intent);
+                createReminderAlarmsDelayed(context);
+                break;
+
+            case ACTION_DISMISS:
+                dismissAllHabits();
+                break;
+
+            case ACTION_CHECK:
+                checkHabit(context, intent);
+                break;
+
+            case ACTION_SNOOZE:
+                snoozeHabit(context, intent);
+                break;
+
+            case Intent.ACTION_BOOT_COMPLETED:
+                ReminderHelper.createReminderAlarms(context);
+                break;
+        }
+    }
+
+    private void createReminderAlarmsDelayed(final Context context)
+    {
+        new Handler().postDelayed(new Runnable()
+        {
+            @Override
+            public void run()
+            {
+                ReminderHelper.createReminderAlarms(context);
+            }
+        }, 5000);
+    }
+
+    private void snoozeHabit(Context context, Intent intent)
+    {
+        Uri data = intent.getData();
+        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+        long delayMinutes = Long.parseLong(prefs.getString("pref_snooze_interval", "15"));
+
+        long habitId = ContentUris.parseId(data);
+        Habit habit = Habit.get(habitId);
+        if(habit != null)
+            ReminderHelper.createReminderAlarm(context, habit,
+                    new Date().getTime() + delayMinutes * 60 * 1000);
+        dismissNotification(context, habitId);
+    }
+
+    private void checkHabit(Context context, Intent intent)
+    {
+        Uri data = intent.getData();
+        Long timestamp = intent.getLongExtra("timestamp", DateHelper.getStartOfToday());
+
+        long habitId = ContentUris.parseId(data);
+        Habit habit = Habit.get(habitId);
+        if(habit != null)
+            habit.repetitions.toggle(timestamp);
+        dismissNotification(context, habitId);
+
+        sendRefreshBroadcast(context);
+    }
+
+    public static void sendRefreshBroadcast(Context context)
+    {
+        LocalBroadcastManager manager = LocalBroadcastManager.getInstance(context);
+        Intent refreshIntent = new Intent(MainActivity.ACTION_REFRESH);
+        manager.sendBroadcast(refreshIntent);
+
+        MainActivity.updateWidgets(context);
+    }
+
+    private void dismissAllHabits()
+    {
+
+    }
+
+    private void dismissNotification(Context context, Long habitId)
+    {
+        NotificationManager notificationManager =
+                (NotificationManager) context.getSystemService(Activity.NOTIFICATION_SERVICE);
+
+        int notificationId = (int) (habitId % Integer.MAX_VALUE);
+        notificationManager.cancel(notificationId);
+    }
+
+
+    private void createNotification(final Context context, final Intent intent)
+    {
+        final Uri data = intent.getData();
+        final Habit habit = Habit.get(ContentUris.parseId(data));
+        final Long timestamp = intent.getLongExtra("timestamp", DateHelper.getStartOfToday());
+        final Long reminderTime = intent.getLongExtra("reminderTime", DateHelper.getStartOfToday());
+
+        if (habit == null) return;
+
+        new BaseTask()
+        {
+            int todayValue;
+
+            @Override
+            protected void doInBackground()
+            {
+                todayValue = habit.checkmarks.getTodayValue();
+            }
+
+            @Override
+            protected void onPostExecute(Void aVoid)
+            {
+                if (todayValue != Checkmark.UNCHECKED) return;
+                if (!checkWeekday(intent, habit)) return;
+                if (!habit.hasReminder()) return;
+
+                Intent contentIntent = new Intent(context, MainActivity.class);
+                contentIntent.setData(data);
+                PendingIntent contentPendingIntent =
+                        PendingIntent.getActivity(context, 0, contentIntent, 0);
+
+                PendingIntent dismissPendingIntent = buildDismissIntent(context);
+                PendingIntent checkIntentPending = buildCheckIntent(context, habit, timestamp);
+                PendingIntent snoozeIntentPending = buildSnoozeIntent(context, habit);
+
+                Uri ringtoneUri = ReminderHelper.getRingtoneUri(context);
+
+                NotificationCompat.WearableExtender wearableExtender =
+                        new NotificationCompat.WearableExtender().setBackground(
+                                BitmapFactory.decodeResource(context.getResources(),
+                                        R.drawable.stripe));
+
+                Notification notification =
+                        new NotificationCompat.Builder(context)
+                                .setSmallIcon(R.drawable.ic_notification)
+                                .setContentTitle(habit.name)
+                                .setContentText(habit.description)
+                                .setContentIntent(contentPendingIntent)
+                                .setDeleteIntent(dismissPendingIntent)
+                                .addAction(R.drawable.ic_action_check,
+                                        context.getString(R.string.check), checkIntentPending)
+                                .addAction(R.drawable.ic_action_snooze,
+                                        context.getString(R.string.snooze), snoozeIntentPending)
+                                .setSound(ringtoneUri)
+                                .extend(wearableExtender)
+                                .setWhen(reminderTime)
+                                .setShowWhen(true)
+                                .build();
+
+                notification.flags |= Notification.FLAG_AUTO_CANCEL;
+
+                NotificationManager notificationManager =
+                        (NotificationManager) context.getSystemService(
+                                Activity.NOTIFICATION_SERVICE);
+
+                int notificationId = (int) (habit.getId() % Integer.MAX_VALUE);
+                notificationManager.notify(notificationId, notification);
+
+                super.onPostExecute(aVoid);
+            }
+        }.execute();
+    }
+
+    public static PendingIntent buildSnoozeIntent(Context context, Habit habit)
+    {
+        Uri data = habit.getUri();
+        Intent snoozeIntent = new Intent(context, HabitBroadcastReceiver.class);
+        snoozeIntent.setData(data);
+        snoozeIntent.setAction(ACTION_SNOOZE);
+        return PendingIntent.getBroadcast(context, 0, snoozeIntent, 0);
+    }
+
+    public static PendingIntent buildCheckIntent(Context context, Habit habit, Long timestamp)
+    {
+        Uri data = habit.getUri();
+        Intent checkIntent = new Intent(context, HabitBroadcastReceiver.class);
+        checkIntent.setData(data);
+        checkIntent.setAction(ACTION_CHECK);
+        if(timestamp != null) checkIntent.putExtra("timestamp", timestamp);
+        return PendingIntent.getBroadcast(context, 0, checkIntent, PendingIntent.FLAG_ONE_SHOT);
+    }
+
+    public static PendingIntent buildDismissIntent(Context context)
+    {
+        Intent deleteIntent = new Intent(context, HabitBroadcastReceiver.class);
+        deleteIntent.setAction(ACTION_DISMISS);
+        return PendingIntent.getBroadcast(context, 0, deleteIntent, 0);
+    }
+
+    public static PendingIntent buildViewHabitIntent(Context context, Habit habit)
+    {
+        Intent intent = new Intent(context, ShowHabitActivity.class);
+        intent.setData(Uri.parse("content://org.isoron.uhabits/habit/" + habit.getId()));
+
+        return TaskStackBuilder.create(context.getApplicationContext())
+                .addNextIntentWithParentStack(intent)
+                .getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);
+    }
+
+    private boolean checkWeekday(Intent intent, Habit habit)
+    {
+        Long timestamp = intent.getLongExtra("timestamp", DateHelper.getStartOfToday());
+
+        boolean reminderDays[] = DateHelper.unpackWeekdayList(habit.reminderDays);
+        int weekday = DateHelper.getWeekday(timestamp);
+
+        return reminderDays[weekday];
+    }
+
+    public static void dismissNotification(Context context, Habit habit)
+    {
+        NotificationManager notificationManager =
+                (NotificationManager) context.getSystemService(
+                        Activity.NOTIFICATION_SERVICE);
+
+        int notificationId = (int) (habit.getId() % Integer.MAX_VALUE);
+        notificationManager.cancel(notificationId);
+    }
+}

app/src/main/java/org/isoron/uhabits/HabitsApplication.java

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits;
+
+import android.app.Application;
+import android.content.Context;
+import android.os.Environment;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.view.WindowManager;
+
+import com.activeandroid.ActiveAndroid;
+
+import org.isoron.uhabits.helpers.DatabaseHelper;
+import org.isoron.uhabits.helpers.DateHelper;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+public class HabitsApplication extends Application
+{
+    @Nullable
+    private static Context context;
+
+    public static boolean isTestMode()
+    {
+        try
+        {
+            if(context != null)
+                context.getClassLoader().loadClass("org.isoron.uhabits.unit.models.HabitTest");
+            return true;
+        }
+        catch (final Exception e)
+        {
+            return false;
+        }
+    }
+
+    @Nullable
+    public static Context getContext()
+    {
+        return context;
+    }
+
+    @Override
+    public void onCreate()
+    {
+        super.onCreate();
+        HabitsApplication.context = this;
+
+        if (isTestMode())
+        {
+            File db = DatabaseHelper.getDatabaseFile();
+            if(db.exists()) db.delete();
+        }
+
+        DatabaseHelper.initializeActiveAndroid();
+    }
+
+    @Override
+    public void onTerminate()
+    {
+        HabitsApplication.context = null;
+        ActiveAndroid.dispose();
+        super.onTerminate();
+    }
+
+    public static String getLogcat() throws IOException
+    {
+        StringBuilder builder = new StringBuilder();
+
+        String[] command = new String[] { "logcat", "-d"};
+        Process process = Runtime.getRuntime().exec(command);
+
+        InputStreamReader in = new InputStreamReader(process.getInputStream());
+        BufferedReader bufferedReader = new BufferedReader(in);
+
+        String line;
+        while ((line = bufferedReader.readLine()) != null)
+        {
+            builder.append(line);
+            builder.append('\n');
+        }
+
+        return builder.toString();
+    }
+
+    public static String getDeviceInfo()
+    {
+        if(context == null) return "";
+
+        StringBuilder b = new StringBuilder();
+        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
+
+        b.append(String.format("App Version Name: %s\n", BuildConfig.VERSION_NAME));
+        b.append(String.format("App Version Code: %s\n", BuildConfig.VERSION_CODE));
+        b.append(String.format("OS Version: %s (%s)\n", System.getProperty("os.version"),
+                android.os.Build.VERSION.INCREMENTAL));
+        b.append(String.format("OS API Level: %s\n", android.os.Build.VERSION.SDK));
+        b.append(String.format("Device: %s\n", android.os.Build.DEVICE));
+        b.append(String.format("Model (Product): %s (%s)\n", android.os.Build.MODEL,
+                android.os.Build.PRODUCT));
+        b.append(String.format("Manufacturer: %s\n", android.os.Build.MANUFACTURER));
+        b.append(String.format("Other tags: %s\n", android.os.Build.TAGS));
+        b.append(String.format("Screen Width: %s\n", wm.getDefaultDisplay().getWidth()));
+        b.append(String.format("Screen Height: %s\n", wm.getDefaultDisplay().getHeight()));
+        b.append(String.format("SD Card state: %s\n\n", Environment.getExternalStorageState()));
+
+        return b.toString();
+    }
+
+    @NonNull
+    public static File generateLogFile() throws IOException
+    {
+        String logcat = getLogcat();
+        String deviceInfo = getDeviceInfo();
+        String date = DateHelper.getBackupDateFormat().format(DateHelper.getLocalTime());
+
+        if(context == null) throw new RuntimeException("application context should not be null");
+        File dir = DatabaseHelper.getFilesDir("Logs");
+        if (dir == null) throw new IOException("log dir should not be null");
+
+        File logFile = new File(String.format("%s/Log %s.txt", dir.getPath(), date));
+        FileWriter output = new FileWriter(logFile);
+        output.write(deviceInfo);
+        output.write(logcat);
+        output.close();
+
+        return logFile;
+    }
+}

app/src/main/java/org/isoron/uhabits/HabitsBackupAgent.java

@@ -1,17 +1,20 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
  *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
+ * This file is part of Loop Habit Tracker.
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  * more details.
  *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.isoron.uhabits;

app/src/main/java/org/isoron/uhabits/IntroActivity.java

@@ -1,17 +1,20 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
  *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
+ * This file is part of Loop Habit Tracker.
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  * more details.
  *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.isoron.uhabits;
@@ -37,10 +40,6 @@ public class IntroActivity extends AppIntro2
                 getString(R.string.intro_description_2), R.drawable.intro_icon_2,
                 Color.parseColor("#ffa726")));
 
-        addSlide(AppIntroFragment.newInstance(getString(R.string.intro_title_3),
-                getString(R.string.intro_description_3), R.drawable.intro_icon_3,
-                Color.parseColor("#7cb342")));
-
         addSlide(AppIntroFragment.newInstance(getString(R.string.intro_title_4),
                 getString(R.string.intro_description_4), R.drawable.intro_icon_4,
                 Color.parseColor("#9575cd")));

app/src/main/java/org/isoron/uhabits/MainActivity.java

@@ -1,61 +1,126 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
  *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
+ * This file is part of Loop Habit Tracker.
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  * more details.
  *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.isoron.uhabits;
 
+import android.appwidget.AppWidgetManager;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
 import android.content.Intent;
+import android.content.IntentFilter;
 import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.graphics.drawable.ColorDrawable;
 import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Build;
 import android.os.Bundle;
+import android.os.Handler;
 import android.preference.PreferenceManager;
+import android.support.annotation.NonNull;
+import android.support.v4.content.LocalBroadcastManager;
+import android.support.v7.app.ActionBar;
 import android.view.Menu;
 import android.view.MenuItem;
 
-import org.isoron.helpers.DateHelper;
-import org.isoron.helpers.DialogHelper;
-import org.isoron.helpers.ReplayableActivity;
 import org.isoron.uhabits.fragments.ListHabitsFragment;
+import org.isoron.uhabits.helpers.DateHelper;
 import org.isoron.uhabits.helpers.ReminderHelper;
+import org.isoron.uhabits.helpers.UIHelper;
+import org.isoron.uhabits.models.Checkmark;
 import org.isoron.uhabits.models.Habit;
+import org.isoron.uhabits.tasks.BaseTask;
+import org.isoron.uhabits.widgets.CheckmarkWidgetProvider;
+import org.isoron.uhabits.widgets.FrequencyWidgetProvider;
+import org.isoron.uhabits.widgets.HistoryWidgetProvider;
+import org.isoron.uhabits.widgets.ScoreWidgetProvider;
+import org.isoron.uhabits.widgets.StreakWidgetProvider;
 
-public class MainActivity extends ReplayableActivity
+import java.io.File;
+import java.io.IOException;
+
+public class MainActivity extends BaseActivity
         implements ListHabitsFragment.OnHabitClickListener
 {
     private ListHabitsFragment listHabitsFragment;
-    SharedPreferences prefs;
+    private SharedPreferences prefs;
+    private BroadcastReceiver receiver;
+    private LocalBroadcastManager localBroadcastManager;
+
+    public static final String ACTION_REFRESH = "org.isoron.uhabits.ACTION_REFRESH";
+
+    public static final int RESULT_IMPORT_DATA = 1;
+    public static final int RESULT_EXPORT_CSV = 2;
+    public static final int RESULT_EXPORT_DB = 3;
+    public static final int RESULT_BUG_REPORT = 4;
 
     @Override
     protected void onCreate(Bundle savedInstanceState)
     {
         super.onCreate(savedInstanceState);
+
         setContentView(R.layout.list_habits_activity);
 
+        setupSupportActionBar(false);
+
         prefs = PreferenceManager.getDefaultSharedPreferences(this);
         listHabitsFragment =
-                (ListHabitsFragment) getFragmentManager().findFragmentById(R.id.fragment1);
+                (ListHabitsFragment) getSupportFragmentManager().findFragmentById(R.id.fragment1);
+
+        receiver = new Receiver();
+        localBroadcastManager = LocalBroadcastManager.getInstance(this);
+        localBroadcastManager.registerReceiver(receiver, new IntentFilter(ACTION_REFRESH));
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP)
+            onPreLollipopStartup();
 
         onStartup();
     }
 
+    private void onPreLollipopStartup()
+    {
+        ActionBar actionBar = getSupportActionBar();
+        if(actionBar == null) return;
+        if(UIHelper.isNightMode()) return;
+
+        int color = getResources().getColor(R.color.grey_900);
+        actionBar.setBackgroundDrawable(new ColorDrawable(color));
+    }
+
     private void onStartup()
     {
         PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
-        ReminderHelper.createReminderAlarms(MainActivity.this);
-        DialogHelper.incrementLaunchCount(this);
+        UIHelper.incrementLaunchCount(this);
+        UIHelper.updateLastAppVersion(this);
         showTutorial();
+
+        new AsyncTask<Void, Void, Void>() {
+            @Override
+            protected Void doInBackground(Void... params)
+            {
+                ReminderHelper.createReminderAlarms(MainActivity.this);
+                updateWidgets(MainActivity.this);
+                return null;
+            }
+        }.execute();
+
     }
 
     private void showTutorial()
@@ -77,7 +142,12 @@ public class MainActivity extends ReplayableActivity
     @Override
     public boolean onCreateOptionsMenu(Menu menu)
     {
+        menu.clear();
         getMenuInflater().inflate(R.menu.list_habits_menu, menu);
+
+        MenuItem nightModeItem = menu.findItem(R.id.action_night_mode);
+        nightModeItem.setChecked(UIHelper.isNightMode());
+
         return true;
     }
 
@@ -86,16 +156,104 @@ public class MainActivity extends ReplayableActivity
     {
         switch (item.getItemId())
         {
+            case R.id.action_night_mode:
+            {
+                if(UIHelper.isNightMode())
+                    UIHelper.setCurrentTheme(UIHelper.THEME_LIGHT);
+                else
+                    UIHelper.setCurrentTheme(UIHelper.THEME_DARK);
+
+                refreshTheme();
+                return true;
+            }
+
             case R.id.action_settings:
+            {
                 Intent intent = new Intent(this, SettingsActivity.class);
+                startActivityForResult(intent, 0);
+                return true;
+            }
+
+            case R.id.action_about:
+            {
+                Intent intent = new Intent(this, AboutActivity.class);
                 startActivity(intent);
                 return true;
+            }
+
+            case R.id.action_faq:
+            {
+                Intent intent = new Intent();
+                intent.setAction(Intent.ACTION_VIEW);
+                intent.setData(Uri.parse(getString(R.string.helpURL)));
+                startActivity(intent);
+                return true;
+            }
 
             default:
                 return super.onOptionsItemSelected(item);
         }
     }
 
+    private void refreshTheme()
+    {
+        new Handler().postDelayed(new Runnable()
+        {
+            @Override
+            public void run()
+            {
+                Intent intent = new Intent(MainActivity.this, MainActivity.class);
+
+                MainActivity.this.finish();
+                overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out);
+                startActivity(intent);
+
+            }
+        }, 500); // Let the menu disappear first
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data)
+    {
+        switch (resultCode)
+        {
+            case RESULT_IMPORT_DATA:
+                listHabitsFragment.showImportDialog();
+                break;
+
+            case RESULT_EXPORT_CSV:
+                listHabitsFragment.exportAllHabits();
+                break;
+
+            case RESULT_EXPORT_DB:
+                listHabitsFragment.exportDB();
+                break;
+
+            case RESULT_BUG_REPORT:
+                generateBugReport();
+                break;
+        }
+    }
+
+    private void generateBugReport()
+    {
+        try
+        {
+            File logFile = HabitsApplication.generateLogFile();
+
+            Intent intent = new Intent();
+            intent.setAction(Intent.ACTION_SENDTO);
+            intent.setData(Uri.parse(getString(R.string.bugReportURL)));
+            intent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(logFile));
+            startActivity(intent);
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+            showToast(R.string.bug_report_failed);
+        }
+    }
+
     @Override
     public void onHabitClicked(Habit habit)
     {
@@ -108,5 +266,69 @@ public class MainActivity extends ReplayableActivity
     public void onPostExecuteCommand(Long refreshKey)
     {
         listHabitsFragment.onPostExecuteCommand(refreshKey);
+
+        new BaseTask()
+        {
+            @Override
+            protected void doInBackground()
+            {
+                dismissNotifications(MainActivity.this);
+                updateWidgets(MainActivity.this);
+            }
+        }.execute();
+    }
+
+    private void dismissNotifications(Context context)
+    {
+        for(Habit h : Habit.getHabitsWithReminder())
+        {
+            if(h.checkmarks.getTodayValue() != Checkmark.UNCHECKED)
+                HabitBroadcastReceiver.dismissNotification(context, h);
+        }
+    }
+
+    public static void updateWidgets(Context context)
+    {
+        updateWidgets(context, CheckmarkWidgetProvider.class);
+        updateWidgets(context, HistoryWidgetProvider.class);
+        updateWidgets(context, ScoreWidgetProvider.class);
+        updateWidgets(context, StreakWidgetProvider.class);
+        updateWidgets(context, FrequencyWidgetProvider.class);
+    }
+
+    private static void updateWidgets(Context context, Class providerClass)
+    {
+        ComponentName provider = new ComponentName(context, providerClass);
+        Intent intent = new Intent(context, providerClass);
+        intent.setAction(AppWidgetManager.ACTION_APPWIDGET_UPDATE);
+        int ids[] = AppWidgetManager.getInstance(context).getAppWidgetIds(provider);
+        intent.putExtra(AppWidgetManager.EXTRA_APPWIDGET_IDS, ids);
+        context.sendBroadcast(intent);
+    }
+
+    @Override
+    protected void onDestroy()
+    {
+        localBroadcastManager.unregisterReceiver(receiver);
+        super.onDestroy();
+    }
+
+    class Receiver extends BroadcastReceiver
+    {
+        @Override
+        public void onReceive(Context context, Intent intent)
+        {
+            listHabitsFragment.onPostExecuteCommand(null);
+        }
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
+                                           @NonNull int[] grantResults)
+    {
+        if (grantResults.length <= 0) return;
+        if (grantResults[0] != PackageManager.PERMISSION_GRANTED) return;
+
+        listHabitsFragment.showImportDialog();
     }
 }

app/src/main/java/org/isoron/uhabits/ReminderAlarmReceiver.java

@@ -1,207 +0,0 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
- *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
- * more details.
- *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package org.isoron.uhabits;
-
-import android.app.Activity;
-import android.app.Notification;
-import android.app.NotificationManager;
-import android.app.PendingIntent;
-import android.content.BroadcastReceiver;
-import android.content.ContentUris;
-import android.content.Context;
-import android.content.Intent;
-import android.content.SharedPreferences;
-import android.graphics.BitmapFactory;
-import android.media.RingtoneManager;
-import android.net.Uri;
-import android.os.Handler;
-import android.preference.PreferenceManager;
-import android.support.v4.app.NotificationCompat;
-
-import org.isoron.helpers.DateHelper;
-import org.isoron.uhabits.helpers.ReminderHelper;
-import org.isoron.uhabits.models.Habit;
-
-import java.util.Date;
-
-public class ReminderAlarmReceiver extends BroadcastReceiver
-{
-    public static final String ACTION_CHECK = "org.isoron.uhabits.ACTION_CHECK";
-    public static final String ACTION_DISMISS = "org.isoron.uhabits.ACTION_DISMISS";
-    public static final String ACTION_REMIND = "org.isoron.uhabits.ACTION_REMIND";
-    public static final String ACTION_REMOVE_REMINDER = "org.isoron.uhabits.ACTION_REMOVE_REMINDER";
-    public static final String ACTION_SNOOZE = "org.isoron.uhabits.ACTION_SNOOZE";
-
-    @Override
-    public void onReceive(final Context context, Intent intent)
-    {
-        switch (intent.getAction())
-        {
-            case ACTION_REMIND:
-                createNotification(context, intent);
-                createReminderAlarms(context);
-                break;
-
-            case ACTION_DISMISS:
-                dismissAllHabits();
-                break;
-
-            case ACTION_CHECK:
-                checkHabit(context, intent);
-                break;
-
-            case ACTION_SNOOZE:
-                snoozeHabit(context, intent);
-                break;
-        }
-    }
-
-    private void createReminderAlarms(final Context context)
-    {
-        new Handler().postDelayed(new Runnable()
-        {
-            @Override
-            public void run()
-            {
-                ReminderHelper.createReminderAlarms(context);
-            }
-        }, 5000);
-    }
-
-    private void snoozeHabit(Context context, Intent intent)
-    {
-        Uri data = intent.getData();
-        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
-        long delayMinutes = Long.parseLong(prefs.getString("pref_snooze_interval", "15"));
-
-        Habit habit = Habit.get(ContentUris.parseId(data));
-        ReminderHelper.createReminderAlarm(context, habit,
-                new Date().getTime() + delayMinutes * 60 * 1000);
-        dismissNotification(context, habit);
-    }
-
-    private void checkHabit(Context context, Intent intent)
-    {
-        Uri data = intent.getData();
-        Long timestamp = DateHelper.getStartOfToday();
-        String paramTimestamp = data.getQueryParameter("timestamp");
-
-        if(paramTimestamp != null) timestamp = Long.parseLong(paramTimestamp);
-
-        Habit habit = Habit.get(ContentUris.parseId(data));
-        habit.toggleRepetition(timestamp);
-        habit.save();
-        dismissNotification(context, habit);
-    }
-
-    private void dismissAllHabits()
-    {
-        for (Habit h : Habit.getHighlightedHabits())
-        {
-            h.highlight = 0;
-            h.save();
-        }
-    }
-
-    private void dismissNotification(Context context, Habit habit)
-    {
-        NotificationManager notificationManager =
-                (NotificationManager) context.getSystemService(Activity.NOTIFICATION_SERVICE);
-
-        int notificationId = (int) (habit.getId() % Integer.MAX_VALUE);
-        notificationManager.cancel(notificationId);
-    }
-
-
-    private void createNotification(Context context, Intent intent)
-    {
-        Uri data = intent.getData();
-        Habit habit = Habit.get(ContentUris.parseId(data));
-
-        if (habit.hasImplicitRepToday()) return;
-
-        habit.highlight = 1;
-        habit.save();
-
-        if (!checkWeekday(intent, habit)) return;
-
-        // Check if reminder has been turned off after alarm was scheduled
-        if (habit.reminderHour == null) return;
-
-        Intent contentIntent = new Intent(context, MainActivity.class);
-        contentIntent.setData(data);
-        PendingIntent contentPendingIntent =
-                PendingIntent.getActivity(context, 0, contentIntent, 0);
-
-        Intent deleteIntent = new Intent(context, ReminderAlarmReceiver.class);
-        deleteIntent.setAction(ACTION_DISMISS);
-        PendingIntent deletePendingIntent = PendingIntent.getBroadcast(context, 0, deleteIntent, 0);
-
-        Intent checkIntent = new Intent(context, ReminderAlarmReceiver.class);
-        checkIntent.setData(data);
-        checkIntent.setAction(ACTION_CHECK);
-        PendingIntent checkIntentPending = PendingIntent.getBroadcast(context, 0, checkIntent, 0);
-
-        Intent snoozeIntent = new Intent(context, ReminderAlarmReceiver.class);
-        snoozeIntent.setData(data);
-        snoozeIntent.setAction(ACTION_SNOOZE);
-        PendingIntent snoozeIntentPending = PendingIntent.getBroadcast(context, 0, snoozeIntent, 0);
-
-        Uri soundUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
-
-        Long reminderTime = intent.getLongExtra("reminderTime", DateHelper.getStartOfToday());
-
-        NotificationCompat.WearableExtender wearableExtender =
-                new NotificationCompat.WearableExtender().setBackground(
-                        BitmapFactory.decodeResource(context.getResources(), R.drawable.stripe));
-
-        Notification notification =
-                new NotificationCompat.Builder(context).setSmallIcon(R.drawable.ic_notification)
-                        .setContentTitle(habit.name)
-                        .setContentText(habit.description)
-                        .setContentIntent(contentPendingIntent)
-                        .setDeleteIntent(deletePendingIntent)
-                        .addAction(R.drawable.ic_action_check,
-                                context.getString(R.string.check), checkIntentPending)
-                        .addAction(R.drawable.ic_action_snooze,
-                                context.getString(R.string.snooze), snoozeIntentPending)
-                        .setSound(soundUri)
-                        .extend(wearableExtender)
-                        .setWhen(reminderTime)
-                        .setShowWhen(true)
-                        .build();
-
-        notification.flags |= Notification.FLAG_AUTO_CANCEL;
-
-        NotificationManager notificationManager =
-                (NotificationManager) context.getSystemService(Activity.NOTIFICATION_SERVICE);
-
-        int notificationId = (int) (habit.getId() % Integer.MAX_VALUE);
-        notificationManager.notify(notificationId, notification);
-    }
-
-    private boolean checkWeekday(Intent intent, Habit habit)
-    {
-        Long timestamp = intent.getLongExtra("timestamp", DateHelper.getStartOfToday());
-
-        boolean reminderDays[] = DateHelper.unpackWeekdayList(habit.reminderDays);
-        int weekday = DateHelper.getWeekday(timestamp);
-
-        return reminderDays[weekday];
-    }
-
-}

app/src/main/java/org/isoron/uhabits/SettingsActivity.java

@@ -1,34 +1,38 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
  *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
+ * This file is part of Loop Habit Tracker.
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  * more details.
  *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.isoron.uhabits;
 
-import android.app.Activity;
 import android.os.Bundle;
 
-import org.isoron.uhabits.fragments.SettingsFragment;
+import org.isoron.uhabits.helpers.UIHelper;
 
-public class SettingsActivity extends Activity
+public class SettingsActivity extends BaseActivity
 {
     @Override
     protected void onCreate(Bundle savedInstanceState)
     {
         super.onCreate(savedInstanceState);
-        getFragmentManager().beginTransaction()
-                .replace(android.R.id.content, new SettingsFragment())
-                .commit();
+        setContentView(R.layout.settings_activity);
+        setupSupportActionBar(true);
+
+        int color = UIHelper.getStyledColor(this, R.attr.aboutScreenColor);
+        setupActionBarColor(color);
     }
 }

app/src/main/java/org/isoron/uhabits/ShowHabitActivity.java

@@ -1,36 +1,35 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
  *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
+ * This file is part of Loop Habit Tracker.
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  * more details.
  *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.isoron.uhabits;
 
 import android.content.ContentUris;
-import android.content.Intent;
-import android.graphics.drawable.ColorDrawable;
 import android.net.Uri;
 import android.os.Bundle;
-import android.view.Menu;
-import android.view.MenuItem;
+import android.support.v7.app.ActionBar;
 
-import org.isoron.helpers.ReplayableActivity;
+import org.isoron.uhabits.helpers.ColorHelper;
 import org.isoron.uhabits.models.Habit;
 
-public class ShowHabitActivity extends ReplayableActivity
+public class ShowHabitActivity extends BaseActivity
 {
-
-    public Habit habit;
+    private Habit habit;
 
     @Override
     protected void onCreate(Bundle savedInstanceState)
@@ -39,34 +38,27 @@ public class ShowHabitActivity extends ReplayableActivity
 
         Uri data = getIntent().getData();
         habit = Habit.get(ContentUris.parseId(data));
-        getActionBar().setTitle(habit.name);
-
-        if (android.os.Build.VERSION.SDK_INT >= 21)
-        {
-            getActionBar().setBackgroundDrawable(new ColorDrawable(habit.color));
-        }
 
         setContentView(R.layout.show_habit_activity);
+
+        setupSupportActionBar(true);
+        setupHabitActionBar();
     }
 
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu)
+    private void setupHabitActionBar()
     {
-        getMenuInflater().inflate(R.menu.show_habit_activity_menu, menu);
-        return true;
+        if(habit == null) return;
+
+        ActionBar actionBar = getSupportActionBar();
+        if(actionBar == null) return;
+
+        actionBar.setTitle(habit.name);
+
+        setupActionBarColor(ColorHelper.getColor(this, habit.color));
     }
 
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item)
+    public Habit getHabit()
     {
-        switch (item.getItemId())
-        {
-            case R.id.action_settings:
-                Intent intent = new Intent(this, SettingsActivity.class);
-                startActivity(intent);
-                return true;
-        }
-
-        return super.onOptionsItemSelected(item);
+        return habit;
     }
 }

app/src/main/java/org/isoron/uhabits/commands/ArchiveHabitsCommand.java

@@ -1,26 +1,27 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
  *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
+ * This file is part of Loop Habit Tracker.
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  * more details.
  *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.isoron.uhabits.commands;
 
-import org.isoron.helpers.Command;
 import org.isoron.uhabits.R;
 import org.isoron.uhabits.models.Habit;
 
-import java.util.LinkedList;
 import java.util.List;
 
 public class ArchiveHabitsCommand extends Command
@@ -28,12 +29,6 @@ public class ArchiveHabitsCommand extends Command
 
     private List<Habit> habits;
 
-    public ArchiveHabitsCommand(Habit habit)
-    {
-        habits = new LinkedList<>();
-        habits.add(habit);
-    }
-
     public ArchiveHabitsCommand(List<Habit> habits)
     {
         this.habits = habits;
@@ -42,15 +37,13 @@ public class ArchiveHabitsCommand extends Command
     @Override
     public void execute()
     {
-        for(Habit h : habits)
-            h.archive();
+        Habit.archive(habits);
     }
 
     @Override
     public void undo()
     {
-        for(Habit h : habits)
-            h.unarchive();
+        Habit.unarchive(habits);
     }
 
     public Integer getExecuteStringId()

app/src/main/java/org/isoron/uhabits/commands/ChangeHabitColorCommand.java

@@ -1,29 +1,31 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
  *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
+ * This file is part of Loop Habit Tracker.
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  * more details.
  *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.isoron.uhabits.commands;
 
 import com.activeandroid.ActiveAndroid;
 
-import org.isoron.helpers.Command;
 import org.isoron.uhabits.R;
+import org.isoron.uhabits.helpers.DatabaseHelper;
 import org.isoron.uhabits.models.Habit;
 
 import java.util.ArrayList;
-import java.util.LinkedList;
 import java.util.List;
 
 public class ChangeHabitColorCommand extends Command
@@ -45,30 +47,16 @@ public class ChangeHabitColorCommand extends Command
     @Override
     public void execute()
     {
-        ActiveAndroid.beginTransaction();
-
-        try
-        {
-            for(Habit h : habits)
-            {
-                h.color = newColor;
-                h.save();
-            }
-
-            ActiveAndroid.setTransactionSuccessful();
-        }
-        finally
-        {
-            ActiveAndroid.endTransaction();
-        }
+        Habit.setColor(habits, newColor);
     }
 
     @Override
     public void undo()
     {
-        ActiveAndroid.beginTransaction();
-
-        try
+        DatabaseHelper.executeAsTransaction(new DatabaseHelper.Command()
+        {
+            @Override
+            public void execute()
             {
                 int k = 0;
                 for(Habit h : habits)
@@ -76,13 +64,8 @@ public class ChangeHabitColorCommand extends Command
                     h.color = originalColors.get(k++);
                     h.save();
                 }
-
-            ActiveAndroid.setTransactionSuccessful();
-        }
-        finally
-        {
-            ActiveAndroid.endTransaction();
             }
+        });
     }
 
     public Integer getExecuteStringId()

app/src/main/java/org/isoron/uhabits/commands/Command.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.commands;
+
+public abstract class Command
+{
+    public abstract void execute();
+
+    public abstract void undo();
+
+    public Integer getExecuteStringId()
+    {
+        return null;
+    }
+
+    public Integer getUndoStringId()
+    {
+        return null;
+    }
+}

app/src/main/java/org/isoron/uhabits/commands/CreateHabitCommand.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.commands;
+
+import org.isoron.uhabits.R;
+import org.isoron.uhabits.models.Habit;
+
+public class CreateHabitCommand extends Command
+{
+    private Habit model;
+    private Long savedId;
+
+    public CreateHabitCommand(Habit model)
+    {
+        this.model = model;
+    }
+
+    @Override
+    public void execute()
+    {
+        Habit savedHabit = new Habit(model);
+        if (savedId == null)
+        {
+            savedHabit.save();
+            savedId = savedHabit.getId();
+        }
+        else
+        {
+            savedHabit.save(savedId);
+        }
+    }
+
+    @Override
+    public void undo()
+    {
+        Habit habit = Habit.get(savedId);
+        if(habit == null) throw new RuntimeException("Habit not found");
+
+        habit.cascadeDelete();
+    }
+
+    @Override
+    public Integer getExecuteStringId()
+    {
+        return R.string.toast_habit_created;
+    }
+
+    @Override
+    public Integer getUndoStringId()
+    {
+        return R.string.toast_habit_deleted;
+    }
+
+}

app/src/main/java/org/isoron/uhabits/commands/DeleteHabitsCommand.java

@@ -1,22 +1,24 @@
-/* Copyright (C) 2016 Alinson Santos Xavier
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
  *
- * This program is free software: you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the Free
- * Software Foundation, either version 3 of the License, or (at your option)
- * any later version.
+ * This file is part of Loop Habit Tracker.
  *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied  warranty of MERCHANTABILITY or
- * FITNESS  FOR  A PARTICULAR PURPOSE. See the GNU General Public License for
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  * more details.
  *
- * You  should  have  received  a  copy  of the GNU General Public License
- * along  with  this  program. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.isoron.uhabits.commands;
 
-import org.isoron.helpers.Command;
 import org.isoron.uhabits.R;
 import org.isoron.uhabits.models.Habit;
 
@@ -36,12 +38,14 @@ public class DeleteHabitsCommand extends Command
     {
         for(Habit h : habits)
             h.cascadeDelete();
+
+        Habit.rebuildOrder();
     }
 
     @Override
     public void undo()
     {
-
+        throw new UnsupportedOperationException();
     }
 
     public Integer getExecuteStringId()

app/src/main/java/org/isoron/uhabits/commands/EditHabitCommand.java

@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.commands;
+
+import org.isoron.uhabits.R;
+import org.isoron.uhabits.models.Habit;
+
+public class EditHabitCommand extends Command
+{
+    private Habit original;
+    private Habit modified;
+    private long savedId;
+    private boolean hasIntervalChanged;
+
+    public EditHabitCommand(Habit original, Habit modified)
+    {
+        this.savedId = original.getId();
+        this.modified = new Habit(modified);
+        this.original = new Habit(original);
+
+        hasIntervalChanged = (!this.original.freqDen.equals(this.modified.freqDen) ||
+                !this.original.freqNum.equals(this.modified.freqNum));
+    }
+
+    @Override
+    public void execute()
+    {
+        copyAttributes(this.modified);
+    }
+
+    @Override
+    public void undo()
+    {
+        copyAttributes(this.original);
+    }
+
+    private void copyAttributes(Habit model)
+    {
+        Habit habit = Habit.get(savedId);
+        if(habit == null) throw new RuntimeException("Habit not found");
+
+        habit.copyAttributes(model);
+        habit.save();
+
+        invalidateIfNeeded(habit);
+    }
+
+    private void invalidateIfNeeded(Habit habit)
+    {
+        if (hasIntervalChanged)
+        {
+            habit.checkmarks.deleteNewerThan(0);
+            habit.streaks.deleteNewerThan(0);
+            habit.scores.invalidateNewerThan(0);
+        }
+    }
+
+    public Integer getExecuteStringId()
+    {
+        return R.string.toast_habit_changed;
+    }
+
+    public Integer getUndoStringId()
+    {
+        return R.string.toast_habit_changed_back;
+    }
+}

app/src/main/java/org/isoron/uhabits/commands/ToggleRepetitionCommand.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2016 Álinson Santos Xavier <isoron@gmail.com>
+ *
+ * This file is part of Loop Habit Tracker.
+ *
+ * Loop Habit Tracker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or (at your
+ * option) any later version.
+ *
+ * Loop Habit Tracker is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+ * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.isoron.uhabits.commands;
+
+import org.isoron.uhabits.models.Habit;
+
+public class ToggleRepetitionCommand extends Command
+{
+    private Long offset;
+    private Habit habit;
+
+    public ToggleRepetitionCommand(Habit habit, long offset)
+    {
+        this.offset = offset;
+        this.habit = habit;
+    }
+
+    @Override
+    public void execute()
+    {
+        habit.repetitions.toggle(offset);
+    }
+
+    @Override
+    public void undo()
+    {
+        execute();
+    }
+}