Migrate watch history to Jetpack Compose

app/src/androidTest/java/org/schabi/newpipe/database/FeedDAOTest.kt

@@ -3,6 +3,9 @@ package org.schabi.newpipe.database
 import android.content.Context
 import androidx.room.Room
 import androidx.test.core.app.ApplicationProvider
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.rx3.await
 import io.reactivex.rxjava3.core.Single
 import java.io.IOException
 import java.time.OffsetDateTime
@@ -22,6 +25,8 @@ import org.schabi.newpipe.database.subscription.SubscriptionEntity
 import org.schabi.newpipe.extractor.ServiceList
 import org.schabi.newpipe.extractor.channel.ChannelInfo
 import org.schabi.newpipe.extractor.stream.StreamType
+import java.io.IOException
+import java.time.OffsetDateTime
 
 class FeedDAOTest {
     private lateinit var db: AppDatabase
@@ -106,14 +111,10 @@ class FeedDAOTest {
         )
     }
 
-    private fun setupUnlinkDelete(time: String) {
+    private fun setupUnlinkDelete(time: String) = runBlocking(Dispatchers.IO) {
         clearAndFillTables()
-        Single.fromCallable {
-            feedDAO.unlinkStreamsOlderThan(OffsetDateTime.parse(time))
-        }.blockingSubscribe()
-        Single.fromCallable {
-            streamDAO.deleteOrphans()
-        }.blockingSubscribe()
+        feedDAO.unlinkStreamsOlderThan(OffsetDateTime.parse(time))
+        streamDAO.deleteOrphans().await()
     }
 
     private fun clearAndFillTables() {

app/src/main/java/org/schabi/newpipe/database/feed/dao/FeedDAO.kt

@@ -119,7 +119,7 @@ abstract class FeedDAO {
               AND   s.upload_date <> max_upload_date))
         """
     )
-    abstract fun unlinkStreamsOlderThan(offsetDateTime: OffsetDateTime)
+    abstract suspend fun unlinkStreamsOlderThan(offsetDateTime: OffsetDateTime)
 
     @Query(
         """

app/src/main/java/org/schabi/newpipe/database/stream/dao/StreamDAO.kt

@@ -30,9 +30,6 @@ abstract class StreamDAO : BasicDAO<StreamEntity> {
     @Query("SELECT * FROM streams WHERE url = :url AND service_id = :serviceId")
     abstract fun getStream(serviceId: Long, url: String): Maybe<StreamEntity>
 
-    @Query("UPDATE streams SET uploader_url = :uploaderUrl WHERE url = :url AND service_id = :serviceId")
-    abstract fun setUploaderUrl(serviceId: Long, url: String, uploaderUrl: String): Completable
-
     @Insert(onConflict = OnConflictStrategy.IGNORE)
     internal abstract fun silentInsertInternal(stream: StreamEntity): Long
 
@@ -122,7 +119,7 @@ abstract class StreamDAO : BasicDAO<StreamEntity> {
         WHERE f.stream_id = streams.uid)
         """
     )
-    abstract fun deleteOrphans(): Int
+    abstract fun deleteOrphans(): Completable
 
     /**
      * Minimal entry class used when comparing/updating an existent stream.

app/src/main/java/org/schabi/newpipe/local/LocalItemListAdapter.java

@@ -22,9 +22,6 @@
 import org.schabi.newpipe.local.holder.LocalPlaylistStreamCardItemHolder;
 import org.schabi.newpipe.local.holder.LocalPlaylistStreamGridItemHolder;
 import org.schabi.newpipe.local.holder.LocalPlaylistStreamItemHolder;
-import org.schabi.newpipe.local.holder.LocalStatisticStreamCardItemHolder;
-import org.schabi.newpipe.local.holder.LocalStatisticStreamGridItemHolder;
-import org.schabi.newpipe.local.holder.LocalStatisticStreamItemHolder;
 import org.schabi.newpipe.local.holder.RemoteBookmarkPlaylistItemHolder;
 import org.schabi.newpipe.local.holder.RemotePlaylistCardItemHolder;
 import org.schabi.newpipe.local.holder.RemotePlaylistGridItemHolder;
@@ -65,10 +62,7 @@ public class LocalItemListAdapter extends RecyclerView.Adapter<RecyclerView.View
     private static final int HEADER_TYPE = 0;
     private static final int FOOTER_TYPE = 1;
 
-    private static final int STREAM_STATISTICS_HOLDER_TYPE = 0x1000;
     private static final int STREAM_PLAYLIST_HOLDER_TYPE = 0x1001;
-    private static final int STREAM_STATISTICS_GRID_HOLDER_TYPE = 0x1002;
-    private static final int STREAM_STATISTICS_CARD_HOLDER_TYPE = 0x1003;
     private static final int STREAM_PLAYLIST_GRID_HOLDER_TYPE = 0x1004;
     private static final int STREAM_PLAYLIST_CARD_HOLDER_TYPE = 0x1005;
 
@@ -293,14 +287,6 @@ public int getItemViewType(int position) {
                 } else {
                     return STREAM_PLAYLIST_HOLDER_TYPE;
                 }
-            case STATISTIC_STREAM_ITEM:
-                if (itemViewMode == ItemViewMode.CARD) {
-                    return STREAM_STATISTICS_CARD_HOLDER_TYPE;
-                } else if (itemViewMode == ItemViewMode.GRID) {
-                    return STREAM_STATISTICS_GRID_HOLDER_TYPE;
-                } else {
-                    return STREAM_STATISTICS_HOLDER_TYPE;
-                }
             default:
                 Log.e(TAG, "No holder type has been considered for item: ["
                         + item.getLocalItemType() + "]");
@@ -316,43 +302,36 @@ public RecyclerView.ViewHolder onCreateViewHolder(@NonNull final ViewGroup paren
             Log.d(TAG, "onCreateViewHolder() called with: "
                     + "parent = [" + parent + "], type = [" + type + "]");
         }
-        switch (type) {
-            case HEADER_TYPE:
-                return new HeaderFooterHolder(header);
-            case FOOTER_TYPE:
-                return new HeaderFooterHolder(footer);
-            case LOCAL_PLAYLIST_HOLDER_TYPE:
-                return new LocalPlaylistItemHolder(localItemBuilder, parent);
-            case LOCAL_PLAYLIST_GRID_HOLDER_TYPE:
-                return new LocalPlaylistGridItemHolder(localItemBuilder, parent);
-            case LOCAL_PLAYLIST_CARD_HOLDER_TYPE:
-                return new LocalPlaylistCardItemHolder(localItemBuilder, parent);
-            case LOCAL_BOOKMARK_PLAYLIST_HOLDER_TYPE:
-                return new LocalBookmarkPlaylistItemHolder(localItemBuilder, parent);
-            case REMOTE_PLAYLIST_HOLDER_TYPE:
-                return new RemotePlaylistItemHolder(localItemBuilder, parent);
-            case REMOTE_PLAYLIST_GRID_HOLDER_TYPE:
-                return new RemotePlaylistGridItemHolder(localItemBuilder, parent);
-            case REMOTE_PLAYLIST_CARD_HOLDER_TYPE:
-                return new RemotePlaylistCardItemHolder(localItemBuilder, parent);
-            case REMOTE_BOOKMARK_PLAYLIST_HOLDER_TYPE:
-                return new RemoteBookmarkPlaylistItemHolder(localItemBuilder, parent);
-            case STREAM_PLAYLIST_HOLDER_TYPE:
-                return new LocalPlaylistStreamItemHolder(localItemBuilder, parent);
-            case STREAM_PLAYLIST_GRID_HOLDER_TYPE:
-                return new LocalPlaylistStreamGridItemHolder(localItemBuilder, parent);
-            case STREAM_PLAYLIST_CARD_HOLDER_TYPE:
-                return new LocalPlaylistStreamCardItemHolder(localItemBuilder, parent);
-            case STREAM_STATISTICS_HOLDER_TYPE:
-                return new LocalStatisticStreamItemHolder(localItemBuilder, parent);
-            case STREAM_STATISTICS_GRID_HOLDER_TYPE:
-                return new LocalStatisticStreamGridItemHolder(localItemBuilder, parent);
-            case STREAM_STATISTICS_CARD_HOLDER_TYPE:
-                return new LocalStatisticStreamCardItemHolder(localItemBuilder, parent);
-            default:
+        return switch (type) {
+            case HEADER_TYPE -> new HeaderFooterHolder(header);
+            case FOOTER_TYPE -> new HeaderFooterHolder(footer);
+            case LOCAL_PLAYLIST_HOLDER_TYPE ->
+                    new LocalPlaylistItemHolder(localItemBuilder, parent);
+            case LOCAL_PLAYLIST_GRID_HOLDER_TYPE ->
+                    new LocalPlaylistGridItemHolder(localItemBuilder, parent);
+            case LOCAL_PLAYLIST_CARD_HOLDER_TYPE ->
+                    new LocalPlaylistCardItemHolder(localItemBuilder, parent);
+            case LOCAL_BOOKMARK_PLAYLIST_HOLDER_TYPE ->
+                    new LocalBookmarkPlaylistItemHolder(localItemBuilder, parent);
+            case REMOTE_PLAYLIST_HOLDER_TYPE ->
+                    new RemotePlaylistItemHolder(localItemBuilder, parent);
+            case REMOTE_PLAYLIST_GRID_HOLDER_TYPE ->
+                    new RemotePlaylistGridItemHolder(localItemBuilder, parent);
+            case REMOTE_PLAYLIST_CARD_HOLDER_TYPE ->
+                    new RemotePlaylistCardItemHolder(localItemBuilder, parent);
+            case REMOTE_BOOKMARK_PLAYLIST_HOLDER_TYPE ->
+                    new RemoteBookmarkPlaylistItemHolder(localItemBuilder, parent);
+            case STREAM_PLAYLIST_HOLDER_TYPE ->
+                    new LocalPlaylistStreamItemHolder(localItemBuilder, parent);
+            case STREAM_PLAYLIST_GRID_HOLDER_TYPE ->
+                    new LocalPlaylistStreamGridItemHolder(localItemBuilder, parent);
+            case STREAM_PLAYLIST_CARD_HOLDER_TYPE ->
+                    new LocalPlaylistStreamCardItemHolder(localItemBuilder, parent);
+            default -> {
                 Log.e(TAG, "No view type has been considered for holder: [" + type + "]");
-                return new FallbackViewHolder(new View(parent.getContext()));
-        }
+                yield new FallbackViewHolder(new View(parent.getContext()));
+            }
+        };
     }
 
     @SuppressWarnings("FinalParameters")

app/src/main/java/org/schabi/newpipe/local/feed/FeedDatabaseManager.kt

@@ -1,7 +1,6 @@
 package org.schabi.newpipe.local.feed
 
 import android.content.Context
-import android.util.Log
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
 import io.reactivex.rxjava3.core.Completable
 import io.reactivex.rxjava3.core.Flowable
@@ -11,6 +10,7 @@ import java.time.LocalDate
 import java.time.OffsetDateTime
 import java.time.ZoneOffset
 import org.schabi.newpipe.MainActivity.DEBUG
+import kotlinx.coroutines.rx3.await
 import org.schabi.newpipe.NewPipeDatabase
 import org.schabi.newpipe.database.feed.model.FeedEntity
 import org.schabi.newpipe.database.feed.model.FeedGroupEntity
@@ -110,20 +110,9 @@ class FeedDatabaseManager(context: Context) {
         )
     }
 
-    fun removeOrphansOrOlderStreams(oldestAllowedDate: OffsetDateTime = FEED_OLDEST_ALLOWED_DATE) {
+    suspend fun removeOrphansOrOlderStreams(oldestAllowedDate: OffsetDateTime = FEED_OLDEST_ALLOWED_DATE) {
         feedTable.unlinkStreamsOlderThan(oldestAllowedDate)
-        streamTable.deleteOrphans()
-    }
-
-    fun clear() {
-        feedTable.deleteAll()
-        val deletedOrphans = streamTable.deleteOrphans()
-        if (DEBUG) {
-            Log.d(
-                this::class.java.simpleName,
-                "clear() → streamTable.deleteOrphans() → $deletedOrphans"
-            )
-        }
+        streamTable.deleteOrphans().await()
     }
 
     // /////////////////////////////////////////////////////////////////////////

app/src/main/java/org/schabi/newpipe/local/feed/service/FeedLoadManager.kt

@@ -4,7 +4,6 @@ import android.content.Context
 import android.content.SharedPreferences
 import androidx.preference.PreferenceManager
 import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers
-import io.reactivex.rxjava3.core.Completable
 import io.reactivex.rxjava3.core.Flowable
 import io.reactivex.rxjava3.core.Notification
 import io.reactivex.rxjava3.core.Single
@@ -15,6 +14,8 @@ import java.time.OffsetDateTime
 import java.time.ZoneOffset
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicInteger
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.rx3.rxCompletable
 import org.schabi.newpipe.R
 import org.schabi.newpipe.database.feed.model.FeedGroupEntity
 import org.schabi.newpipe.database.subscription.NotificationMode
@@ -261,7 +262,7 @@ class FeedLoadManager(private val context: Context) {
      * Remove streams from the feed which are older than [FeedDatabaseManager.FEED_OLDEST_ALLOWED_DATE].
      * Remove streams from the database which are not linked / used by any table.
      */
-    private fun postProcessFeed() = Completable.fromRunnable {
+    private fun postProcessFeed() = rxCompletable(Dispatchers.IO) {
         FeedEventManager.postEvent(FeedEventManager.Event.ProgressEvent(R.string.feed_processing_message))
         feedDatabaseManager.removeOrphansOrOlderStreams()
 

app/src/main/java/org/schabi/newpipe/local/history/HistoryFragment.kt

@@ -0,0 +1,94 @@
+package org.schabi.newpipe.local.history
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.Toast
+import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.app.AppCompatActivity
+import androidx.compose.material3.Surface
+import androidx.core.view.MenuProvider
+import androidx.fragment.app.Fragment
+import androidx.fragment.compose.content
+import androidx.lifecycle.lifecycleScope
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.rx3.await
+import org.schabi.newpipe.R
+import org.schabi.newpipe.error.ErrorInfo
+import org.schabi.newpipe.error.ErrorUtil.Companion.openActivity
+import org.schabi.newpipe.error.UserAction
+import org.schabi.newpipe.ui.screens.HistoryScreen
+import org.schabi.newpipe.ui.theme.AppTheme
+
+class HistoryFragment : Fragment() {
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?,
+    ) = content {
+        AppTheme {
+            Surface {
+                HistoryScreen()
+            }
+        }
+    }
+
+    override fun onViewCreated(
+        view: View,
+        savedInstanceState: Bundle?,
+    ) {
+        val context = requireActivity()
+        (context as? AppCompatActivity)?.supportActionBar?.setTitle(R.string.title_activity_history)
+
+        val recordManager = HistoryRecordManager(context)
+        context.addMenuProvider(
+            object : MenuProvider {
+                override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
+                    menuInflater.inflate(R.menu.menu_history, menu)
+                }
+
+                override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+                    when (menuItem.itemId) {
+                        R.id.action_history_clear -> {
+                            AlertDialog.Builder(context)
+                                .setTitle(R.string.delete_view_history_alert)
+                                .setNegativeButton(R.string.cancel) { dialog, which -> dialog.dismiss() }
+                                .setPositiveButton(R.string.delete) { dialog, which ->
+                                    viewLifecycleOwner.lifecycleScope.launch {
+                                        launch(getExceptionHandler("Delete playback states")) {
+                                            recordManager.deleteCompleteStreamStateHistory().await()
+                                            Toast
+                                                .makeText(context, R.string.watch_history_states_deleted, Toast.LENGTH_SHORT)
+                                                .show()
+                                        }
+
+                                        launch(getExceptionHandler("Delete watch history")) {
+                                            recordManager.deleteWholeStreamHistory().await()
+                                            Toast.makeText(context, R.string.watch_history_deleted, Toast.LENGTH_SHORT)
+                                                .show()
+                                        }
+
+                                        launch(getExceptionHandler("Clear orphaned records")) {
+                                            recordManager.removeOrphanedRecords().await()
+                                        }
+                                    }
+                                }
+                                .show()
+                        }
+                    }
+                    return true
+                }
+            },
+            viewLifecycleOwner
+        )
+    }
+
+    private fun getExceptionHandler(action: String) = CoroutineExceptionHandler { _, throwable ->
+        openActivity(requireContext(), ErrorInfo(throwable, UserAction.DELETE_FROM_HISTORY, action))
+    }
+}

app/src/main/java/org/schabi/newpipe/local/history/HistoryRecordManager.java

@@ -151,30 +151,22 @@ public Maybe<Long> onViewed(final StreamInfo info) {
     }
 
     public Completable deleteStreamHistoryAndState(final long streamId) {
-        return Completable.fromAction(() -> {
-            streamStateTable.deleteState(streamId);
-            streamHistoryTable.deleteStreamHistory(streamId);
-        }).subscribeOn(Schedulers.io());
+        return streamStateTable.deleteState(streamId)
+                .andThen(streamHistoryTable.deleteStreamHistory(streamId));
     }
 
-    public Single<Integer> deleteWholeStreamHistory() {
-        return Single.fromCallable(streamHistoryTable::deleteAll)
-                .subscribeOn(Schedulers.io());
+    public Completable deleteWholeStreamHistory() {
+        return streamHistoryTable.deleteAll().subscribeOn(Schedulers.io());
     }
 
-    public Single<Integer> deleteCompleteStreamStateHistory() {
-        return Single.fromCallable(streamStateTable::deleteAll)
-                .subscribeOn(Schedulers.io());
+    public Completable deleteCompleteStreamStateHistory() {
+        return streamStateTable.deleteAll().subscribeOn(Schedulers.io());
     }
 
     public Flowable<List<StreamHistoryEntry>> getStreamHistorySortedById() {
         return streamHistoryTable.getHistorySortedById().subscribeOn(Schedulers.io());
     }
 
-    public Flowable<List<StreamStatisticsEntry>> getStreamStatistics() {
-        return streamHistoryTable.getStatistics().subscribeOn(Schedulers.io());
-    }
-
     private boolean isStreamHistoryEnabled() {
         return sharedPreferences.getBoolean(streamHistoryKey, false);
     }
@@ -283,8 +275,7 @@ public Single<List<StreamStateEntity>> loadLocalStreamStateBatch(
     // Utility
     ///////////////////////////////////////////////////////
 
-    public Single<Integer> removeOrphanedRecords() {
-        return Single.fromCallable(streamTable::deleteOrphans).subscribeOn(Schedulers.io());
+    public Completable removeOrphanedRecords() {
+        return streamTable.deleteOrphans().subscribeOn(Schedulers.io());
     }
-
 }