Updated to androidx.

.github/CONTRIBUTING.md

@@ -41,12 +41,6 @@ Always check if the web version of your instance is working.
 * Remember that PR review can take time.
 
 
-# Install Selfoss (if you don't have an instance)
-
-I won't provide any selfoss instance url. If you want to help, but to not have one, you'll have to install one, and use it.
-
-All the details to need are [here](https://selfoss.aditu.de/).
-
 # Build the project
 
 You can directly import this project into IntellIJ/Android Studio.

.gitignore

@@ -216,4 +216,6 @@ gradle-app.setting
 
 release/
 
-crowdin.properties
+crowdin.properties
+
+publish-version.sh

CHANGELOG.md

@@ -1,47 +1,3 @@
-**1.7.x**
-
-- Hiding tags with 0 articles
-
-- Fixed issue with basic auth and images loading
-
-- Added the ability to justify or left align the reader text
-
-- Fixed #251
-
-- Added experimental issue to set a default timeout. Should work for #238.
-
-- Closing #220.
-
-- Start of #238. "Add a quick shortcut to open the app on offline mode ?"
-
-- Closes #216. Issue with selfoss version 2.19.
-
-- Closes #179. Sync of read/unread/star/unstar items on background task or on app reload with network available.
-
-- Closes #33. Background sync with settings.
-
-- Closing #1. Initial article caching.
-
-- Closing #228 by removing the list action bar. Action buttons are exclusively on the card view from now on.
-
-- Closing #38. Only doing api calls on network available.
-
-- Closing #298 and #287. Issues with Listview rendering
-
-- Closing #290. Fixing back button issue in Settings
-
-- Closing #300. Fixing issues when displaying some special characters.
-
-- Closing #310. Some feeds don't have icons nor thumbnails.
-
-- Closing #178. Expending images on tap.
-
-- Closing #323. Old issue with textview not having the right color.
-
-- Closing #324. Svg images loading crashes the app.
-
-- Closing #322. App crashed because of svg images.
-
 **1.6.x**
 
 - Handling hidden tags.
@@ -62,8 +18,6 @@
 
 - Fixes #215, #208.
 
-- Fixes #328.
-
 **1.5.7.x**
 
 - Added confirmation to the mark as read and update menues.

README.md

@@ -1,34 +1,24 @@
-# ReaderForSelfoss **(Only available from F-Droid)**
+# ReaderForSelfoss
 
-[![Crowdin](https://d322cqt584bo4o.cloudfront.net/readerforselfoss/localized.svg)](https://crowdin.com/project/readerforselfoss)
+[![Slack Channel](https://img.shields.io/badge/chat-slack-green.svg)](https://join.slack.com/t/readerforselfoss/shared_invite/enQtMjkyNzc3NjM2Mjc1LTUzZTZhOGM5YjQ1MTI5MWZiODRjMjE1ZDBmMzQxZmQ3NWZhYTNhMTBjNGEwNmE2ZGFjODU5NjUxZjBkMWJmMDQ) [![Build Status](https://jenkins.amine-bou.fr/job/ReaderForSelfoss/badge/icon)](https://jenkins.amine-bou.fr/job/ReaderForSelfoss/) [![Code Triagers Badge](https://www.codetriage.com/aminecmi/readerforselfoss/badges/users.svg)](https://www.codetriage.com/aminecmi/readerforselfoss) [![Crowdin](https://d322cqt584bo4o.cloudfront.net/readerforselfoss/localized.svg)](https://crowdin.com/project/readerforselfoss)
 
 It's an RSS Reader for Android, that **only** works with [Selfoss](https://selfoss.aditu.de/)
 
-**The project is not dead at all.** 
+<a href='https://play.google.com/store/apps/details?id=apps.amine.bou.readerforselfoss'><img alt='Get it on Google Play' src='https://play.google.com/intl/en_us/badges/images/generic/en_badge_web_generic.png' height="100"/></a> <a href="https://f-droid.org/packages/apps.amine.bou.readerforselfoss"><img src="https://f-droid.org/badge/get-it-on.png" alt="Get it on F-Droid" height="100"></a>
 
-I still want to work on it, but for the last few months, I didn't have that much time to do so. 
+Also, the last APK built from source is available [here](https://jenkins.amine-bou.fr/job/ReaderForSelfoss/lastSuccessfulBuild/artifact/SignApksBuilder-out/selfoss-key/selfoss/app-githubConfig-release-unsigned.apk/app-githubConfig-release.apk).
 
-If you are a developer, don't hesitate to help with PRs.
+## Join the alpha channel
 
-If you are a user, you can still create new issues. I'll fix them when I can.
+**Keep in mind, it could be instable, but you'll have the new updates faster**
 
-<a href="https://f-droid.org/packages/apps.amine.bou.readerforselfoss"><img src="https://f-droid.org/badge/get-it-on.png" alt="Get it on F-Droid" height="100"></a>
+- First, join the google [group](https://groups.google.com/d/forum/reader-for-selfoss-alpha-testing).
-
+- Then, join the [alpha channel](https://play.google.com/apps/testing/apps.amine.bou.readerforselfoss) of the app.
-## Screen captures
+- You'll be able to update the app for the current alpha version.
-
-<img src="res//fr-card.png?raw=true" alt="card view" width="400"/> <img src="res//fr-list.png?raw=true" alt="list view" width="400"/>
-
-## Like my app ?
-
-<a href="https://www.buymeacoffee.com/aminecmi" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/lato-orange.png" alt="Buy Me A Coffee" style="height: 51px !important;width: 217px !important;" ></a>
 
 ## Want to help ?
 
-1. **You'll have to have a Selfoss instance running.** You'll find everything you need to install it [here](https://selfoss.aditu.de/).
+Check the [Contribution guide](https://github.com/aminecmi/ReaderforSelfoss/blob/master/.github/CONTRIBUTING.md)
-
-2. Check the [Contribution guide](https://github.com/aminecmi/ReaderforSelfoss/blob/master/.github/CONTRIBUTING.md).
-
-3. Build the project by following [these steps](https://github.com/aminecmi/ReaderforSelfoss/blob/master/.github/CONTRIBUTING.md#build-the-project) (you should have read them after the contribution guide)
 
 ## Useful links
 
@@ -36,3 +26,4 @@ If you are a user, you can still create new issues. I'll fix them when I can.
 - [See what I'm doing](https://github.com/aminecmi/ReaderforSelfoss/projects/1)
 - [Create an issue, or request a new feature](https://github.com/aminecmi/ReaderforSelfoss/issues)
 - [Help translation the app](https://crowdin.com/project/readerforselfoss)
+- [Ask for help](https://join.slack.com/t/readerforselfoss/shared_invite/enQtMjkyNzc3NjM2Mjc1LTUzZTZhOGM5YjQ1MTI5MWZiODRjMjE1ZDBmMzQxZmQ3NWZhYTNhMTBjNGEwNmE2ZGFjODU5NjUxZjBkMWJmMDQ)

app/build.gradle

@@ -1,17 +1,17 @@
 buildscript {
 }
 
+ext {
+    configuration = [
+            buildDate: new Date()
+    ]
+    // This will make me able to build multiple times a day. May break thinks. I may forget it.
+    todaysBuilds = "1"
+}
+
 def gitVersion() {
-    def process
+    def process = "git describe --abbrev=0 --tags".execute()
-    def maybeTagOfCurrentCommit = 'git describe --contains HEAD'.execute()
+    return process.text.substring(1).replaceAll("\\.", "").trim()
-    if (maybeTagOfCurrentCommit.text.isEmpty()) {
-        println "No tag on current commit. Will take the latest one."
-        process = "git for-each-ref refs/tags --sort=-authordate --format='%(refname:short)' --count=1".execute()
-    } else {
-        println "Tag found on current commit"
-        process = 'git describe --contains HEAD'.execute()
-    }
-    return process.text.replaceAll("'", "").substring(1).replaceAll("\\.", "").trim()
 }
 
 def versionCodeFromGit() {
@@ -28,22 +28,19 @@ apply plugin: 'com.android.application'
 
 apply plugin: 'kotlin-android'
 
-apply plugin: 'kotlin-kapt'
+apply plugin: 'kotlin-android-extensions'
 
 android {
     compileOptions {
         sourceCompatibility JavaVersion.VERSION_1_8
         targetCompatibility JavaVersion.VERSION_1_8
     }
-    compileSdkVersion 30
+    compileSdkVersion 28
-    buildToolsVersion '30.0.3'
+    buildToolsVersion '28.0.2'
-    buildFeatures {
-        viewBinding true
-    }
     defaultConfig {
         applicationId "apps.amine.bou.readerforselfoss"
         minSdkVersion 16
-        targetSdkVersion 30
+        targetSdkVersion 28
         versionCode versionCodeFromGit()
         versionName versionNameFromGit()
 
@@ -57,22 +54,19 @@ android {
 
         // tests
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-
-        javaCompileOptions {
-            annotationProcessorOptions {
-                arguments = ["room.schemaLocation":
-                                     "$projectDir/schemas".toString()]
-            }
-        }
     }
     buildTypes {
         release {
             minifyEnabled true
-            shrinkResources false
+            shrinkResources true
             proguardFiles getDefaultProguardFile('proguard-android.txt'),
                     'proguard-rules.pro'
         }
         debug {
+            buildConfigField "String", "LOGIN_URL", appLoginUrl
+            buildConfigField "String", "LOGIN_USERNAME", appLoginUsername
+            buildConfigField "String", "LOGIN_PASSWORD", appLoginPassword
+            applicationIdSuffix ".dev"
         }
     }
     flavorDimensions "build"
@@ -81,35 +75,42 @@ android {
             versionNameSuffix '-github'
             dimension "build"
         }
+        storeConfig {
+            // As jenkins publishes to alpha first, this is the default suffix now.
+            versionNameSuffix '-store'
+            dimension "build"
+        }
     }
 }
 
 dependencies {
     // Testing
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0-alpha02'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.0-alpha4'
-    androidTestImplementation 'androidx.test:runner:1.3.1-alpha02'
+    androidTestImplementation 'androidx.test:runner:1.1.0-alpha4'
     // Espresso-contrib for DatePicker, RecyclerView, Drawer actions, Accessibility checks, CountingIdlingResource
-    androidTestImplementation 'androidx.test.espresso:espresso-contrib:3.4.0-alpha02'
+    androidTestImplementation 'androidx.test.espresso:espresso-contrib:3.1.0-alpha4'
     // Espresso-intents for validation and stubbing of Intents
-    androidTestImplementation 'androidx.test.espresso:espresso-intents:3.4.0-alpha02'
+    androidTestImplementation 'androidx.test.espresso:espresso-intents:3.1.0-alpha4'
     implementation fileTree(include: ['*.jar'], dir: 'libs')
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     // Android Support
-    implementation "androidx.appcompat:appcompat:1.3.0-alpha02"
+    implementation 'androidx.appcompat:appcompat:1.0.0'
-    implementation 'com.google.android.material:material:1.3.0-beta01'
+    implementation 'com.google.android.material:material:1.0.0'
-    implementation 'androidx.recyclerview:recyclerview:1.2.0-beta01'
+    implementation 'androidx.recyclerview:recyclerview:1.0.0'
-    implementation "androidx.legacy:legacy-support-v4:$android_version"
+    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
-    implementation 'androidx.vectordrawable:vectordrawable:1.2.0-alpha02'
+    implementation 'androidx.vectordrawable:vectordrawable:1.0.0'
-    implementation "androidx.browser:browser:1.3.0"
+    implementation 'androidx.browser:browser:1.0.0'
-    implementation "androidx.cardview:cardview:$android_version"
+    implementation 'androidx.cardview:cardview:1.0.0'
-    implementation 'androidx.constraintlayout:constraintlayout:2.1.0-alpha2'
+    implementation 'androidx.constraintlayout:constraintlayout:2.0.0-alpha2'
-    implementation 'org.jsoup:jsoup:1.13.1'
 
     //multidex
-    implementation 'androidx.multidex:multidex:2.0.1'
+    implementation 'androidx.multidex:multidex:2.0.0'
+
+    // Intro
+    implementation 'agency.tango.android:material-intro-screen:0.0.5'
 
     // About
-    implementation('com.mikepenz:aboutlibraries:6.2.0@aar') {
+    implementation('com.mikepenz:aboutlibraries:6.0.0@aar') {
         transitive = true
     }
 
@@ -120,35 +121,49 @@ dependencies {
     implementation 'com.burgstaller:okhttp-digest:1.12'
 
     // Material-ish things
-    implementation 'com.ashokvarma.android:bottom-navigation-bar:2.1.0'
+    implementation 'com.ashokvarma.android:bottom-navigation-bar:2.0.3'
-    implementation 'com.github.jd-alexander:LikeButton:0.2.3'
+    implementation 'com.github.jd-alexander:LikeButton:0.2.1'
     implementation 'com.amulyakhare:com.amulyakhare.textdrawable:1.0.1'
 
     // glide
     implementation 'com.github.bumptech.glide:glide:4.1.1'
     implementation 'com.github.bumptech.glide:okhttp3-integration:4.1.1'
 
+    // Asking politely users to rate the app
+    implementation 'com.github.stkent:amplify:2.1.0'
+
     // Drawer
-    implementation 'co.zsmb:materialdrawer-kt:2.0.2'
+    implementation 'co.zsmb:materialdrawer-kt:2.0.0'
+    implementation 'com.anupcowkur:reservoir:3.1.0'
 
     // Themes
     implementation 'com.52inc:scoops:1.0.0'
-    implementation 'com.jaredrummler:colorpicker:1.0.2'
+    implementation 'com.jrummyapps:colorpicker:2.1.7'
     implementation 'com.github.rubensousa:floatingtoolbar:1.5.1'
 
     // Pager
-    implementation 'me.relex:circleindicator:2.0.0@aar'
+    implementation 'me.relex:circleindicator:1.2.2@aar'
 
-    //PhotoView
+    implementation 'androidx.core:core-ktx:1.0.0'
-    implementation 'com.github.chrisbanes:PhotoView:2.0.0'
 
-    implementation 'androidx.core:core-ktx:1.5.0-alpha05'
+    // Crash
-
+    implementation 'ch.acra:acra-http:5.2.0'
-    implementation "androidx.lifecycle:lifecycle-livedata:2.3.0-rc01"
+    implementation 'ch.acra:acra-dialog:5.2.0'
-    implementation "androidx.lifecycle:lifecycle-common-java8:2.3.0-rc01"
-
-    implementation "androidx.room:room-runtime:2.3.0-alpha04"
-    kapt "androidx.room:room-compiler:2.3.0-alpha04"
-
-    implementation "android.arch.work:work-runtime-ktx:$work_version"
 }
+
+
+afterEvaluate {
+    initAppLoginPropertiesIfNeeded()
+}
+
+def initAppLoginPropertiesIfNeeded() {
+    def propertiesFile = file(System.getProperty("user.home") + '/.gradle/gradle.properties')
+    if (!propertiesFile.exists()) {
+        def commentMessage = "This is autogenerated local property from system environment to prevent key to be committed to source control."
+        ant.propertyfile(file: System.getProperty("user.home") + "/.gradle/gradle.properties", comment: commentMessage) {
+            entry(key: "appLoginUrl", value: System.getProperty("appLoginUrl"))
+            entry(key: "appLoginUsername", value: System.getProperty("appLoginUsername"))
+            entry(key: "appLoginPassword", value: System.getProperty("appLoginPassword"))
+        }
+    }
+}

app/proguard-rules.pro

@@ -30,6 +30,22 @@
     <fields>;
 }
 
+
+##Retrofit
+#-keep class com.google.gson.** { *; }
+#-keep class com.google.inject.** { *; }
+#-keep class org.apache.http.** { *; }
+#-keep class org.apache.james.mime4j.** { *; }
+#-keep class javax.inject.** { *; }
+#-keep class retrofit.** { *; }
+#-keepclassmembernames interface * {
+#    @retrofit.http.* <methods>;
+#}
+#-keep class retrofit.** { *; }
+#-keep class apps.amine.bou.readerforselfoss.api.selfoss.model.** { *; }
+#-keepclassmembernames interface * {
+#    @retrofit.http.* <methods>;
+#}
 -dontwarn okio.**
 -dontwarn retrofit2.Platform$Java8
 -keep class retrofit.** { *; }
@@ -59,7 +75,4 @@
 
 -dontwarn javax.annotation.**
 
--keep class android.support.v7.widget.SearchView { *; }
+-keep class androidx.appcompat.widget.SearchView { *; }
-
-# maybe remove later ?
--keep class * extends androidx.fragment.app.Fragment

app/schemas/apps.amine.bou.readerforselfoss.persistence.database.AppDatabase/1.json

@@ -1,96 +0,0 @@
-{
-  "formatVersion": 1,
-  "database": {
-    "version": 1,
-    "identityHash": "08ca537d7ac9d4dd216e8e395d70801a",
-    "entities": [
-      {
-        "tableName": "tags",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tag` TEXT NOT NULL, `color` TEXT NOT NULL, `unread` INTEGER NOT NULL, PRIMARY KEY(`tag`))",
-        "fields": [
-          {
-            "fieldPath": "tag",
-            "columnName": "tag",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "color",
-            "columnName": "color",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "tag"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "sources",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `title` TEXT NOT NULL, `tags` TEXT NOT NULL, `spout` TEXT NOT NULL, `error` TEXT NOT NULL, `icon` TEXT NOT NULL, PRIMARY KEY(`id`))",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tags",
-            "columnName": "tags",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "spout",
-            "columnName": "spout",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "error",
-            "columnName": "error",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "icon",
-            "columnName": "icon",
-            "affinity": "TEXT",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      }
-    ],
-    "views": [],
-    "setupQueries": [
-      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, \"08ca537d7ac9d4dd216e8e395d70801a\")"
-    ]
-  }
-}

app/schemas/apps.amine.bou.readerforselfoss.persistence.database.AppDatabase/2.json

@@ -1,176 +0,0 @@
-{
-  "formatVersion": 1,
-  "database": {
-    "version": 2,
-    "identityHash": "6fa6944b04100d68eab61039876a8804",
-    "entities": [
-      {
-        "tableName": "tags",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tag` TEXT NOT NULL, `color` TEXT NOT NULL, `unread` INTEGER NOT NULL, PRIMARY KEY(`tag`))",
-        "fields": [
-          {
-            "fieldPath": "tag",
-            "columnName": "tag",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "color",
-            "columnName": "color",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "tag"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "sources",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `title` TEXT NOT NULL, `tags` TEXT NOT NULL, `spout` TEXT NOT NULL, `error` TEXT NOT NULL, `icon` TEXT NOT NULL, PRIMARY KEY(`id`))",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tags",
-            "columnName": "tags",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "spout",
-            "columnName": "spout",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "error",
-            "columnName": "error",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "icon",
-            "columnName": "icon",
-            "affinity": "TEXT",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "items",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `datetime` TEXT NOT NULL, `title` TEXT NOT NULL, `content` TEXT NOT NULL, `unread` INTEGER NOT NULL, `starred` INTEGER NOT NULL, `thumbnail` TEXT NOT NULL, `icon` TEXT NOT NULL, `link` TEXT NOT NULL, `sourcetitle` TEXT NOT NULL, `tags` TEXT NOT NULL, PRIMARY KEY(`id`))",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "datetime",
-            "columnName": "datetime",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "content",
-            "columnName": "content",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "starred",
-            "columnName": "starred",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "thumbnail",
-            "columnName": "thumbnail",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "icon",
-            "columnName": "icon",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "link",
-            "columnName": "link",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "sourcetitle",
-            "columnName": "sourcetitle",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tags",
-            "columnName": "tags",
-            "affinity": "TEXT",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      }
-    ],
-    "views": [],
-    "setupQueries": [
-      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, \"6fa6944b04100d68eab61039876a8804\")"
-    ]
-  }
-}

app/schemas/apps.amine.bou.readerforselfoss.persistence.database.AppDatabase/3.json

@@ -1,226 +0,0 @@
-{
-  "formatVersion": 1,
-  "database": {
-    "version": 3,
-    "identityHash": "7ad9c4961992c13b670128485ebb3efc",
-    "entities": [
-      {
-        "tableName": "tags",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tag` TEXT NOT NULL, `color` TEXT NOT NULL, `unread` INTEGER NOT NULL, PRIMARY KEY(`tag`))",
-        "fields": [
-          {
-            "fieldPath": "tag",
-            "columnName": "tag",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "color",
-            "columnName": "color",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "tag"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "sources",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `title` TEXT NOT NULL, `tags` TEXT NOT NULL, `spout` TEXT NOT NULL, `error` TEXT NOT NULL, `icon` TEXT NOT NULL, PRIMARY KEY(`id`))",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tags",
-            "columnName": "tags",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "spout",
-            "columnName": "spout",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "error",
-            "columnName": "error",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "icon",
-            "columnName": "icon",
-            "affinity": "TEXT",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "items",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `datetime` TEXT NOT NULL, `title` TEXT NOT NULL, `content` TEXT NOT NULL, `unread` INTEGER NOT NULL, `starred` INTEGER NOT NULL, `thumbnail` TEXT NOT NULL, `icon` TEXT NOT NULL, `link` TEXT NOT NULL, `sourcetitle` TEXT NOT NULL, `tags` TEXT NOT NULL, PRIMARY KEY(`id`))",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "datetime",
-            "columnName": "datetime",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "content",
-            "columnName": "content",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "starred",
-            "columnName": "starred",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "thumbnail",
-            "columnName": "thumbnail",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "icon",
-            "columnName": "icon",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "link",
-            "columnName": "link",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "sourcetitle",
-            "columnName": "sourcetitle",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tags",
-            "columnName": "tags",
-            "affinity": "TEXT",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "actions",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `articleid` TEXT NOT NULL, `read` INTEGER NOT NULL, `unread` INTEGER NOT NULL, `starred` INTEGER NOT NULL, `unstarred` INTEGER NOT NULL)",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "articleId",
-            "columnName": "articleid",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "read",
-            "columnName": "read",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "starred",
-            "columnName": "starred",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unstarred",
-            "columnName": "unstarred",
-            "affinity": "INTEGER",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": true
-        },
-        "indices": [],
-        "foreignKeys": []
-      }
-    ],
-    "views": [],
-    "setupQueries": [
-      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, \"7ad9c4961992c13b670128485ebb3efc\")"
-    ]
-  }
-}

app/schemas/apps.amine.bou.readerforselfoss.persistence.database.AppDatabase/4.json

@@ -1,226 +0,0 @@
-{
-  "formatVersion": 1,
-  "database": {
-    "version": 4,
-    "identityHash": "9cf8b03d32f80dfd58160599a1df197d",
-    "entities": [
-      {
-        "tableName": "tags",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`tag` TEXT NOT NULL, `color` TEXT NOT NULL, `unread` INTEGER NOT NULL, PRIMARY KEY(`tag`))",
-        "fields": [
-          {
-            "fieldPath": "tag",
-            "columnName": "tag",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "color",
-            "columnName": "color",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "tag"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "sources",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `title` TEXT NOT NULL, `tags` TEXT NOT NULL, `spout` TEXT NOT NULL, `error` TEXT NOT NULL, `icon` TEXT NOT NULL, PRIMARY KEY(`id`))",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tags",
-            "columnName": "tags",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "spout",
-            "columnName": "spout",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "error",
-            "columnName": "error",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "icon",
-            "columnName": "icon",
-            "affinity": "TEXT",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "items",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` TEXT NOT NULL, `datetime` TEXT NOT NULL, `title` TEXT NOT NULL, `content` TEXT NOT NULL, `unread` INTEGER NOT NULL, `starred` INTEGER NOT NULL, `thumbnail` TEXT, `icon` TEXT, `link` TEXT NOT NULL, `sourcetitle` TEXT NOT NULL, `tags` TEXT NOT NULL, PRIMARY KEY(`id`))",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "datetime",
-            "columnName": "datetime",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "title",
-            "columnName": "title",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "content",
-            "columnName": "content",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "starred",
-            "columnName": "starred",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "thumbnail",
-            "columnName": "thumbnail",
-            "affinity": "TEXT",
-            "notNull": false
-          },
-          {
-            "fieldPath": "icon",
-            "columnName": "icon",
-            "affinity": "TEXT",
-            "notNull": false
-          },
-          {
-            "fieldPath": "link",
-            "columnName": "link",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "sourcetitle",
-            "columnName": "sourcetitle",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "tags",
-            "columnName": "tags",
-            "affinity": "TEXT",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": false
-        },
-        "indices": [],
-        "foreignKeys": []
-      },
-      {
-        "tableName": "actions",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `articleid` TEXT NOT NULL, `read` INTEGER NOT NULL, `unread` INTEGER NOT NULL, `starred` INTEGER NOT NULL, `unstarred` INTEGER NOT NULL)",
-        "fields": [
-          {
-            "fieldPath": "id",
-            "columnName": "id",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "articleId",
-            "columnName": "articleid",
-            "affinity": "TEXT",
-            "notNull": true
-          },
-          {
-            "fieldPath": "read",
-            "columnName": "read",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unread",
-            "columnName": "unread",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "starred",
-            "columnName": "starred",
-            "affinity": "INTEGER",
-            "notNull": true
-          },
-          {
-            "fieldPath": "unstarred",
-            "columnName": "unstarred",
-            "affinity": "INTEGER",
-            "notNull": true
-          }
-        ],
-        "primaryKey": {
-          "columnNames": [
-            "id"
-          ],
-          "autoGenerate": true
-        },
-        "indices": [],
-        "foreignKeys": []
-      }
-    ],
-    "views": [],
-    "setupQueries": [
-      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, \"9cf8b03d32f80dfd58160599a1df197d\")"
-    ]
-  }
-}

app/src/androidTest/java/apps/amine/bou/readerforselfoss/HomeActivityEspressoTest.kt

@@ -7,17 +7,14 @@ import androidx.test.espresso.Espresso.onView
 import androidx.test.espresso.Espresso.openActionBarOverflowOrOptionsMenu
 import androidx.test.espresso.action.ViewActions.click
 import androidx.test.espresso.action.ViewActions.closeSoftKeyboard
-import androidx.test.espresso.action.ViewActions.pressBack
 import androidx.test.espresso.action.ViewActions.pressKey
 import androidx.test.espresso.action.ViewActions.typeText
 import androidx.test.espresso.assertion.ViewAssertions.matches
-import androidx.test.espresso.contrib.DrawerActions
 import androidx.test.espresso.intent.Intents
 import androidx.test.espresso.intent.Intents.intended
 import androidx.test.espresso.intent.Intents.times
 import androidx.test.espresso.intent.matcher.IntentMatchers.hasComponent
 import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
-import androidx.test.espresso.matcher.ViewMatchers.isRoot
 import androidx.test.espresso.matcher.ViewMatchers.withContentDescription
 import androidx.test.espresso.matcher.ViewMatchers.withId
 import androidx.test.espresso.matcher.ViewMatchers.withText

app/src/androidTest/java/apps/amine/bou/readerforselfoss/IntroActivityEspressoTest.kt

@@ -0,0 +1,91 @@
+package apps.amine.bou.readerforselfoss
+
+import android.content.Context
+import android.content.Intent
+import androidx.test.InstrumentationRegistry.getInstrumentation
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions.click
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.intent.Intents
+import androidx.test.espresso.intent.Intents.intended
+import androidx.test.espresso.intent.Intents.times
+import androidx.test.espresso.intent.matcher.IntentMatchers.hasComponent
+import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.withId
+import androidx.test.espresso.matcher.ViewMatchers.withText
+import androidx.test.rule.ActivityTestRule
+import androidx.test.runner.AndroidJUnit4
+import apps.amine.bou.readerforselfoss.utils.Config
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.util.*
+
+@RunWith(AndroidJUnit4::class)
+class IntroActivityEspressoTest {
+
+    @Rule @JvmField
+    val rule = ActivityTestRule(IntroActivity::class.java, true, false)
+
+    @Before
+    fun clearData() {
+        val editor =
+                getInstrumentation().targetContext
+                        .getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
+                        .edit()
+        editor.clear()
+        editor.commit()
+
+        Intents.init()
+    }
+
+    @Test
+    fun nextEachTimes() {
+
+        rule.launchActivity(Intent())
+
+        onView(withText(R.string.intro_hello_title)).check(matches(isDisplayed()))
+        onView(withId(R.id.button_next)).perform(click())
+        onView(withText(R.string.intro_needs_selfoss_message)).check(matches(isDisplayed()))
+        onView(withId(R.id.button_next)).perform(click())
+        onView(withText(R.string.intro_all_set_message)).check(matches(isDisplayed()))
+        onView(withId(R.id.button_next)).perform(click())
+
+        intended(hasComponent(IntroActivity::class.java.name), times(1))
+        intended(hasComponent(LoginActivity::class.java.name), times(1))
+    }
+
+    @Test
+    fun nextBackRandomTimes() {
+        val max = 5
+        val min = 1
+
+        val random = (Random().nextInt(max + 1 - min)) + min
+
+        rule.launchActivity(Intent())
+
+        onView(withText(R.string.intro_hello_title)).check(matches(isDisplayed()))
+        onView(withId(R.id.button_next)).perform(click())
+
+        repeat(random) { _ ->
+            onView(withText(R.string.intro_needs_selfoss_message)).check(matches(isDisplayed()))
+            onView(withId(R.id.button_next)).perform(click())
+            onView(withText(R.string.intro_all_set_message)).check(matches(isDisplayed()))
+            onView(withId(R.id.button_back)).perform(click())
+        }
+
+        onView(withId(R.id.button_next)).perform(click())
+        onView(withText(R.string.intro_all_set_message)).check(matches(isDisplayed()))
+        onView(withId(R.id.button_next)).perform(click())
+
+        intended(hasComponent(IntroActivity::class.java.name), times(1))
+        intended(hasComponent(LoginActivity::class.java.name), times(1))
+    }
+
+    @After
+    fun releaseIntents() {
+        Intents.release()
+    }
+}

app/src/androidTest/java/apps/amine/bou/readerforselfoss/MainActivityEspressoTest.kt

@@ -45,6 +45,7 @@ class MainActivityEspressoTest {
         rule.launchActivity(intent)
 
         intended(hasComponent(MainActivity::class.java.name))
+        intended(hasComponent(IntroActivity::class.java.name))
         intended(hasComponent(LoginActivity::class.java.name), times(0))
     }
 
@@ -57,6 +58,7 @@ class MainActivityEspressoTest {
 
         intended(hasComponent(MainActivity::class.java.name))
         intended(hasComponent(LoginActivity::class.java.name))
+        intended(hasComponent(IntroActivity::class.java.name), times(0))
     }
 
     @After

app/src/main/AndroidManifest.xml

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="apps.amine.bou.readerforselfoss">
+    package="apps.amine.bou.readerforselfoss"
+    xmlns:tools="http://schemas.android.com/tools">
 
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.INTERNET" />
 
     <application
@@ -11,19 +11,19 @@
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:supportsRtl="true"
-        android:networkSecurityConfig="@xml/network_security_config"
         android:theme="@style/NoBar">
         <activity
             android:name=".MainActivity"
             android:theme="@style/SplashTheme">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
-
+        </activity>
-            <meta-data
+        <activity
-                android:name="android.app.shortcuts"
+            android:name=".IntroActivity"
-                android:resource="@xml/shortcuts" />
+            android:theme="@style/Theme.Intro">
         </activity>
         <activity
             android:name=".LoginActivity"
@@ -37,7 +37,7 @@
             android:parentActivityName=".HomeActivity">
             <meta-data
                 android:name="android.support.PARENT_ACTIVITY"
-                android:value=".HomeActivity" />
+                android:value="apps.amine.bou.readerforselfoss.HomeActivity" />
         </activity>
         <activity
             android:name=".SourcesActivity"
@@ -55,16 +55,15 @@
 
             <intent-filter>
                 <action android:name="android.intent.action.SEND" />
+
                 <category android:name="android.intent.category.DEFAULT" />
+
                 <data android:mimeType="text/plain" />
             </intent-filter>
         </activity>
         <activity
             android:name=".ReaderActivity">
         </activity>
-        <activity
-            android:name=".ImageActivity">
-        </activity>
 
         <meta-data
             android:name="apps.amine.bou.readerforselfoss.utils.glide.SelfSignedGlideModule"
@@ -77,9 +76,6 @@
             android:value="true" />
 
         <meta-data android:name="android.max_aspect" android:value="2.1" />
-        <meta-data
-            android:name="preloaded_fonts"
-            android:resource="@array/preloaded_fonts" />
     </application>
 
 </manifest>

app/src/main/java/apps/amine/bou/readerforselfoss/AddSourceActivity.kt

@@ -1,6 +1,5 @@
 package apps.amine.bou.readerforselfoss
 
-import android.content.Context
 import android.content.Intent
 import android.os.Build
 import android.os.Bundle
@@ -27,9 +26,8 @@ import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
 import android.graphics.PorterDuff
-import apps.amine.bou.readerforselfoss.databinding.ActivityAddSourceBinding
+import androidx.appcompat.widget.Toolbar
-
+import kotlinx.android.synthetic.main.activity_add_source.*
-
 
 class AddSourceActivity : AppCompatActivity() {
 
@@ -37,76 +35,71 @@ class AddSourceActivity : AppCompatActivity() {
     private lateinit var api: SelfossApi
 
     private lateinit var appColors: AppColors
-    private lateinit var binding: ActivityAddSourceBinding
 
     override fun onCreate(savedInstanceState: Bundle?) {
         appColors = AppColors(this@AddSourceActivity)
 
         super.onCreate(savedInstanceState)
-        binding = ActivityAddSourceBinding.inflate(layoutInflater)
-        val view = binding.root
 
-        setContentView(view)
+        setContentView(R.layout.activity_add_source)
 
         val scoop = Scoop.getInstance()
-        scoop.bind(this, Toppings.PRIMARY.value, binding.toolbar)
+        scoop.bind(this, Toppings.PRIMARY.value, toolbar)
         if  (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
             scoop.bindStatusBar(this, Toppings.PRIMARY_DARK.value)
         }
 
-        val drawable = binding.nameInput.background
+        val drawable = nameInput.background
         drawable.setColorFilter(appColors.colorAccent, PorterDuff.Mode.SRC_ATOP)
 
 
         // TODO: clean
         if(Build.VERSION.SDK_INT > 16) {
-            binding.nameInput.background = drawable
+            nameInput.background = drawable
         } else{
-            binding.nameInput.setBackgroundDrawable(drawable)
+            nameInput.setBackgroundDrawable(drawable)
         }
 
-        val drawable1 = binding.sourceUri.background
+        val drawable1 = sourceUri.background
         drawable1.setColorFilter(appColors.colorAccent, PorterDuff.Mode.SRC_ATOP)
 
         if(Build.VERSION.SDK_INT > 16) {
-            binding.sourceUri.background = drawable1
+            sourceUri.background = drawable1
         } else{
-            binding.sourceUri.setBackgroundDrawable(drawable1)
+            sourceUri.setBackgroundDrawable(drawable1)
         }
 
-        val drawable2 = binding.tags.background
+        val drawable2 = tags.background
         drawable2.setColorFilter(appColors.colorAccent, PorterDuff.Mode.SRC_ATOP)
 
         if(Build.VERSION.SDK_INT > 16) {
-            binding.tags.background = drawable2
+            tags.background = drawable2
         } else{
-            binding.tags.setBackgroundDrawable(drawable2)
+            tags.setBackgroundDrawable(drawable2)
         }
 
-        setSupportActionBar(binding.toolbar)
+        setSupportActionBar(toolbar)
         supportActionBar?.setDisplayHomeAsUpEnabled(true)
         supportActionBar?.setDisplayShowHomeEnabled(true)
 
         try {
             val prefs = PreferenceManager.getDefaultSharedPreferences(this)
-            val settings =
-                getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
             api = SelfossApi(
                 this,
                 this@AddSourceActivity,
-                settings.getBoolean("isSelfSignedCert", false),
+                prefs.getBoolean("isSelfSignedCert", false),
-                prefs.getString("api_timeout", "-1")!!.toLong()
+                prefs.getBoolean("should_log_everything", false)
             )
         } catch (e: IllegalArgumentException) {
             mustLoginToAddSource()
         }
 
-        maybeGetDetailsFromIntentSharing(intent, binding.sourceUri, binding.nameInput)
+        maybeGetDetailsFromIntentSharing(intent, sourceUri, nameInput)
 
-        binding.saveBtn.setTextColor(appColors.colorAccent)
+        saveBtn.setTextColor(appColors.colorAccent)
 
-        binding.saveBtn.setOnClickListener {
+        saveBtn.setOnClickListener {
-            handleSaveSource(binding.tags, binding.nameInput.text.toString(), binding.sourceUri.text.toString(), api)
+            handleSaveSource(tags, nameInput.text.toString(), sourceUri.text.toString(), api!!)
         }
     }
 
@@ -114,10 +107,10 @@ class AddSourceActivity : AppCompatActivity() {
         super.onResume()
         val config = Config(this)
 
-        if (config.baseUrl.isEmpty() || !config.baseUrl.isBaseUrlValid(this@AddSourceActivity)) {
+        if (config.baseUrl.isEmpty() || !config.baseUrl.isBaseUrlValid()) {
             mustLoginToAddSource()
         } else {
-            handleSpoutsSpinner(binding.spoutsSpinner, api, binding.progress, binding.formContainer)
+            handleSpoutsSpinner(spoutsSpinner, api, progress, formContainer)
         }
     }
 

app/src/main/java/apps/amine/bou/readerforselfoss/ImageActivity.kt

@@ -1,56 +0,0 @@
-package apps.amine.bou.readerforselfoss
-
-import android.os.Bundle
-import android.view.MenuItem
-import androidx.appcompat.app.AppCompatActivity
-import androidx.fragment.app.FragmentManager
-import androidx.fragment.app.FragmentStatePagerAdapter
-import apps.amine.bou.readerforselfoss.databinding.ActivityImageBinding
-import apps.amine.bou.readerforselfoss.fragments.ImageFragment
-
-class ImageActivity : AppCompatActivity() {
-    private lateinit var allImages : ArrayList<String>
-    private var position : Int = 0
-
-    private lateinit var binding: ActivityImageBinding
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        binding = ActivityImageBinding.inflate(layoutInflater)
-        val view = binding.root
-
-        setContentView(view)
-
-        setSupportActionBar(binding.toolBar)
-        supportActionBar?.setDisplayShowTitleEnabled(false)
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
-
-        allImages = intent.getStringArrayListExtra("allImages") as ArrayList<String>
-        position = intent.getIntExtra("position", 0)
-
-        binding.pager.adapter = ScreenSlidePagerAdapter(supportFragmentManager)
-        binding.pager.currentItem = position
-    }
-
-    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        when (item.itemId) {
-            android.R.id.home -> {
-                onBackPressed()
-                return true
-            }
-        }
-
-        return super.onOptionsItemSelected(item)
-    }
-
-    private inner class ScreenSlidePagerAdapter(fm: FragmentManager) : FragmentStatePagerAdapter(fm, FragmentStatePagerAdapter.BEHAVIOR_RESUME_ONLY_CURRENT_FRAGMENT) {
-
-        override fun getCount(): Int {
-            return allImages.size
-        }
-
-        override fun getItem(position: Int): ImageFragment {
-            return ImageFragment.newInstance(allImages[position])
-        }
-    }
-}

app/src/main/java/apps/amine/bou/readerforselfoss/IntroActivity.kt

@@ -0,0 +1,70 @@
+package apps.amine.bou.readerforselfoss
+
+import agency.tango.materialintroscreen.MaterialIntroActivity
+import agency.tango.materialintroscreen.MessageButtonBehaviour
+import agency.tango.materialintroscreen.SlideFragmentBuilder
+import android.content.Intent
+import android.net.Uri
+import android.os.Bundle
+import android.preference.PreferenceManager
+import android.view.View
+import androidx.appcompat.app.AppCompatDelegate
+
+class IntroActivity : MaterialIntroActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        AppCompatDelegate.setCompatVectorFromResourcesEnabled(true)
+
+        addSlide(
+            SlideFragmentBuilder()
+                .backgroundColor(R.color.colorPrimary)
+                .buttonsColor(R.color.colorAccent)
+                .image(R.drawable.web_hi_res_512)
+                .title(getString(R.string.intro_hello_title))
+                .description(getString(R.string.intro_hello_message))
+                .build()
+        )
+
+        addSlide(
+            SlideFragmentBuilder()
+                .backgroundColor(R.color.colorAccent)
+                .buttonsColor(R.color.colorPrimary)
+                .image(R.drawable.ic_info_outline_white_48px)
+                .title(getString(R.string.intro_needs_selfoss_title))
+                .description(getString(R.string.intro_needs_selfoss_message))
+                .build(),
+            MessageButtonBehaviour(
+                View.OnClickListener {
+                    val browserIntent = Intent(
+                        Intent.ACTION_VIEW,
+                        Uri.parse("https://selfoss.aditu.de")
+                    )
+                    startActivity(browserIntent)
+                }, getString(R.string.intro_needs_selfoss_link)
+            )
+        )
+
+        addSlide(
+            SlideFragmentBuilder()
+                .backgroundColor(R.color.colorPrimaryDark)
+                .buttonsColor(R.color.colorAccentDark)
+                .image(R.drawable.ic_thumb_up_white_48px)
+                .title(getString(R.string.intro_all_set_title))
+                .description(getString(R.string.intro_all_set_message))
+                .build()
+        )
+    }
+
+    override fun onFinish() {
+        super.onFinish()
+        val getPrefs = PreferenceManager.getDefaultSharedPreferences(baseContext)
+        val e = getPrefs.edit()
+        e.putBoolean("firstStart", false)
+        e.apply()
+        val intent = Intent(this, LoginActivity::class.java)
+        startActivity(intent)
+        finish()
+    }
+}

app/src/main/java/apps/amine/bou/readerforselfoss/LoginActivity.kt

@@ -17,13 +17,14 @@ import android.widget.TextView
 import android.widget.Toast
 import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
 import apps.amine.bou.readerforselfoss.api.selfoss.SuccessResponse
-import apps.amine.bou.readerforselfoss.databinding.ActivityLoginBinding
 import apps.amine.bou.readerforselfoss.themes.AppColors
 import apps.amine.bou.readerforselfoss.utils.Config
 import apps.amine.bou.readerforselfoss.utils.isBaseUrlValid
-import apps.amine.bou.readerforselfoss.utils.network.isNetworkAccessible
+import apps.amine.bou.readerforselfoss.utils.maybeHandleSilentException
 import com.mikepenz.aboutlibraries.Libs
 import com.mikepenz.aboutlibraries.LibsBuilder
+import kotlinx.android.synthetic.main.activity_login.*
+import org.acra.ACRA
 import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
@@ -38,28 +39,28 @@ class LoginActivity : AppCompatActivity() {
     private lateinit var settings: SharedPreferences
     private lateinit var editor: SharedPreferences.Editor
     private lateinit var userIdentifier: String
+    private var logErrors: Boolean = false
     private lateinit var appColors: AppColors
-    private lateinit var binding: ActivityLoginBinding
 
     override fun onCreate(savedInstanceState: Bundle?) {
         appColors = AppColors(this@LoginActivity)
 
         super.onCreate(savedInstanceState)
-        binding = ActivityLoginBinding.inflate(layoutInflater)
-        val view = binding.root
 
-        setContentView(view)
+        setContentView(R.layout.activity_login)
 
-        setSupportActionBar(binding.toolbar)
+        setSupportActionBar(toolbar)
 
         handleBaseUrlFail()
 
+
         settings = getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
-        userIdentifier = settings.getString("unique_id", "")!!
+        userIdentifier = settings.getString("unique_id", "")
+        logErrors = settings.getBoolean("login_debug", false)
 
         editor = settings.edit()
 
-        if (settings.getString("url", "")!!.isNotEmpty()) {
+        if (settings.getString("url", "").isNotEmpty()) {
             goToMain()
         }
 
@@ -68,14 +69,14 @@ class LoginActivity : AppCompatActivity() {
 
     private fun handleActions() {
 
-        binding.withSelfhostedCert.setOnCheckedChangeListener { _, b ->
+        withSelfhostedCert.setOnCheckedChangeListener { _, b ->
             isWithSelfSignedCert = !isWithSelfSignedCert
             val visi: Int = if (b) View.VISIBLE else View.GONE
 
-            binding.warningText.visibility = visi
+            warningText.visibility = visi
         }
 
-        binding.passwordView.setOnEditorActionListener(
+        passwordView.setOnEditorActionListener(
             TextView.OnEditorActionListener { _, id, _ ->
                 if (id == R.id.loginView || id == EditorInfo.IME_NULL) {
                     attemptLogin()
@@ -85,22 +86,22 @@ class LoginActivity : AppCompatActivity() {
             }
         )
 
-        binding.signInButton.setOnClickListener { attemptLogin() }
+        signInButton.setOnClickListener { attemptLogin() }
 
-        binding.withLogin.setOnCheckedChangeListener { _, b ->
+        withLogin.setOnCheckedChangeListener { _, b ->
             isWithLogin = !isWithLogin
             val visi: Int = if (b) View.VISIBLE else View.GONE
 
-            binding.loginLayout.visibility = visi
+            loginLayout.visibility = visi
-            binding.passwordLayout.visibility = visi
+            passwordLayout.visibility = visi
         }
 
-        binding.withHttpLogin.setOnCheckedChangeListener { _, b ->
+        withHttpLogin.setOnCheckedChangeListener { _, b ->
             isWithHTTPLogin = !isWithHTTPLogin
             val visi: Int = if (b) View.VISIBLE else View.GONE
 
-            binding.httpLoginInput.visibility = visi
+            httpLoginInput.visibility = visi
-            binding.httpPasswordInput.visibility = visi
+            httpPasswordInput.visibility = visi
         }
     }
 
@@ -111,9 +112,8 @@ class LoginActivity : AppCompatActivity() {
             alertDialog.setMessage(getString(R.string.base_url_error))
             alertDialog.setButton(
                 AlertDialog.BUTTON_NEUTRAL,
-                "OK",
+                "OK"
-                { dialog, _ -> dialog.dismiss() }
+            ) { dialog, _ -> dialog.dismiss() }
-            )
             alertDialog.show()
         }
     }
@@ -127,25 +127,25 @@ class LoginActivity : AppCompatActivity() {
     private fun attemptLogin() {
 
         // Reset errors.
-        binding.urlView.error = null
+        urlView.error = null
-        binding.loginView.error = null
+        loginView.error = null
-        binding.httpLoginView.error = null
+        httpLoginView.error = null
-        binding.passwordView.error = null
+        passwordView.error = null
-        binding.httpPasswordView.error = null
+        httpPasswordView.error = null
 
         // Store values at the time of the login attempt.
-        val url = binding.urlView.text.toString()
+        val url = urlView.text.toString()
-        val login = binding.loginView.text.toString()
+        val login = loginView.text.toString()
-        val httpLogin = binding.httpLoginView.text.toString()
+        val httpLogin = httpLoginView.text.toString()
-        val password = binding.passwordView.text.toString()
+        val password = passwordView.text.toString()
-        val httpPassword = binding.httpPasswordView.text.toString()
+        val httpPassword = httpPasswordView.text.toString()
 
         var cancel = false
         var focusView: View? = null
 
-        if (!url.isBaseUrlValid(this@LoginActivity)) {
+        if (!url.isBaseUrlValid()) {
-            binding.urlView.error = getString(R.string.login_url_problem)
+            urlView.error = getString(R.string.login_url_problem)
-            focusView = binding.urlView
+            focusView = urlView
             cancel = true
             inValidCount++
             if (inValidCount == 3) {
@@ -154,38 +154,23 @@ class LoginActivity : AppCompatActivity() {
                 alertDialog.setMessage(getString(R.string.text_wrong_url))
                 alertDialog.setButton(
                     AlertDialog.BUTTON_NEUTRAL,
-                    "OK",
+                    "OK"
-                    { dialog, _ -> dialog.dismiss() }
+                ) { dialog, _ -> dialog.dismiss() }
-                )
                 alertDialog.show()
                 inValidCount = 0
             }
         }
 
-        if (isWithLogin) {
+        if (isWithLogin || isWithHTTPLogin) {
             if (TextUtils.isEmpty(password)) {
-                binding.passwordView.error = getString(R.string.error_invalid_password)
+                passwordView.error = getString(R.string.error_invalid_password)
-                focusView = binding.passwordView
+                focusView = passwordView
                 cancel = true
             }
 
             if (TextUtils.isEmpty(login)) {
-                binding.loginView.error = getString(R.string.error_field_required)
+                loginView.error = getString(R.string.error_field_required)
-                focusView = binding.loginView
+                focusView = loginView
-                cancel = true
-            }
-        }
-
-        if (isWithHTTPLogin) {
-            if (TextUtils.isEmpty(httpPassword)) {
-                binding.httpPasswordView.error = getString(R.string.error_invalid_password)
-                focusView = binding.httpPasswordView
-                cancel = true
-            }
-
-            if (TextUtils.isEmpty(httpLogin)) {
-                binding.httpLoginView.error = getString(R.string.error_field_required)
-                focusView = binding.httpLoginView
                 cancel = true
             }
         }
@@ -207,72 +192,75 @@ class LoginActivity : AppCompatActivity() {
                 this,
                 this@LoginActivity,
                 isWithSelfSignedCert,
-                -1L
+                isWithSelfSignedCert
             )
-
+            api.login().enqueue(object : Callback<SuccessResponse> {
-            if (this@LoginActivity.isNetworkAccessible(this@LoginActivity.findViewById(R.id.loginForm))) {
+                private fun preferenceError(t: Throwable) {
-                api.login().enqueue(object : Callback<SuccessResponse> {
+                    editor.remove("url")
-                    private fun preferenceError(t: Throwable) {
+                    editor.remove("login")
-                        editor.remove("url")
+                    editor.remove("httpUserName")
-                        editor.remove("login")
+                    editor.remove("password")
-                        editor.remove("httpUserName")
+                    editor.remove("httpPassword")
-                        editor.remove("password")
+                    editor.apply()
-                        editor.remove("httpPassword")
+                    urlView.error = getString(R.string.wrong_infos)
-                        editor.apply()
+                    loginView.error = getString(R.string.wrong_infos)
-                        binding.urlView.error = getString(R.string.wrong_infos)
+                    passwordView.error = getString(R.string.wrong_infos)
-                        binding.loginView.error = getString(R.string.wrong_infos)
+                    httpLoginView.error = getString(R.string.wrong_infos)
-                        binding.passwordView.error = getString(R.string.wrong_infos)
+                    httpPasswordView.error = getString(R.string.wrong_infos)
-                        binding.httpLoginView.error = getString(R.string.wrong_infos)
+                    if (logErrors) {
-                        binding.httpPasswordView.error = getString(R.string.wrong_infos)
+                        ACRA.getErrorReporter().maybeHandleSilentException(t, this@LoginActivity)
-                        showProgress(false)
+                        Toast.makeText(
+                            this@LoginActivity,
+                            t.message,
+                            Toast.LENGTH_LONG
+                        ).show()
                     }
+                    showProgress(false)
+                }
 
-                    override fun onResponse(
+                override fun onResponse(
-                        call: Call<SuccessResponse>,
+                    call: Call<SuccessResponse>,
-                        response: Response<SuccessResponse>
+                    response: Response<SuccessResponse>
-                    ) {
+                ) {
-                        if (response.body() != null && response.body()!!.isSuccess) {
+                    if (response.body() != null && response.body()!!.isSuccess) {
-                            goToMain()
+                        goToMain()
-                        } else {
+                    } else {
-                            preferenceError(Exception("No response body..."))
+                        preferenceError(Exception("No response body..."))
-                        }
                     }
+                }
 
-                    override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
+                override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
-                        preferenceError(t)
+                    preferenceError(t)
-                    }
+                }
-                })
+            })
-            } else {
-                showProgress(false)
-            }
         }
     }
 
     private fun showProgress(show: Boolean) {
         val shortAnimTime = resources.getInteger(android.R.integer.config_shortAnimTime)
 
-        binding.loginForm.visibility = if (show) View.GONE else View.VISIBLE
+        loginForm.visibility = if (show) View.GONE else View.VISIBLE
-        binding.loginForm
+        loginForm
             .animate()
             .setDuration(shortAnimTime.toLong())
             .alpha(
                 if (show) 0F else 1F
             ).setListener(object : AnimatorListenerAdapter() {
             override fun onAnimationEnd(animation: Animator) {
-                binding.loginForm.visibility = if (show) View.GONE else View.VISIBLE
+                loginForm.visibility = if (show) View.GONE else View.VISIBLE
             }
         }
         )
 
-        binding.loginProgress.visibility = if (show) View.VISIBLE else View.GONE
+        loginProgress.visibility = if (show) View.VISIBLE else View.GONE
-        binding.loginProgress
+        loginProgress
             .animate()
             .setDuration(shortAnimTime.toLong())
             .alpha(
                 if (show) 1F else 0F
             ).setListener(object : AnimatorListenerAdapter() {
             override fun onAnimationEnd(animation: Animator) {
-                binding.loginProgress.visibility = if (show) View.VISIBLE else View.GONE
+                loginProgress.visibility = if (show) View.VISIBLE else View.GONE
             }
         }
         )
@@ -280,19 +268,29 @@ class LoginActivity : AppCompatActivity() {
 
     override fun onCreateOptionsMenu(menu: Menu): Boolean {
         menuInflater.inflate(R.menu.login_menu, menu)
+        menu.findItem(R.id.login_debug).isChecked = logErrors
         return true
     }
 
     override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        return when (item.itemId) {
+        when (item.itemId) {
             R.id.about -> {
                 LibsBuilder()
+                    .withActivityStyle(Libs.ActivityStyle.LIGHT_DARK_TOOLBAR)
                     .withAboutIconShown(true)
                     .withAboutVersionShown(true)
                     .start(this)
-                true
+                return true
             }
-            else -> super.onOptionsItemSelected(item)
+            R.id.login_debug -> {
+                val newState = !item.isChecked
+                item.isChecked = newState
+                logErrors = newState
+                editor.putBoolean("login_debug", newState)
+                editor.apply()
+                return true
+            }
+            else -> return super.onOptionsItemSelected(item)
         }
     }
 }

app/src/main/java/apps/amine/bou/readerforselfoss/MainActivity.kt

@@ -4,22 +4,24 @@ import android.content.Intent
 import android.os.Bundle
 import android.preference.PreferenceManager
 import androidx.appcompat.app.AppCompatActivity
-import apps.amine.bou.readerforselfoss.databinding.ActivityAddSourceBinding
-import apps.amine.bou.readerforselfoss.databinding.ActivityMainBinding
 
 class MainActivity : AppCompatActivity() {
-    private lateinit var binding: ActivityMainBinding
-
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivityMainBinding.inflate(layoutInflater)
+        setContentView(R.layout.activity_main)
-        val view = binding.root
-        setContentView(view)
 
-        val intent = Intent(this, LoginActivity::class.java)
+        if (PreferenceManager.getDefaultSharedPreferences(baseContext).getBoolean(
+                "firstStart",
+                true
+            )) {
+            val i = Intent(this@MainActivity, IntroActivity::class.java)
+            startActivity(i)
+        } else {
+            val intent = Intent(this, LoginActivity::class.java)
+            startActivity(intent)
+        }
 
-        startActivity(intent)
         finish()
     }
 }

app/src/main/java/apps/amine/bou/readerforselfoss/MyApp.kt

@@ -1,45 +1,58 @@
 package apps.amine.bou.readerforselfoss
 
-import android.app.NotificationChannel
-import android.app.NotificationManager
 import android.content.Context
 import android.content.SharedPreferences
 import android.graphics.drawable.Drawable
 import android.net.Uri
-import android.os.Build
 import android.preference.PreferenceManager
 import android.widget.ImageView
 import androidx.multidex.MultiDexApplication
-import apps.amine.bou.readerforselfoss.api.selfoss.ApiVersion
-import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
 import apps.amine.bou.readerforselfoss.utils.Config
-import apps.amine.bou.readerforselfoss.utils.glide.loadMaybeBasicAuth
+import com.anupcowkur.reservoir.Reservoir
 import com.bumptech.glide.Glide
 import com.bumptech.glide.request.RequestOptions
 import com.ftinc.scoop.Scoop
+import com.github.stkent.amplify.feedback.DefaultEmailFeedbackCollector
+import com.github.stkent.amplify.feedback.GooglePlayStoreFeedbackCollector
+import com.github.stkent.amplify.tracking.Amplify
 import com.mikepenz.materialdrawer.util.AbstractDrawerImageLoader
 import com.mikepenz.materialdrawer.util.DrawerImageLoader
-import retrofit2.Call
+import org.acra.ACRA
-import retrofit2.Callback
+import org.acra.ReportField
-import retrofit2.Response
+import org.acra.annotation.AcraCore
+import org.acra.annotation.AcraDialog
+import org.acra.annotation.AcraHttpSender
+import org.acra.sender.HttpSender
+import java.io.IOException
 import java.util.UUID.randomUUID
 
-var dateTimeFormatter = "yyyy-MM-dd HH:mm:ss"
 
+@AcraHttpSender(uri = "http://amine-bou.fr:5984/acra-selfoss/_design/acra-storage/_update/report",
+                basicAuthLogin = "selfoss",
+                basicAuthPassword = "selfoss",
+                httpMethod = HttpSender.Method.PUT)
+@AcraDialog(resText = R.string.crash_dialog_text,
+            resCommentPrompt = R.string.crash_dialog_comment,
+            resTheme = android.R.style.Theme_DeviceDefault_Dialog)
+@AcraCore(reportContent = [ReportField.REPORT_ID, ReportField.INSTALLATION_ID,
+    ReportField.APP_VERSION_CODE, ReportField.APP_VERSION_NAME,
+    ReportField.BUILD, ReportField.ANDROID_VERSION, ReportField.BRAND, ReportField.PHONE_MODEL,
+    ReportField.AVAILABLE_MEM_SIZE, ReportField.TOTAL_MEM_SIZE,
+    ReportField.STACK_TRACE, ReportField.APPLICATION_LOG, ReportField.LOGCAT,
+    ReportField.INITIAL_CONFIGURATION, ReportField.CRASH_CONFIGURATION, ReportField.IS_SILENT,
+    ReportField.USER_APP_START_DATE, ReportField.USER_COMMENT, ReportField.USER_CRASH_DATE, ReportField.USER_EMAIL, ReportField.CUSTOM_DATA],
+          buildConfigClass = BuildConfig::class)
 class MyApp : MultiDexApplication() {
-    private lateinit var config: Config
-    private lateinit var api: SelfossApi
-    private lateinit var settings: SharedPreferences
-    private lateinit var sharedPref: SharedPreferences
-
-    private var apiVersionMajor: Int = 0
 
     override fun onCreate() {
         super.onCreate()
-        config = Config(baseContext)
+
+        initAmplify()
+
+        initCache()
 
         val prefs = getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
-        if (prefs.getString("unique_id", "")!!.isEmpty()) {
+        if (prefs.getString("unique_id", "").isEmpty()) {
             val editor = prefs.edit()
             editor.putString("unique_id", randomUUID().toString())
             editor.apply()
@@ -50,37 +63,28 @@ class MyApp : MultiDexApplication() {
         initTheme()
 
         tryToHandleBug()
-
-        handleNotificationChannels()
-
-        sharedPref = PreferenceManager.getDefaultSharedPreferences(this)
-        apiVersionMajor = sharedPref.getInt("apiVersionMajor", 0)
-        settings = getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
-
-        api = SelfossApi(
-                this,
-                null,
-                settings.getBoolean("isSelfSignedCert", false),
-                sharedPref.getString("api_timeout", "-1")!!.toLong()
-        )
-
-        getApiMajorVersion()
     }
 
-    private fun handleNotificationChannels() {
+    override fun attachBaseContext(base: Context?) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        super.attachBaseContext(base)
-            val notificationManager = getSystemService(NOTIFICATION_SERVICE) as NotificationManager
+        val prefs = getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
+        ACRA.init(this)
+        ACRA.getErrorReporter().putCustomData("unique_id", prefs.getString("unique_id", ""))
 
-            val name = getString(R.string.notification_channel_sync)
+    }
-            val importance = NotificationManager.IMPORTANCE_LOW
-            val mChannel = NotificationChannel(Config.syncChannelId, name, importance)
 
-            val newItemsChannelname = getString(R.string.new_items_channel_sync)
+    private fun initAmplify() {
-            val newItemsChannelimportance = NotificationManager.IMPORTANCE_DEFAULT
+        Amplify.initSharedInstance(this)
-            val newItemsChannelmChannel = NotificationChannel(Config.newItemsChannelId, newItemsChannelname, newItemsChannelimportance)
+            .setPositiveFeedbackCollectors(GooglePlayStoreFeedbackCollector())
+            .setCriticalFeedbackCollectors(DefaultEmailFeedbackCollector(Config.feedbackEmail))
+            .applyAllDefaultRules()
+    }
 
-            notificationManager.createNotificationChannel(mChannel)
+    private fun initCache() {
-            notificationManager.createNotificationChannel(newItemsChannelmChannel)
+        try {
+            Reservoir.init(this, 8192) //in bytes
+        } catch (e: IOException) {
+            //failure
         }
     }
 
@@ -93,7 +97,7 @@ class MyApp : MultiDexApplication() {
                 tag: String?
             ) {
                 Glide.with(imageView?.context)
-                    .loadMaybeBasicAuth(config, uri.toString())
+                    .load(uri)
                     .apply(RequestOptions.fitCenterTransform().placeholder(placeholder))
                     .into(imageView)
             }
@@ -129,24 +133,4 @@ class MyApp : MultiDexApplication() {
             }
         }
     }
-
-    private fun getApiMajorVersion() {
-        api.apiVersion.enqueue(object : Callback<ApiVersion> {
-            override fun onFailure(call: Call<ApiVersion>, t: Throwable) {
-                if (apiVersionMajor >= 4) {
-                    dateTimeFormatter = "yyyy-MM-dd'T'HH:mm:ssXXX"
-                }
-            }
-
-            override fun onResponse(call: Call<ApiVersion>, response: Response<ApiVersion>) {
-                val version = response.body() as ApiVersion
-                apiVersionMajor = version.getApiMajorVersion()
-                sharedPref.edit().putInt("apiVersionMajor", apiVersionMajor).commit()
-
-                if (apiVersionMajor >= 4) {
-                    dateTimeFormatter = "yyyy-MM-dd'T'HH:mm:ssXXX"
-                }
-            }
-        })
-    }
 }

app/src/main/java/apps/amine/bou/readerforselfoss/ReaderActivity.kt

@@ -1,7 +1,5 @@
 package apps.amine.bou.readerforselfoss
 
-import android.content.Context
-import android.content.SharedPreferences
 import android.graphics.drawable.ColorDrawable
 import android.os.Build
 import android.os.Bundle
@@ -15,37 +13,28 @@ import android.view.Menu
 import android.view.MenuItem
 import android.view.ViewGroup
 import android.widget.Toast
-import androidx.fragment.app.Fragment
-import androidx.room.Room
 import apps.amine.bou.readerforselfoss.api.selfoss.Item
 import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
 import apps.amine.bou.readerforselfoss.api.selfoss.SuccessResponse
-import apps.amine.bou.readerforselfoss.databinding.ActivityImageBinding
-import apps.amine.bou.readerforselfoss.databinding.ActivityReaderBinding
 import apps.amine.bou.readerforselfoss.fragments.ArticleFragment
-import apps.amine.bou.readerforselfoss.persistence.database.AppDatabase
-import apps.amine.bou.readerforselfoss.persistence.entities.ActionEntity
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_1_2
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_2_3
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_3_4
 import apps.amine.bou.readerforselfoss.themes.AppColors
 import apps.amine.bou.readerforselfoss.themes.Toppings
 import apps.amine.bou.readerforselfoss.transformers.DepthPageTransformer
-import apps.amine.bou.readerforselfoss.utils.Config
+import apps.amine.bou.readerforselfoss.utils.maybeHandleSilentException
-import apps.amine.bou.readerforselfoss.utils.network.isNetworkAccessible
-import apps.amine.bou.readerforselfoss.utils.persistence.toEntity
 import apps.amine.bou.readerforselfoss.utils.succeeded
 import apps.amine.bou.readerforselfoss.utils.toggleStar
 import com.ftinc.scoop.Scoop
+import kotlinx.android.synthetic.main.activity_reader.*
 import me.relex.circleindicator.CircleIndicator
+import org.acra.ACRA
 import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
-import kotlin.concurrent.thread
 
 class ReaderActivity : AppCompatActivity() {
 
     private var markOnScroll: Boolean = false
+    private var debugReadingItems: Boolean = false
     private var currentItem: Int = 0
     private lateinit var userIdentifier: String
 
@@ -53,14 +42,6 @@ class ReaderActivity : AppCompatActivity() {
 
     private lateinit var toolbarMenu: Menu
 
-    private lateinit var db: AppDatabase
-    private lateinit var prefs: SharedPreferences
-    private lateinit var binding: ActivityReaderBinding
-
-    private var activeAlignment: Int = 1
-    val JUSTIFY = 1
-    val ALIGN_LEFT = 2
-
     private fun showMenuItem(willAddToFavorite: Boolean) {
         toolbarMenu.findItem(R.id.save).isVisible = willAddToFavorite
         toolbarMenu.findItem(R.id.unsave).isVisible = !willAddToFavorite
@@ -74,45 +55,32 @@ class ReaderActivity : AppCompatActivity() {
         showMenuItem(false)
     }
 
-    private lateinit var editor: SharedPreferences.Editor
-
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        binding = ActivityReaderBinding.inflate(layoutInflater)
-        val view = binding.root
 
-        setContentView(view)
+        setContentView(R.layout.activity_reader)
-
-        db = Room.databaseBuilder(
-            applicationContext,
-            AppDatabase::class.java, "selfoss-database"
-        ).addMigrations(MIGRATION_1_2).addMigrations(MIGRATION_2_3).addMigrations(MIGRATION_3_4).build()
 
         val scoop = Scoop.getInstance()
-        scoop.bind(this, Toppings.PRIMARY.value, binding.toolBar)
+        scoop.bind(this, Toppings.PRIMARY.value, toolBar)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+        if  (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
             scoop.bindStatusBar(this, Toppings.PRIMARY_DARK.value)
         }
 
-        setSupportActionBar(binding.toolBar)
+        setSupportActionBar(toolBar)
         supportActionBar?.setDisplayHomeAsUpEnabled(true)
         supportActionBar?.setDisplayShowHomeEnabled(true)
 
-        val settings =
+        val prefs = PreferenceManager.getDefaultSharedPreferences(this)
-            getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
 
-        prefs = PreferenceManager.getDefaultSharedPreferences(this)
+        debugReadingItems = prefs.getBoolean("read_debug", false)
-        editor = prefs.edit()
+        userIdentifier = prefs.getString("unique_id", "")
-
-        userIdentifier = prefs.getString("unique_id", "")!!
         markOnScroll = prefs.getBoolean("mark_on_scroll", false)
-        activeAlignment = prefs.getInt("text_align", JUSTIFY)
 
         api = SelfossApi(
             this,
             this@ReaderActivity,
-            settings.getBoolean("isSelfSignedCert", false),
+            prefs.getBoolean("isSelfSignedCert", false),
-            prefs.getString("api_timeout", "-1")!!.toLong()
+            prefs.getBoolean("should_log_everything", false)
         )
 
         if (allItems.isEmpty()) {
@@ -121,11 +89,10 @@ class ReaderActivity : AppCompatActivity() {
 
         currentItem = intent.getIntExtra("currentItem", 0)
 
-        readItem(allItems[currentItem])
+        readItem(allItems[currentItem].id)
 
-        binding.pager.adapter =
+        pager.adapter = ScreenSlidePagerAdapter(supportFragmentManager, AppColors(this@ReaderActivity))
-                ScreenSlidePagerAdapter(supportFragmentManager, AppColors(this@ReaderActivity))
+        pager.currentItem = currentItem
-        binding.pager.currentItem = currentItem
     }
 
     override fun onResume() {
@@ -133,10 +100,11 @@ class ReaderActivity : AppCompatActivity() {
 
         notifyAdapter()
 
-        binding.pager.setPageTransformer(true, DepthPageTransformer())
+        pager.setPageTransformer(true, DepthPageTransformer())
-        (binding.indicator as CircleIndicator).setViewPager(binding.pager)
+        // TODO: add back the page indicator
+        // (indicator as CircleIndicator).setViewPager(pager as android.support.v4.view.ViewPager)
 
-        binding.pager.addOnPageChangeListener(
+        pager.addOnPageChangeListener(
             object : ViewPager.SimpleOnPageChangeListener() {
 
                 override fun onPageSelected(position: Int) {
@@ -146,63 +114,67 @@ class ReaderActivity : AppCompatActivity() {
                     } else {
                         canFavorite()
                     }
-                    readItem(allItems[binding.pager.currentItem])
+                    readItem(allItems[pager.currentItem].id)
                 }
             }
         )
     }
 
-    fun readItem(item: Item) {
+    fun readItem(id: String) {
         if (markOnScroll) {
-            thread {
+            api.markItem(id).enqueue(
-                db.itemsDao().delete(item.toEntity())
+                object : Callback<SuccessResponse> {
-            }
+                    override fun onResponse(
-            if (this@ReaderActivity.isNetworkAccessible(this@ReaderActivity.findViewById(R.id.reader_activity_view))) {
+                        call: Call<SuccessResponse>,
-                api.markItem(item.id).enqueue(
+                        response: Response<SuccessResponse>
-                    object : Callback<SuccessResponse> {
+                    ) {
-                        override fun onResponse(
+                        if (!response.succeeded() && debugReadingItems) {
-                            call: Call<SuccessResponse>,
+                            val message =
-                            response: Response<SuccessResponse>
+                                "message: ${response.message()} " +
-                        ) {
+                                        "response isSuccess: ${response.isSuccessful} " +
-                        }
+                                        "response code: ${response.code()} " +
-
+                                        "response message: ${response.message()} " +
-                        override fun onFailure(
+                                        "response errorBody: ${response.errorBody()?.string()} " +
-                            call: Call<SuccessResponse>,
+                                        "body success: ${response.body()?.success} " +
-                            t: Throwable
+                                        "body isSuccess: ${response.body()?.isSuccess}"
-                        ) {
+                            ACRA.getErrorReporter()
-                            thread {
+                                .maybeHandleSilentException(Exception(message), this@ReaderActivity)
-                                db.itemsDao().insertAllItems(item.toEntity())
+                        }
-                            }
+                    }
+
+                    override fun onFailure(
+                        call: Call<SuccessResponse>,
+                        t: Throwable
+                    ) {
+                        if (debugReadingItems) {
+                            ACRA.getErrorReporter().maybeHandleSilentException(t, this@ReaderActivity)
                         }
                     }
-                )
-            } else {
-                thread {
-                    db.actionsDao().insertAllActions(ActionEntity(item.id, true, false, false, false))
                 }
-            }
+            )
         }
     }
 
     private fun notifyAdapter() {
-        (binding.pager.adapter as ScreenSlidePagerAdapter).notifyDataSetChanged()
+        (pager.adapter as ScreenSlidePagerAdapter).notifyDataSetChanged()
     }
 
     override fun onPause() {
         super.onPause()
         if (markOnScroll) {
-            binding.pager.clearOnPageChangeListeners()
+            pager.clearOnPageChangeListeners()
         }
     }
 
-    override fun onSaveInstanceState(oldInstanceState: Bundle) {
+    override fun onSaveInstanceState(oldInstanceState: Bundle?) {
         super.onSaveInstanceState(oldInstanceState)
-        oldInstanceState.clear()
+        oldInstanceState!!.clear()
     }
 
     private inner class ScreenSlidePagerAdapter(fm: FragmentManager, val appColors: AppColors) :
         FragmentStatePagerAdapter(fm) {
 
+
         override fun getCount(): Int {
             return allItems.size
         }
@@ -214,20 +186,10 @@ class ReaderActivity : AppCompatActivity() {
         override fun startUpdate(container: ViewGroup) {
             super.startUpdate(container)
 
-            container.background = ColorDrawable(
+            container.background = ColorDrawable(ContextCompat.getColor(this@ReaderActivity, appColors.colorBackground))
-                ContextCompat.getColor(
-                    this@ReaderActivity,
-                    appColors.colorBackground
-                )
-            )
         }
     }
 
-    fun alignmentMenu(showJustify: Boolean) {
-        toolbarMenu.findItem(R.id.align_left).isVisible = !showJustify
-        toolbarMenu.findItem(R.id.align_justify).isVisible = showJustify
-    }
-
     override fun onCreateOptionsMenu(menu: Menu): Boolean {
         val inflater = menuInflater
         inflater.inflate(R.menu.reader_menu, menu)
@@ -238,115 +200,68 @@ class ReaderActivity : AppCompatActivity() {
         } else {
             canFavorite()
         }
-        if (activeAlignment == JUSTIFY) {
-            alignmentMenu(false)
-        } else {
-            alignmentMenu(true)
-        }
 
         return true
     }
 
     override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        fun afterSave() {
-            allItems[binding.pager.currentItem] =
-                    allItems[binding.pager.currentItem].toggleStar()
-            notifyAdapter()
-            canRemoveFromFavorite()
-        }
-
-        fun afterUnsave() {
-            allItems[binding.pager.currentItem] = allItems[binding.pager.currentItem].toggleStar()
-            notifyAdapter()
-            canFavorite()
-        }
-
         when (item.itemId) {
             android.R.id.home -> {
                 onBackPressed()
                 return true
             }
             R.id.save -> {
-                if (this@ReaderActivity.isNetworkAccessible(null)) {
+                api.starrItem(allItems[pager.currentItem].id)
-                    api.starrItem(allItems[binding.pager.currentItem].id)
+                    .enqueue(object : Callback<SuccessResponse> {
-                        .enqueue(object : Callback<SuccessResponse> {
+                        override fun onResponse(
-                            override fun onResponse(
+                            call: Call<SuccessResponse>,
-                                call: Call<SuccessResponse>,
+                            response: Response<SuccessResponse>
-                                response: Response<SuccessResponse>
+                        ) {
-                            ) {
+                            allItems[pager.currentItem] = allItems[pager.currentItem].toggleStar()
-                                afterSave()
+                            notifyAdapter()
-                            }
+                            canRemoveFromFavorite()
+                        }
 
-                            override fun onFailure(
+                        override fun onFailure(
-                                call: Call<SuccessResponse>,
+                            call: Call<SuccessResponse>,
-                                t: Throwable
+                            t: Throwable
-                            ) {
+                        ) {
-                                Toast.makeText(
+                            Toast.makeText(
-                                    baseContext,
+                                baseContext,
-                                    R.string.cant_mark_favortie,
+                                R.string.cant_mark_favortie,
-                                    Toast.LENGTH_SHORT
+                                Toast.LENGTH_SHORT
-                                ).show()
+                            ).show()
-                            }
+                        }
-                        })
+                    })
-                } else {
-                    thread {
-                        db.actionsDao().insertAllActions(ActionEntity(allItems[binding.pager.currentItem].id, false, false, true, false))
-                        afterSave()
-                    }
-                }
             }
             R.id.unsave -> {
-                if (this@ReaderActivity.isNetworkAccessible(null)) {
+                api.unstarrItem(allItems[pager.currentItem].id)
-                    api.unstarrItem(allItems[binding.pager.currentItem].id)
+                    .enqueue(object : Callback<SuccessResponse> {
-                        .enqueue(object : Callback<SuccessResponse> {
+                        override fun onResponse(
-                            override fun onResponse(
+                            call: Call<SuccessResponse>,
-                                call: Call<SuccessResponse>,
+                            response: Response<SuccessResponse>
-                                response: Response<SuccessResponse>
+                        ) {
-                            ) {
+                            allItems[pager.currentItem] = allItems[pager.currentItem].toggleStar()
-                                afterUnsave()
+                            notifyAdapter()
-                            }
+                            canFavorite()
+                        }
 
-                            override fun onFailure(
+                        override fun onFailure(
-                                call: Call<SuccessResponse>,
+                            call: Call<SuccessResponse>,
-                                t: Throwable
+                            t: Throwable
-                            ) {
+                        ) {
-                                Toast.makeText(
+                            Toast.makeText(
-                                    baseContext,
+                                baseContext,
-                                    R.string.cant_unmark_favortie,
+                                R.string.cant_unmark_favortie,
-                                    Toast.LENGTH_SHORT
+                                Toast.LENGTH_SHORT
-                                ).show()
+                            ).show()
-                            }
+                        }
-                        })
+                    })
-                } else {
-                    thread {
-                        db.actionsDao().insertAllActions(ActionEntity(allItems[binding.pager.currentItem].id, false, false, false, true))
-                        afterUnsave()
-                    }
-                }
-            }
-            R.id.align_left -> {
-                editor.putInt("text_align", ALIGN_LEFT)
-                editor.apply()
-                alignmentMenu(true)
-                refreshFragment()
-            }
-            R.id.align_justify -> {
-                editor.putInt("text_align", JUSTIFY)
-                editor.apply()
-                alignmentMenu(false)
-                refreshFragment()
             }
         }
         return super.onOptionsItemSelected(item)
     }
 
-    private fun refreshFragment() {
-        finish()
-        overridePendingTransition(0, 0)
-        startActivity(intent)
-        overridePendingTransition(0, 0)
-    }
-
     companion object {
         var allItems: ArrayList<Item> = ArrayList()
     }

app/src/main/java/apps/amine/bou/readerforselfoss/SourcesActivity.kt

@@ -1,24 +1,20 @@
 package apps.amine.bou.readerforselfoss
 
-import android.content.Context
 import android.content.Intent
 import android.content.res.ColorStateList
 import android.os.Build
 import android.os.Bundle
 import android.preference.PreferenceManager
 import androidx.appcompat.app.AppCompatActivity
-import androidx.recyclerview.widget.LinearLayoutManager
 import android.widget.Toast
+import androidx.recyclerview.widget.LinearLayoutManager
 import apps.amine.bou.readerforselfoss.adapters.SourcesListAdapter
 import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
-import apps.amine.bou.readerforselfoss.api.selfoss.Source
+import apps.amine.bou.readerforselfoss.api.selfoss.Sources
-import apps.amine.bou.readerforselfoss.databinding.ActivityImageBinding
-import apps.amine.bou.readerforselfoss.databinding.ActivitySourcesBinding
 import apps.amine.bou.readerforselfoss.themes.AppColors
 import apps.amine.bou.readerforselfoss.themes.Toppings
-import apps.amine.bou.readerforselfoss.utils.Config
-import apps.amine.bou.readerforselfoss.utils.network.isNetworkAccessible
 import com.ftinc.scoop.Scoop
+import kotlinx.android.synthetic.main.activity_sources.*
 import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
@@ -26,87 +22,80 @@ import retrofit2.Response
 class SourcesActivity : AppCompatActivity() {
 
     private lateinit var appColors: AppColors
-    private lateinit var binding: ActivitySourcesBinding
 
     override fun onCreate(savedInstanceState: Bundle?) {
         appColors = AppColors(this@SourcesActivity)
 
         super.onCreate(savedInstanceState)
-        binding = ActivitySourcesBinding.inflate(layoutInflater)
-        val view = binding.root
 
-        setContentView(view)
+        setContentView(R.layout.activity_sources)
 
         val scoop = Scoop.getInstance()
-        scoop.bind(this, Toppings.PRIMARY.value, binding.toolbar)
+        scoop.bind(this, Toppings.PRIMARY.value, toolbar)
         if  (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
             scoop.bindStatusBar(this, Toppings.PRIMARY_DARK.value)
         }
 
-        setSupportActionBar(binding.toolbar)
+        setSupportActionBar(toolbar)
         supportActionBar?.setDisplayHomeAsUpEnabled(true)
         supportActionBar?.setDisplayShowHomeEnabled(true)
 
-        binding.fab.rippleColor = appColors.colorAccentDark
+        fab.rippleColor = appColors.colorAccentDark
-        binding.fab.backgroundTintList = ColorStateList.valueOf(appColors.colorAccent)
+        fab.backgroundTintList = ColorStateList.valueOf(appColors.colorAccent)
     }
 
     override fun onStop() {
         super.onStop()
-        binding.recyclerView.clearOnScrollListeners()
+        recyclerView.clearOnScrollListeners()
     }
 
     override fun onResume() {
         super.onResume()
         val mLayoutManager = LinearLayoutManager(this)
 
-        val settings =
-            getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
         val prefs = PreferenceManager.getDefaultSharedPreferences(this)
 
         val api = SelfossApi(
             this,
             this@SourcesActivity,
-            settings.getBoolean("isSelfSignedCert", false),
+            prefs.getBoolean("isSelfSignedCert", false),
-            prefs.getString("api_timeout", "-1")!!.toLong()
+            prefs.getBoolean("should_log_everything", false)
         )
-        var items: ArrayList<Source> = ArrayList()
+        var items: ArrayList<Sources> = ArrayList()
 
-        binding.recyclerView.setHasFixedSize(true)
+        recyclerView.setHasFixedSize(true)
-        binding.recyclerView.layoutManager = mLayoutManager
+        recyclerView.layoutManager = mLayoutManager
 
-        if (this@SourcesActivity.isNetworkAccessible(this@SourcesActivity.findViewById(R.id.recyclerView))) {
+        api.sources.enqueue(object : Callback<List<Sources>> {
-            api.sources.enqueue(object : Callback<List<Source>> {
+            override fun onResponse(
-                override fun onResponse(
+                call: Call<List<Sources>>,
-                    call: Call<List<Source>>,
+                response: Response<List<Sources>>
-                    response: Response<List<Source>>
+            ) {
-                ) {
+                if (response.body() != null && response.body()!!.isNotEmpty()) {
-                    if (response.body() != null && response.body()!!.isNotEmpty()) {
+                    items = response.body() as ArrayList<Sources>
-                        items = response.body() as ArrayList<Source>
-                    }
-                    val mAdapter = SourcesListAdapter(this@SourcesActivity, items, api)
-                    binding.recyclerView.adapter = mAdapter
-                    mAdapter.notifyDataSetChanged()
-                    if (items.isEmpty()) {
-                        Toast.makeText(
-                            this@SourcesActivity,
-                            R.string.nothing_here,
-                            Toast.LENGTH_SHORT
-                        ).show()
-                    }
                 }
-
+                val mAdapter = SourcesListAdapter(this@SourcesActivity, items, api)
-                override fun onFailure(call: Call<List<Source>>, t: Throwable) {
+                recyclerView.adapter = mAdapter
+                mAdapter.notifyDataSetChanged()
+                if (items.isEmpty()) {
                     Toast.makeText(
                         this@SourcesActivity,
-                        R.string.cant_get_sources,
+                        R.string.nothing_here,
                         Toast.LENGTH_SHORT
                     ).show()
                 }
-            })
+            }
-        }
 
-        binding.fab.setOnClickListener {
+            override fun onFailure(call: Call<List<Sources>>, t: Throwable) {
+                Toast.makeText(
+                    this@SourcesActivity,
+                    R.string.cant_get_sources,
+                    Toast.LENGTH_SHORT
+                ).show()
+            }
+        })
+
+        fab.setOnClickListener {
             startActivity(Intent(this@SourcesActivity, AddSourceActivity::class.java))
         }
     }

app/src/main/java/apps/amine/bou/readerforselfoss/adapters/ItemCardAdapter.kt

@@ -4,27 +4,21 @@ import android.app.Activity
 import android.content.Context
 import androidx.cardview.widget.CardView
 import androidx.recyclerview.widget.RecyclerView
+import android.text.Html
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.ImageView.ScaleType
 import android.widget.Toast
-import androidx.core.content.ContextCompat
 import apps.amine.bou.readerforselfoss.R
 import apps.amine.bou.readerforselfoss.api.selfoss.Item
 import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
 import apps.amine.bou.readerforselfoss.api.selfoss.SuccessResponse
-import apps.amine.bou.readerforselfoss.databinding.CardItemBinding
-import apps.amine.bou.readerforselfoss.persistence.database.AppDatabase
-import apps.amine.bou.readerforselfoss.persistence.entities.ActionEntity
 import apps.amine.bou.readerforselfoss.themes.AppColors
-import apps.amine.bou.readerforselfoss.utils.Config
-import apps.amine.bou.readerforselfoss.utils.LinkOnTouchListener
 import apps.amine.bou.readerforselfoss.utils.buildCustomTabsIntent
 import apps.amine.bou.readerforselfoss.utils.customtabs.CustomTabActivityHelper
 import apps.amine.bou.readerforselfoss.utils.glide.bitmapCenterCrop
 import apps.amine.bou.readerforselfoss.utils.glide.circularBitmapDrawable
-import apps.amine.bou.readerforselfoss.utils.network.isNetworkAccessible
 import apps.amine.bou.readerforselfoss.utils.openInBrowserAsNewTask
 import apps.amine.bou.readerforselfoss.utils.openItemUrl
 import apps.amine.bou.readerforselfoss.utils.shareLink
@@ -35,23 +29,22 @@ import com.amulyakhare.textdrawable.util.ColorGenerator
 import com.bumptech.glide.Glide
 import com.like.LikeButton
 import com.like.OnLikeListener
+import kotlinx.android.synthetic.main.card_item.view.*
 import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
-import kotlin.concurrent.thread
 
 class ItemCardAdapter(
     override val app: Activity,
     override var items: ArrayList<Item>,
     override val api: SelfossApi,
-    override val db: AppDatabase,
     private val helper: CustomTabActivityHelper,
     private val internalBrowser: Boolean,
     private val articleViewer: Boolean,
     private val fullHeightCards: Boolean,
     override val appColors: AppColors,
+    override val debugReadingItems: Boolean,
     override val userIdentifier: String,
-    override val config: Config,
     override val updateItems: (ArrayList<Item>) -> Unit
 ) : ItemsAdapter<ItemCardAdapter.ViewHolder>() {
     private val c: Context = app.baseContext
@@ -60,143 +53,118 @@ class ItemCardAdapter(
         c.resources.getDimension(R.dimen.card_image_max_height).toInt()
 
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
-        val binding = CardItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        val v = LayoutInflater.from(c).inflate(R.layout.card_item, parent, false) as CardView
-        return ViewHolder(binding)
+        return ViewHolder(v)
     }
 
     override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        with(holder) {
+        val itm = items[position]
-            val itm = items[position]
 
 
-            binding.favButton.isLiked = itm.starred
+        holder.mView.favButton.isLiked = itm.starred
-            binding.title.text = itm.getTitleDecoded()
+        holder.mView.title.text = Html.fromHtml(itm.title)
-            binding.title.setTextColor(ContextCompat.getColor(
-                    c,
-                    appColors.textColor
-            ))
-            binding.title.setOnTouchListener(LinkOnTouchListener())
 
-            binding.title.setLinkTextColor(appColors.colorAccent)
+        holder.mView.title.setLinkTextColor(appColors.colorAccent)
 
-            binding.sourceTitleAndDate.text = itm.sourceAndDateText()
+        holder.mView.sourceTitleAndDate.text = itm.sourceAndDateText()
 
-            binding.sourceTitleAndDate.setTextColor(ContextCompat.getColor(
+        if (!fullHeightCards) {
-                    c,
+            holder.mView.itemImage.maxHeight = imageMaxHeight
-                    appColors.textColor
+            holder.mView.itemImage.scaleType = ScaleType.CENTER_CROP
-            ))
-
-            if (!fullHeightCards) {
-                binding.itemImage.maxHeight = imageMaxHeight
-                binding.itemImage.scaleType = ScaleType.CENTER_CROP
-            }
-
-            if (itm.getThumbnail(c).isEmpty()) {
-                binding.itemImage.visibility = View.GONE
-                Glide.with(c).clear(binding.itemImage)
-                binding.itemImage.setImageDrawable(null)
-            } else {
-                binding.itemImage.visibility = View.VISIBLE
-                c.bitmapCenterCrop(config, itm.getThumbnail(c), binding.itemImage)
-            }
-
-            if (itm.getIcon(c).isEmpty()) {
-                val color = generator.getColor(itm.getSourceTitle())
-
-                val drawable =
-                        TextDrawable
-                                .builder()
-                                .round()
-                                .build(itm.getSourceTitle().toTextDrawableString(c), color)
-                binding.sourceImage.setImageDrawable(drawable)
-            } else {
-                c.circularBitmapDrawable(config, itm.getIcon(c), binding.sourceImage)
-            }
-
-            binding.favButton.isLiked = itm.starred
         }
+
+        if (itm.getThumbnail(c).isEmpty()) {
+            holder.mView.itemImage.visibility = View.GONE
+            Glide.with(c).clear(holder.mView.itemImage)
+            holder.mView.itemImage.setImageDrawable(null)
+        } else {
+            holder.mView.itemImage.visibility = View.VISIBLE
+            c.bitmapCenterCrop(itm.getThumbnail(c), holder.mView.itemImage)
+        }
+
+        if (itm.getIcon(c).isEmpty()) {
+            val color = generator.getColor(itm.sourcetitle)
+
+            val drawable =
+                TextDrawable
+                    .builder()
+                    .round()
+                    .build(itm.sourcetitle.toTextDrawableString(c), color)
+            holder.mView.sourceImage.setImageDrawable(drawable)
+        } else {
+            c.circularBitmapDrawable(itm.getIcon(c), holder.mView.sourceImage)
+        }
+
+        holder.mView.favButton.isLiked = itm.starred
     }
 
     override fun getItemCount(): Int {
         return items.size
     }
 
-    inner class ViewHolder(val binding: CardItemBinding) : RecyclerView.ViewHolder(binding.root) {
+    inner class ViewHolder(val mView: CardView) : RecyclerView.ViewHolder(mView) {
         init {
-            binding.root.setCardBackgroundColor(appColors.cardBackgroundColor)
+            mView.setCardBackgroundColor(appColors.cardBackgroundColor)
             handleClickListeners()
             handleCustomTabActions()
         }
 
         private fun handleClickListeners() {
 
-            binding.favButton.setOnLikeListener(object : OnLikeListener {
+            mView.favButton.setOnLikeListener(object : OnLikeListener {
                 override fun liked(likeButton: LikeButton) {
-                    val (id) = items[bindingAdapterPosition]
+                    val (id) = items[adapterPosition]
-                    if (c.isNetworkAccessible(null)) {
+                    api.starrItem(id).enqueue(object : Callback<SuccessResponse> {
-                        api.starrItem(id).enqueue(object : Callback<SuccessResponse> {
+                        override fun onResponse(
-                            override fun onResponse(
+                            call: Call<SuccessResponse>,
-                                call: Call<SuccessResponse>,
+                            response: Response<SuccessResponse>
-                                response: Response<SuccessResponse>
+                        ) {
-                            ) {
-                            }
-
-                            override fun onFailure(
-                                call: Call<SuccessResponse>,
-                                t: Throwable
-                            ) {
-                                binding.favButton.isLiked = false
-                                Toast.makeText(
-                                    c,
-                                    R.string.cant_mark_favortie,
-                                    Toast.LENGTH_SHORT
-                                ).show()
-                            }
-                        })
-                    } else {
-                        thread {
-                            db.actionsDao().insertAllActions(ActionEntity(id, false, false, true, false))
                         }
-                    }
+
+                        override fun onFailure(
+                            call: Call<SuccessResponse>,
+                            t: Throwable
+                        ) {
+                            mView.favButton.isLiked = false
+                            Toast.makeText(
+                                c,
+                                R.string.cant_mark_favortie,
+                                Toast.LENGTH_SHORT
+                            ).show()
+                        }
+                    })
                 }
 
                 override fun unLiked(likeButton: LikeButton) {
-                    val (id) = items[bindingAdapterPosition]
+                    val (id) = items[adapterPosition]
-                    if (c.isNetworkAccessible(null)) {
+                    api.unstarrItem(id).enqueue(object : Callback<SuccessResponse> {
-                        api.unstarrItem(id).enqueue(object : Callback<SuccessResponse> {
+                        override fun onResponse(
-                            override fun onResponse(
+                            call: Call<SuccessResponse>,
-                                call: Call<SuccessResponse>,
+                            response: Response<SuccessResponse>
-                                response: Response<SuccessResponse>
+                        ) {
-                            ) {
-                            }
-
-                            override fun onFailure(
-                                call: Call<SuccessResponse>,
-                                t: Throwable
-                            ) {
-                                binding.favButton.isLiked = true
-                                Toast.makeText(
-                                    c,
-                                    R.string.cant_unmark_favortie,
-                                    Toast.LENGTH_SHORT
-                                ).show()
-                            }
-                        })
-                    } else {
-                        thread {
-                            db.actionsDao().insertAllActions(ActionEntity(id, false, false, false, true))
                         }
-                    }
+
+                        override fun onFailure(
+                            call: Call<SuccessResponse>,
+                            t: Throwable
+                        ) {
+                            mView.favButton.isLiked = true
+                            Toast.makeText(
+                                c,
+                                R.string.cant_unmark_favortie,
+                                Toast.LENGTH_SHORT
+                            ).show()
+                        }
+                    })
                 }
             })
 
-            binding.shareBtn.setOnClickListener {
+            mView.shareBtn.setOnClickListener {
-                val item = items[bindingAdapterPosition]
+                c.shareLink(items[adapterPosition].getLinkDecoded())
-                c.shareLink(item.getLinkDecoded(), item.getTitleDecoded())
             }
 
-            binding.browserBtn.setOnClickListener {
+            mView.browserBtn.setOnClickListener {
-                c.openInBrowserAsNewTask(items[bindingAdapterPosition])
+                c.openInBrowserAsNewTask(items[adapterPosition])
             }
         }
 
@@ -204,11 +172,11 @@ class ItemCardAdapter(
             val customTabsIntent = c.buildCustomTabsIntent()
             helper.bindCustomTabsService(app)
 
-            binding.root.setOnClickListener {
+            mView.setOnClickListener {
                 c.openItemUrl(
                     items,
-                    bindingAdapterPosition,
+                    adapterPosition,
-                    items[bindingAdapterPosition].getLinkDecoded(),
+                    items[adapterPosition].getLinkDecoded(),
                     customTabsIntent,
                     internalBrowser,
                     articleViewer,

app/src/main/java/apps/amine/bou/readerforselfoss/adapters/ItemListAdapter.kt

@@ -4,25 +4,17 @@ import android.app.Activity
 import android.content.Context
 import androidx.constraintlayout.widget.ConstraintLayout
 import androidx.recyclerview.widget.RecyclerView
-import android.text.Spannable
+import android.text.Html
-import android.text.style.ClickableSpan
 import android.util.TypedValue
 import android.view.LayoutInflater
-import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
-import android.widget.TextView
 import android.widget.Toast
-import androidx.core.content.ContextCompat
 import apps.amine.bou.readerforselfoss.R
 import apps.amine.bou.readerforselfoss.api.selfoss.Item
 import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
 import apps.amine.bou.readerforselfoss.api.selfoss.SuccessResponse
-import apps.amine.bou.readerforselfoss.databinding.ListItemBinding
-import apps.amine.bou.readerforselfoss.persistence.database.AppDatabase
 import apps.amine.bou.readerforselfoss.themes.AppColors
-import apps.amine.bou.readerforselfoss.utils.Config
-import apps.amine.bou.readerforselfoss.utils.LinkOnTouchListener
 import apps.amine.bou.readerforselfoss.utils.buildCustomTabsIntent
 import apps.amine.bou.readerforselfoss.utils.customtabs.CustomTabActivityHelper
 import apps.amine.bou.readerforselfoss.utils.glide.bitmapCenterCrop
@@ -36,6 +28,7 @@ import com.amulyakhare.textdrawable.TextDrawable
 import com.amulyakhare.textdrawable.util.ColorGenerator
 import com.like.LikeButton
 import com.like.OnLikeListener
+import kotlinx.android.synthetic.main.list_item.view.*
 import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
@@ -46,89 +39,201 @@ class ItemListAdapter(
     override val app: Activity,
     override var items: ArrayList<Item>,
     override val api: SelfossApi,
-    override val db: AppDatabase,
     private val helper: CustomTabActivityHelper,
+    private val clickBehavior: Boolean,
     private val internalBrowser: Boolean,
     private val articleViewer: Boolean,
+    override val debugReadingItems: Boolean,
     override val userIdentifier: String,
     override val appColors: AppColors,
-    override val config: Config,
     override val updateItems: (ArrayList<Item>) -> Unit
 ) : ItemsAdapter<ItemListAdapter.ViewHolder>() {
     private val generator: ColorGenerator = ColorGenerator.MATERIAL
     private val c: Context = app.baseContext
+    private val bars: ArrayList<Boolean> = ArrayList(Collections.nCopies(items.size + 1, false))
 
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
-        val binding = ListItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        val v = LayoutInflater.from(c).inflate(
-        return ViewHolder(binding)
+            R.layout.list_item,
+            parent,
+            false
+        ) as ConstraintLayout
+        return ViewHolder(v)
     }
 
     override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-        with(holder) {
+        val itm = items[position]
-            val itm = items[position]
 
 
-            binding.title.text = itm.getTitleDecoded()
+        holder.mView.title.text = Html.fromHtml(itm.title)
 
-            binding.title.setTextColor(ContextCompat.getColor(
+        holder.mView.title.setLinkTextColor(appColors.colorAccent)
-                    c,
-                    appColors.textColor
-            ))
 
-            binding.title.setOnTouchListener(LinkOnTouchListener())
+        holder.mView.sourceTitleAndDate.text = itm.sourceAndDateText()
 
-            binding.title.setLinkTextColor(appColors.colorAccent)
+        if (itm.getThumbnail(c).isEmpty()) {
+            val sizeInInt = 46
+            val sizeInDp = TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_DIP, sizeInInt.toFloat(), c.resources
+                    .displayMetrics
+            ).toInt()
 
-            binding.sourceTitleAndDate.text = itm.sourceAndDateText()
+            val marginInInt = 16
+            val marginInDp = TypedValue.applyDimension(
+                TypedValue.COMPLEX_UNIT_DIP, marginInInt.toFloat(), c.resources
+                    .displayMetrics
+            ).toInt()
 
-            binding.sourceTitleAndDate.setTextColor(ContextCompat.getColor(
+            val params = holder.mView.itemImage.layoutParams as ViewGroup.MarginLayoutParams
-                    c,
+            params.height = sizeInDp
-                    appColors.textColor
+            params.width = sizeInDp
-            ))
+            params.setMargins(marginInDp, 0, 0, 0)
+            holder.mView.itemImage.layoutParams = params
 
-            if (itm.getThumbnail(c).isEmpty()) {
+            if (itm.getIcon(c).isEmpty()) {
+                val color = generator.getColor(itm.sourcetitle)
 
-                if (itm.getIcon(c).isEmpty()) {
+                val drawable =
-                    val color = generator.getColor(itm.getSourceTitle())
+                    TextDrawable
+                        .builder()
+                        .round()
+                        .build(itm.sourcetitle.toTextDrawableString(c), color)
 
-                    val drawable =
+                holder.mView.itemImage.setImageDrawable(drawable)
-                            TextDrawable
-                                    .builder()
-                                    .round()
-                                    .build(itm.getSourceTitle().toTextDrawableString(c), color)
-
-                    binding.itemImage.setImageDrawable(drawable)
-                } else {
-                    c.circularBitmapDrawable(config, itm.getIcon(c), binding.itemImage)
-                }
             } else {
-                c.bitmapCenterCrop(config, itm.getThumbnail(c), binding.itemImage)
+                c.circularBitmapDrawable(itm.getIcon(c), holder.mView.itemImage)
             }
+        } else {
+            c.bitmapCenterCrop(itm.getThumbnail(c), holder.mView.itemImage)
         }
+
+        // TODO: maybe handle this differently. It crashes when changing tab
+        try {
+            if (bars[position]) {
+                holder.mView.actionBar.visibility = View.VISIBLE
+            } else {
+                holder.mView.actionBar.visibility = View.GONE
+            }
+        } catch (e: IndexOutOfBoundsException) {
+            holder.mView.actionBar.visibility = View.GONE
+        }
+
+        holder.mView.favButton.isLiked = itm.starred
     }
 
     override fun getItemCount(): Int = items.size
 
-    inner class ViewHolder(val binding: ListItemBinding) : RecyclerView.ViewHolder(binding.root) {
+    inner class ViewHolder(val mView: ConstraintLayout) : RecyclerView.ViewHolder(mView) {
 
         init {
+            handleClickListeners()
             handleCustomTabActions()
         }
 
+        private fun handleClickListeners() {
+
+            mView.favButton.setOnLikeListener(object : OnLikeListener {
+                override fun liked(likeButton: LikeButton) {
+                    val (id) = items[adapterPosition]
+                    api.starrItem(id).enqueue(object : Callback<SuccessResponse> {
+                        override fun onResponse(
+                            call: Call<SuccessResponse>,
+                            response: Response<SuccessResponse>
+                        ) {
+                        }
+
+                        override fun onFailure(
+                            call: Call<SuccessResponse>,
+                            t: Throwable
+                        ) {
+                            mView.favButton.isLiked = false
+                            Toast.makeText(
+                                c,
+                                R.string.cant_mark_favortie,
+                                Toast.LENGTH_SHORT
+                            ).show()
+                        }
+                    })
+                }
+
+                override fun unLiked(likeButton: LikeButton) {
+                    val (id) = items[adapterPosition]
+                    api.unstarrItem(id).enqueue(object : Callback<SuccessResponse> {
+                        override fun onResponse(
+                            call: Call<SuccessResponse>,
+                            response: Response<SuccessResponse>
+                        ) {
+                        }
+
+                        override fun onFailure(
+                            call: Call<SuccessResponse>,
+                            t: Throwable
+                        ) {
+                            mView.favButton.isLiked = true
+                            Toast.makeText(
+                                c,
+                                R.string.cant_unmark_favortie,
+                                Toast.LENGTH_SHORT
+                            ).show()
+                        }
+                    })
+                }
+            })
+
+            mView.shareBtn.setOnClickListener {
+                c.shareLink(items[adapterPosition].getLinkDecoded())
+            }
+
+            mView.browserBtn.setOnClickListener {
+                c.openInBrowserAsNewTask(items[adapterPosition])
+
+            }
+        }
+
         private fun handleCustomTabActions() {
             val customTabsIntent = c.buildCustomTabsIntent()
             helper.bindCustomTabsService(app)
 
-            binding.root.setOnClickListener {
+
-                c.openItemUrl(
+            if (!clickBehavior) {
-                    items,
+                mView.setOnClickListener {
-                    bindingAdapterPosition,
+                    c.openItemUrl(
-                    items[bindingAdapterPosition].getLinkDecoded(),
+                        items,
-                    customTabsIntent,
+                        adapterPosition,
-                    internalBrowser,
+                        items[adapterPosition].getLinkDecoded(),
-                    articleViewer,
+                        customTabsIntent,
-                    app
+                        internalBrowser,
-                )
+                        articleViewer,
+                        app
+                    )
+                }
+                mView.setOnLongClickListener {
+                    actionBarShowHide()
+                    true
+                }
+            } else {
+                mView.setOnClickListener { actionBarShowHide() }
+                mView.setOnLongClickListener {
+                    c.openItemUrl(
+                        items,
+                        adapterPosition,
+                        items[adapterPosition].getLinkDecoded(),
+                        customTabsIntent,
+                        internalBrowser,
+                        articleViewer,
+                        app
+                    )
+                    true
+                }
+            }
+        }
+
+        private fun actionBarShowHide() {
+            bars[adapterPosition] = true
+            if (mView.actionBar.visibility == View.GONE) {
+                mView.actionBar.visibility = View.VISIBLE
+            } else {
+                mView.actionBar.visibility = View.GONE
             }
         }
     }

app/src/main/java/apps/amine/bou/readerforselfoss/adapters/ItemsAdapter.kt

@@ -2,7 +2,6 @@ package apps.amine.bou.readerforselfoss.adapters
 
 import android.app.Activity
 import android.graphics.Color
-import com.google.android.material.snackbar.Snackbar
 import androidx.recyclerview.widget.RecyclerView
 import android.widget.TextView
 import android.widget.Toast
@@ -10,26 +9,22 @@ import apps.amine.bou.readerforselfoss.R
 import apps.amine.bou.readerforselfoss.api.selfoss.Item
 import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
 import apps.amine.bou.readerforselfoss.api.selfoss.SuccessResponse
-import apps.amine.bou.readerforselfoss.persistence.database.AppDatabase
-import apps.amine.bou.readerforselfoss.persistence.entities.ActionEntity
 import apps.amine.bou.readerforselfoss.themes.AppColors
-import apps.amine.bou.readerforselfoss.utils.Config
+import apps.amine.bou.readerforselfoss.utils.maybeHandleSilentException
-import apps.amine.bou.readerforselfoss.utils.network.isNetworkAccessible
-import apps.amine.bou.readerforselfoss.utils.persistence.toEntity
 import apps.amine.bou.readerforselfoss.utils.succeeded
+import com.google.android.material.snackbar.Snackbar
+import org.acra.ACRA
 import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
-import kotlin.concurrent.thread
 
 abstract class ItemsAdapter<VH : RecyclerView.ViewHolder?> : RecyclerView.Adapter<VH>() {
     abstract var items: ArrayList<Item>
     abstract val api: SelfossApi
-    abstract val db: AppDatabase
+    abstract val debugReadingItems: Boolean
     abstract val userIdentifier: String
     abstract val app: Activity
     abstract val appColors: AppColors
-    abstract val config: Config
     abstract val updateItems: (ArrayList<Item>) -> Unit
 
     fun updateAllItems(newItems: ArrayList<Item>) {
@@ -38,7 +33,7 @@ abstract class ItemsAdapter<VH : RecyclerView.ViewHolder?> : RecyclerView.Adapte
         updateItems(items)
     }
 
-    private fun unmarkSnackbar(i: Item, position: Int) {
+    private fun doUnmark(i: Item, position: Int) {
         val s = Snackbar
             .make(
                 app.findViewById(R.id.coordLayout),
@@ -47,34 +42,23 @@ abstract class ItemsAdapter<VH : RecyclerView.ViewHolder?> : RecyclerView.Adapte
             )
             .setAction(R.string.undo_string) {
                 items.add(position, i)
-                thread {
-                    db.itemsDao().insertAllItems(i.toEntity())
-                }
                 notifyItemInserted(position)
                 updateItems(items)
 
-                if (app.isNetworkAccessible(null)) {
+                api.unmarkItem(i.id).enqueue(object : Callback<SuccessResponse> {
-                    api.unmarkItem(i.id).enqueue(object : Callback<SuccessResponse> {
+                    override fun onResponse(
-                        override fun onResponse(
+                        call: Call<SuccessResponse>,
-                            call: Call<SuccessResponse>,
+                        response: Response<SuccessResponse>
-                            response: Response<SuccessResponse>
+                    ) {
-                        ) {
-                        }
-
-                        override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
-                            items.remove(i)
-                            thread {
-                                db.itemsDao().delete(i.toEntity())
-                            }
-                            notifyItemRemoved(position)
-                            updateItems(items)
-                        }
-                    })
-                } else {
-                    thread {
-                        db.actionsDao().insertAllActions(ActionEntity(i.id, false, true, false, false))
                     }
-                }
+
+                    override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
+                        items.remove(i)
+                        notifyItemRemoved(position)
+                        updateItems(items)
+                        doUnmark(i, position)
+                    }
+                })
             }
 
         val view = s.view
@@ -83,145 +67,51 @@ abstract class ItemsAdapter<VH : RecyclerView.ViewHolder?> : RecyclerView.Adapte
         s.show()
     }
 
-    private fun markSnackbar(i: Item, position: Int) {
+    fun removeItemAtIndex(position: Int) {
-        val s = Snackbar
+
-            .make(
+        val i = items[position]
-                app.findViewById(R.id.coordLayout),
+
-                R.string.marked_as_unread,
+        items.remove(i)
-                Snackbar.LENGTH_LONG
+        notifyItemRemoved(position)
-            )
+        updateItems(items)
-            .setAction(R.string.undo_string) {
+
-                items.add(position, i)
+
-                thread {
+        api.markItem(i.id).enqueue(object : Callback<SuccessResponse> {
-                    db.itemsDao().delete(i.toEntity())
+            override fun onResponse(
+                call: Call<SuccessResponse>,
+                response: Response<SuccessResponse>
+            ) {
+                if (!response.succeeded() && debugReadingItems) {
+                    val message =
+                        "message: ${response.message()} " +
+                                "response isSuccess: ${response.isSuccessful} " +
+                                "response code: ${response.code()} " +
+                                "response message: ${response.message()} " +
+                                "response errorBody: ${response.errorBody()?.string()} " +
+                                "body success: ${response.body()?.success} " +
+                                "body isSuccess: ${response.body()?.isSuccess}"
+                    ACRA.getErrorReporter().maybeHandleSilentException(Exception(message), app)
+                    Toast.makeText(app.baseContext, message, Toast.LENGTH_LONG).show()
                 }
+                doUnmark(i, position)
+            }
+
+            override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
+                if (debugReadingItems) {
+                    ACRA.getErrorReporter().maybeHandleSilentException(t, app)
+                    Toast.makeText(app.baseContext, t.message, Toast.LENGTH_LONG).show()
+                }
+                Toast.makeText(
+                    app,
+                    app.getString(R.string.cant_mark_read),
+                    Toast.LENGTH_SHORT
+                ).show()
+                items.add(i)
                 notifyItemInserted(position)
                 updateItems(items)
 
-                if (app.isNetworkAccessible(null)) {
-                    api.markItem(i.id).enqueue(object : Callback<SuccessResponse> {
-                        override fun onResponse(
-                            call: Call<SuccessResponse>,
-                            response: Response<SuccessResponse>
-                        ) {
-                        }
-
-                        override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
-                            items.remove(i)
-                            thread {
-                                db.itemsDao().insertAllItems(i.toEntity())
-                            }
-                            notifyItemRemoved(position)
-                            updateItems(items)
-                        }
-                    })
-                } else {
-                    thread {
-                        db.actionsDao().insertAllActions(ActionEntity(i.id, true, false, false, false))
-                    }
-                }
             }
-
+        })
-        val view = s.view
-        val tv: TextView = view.findViewById(com.google.android.material.R.id.snackbar_text)
-        tv.setTextColor(Color.WHITE)
-        s.show()
-    }
-
-    fun handleItemAtIndex(position: Int) {
-        if (unreadItemStatusAtIndex(position)) {
-            readItemAtIndex(position)
-        } else {
-            unreadItemAtIndex(position)
-        }
-    }
-
-    fun unreadItemStatusAtIndex(position: Int): Boolean {
-        return items[position].unread
-    }
-
-    private fun readItemAtIndex(position: Int) {
-        val i = items[position]
-        items.remove(i)
-        notifyItemRemoved(position)
-        updateItems(items)
-
-        thread {
-            db.itemsDao().delete(i.toEntity())
-        }
-
-        if (app.isNetworkAccessible(null)) {
-            api.markItem(i.id).enqueue(object : Callback<SuccessResponse> {
-                override fun onResponse(
-                    call: Call<SuccessResponse>,
-                    response: Response<SuccessResponse>
-                ) {
-
-                    unmarkSnackbar(i, position)
-                }
-
-                override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
-                    Toast.makeText(
-                        app,
-                        app.getString(R.string.cant_mark_read),
-                        Toast.LENGTH_SHORT
-                    ).show()
-                    items.add(position, i)
-                    notifyItemInserted(position)
-                    updateItems(items)
-
-                    thread {
-                        db.itemsDao().insertAllItems(i.toEntity())
-                    }
-                }
-            })
-        } else {
-            thread {
-                db.actionsDao().insertAllActions(ActionEntity(i.id, true, false, false, false))
-            }
-        }
-    }
-
-    private fun unreadItemAtIndex(position: Int) {
-        val i = items[position]
-        items.remove(i)
-        notifyItemRemoved(position)
-        updateItems(items)
-
-        thread {
-            db.itemsDao().insertAllItems(i.toEntity())
-        }
-
-        if (app.isNetworkAccessible(null)) {
-            api.unmarkItem(i.id).enqueue(object : Callback<SuccessResponse> {
-                override fun onResponse(
-                    call: Call<SuccessResponse>,
-                    response: Response<SuccessResponse>
-                ) {
-
-                    markSnackbar(i, position)
-                }
-
-                override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
-                    Toast.makeText(
-                        app,
-                        app.getString(R.string.cant_mark_unread),
-                        Toast.LENGTH_SHORT
-                    ).show()
-                    items.add(i)
-                    notifyItemInserted(position)
-                    updateItems(items)
-
-                    thread {
-                        db.itemsDao().delete(i.toEntity())
-                    }
-                }
-            })
-        } else {
-            thread {
-                db.actionsDao().insertAllActions(ActionEntity(i.id, false, true, false, false))
-            }
-        }
     }
 
     fun addItemAtIndex(item: Item, position: Int) {

app/src/main/java/apps/amine/bou/readerforselfoss/adapters/SourcesListAdapter.kt

@@ -10,52 +10,51 @@ import android.widget.Button
 import android.widget.Toast
 import apps.amine.bou.readerforselfoss.R
 import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
-import apps.amine.bou.readerforselfoss.api.selfoss.Source
+import apps.amine.bou.readerforselfoss.api.selfoss.Sources
 import apps.amine.bou.readerforselfoss.api.selfoss.SuccessResponse
-import apps.amine.bou.readerforselfoss.databinding.SourceListItemBinding
-import apps.amine.bou.readerforselfoss.utils.Config
 import apps.amine.bou.readerforselfoss.utils.glide.circularBitmapDrawable
-import apps.amine.bou.readerforselfoss.utils.network.isNetworkAccessible
 import apps.amine.bou.readerforselfoss.utils.toTextDrawableString
 import com.amulyakhare.textdrawable.TextDrawable
 import com.amulyakhare.textdrawable.util.ColorGenerator
+import kotlinx.android.synthetic.main.source_list_item.view.*
 import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
 
 class SourcesListAdapter(
     private val app: Activity,
-    private val items: ArrayList<Source>,
+    private val items: ArrayList<Sources>,
     private val api: SelfossApi
 ) : RecyclerView.Adapter<SourcesListAdapter.ViewHolder>() {
     private val c: Context = app.baseContext
     private val generator: ColorGenerator = ColorGenerator.MATERIAL
-    private lateinit var config: Config
-    private lateinit var binding: SourceListItemBinding
 
     override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
-        binding = SourceListItemBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+        val v = LayoutInflater.from(c).inflate(
-        return ViewHolder(binding.root)
+            R.layout.source_list_item,
+            parent,
+            false
+        ) as ConstraintLayout
+        return ViewHolder(v)
     }
 
     override fun onBindViewHolder(holder: ViewHolder, position: Int) {
         val itm = items[position]
-        config = Config(c)
 
         if (itm.getIcon(c).isEmpty()) {
-            val color = generator.getColor(itm.getTitleDecoded())
+            val color = generator.getColor(itm.title)
 
             val drawable =
                 TextDrawable
                     .builder()
                     .round()
-                    .build(itm.getTitleDecoded().toTextDrawableString(c), color)
+                    .build(itm.title.toTextDrawableString(c), color)
-            binding.itemImage.setImageDrawable(drawable)
+            holder.mView.itemImage.setImageDrawable(drawable)
         } else {
-            c.circularBitmapDrawable(config, itm.getIcon(c), binding.itemImage)
+            c.circularBitmapDrawable(itm.getIcon(c), holder.mView.itemImage)
         }
 
-        binding.sourceTitle.text = itm.getTitleDecoded()
+        holder.mView.sourceTitle.text = itm.title
     }
 
     override fun getItemCount(): Int = items.size
@@ -71,35 +70,33 @@ class SourcesListAdapter(
             val deleteBtn: Button = mView.findViewById(R.id.deleteBtn)
 
             deleteBtn.setOnClickListener {
-                if (c.isNetworkAccessible(null)) {
+                val (id) = items[adapterPosition]
-                    val (id) = items[adapterPosition]
+                api.deleteSource(id).enqueue(object : Callback<SuccessResponse> {
-                    api.deleteSource(id).enqueue(object : Callback<SuccessResponse> {
+                    override fun onResponse(
-                        override fun onResponse(
+                        call: Call<SuccessResponse>,
-                            call: Call<SuccessResponse>,
+                        response: Response<SuccessResponse>
-                            response: Response<SuccessResponse>
+                    ) {
-                        ) {
+                        if (response.body() != null && response.body()!!.isSuccess) {
-                            if (response.body() != null && response.body()!!.isSuccess) {
+                            items.removeAt(adapterPosition)
-                                items.removeAt(adapterPosition)
+                            notifyItemRemoved(adapterPosition)
-                                notifyItemRemoved(adapterPosition)
+                            notifyItemRangeChanged(adapterPosition, itemCount)
-                                notifyItemRangeChanged(adapterPosition, itemCount)
+                        } else {
-                            } else {
-                                Toast.makeText(
-                                    app,
-                                    R.string.can_delete_source,
-                                    Toast.LENGTH_SHORT
-                                ).show()
-                            }
-                        }
-
-                        override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
                             Toast.makeText(
                                 app,
                                 R.string.can_delete_source,
                                 Toast.LENGTH_SHORT
                             ).show()
                         }
-                    })
+                    }
-                }
+
+                    override fun onFailure(call: Call<SuccessResponse>, t: Throwable) {
+                        Toast.makeText(
+                            app,
+                            R.string.can_delete_source,
+                            Toast.LENGTH_SHORT
+                        ).show()
+                    }
+                })
             }
         }
     }

app/src/main/java/apps/amine/bou/readerforselfoss/api/mercury/MercuryApi.kt

@@ -7,13 +7,17 @@ import retrofit2.Call
 import retrofit2.Retrofit
 import retrofit2.converter.gson.GsonConverterFactory
 
-class MercuryApi() {
+class MercuryApi(shouldLog: Boolean) {
     private val service: MercuryService
 
     init {
 
         val interceptor = HttpLoggingInterceptor()
-        interceptor.level = HttpLoggingInterceptor.Level.NONE
+        interceptor.level = if (shouldLog) {
+            HttpLoggingInterceptor.Level.BODY
+        } else {
+            HttpLoggingInterceptor.Level.NONE
+        }
         val client = OkHttpClient.Builder().addInterceptor(interceptor).build()
 
         val gson = GsonBuilder()

app/src/main/java/apps/amine/bou/readerforselfoss/api/mercury/MercuryModels.kt

@@ -28,17 +28,17 @@ class ParsedContent(
     }
 
     constructor(source: Parcel) : this(
-        title = source.readString().orEmpty(),
+        title = source.readString(),
         content = source.readString(),
-        date_published = source.readString().orEmpty(),
+        date_published = source.readString(),
         lead_image_url = source.readString(),
-        dek = source.readString().orEmpty(),
+        dek = source.readString(),
-        url = source.readString().orEmpty(),
+        url = source.readString(),
-        domain = source.readString().orEmpty(),
+        domain = source.readString(),
-        excerpt = source.readString().orEmpty(),
+        excerpt = source.readString(),
         total_pages = source.readInt(),
         rendered_pages = source.readInt(),
-        next_page_url = source.readString().orEmpty()
+        next_page_url = source.readString()
     )
 
     override fun describeContents() = 0

app/src/main/java/apps/amine/bou/readerforselfoss/api/selfoss/SelfossApi.kt

@@ -12,20 +12,18 @@ import com.burgstaller.okhttp.digest.CachingAuthenticator
 import com.burgstaller.okhttp.digest.Credentials
 import com.burgstaller.okhttp.digest.DigestAuthenticator
 import com.google.gson.GsonBuilder
-import okhttp3.*
+import okhttp3.OkHttpClient
 import okhttp3.logging.HttpLoggingInterceptor
 import retrofit2.Call
 import retrofit2.Retrofit
 import retrofit2.converter.gson.GsonConverterFactory
-import java.net.SocketTimeoutException
 import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.TimeUnit
 
 class SelfossApi(
     c: Context,
-    callingActivity: Activity?,
+    callingActivity: Activity,
     isWithSelfSignedCert: Boolean,
-    timeout: Long
+    shouldLog: Boolean
 ) {
 
     private lateinit var service: SelfossService
@@ -40,39 +38,19 @@ class SelfossApi(
             this
         }
 
-    fun OkHttpClient.Builder.maybeWithSettingsTimeout(timeout: Long): OkHttpClient.Builder =
-        if (timeout != -1L) {
-            this.readTimeout(timeout, TimeUnit.SECONDS)
-                .connectTimeout(timeout, TimeUnit.SECONDS)
-        } else {
-            this
-        }
-
     fun Credentials.createAuthenticator(): DispatchingAuthenticator =
         DispatchingAuthenticator.Builder()
             .with("digest", DigestAuthenticator(this))
             .with("basic", BasicAuthenticator(this))
             .build()
 
-    fun DispatchingAuthenticator.getHttpClien(isWithSelfSignedCert: Boolean, timeout: Long): OkHttpClient.Builder {
+    fun DispatchingAuthenticator.getHttpClien(isWithSelfSignedCert: Boolean): OkHttpClient.Builder {
         val authCache = ConcurrentHashMap<String, CachingAuthenticator>()
         return OkHttpClient
             .Builder()
-            .maybeWithSettingsTimeout(timeout)
             .maybeWithSelfSigned(isWithSelfSignedCert)
             .authenticator(CachingAuthenticatorDecorator(this, authCache))
             .addInterceptor(AuthenticationCacheInterceptor(authCache))
-            .addInterceptor(object: Interceptor {
-                override fun intercept(chain: Interceptor.Chain): Response {
-                    val request: Request = chain.request()
-                    val response: Response = chain.proceed(request)
-
-                    if (response.code() == 408) {
-                        return response
-                    }
-                    return response
-                }
-            })
     }
 
     init {
@@ -88,40 +66,20 @@ class SelfossApi(
         val gson =
             GsonBuilder()
                 .registerTypeAdapter(Boolean::class.javaPrimitiveType, BooleanTypeAdapter())
-                .registerTypeAdapter(SelfossTagType::class.java, SelfossTagTypeTypeAdapter())
                 .setLenient()
                 .create()
 
         val logging = HttpLoggingInterceptor()
 
+        logging.level = if (shouldLog) {
+            HttpLoggingInterceptor.Level.BODY
+        } else {
+            HttpLoggingInterceptor.Level.NONE
+        }
 
-        logging.level = HttpLoggingInterceptor.Level.NONE
+        val httpClient = authenticator.getHttpClien(isWithSelfSignedCert)
-        val httpClient = authenticator.getHttpClien(isWithSelfSignedCert, timeout)
 
-        val timeoutCode = 504
+        httpClient.addInterceptor(logging)
-        httpClient
-                .addInterceptor { chain ->
-                    val res = chain.proceed(chain.request())
-                    if (res.code() == timeoutCode) {
-                        throw SocketTimeoutException("timeout")
-                    }
-                    res
-                }
-                .addInterceptor(logging)
-                .addInterceptor { chain ->
-                    val request = chain.request()
-                    try {
-                        chain.proceed(request)
-                    } catch (e: SocketTimeoutException) {
-                        Response.Builder()
-                                .code(timeoutCode)
-                                .protocol(Protocol.HTTP_2)
-                                .body(ResponseBody.create(MediaType.parse("text/plain"), ""))
-                                .message("")
-                                .request(request)
-                                .build()
-                    }
-                }
 
         try {
             val retrofit =
@@ -133,9 +91,7 @@ class SelfossApi(
                     .build()
             service = retrofit.create(SelfossService::class.java)
         } catch (e: IllegalArgumentException) {
-            if (callingActivity != null) {
+            Config.logoutAndRedirect(c, callingActivity, config.settings.edit(), baseUrlFail = true)
-                Config.logoutAndRedirect(c, callingActivity, config.settings.edit(), baseUrlFail = true)
-            }
         }
     }
 
@@ -169,18 +125,6 @@ class SelfossApi(
     ): Call<List<Item>> =
         getItems("starred", tag, sourceId, search, itemsNumber, offset)
 
-    fun allItems(): Call<List<Item>> =
-        service.allItems(userName, password)
-
-    fun allNewItems(): Call<List<Item>> =
-            getItems("unread", null, null, null, 200, 0)
-
-    fun allReadItems(): Call<List<Item>> =
-            getItems("read", null, null, null, 200, 0)
-
-    fun allStarredItems(): Call<List<Item>> =
-            getItems("read", null, null, null, 200, 0)
-
     private fun getItems(
         type: String,
         tag: String?,
@@ -215,10 +159,7 @@ class SelfossApi(
     fun update(): Call<String> =
         service.update(userName, password)
 
-    val apiVersion: Call<ApiVersion>
+    val sources: Call<List<Sources>>
-        get() = service.version()
-
-    val sources: Call<List<Source>>
         get() = service.sources(userName, password)
 
     fun deleteSource(id: String): Call<SuccessResponse> =

app/src/main/java/apps/amine/bou/readerforselfoss/api/selfoss/SelfossModels.kt

@@ -4,24 +4,18 @@ import android.content.Context
 import android.net.Uri
 import android.os.Parcel
 import android.os.Parcelable
-import android.text.Html
-import android.webkit.URLUtil
-import org.jsoup.Jsoup
 
 import apps.amine.bou.readerforselfoss.utils.Config
 import apps.amine.bou.readerforselfoss.utils.isEmptyOrNullOrNullString
-import com.bumptech.glide.Glide
-import com.bumptech.glide.load.engine.DiskCacheStrategy
-import com.bumptech.glide.request.RequestOptions
 import com.google.gson.annotations.SerializedName
 
-private fun constructUrl(config: Config?, path: String, file: String?): String {
+private fun constructUrl(config: Config?, path: String, file: String): String {
+    val baseUriBuilder = Uri.parse(config!!.baseUrl).buildUpon()
+    baseUriBuilder.appendPath(path).appendPath(file)
+
     return if (file.isEmptyOrNullOrNullString()) {
         ""
     } else {
-        val baseUriBuilder = Uri.parse(config!!.baseUrl).buildUpon()
-        baseUriBuilder.appendPath(path).appendPath(file)
-
         baseUriBuilder.toString()
     }
 }
@@ -48,23 +42,10 @@ data class Spout(
     @SerializedName("description") val description: String
 )
 
-data class ApiVersion(
+data class Sources(
-        @SerializedName("version") val version: String,
-        @SerializedName("apiversion") val apiversion: String
-) {
-    fun getApiMajorVersion() : Int {
-        var versionNumber = 0
-        if (apiversion != null) {
-            versionNumber = apiversion.substringBefore(".").toInt()
-        }
-        return versionNumber
-    }
-}
-
-data class Source(
     @SerializedName("id") val id: String,
     @SerializedName("title") val title: String,
-    @SerializedName("tags") val tags: SelfossTagType,
+    @SerializedName("tags") val tags: String,
     @SerializedName("spout") val spout: String,
     @SerializedName("error") val error: String,
     @SerializedName("icon") val icon: String
@@ -77,10 +58,6 @@ data class Source(
         }
         return constructUrl(config, "favicons", icon)
     }
-
-    fun getTitleDecoded(): String {
-        return Html.fromHtml(title).toString()
-    }
 }
 
 data class Item(
@@ -90,11 +67,11 @@ data class Item(
     @SerializedName("content") val content: String,
     @SerializedName("unread") val unread: Boolean,
     @SerializedName("starred") var starred: Boolean,
-    @SerializedName("thumbnail") val thumbnail: String?,
+    @SerializedName("thumbnail") val thumbnail: String,
-    @SerializedName("icon") val icon: String?,
+    @SerializedName("icon") val icon: String,
     @SerializedName("link") val link: String,
     @SerializedName("sourcetitle") val sourcetitle: String,
-    @SerializedName("tags") val tags: SelfossTagType
+    @SerializedName("tags") val tags: String
 ) : Parcelable {
 
     var config: Config? = null
@@ -107,17 +84,17 @@ data class Item(
     }
 
     constructor(source: Parcel) : this(
-        id = source.readString().orEmpty(),
+        id = source.readString(),
-        datetime = source.readString().orEmpty(),
+        datetime = source.readString(),
-        title = source.readString().orEmpty(),
+        title = source.readString(),
-        content = source.readString().orEmpty(),
+        content = source.readString(),
         unread = 0.toByte() != source.readByte(),
         starred = 0.toByte() != source.readByte(),
         thumbnail = source.readString(),
         icon = source.readString(),
-        link = source.readString().orEmpty(),
+        link = source.readString(),
-        sourcetitle = source.readString().orEmpty(),
+        sourcetitle = source.readString(),
-        tags = if (source.readParcelable<SelfossTagType>(ClassLoader.getSystemClassLoader()) != null) source.readParcelable(ClassLoader.getSystemClassLoader())!! else SelfossTagType("")
+        tags = source.readString()
     )
 
     override fun describeContents() = 0
@@ -133,7 +110,7 @@ data class Item(
         dest.writeString(icon)
         dest.writeString(link)
         dest.writeString(sourcetitle)
-        dest.writeParcelable(tags, flags)
+        dest.writeString(tags)
     }
 
     fun getIcon(app: Context): String {
@@ -150,51 +127,6 @@ data class Item(
         return constructUrl(config, "thumbnails", thumbnail)
     }
 
-    fun getImages() : ArrayList<String> {
-        var allImages = ArrayList<String>()
-
-        for ( image in Jsoup.parse(content).getElementsByTag("img")) {
-            val url = image.attr("src")
-            if (url.toLowerCase().contains(".jpg") ||
-                    url.toLowerCase().contains(".jpeg") ||
-                    url.toLowerCase().contains(".png") ||
-                    url.toLowerCase().contains(".webp"))
-            {
-                allImages.add(url)
-            }
-        }
-        return allImages
-    }
-
-    fun preloadImages(context: Context) : Boolean {
-        val imageUrls = this.getImages()
-
-        val glideOptions = RequestOptions.diskCacheStrategyOf(DiskCacheStrategy.ALL).timeout(10000)
-
-
-        try {
-            for (url in imageUrls) {
-                if ( URLUtil.isValidUrl(url)) {
-                    val image = Glide.with(context).asBitmap()
-                            .apply(glideOptions)
-                            .load(url).submit()
-                }
-            }
-        } catch (e : Error) {
-            return false
-        }
-
-        return true
-    }
-
-    fun getTitleDecoded(): String {
-        return Html.fromHtml(title).toString()
-    }
-
-    fun getSourceTitle(): String {
-        return Html.fromHtml(sourcetitle).toString()
-    }
-
     // TODO: maybe find a better way to handle these kind of urls
     fun getLinkDecoded(): String {
         var stringUrl: String
@@ -221,27 +153,4 @@ data class Item(
 
         return stringUrl
     }
-}
-
-data class SelfossTagType(val tags: String) : Parcelable {
-
-    companion object {
-        @JvmField val CREATOR: Parcelable.Creator<SelfossTagType> =
-            object : Parcelable.Creator<SelfossTagType> {
-                override fun createFromParcel(source: Parcel): SelfossTagType =
-                    SelfossTagType(source)
-
-                override fun newArray(size: Int): Array<SelfossTagType?> = arrayOfNulls(size)
-            }
-    }
-
-    constructor(source: Parcel) : this(
-        tags = source.readString().orEmpty()
-    )
-
-    override fun describeContents() = 0
-
-    override fun writeToParcel(dest: Parcel, flags: Int) {
-        dest.writeString(tags)
-    }
 }

app/src/main/java/apps/amine/bou/readerforselfoss/api/selfoss/SelfossService.kt

@@ -27,12 +27,6 @@ internal interface SelfossService {
         @Query("offset") offset: Int
     ): Call<List<Item>>
 
-    @GET("items")
-    fun allItems(
-        @Query("username") username: String,
-        @Query("password") password: String
-    ): Call<List<Item>>
-
     @Headers("Content-Type: application/x-www-form-urlencoded")
     @POST("mark/{id}")
     fun markAsRead(
@@ -101,10 +95,7 @@ internal interface SelfossService {
     fun sources(
         @Query("username") username: String,
         @Query("password") password: String
-    ): Call<List<Source>>
+    ): Call<List<Sources>>
-
-    @GET("api/about")
-    fun version(): Call<ApiVersion>
 
     @DELETE("source/{id}")
     fun deleteSource(

app/src/main/java/apps/amine/bou/readerforselfoss/api/selfoss/SelfossTagTypeTypeAdapter.kt

@@ -1,22 +0,0 @@
-package apps.amine.bou.readerforselfoss.api.selfoss
-
-import com.google.gson.JsonDeserializationContext
-import com.google.gson.JsonDeserializer
-import com.google.gson.JsonElement
-import com.google.gson.JsonParseException
-import java.lang.reflect.Type
-
-internal class SelfossTagTypeTypeAdapter : JsonDeserializer<SelfossTagType> {
-
-    @Throws(JsonParseException::class)
-    override fun deserialize(
-        json: JsonElement,
-        typeOfT: Type,
-        context: JsonDeserializationContext
-    ): SelfossTagType? =
-        if (json.isJsonArray) {
-            SelfossTagType(json.asJsonArray.joinToString(",") { it.toString() })
-        } else {
-            SelfossTagType(json.toString())
-        }
-}

app/src/main/java/apps/amine/bou/readerforselfoss/background/background.kt

@@ -1,186 +0,0 @@
-package apps.amine.bou.readerforselfoss.background
-
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.preference.PreferenceManager
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationCompat.PRIORITY_DEFAULT
-import androidx.core.app.NotificationCompat.PRIORITY_LOW
-import androidx.room.Room
-import androidx.work.Worker
-import androidx.work.WorkerParameters
-import apps.amine.bou.readerforselfoss.MainActivity
-import apps.amine.bou.readerforselfoss.R
-import apps.amine.bou.readerforselfoss.api.selfoss.Item
-import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
-import apps.amine.bou.readerforselfoss.persistence.database.AppDatabase
-import apps.amine.bou.readerforselfoss.persistence.entities.ActionEntity
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_1_2
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_2_3
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_3_4
-import apps.amine.bou.readerforselfoss.utils.Config
-import apps.amine.bou.readerforselfoss.utils.network.isNetworkAccessible
-import apps.amine.bou.readerforselfoss.utils.persistence.toEntity
-import retrofit2.Call
-import retrofit2.Callback
-import retrofit2.Response
-import java.util.*
-import kotlin.concurrent.schedule
-import kotlin.concurrent.thread
-
-class LoadingWorker(val context: Context, params: WorkerParameters) : Worker(context, params) {
-    lateinit var db: AppDatabase
-
-    override fun doWork(): Result {
-        if (context.isNetworkAccessible(null)) {
-
-            val notificationManager =
-                applicationContext.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-            val notification = NotificationCompat.Builder(applicationContext, Config.syncChannelId)
-                .setContentTitle(context.getString(R.string.loading_notification_title))
-                .setContentText(context.getString(R.string.loading_notification_text))
-                .setOngoing(true)
-                .setPriority(PRIORITY_LOW)
-                .setChannelId(Config.syncChannelId)
-                .setSmallIcon(R.drawable.ic_stat_cloud_download_black_24dp)
-
-            notificationManager.notify(1, notification.build())
-
-            val settings =
-                this.context.getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
-            val sharedPref = PreferenceManager.getDefaultSharedPreferences(this.context)
-            val notifyNewItems = sharedPref.getBoolean("notify_new_items", false)
-
-            db = Room.databaseBuilder(
-                applicationContext,
-                AppDatabase::class.java, "selfoss-database"
-            ).addMigrations(MIGRATION_1_2).addMigrations(MIGRATION_2_3).addMigrations(MIGRATION_3_4).build()
-
-            val api = SelfossApi(
-                this.context,
-                null,
-                settings.getBoolean("isSelfSignedCert", false),
-                sharedPref.getString("api_timeout", "-1")!!.toLong()
-            )
-
-            api.allNewItems().enqueue(object : Callback<List<Item>> {
-                override fun onFailure(call: Call<List<Item>>, t: Throwable) {
-                    Timer("", false).schedule(4000) {
-                        notificationManager.cancel(1)
-                    }
-                }
-
-                override fun onResponse(
-                    call: Call<List<Item>>,
-                    response: Response<List<Item>>
-                ) {
-                    storeItems(response, true, notifyNewItems, notificationManager)
-                }
-            })
-            api.allReadItems().enqueue(object : Callback<List<Item>> {
-                override fun onFailure(call: Call<List<Item>>, t: Throwable) {
-                    Timer("", false).schedule(4000) {
-                        notificationManager.cancel(1)
-                    }
-                }
-
-                override fun onResponse(
-                        call: Call<List<Item>>,
-                        response: Response<List<Item>>
-                ) {
-                    storeItems(response, false, notifyNewItems, notificationManager)
-                }
-            })
-            api.allStarredItems().enqueue(object : Callback<List<Item>> {
-                override fun onFailure(call: Call<List<Item>>, t: Throwable) {
-                    Timer("", false).schedule(4000) {
-                        notificationManager.cancel(1)
-                    }
-                }
-
-                override fun onResponse(
-                        call: Call<List<Item>>,
-                        response: Response<List<Item>>
-                ) {
-                    storeItems(response, false, notifyNewItems, notificationManager)
-                }
-            })
-
-            thread {
-                val actions = db.actionsDao().actions()
-
-                actions.forEach { action ->
-                    when {
-                        action.read -> doAndReportOnFail(api.markItem(action.articleId), action)
-                        action.unread -> doAndReportOnFail(api.unmarkItem(action.articleId), action)
-                        action.starred -> doAndReportOnFail(api.starrItem(action.articleId), action)
-                        action.unstarred -> doAndReportOnFail(
-                            api.unstarrItem(action.articleId),
-                            action
-                        )
-                    }
-                }
-            }
-        }
-        return Result.success()
-    }
-
-    private fun storeItems(response: Response<List<Item>>, newItems: Boolean, notifyNewItems: Boolean, notificationManager: NotificationManager) {
-        thread {
-            if (response.body() != null) {
-                val apiItems = (response.body() as ArrayList<Item>)
-
-                if (newItems) {
-                    db.itemsDao().deleteAllItems()
-                }
-                db.itemsDao()
-                        .insertAllItems(*(apiItems.map { it.toEntity() }).toTypedArray())
-
-                val newSize = apiItems.filter { it.unread }.size
-                if (newItems && notifyNewItems && newSize > 0) {
-
-                    val intent = Intent(context, MainActivity::class.java).apply {
-                        flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
-                    }
-                    val pendingIntent: PendingIntent = PendingIntent.getActivity(context, 0, intent, 0)
-
-                    val newItemsNotification = NotificationCompat.Builder(applicationContext, Config.newItemsChannelId)
-                            .setContentTitle(context.getString(R.string.new_items_notification_title))
-                            .setContentText(context.getString(R.string.new_items_notification_text, newSize))
-                            .setPriority(PRIORITY_DEFAULT)
-                            .setChannelId(Config.newItemsChannelId)
-                            .setContentIntent(pendingIntent)
-                            .setAutoCancel(true)
-                            .setSmallIcon(R.drawable.ic_tab_fiber_new_black_24dp)
-
-                    Timer("", false).schedule(4000) {
-                        notificationManager.notify(2, newItemsNotification.build())
-                    }
-                }
-                apiItems.map { it.preloadImages(context) }
-            }
-            Timer("", false).schedule(4000) {
-                notificationManager.cancel(1)
-            }
-        }
-    }
-
-    private fun <T> doAndReportOnFail(call: Call<T>, action: ActionEntity) {
-        call.enqueue(object : Callback<T> {
-            override fun onResponse(
-                call: Call<T>,
-                response: Response<T>
-            ) {
-                thread {
-                    db.actionsDao().delete(action)
-                }
-            }
-
-            override fun onFailure(call: Call<T>, t: Throwable) {
-            }
-        })
-    }
-}

app/src/main/java/apps/amine/bou/readerforselfoss/fragments/ArticleFragment.kt

@@ -4,402 +4,330 @@ import android.content.Context
 import android.content.Intent
 import android.content.SharedPreferences
 import android.content.res.ColorStateList
-import android.content.res.TypedArray
-import android.graphics.Bitmap
-import android.graphics.Typeface
 import android.graphics.drawable.ColorDrawable
 import android.net.Uri
 import android.os.Build
 import android.os.Bundle
 import android.preference.PreferenceManager
-import android.view.*
-import android.webkit.*
 import androidx.browser.customtabs.CustomTabsIntent
 import com.google.android.material.floatingactionbutton.FloatingActionButton
 import androidx.fragment.app.Fragment
 import androidx.core.content.ContextCompat
 import androidx.core.widget.NestedScrollView
 import androidx.appcompat.app.AlertDialog
-import androidx.core.content.res.ResourcesCompat
+import android.view.LayoutInflater
-import androidx.room.Room
+import android.view.MenuItem
-import apps.amine.bou.readerforselfoss.ImageActivity
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebSettings
 import apps.amine.bou.readerforselfoss.R
 import apps.amine.bou.readerforselfoss.api.mercury.MercuryApi
 import apps.amine.bou.readerforselfoss.api.mercury.ParsedContent
 import apps.amine.bou.readerforselfoss.api.selfoss.Item
 import apps.amine.bou.readerforselfoss.api.selfoss.SelfossApi
 import apps.amine.bou.readerforselfoss.api.selfoss.SuccessResponse
-import apps.amine.bou.readerforselfoss.databinding.FragmentArticleBinding
-import apps.amine.bou.readerforselfoss.persistence.database.AppDatabase
-import apps.amine.bou.readerforselfoss.persistence.entities.ActionEntity
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_1_2
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_2_3
-import apps.amine.bou.readerforselfoss.persistence.migrations.MIGRATION_3_4
 import apps.amine.bou.readerforselfoss.themes.AppColors
 import apps.amine.bou.readerforselfoss.utils.Config
 import apps.amine.bou.readerforselfoss.utils.buildCustomTabsIntent
 import apps.amine.bou.readerforselfoss.utils.customtabs.CustomTabActivityHelper
-import apps.amine.bou.readerforselfoss.utils.glide.loadMaybeBasicAuth
-import apps.amine.bou.readerforselfoss.utils.glide.getBitmapInputStream
 import apps.amine.bou.readerforselfoss.utils.isEmptyOrNullOrNullString
-import apps.amine.bou.readerforselfoss.utils.network.isNetworkAccessible
+import apps.amine.bou.readerforselfoss.utils.maybeHandleSilentException
 import apps.amine.bou.readerforselfoss.utils.openItemUrl
 import apps.amine.bou.readerforselfoss.utils.shareLink
 import apps.amine.bou.readerforselfoss.utils.sourceAndDateText
 import apps.amine.bou.readerforselfoss.utils.succeeded
+import apps.amine.bou.readerforselfoss.utils.toPx
 import com.bumptech.glide.Glide
-import com.bumptech.glide.load.engine.DiskCacheStrategy
 import com.bumptech.glide.request.RequestOptions
 import com.github.rubensousa.floatingtoolbar.FloatingToolbar
+import kotlinx.android.synthetic.main.fragment_article.view.*
+import org.acra.ACRA
 import retrofit2.Call
 import retrofit2.Callback
 import retrofit2.Response
 import java.net.MalformedURLException
 import java.net.URL
-import java.util.concurrent.ExecutionException
-import kotlin.collections.ArrayList
-import kotlin.concurrent.thread
 
 class ArticleFragment : Fragment() {
     private lateinit var pageNumber: Number
-    private var fontSize: Int = 16
+    private var fontSize: Int = 14
     private lateinit var allItems: ArrayList<Item>
-    private var mCustomTabActivityHelper: CustomTabActivityHelper? = null;
+    private lateinit var mCustomTabActivityHelper: CustomTabActivityHelper
     private lateinit var url: String
     private lateinit var contentText: String
     private lateinit var contentSource: String
     private lateinit var contentImage: String
     private lateinit var contentTitle: String
-    private lateinit var allImages : ArrayList<String>
+    private var showMalformedUrl: Boolean = false
     private lateinit var editor: SharedPreferences.Editor
     private lateinit var fab: FloatingActionButton
     private lateinit var appColors: AppColors
-    private lateinit var db: AppDatabase
-    private lateinit var textAlignment: String
-    private lateinit var config: Config
-    private var _binding: FragmentArticleBinding? = null
-    private val binding get() = _binding!!
-
-    private lateinit var prefs: SharedPreferences
-
-    private var typeface: Typeface? = null
-    private var resId: Int = 0
-    private var font = ""
 
     override fun onStop() {
         super.onStop()
-        if (mCustomTabActivityHelper != null) {
+        mCustomTabActivityHelper.unbindCustomTabsService(activity)
-            mCustomTabActivityHelper!!.unbindCustomTabsService(activity)
-        }
     }
 
     override fun onCreate(savedInstanceState: Bundle?) {
-        appColors = AppColors(requireActivity())
+        appColors = AppColors(activity!!)
-        config = Config(requireActivity())
 
         super.onCreate(savedInstanceState)
 
-        pageNumber = requireArguments().getInt(ARG_POSITION)
+        pageNumber = arguments!!.getInt(ARG_POSITION)
-        allItems = requireArguments().getParcelableArrayList<Item>(ARG_ITEMS) as ArrayList<Item>
+        allItems = arguments!!.getParcelableArrayList(ARG_ITEMS)
-
-        db = Room.databaseBuilder(
-            requireContext(),
-            AppDatabase::class.java, "selfoss-database"
-        ).addMigrations(MIGRATION_1_2).addMigrations(MIGRATION_2_3).addMigrations(MIGRATION_3_4).build()
     }
 
+    private lateinit var rootView: ViewGroup
+
+
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View? {
-        try {
+        rootView = inflater
-            _binding = FragmentArticleBinding.inflate(inflater, container, false)
+            .inflate(R.layout.fragment_article, container, false) as ViewGroup
 
-            url = allItems[pageNumber.toInt()].getLinkDecoded()
+        url = allItems[pageNumber.toInt()].getLinkDecoded()
-            contentText = allItems[pageNumber.toInt()].content
+        contentText = allItems[pageNumber.toInt()].content
-            contentTitle = allItems[pageNumber.toInt()].getTitleDecoded()
+        contentTitle = allItems[pageNumber.toInt()].title
-            contentImage = allItems[pageNumber.toInt()].getThumbnail(requireActivity())
+        contentImage = allItems[pageNumber.toInt()].getThumbnail(activity!!)
-            contentSource = allItems[pageNumber.toInt()].sourceAndDateText()
+        contentSource = allItems[pageNumber.toInt()].sourceAndDateText()
-            allImages = allItems[pageNumber.toInt()].getImages()
 
-            prefs = PreferenceManager.getDefaultSharedPreferences(activity)
+        val prefs = PreferenceManager.getDefaultSharedPreferences(activity)
-            editor = prefs.edit()
+        editor = prefs.edit()
-            fontSize = prefs.getString("reader_font_size", "16")!!.toInt()
+        fontSize = prefs.getString("reader_font_size", "14").toInt()
+        showMalformedUrl = prefs.getBoolean("show_error_malformed_url", true)
 
-            font = prefs.getString("reader_font", "")!!
+        val settings = activity!!.getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
-            if (font.isNotEmpty()) {
+        val debugReadingItems = prefs.getBoolean("read_debug", false)
-                resId = requireContext().resources.getIdentifier(font, "font", requireContext().packageName)
-                typeface = try {
-                    ResourcesCompat.getFont(requireContext(), resId)!!
-                } catch (e: java.lang.Exception) {
-                    // ACRA.getErrorReporter().maybeHandleSilentException(Throwable("Font loading issue: ${e.message}"), requireContext())
-                    // Just to be sure
-                    null
-                }
-            }
 
-            refreshAlignment()
+        val api = SelfossApi(
+            context!!,
+            activity!!,
+            settings.getBoolean("isSelfSignedCert", false),
+            prefs.getBoolean("should_log_everything", false)
+        )
 
-            val settings = requireActivity().getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE)
+        fab = rootView.fab
 
-            val api = SelfossApi(
+        fab.backgroundTintList = ColorStateList.valueOf(appColors.colorAccent)
-                requireContext(),
-                requireActivity(),
-                settings.getBoolean("isSelfSignedCert", false),
-                prefs.getString("api_timeout", "-1")!!.toLong()
-            )
 
-            fab = binding.fab
+        fab.rippleColor = appColors.colorAccentDark
 
-            fab.backgroundTintList = ColorStateList.valueOf(appColors.colorAccent)
+        val floatingToolbar: FloatingToolbar = rootView.floatingToolbar
+        floatingToolbar.attachFab(fab)
 
-            fab.rippleColor = appColors.colorAccentDark
+        floatingToolbar.background = ColorDrawable(appColors.colorAccent)
 
-            val floatingToolbar: FloatingToolbar = binding.floatingToolbar
+        val customTabsIntent = activity!!.buildCustomTabsIntent()
-            floatingToolbar.attachFab(fab)
+        mCustomTabActivityHelper = CustomTabActivityHelper()
-
+        mCustomTabActivityHelper.bindCustomTabsService(activity)
-            floatingToolbar.background = ColorDrawable(appColors.colorAccent)
-
-            val customTabsIntent = requireActivity().buildCustomTabsIntent()
-            mCustomTabActivityHelper = CustomTabActivityHelper()
-            mCustomTabActivityHelper!!.bindCustomTabsService(activity)
 
 
-            floatingToolbar.setClickListener(
+        floatingToolbar.setClickListener(
-                object : FloatingToolbar.ItemClickListener {
+            object : FloatingToolbar.ItemClickListener {
-                    override fun onItemClick(item: MenuItem) {
+                override fun onItemClick(item: MenuItem) {
-                        when (item.itemId) {
+                    when (item.itemId) {
-                            R.id.more_action -> getContentFromMercury(customTabsIntent, prefs)
+                        R.id.more_action -> getContentFromMercury(customTabsIntent, prefs)
-                            R.id.share_action -> requireActivity().shareLink(url, contentTitle)
+                        R.id.share_action -> activity!!.shareLink(url)
-                            R.id.open_action -> requireActivity().openItemUrl(
+                        R.id.open_action -> activity!!.openItemUrl(
-                                allItems,
+                            allItems,
-                                pageNumber.toInt(),
+                            pageNumber.toInt(),
-                                url,
+                            url,
-                                customTabsIntent,
+                            customTabsIntent,
-                                false,
+                            false,
-                                false,
+                            false,
-                                requireActivity()
+                            activity!!
-                            )
+                        )
-                            R.id.unread_action -> if ((context != null && requireContext().isNetworkAccessible(null)) || context == null) {
+                        R.id.unread_action -> api.unmarkItem(allItems[pageNumber.toInt()].id).enqueue(
-                                api.unmarkItem(allItems[pageNumber.toInt()].id).enqueue(
+                            object : Callback<SuccessResponse> {
-                                    object : Callback<SuccessResponse> {
+                                override fun onResponse(
-                                        override fun onResponse(
+                                    call: Call<SuccessResponse>,
-                                            call: Call<SuccessResponse>,
+                                    response: Response<SuccessResponse>
-                                            response: Response<SuccessResponse>
+                                ) {
-                                        ) {
+                                    if (!response.succeeded() && debugReadingItems) {
-                                        }
+                                        val message =
-
+                                            "message: ${response.message()} " +
-                                        override fun onFailure(
+                                                    "response isSuccess: ${response.isSuccessful} " +
-                                            call: Call<SuccessResponse>,
+                                                    "response code: ${response.code()} " +
-                                            t: Throwable
+                                                    "response message: ${response.message()} " +
-                                        ) {
+                                                    "response errorBody: ${response.errorBody()?.string()} " +
-                                        }
+                                                    "body success: ${response.body()?.success} " +
+                                                    "body isSuccess: ${response.body()?.isSuccess}"
+                                        ACRA.getErrorReporter().maybeHandleSilentException(Exception(message), activity!!)
+                                    }
+                                }
+
+                                override fun onFailure(
+                                    call: Call<SuccessResponse>,
+                                    t: Throwable
+                                ) {
+                                    if (debugReadingItems) {
+                                        ACRA.getErrorReporter().maybeHandleSilentException(t, activity!!)
                                     }
-                                )
-                            } else {
-                                thread {
-                                    db.actionsDao().insertAllActions(ActionEntity(allItems[pageNumber.toInt()].id, false, true, false, false))
                                 }
                             }
-                            else -> Unit
+                        )
-                        }
+                        else -> Unit
-                    }
-
-                    override fun onItemLongClick(item: MenuItem?) {
                     }
                 }
-            )
 
-            binding.source.text = contentSource
+                override fun onItemLongClick(item: MenuItem?) {
-            if (typeface != null) {
+                }
-                binding.source.typeface = typeface
             }
+        )
 
-            if (contentText.isEmptyOrNullOrNullString()) {
+        rootView.source.text = contentSource
-                getContentFromMercury(customTabsIntent, prefs)
+
+        if (contentText.isEmptyOrNullOrNullString()) {
+            getContentFromMercury(customTabsIntent, prefs)
+        } else {
+            rootView.titleView.text = contentTitle
+
+            htmlToWebview(contentText, prefs)
+
+            if (!contentImage.isEmptyOrNullOrNullString() && context != null) {
+                rootView.imageView.visibility = View.VISIBLE
+                Glide
+                    .with(context!!)
+                    .asBitmap()
+                    .load(contentImage)
+                    .apply(RequestOptions.fitCenterTransform())
+                    .into(rootView.imageView)
             } else {
-                binding.titleView.text = contentTitle
+                rootView.imageView.visibility = View.GONE
-                if (typeface != null) {
+            }
-                    binding.titleView.typeface = typeface
+        }
-                }
 
-                htmlToWebview()
+        rootView.nestedScrollView.setOnScrollChangeListener(
-
+            NestedScrollView.OnScrollChangeListener { _, _, scrollY, _, oldScrollY ->
-                if (!contentImage.isEmptyOrNullOrNullString() && context != null) {
+                if (scrollY > oldScrollY) {
-                    binding.imageView.visibility = View.VISIBLE
+                    fab.hide()
-                    Glide
-                        .with(requireContext())
-                        .asBitmap()
-                        .loadMaybeBasicAuth(config, contentImage)
-                        .apply(RequestOptions.fitCenterTransform())
-                        .into(binding.imageView)
                 } else {
-                    binding.imageView.visibility = View.GONE
+                    if (floatingToolbar.isShowing) floatingToolbar.hide() else fab.show()
                 }
             }
+        )
 
-            binding.nestedScrollView.setOnScrollChangeListener(
+        return rootView
-                NestedScrollView.OnScrollChangeListener { _, _, scrollY, _, oldScrollY ->
-                    if (scrollY > oldScrollY) {
-                        fab.hide()
-                    } else {
-                        if (floatingToolbar.isShowing) floatingToolbar.hide() else fab.show()
-                    }
-                }
-            )
-
-        } catch (e: InflateException) {
-            AlertDialog.Builder(requireContext())
-                .setMessage(requireContext().getString(R.string.webview_dialog_issue_message))
-                .setTitle(requireContext().getString(R.string.webview_dialog_issue_title))
-                .setPositiveButton(android.R.string.ok
-                ) { dialog, which ->
-                    val sharedPref = PreferenceManager.getDefaultSharedPreferences(requireContext())
-                    val editor = sharedPref.edit()
-                    editor.putBoolean("prefer_article_viewer", false)
-                    editor.commit()
-                    requireActivity().finish()
-                }
-                .create()
-                .show()
-        }
-
-        return binding.root
-    }
-
-    override fun onDestroyView() {
-        super.onDestroyView()
-        _binding = null
-    }
-
-    private fun refreshAlignment() {
-        textAlignment = when (prefs.getInt("text_align", 1)) {
-            1 -> "justify"
-            2 -> "left"
-            else -> "justify"
-        }
     }
 
     private fun getContentFromMercury(
         customTabsIntent: CustomTabsIntent,
         prefs: SharedPreferences
     ) {
-        if ((context != null && requireContext().isNetworkAccessible(null)) || context == null) {
+        rootView.progressBar.visibility = View.VISIBLE
-            binding.progressBar.visibility = View.VISIBLE
+        val parser = MercuryApi(
-            val parser = MercuryApi()
+            prefs.getBoolean("should_log_everything", false)
+        )
 
-            parser.parseUrl(url).enqueue(
+        parser.parseUrl(url).enqueue(
-                object : Callback<ParsedContent> {
+            object : Callback<ParsedContent> {
-                    override fun onResponse(
+                override fun onResponse(
-                        call: Call<ParsedContent>,
+                    call: Call<ParsedContent>,
-                        response: Response<ParsedContent>
+                    response: Response<ParsedContent>
-                    ) {
+                ) {
-                        // TODO: clean all the following after finding the mercury content issue
+                    // TODO: clean all the following after finding the mercury content issue
-                        try {
+                    try {
-                            if (response.body() != null && response.body()!!.content != null && !response.body()!!.content.isNullOrEmpty()) {
+                        if (response.body() != null && response.body()!!.content != null && !response.body()!!.content.isNullOrEmpty()) {
-                                try {
+                            try {
-                                    binding.titleView.text = response.body()!!.title
+                                rootView.titleView.text = response.body()!!.title
-                                    if (typeface != null) {
+                                url = response.body()!!.url
-                                        binding.titleView.typeface = typeface
+                            } catch (e: Exception) {
-                                    }
+                                if (context != null) {
-                                    try {
+                                    ACRA.getErrorReporter().maybeHandleSilentException(e, context!!)
-                                        // Note: Mercury may return relative urls... If it does the url val will not be changed.
-                                        URL(response.body()!!.url)
-                                        url = response.body()!!.url
-                                    } catch (e: MalformedURLException) {
-                                        // Mercury returned a relative url. We do nothing.
-                                    }
-                                } catch (e: Exception) {
-                                }
-
-                                try {
-                                    contentText = response.body()!!.content.orEmpty()
-                                    htmlToWebview()
-                                } catch (e: Exception) {
-                                }
-
-                                try {
-                                    if (response.body()!!.lead_image_url != null && !response.body()!!.lead_image_url.isNullOrEmpty() && context != null) {
-                                        binding.imageView.visibility = View.VISIBLE
-                                        try {
-                                            Glide
-                                                .with(requireContext())
-                                                .asBitmap()
-                                                .loadMaybeBasicAuth(config, response.body()!!.lead_image_url.orEmpty())
-                                                .apply(RequestOptions.fitCenterTransform())
-                                                .into(binding.imageView)
-                                        } catch (e: Exception) {
-                                        }
-                                    } else {
-                                        binding.imageView.visibility = View.GONE
-                                    }
-                                } catch (e: Exception) {
-                                    if (context != null) {
-                                    }
-                                }
-
-                                try {
-                                    binding.nestedScrollView.scrollTo(0, 0)
-
-                                    binding.progressBar.visibility = View.GONE
-                                } catch (e: Exception) {
-                                    if (context != null) {
-                                    }
-                                }
-                            } else {
-                                try {
-                                    openInBrowserAfterFailing(customTabsIntent)
-                                } catch (e: Exception) {
-                                    if (context != null) {
-                                    }
                                 }
                             }
-                        } catch (e: Exception) {
+
-                            if (context != null) {
+                            try {
+                                htmlToWebview(response.body()!!.content.orEmpty(), prefs)
+                            } catch (e: Exception) {
+                                if (context != null) {
+                                    ACRA.getErrorReporter().maybeHandleSilentException(e, context!!)
+                                }
+                            }
+
+                            try {
+                                if (response.body()!!.lead_image_url != null && !response.body()!!.lead_image_url.isNullOrEmpty() && context != null) {
+                                    rootView.imageView.visibility = View.VISIBLE
+                                    try {
+                                        Glide
+                                            .with(context!!)
+                                            .asBitmap()
+                                            .load(response.body()!!.lead_image_url)
+                                            .apply(RequestOptions.fitCenterTransform())
+                                            .into(rootView.imageView)
+                                    } catch (e: Exception) {
+                                        ACRA.getErrorReporter().maybeHandleSilentException(e, context!!)
+                                    }
+                                } else {
+                                    rootView.imageView.visibility = View.GONE
+                                }
+                            } catch (e: Exception) {
+                                if (context != null) {
+                                    ACRA.getErrorReporter().maybeHandleSilentException(e, context!!)
+                                }
+                            }
+
+                            try {
+                                rootView.nestedScrollView.scrollTo(0, 0)
+
+                                rootView.progressBar.visibility = View.GONE
+                            } catch (e: Exception) {
+                                if (context != null) {
+                                    ACRA.getErrorReporter().maybeHandleSilentException(e, context!!)
+                                }
+                            }
+                        } else {
+                            try {
+                                openInBrowserAfterFailing(customTabsIntent)
+                            } catch (e: Exception) {
+                                if (context != null) {
+                                    ACRA.getErrorReporter().maybeHandleSilentException(e, context!!)
+                                }
                             }
                         }
+                    } catch (e: Exception) {
+                        if (context != null) {
+                            ACRA.getErrorReporter().maybeHandleSilentException(e, context!!)
+                        }
                     }
-
-                    override fun onFailure(
-                        call: Call<ParsedContent>,
-                        t: Throwable
-                    ) = openInBrowserAfterFailing(customTabsIntent)
                 }
-            )
+
-        }
+                override fun onFailure(
+                    call: Call<ParsedContent>,
+                    t: Throwable
+                ) = openInBrowserAfterFailing(customTabsIntent)
+            }
+        )
     }
 
-    private fun htmlToWebview() {
+    private fun htmlToWebview(c: String, prefs: SharedPreferences) {
         val stringColor = String.format("#%06X", 0xFFFFFF and appColors.colorAccent)
 
-        val attrs: IntArray = intArrayOf(android.R.attr.fontFamily)
+        rootView.webcontent.visibility = View.VISIBLE
-        val a: TypedArray = requireContext().obtainStyledAttributes(resId, attrs)
-
-
-        binding.webcontent.settings.standardFontFamily = a.getString(0)
-        binding.webcontent.visibility = View.VISIBLE
         val (textColor, backgroundColor) = if (appColors.isDarkTheme) {
             if (context != null) {
-                binding.webcontent.setBackgroundColor(
+                rootView.webcontent.setBackgroundColor(
                     ContextCompat.getColor(
-                        requireContext(),
+                        context!!,
                         R.color.dark_webview
                     )
                 )
-                Pair(ContextCompat.getColor(requireContext(), R.color.dark_webview_text), ContextCompat.getColor(requireContext(), R.color.dark_webview))
+                Pair(ContextCompat.getColor(context!!, R.color.dark_webview_text), ContextCompat.getColor(context!!, R.color.light_webview_text))
             } else {
                 Pair(null, null)
             }
         } else {
             if (context != null) {
-                binding.webcontent.setBackgroundColor(
+                rootView.webcontent.setBackgroundColor(
                     ContextCompat.getColor(
-                        requireContext(),
+                        context!!,
                         R.color.light_webview
                     )
                 )
-                Pair(ContextCompat.getColor(requireContext(), R.color.light_webview_text), ContextCompat.getColor(requireContext(), R.color.light_webview))
+                Pair(ContextCompat.getColor(context!!, R.color.light_webview_text), ContextCompat.getColor(context!!, R.color.dark_webview_text))
             } else {
                 Pair(null, null)
             }
@@ -417,56 +345,15 @@ class ArticleFragment : Fragment() {
             "#FFFFFF"
         }
 
-        binding.webcontent.settings.useWideViewPort = true
+        rootView.webcontent.settings.useWideViewPort = true
-        binding.webcontent.settings.loadWithOverviewMode = true
+        rootView.webcontent.settings.loadWithOverviewMode = true
-        binding.webcontent.settings.javaScriptEnabled = false
+        rootView.webcontent.settings.javaScriptEnabled = false
-
-        binding.webcontent.webViewClient = object : WebViewClient() {
-            override fun shouldOverrideUrlLoading(view: WebView?, url : String): Boolean {
-                if (binding.webcontent.hitTestResult.type != WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE) {
-                    requireContext().startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(url)))
-                }
-                return true
-            }
-
-            override fun shouldInterceptRequest(view: WebView?, url: String): WebResourceResponse? {
-                val glideOptions = RequestOptions.diskCacheStrategyOf(DiskCacheStrategy.ALL)
-                if (url.toLowerCase().contains(".jpg") || url.toLowerCase().contains(".jpeg")) {
-                    try {
-                        val image = Glide.with(view).asBitmap().apply(glideOptions).load(url).submit().get()
-                        return WebResourceResponse("image/jpg", "UTF-8", getBitmapInputStream(image, Bitmap.CompressFormat.JPEG))
-                    }catch ( e : ExecutionException) {}
-                }
-                else if (url.toLowerCase().contains(".png")) {
-                    try {
-                        val image = Glide.with(view).asBitmap().apply(glideOptions).load(url).submit().get()
-                        return WebResourceResponse("image/jpg", "UTF-8", getBitmapInputStream(image, Bitmap.CompressFormat.PNG))
-                    }catch ( e : ExecutionException) {}
-                }
-                else if (url.toLowerCase().contains(".webp")) {
-                    try {
-                        val image = Glide.with(view).asBitmap().apply(glideOptions).load(url).submit().get()
-                        return WebResourceResponse("image/jpg", "UTF-8", getBitmapInputStream(image, Bitmap.CompressFormat.WEBP))
-                    }catch ( e : ExecutionException) {}
-                }
-
-                return super.shouldInterceptRequest(view, url)
-            }
-        }
-
-        val gestureDetector = GestureDetector(activity, object : GestureDetector.SimpleOnGestureListener() {
-            override fun onSingleTapUp(e: MotionEvent?): Boolean {
-                return performClick()
-            }
-        })
-
-        binding.webcontent.setOnTouchListener { _, event -> gestureDetector.onTouchEvent(event)}
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
-            binding.webcontent.settings.layoutAlgorithm =
+            rootView.webcontent.settings.layoutAlgorithm =
                     WebSettings.LayoutAlgorithm.TEXT_AUTOSIZING
         } else {
-            binding.webcontent.settings.layoutAlgorithm = WebSettings.LayoutAlgorithm.SINGLE_COLUMN
+            rootView.webcontent.settings.layoutAlgorithm = WebSettings.LayoutAlgorithm.SINGLE_COLUMN
         }
 
         var baseUrl: String? = null
@@ -475,88 +362,88 @@ class ArticleFragment : Fragment() {
             val itemUrl = URL(url)
             baseUrl = itemUrl.protocol + "://" + itemUrl.host
         } catch (e: MalformedURLException) {
+            if (showMalformedUrl && context != null) {
+                val alertDialog = AlertDialog.Builder(context!!).create()
+                alertDialog.setTitle("Error")
+                alertDialog.setMessage("You are encountering a bug that I can't solve. Can you please contact me to solve the issue, please ?")
+                alertDialog.setButton(
+                    AlertDialog.BUTTON_POSITIVE,
+                    "Send mail"
+                ) { dialog, _ ->
+
+                    // This won't be translated because it should only be temporary.
+                    val to = Config.feedbackEmail
+                    val subject= "[ReaderForSelfoss MalformedURLException]"
+                    val body= "Please specify the source, item and spout you are using for the url below : \n ${e.message}"
+                    val mailTo = "mailto:" + to + "?&subject=" + Uri.encode(subject) + "&body=" + Uri.encode(body)
+
+                    val emailIntent = Intent(Intent.ACTION_VIEW)
+                    emailIntent.data = Uri.parse(mailTo)
+                    startActivity(emailIntent)
+
+                    dialog.dismiss()
+                }
+                alertDialog.setButton(
+                    AlertDialog.BUTTON_NEUTRAL,
+                    "Not now"
+                ) { dialog, _ -> dialog.dismiss() }
+                alertDialog.setButton(
+                    AlertDialog.BUTTON_NEGATIVE,
+                    "Don't show anymore."
+                ) { dialog, _ ->
+                    editor.putBoolean("show_error_malformed_url", false)
+                    editor.apply()
+                    dialog.dismiss()
+                }
+                alertDialog.show()
+            }
         }
 
-        val fontName =  when (font) {
+        rootView.webcontent.loadDataWithBaseURL(
-            getString(R.string.open_sans_font_id) -> "Open Sans"
-            getString(R.string.roboto_font_id) -> "Roboto"
-            else -> ""
-        }
-
-        val fontLinkAndStyle = if (font.isNotEmpty()) {
-            """<link href="https://fonts.googleapis.com/css?family=${fontName.replace(" ", "+")}" rel="stylesheet">
-                |<style>
-                |   * {
-                |       font-family: '$fontName';
-                |   }
-                |</style>
-            """.trimMargin()
-        } else {
-            ""
-        }
-
-        binding.webcontent.loadDataWithBaseURL(
             baseUrl,
-            """<html>
+            """<style>
-                |<head>
+                |img {
-                |   <meta name="viewport" content="width=device-width, initial-scale=1">
+                |  display: inline-block;
-                |   <style>
+                |  height: auto;
-                |      img {
+                |  width: 100%;
-                |        display: inline-block;
+                |  max-width: 100%;
-                |        height: auto;
+                |}
-                |        width: 100%;
+                |a {
-                |        max-width: 100%;
+                |  color: $stringColor !important;
-                |      }
+                |}
-                |      a {
+                |*:not(a) {
-                |        color: $stringColor !important;
+                |  color: $stringTextColor;
-                |      }
+                |}
-                |      *:not(a) {
+                |* {
-                |        color: $stringTextColor;
+                |  font-size: ${fontSize.toPx}px;
-                |      }
+                |  text-align: justify;
-                |      * {
+                |  word-break: break-word;
-                |        font-size: ${fontSize}px;
+                |  overflow:hidden;
-                |        text-align: $textAlignment;
+                |}
-                |        word-break: break-word;
+                |a, pre, code {
-                |        overflow:hidden;
+                |  text-align: left;
-                |        line-height: 1.5em;
+                |}
-                |        background-color: $stringBackgroundColor;
+                |pre, code {
-                |      }
+                |  white-space: pre-wrap;
-                |      body, html {
+                |  width:100%;
-                |        background-color: $stringBackgroundColor !important;
+                |  background-color: $stringBackgroundColor;
-                |        border-color: $stringBackgroundColor  !important;
+                |}</style>$c""".trimMargin(),
-                |        padding: 0 !important;
+            "text/html; charset=utf-8",
-                |        margin: 0 !important;
-                |      }
-                |      a, pre, code {
-                |        text-align: $textAlignment;
-                |      }
-                |      pre, code {
-                |        white-space: pre-wrap;
-                |        width:100%;
-                |        background-color: $stringBackgroundColor;
-                |      }
-                |   </style>
-                |   $fontLinkAndStyle
-                |</head>
-                |<body>
-                |   $contentText
-                |</body>""".trimMargin(),
-            "text/html",
             "utf-8",
             null
         )
     }
 
     private fun openInBrowserAfterFailing(customTabsIntent: CustomTabsIntent) {
-        binding.progressBar.visibility = View.GONE
+        rootView.progressBar.visibility = View.GONE
-        requireActivity().openItemUrl(
+        activity!!.openItemUrl(
             allItems,
             pageNumber.toInt(),
             url,
             customTabsIntent,
             true,
             false,
-            requireActivity()
+            activity!!
         )
     }
 
@@ -577,20 +464,5 @@ class ArticleFragment : Fragment() {
         }
     }
 
-    fun performClick(): Boolean {
-        if (binding.webcontent.hitTestResult.type == WebView.HitTestResult.IMAGE_TYPE ||
-                binding.webcontent.hitTestResult.type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE) {
-
-            val position : Int = allImages.indexOf(binding.webcontent.hitTestResult.extra)
-
-            val intent = Intent(activity, ImageActivity::class.java)
-            intent.putExtra("allImages", allImages)
-            intent.putExtra("position", position)
-            startActivity(intent)
-            return false
-        }
-        return false
-    }
-
 
 }

app/src/main/java/apps/amine/bou/readerforselfoss/fragments/ImageFragment.kt

@@ -1,57 +0,0 @@
-package apps.amine.bou.readerforselfoss.fragments
-
-import android.os.Bundle
-import android.view.*
-import androidx.fragment.app.Fragment
-import apps.amine.bou.readerforselfoss.R
-import apps.amine.bou.readerforselfoss.databinding.FragmentImageBinding
-import com.bumptech.glide.Glide
-import com.bumptech.glide.load.engine.DiskCacheStrategy
-import com.bumptech.glide.request.RequestOptions
-
-class ImageFragment : Fragment() {
-
-    private lateinit var imageUrl : String
-    private val glideOptions = RequestOptions.diskCacheStrategyOf(DiskCacheStrategy.ALL)
-    private var _binding: FragmentImageBinding? = null
-    private val binding get() = _binding
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-
-        imageUrl = requireArguments().getString("imageUrl")!!
-    }
-
-    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
-        _binding = FragmentImageBinding.inflate(inflater, container, false)
-        val view = binding?.root
-
-        binding!!.photoView.visibility = View.VISIBLE
-        Glide.with(activity)
-                .asBitmap()
-                .apply(glideOptions)
-                .load(imageUrl)
-                .into(binding!!.photoView)
-
-        return view
-    }
-
-    override fun onDestroyView() {
-        super.onDestroyView()
-        _binding = null
-    }
-
-    companion object {
-        private const val ARG_IMAGE = "imageUrl"
-
-        fun newInstance(
-                imageUrl : String
-        ): ImageFragment {
-            val fragment = ImageFragment()
-            val args = Bundle()
-            args.putString(ARG_IMAGE, imageUrl)
-            fragment.arguments = args
-            return fragment
-        }
-    }
-}

app/src/main/java/apps/amine/bou/readerforselfoss/persistence/dao/ActionsDao.kt

@@ -1,23 +0,0 @@
-package apps.amine.bou.readerforselfoss.persistence.dao
-
-import androidx.room.Dao
-import androidx.room.Delete
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import apps.amine.bou.readerforselfoss.persistence.entities.ActionEntity
-
-@Dao
-interface ActionsDao {
-    @Query("SELECT * FROM actions order by id asc")
-    fun actions(): List<ActionEntity>
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    fun insertAllActions(vararg actions: ActionEntity)
-
-    @Query("DELETE FROM actions WHERE articleid = :article_id AND read = 1")
-    fun deleteReadActionForArticle(article_id: String)
-
-    @Delete
-    fun delete(action: ActionEntity)
-}

app/src/main/java/apps/amine/bou/readerforselfoss/persistence/dao/DrawerDataDao.kt

@@ -1,36 +0,0 @@
-package apps.amine.bou.readerforselfoss.persistence.dao
-
-import androidx.room.Delete
-import androidx.room.Dao
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import apps.amine.bou.readerforselfoss.persistence.entities.SourceEntity
-import apps.amine.bou.readerforselfoss.persistence.entities.TagEntity
-
-@Dao
-interface DrawerDataDao {
-    @Query("SELECT * FROM tags")
-    fun tags(): List<TagEntity>
-
-    @Query("SELECT * FROM sources")
-    fun sources(): List<SourceEntity>
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    fun insertAllTags(vararg tags: TagEntity)
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    fun insertAllSources(vararg sources: SourceEntity)
-
-    @Query("DELETE FROM tags")
-    fun deleteAllTags()
-
-    @Query("DELETE FROM sources")
-    fun deleteAllSources()
-
-    @Delete
-    fun deleteTag(tag: TagEntity)
-
-    @Delete
-    fun deleteSource(source: SourceEntity)
-}

app/src/main/java/apps/amine/bou/readerforselfoss/persistence/dao/ItemsDao.kt

@@ -1,29 +0,0 @@
-package apps.amine.bou.readerforselfoss.persistence.dao
-
-import androidx.room.Dao
-import androidx.room.Delete
-import androidx.room.Insert
-import androidx.room.OnConflictStrategy
-import androidx.room.Query
-import apps.amine.bou.readerforselfoss.persistence.entities.ItemEntity
-import androidx.room.Update
-
-
-
-@Dao
-interface ItemsDao {
-    @Query("SELECT * FROM items order by id desc")
-    fun items(): List<ItemEntity>
-
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    fun insertAllItems(vararg items: ItemEntity)
-
-    @Query("DELETE FROM items")
-    fun deleteAllItems()
-
-    @Delete
-    fun delete(item: ItemEntity)
-
-    @Update
-    fun updateItem(item: ItemEntity)
-}

app/src/main/java/apps/amine/bou/readerforselfoss/persistence/database/AppDatabase.kt

@@ -1,20 +0,0 @@
-package apps.amine.bou.readerforselfoss.persistence.database
-
-import androidx.room.RoomDatabase
-import androidx.room.Database
-import apps.amine.bou.readerforselfoss.persistence.dao.ActionsDao
-import apps.amine.bou.readerforselfoss.persistence.dao.DrawerDataDao
-import apps.amine.bou.readerforselfoss.persistence.dao.ItemsDao
-import apps.amine.bou.readerforselfoss.persistence.entities.ActionEntity
-import apps.amine.bou.readerforselfoss.persistence.entities.ItemEntity
-import apps.amine.bou.readerforselfoss.persistence.entities.SourceEntity
-import apps.amine.bou.readerforselfoss.persistence.entities.TagEntity
-
-@Database(entities = [TagEntity::class, SourceEntity::class, ItemEntity::class, ActionEntity::class], version = 4)
-abstract class AppDatabase : RoomDatabase() {
-    abstract fun drawerDataDao(): DrawerDataDao
-
-    abstract fun itemsDao(): ItemsDao
-
-    abstract fun actionsDao(): ActionsDao
-}

app/src/main/java/apps/amine/bou/readerforselfoss/persistence/entities/ActionEntity.kt

@@ -1,22 +0,0 @@
-package apps.amine.bou.readerforselfoss.persistence.entities
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-@Entity(tableName = "actions")
-data class ActionEntity(
-    @ColumnInfo(name = "articleid")
-    val articleId: String,
-    @ColumnInfo(name = "read")
-    val read: Boolean,
-    @ColumnInfo(name = "unread")
-    val unread: Boolean,
-    @ColumnInfo(name = "starred")
-    var starred: Boolean,
-    @ColumnInfo(name = "unstarred")
-    var unstarred: Boolean
-) {
-    @PrimaryKey(autoGenerate = true)
-    var id: Int = 0
-}

app/src/main/java/apps/amine/bou/readerforselfoss/persistence/entities/DrawerDataEntity.kt

@@ -1,33 +0,0 @@
-package apps.amine.bou.readerforselfoss.persistence.entities
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-@Entity(tableName = "tags")
-data class TagEntity(
-    @PrimaryKey
-    @ColumnInfo(name = "tag")
-    val tag: String,
-    @ColumnInfo(name = "color")
-    val color: String,
-    @ColumnInfo(name = "unread")
-    val unread: Int
-)
-
-@Entity(tableName = "sources")
-data class SourceEntity(
-    @PrimaryKey
-    @ColumnInfo(name = "id")
-    val id: String,
-    @ColumnInfo(name = "title")
-    val title: String,
-    @ColumnInfo(name = "tags")
-    val tags: String,
-    @ColumnInfo(name = "spout")
-    val spout: String,
-    @ColumnInfo(name = "error")
-    val error: String,
-    @ColumnInfo(name = "icon")
-    val icon: String
-)

app/src/main/java/apps/amine/bou/readerforselfoss/persistence/entities/ItemEntity.kt

@@ -1,32 +0,0 @@
-package apps.amine.bou.readerforselfoss.persistence.entities
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import androidx.room.PrimaryKey
-
-@Entity(tableName = "items")
-data class ItemEntity(
-    @PrimaryKey
-    @ColumnInfo(name = "id")
-    val id: String,
-    @ColumnInfo(name = "datetime")
-    val datetime: String,
-    @ColumnInfo(name = "title")
-    val title: String,
-    @ColumnInfo(name = "content")
-    val content: String,
-    @ColumnInfo(name = "unread")
-    val unread: Boolean,
-    @ColumnInfo(name = "starred")
-    var starred: Boolean,
-    @ColumnInfo(name = "thumbnail")
-    val thumbnail: String?,
-    @ColumnInfo(name = "icon")
-    val icon: String?,
-    @ColumnInfo(name = "link")
-    val link: String,
-    @ColumnInfo(name = "sourcetitle")
-    val sourcetitle: String,
-    @ColumnInfo(name = "tags")
-    val tags: String
-)

app/src/main/java/apps/amine/bou/readerforselfoss/persistence/migrations/migrations.kt

@@ -1,34 +0,0 @@
-package apps.amine.bou.readerforselfoss.persistence.migrations
-
-import androidx.sqlite.db.SupportSQLiteDatabase
-import androidx.room.migration.Migration
-
-val MIGRATION_1_2: Migration = object : Migration(1, 2) {
-    override fun migrate(database: SupportSQLiteDatabase) {
-        database.execSQL("CREATE TABLE IF NOT EXISTS `items` (`id` TEXT NOT NULL, `datetime` TEXT NOT NULL, `title` TEXT NOT NULL, `content` TEXT NOT NULL, `unread` INTEGER NOT NULL, `starred` INTEGER NOT NULL, `thumbnail` TEXT NOT NULL, `icon` TEXT NOT NULL, `link` TEXT NOT NULL, `sourcetitle` TEXT NOT NULL, `tags` TEXT NOT NULL, PRIMARY KEY(`id`))")
-    }
-}
-
-val MIGRATION_2_3: Migration = object : Migration(2, 3) {
-    override fun migrate(database: SupportSQLiteDatabase) {
-        database.execSQL("CREATE TABLE IF NOT EXISTS `actions` (`id` INTEGER NOT NULL, `articleid` TEXT NOT NULL, `read` INTEGER NOT NULL, `unread` INTEGER NOT NULL, `starred` INTEGER NOT NULL, `unstarred` INTEGER NOT NULL, PRIMARY KEY(`id`))")
-    }
-}
-
-val MIGRATION_3_4: Migration = object : Migration(3, 4) {
-    override fun migrate(database: SupportSQLiteDatabase) {
-        // @see https://stackoverflow.com/questions/57392015/how-to-migrate-not-null-table-column-into-null-in-android-room-database
-        // Create the new table
-        database.execSQL("CREATE TABLE IF NOT EXISTS `itemstmp` (`id` TEXT NOT NULL, `datetime` TEXT NOT NULL, `title` TEXT NOT NULL, `content` TEXT NOT NULL, `unread` INTEGER NOT NULL, `starred` INTEGER NOT NULL, `thumbnail` TEXT, `icon` TEXT, `link` TEXT NOT NULL, `sourcetitle` TEXT NOT NULL, `tags` TEXT NOT NULL, PRIMARY KEY(`id`))")
-
-        // Copy the data
-        database.execSQL(
-                "INSERT INTO itemstmp (`id`, `datetime`, `title`, `content`, `unread`, `starred`, `thumbnail`, `icon`, `link`, `sourcetitle`, `tags`) SELECT `id`, `datetime`, `title`, `content`, `unread`, `starred`, `thumbnail`, `icon`, `link`, `sourcetitle`, `tags` FROM items")
-
-        // Remove the old table
-        database.execSQL("DROP TABLE items")
-
-        // Change the table name to the correct one
-        database.execSQL("ALTER TABLE itemstmp RENAME TO items")
-    }
-}

app/src/main/java/apps/amine/bou/readerforselfoss/settings/AppCompatPreferenceActivity.java

@@ -7,7 +7,6 @@ import android.preference.PreferenceActivity;
 import androidx.annotation.LayoutRes;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
-import com.google.android.material.appbar.AppBarLayout;
 import androidx.appcompat.app.ActionBar;
 import androidx.appcompat.app.AppCompatDelegate;
 import androidx.appcompat.widget.Toolbar;
@@ -18,6 +17,7 @@ import android.view.ViewGroup;
 import android.widget.LinearLayout;
 
 import com.ftinc.scoop.Scoop;
+import com.google.android.material.appbar.AppBarLayout;
 
 import apps.amine.bou.readerforselfoss.R;
 import apps.amine.bou.readerforselfoss.themes.AppColors;

app/src/main/java/apps/amine/bou/readerforselfoss/settings/SettingsActivity.java

@@ -8,7 +8,6 @@ import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.res.Configuration;
-import android.content.res.Resources;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
@@ -25,7 +24,6 @@ import android.text.Editable;
 import android.text.InputFilter;
 import android.text.Spanned;
 import android.text.TextWatcher;
-import android.util.Log;
 import android.view.Menu;
 import android.view.MenuInflater;
 import android.view.MenuItem;
@@ -126,27 +124,6 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
     @TargetApi(Build.VERSION_CODES.HONEYCOMB)
     public void onBuildHeaders(List<Header> target) {
         loadHeadersFromResource(R.xml.pref_headers, target);
-
-        AppColors appColors = new AppColors(this);
-        if (appColors != null && appColors.isDarkTheme()) {
-            for (Header header : target) {
-                tryLoadIconDark(header);
-            }
-        }
-    }
-
-    private void tryLoadIconDark(Header header){
-        try{
-            if (header.fragmentArguments != null) {
-                String iconDark = header.fragmentArguments.getString("iconDark");
-                int iconDarkId = getResources().getIdentifier(iconDark, "drawable", getPackageName());
-                if (iconDarkId != 0) {
-                    header.iconRes = iconDarkId;
-                }
-            }
-        } catch (Exception e) {
-            Log.e("SettingsActivity", "Can not load dark icon", e);
-        }
     }
 
     /**
@@ -158,8 +135,7 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
         return PreferenceFragment.class.getName().equals(fragmentName)
                 || GeneralPreferenceFragment.class.getName().equals(fragmentName)
                 || ArticleViewerPreferenceFragment.class.getName().equals(fragmentName)
-                || OfflinePreferenceFragment.class.getName().equals(fragmentName)
+                || DebugPreferenceFragment.class.getName().equals(fragmentName)
-                || ExperimentalPreferenceFragment.class.getName().equals(fragmentName)
                 || LinksPreferenceFragment.class.getName().equals(fragmentName)
                 || ThemePreferenceFragment.class.getName().equals(fragmentName);
     }
@@ -176,6 +152,17 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
             addPreferencesFromResource(R.xml.pref_general);
             setHasOptionsMenu(true);
 
+            SwitchPreference cardViewActive = (SwitchPreference) findPreference("card_view_active");
+            final SwitchPreference tabOnTap = (SwitchPreference) findPreference("tab_on_tap");
+            tabOnTap.setEnabled(!cardViewActive.isChecked());
+            cardViewActive.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
+                public boolean onPreferenceChange(Preference preference, Object newValue) {
+                    boolean isEnabled = (Boolean) newValue;
+                    tabOnTap.setEnabled(!isEnabled);
+                    return true;
+                }
+            });
+
             EditTextPreference itemsNumber = (EditTextPreference) findPreference("prefer_api_items_number");
             itemsNumber.getEditText().setFilters(new InputFilter[]{
                     new InputFilter() {
@@ -195,6 +182,16 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
             });
 
         }
+
+        @Override
+        public boolean onOptionsItemSelected(MenuItem item) {
+            int id = item.getItemId();
+            if (id == android.R.id.home) {
+                getActivity().finish();
+                return true;
+            }
+            return super.onOptionsItemSelected(item);
+        }
     }
 
     @TargetApi(Build.VERSION_CODES.HONEYCOMB)
@@ -235,6 +232,58 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
                     }
             });
         }
+
+        @Override
+        public boolean onOptionsItemSelected(MenuItem item) {
+            int id = item.getItemId();
+            if (id == android.R.id.home) {
+                getActivity().finish();
+                return true;
+            }
+            return super.onOptionsItemSelected(item);
+        }
+    }
+
+    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+    public static class DebugPreferenceFragment extends PreferenceFragment {
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            addPreferencesFromResource(R.xml.pref_debug);
+            setHasOptionsMenu(true);
+
+            SharedPreferences pref = getActivity().getSharedPreferences(Config.settingsName, Context.MODE_PRIVATE);
+            final String id = pref.getString("unique_id", "...");
+
+            final Preference identifier = findPreference("debug_identifier");
+            final ClipboardManager clipboard = (ClipboardManager)
+                    getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
+
+            identifier.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+                @Override
+                public boolean onPreferenceClick(Preference preference) {
+                    if (clipboard != null) {
+                        ClipData clip = ClipData.newPlainText("Selfoss unique id", id);
+                        clipboard.setPrimaryClip(clip);
+
+                        Toast.makeText(getActivity(), R.string.unique_id_to_clipboard, Toast.LENGTH_LONG).show();
+                        return true;
+                    }
+                    return false;
+                }
+            });
+            identifier.setTitle(id);
+        }
+
+        @Override
+        public boolean onOptionsItemSelected(MenuItem item) {
+            int id = item.getItemId();
+            if (id == android.R.id.home) {
+                getActivity().finish();
+                return true;
+            }
+            return super.onOptionsItemSelected(item);
+        }
     }
 
     /**
@@ -278,6 +327,16 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
                 }
             });
         }
+
+        @Override
+        public boolean onOptionsItemSelected(MenuItem item) {
+            int id = item.getItemId();
+            if (id == android.R.id.home) {
+                getActivity().finish();
+                return true;
+            }
+            return super.onOptionsItemSelected(item);
+        }
     }
 
     @TargetApi(Build.VERSION_CODES.HONEYCOMB)
@@ -292,7 +351,10 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
         @Override
         public boolean onOptionsItemSelected(MenuItem item) {
             int id = item.getItemId();
-            if (id == R.id.clear) {
+            if (id == android.R.id.home) {
+                getActivity().finish();
+                return true;
+            } else if (id == R.id.clear) {
                 SharedPreferences pref = PreferenceManager.getDefaultSharedPreferences(getActivity());
                 SharedPreferences.Editor editor = pref.edit();
                 editor.remove("color_primary");
@@ -301,7 +363,7 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
                 editor.remove("color_accent_dark");
                 editor.remove("dark_theme");
                 editor.apply();
-                getActivity().recreate();
+                getActivity().finish();
             }
             return super.onOptionsItemSelected(item);
         }
@@ -312,32 +374,11 @@ public class SettingsActivity extends AppCompatPreferenceActivity {
         }
     }
 
-    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
-    public static class OfflinePreferenceFragment extends PreferenceFragment {
-        @Override
-        public void onCreate(Bundle savedInstanceState) {
-            super.onCreate(savedInstanceState);
-            addPreferencesFromResource(R.xml.pref_offline);
-            setHasOptionsMenu(true);
-        }
-    }
-
-    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
-    public static class ExperimentalPreferenceFragment extends PreferenceFragment {
-        @Override
-        public void onCreate(Bundle savedInstanceState) {
-            super.onCreate(savedInstanceState);
-            addPreferencesFromResource(R.xml.pref_experimental);
-            setHasOptionsMenu(true);
-        }
-    }
-
-
     @Override
     public boolean onOptionsItemSelected(MenuItem item) {
         int id = item.getItemId();
         if (id == android.R.id.home) {
-            super.onBackPressed();
+            finish();
             return true;
         }
         return super.onOptionsItemSelected(item);

app/src/main/java/apps/amine/bou/readerforselfoss/themes/AppColors.kt

@@ -3,12 +3,9 @@ package apps.amine.bou.readerforselfoss.themes
 import android.app.Activity
 import android.content.Context
 import android.preference.PreferenceManager
-import androidx.annotation.ColorInt
-import androidx.appcompat.view.ContextThemeWrapper
 import android.util.TypedValue
+import androidx.annotation.ColorInt
 import apps.amine.bou.readerforselfoss.R
-import android.view.LayoutInflater
-import android.view.ViewGroup
 
 class AppColors(a: Activity) {
 
@@ -18,7 +15,6 @@ class AppColors(a: Activity) {
     @ColorInt val colorAccentDark: Int
     @ColorInt val cardBackgroundColor: Int
     @ColorInt val colorBackground: Int
-    @ColorInt val textColor: Int
     val isDarkTheme: Boolean
 
     init {
@@ -58,12 +54,6 @@ class AppColors(a: Activity) {
             android.R.color.background_light
         }
 
-        textColor = if (isDarkTheme) {
-            R.color.md_white_1000
-        } else {
-            R.color.md_grey_900
-        }
-
         val wrapper = Context::class.java
         val method = wrapper!!.getMethod("getThemeResId")
         method.isAccessible = true

app/src/main/java/apps/amine/bou/readerforselfoss/utils/Acra.kt

@@ -0,0 +1,12 @@
+package apps.amine.bou.readerforselfoss.utils
+
+import android.content.Context
+import android.preference.PreferenceManager
+import org.acra.ErrorReporter
+
+fun ErrorReporter.maybeHandleSilentException(throwable: Throwable, ctx: Context) {
+    val sharedPref = PreferenceManager.getDefaultSharedPreferences(ctx)
+    if (sharedPref.getBoolean("acra_should_log", false)) {
+        this.handleSilentException(throwable)
+    }
+}

app/src/main/java/apps/amine/bou/readerforselfoss/utils/AppUtils.kt

@@ -25,12 +25,11 @@ fun String.toStringUriWithHttp(): String =
         this
     }
 
-fun Context.shareLink(itemUrl: String, itemTitle: String) {
+fun Context.shareLink(itemUrl: String) {
     val sendIntent = Intent()
     sendIntent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
     sendIntent.action = Intent.ACTION_SEND
     sendIntent.putExtra(Intent.EXTRA_TEXT, itemUrl.toStringUriWithHttp())
-    sendIntent.putExtra(Intent.EXTRA_SUBJECT, itemTitle)
     sendIntent.type = "text/plain"
     startActivity(
         Intent.createChooser(

app/src/main/java/apps/amine/bou/readerforselfoss/utils/Config.kt

@@ -11,19 +11,19 @@ class Config(c: Context) {
     val settings: SharedPreferences = c.getSharedPreferences(settingsName, Context.MODE_PRIVATE)
 
     val baseUrl: String
-        get() = settings.getString("url", "")!!
+        get() = settings.getString("url", "")
 
     val userLogin: String
-        get() = settings.getString("login", "")!!
+        get() = settings.getString("login", "")
 
     val userPassword: String
-        get() = settings.getString("password", "")!!
+        get() = settings.getString("password", "")
 
     val httpUserLogin: String
-        get() = settings.getString("httpUserName", "")!!
+        get() = settings.getString("httpUserName", "")
 
     val httpUserPassword: String
-        get() = settings.getString("httpPassword", "")!!
+        get() = settings.getString("httpPassword", "")
 
     companion object {
         const val settingsName = "paramsselfoss"
@@ -36,10 +36,6 @@ class Config(c: Context) {
 
         const val trackerUrl = "https://github.com/aminecmi/ReaderforSelfoss/issues"
 
-        const val syncChannelId = "sync-channel-id"
-
-        const val newItemsChannelId = "new-items-channel-id"
-
         fun logoutAndRedirect(
             c: Context,
             callingActivity: Activity,

app/src/main/java/apps/amine/bou/readerforselfoss/utils/ItemsUtils.kt

@@ -3,8 +3,7 @@ package apps.amine.bou.readerforselfoss.utils
 import android.content.Context
 import android.text.format.DateUtils
 import apps.amine.bou.readerforselfoss.api.selfoss.Item
-import apps.amine.bou.readerforselfoss.api.selfoss.SelfossTagType
+import org.acra.ACRA
-import apps.amine.bou.readerforselfoss.dateTimeFormatter
 import java.text.ParseException
 import java.text.SimpleDateFormat
 import java.util.*
@@ -15,6 +14,7 @@ fun String.toTextDrawableString(c: Context): String {
         try {
             textDrawable.append(s[0])
         } catch (e: StringIndexOutOfBoundsException) {
+            ACRA.getErrorReporter().maybeHandleSilentException(e, c)
         }
     }
     return textDrawable.toString()
@@ -23,7 +23,7 @@ fun String.toTextDrawableString(c: Context): String {
 fun Item.sourceAndDateText(): String {
     val formattedDate: String = try {
         " " + DateUtils.getRelativeTimeSpanString(
-            SimpleDateFormat(dateTimeFormatter).parse(this.datetime).time,
+            SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(this.datetime).time,
             Date().time,
             DateUtils.MINUTE_IN_MILLIS,
             DateUtils.FORMAT_ABBREV_RELATIVE
@@ -33,7 +33,7 @@ fun Item.sourceAndDateText(): String {
         ""
     }
 
-    return this.getSourceTitle() + formattedDate
+    return this.sourcetitle + formattedDate
 }
 
 fun Item.toggleStar(): Item {
@@ -44,8 +44,8 @@ fun Item.toggleStar(): Item {
 fun List<Item>.flattenTags(): List<Item> =
     this.flatMap {
         val item = it
-        val tags: List<String> = it.tags.tags.split(",")
+        val tags: List<String> = it.tags.split(",")
-        tags.map { t ->
+        tags.map {
-            item.copy(tags = SelfossTagType(t.trim()))
+            item.copy(tags = it.trim())
         }
     }

app/src/main/java/apps/amine/bou/readerforselfoss/utils/LinksUtils.kt

@@ -2,18 +2,12 @@ package apps.amine.bou.readerforselfoss.utils
 
 import android.app.Activity
 import android.app.PendingIntent
-import android.content.ActivityNotFoundException
 import android.content.Context
 import android.content.Intent
 import android.graphics.BitmapFactory
 import android.net.Uri
-import android.text.Spannable
-import android.text.style.ClickableSpan
 import androidx.browser.customtabs.CustomTabsIntent
 import android.util.Patterns
-import android.view.MotionEvent
-import android.view.View
-import android.widget.TextView
 import android.widget.Toast
 import apps.amine.bou.readerforselfoss.R
 import apps.amine.bou.readerforselfoss.ReaderActivity
@@ -129,17 +123,13 @@ fun Context.openItemUrl(
 private fun openInBrowser(linkDecoded: String, app: Activity) {
     val intent = Intent(Intent.ACTION_VIEW)
     intent.data = Uri.parse(linkDecoded)
-    try {
+    app.startActivity(intent)
-        app.startActivity(intent)
-    } catch (e: ActivityNotFoundException) {
-        Toast.makeText(app.baseContext, e.message, Toast.LENGTH_LONG).show()
-    }
 }
 
 fun String.isUrlValid(): Boolean =
     HttpUrl.parse(this) != null && Patterns.WEB_URL.matcher(this).matches()
 
-fun String.isBaseUrlValid(ctx: Context): Boolean {
+fun String.isBaseUrlValid(): Boolean {
     val baseUrl = HttpUrl.parse(this)
     var existsAndEndsWithSlash = false
     if (baseUrl != null) {
@@ -156,40 +146,3 @@ fun Context.openInBrowserAsNewTask(i: Item) {
     intent.data = Uri.parse(i.getLinkDecoded().toStringUriWithHttp())
     startActivity(intent)
 }
-
-class LinkOnTouchListener: View.OnTouchListener {
-    override fun onTouch(v: View?, event: MotionEvent?): Boolean {
-        var ret = false
-        val widget: TextView = v as TextView
-        val text: CharSequence = widget.text
-        val stext = Spannable.Factory.getInstance().newSpannable(text)
-
-        val action = event!!.action
-
-        if (action == MotionEvent.ACTION_UP ||
-            action == MotionEvent.ACTION_DOWN) {
-            var x: Float = event.x
-            var y: Float = event.y
-
-            x -= widget.totalPaddingLeft
-            y -= widget.totalPaddingTop
-
-            x += widget.scrollX
-            y += widget.scrollY
-
-            val layout = widget.layout
-            val line = layout.getLineForVertical(y.toInt())
-            val off = layout.getOffsetForHorizontal(line, x)
-
-            val link = stext.getSpans(off, off, ClickableSpan::class.java)
-
-            if (link.isNotEmpty()) {
-                if (action == MotionEvent.ACTION_UP) {
-                    link[0].onClick(widget)
-                }
-                ret = true
-            }
-        }
-        return ret
-    }
-}

app/src/main/java/apps/amine/bou/readerforselfoss/utils/ScrollAwareFABBehavior.kt

@@ -0,0 +1,54 @@
+package apps.amine.bou.readerforselfoss.utils
+
+import android.content.Context
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+import com.google.android.material.floatingactionbutton.FloatingActionButton
+import android.util.AttributeSet
+import android.view.View
+
+class ScrollAwareFABBehavior(
+    context: Context,
+    attrs: AttributeSet
+) : CoordinatorLayout.Behavior<FloatingActionButton>() {
+
+
+    override fun onStartNestedScroll(
+        coordinatorLayout: CoordinatorLayout,
+        child: FloatingActionButton,
+        directTargetChild: View,
+        target: View,
+        nestedScrollAxes: Int
+    ): Boolean {
+        return true
+    }
+
+    override fun onNestedScroll(
+        coordinatorLayout: CoordinatorLayout,
+        child: FloatingActionButton,
+        target: View,
+        dxConsumed: Int,
+        dyConsumed: Int,
+        dxUnconsumed: Int,
+        dyUnconsumed: Int
+    ) {
+        super.onNestedScroll(
+            coordinatorLayout,
+            child,
+            target,
+            dxConsumed,
+            dyConsumed,
+            dxUnconsumed,
+            dyUnconsumed
+        )
+        if (dyConsumed > 0 && child.visibility == View.VISIBLE) {
+            child.hide(object : FloatingActionButton.OnVisibilityChangedListener() {
+                override fun onHidden(fab: FloatingActionButton?) {
+                    super.onHidden(fab)
+                    fab!!.visibility = View.INVISIBLE
+                }
+            })
+        } else if (dyConsumed < 0 && child.visibility != View.VISIBLE) {
+            child.show()
+        }
+    }
+}

app/src/main/java/apps/amine/bou/readerforselfoss/utils/customtabs/CustomTabsHelper.java

@@ -24,7 +24,7 @@ class CustomTabsHelper {
     private static final String DEV_PACKAGE = "com.chrome.dev";
     private static final String LOCAL_PACKAGE = "com.google.android.apps.chrome";
     private static final String EXTRA_CUSTOM_TABS_KEEP_ALIVE =
-            "android.support.customtabs.extra.KEEP_ALIVE";
+            "androidx.browser.customtabs.extra.KEEP_ALIVE";
 
     private static String sPackageNameToUse;
 

app/src/main/java/apps/amine/bou/readerforselfoss/utils/drawer/CustomUrlBasePrimaryDrawerItem.kt

@@ -0,0 +1,112 @@
+/* From https://github.com/mikepenz/MaterialDrawer/blob/develop/app/src/main/java/com/mikepenz/materialdrawer/app/drawerItems/CustomUrlBasePrimaryDrawerItem.java */
+package apps.amine.bou.readerforselfoss.utils.drawer
+
+import android.net.Uri
+import androidx.annotation.ColorInt
+import androidx.annotation.ColorRes
+import androidx.annotation.StringRes
+import androidx.recyclerview.widget.RecyclerView
+
+import com.mikepenz.materialdrawer.holder.ColorHolder
+import com.mikepenz.materialdrawer.holder.ImageHolder
+import com.mikepenz.materialdrawer.holder.StringHolder
+import com.mikepenz.materialdrawer.model.BaseDrawerItem
+import com.mikepenz.materialdrawer.util.DrawerImageLoader
+import com.mikepenz.materialdrawer.util.DrawerUIUtils
+import com.mikepenz.materialize.util.UIUtils
+
+abstract class CustomUrlBasePrimaryDrawerItem<T, VH : RecyclerView.ViewHolder> :
+    BaseDrawerItem<T, VH>() {
+    fun withIcon(url: String): T {
+        this.icon = ImageHolder(url)
+        return this as T
+    }
+
+    fun withIcon(uri: Uri): T {
+        this.icon = ImageHolder(uri)
+        return this as T
+    }
+
+    var description: StringHolder? = null
+        private set
+    var descriptionTextColor: ColorHolder? = null
+        private set
+
+    fun withDescription(description: String): T {
+        this.description = StringHolder(description)
+        return this as T
+    }
+
+    fun withDescription(@StringRes descriptionRes: Int): T {
+        this.description = StringHolder(descriptionRes)
+        return this as T
+    }
+
+    fun withDescriptionTextColor(@ColorInt color: Int): T {
+        this.descriptionTextColor = ColorHolder.fromColor(color)
+        return this as T
+    }
+
+    fun withDescriptionTextColorRes(@ColorRes colorRes: Int): T {
+        this.descriptionTextColor = ColorHolder.fromColorRes(colorRes)
+        return this as T
+    }
+
+    /**
+     * a helper method to have the logic for all secondaryDrawerItems only once
+
+     * @param viewHolder
+     */
+    protected fun bindViewHelper(viewHolder: CustomBaseViewHolder) {
+        val ctx = viewHolder.itemView.context
+
+        //set the identifier from the drawerItem here. It can be used to run tests
+        viewHolder.itemView.id = hashCode()
+
+        //set the item selected if it is
+        viewHolder.itemView.isSelected = isSelected
+
+        //get the correct color for the background
+        val selectedColor = getSelectedColor(ctx)
+        //get the correct color for the text
+        val color = getColor(ctx)
+        val selectedTextColor = getSelectedTextColor(ctx)
+        //get the correct color for the icon
+        val iconColor = getIconColor(ctx)
+        val selectedIconColor = getSelectedIconColor(ctx)
+
+        //set the background for the item
+        UIUtils.setBackground(
+            viewHolder.view,
+            UIUtils.getSelectableBackground(ctx, selectedColor, true)
+        )
+        //set the text for the name
+        StringHolder.applyTo(this.getName(), viewHolder.name)
+        //set the text for the description or hide
+        StringHolder.applyToOrHide(this.description, viewHolder.description)
+
+        //set the colors for textViews
+        viewHolder.name.setTextColor(getTextColorStateList(color, selectedTextColor))
+        //set the description text color
+        ColorHolder.applyToOr(
+            descriptionTextColor,
+            viewHolder.description,
+            getTextColorStateList(color, selectedTextColor)
+        )
+
+        //define the typeface for our textViews
+        if (getTypeface() != null) {
+            viewHolder.name.typeface = getTypeface()
+            viewHolder.description.typeface = getTypeface()
+        }
+
+        //we make sure we reset the image first before setting the new one in case there is an empty one
+        DrawerImageLoader.getInstance().cancelImage(viewHolder.icon)
+        viewHolder.icon.setImageBitmap(null)
+        //get the drawables for our icon and set it
+        ImageHolder.applyTo(icon, viewHolder.icon, "customUrlItem")
+
+        //for android API 17 --> Padding not applied via xml
+        DrawerUIUtils.setDrawerVerticalPadding(viewHolder.view)
+    }
+}

app/src/main/java/apps/amine/bou/readerforselfoss/utils/drawer/CustomUrlPrimaryDrawerItem.kt

@@ -0,0 +1,94 @@
+/* From https://github.com/mikepenz/MaterialDrawer/blob/develop/app/src/main/java/com/mikepenz/materialdrawer/app/drawerItems/CustomUrlPrimaryDrawerItem.java */
+package apps.amine.bou.readerforselfoss.utils.drawer
+
+import androidx.annotation.LayoutRes
+import androidx.annotation.StringRes
+import android.view.View
+import android.widget.TextView
+import apps.amine.bou.readerforselfoss.R
+import com.mikepenz.materialdrawer.holder.BadgeStyle
+import com.mikepenz.materialdrawer.holder.StringHolder
+import com.mikepenz.materialdrawer.model.interfaces.ColorfulBadgeable
+
+class CustomUrlPrimaryDrawerItem :
+    CustomUrlBasePrimaryDrawerItem<CustomUrlPrimaryDrawerItem, CustomUrlPrimaryDrawerItem.ViewHolder>(),
+    ColorfulBadgeable<CustomUrlPrimaryDrawerItem> {
+    protected var mBadge: StringHolder = StringHolder("")
+    protected var mBadgeStyle = BadgeStyle()
+
+    override fun withBadge(badge: StringHolder): CustomUrlPrimaryDrawerItem {
+        this.mBadge = badge
+        return this
+    }
+
+    override fun withBadge(badge: String): CustomUrlPrimaryDrawerItem {
+        this.mBadge = StringHolder(badge)
+        return this
+    }
+
+    override fun withBadge(@StringRes badgeRes: Int): CustomUrlPrimaryDrawerItem {
+        this.mBadge = StringHolder(badgeRes)
+        return this
+    }
+
+    override fun withBadgeStyle(badgeStyle: BadgeStyle): CustomUrlPrimaryDrawerItem {
+        this.mBadgeStyle = badgeStyle
+        return this
+    }
+
+    override fun getBadge(): StringHolder {
+        return mBadge
+    }
+
+    override fun getBadgeStyle(): BadgeStyle {
+        return mBadgeStyle
+    }
+
+    override fun getType(): Int {
+        return R.id.material_drawer_item_custom_url_item
+    }
+
+    @LayoutRes
+    override fun getLayoutRes(): Int {
+        return R.layout.material_drawer_item_primary
+    }
+
+    override fun bindView(viewHolder: ViewHolder, payloads: List<*>?) {
+        super.bindView(viewHolder, payloads)
+
+        val ctx = viewHolder.itemView.context
+
+        //bind the basic view parts
+        bindViewHelper(viewHolder)
+
+        //set the text for the badge or hide
+        val badgeVisible = StringHolder.applyToOrHide(mBadge, viewHolder.badge)
+        //style the badge if it is visible
+        if (badgeVisible) {
+            mBadgeStyle.style(
+                viewHolder.badge,
+                getTextColorStateList(getColor(ctx), getSelectedTextColor(ctx))
+            )
+            viewHolder.badgeContainer.visibility = View.VISIBLE
+        } else {
+            viewHolder.badgeContainer.visibility = View.GONE
+        }
+
+        //define the typeface for our textViews
+        if (getTypeface() != null) {
+            viewHolder.badge.typeface = getTypeface()
+        }
+
+        //call the onPostBindView method to trigger post bind view actions (like the listener to modify the item if required)
+        onPostBindView(this, viewHolder.itemView)
+    }
+
+    override fun getViewHolder(v: View): ViewHolder {
+        return ViewHolder(v)
+    }
+
+    class ViewHolder(view: View) : CustomBaseViewHolder(view) {
+        val badgeContainer: View = view.findViewById(R.id.material_drawer_badge_container)
+        val badge: TextView = view.findViewById(R.id.material_drawer_badge)
+    }
+}

app/src/main/java/apps/amine/bou/readerforselfoss/utils/glide/GlideUtils.kt

@@ -2,33 +2,30 @@ package apps.amine.bou.readerforselfoss.utils.glide
 
 import android.content.Context
 import android.graphics.Bitmap
-import android.graphics.drawable.Drawable
-import android.util.Base64
 import androidx.core.graphics.drawable.RoundedBitmapDrawableFactory
 import android.widget.ImageView
-import apps.amine.bou.readerforselfoss.utils.Config
 import com.bumptech.glide.Glide
-import com.bumptech.glide.RequestBuilder
-import com.bumptech.glide.RequestManager
-import com.bumptech.glide.load.model.GlideUrl
-import com.bumptech.glide.load.model.LazyHeaders
 import com.bumptech.glide.request.RequestOptions
 import com.bumptech.glide.request.target.BitmapImageViewTarget
-import java.io.ByteArrayInputStream
-import java.io.ByteArrayOutputStream
-import java.io.InputStream
 
-fun Context.bitmapCenterCrop(config: Config, url: String, iv: ImageView) =
+fun Context.bitmapCenterCrop(url: String, iv: ImageView) =
     Glide.with(this)
         .asBitmap()
-        .loadMaybeBasicAuth(config, url)
+        .load(url)
         .apply(RequestOptions.centerCropTransform())
         .into(iv)
 
-fun Context.circularBitmapDrawable(config: Config, url: String, iv: ImageView) =
+fun Context.bitmapFitCenter(url: String, iv: ImageView) =
     Glide.with(this)
         .asBitmap()
-        .loadMaybeBasicAuth(config, url)
+        .load(url)
+        .apply(RequestOptions.fitCenterTransform())
+        .into(iv)
+
+fun Context.circularBitmapDrawable(url: String, iv: ImageView) =
+    Glide.with(this)
+        .asBitmap()
+        .load(url)
         .apply(RequestOptions.centerCropTransform())
         .into(object : BitmapImageViewTarget(iv) {
             override fun setResource(resource: Bitmap?) {
@@ -39,31 +36,4 @@ fun Context.circularBitmapDrawable(config: Config, url: String, iv: ImageView) =
                 circularBitmapDrawable.isCircular = true
                 iv.setImageDrawable(circularBitmapDrawable)
             }
-        })
+        })
-
-fun RequestBuilder<Bitmap>.loadMaybeBasicAuth(config: Config, url: String): RequestBuilder<Bitmap> {
-    val builder: LazyHeaders.Builder = LazyHeaders.Builder()
-    if (config.httpUserLogin.isNotEmpty() || config.httpUserPassword.isNotEmpty()) {
-        val basicAuth = "Basic " + Base64.encodeToString("${config.httpUserLogin}:${config.httpUserPassword}".toByteArray(), Base64.NO_WRAP)
-        builder.addHeader("Authorization", basicAuth)
-    }
-    val glideUrl = GlideUrl(url, builder.build())
-    return this.load(glideUrl)
-}
-
-fun RequestManager.loadMaybeBasicAuth(config: Config, url: String): RequestBuilder<Drawable> {
-    val builder: LazyHeaders.Builder = LazyHeaders.Builder()
-    if (config.httpUserLogin.isNotEmpty() || config.httpUserPassword.isNotEmpty()) {
-        val basicAuth = "Basic " + Base64.encodeToString("${config.httpUserLogin}:${config.httpUserPassword}".toByteArray(), Base64.NO_WRAP)
-        builder.addHeader("Authorization", basicAuth)
-    }
-    val glideUrl = GlideUrl(url, builder.build())
-    return this.load(glideUrl)
-}
-
-fun getBitmapInputStream(bitmap:Bitmap,compressFormat: Bitmap.CompressFormat): InputStream {
-    val byteArrayOutputStream = ByteArrayOutputStream()
-    bitmap.compress(compressFormat, 80, byteArrayOutputStream)
-    val bitmapData: ByteArray = byteArrayOutputStream.toByteArray()
-    return ByteArrayInputStream(bitmapData)
-}

app/src/main/java/apps/amine/bou/readerforselfoss/utils/network/NetworkUtils.kt

@@ -1,45 +0,0 @@
-package apps.amine.bou.readerforselfoss.utils.network
-
-import android.content.Context
-import android.graphics.Color
-import android.net.ConnectivityManager
-import android.net.NetworkInfo
-import android.view.View
-import android.widget.TextView
-import apps.amine.bou.readerforselfoss.R
-import com.google.android.material.snackbar.Snackbar
-
-var snackBarShown = false
-var view: View? = null
-lateinit var s: Snackbar
-
-fun Context.isNetworkAccessible(v: View?, overrideOffline: Boolean = false): Boolean {
-    val cm = this.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-    val activeNetwork: NetworkInfo? = cm.activeNetworkInfo
-    val networkIsAccessible = activeNetwork != null && activeNetwork.isConnectedOrConnecting
-
-    if (v != null && (!networkIsAccessible || overrideOffline) && (!snackBarShown || v != view)) {
-        view = v
-        s = Snackbar
-            .make(
-                v,
-                R.string.no_network_connectivity,
-                Snackbar.LENGTH_INDEFINITE
-            )
-
-        s.setAction(android.R.string.ok) {
-            snackBarShown = false
-            s.dismiss()
-        }
-
-        val view = s.view
-        val tv: TextView = view.findViewById(com.google.android.material.R.id.snackbar_text)
-        tv.setTextColor(Color.WHITE)
-        s.show()
-        snackBarShown = true
-    }
-    if (snackBarShown && networkIsAccessible && !overrideOffline) {
-        s.dismiss()
-    }
-    return if(overrideOffline) overrideOffline else networkIsAccessible
-}

app/src/main/java/apps/amine/bou/readerforselfoss/utils/persistence/EntitiesUtils.kt

@@ -1,73 +0,0 @@
-package apps.amine.bou.readerforselfoss.utils.persistence
-
-import apps.amine.bou.readerforselfoss.api.selfoss.Item
-import apps.amine.bou.readerforselfoss.api.selfoss.SelfossTagType
-import apps.amine.bou.readerforselfoss.api.selfoss.Source
-import apps.amine.bou.readerforselfoss.api.selfoss.Tag
-import apps.amine.bou.readerforselfoss.persistence.entities.ItemEntity
-import apps.amine.bou.readerforselfoss.persistence.entities.SourceEntity
-import apps.amine.bou.readerforselfoss.persistence.entities.TagEntity
-
-fun TagEntity.toView(): Tag =
-        Tag(
-            this.tag,
-            this.color,
-            this.unread
-        )
-
-fun SourceEntity.toView(): Source =
-        Source(
-            this.id,
-            this.title,
-            SelfossTagType(this.tags),
-            this.spout,
-            this.error,
-            this.icon
-        )
-
-fun Source.toEntity(): SourceEntity =
-        SourceEntity(
-            this.id,
-            this.getTitleDecoded(),
-            this.tags.tags,
-            this.spout,
-            this.error,
-            this.icon.orEmpty()
-        )
-
-fun Tag.toEntity(): TagEntity =
-        TagEntity(
-            this.tag,
-            this.color,
-            this.unread
-        )
-
-fun ItemEntity.toView(): Item =
-        Item(
-            this.id,
-            this.datetime,
-            this.title,
-            this.content,
-            this.unread,
-            this.starred,
-            this.thumbnail,
-            this.icon,
-            this.link,
-            this.sourcetitle,
-            SelfossTagType(this.tags)
-        )
-
-fun Item.toEntity(): ItemEntity =
-    ItemEntity(
-        this.id,
-        this.datetime,
-        this.getTitleDecoded(),
-        this.content,
-        this.unread,
-        this.starred,
-        this.thumbnail,
-        this.icon,
-        this.link,
-        this.getSourceTitle(),
-        this.tags.tags
-    )

app/src/main/res/drawable-anydpi/ic_format_align_justify.xml

@@ -1,9 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M3,21h18v-2L3,19v2zM3,17h18v-2L3,15v2zM3,13h18v-2L3,11v2zM3,9h18L21,7L3,7v2zM3,3v2h18L21,3L3,3z"/>
-</vector>

app/src/main/res/drawable-anydpi/ic_format_align_left.xml

@@ -1,9 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M15,15L3,15v2h12v-2zM15,7L3,7v2h12L15,7zM3,13h18v-2L3,11v2zM3,21h18v-2L3,19v2zM3,3v2h18L21,3L3,3z"/>
-</vector>