From e7511d0041f2efd1969410eed7a2fcd6f3d5c12f Mon Sep 17 00:00:00 2001
From: Gabriele M <moto.falcon.git@gmail.com>
Date: Sun, 2 Jul 2017 17:46:36 +0200
Subject: [PATCH] Project init

---
 Android.mk                                    |  37 ++
 AndroidManifest.xml                           |  32 ++
 res/drawable-hdpi/ic_launcher.png             | Bin 0 -> 1010 bytes
 res/drawable-mdpi/ic_launcher.png             | Bin 0 -> 670 bytes
 res/drawable-xhdpi/ic_launcher.png            | Bin 0 -> 1193 bytes
 res/drawable-xxhdpi/ic_launcher.png           | Bin 0 -> 1618 bytes
 res/drawable-xxxhdpi/ic_launcher.png          | Bin 0 -> 2190 bytes
 res/drawable/ic_system_update.xml             |  11 +
 res/layout/activity_updates.xml               |  13 +
 res/layout/fragment_updates_list.xml          |  14 +
 res/layout/update_item_view.xml               |  31 ++
 res/values/config.xml                         |   4 +
 res/values/strings.xml                        |  38 ++
 src/org/lineageos/updater/DownloadClient.java | 287 ++++++++++++++
 .../lineageos/updater/DownloadController.java | 357 ++++++++++++++++++
 .../updater/DownloadControllerInt.java        |  42 +++
 .../lineageos/updater/DownloadService.java    | 266 +++++++++++++
 src/org/lineageos/updater/Update.java         |  82 ++++
 src/org/lineageos/updater/UpdateDownload.java |  76 ++++
 src/org/lineageos/updater/UpdateStatus.java   |  37 ++
 .../updater/UpdaterBroadcastReceiver.java     |  61 +++
 .../lineageos/updater/UpdatesActivity.java    | 190 ++++++++++
 .../lineageos/updater/UpdatesDbHelper.java    | 207 ++++++++++
 .../lineageos/updater/UpdatesListAdapter.java | 192 ++++++++++
 src/org/lineageos/updater/misc/Utils.java     | 131 +++++++
 25 files changed, 2108 insertions(+)
 create mode 100644 Android.mk
 create mode 100644 AndroidManifest.xml
 create mode 100644 res/drawable-hdpi/ic_launcher.png
 create mode 100644 res/drawable-mdpi/ic_launcher.png
 create mode 100644 res/drawable-xhdpi/ic_launcher.png
 create mode 100644 res/drawable-xxhdpi/ic_launcher.png
 create mode 100644 res/drawable-xxxhdpi/ic_launcher.png
 create mode 100644 res/drawable/ic_system_update.xml
 create mode 100644 res/layout/activity_updates.xml
 create mode 100644 res/layout/fragment_updates_list.xml
 create mode 100644 res/layout/update_item_view.xml
 create mode 100644 res/values/config.xml
 create mode 100644 res/values/strings.xml
 create mode 100644 src/org/lineageos/updater/DownloadClient.java
 create mode 100644 src/org/lineageos/updater/DownloadController.java
 create mode 100644 src/org/lineageos/updater/DownloadControllerInt.java
 create mode 100644 src/org/lineageos/updater/DownloadService.java
 create mode 100644 src/org/lineageos/updater/Update.java
 create mode 100644 src/org/lineageos/updater/UpdateDownload.java
 create mode 100644 src/org/lineageos/updater/UpdateStatus.java
 create mode 100644 src/org/lineageos/updater/UpdaterBroadcastReceiver.java
 create mode 100644 src/org/lineageos/updater/UpdatesActivity.java
 create mode 100644 src/org/lineageos/updater/UpdatesDbHelper.java
 create mode 100644 src/org/lineageos/updater/UpdatesListAdapter.java
 create mode 100644 src/org/lineageos/updater/misc/Utils.java

diff --git a/Android.mk b/Android.mk
new file mode 100644
index 00000000..aad3dcfb
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,37 @@
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_STATIC_JAVA_LIBRARIES := \
+    android-support-design \
+    android-support-v4 \
+    android-support-v7-appcompat \
+    android-support-v7-cardview \
+    android-support-v7-preference \
+    android-support-v7-recyclerview \
+    okhttp
+
+LOCAL_RESOURCE_DIR := \
+    $(TOP)/frameworks/support/design/res \
+    $(TOP)/frameworks/support/v7/appcompat/res \
+    $(TOP)/frameworks/support/v7/cardview/res \
+    $(TOP)/frameworks/support/v7/preference/res \
+    $(TOP)/frameworks/support/v7/recyclerview/res \
+    $(LOCAL_PATH)/res
+
+LOCAL_AAPT_FLAGS := \
+    --auto-add-overlay \
+    --extra-packages android.support.design \
+    --extra-packages android.support.v7.appcompat \
+    --extra-packages android.support.v7.cardview \
+    --extra-packages android.support.v7.preference \
+    --extra-packages android.support.v7.recyclerview
+
+LOCAL_PACKAGE_NAME := Updater
+LOCAL_PRIVILEGED_MODULE := true
+
+include $(BUILD_PACKAGE)
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
new file mode 100644
index 00000000..f441156d
--- /dev/null
+++ b/AndroidManifest.xml
@@ -0,0 +1,32 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.lineageos.updater">
+
+    <uses-permission android:name="android.permission.ACCESS_CACHE_FILESYSTEM" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    <application
+        android:allowBackup="false"
+        android:icon="@drawable/ic_launcher"
+        android:label="@string/app_name"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.AppCompat.Light">
+
+        <activity
+            android:name=".UpdatesActivity"
+            android:label="@string/display_name"
+            android:launchMode="singleTask">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="com.android.settings.SHORTCUT" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
+        <service android:name=".DownloadService" />
+
+        <receiver android:name=".UpdaterBroadcastReceiver" android:exported="false" />
+    </application>
+
+</manifest>
diff --git a/res/drawable-hdpi/ic_launcher.png b/res/drawable-hdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..030e540768a2caed462916f6e326f940e48f6c26
GIT binary patch
literal 1010
zcmV<O0}cF%P)<h;3K|Lk000e1NJLTq002k;002k`1^@s6RqeA!0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU#lu1NERCwC#+|6neK^y?^|4hErsst74
zMH)N^UaSFcJrwZ)482%Ta>xTHeSsc)fxJUJ^-|)|gGi9-QStzm6hWj14Vtt~vLDW5
zciSbK-E1Z^yEEzhVY`83zkZ#M|4fDe=+L1<U?7%*GJCxe+11HbQRF$BWZN-cT<-`6
za&f+qt*BUG=#s5GFA`?BP+dVBaPPT3??Eg;6;L-SNdR4{&_EhU18E=)q=7V$2D+?~
zP2wV@6$I5%j_Wxaoe^~Uw)#NpMGPOGUV&l`aXs(r2U&Rb=?vOkOYJJQzri18Jn|&x
z+}|hw*op(KtssHtCbvHt5+qw)An`$PjG?pFKw(CfQ<5}LoRXx0f`QOQNis+3<w55c
zdv_f5l(PZcFkamWeGe?t*=KUgRD$B;#0rY!L8%YK8OICL;DUsg6306)2c)blIGd|E
z*u0w`zi#~+K<n6KghRoSgfKIBR+f@OadsbF8^3-_dZO0PQ*w9t#c<A%Moy#6fP|&0
zR+9~_Kd)iM@gp&0+gM5*?{gN(YmCuiIR0a4byKpNp9<hl{tP}1y=^N9gl0S--Dq{2
z_rH($%pzdvalBGuS@Dq&zbO{11de~yJ}a+5d~+)-9Zp#Lg4{n*?FizZcqX0)t>4PQ
z^LzPV9<-YC<wOP8ee45rckh1;p#9rO3@3RYa-;1(2E2KA6{`0Op&z43qnA~C(fEGq
z;-JKEQmbOMFaMx%IEejuic>rI3v;g+<j`2B)=0-i3g84D+MeDnEkie7``U{{nvDbV
zS2@+X`7oq-IP+F3MZ5V)q(~f$!_UVVC!OhzkcXg1UNR^PPAc7ebeq(7Gvz28B)nS5
zH=6f92+jm&08_$|2x#I#un#B-hjorf)+%PayqymCa#XPdaFiL%D}u9RKw<{0$^(_?
zA}UaLG=C&;q2*EEieAX6!f1Z$;0(GW{z%=S4O^d2gyJO9&C^w=Pd=PLbqzDL9TC$Y
zhjbaRB@~A#VaV+D*owonuWp!U0vV4Z@0r^-kyKUe;!0!)k;$ftBmZEPBGK8usI|=!
z;iS{e(^7=75;*DQK{)G-*d@nFH&LV|Y0=3p!8qw>(sWT1#?s=*G1Q<9cVak7j^>fm
zCP|1R&tMh#k>tT)1!{^%5{A=E0%!-EpPCVblo5r~b?;p)ko)^PWw9j*izqo|bNfaI
gbm-6_Q~VcT0IFs7iTcdBRsaA107*qoM6N<$f~@G$Z~y=R

literal 0
HcmV?d00001

diff --git a/res/drawable-mdpi/ic_launcher.png b/res/drawable-mdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..b71eea187be9bdebc6e6ab9a6dff26bfaad6a14c
GIT binary patch
literal 670
zcmV;P0%84$P)<h;3K|Lk000e1NJLTq001xm001xu1^@s6R|5Hm0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU!KuJVFRCwC#nLSR!Fcin1oitqlRRR{K
ziW9)Xz|<>r0*OzRBXEu$0VK-A)GKs>vT*`XXQm2@5RH>yrwvJ)runcPHz<~(Hm>db
z{?G6E*(pF-)D{%iKzkU~=tq}cjhxwf^lDm1Yr|!YaDstUz{B*J-MB_L;XtZNgL*)n
zSAfz&U1(5f0U}(e6i^EI&jNJb0WRt~wD%3DRZyyaL(_rlmoeN8h}s#rIjE+FXNC1?
z?->BLRa_UU8B{nK12}fUW58r0oB|7A9!Ro@(1ooA_wVtWUF6@B)2+EW3U8ToAY)Z#
zAR0chuvlO-p<X}+c&{IGqZA^rOn7p(?Oq|Eg@OWgOoT;L2#ByWTkDCL3_j>iHpx>!
zjN32~3$3~U-s@}IieeySWi+W{R*iEFlrF35^5Lg-Zatb<6%iru;%6WVz=QWZ#z`SO
zw;7-hyFFZo^WAFbCvv&-_r3G_4XwuyA@IUyp!M_#owuLJ-+g!_EDnSRag>M|_+@}8
z;{eMD;#Pk&BO*II%6SzE05B0=LJGlS9PX0=UU(3P+^PRHJ#o#$BW}y*w;RQpZ*jr!
zLT7-SY|7h972~x^wp^fGfP1h9g^7&4-{I;%R-DM#%c*SO4qQEdb0@MSe=)_Icz&;+
zXm69C4ZXLHH<0`oaF<F=IDEc|Ow;|NU{3JjS0N@M_;AVaa+Xo85;%d$g_oBHJQ3XR
zDiayfq{Al_(966##X2v1PlSLbp9qZyz6oVn@$xIc0GigDN@sN8{{R3007*qoM6N<$
Ef=j_FBme*a

literal 0
HcmV?d00001

diff --git a/res/drawable-xhdpi/ic_launcher.png b/res/drawable-xhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..37fbfc1af3e54caa657744f69d0a3672557ee2af
GIT binary patch
literal 1193
zcmV;a1XlZrP)<h;3K|Lk000e1NJLTq003YB003YJ1^@s6;+S_h0000PbVXQnQ*UN;
zcVTj606}DLVr3vnZDD6+Qe|Oed2z{QJOBU$OG!jQRCwC#oxg9>Koo%Q&TcCNl_CKP
zEP;`!kvg$uVI>j+NI-@1FLb9WJO2Wz!o(Ifn3zfz1X&mh8GwN)qAewf6LXh1#Vv8_
zALqMwckfAVTE+F%-{*JdcXnJtFfcGMFkB5PYeU|v!zzE-;!A@s6-#;b_|oRf_UQhl
zE*JqE{u+OIXEFGBBI;a1N4tRN$p7RJ{J4Z#(M(_x{*WyP;ge{ew~B5=hJc2{V`u|{
zfQrKcDi8!<pa2wrfdWtf1`0p{7$^V*V4wgLfPn(c2p_^9QN2jX^R*Rn_qwN~y;e6M
z&pr=G_b9{+5b!_Txu6Wbh>fa0X;ZZAyZ~|JSC-U+5N$raB|3o6Z2>Be{QolH#xfzp
zfmR7P2!~@rf&mK98e@GDP{4_VkroLk;B0p!M4$i-L8CLV(NL)b6cC3$3xyJVXe|7f
zKhqG)2bM?h=*qe4OeF;TJ(m2wyBUxle#QY|Iw*%B3Q!MUodkyPQ?x0@1h)lfgg;4y
zu(TS1IR!tppgHSJB*@PM-&FX)<Ey84WakI}vRn@Qc%dfFjy&Im49M7>2rx<Agbeuc
zDGSk--2!s<<@4rqWWt|qPh^5v>=cj_{tWa)!mvE}@r;uo!OW?Mg<xsMZlb^-FQF@9
z*1?Z=6SDg15~m}WmGI-;QBesv7nJcl|I~VPdbKOB1X}*h0?cao@$>g_P)?h67h)N9
zG70|dTagK51PVU<49K;UG~on?rkmAN2p_fp+3;n7l{_x^P~pG0y-GH2uB85z;K{Yb
z_geeMq`CVG9DJA=5bb31{Q+rx=@;JIY4{WreDGsHQ3<KwV<A?Kg!J&k#e*{zV%a4m
z!e0b)o&+q!{()%j9j20y9e#mvLBa#am<jMtGT|HvxsLpK>nMV6WFeL$Ar*YaK*2Y*
z5IZZuRQR9^v2zDzE@3)&j`PFU(C5P!kl`|7bMGj26Kxv!6cl`O&Vm-fU>^U`GZH@B
zE+{Ju0eT!2RaxNYZO`2dSO9~?ZY58GpSiFqzYqhL0l~w|@MYr|00cgzD8OX+C_poO
z6rdSC3eXH61!#s3Lcr_qBYkau8)}6QLcnIHPkKZ3kBjLILbCbsk5>2~1c=9mt-n1^
ze>6&n*4F`9e{;y&9&3dUrV{S{4#~aUJ}-k0iouXMv8L!&6*z;i*qNjczgY?&-dT{C
zT0SemV)!smL*o)GhYz<75E7VYJ$%@On8<=f*K#d@55E#-{`8qWmcln<DnevJS+|a8
zhHr*|iG-y&p8+!;zBvMBnP3@wvjhmZ%m)VFwM&vTNrIX1%@c4U!LtIsECD_B5?CZb
zJNzC50c|~*z~tR@oBzmfLlCg7B@1Q}DANVM7wx-V0nz_duWOUQSpI6c82tL^!D<)8
zAj~Cn_)Cp1J6c3Amc3fe-{*^cta11qf`Ng7fq_vV{t7SvX+$xd*_nYC00000NkvXX
Hu0mjfFB%qZ

literal 0
HcmV?d00001

diff --git a/res/drawable-xxhdpi/ic_launcher.png b/res/drawable-xxhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..73fb73104a0651703e73b7fb6d08aacd2afb6061
GIT binary patch
literal 1618
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
Q<^TWy07*qoM6N<$f}J1hv;Y7A

literal 0
HcmV?d00001

diff --git a/res/drawable-xxxhdpi/ic_launcher.png b/res/drawable-xxxhdpi/ic_launcher.png
new file mode 100644
index 0000000000000000000000000000000000000000..80acfa7d7d907ba3ed466791c4b7cd5e12a8c2d9
GIT binary patch
literal 2190
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
St(=w>tEc+`x9UBiIe!8E-RRB$

literal 0
HcmV?d00001

diff --git a/res/drawable/ic_system_update.xml b/res/drawable/ic_system_update.xml
new file mode 100644
index 00000000..321b0c8d
--- /dev/null
+++ b/res/drawable/ic_system_update.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+
+    <path
+        android:fillColor="@android:color/white"
+        android:pathData="M17 1.01L7 1c-1.1 0-2 .9-2 2v18c0 1.1.9 2 2 2h10c1.1 0 2-.9 2-2V3c0-1.1-.9-1.99-2-1.99zM17 19H7V5h10v14zm-1-6h-3V8h-2v5H8l4 4 4-4z" />
+</vector>
diff --git a/res/layout/activity_updates.xml b/res/layout/activity_updates.xml
new file mode 100644
index 00000000..23e0f0d6
--- /dev/null
+++ b/res/layout/activity_updates.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/main_container"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <android.support.v7.widget.RecyclerView
+        android:id="@+id/recycler_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:scrollbars="vertical" />
+</FrameLayout>
diff --git a/res/layout/fragment_updates_list.xml b/res/layout/fragment_updates_list.xml
new file mode 100644
index 00000000..3641b617
--- /dev/null
+++ b/res/layout/fragment_updates_list.xml
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <android.support.v7.widget.RecyclerView
+        android:id="@+id/recycler_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:scrollbars="vertical" />
+
+</FrameLayout>
diff --git a/res/layout/update_item_view.xml b/res/layout/update_item_view.xml
new file mode 100644
index 00000000..b6de496d
--- /dev/null
+++ b/res/layout/update_item_view.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical">
+
+    <Button
+        android:id="@+id/button1"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content" />
+
+    <Button
+        android:id="@+id/button2"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/download_button" />
+
+    <TextView
+        android:id="@+id/name"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/cancel_button" />
+
+    <ProgressBar
+        android:id="@+id/progress_bar"
+        style="@style/Widget.AppCompat.ProgressBar.Horizontal"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+</LinearLayout>
diff --git a/res/values/config.xml b/res/values/config.xml
new file mode 100644
index 00000000..bf2857a4
--- /dev/null
+++ b/res/values/config.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <bool name="download_in_cache">false</bool>
+</resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
new file mode 100644
index 00000000..c04764ed
--- /dev/null
+++ b/res/values/strings.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2017 The LineageOS 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.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="app_name">Updater</string>
+    <string name="display_name">Updater</string>
+
+    <string name="download_path_cache" translatable="false">/cache/ota_package/</string>
+    <string name="download_path_data" translatable="false">/data/ota_package/</string>
+    <string name="conf_update_server_url_def" translatable="false">https://download.lineageos.org/api</string>
+
+    <string name="verification_failed_notification">Verification failed</string>
+    <string name="verifying_download_notification">Verifying download</string>
+    <string name="downloading_notification">Downloading</string>
+    <string name="download_paused_notification">Download paused</string>
+    <string name="download_paused_error_notification">Download error</string>
+    <string name="download_completed_notification">Download completed</string>
+    <string name="download_starting_notification">Starting download</string>
+
+    <string name="download_button">Download</string>
+    <string name="pause_button">Pause</string>
+    <string name="resume_button">Resume</string>
+    <string name="cancel_button">Delete</string>
+    <string name="install_button">Install</string>
+</resources>
diff --git a/src/org/lineageos/updater/DownloadClient.java b/src/org/lineageos/updater/DownloadClient.java
new file mode 100644
index 00000000..bad5e158
--- /dev/null
+++ b/src/org/lineageos/updater/DownloadClient.java
@@ -0,0 +1,287 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import android.os.AsyncTask;
+import android.os.SystemClock;
+import android.util.Log;
+
+import com.android.okhttp.Callback;
+import com.android.okhttp.Interceptor;
+import com.android.okhttp.MediaType;
+import com.android.okhttp.OkHttpClient;
+import com.android.okhttp.Response;
+import com.android.okhttp.ResponseBody;
+import com.android.okhttp.Request;
+import com.android.okhttp.okio.BufferedSink;
+import com.android.okhttp.okio.BufferedSource;
+import com.android.okhttp.okio.Buffer;
+import com.android.okhttp.okio.ForwardingSource;
+import com.android.okhttp.okio.Okio;
+import com.android.okhttp.okio.Source;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+public class DownloadClient {
+
+    private static final String TAG = "DownloadClient";
+
+    private static final Object DOWNLOAD_TAG = new Object();
+
+    public interface DownloadCallback {
+        void onResponse(int statusCode, String url, Headers headers);
+        void onSuccess(String body);
+        void onFailure();
+    }
+
+    public interface ProgressListener {
+        void update(long bytesRead, long contentLength, long speed, long eta, boolean done);
+    }
+
+    public class Headers {
+        private com.android.okhttp.Headers mHeaders;
+
+        private Headers(com.android.okhttp.Headers headers) {
+            mHeaders = headers;
+        }
+
+        public String get(String name) {
+            return mHeaders.get(name);
+        }
+
+        public Map<String, List<String>> getAll() {
+            return mHeaders.toMultimap();
+        }
+    }
+
+    private final OkHttpClient mClient = new OkHttpClient();
+
+    private long mResumeOffset = 0;
+
+    private DownloadClient() { }
+
+    public static void download(String url, DownloadCallback callback) {
+        DownloadClient downloadClient = new DownloadClient();
+        downloadClient.downloadInternal(url, callback);
+    }
+
+    public static DownloadClient downloadFile(String url, File destination,
+            DownloadCallback callback, ProgressListener progressListener) {
+        DownloadClient downloadClient = new DownloadClient();
+        downloadClient.downloadFileInternal(url, destination, callback, progressListener);
+        return downloadClient;
+    }
+
+    public static DownloadClient downloadFile(String url, File destination,
+            DownloadCallback callback) {
+        return downloadFile(url, destination, callback, null);
+    }
+
+    public static DownloadClient downloadFileResume(String url, File destination,
+            DownloadCallback callback, ProgressListener progressListener) {
+        DownloadClient downloadClient = new DownloadClient();
+        downloadClient.downloadFileResumeInternal(url, destination, callback, progressListener);
+        return downloadClient;
+    }
+
+    public void cancel() {
+        new AsyncTask<Void, Void, Void>() {
+            protected Void doInBackground(Void... unused) {
+                mClient.cancel(DOWNLOAD_TAG);
+                return null;
+            }
+        }.execute();
+    }
+
+    private void downloadInternal(String url, final DownloadCallback callback) {
+        final Request request = new Request.Builder()
+                .url(url)
+                .build();
+
+        mClient.newCall(request).enqueue(new Callback() {
+            @Override
+            public void onFailure(Request request, IOException e) {
+                Log.d(TAG, "Download failed", e);
+                callback.onFailure();
+            }
+
+            @Override
+            public void onResponse(Response response) {
+                try {
+                    callback.onResponse(response.code(), response.request().urlString(),
+                            new Headers(response.headers()));
+                    callback.onSuccess(response.body().string());
+                } catch (IOException e) {
+                    onFailure(request, e);
+                }
+            }
+        });
+    }
+
+    private void downloadFileInternal(String url, final File destination,
+            final DownloadCallback callback, final ProgressListener progressListener) {
+        final Request request = new Request.Builder()
+                .url(url)
+                .tag(DOWNLOAD_TAG)
+                .build();
+        downloadFileInternalCommon(request, destination, callback, progressListener);
+    }
+
+    private void downloadFileResumeInternal(String url, final File destination,
+            final DownloadCallback callback, final ProgressListener progressListener) {
+        final Request.Builder requestBuilder = new Request.Builder()
+                .url(url)
+                .tag(DOWNLOAD_TAG);
+        long offset = destination.length();
+        requestBuilder.addHeader("Range", "bytes=" + offset + "-");
+        final Request request = requestBuilder.build();
+        downloadFileInternalCommon(request, destination, callback, progressListener);
+    }
+
+    private void downloadFileInternalCommon(final Request request, final File destination,
+            final DownloadCallback callback, final ProgressListener progressListener) {
+
+        mClient.networkInterceptors().add(new Interceptor() {
+            @Override
+            public Response intercept(Chain chain) throws IOException {
+                Response originalResponse = chain.proceed(chain.request());
+                ProgressResponseBody progressResponseBody =
+                        new ProgressResponseBody(originalResponse.body(), progressListener);
+                return originalResponse.newBuilder()
+                        .body(progressResponseBody)
+                        .build();
+            }
+        });
+
+        mClient.newCall(request).enqueue(new Callback() {
+
+            @Override
+            public void onFailure(Request request, IOException e) {
+                Log.d(TAG, "Download failed", e);
+                callback.onFailure();
+            }
+
+            @Override
+            public void onResponse(Response response) {
+                Log.d(TAG, "Downloading");
+
+                final boolean resume = response.code() == 206;
+                if (resume) {
+                    mResumeOffset = destination.length();
+                    Log.d(TAG, "The server fulfilled the partial content request");
+                }
+
+                callback.onResponse(response.code(), response.request().urlString(),
+                        new Headers(response.headers()));
+                try (BufferedSink sink = Okio.buffer(resume ?
+                        Okio.appendingSink(destination) : Okio.sink(destination))) {
+                    sink.writeAll(response.body().source());
+                    Log.d(TAG, "Download complete");
+                    sink.flush();
+                    callback.onSuccess(null);
+                } catch (IOException e) {
+                    onFailure(request, e);
+                }
+            }
+        });
+    }
+
+    private class ProgressResponseBody extends ResponseBody {
+
+        private final ResponseBody mResponseBody;
+        private final ProgressListener mProgressListener;
+        private BufferedSource mBufferedSource;
+
+        ProgressResponseBody(ResponseBody responseBody, ProgressListener progressListener) {
+            mResponseBody = responseBody;
+            mProgressListener = progressListener;
+        }
+
+        @Override
+        public MediaType contentType() {
+            return mResponseBody.contentType();
+        }
+
+        @Override
+        public long contentLength() throws IOException {
+            return mResponseBody.contentLength();
+        }
+
+        @Override
+        public BufferedSource source() throws IOException {
+            if (mBufferedSource == null) {
+                mBufferedSource = Okio.buffer(source(mResponseBody.source()));
+            }
+            return mBufferedSource;
+        }
+
+        private Source source(Source source) {
+            return new ForwardingSource(source) {
+                private long mTotalBytes = 0;
+                private long mTotalBytesRead = mResumeOffset;
+
+                private long mCurSampleBytes = 0;
+                private long mLastMillis = 0;
+                private long mSpeed = -1;
+                private long mEta = -1;
+
+                private void calculateSpeed() {
+                    final long millis = SystemClock.elapsedRealtime();
+                    final long delta = millis - mLastMillis;
+                    if (delta > 500) {
+                        final long curSpeed = ((mTotalBytesRead - mCurSampleBytes) * 1000) / delta;
+                        if (mSpeed == -1) {
+                            mSpeed = curSpeed;
+                        } else {
+                            mSpeed = ((mSpeed * 3) + curSpeed) / 4;
+                        }
+
+                        mLastMillis = millis;
+                        mCurSampleBytes = mTotalBytesRead;
+                    }
+                }
+
+                private void calculateEta() {
+                    if (mSpeed > 0) {
+                        mEta = (mTotalBytes - mTotalBytesRead) / mSpeed;
+                    }
+                }
+
+                @Override
+                public long read(Buffer sink, long byteCount) throws IOException {
+                    long bytesRead = super.read(sink, byteCount);
+
+                    mTotalBytes = mResponseBody.contentLength() + mResumeOffset;
+                    // read() returns the number of bytes read, or -1 if this source is exhausted.
+                    mTotalBytesRead += bytesRead != -1 ? bytesRead : 0;
+
+                    calculateSpeed();
+                    calculateEta();
+
+                    if (mProgressListener != null) {
+                        mProgressListener.update(mTotalBytesRead, mTotalBytes,
+                                mSpeed, mEta, bytesRead == -1);
+                    }
+
+                    return bytesRead;
+                }
+            };
+        }
+    }
+}
diff --git a/src/org/lineageos/updater/DownloadController.java b/src/org/lineageos/updater/DownloadController.java
new file mode 100644
index 00000000..b43a965e
--- /dev/null
+++ b/src/org/lineageos/updater/DownloadController.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.PowerManager;
+import android.os.SystemClock;
+import android.support.v4.content.LocalBroadcastManager;
+import android.util.Log;
+
+import org.lineageos.updater.misc.Utils;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class DownloadController implements DownloadControllerInt {
+
+    public static final String PROGRESS_ACTION = "progress_action";
+    public static final String UPDATE_STATUS_ACTION = "update_status_change_action";
+    public static final String DOWNLOAD_ID_EXTRA = "download_id_extra";
+
+    private final String TAG = "DownloadController";
+
+    private static DownloadController sDownloadController;
+
+    private static final int MAX_REPORT_INTERVAL_MS = 1000;
+
+    private final LocalBroadcastManager mBroadcastManager;
+    private final UpdatesDbHelper mUpdatesDbHelper;
+
+    private final PowerManager.WakeLock mWakeLock;
+
+    private final File mDownloadRoot;
+
+    public static DownloadController getInstance() {
+        return sDownloadController;
+    }
+
+    public static synchronized DownloadController newInstance(Context context) {
+        if (sDownloadController == null) {
+            sDownloadController = new DownloadController(context);
+        }
+        return sDownloadController;
+    }
+
+    private DownloadController(Context context) {
+        mBroadcastManager = LocalBroadcastManager.getInstance(context);
+        mUpdatesDbHelper = new UpdatesDbHelper(context);
+        mDownloadRoot = Utils.getDownloadPath(context);
+        PowerManager powerManager = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
+        mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Updater");
+        mWakeLock.setReferenceCounted(false);
+    }
+
+    private class DownloadEntry {
+        final UpdateDownload mUpdate;
+        DownloadClient mDownloadClient;
+        private DownloadEntry(UpdateDownload update) {
+            mUpdate = update;
+        }
+    }
+
+    private Map<String, DownloadEntry> mDownloads = new HashMap<>();
+
+    private void notifyUpdateChange(String downloadId) {
+        Intent intent = new Intent();
+        intent.setAction(UPDATE_STATUS_ACTION);
+        intent.putExtra(DOWNLOAD_ID_EXTRA, downloadId);
+        mBroadcastManager.sendBroadcast(intent);
+    }
+
+    private void notifyDownloadProgress(String downloadId) {
+        Intent intent = new Intent();
+        intent.setAction(PROGRESS_ACTION);
+        intent.putExtra(DOWNLOAD_ID_EXTRA, downloadId);
+        mBroadcastManager.sendBroadcast(intent);
+    }
+
+    private void tryReleaseWakelock() {
+        if (!hasActiveDownloads()) {
+            mWakeLock.release();
+        }
+    }
+
+    private DownloadClient.DownloadCallback getDownloadCallback(final String downloadId) {
+        return new DownloadClient.DownloadCallback() {
+
+            @Override
+            public void onResponse(int statusCode, String url, DownloadClient.Headers headers) {
+                UpdateDownload update = mDownloads.get(downloadId).mUpdate;
+                String contentLenght = headers.get("Content-Length");
+                if (contentLenght != null) {
+                    try {
+                        long size = Long.parseLong(contentLenght);
+                        update.setFileSize(size);
+                    } catch (NumberFormatException e) {
+                        Log.e(TAG, "Could not get content-length");
+                    }
+                }
+                update.setStatus(UpdateStatus.DOWNLOADING);
+                update.setPersistentStatus(UpdateStatus.Persistent.INCOMPLETE);
+                mUpdatesDbHelper.addUpdateWithOnConflict(update);
+                notifyUpdateChange(downloadId);
+            }
+
+            @Override
+            public void onSuccess(String body) {
+                UpdateDownload update = mDownloads.get(downloadId).mUpdate;
+                update.setStatus(UpdateStatus.VERIFYING);
+                notifyUpdateChange(downloadId);
+                Log.d(TAG, "Download complete");
+                if (!verifyDownload(update.getFile())) {
+                    update.setPersistentStatus(UpdateStatus.Persistent.UNKNOWN);
+                    mUpdatesDbHelper.removeUpdate(downloadId);
+                    update.setProgress(0);
+                    update.setStatus(UpdateStatus.VERIFICATION_FAILED);
+                } else {
+                    update.setPersistentStatus(UpdateStatus.Persistent.VERIFIED);
+                    mUpdatesDbHelper.changeUpdateStatus(update);
+                    update.setStatus(UpdateStatus.VERIFIED);
+                }
+                mDownloads.get(downloadId).mDownloadClient = null;
+                notifyUpdateChange(downloadId);
+                tryReleaseWakelock();
+            }
+
+            @Override
+            public void onFailure() {
+                // The client is null if we intentionally stopped the download
+                boolean cancelled = mDownloads.get(downloadId).mDownloadClient == null;
+                UpdateDownload update = mDownloads.get(downloadId).mUpdate;
+                if (cancelled) {
+                    Log.d(TAG, "Download cancelled");
+                    update.setStatus(UpdateStatus.PAUSED);
+                    // Already notified
+                } else {
+                    Log.e(TAG, "Download failed");
+                    mDownloads.get(downloadId).mDownloadClient = null;
+                    update.setStatus(UpdateStatus.PAUSED_ERROR);
+                    notifyUpdateChange(downloadId);
+                }
+                tryReleaseWakelock();
+            }
+        };
+    }
+
+    private DownloadClient.ProgressListener getProgressListener(final String downloadId) {
+        return new DownloadClient.ProgressListener() {
+            private long mLastUpdate = 0;
+            private int mProgress = 0;
+
+            @Override
+            public void update(long bytesRead, long contentLength, long speed, long eta,
+                    boolean done) {
+                final long now = SystemClock.elapsedRealtime();
+                int progress = Math.round(bytesRead * 100 / contentLength);
+                if (progress != mProgress || mLastUpdate - now > MAX_REPORT_INTERVAL_MS) {
+                    mProgress = progress;
+                    mLastUpdate = now;
+                    getUpdate(downloadId).setProgress(progress);
+                    getUpdate(downloadId).setEta(eta);
+                    notifyDownloadProgress(downloadId);
+                }
+            }
+        };
+    }
+
+    private boolean verifyDownload(File file) {
+        try {
+            android.os.RecoverySystem.verifyPackage(file, null, null);
+            Log.e(TAG, "Verification successful");
+            return true;
+        } catch (Exception e) {
+            Log.e(TAG, "Verification failed", e);
+            if (file.exists()) {
+                file.delete();
+            } else {
+                // The download was probably stopped. Exit silently
+                Log.e(TAG, "Error while verifying the file", e);
+            }
+            return false;
+        }
+    }
+
+    private boolean fixUpdateStatus(UpdateDownload update) {
+        switch (update.getPersistentStatus()) {
+            case UpdateStatus.Persistent.VERIFIED:
+            case UpdateStatus.Persistent.INCOMPLETE:
+                if (update.getFile() == null || !update.getFile().exists()) {
+                    update.setStatus(UpdateStatus.UNKNOWN);
+                    return false;
+                } else {
+                    int progress = Math.round(
+                            update.getFile().length() * 100 / update.getFileSize());
+                    update.setProgress(progress);
+                }
+                break;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean addUpdate(UpdateDownload update, boolean local) {
+        Log.d(TAG, "Adding download: " + update.getDownloadId());
+        if (mDownloads.containsKey(update.getDownloadId())) {
+            Log.e(TAG, "Download (" + update.getDownloadId() + ") already added");
+            return false;
+        }
+        if (!fixUpdateStatus(update) && local) {
+            update.setPersistentStatus(UpdateStatus.Persistent.UNKNOWN);
+            mUpdatesDbHelper.removeUpdate(update.getDownloadId());
+            Log.d(TAG, update.getDownloadId() + " had an invalid status and is local");
+            return false;
+        }
+        mDownloads.put(update.getDownloadId(), new DownloadEntry(update));
+        return true;
+    }
+
+    @Override
+    public boolean startDownload(String downloadId) {
+        Log.d(TAG, "Starting " + downloadId);
+        if (!mDownloads.containsKey(downloadId) || isDownloading(downloadId)) {
+            return false;
+        }
+        UpdateDownload update = mDownloads.get(downloadId).mUpdate;
+        File destination = new File(mDownloadRoot, update.getName());
+        update.setFile(destination);
+        mDownloads.get(downloadId).mDownloadClient =
+                DownloadClient.downloadFile(update.getDownloadUrl(),
+                        update.getFile(),
+                        getDownloadCallback(downloadId),
+                        getProgressListener(downloadId));
+        update.setStatus(UpdateStatus.STARTING);
+        notifyUpdateChange(downloadId);
+        mWakeLock.acquire();
+        return true;
+    }
+
+    @Override
+    public boolean resumeDownload(String downloadId) {
+        Log.d(TAG, "Resuming " + downloadId);
+        if (!mDownloads.containsKey(downloadId) || isDownloading(downloadId)) {
+            return false;
+        }
+        UpdateDownload update = mDownloads.get(downloadId).mUpdate;
+        mDownloads.get(downloadId).mDownloadClient =
+                DownloadClient.downloadFileResume(update.getDownloadUrl(),
+                        update.getFile(),
+                        getDownloadCallback(downloadId),
+                        getProgressListener(downloadId));
+        update.setStatus(UpdateStatus.STARTING);
+        notifyUpdateChange(downloadId);
+        mWakeLock.acquire();
+        return true;
+    }
+
+    @Override
+    public boolean pauseDownload(String downloadId) {
+        Log.d(TAG, "Pausing " + downloadId);
+        if (!isDownloading(downloadId)) {
+            return false;
+        }
+
+        // First remove the client and then cancel the download so that when the download
+        // fails, we know it was intentional
+        DownloadClient downloadClient = mDownloads.get(downloadId).mDownloadClient;
+        mDownloads.get(downloadId).mDownloadClient = null;
+        downloadClient.cancel();
+        UpdateDownload update = mDownloads.get(downloadId).mUpdate;
+        update.setStatus(UpdateStatus.PAUSED);
+        notifyUpdateChange(downloadId);
+        return true;
+    }
+
+    private void deleteUpdateAsync(final String downloadId) {
+        new AsyncTask<Void, Void, Void>() {
+            protected Void doInBackground(Void... voids) {
+                UpdateDownload update = mDownloads.get(downloadId).mUpdate;
+                File file = update.getFile();
+                if (file.exists() && !file.delete()) {
+                    Log.e(TAG, "Could not delete " + file.getAbsolutePath());
+                }
+                mUpdatesDbHelper.removeUpdate(downloadId);
+                return null;
+            }
+        }.execute();
+    }
+
+    @Override
+    public boolean cancelDownload(String downloadId) {
+        Log.d(TAG, "Cancelling " + downloadId);
+        if (!mDownloads.containsKey(downloadId) || isDownloading(downloadId)) {
+            return false;
+        }
+        UpdateDownload update = mDownloads.get(downloadId).mUpdate;
+        update.setStatus(UpdateStatus.DELETED);
+        update.setProgress(0);
+        update.setPersistentStatus(UpdateStatus.Persistent.UNKNOWN);
+        deleteUpdateAsync(downloadId);
+        notifyUpdateChange(downloadId);
+        return true;
+    }
+
+    @Override
+    public Set<String> getIds() {
+        return mDownloads.keySet();
+    }
+
+    @Override
+    public List<UpdateDownload> getUpdates() {
+        List<UpdateDownload> updates = new ArrayList<>();
+        for (DownloadEntry entry : mDownloads.values()) {
+            updates.add(entry.mUpdate);
+        }
+        return updates;
+    }
+
+    @Override
+    public UpdateDownload getUpdate(String downloadId) {
+        return mDownloads.get(downloadId).mUpdate;
+    }
+
+    @Override
+    public boolean isDownloading(String downloadId) {
+        return mDownloads.containsKey(downloadId) &&
+                mDownloads.get(downloadId).mDownloadClient != null;
+    }
+
+    @Override
+    public boolean hasActiveDownloads() {
+        for (DownloadEntry entry : mDownloads.values()) {
+            if (entry.mDownloadClient != null) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/src/org/lineageos/updater/DownloadControllerInt.java b/src/org/lineageos/updater/DownloadControllerInt.java
new file mode 100644
index 00000000..29b61739
--- /dev/null
+++ b/src/org/lineageos/updater/DownloadControllerInt.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import java.util.List;
+import java.util.Set;
+
+public interface DownloadControllerInt {
+
+    boolean addUpdate(UpdateDownload update, boolean local);
+
+    List<UpdateDownload> getUpdates();
+
+    Set<String> getIds();
+
+    UpdateDownload getUpdate(String downloadId);
+
+    boolean startDownload(String downloadId);
+
+    boolean pauseDownload(String downloadId);
+
+    boolean cancelDownload(String downloadId);
+
+    boolean resumeDownload(String downloadId);
+
+    boolean isDownloading(String downloadId);
+
+    boolean hasActiveDownloads();
+}
diff --git a/src/org/lineageos/updater/DownloadService.java b/src/org/lineageos/updater/DownloadService.java
new file mode 100644
index 00000000..13e97d21
--- /dev/null
+++ b/src/org/lineageos/updater/DownloadService.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Binder;
+import android.os.IBinder;
+import android.support.v4.content.LocalBroadcastManager;
+import android.support.v7.app.NotificationCompat;
+import android.util.Log;
+
+public class DownloadService extends Service {
+
+    private static final String TAG = "DownloadService";
+
+    private static final int NOTIFICATION_ID = 10;
+
+    private final IBinder mBinder = new LocalBinder();
+    private boolean mHasClients;
+
+    private BroadcastReceiver mBroadcastReceiver;
+    private NotificationCompat.Builder mNotificationBuilder;
+    private NotificationManager mNotificationManager;
+
+    private DownloadControllerInt mDownloadController;
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+
+        mDownloadController = DownloadController.newInstance(this);
+
+        mNotificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+        mNotificationBuilder = new NotificationCompat.Builder(this);
+        mNotificationBuilder.setSmallIcon(R.drawable.ic_system_update);
+        mNotificationBuilder.setShowWhen(false);
+
+        Intent notificationIntent = new Intent(this, UpdatesActivity.class);
+        PendingIntent intent = PendingIntent.getActivity(this, 0, notificationIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT);
+        mNotificationBuilder.setContentIntent(intent);
+
+        mBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                String downloadId = intent.getStringExtra(DownloadController.DOWNLOAD_ID_EXTRA);
+                if (DownloadController.UPDATE_STATUS_ACTION.equals(intent.getAction())) {
+                    UpdateDownload update = mDownloadController.getUpdate(downloadId);
+                    handleDownloadStatusChange(update);
+                } else if (DownloadController.PROGRESS_ACTION.equals(intent.getAction())) {
+                    UpdateDownload update = mDownloadController.getUpdate(downloadId);
+                    int progress = update.getProgress();
+                    mNotificationBuilder.setProgress(100, progress, false);
+                    mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                }
+            }
+        };
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(DownloadController.PROGRESS_ACTION);
+        intentFilter.addAction(DownloadController.UPDATE_STATUS_ACTION);
+        LocalBroadcastManager.getInstance(this).registerReceiver(mBroadcastReceiver, intentFilter);
+
+    }
+
+    @Override
+    public void onDestroy() {
+        LocalBroadcastManager.getInstance(this).unregisterReceiver(mBroadcastReceiver);
+        super.onDestroy();
+    }
+
+    public class LocalBinder extends Binder {
+        public DownloadService getService() {
+            return DownloadService.this;
+        }
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        mHasClients = true;
+        return mBinder;
+    }
+
+    @Override
+    public boolean onUnbind(Intent intent) {
+        mHasClients = false;
+        tryStopSelf();
+        return false;
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (intent == null) {
+            Log.d(TAG, "The service is being restarted, exit");
+            // The service is being restarted, exit without doing anything
+            stopForeground(STOP_FOREGROUND_DETACH);
+            mNotificationBuilder.setOngoing(false);
+            mNotificationManager.cancel(NOTIFICATION_ID);
+            stopSelf();
+        }
+        Log.d(TAG, "Service started");
+        return START_STICKY;
+    }
+
+    public DownloadControllerInt getDownloadController() {
+        return mDownloadController;
+    }
+
+    private void tryStopSelf() {
+        if (!mHasClients && !mDownloadController.hasActiveDownloads()) {
+            Log.d(TAG, "Service no longer needed, stopping");
+            stopSelf();
+        }
+    }
+
+    private void handleDownloadStatusChange(UpdateDownload update) {
+        switch (update.getStatus()) {
+            case DELETED: {
+                stopForeground(STOP_FOREGROUND_DETACH);
+                mNotificationBuilder.setOngoing(false);
+                mNotificationManager.cancel(NOTIFICATION_ID);
+                tryStopSelf();
+                break;
+            }
+            case STARTING: {
+                mNotificationBuilder.mActions.clear();
+                mNotificationBuilder.setProgress(0, 0, true);
+                String text = getString(R.string.download_starting_notification);
+                NotificationCompat.BigTextStyle style = new NotificationCompat.BigTextStyle()
+                        .setBigContentTitle(text).bigText(update.getName());
+                mNotificationBuilder.setStyle(style);
+                mNotificationBuilder.setContentTitle(text);
+                mNotificationBuilder.setTicker(text);
+                mNotificationBuilder.setOngoing(true);
+                startForeground(NOTIFICATION_ID, mNotificationBuilder.build());
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                break;
+            }
+            case DOWNLOADING: {
+                String text = getString(R.string.downloading_notification);
+                NotificationCompat.BigTextStyle style = new NotificationCompat.BigTextStyle()
+                        .setBigContentTitle(text).bigText(update.getName());
+                mNotificationBuilder.addAction(com.android.internal.R.drawable.ic_media_pause,
+                        getString(R.string.pause_button),
+                        getPausePendingIntent(update.getDownloadId()));
+                mNotificationBuilder.setStyle(style);
+                mNotificationBuilder.setContentTitle(text);
+                mNotificationBuilder.setTicker(text);
+                mNotificationBuilder.setOngoing(true);
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                break;
+            }
+            case PAUSED: {
+                stopForeground(STOP_FOREGROUND_DETACH);
+                mNotificationBuilder.mActions.clear();
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                String text = getString(R.string.download_paused_notification);
+                NotificationCompat.BigTextStyle style = new NotificationCompat.BigTextStyle()
+                        .setBigContentTitle(text).bigText(update.getName());
+                mNotificationBuilder.addAction(com.android.internal.R.drawable.ic_media_play,
+                        getString(R.string.resume_button),
+                        getResumePendingIntent(update.getDownloadId()));
+                mNotificationBuilder.setStyle(style);
+                mNotificationBuilder.setContentTitle(text);
+                mNotificationBuilder.setTicker(text);
+                mNotificationBuilder.setOngoing(false);
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                break;
+            }
+            case PAUSED_ERROR: {
+                stopForeground(STOP_FOREGROUND_DETACH);
+                mNotificationBuilder.mActions.clear();
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                String text = getString(R.string.download_paused_error_notification);
+                NotificationCompat.BigTextStyle style = new NotificationCompat.BigTextStyle()
+                        .setBigContentTitle(text).bigText(update.getName());
+                mNotificationBuilder.addAction(com.android.internal.R.drawable.ic_media_play,
+                        getString(R.string.resume_button),
+                        getResumePendingIntent(update.getDownloadId()));
+                mNotificationBuilder.setStyle(style);
+                mNotificationBuilder.setContentTitle(text);
+                mNotificationBuilder.setTicker(text);
+                mNotificationBuilder.setOngoing(false);
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                break;
+            }
+            case VERIFYING: {
+                mNotificationBuilder.setProgress(0, 0, true);
+                mNotificationBuilder.mActions.clear();
+                String text = getString(R.string.verifying_download_notification);
+                NotificationCompat.BigTextStyle style = new NotificationCompat.BigTextStyle()
+                        .setBigContentTitle(text).bigText(update.getName());
+                mNotificationBuilder.setStyle(style);
+                mNotificationBuilder.setContentTitle(text);
+                mNotificationBuilder.setTicker(text);
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                break;
+            }
+            case VERIFIED: {
+                stopForeground(STOP_FOREGROUND_DETACH);
+                mNotificationBuilder.setProgress(100, 100, false);
+                String text = getString(R.string.download_completed_notification);
+                NotificationCompat.BigTextStyle style = new NotificationCompat.BigTextStyle()
+                        .setBigContentTitle(text).bigText(update.getName());
+                mNotificationBuilder.setStyle(style);
+                mNotificationBuilder.setContentTitle(text);
+                mNotificationBuilder.setTicker(text);
+                mNotificationBuilder.setOngoing(false);
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                tryStopSelf();
+                break;
+            }
+            case VERIFICATION_FAILED: {
+                stopForeground(STOP_FOREGROUND_DETACH);
+                String text = getString(R.string.verification_failed_notification);
+                NotificationCompat.BigTextStyle style = new NotificationCompat.BigTextStyle()
+                        .setBigContentTitle(text).bigText(update.getName());
+                mNotificationBuilder.setStyle(style);
+                mNotificationBuilder.setContentTitle(text);
+                mNotificationBuilder.setTicker(text);
+                mNotificationBuilder.setOngoing(false);
+                mNotificationManager.notify(NOTIFICATION_ID, mNotificationBuilder.build());
+                tryStopSelf();
+                break;
+            }
+        }
+    }
+
+    private PendingIntent getResumePendingIntent(String downloadId) {
+        final Intent intent = new Intent(this, UpdaterBroadcastReceiver.class);
+        intent.setAction(UpdaterBroadcastReceiver.ACTION_DOWNLOAD);
+        intent.putExtra(UpdaterBroadcastReceiver.EXTRA_DOWNLOAD_ID, downloadId);
+        intent.putExtra(UpdaterBroadcastReceiver.EXTRA_DOWNLOAD_ACTION,
+                UpdaterBroadcastReceiver.RESUME);
+        return PendingIntent.getBroadcast(this, 0, intent,
+                PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_UPDATE_CURRENT);
+    }
+
+    private PendingIntent getPausePendingIntent(String downloadId) {
+        final Intent intent = new Intent(this, UpdaterBroadcastReceiver.class);
+        intent.setAction(UpdaterBroadcastReceiver.ACTION_DOWNLOAD);
+        intent.putExtra(UpdaterBroadcastReceiver.EXTRA_DOWNLOAD_ID, downloadId);
+        intent.putExtra(UpdaterBroadcastReceiver.EXTRA_DOWNLOAD_ACTION,
+                UpdaterBroadcastReceiver.PAUSE);
+        return PendingIntent.getBroadcast(this, 0, intent,
+                PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_UPDATE_CURRENT);
+    }
+}
diff --git a/src/org/lineageos/updater/Update.java b/src/org/lineageos/updater/Update.java
new file mode 100644
index 00000000..0cd10b33
--- /dev/null
+++ b/src/org/lineageos/updater/Update.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+public class Update implements Comparable<Update> {
+
+    private String mName;
+    private String mDownloadUrl;
+    private String mDownloadId;
+    private long mTimestamp;
+    private String mType;
+    private String mVersion;
+
+    public Update() {
+    }
+
+    public String getName() {
+        return mName;
+    }
+
+    public void setName(String name) {
+        mName = name;
+    }
+
+    public String getDownloadId() {
+        return mDownloadId;
+    }
+
+    public void setDownloadId(String downloadId) {
+        mDownloadId = downloadId;
+    }
+
+    public long getTimestamp() {
+        return mTimestamp;
+    }
+
+    public void setTimestamp(long timestamp) {
+        mTimestamp = timestamp;
+    }
+
+    public String getType() {
+        return mType;
+    }
+
+    public void setType(String type) {
+        mType = type;
+    }
+
+    public String getVersion() {
+        return mVersion;
+    }
+
+    public void setVersion(String version) {
+        mVersion = version;
+    }
+
+    public String getDownloadUrl() {
+        return mDownloadUrl;
+    }
+
+    public void setDownloadUrl(String downloadUrl) {
+        mDownloadUrl = downloadUrl;
+    }
+
+    @Override
+    public int compareTo(Update u) {
+        return mTimestamp < u.mTimestamp ? -1 : mTimestamp > u.mTimestamp ? 1 : 0;
+    }
+}
diff --git a/src/org/lineageos/updater/UpdateDownload.java b/src/org/lineageos/updater/UpdateDownload.java
new file mode 100644
index 00000000..3c02558b
--- /dev/null
+++ b/src/org/lineageos/updater/UpdateDownload.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import java.io.File;
+
+public class UpdateDownload extends Update {
+
+    private UpdateStatus mStatus = UpdateStatus.UNKNOWN;
+    private int mPersistentStatus = UpdateStatus.Persistent.UNKNOWN;
+    private File mFile;
+    private long mFileSize;
+    private int mProgress;
+    private long mEta;
+
+    public UpdateStatus getStatus() {
+        return mStatus;
+    }
+
+    public void setStatus(UpdateStatus status) {
+        mStatus = status;
+    }
+
+    public int getPersistentStatus() {
+        return mPersistentStatus;
+    }
+
+    public void setPersistentStatus(int status) {
+        mPersistentStatus = status;
+    }
+
+    public File getFile() {
+        return mFile;
+    }
+
+    public void setFile(File file) {
+        mFile = file;
+    }
+
+    public long getFileSize() {
+        return mFileSize;
+    }
+
+    public void setFileSize(long fileSize) {
+        mFileSize = fileSize;
+    }
+
+    public int getProgress() {
+        return mProgress;
+    }
+
+    public void setProgress(int progress) {
+        mProgress = progress;
+    }
+
+    public long getEta() {
+        return mEta;
+    }
+
+    public void setEta(long eta) {
+        mEta = eta;
+    }
+}
diff --git a/src/org/lineageos/updater/UpdateStatus.java b/src/org/lineageos/updater/UpdateStatus.java
new file mode 100644
index 00000000..6ec426f2
--- /dev/null
+++ b/src/org/lineageos/updater/UpdateStatus.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+public enum UpdateStatus {
+    UNKNOWN,
+    STARTING,
+    DOWNLOADING,
+    DOWNLOADED,
+    PAUSED,
+    PAUSED_ERROR,
+    DELETED,
+    VERIFYING,
+    VERIFIED,
+    VERIFICATION_FAILED,
+    INSTALLING,
+    INSTALLED;
+
+    public static final class Persistent {
+        public static final int UNKNOWN = 0;
+        public static final int INCOMPLETE = 1;
+        public static final int VERIFIED = 2;
+    }
+}
\ No newline at end of file
diff --git a/src/org/lineageos/updater/UpdaterBroadcastReceiver.java b/src/org/lineageos/updater/UpdaterBroadcastReceiver.java
new file mode 100644
index 00000000..cb785113
--- /dev/null
+++ b/src/org/lineageos/updater/UpdaterBroadcastReceiver.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+public class UpdaterBroadcastReceiver extends BroadcastReceiver {
+
+    public static final String ACTION_DOWNLOAD =
+            "org.lineageos.updater.action.DOWNLOAD";
+    public static final String EXTRA_DOWNLOAD_ID =
+            "org.lineageos.updater.extra.DOWNLOAD_ID";
+    public static final String EXTRA_DOWNLOAD_ACTION =
+            "org.lineageos.updater.extra.DOWNLOAD_CHANGE";
+
+    public static final int PAUSE = 0;
+    public static final int RESUME = 1;
+
+    private final static String TAG = "BroadcastReceiver";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        final String action = intent.getAction();
+        if (ACTION_DOWNLOAD.equals(action)) {
+            if (intent.hasExtra(EXTRA_DOWNLOAD_ACTION) && intent.hasExtra(EXTRA_DOWNLOAD_ID)) {
+                DownloadController downloadController = DownloadController.getInstance();
+                if (downloadController == null) {
+                    Log.e(TAG, "No download controller instance found");
+                    return;
+                }
+                String downloadId = intent.getStringExtra(EXTRA_DOWNLOAD_ID);
+                int requestedAction = intent.getIntExtra(EXTRA_DOWNLOAD_ACTION, -1);
+                if (requestedAction == PAUSE) {
+                    downloadController.pauseDownload(downloadId);
+                } else if (requestedAction == RESUME) {
+                    downloadController.resumeDownload(downloadId);
+                } else {
+                    Log.e(TAG, "Unknown action");
+                }
+            } else {
+                Log.e(TAG, "Missing extra data");
+            }
+        }
+    }
+}
diff --git a/src/org/lineageos/updater/UpdatesActivity.java b/src/org/lineageos/updater/UpdatesActivity.java
new file mode 100644
index 00000000..5deb3e40
--- /dev/null
+++ b/src/org/lineageos/updater/UpdatesActivity.java
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.ServiceConnection;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.support.v4.content.LocalBroadcastManager;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.support.v7.widget.SimpleItemAnimator;
+import android.util.Log;
+
+import org.json.JSONException;
+import org.lineageos.updater.misc.Utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class UpdatesActivity extends AppCompatActivity {
+
+    private static final String TAG = "UpdatesActivity";
+    private DownloadService mDownloadService;
+    private BroadcastReceiver mBroadcastReceiver;
+
+    private UpdatesListAdapter mAdapter;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_updates);
+
+        RecyclerView recyclerView = (RecyclerView) findViewById(R.id.recycler_view);
+        mAdapter = new UpdatesListAdapter(this);
+        recyclerView.setAdapter(mAdapter);
+        RecyclerView.LayoutManager layoutManager = new LinearLayoutManager(this);
+        recyclerView.setLayoutManager(layoutManager);
+        RecyclerView.ItemAnimator animator = recyclerView.getItemAnimator();
+        if (animator instanceof SimpleItemAnimator) {
+            ((SimpleItemAnimator) animator).setSupportsChangeAnimations(false);
+        }
+
+        mBroadcastReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                if (DownloadController.UPDATE_STATUS_ACTION.equals(intent.getAction())) {
+                    mAdapter.notifyDataSetChanged();
+                } else if (DownloadController.PROGRESS_ACTION.equals(intent.getAction())) {
+                    String downloadId = intent.getStringExtra(DownloadController.DOWNLOAD_ID_EXTRA);
+                    mAdapter.notifyItemChanged(downloadId);
+                }
+            }
+        };
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        Intent intent = new Intent(this, DownloadService.class);
+        startService(intent);
+        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
+
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(DownloadController.UPDATE_STATUS_ACTION);
+        intentFilter.addAction(DownloadController.PROGRESS_ACTION);
+        LocalBroadcastManager.getInstance(this).registerReceiver(mBroadcastReceiver, intentFilter);
+    }
+
+    @Override
+    public void onStop() {
+        LocalBroadcastManager.getInstance(this).unregisterReceiver(mBroadcastReceiver);
+        if (mDownloadService != null) {
+            unbindService(mConnection);
+        }
+        super.onStop();
+    }
+
+    private ServiceConnection mConnection = new ServiceConnection() {
+
+        @Override
+        public void onServiceConnected(ComponentName className,
+                IBinder service) {
+            DownloadService.LocalBinder binder = (DownloadService.LocalBinder) service;
+            mDownloadService = binder.getService();
+            mAdapter.setDownloadController(mDownloadService.getDownloadController());
+            getUpdatesList();
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName componentName) {
+            mAdapter.setDownloadController(null);
+            mDownloadService = null;
+            mAdapter.notifyDataSetChanged();
+        }
+    };
+
+    private void loadUpdatesList() throws IOException, JSONException {
+        // Process local files first. If they aren't valid, the controller will delete
+        // them from the database. If they are valid, they should be prioritized.
+
+        Log.d(TAG, "Getting updates from internal database");
+
+        DownloadControllerInt controller = mDownloadService.getDownloadController();
+        UpdatesDbHelper dbHelper = new UpdatesDbHelper(this);
+        for (UpdateDownload update : dbHelper.getUpdates()) {
+            controller.addUpdate(update, true);
+        }
+
+        Log.d(TAG, "Adding remote updates");
+
+        File jsonFile = Utils.getCachedUpdateList(this);
+        for (UpdateDownload update : Utils.parseJson(jsonFile, true)) {
+            controller.addUpdate(update, true);
+        }
+
+        List<String> updateIds = new ArrayList<>();
+        updateIds.addAll(controller.getIds());
+        Collections.sort(updateIds);
+        mAdapter.setData(updateIds);
+        mAdapter.notifyDataSetChanged();
+    }
+
+    private void getUpdatesList() {
+        File jsonFile = Utils.getCachedUpdateList(this);
+        if (jsonFile.exists()) {
+            try {
+                loadUpdatesList();
+                Log.d(TAG, "Cached list parsed");
+            } catch (IOException | JSONException e) {
+                Log.e(TAG, "Error while parsing json list", e);
+            }
+        } else {
+            downloadUpdatesList();
+        }
+    }
+
+    private void downloadUpdatesList() {
+        File jsonFile = Utils.getCachedUpdateList(this);
+        String url = Utils.getServerURL(this);
+        Log.d(TAG, "Checking " + url);
+        DownloadClient.downloadFile(url, jsonFile, new DownloadClient.DownloadCallback() {
+            @Override
+            public void onFailure() {
+                Log.e(TAG, "Could not download updates list");
+            }
+
+            @Override
+            public void onResponse(int statusCode, String url,
+                    DownloadClient.Headers headers) {
+            }
+
+            @Override
+            public void onSuccess(String response) {
+                runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            Log.d(TAG, "List downloaded");
+                            loadUpdatesList();
+                        } catch (IOException | JSONException e) {
+                            Log.e(TAG, "Could not read json", e);
+                        }
+                    }
+                });
+            }
+        });
+    }
+}
diff --git a/src/org/lineageos/updater/UpdatesDbHelper.java b/src/org/lineageos/updater/UpdatesDbHelper.java
new file mode 100644
index 00000000..cdbdf207
--- /dev/null
+++ b/src/org/lineageos/updater/UpdatesDbHelper.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.provider.BaseColumns;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class UpdatesDbHelper extends SQLiteOpenHelper {
+
+    public static final int DATABASE_VERSION = 1;
+    public static final String DATABASE_NAME = "updates.db";
+
+    public static class UpdateEntry implements BaseColumns {
+        public static final String TABLE_NAME = "updates";
+        public static final String COLUMN_NAME_STATUS = "status";
+        public static final String COLUMN_NAME_PATH = "path";
+        public static final String COLUMN_NAME_NAME = "name";
+        public static final String COLUMN_NAME_DOWNLOAD_ID = "download_id";
+        public static final String COLUMN_NAME_DOWNLOAD_URL = "download_url";
+        public static final String COLUMN_NAME_TIMESTAMP = "timestamp";
+        public static final String COLUMN_NAME_TYPE = "type";
+        public static final String COLUMN_NAME_VERSION = "version";
+        public static final String COLUMN_NAME_SIZE = "size";
+    }
+
+    private static final String SQL_CREATE_ENTRIES =
+            "CREATE TABLE " + UpdateEntry.TABLE_NAME + " (" +
+                    UpdateEntry._ID + " INTEGER PRIMARY KEY," +
+                    UpdateEntry.COLUMN_NAME_STATUS + " INTEGER," +
+                    UpdateEntry.COLUMN_NAME_PATH + " TEXT," +
+                    UpdateEntry.COLUMN_NAME_NAME + " TEXT," +
+                    UpdateEntry.COLUMN_NAME_DOWNLOAD_ID + " TEXT NOT NULL UNIQUE," +
+                    UpdateEntry.COLUMN_NAME_DOWNLOAD_URL + " TEXT," +
+                    UpdateEntry.COLUMN_NAME_TIMESTAMP + " INTEGER," +
+                    UpdateEntry.COLUMN_NAME_TYPE + " TEXT," +
+                    UpdateEntry.COLUMN_NAME_VERSION + " TEXT," +
+                    UpdateEntry.COLUMN_NAME_SIZE + " INTEGER)";
+
+    private static final String SQL_DELETE_ENTRIES =
+            "DROP TABLE IF EXISTS " + UpdateEntry.TABLE_NAME;
+
+    public UpdatesDbHelper(Context context) {
+        super(context, DATABASE_NAME, null, DATABASE_VERSION);
+    }
+
+    public void onCreate(SQLiteDatabase db) {
+        db.execSQL(SQL_CREATE_ENTRIES);
+    }
+
+    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        db.execSQL(SQL_DELETE_ENTRIES);
+        onCreate(db);
+    }
+
+    public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+        onUpgrade(db, oldVersion, newVersion);
+    }
+
+    public long addUpdate(UpdateDownload update) {
+        SQLiteDatabase db = getWritableDatabase();
+        ContentValues values = new ContentValues();
+        values.put(UpdateEntry.COLUMN_NAME_STATUS, update.getPersistentStatus());
+        values.put(UpdateEntry.COLUMN_NAME_PATH, update.getFile().getAbsolutePath());
+        values.put(UpdateEntry.COLUMN_NAME_NAME, update.getName());
+        values.put(UpdateEntry.COLUMN_NAME_DOWNLOAD_ID, update.getDownloadId());
+        values.put(UpdateEntry.COLUMN_NAME_DOWNLOAD_URL, update.getDownloadUrl());
+        values.put(UpdateEntry.COLUMN_NAME_TIMESTAMP, update.getTimestamp());
+        values.put(UpdateEntry.COLUMN_NAME_TYPE, update.getType());
+        values.put(UpdateEntry.COLUMN_NAME_VERSION, update.getVersion());
+        values.put(UpdateEntry.COLUMN_NAME_SIZE, update.getFileSize());
+        return db.insert(UpdateEntry.TABLE_NAME, null, values);
+    }
+
+    public long addUpdateWithOnConflict(UpdateDownload update) {
+        SQLiteDatabase db = getWritableDatabase();
+        ContentValues values = new ContentValues();
+        values.put(UpdateEntry.COLUMN_NAME_STATUS, update.getPersistentStatus());
+        values.put(UpdateEntry.COLUMN_NAME_PATH, update.getFile().getAbsolutePath());
+        values.put(UpdateEntry.COLUMN_NAME_NAME, update.getName());
+        values.put(UpdateEntry.COLUMN_NAME_DOWNLOAD_ID, update.getDownloadId());
+        values.put(UpdateEntry.COLUMN_NAME_DOWNLOAD_URL, update.getDownloadUrl());
+        values.put(UpdateEntry.COLUMN_NAME_TIMESTAMP, update.getTimestamp());
+        values.put(UpdateEntry.COLUMN_NAME_TYPE, update.getType());
+        values.put(UpdateEntry.COLUMN_NAME_VERSION, update.getVersion());
+        values.put(UpdateEntry.COLUMN_NAME_SIZE, update.getFileSize());
+        return db.insertWithOnConflict(UpdateEntry.TABLE_NAME, null, values,
+                SQLiteDatabase.CONFLICT_IGNORE);
+    }
+
+    public boolean removeUpdate(String downloadId) {
+        SQLiteDatabase db = getWritableDatabase();
+        String selection = UpdateEntry.COLUMN_NAME_DOWNLOAD_ID + " = ?";
+        String[] selectionArgs = {downloadId};
+        return db.delete(UpdateEntry.TABLE_NAME, selection, selectionArgs) != 0;
+    }
+
+    public boolean removeUpdate(long rowId) {
+        SQLiteDatabase db = getWritableDatabase();
+        String selection = UpdateEntry._ID + " = " + rowId;
+        return db.delete(UpdateEntry.TABLE_NAME, selection, null) != 0;
+    }
+
+    public boolean changeUpdateStatus(UpdateDownload update) {
+        String selection = UpdateEntry.COLUMN_NAME_DOWNLOAD_ID + " = ?";
+        String[] selectionArgs = {update.getDownloadId()};
+        return changeUpdateStatus(selection, selectionArgs, update.getPersistentStatus());
+    }
+
+    public boolean changeUpdateStatus(long rowId, int status) {
+        String selection = UpdateEntry._ID + " = " + rowId;
+        return changeUpdateStatus(selection, null, status);
+    }
+
+    private boolean changeUpdateStatus(String selection, String[] selectionArgs,
+            int status) {
+        SQLiteDatabase db = getWritableDatabase();
+        ContentValues values = new ContentValues();
+        values.put(UpdateEntry.COLUMN_NAME_STATUS, status);
+        return db.update(UpdateEntry.TABLE_NAME, values, selection, selectionArgs) != 0;
+    }
+
+    public UpdateDownload getUpdate(long rowId) {
+        String selection = UpdateEntry._ID + " = " + rowId;
+        return getUpdate(selection, null);
+    }
+
+    public UpdateDownload getUpdate(String downloadId) {
+        String selection = UpdateEntry.COLUMN_NAME_DOWNLOAD_ID + " = ?";
+        String[] selectionArgs = {downloadId};
+        return getUpdate(selection, selectionArgs);
+    }
+
+    private UpdateDownload getUpdate(String selection, String[] selectionArgs) {
+        List<UpdateDownload> updates = getUpdates(selection, selectionArgs);
+        return updates != null ? updates.get(0) : null;
+    }
+
+    public List<UpdateDownload> getUpdates() {
+        return getUpdates(null, null);
+    }
+
+    public List<UpdateDownload> getUpdates(String selection, String[] selectionArgs) {
+        SQLiteDatabase db = getReadableDatabase();
+        String[] projection = {
+                UpdateEntry.COLUMN_NAME_PATH,
+                UpdateEntry.COLUMN_NAME_NAME,
+                UpdateEntry.COLUMN_NAME_DOWNLOAD_ID,
+                UpdateEntry.COLUMN_NAME_DOWNLOAD_URL,
+                UpdateEntry.COLUMN_NAME_TIMESTAMP,
+                UpdateEntry.COLUMN_NAME_TYPE,
+                UpdateEntry.COLUMN_NAME_VERSION,
+                UpdateEntry.COLUMN_NAME_STATUS,
+                UpdateEntry.COLUMN_NAME_SIZE,
+        };
+        String sort = UpdateEntry.COLUMN_NAME_TIMESTAMP + " DESC";
+        Cursor cursor = db.query(UpdateEntry.TABLE_NAME, projection, selection, selectionArgs,
+                null, null, sort);
+        List<UpdateDownload> updates = new ArrayList<>();
+        if (cursor != null) {
+            while (cursor.moveToNext()) {
+                UpdateDownload update = new UpdateDownload();
+                int index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_PATH);
+                update.setFile(new File(cursor.getString(index)));
+                index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_NAME);
+                update.setName(cursor.getString(index));
+                index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_DOWNLOAD_ID);
+                update.setDownloadId(cursor.getString(index));
+                index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_DOWNLOAD_URL);
+                update.setDownloadUrl(cursor.getString(index));
+                index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_TIMESTAMP);
+                update.setTimestamp(cursor.getLong(index));
+                index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_TYPE);
+                update.setType(cursor.getString(index));
+                index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_VERSION);
+                update.setVersion(cursor.getString(index));
+                index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_STATUS);
+                update.setPersistentStatus(cursor.getInt(index));
+                index = cursor.getColumnIndex(UpdateEntry.COLUMN_NAME_SIZE);
+                update.setFileSize(cursor.getLong(index));
+                updates.add(update);
+            }
+            cursor.close();
+        }
+        return updates;
+    }
+}
diff --git a/src/org/lineageos/updater/UpdatesListAdapter.java b/src/org/lineageos/updater/UpdatesListAdapter.java
new file mode 100644
index 00000000..e608fbf6
--- /dev/null
+++ b/src/org/lineageos/updater/UpdatesListAdapter.java
@@ -0,0 +1,192 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater;
+
+import android.content.Context;
+import android.support.v7.widget.RecyclerView;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+
+import org.lineageos.updater.misc.Utils;
+
+import java.io.IOException;
+import java.util.List;
+
+public class UpdatesListAdapter extends RecyclerView.Adapter<UpdatesListAdapter.ViewHolder> {
+
+    private static final String TAG = "UpdateListAdapter";
+
+    private List<String> mDownloadIds;
+    private DownloadControllerInt mDownloadController;
+    private Context mContext;
+
+    private enum Action {
+        DOWNLOAD,
+        PAUSE,
+        RESUME,
+        CANCEL,
+        INSTALL
+    }
+
+    public static class ViewHolder extends RecyclerView.ViewHolder {
+        private TextView mName;
+        private Button mButton1;
+        private Button mButton2;
+        private ProgressBar mProgressBar;
+
+        public ViewHolder(final View view) {
+            super(view);
+            mName = (TextView) view.findViewById(R.id.name);
+            mButton1 = (Button) view.findViewById(R.id.button1);
+            mButton2 = (Button) view.findViewById(R.id.button2);
+            mProgressBar = (ProgressBar) view.findViewById(R.id.progress_bar);
+        }
+    }
+
+    public UpdatesListAdapter(Context context) {
+        mContext = context;
+    }
+
+    @Override
+    public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
+        View view = LayoutInflater.from(viewGroup.getContext())
+                .inflate(R.layout.update_item_view, viewGroup, false);
+        return new ViewHolder(view);
+    }
+
+    public void setDownloadController(DownloadControllerInt downloadController) {
+        mDownloadController = downloadController;
+        notifyDataSetChanged();
+    }
+
+    @Override
+    public void onBindViewHolder(final ViewHolder viewHolder, int i) {
+        if (mDownloadController == null) {
+            viewHolder.mButton1.setEnabled(false);
+            viewHolder.mButton2.setEnabled(false);
+            return;
+        }
+
+        final String downloadId = mDownloadIds.get(i);
+        UpdateDownload update = mDownloadController.getUpdate(downloadId);
+        viewHolder.mName.setText(update.getName());
+
+        viewHolder.mProgressBar.setProgress(update.getProgress());
+        boolean indeterminate = update.getStatus() == UpdateStatus.STARTING ||
+                update.getStatus() == UpdateStatus.VERIFYING ||
+                update.getStatus() == UpdateStatus.INSTALLING;
+        viewHolder.mProgressBar.setIndeterminate(indeterminate);
+
+        if (mDownloadController.isDownloading(downloadId)) {
+            setButtonAction(viewHolder.mButton1, Action.PAUSE, downloadId, true);
+            viewHolder.mButton2.setEnabled(false);
+        } else {
+            // Allow one active download
+            boolean enabled = !mDownloadController.hasActiveDownloads();
+            int persistentStatus = update.getPersistentStatus();
+            if (persistentStatus == UpdateStatus.Persistent.INCOMPLETE) {
+                setButtonAction(viewHolder.mButton1, Action.RESUME, downloadId, enabled);
+                setButtonAction(viewHolder.mButton2, Action.CANCEL, downloadId, enabled);
+            } else if (persistentStatus == UpdateStatus.Persistent.VERIFIED) {
+                setButtonAction(viewHolder.mButton1, Action.INSTALL, downloadId, enabled);
+                setButtonAction(viewHolder.mButton2, Action.CANCEL, downloadId, enabled);
+            } else {
+                setButtonAction(viewHolder.mButton1, Action.DOWNLOAD, downloadId, enabled);
+                setButtonAction(viewHolder.mButton2, Action.CANCEL, downloadId, false);
+            }
+        }
+    }
+
+    @Override
+    public int getItemCount() {
+        return mDownloadIds == null ? 0 : mDownloadIds.size();
+    }
+
+    public void setData(List<String> downloadIds) {
+        mDownloadIds = downloadIds;
+    }
+
+    public void notifyItemChanged(String downloadId) {
+        notifyItemChanged(mDownloadIds.indexOf(downloadId));
+    }
+
+    private void setButtonAction(Button button, Action action, final String downloadId,
+            boolean enabled) {
+        switch (action) {
+            case DOWNLOAD:
+                button.setText(R.string.download_button);
+                button.setEnabled(enabled);
+                button.setOnClickListener(!enabled ? null : new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        mDownloadController.startDownload(downloadId);
+                    }
+                });
+                break;
+            case PAUSE:
+                button.setText(R.string.pause_button);
+                button.setEnabled(enabled);
+                button.setOnClickListener(!enabled ? null : new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        mDownloadController.pauseDownload(downloadId);
+                    }
+                });
+                break;
+            case RESUME:
+                button.setText(R.string.resume_button);
+                button.setEnabled(enabled);
+                button.setOnClickListener(!enabled ? null : new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        mDownloadController.resumeDownload(downloadId);
+                    }
+                });
+                break;
+            case CANCEL:
+                button.setText(R.string.cancel_button);
+                button.setEnabled(enabled);
+                button.setOnClickListener(!enabled ? null : new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        mDownloadController.cancelDownload(downloadId);
+                    }
+                });
+                break;
+            case INSTALL:
+                button.setText(R.string.install_button);
+                button.setEnabled(enabled);
+                button.setOnClickListener(!enabled ? null : new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        try {
+                            Utils.triggerUpdate(mContext,
+                                    mDownloadController.getUpdate(downloadId));
+                        } catch (IOException e) {
+                            Log.e(TAG, "Could not trigger the update", e);
+                            // TODO: show error message
+                        }
+                    }
+                });
+                break;
+        }
+    }
+}
diff --git a/src/org/lineageos/updater/misc/Utils.java b/src/org/lineageos/updater/misc/Utils.java
new file mode 100644
index 00000000..addc0e8d
--- /dev/null
+++ b/src/org/lineageos/updater/misc/Utils.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2017 The LineageOS 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.
+ */
+package org.lineageos.updater.misc;
+
+import android.content.Context;
+import android.os.SystemProperties;
+import android.util.Log;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+import org.lineageos.updater.R;
+import org.lineageos.updater.Update;
+import org.lineageos.updater.UpdateDownload;
+import org.lineageos.updater.UpdateStatus;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.channels.FileChannel;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Utils {
+
+    private static final String TAG = "Utils";
+
+    public static File getDownloadPath(Context context) {
+        boolean useCache = context.getResources().getBoolean(R.bool.download_in_cache);
+        int id = useCache ? R.string.download_path_cache : R.string.download_path_data;
+        return new File(context.getString(id));
+    }
+
+    public static File getCachedUpdateList(Context context) {
+        return new File(context.getCacheDir(), "updates.json");
+    }
+
+    // This should really return an Update object, but currently this only
+    // used to initialize UpdateDownload objects
+    private static UpdateDownload parseJsonUpdate(JSONObject object) throws JSONException {
+        UpdateDownload update = new UpdateDownload();
+        update.setTimestamp(object.getLong("datetime"));
+        update.setName(object.getString("filename"));
+        update.setDownloadId(object.getString("id"));
+        update.setType(object.getString("romtype"));
+        update.setDownloadUrl(object.getString("url"));
+        update.setVersion(object.getString("version"));
+        return update;
+    }
+
+    public static boolean isCompatible(Update update) {
+        if (update.getTimestamp() < SystemProperties.getLong("ro.build.date.utc", 0)) {
+            Log.d(TAG, update.getName() + " is older than current build");
+            return false;
+        }
+        if (!update.getType().equalsIgnoreCase(SystemProperties.get("ro.cm.releasetype"))) {
+            Log.d(TAG, update.getName() + " has type " + update.getType());
+            return false;
+        }
+        if (!update.getVersion().equalsIgnoreCase(SystemProperties.get("ro.cm.build.version"))) {
+            Log.d(TAG, update.getName() + " has version " + update.getVersion());
+            return false;
+        }
+        return true;
+    }
+
+    public static List<UpdateDownload> parseJson(File file, boolean compatibleOnly)
+            throws IOException, JSONException {
+        List<UpdateDownload> updates = new ArrayList<>();
+
+        String json = "";
+        try (BufferedReader br = new BufferedReader(new FileReader(file))) {
+            for (String line; (line = br.readLine()) != null;) {
+                json += line;
+            }
+        }
+
+        JSONObject obj = new JSONObject(json);
+        JSONArray updatesList = obj.getJSONArray("response");
+        for (int i = 0; i < updatesList.length(); i++) {
+            if (updatesList.isNull(i)) {
+                continue;
+            }
+            try {
+                UpdateDownload update = parseJsonUpdate(updatesList.getJSONObject(i));
+                if (compatibleOnly && isCompatible(update)) {
+                    updates.add(update);
+                } else {
+                    Log.d(TAG, "Ignoring incompatible update " + update.getName());
+                }
+            } catch (JSONException e) {
+                Log.e(TAG, "Could not parse update object, index=" + i);
+            }
+        }
+
+        return updates;
+    }
+
+    public static String getServerURL(Context context) {
+        String serverUrl = SystemProperties.get("cm.updater.uri");
+        if (serverUrl.trim().isEmpty()) {
+            serverUrl = context.getString(R.string.conf_update_server_url_def);
+        }
+        String incrementalVersion = SystemProperties.get("ro.build.version.incremental");
+        String device = SystemProperties.get("ro.cm.device").toLowerCase();
+        String type = SystemProperties.get("ro.cm.releasetype").toLowerCase();
+        return serverUrl + "/v1/" + device + "/" + type + "/" + incrementalVersion;
+    }
+
+    public static void triggerUpdate(Context context, UpdateDownload update) throws IOException {
+        if (update.getStatus() == UpdateStatus.VERIFIED) {
+            android.os.RecoverySystem.installPackage(context, update.getFile());
+        }
+    }
+}