FeedFragment.kt.orig

The two implementations present quite different approaches, and here are the main comparisons:

  1. Data Loading Management:

    • Classic: Data is managed via synchronous calls and direct view updates (e.g., handleResult with the stream states).
    • RxJava: Data is loaded asynchronously with Observable, allowing multiple tasks to be handled in parallel (stream extraction, waiting with CountDownLatch, and error handling via Rx chains).

  2. User Interactions:

    • Classic: Clicking on the menu (e.g., help) directly triggers a dialog box.
    • RxJava: The interaction can potentially trigger asynchronous tasks (e.g., a search triggers data extraction and updates the UI after processing).

  3. Lifecycle Management:

    • Classic: Little management of unsubscriptions or resource cleanup.
    • RxJava: Uses Disposable to manage the lifecycle of streams and ensure memory leaks are avoided.

  4. UI Updates:

    • Both approaches update the title, subtitle, and refresh texts, but in the RxJava version, these updates are often triggered after asynchronous processing.

  5. Search and Dynamic Loading:

    • Classic: Loading seems rather passive, waiting for a change in the FeedState.
    • RxJava: A keyword search (getStreamWithKeyword) allows active filtering of video streams and dynamic updating of results.

Overall, the RxJava version is much more reactive and flexible, especially for complex tasks like loading and searching for videos. The classic version, on the other hand, is simpler and more straightforward but less performant when it comes to handling network calls or parallel updates.

This FeedFragment file is a class that manages the display of feeds in the NewPipe application. Let's dive into the key aspects:

🌟 Inheritance and Initialization

  • FeedFragment inherits from BaseStateFragment<FeedState>(), which allows managing specific states for feed display (loading, error, available content, etc.).
  • Variable Initialization:
    • _feedBinding for view binding (linking to UI elements).
    • disposables to manage RxJava subscriptions and prevent memory leaks.
    • viewModel to observe feed data through FeedViewModel.
    • Saved states like listState and options like contentFilter.

🏃 Lifecycle

  • onCreate(): Retrieves arguments (such as the current feed group) and registers a listener to detect changes in user preferences.
  • onCreateView(): Inflates the layout.
  • onViewCreated():
    • Initializes the FeedViewModel with a factory.
    • Observes stateLiveData to react to data changes.
    • Configures the GroupieAdapter to display feed items.
    • Manages the scroll listener to detect scrolling and show/hide the new items button.
  • onPause() and onResume(): Save and restore the list state (useful to prevent users from losing their position after temporarily leaving the screen).
  • onDestroy():
    • Releases RxJava subscriptions with disposables.dispose().
    • Unregisters the preference listener.
    • Cleans up animations to prevent memory leaks.

đŸ“± List and View Management

  • Display Mode (Grid or List):
    • The setupListViewMode() method adjusts the number of columns based on whether the user prefers a grid or list view.
  • Click Handling:
    • The adapter uses an OnItemClickListener and OnItemLongClickListener to handle interactions with each video feed.

🔧 Menu and Preferences

  • onCreateOptionsMenu() and onOptionsItemSelected():
    • Add options to the menu (e.g., help to understand the dedicated feed retrieval mode).
  • Dynamic Subtitle Management: The subtitle in the action bar is updated based on the current feed group.

⚡ RxJava and Asynchrony

  • Data streams (videos, subscriptions, etc.) are managed asynchronously, with:
    • CompositeDisposable to register and clean up subscriptions.
    • Schedulers.io() for background operations (like loading feeds from the database).
    • AndroidSchedulers.mainThread() to update the UI after data loading.

This code in the FeedFragment is super rich! 🌟 I’ll explain the key parts, especially those related to feed display (loading, errors, results) and the use of RxJava. Ready? Let’s go!

🚀 1. Loading State Management

Main Methods:

  • showLoading(): Displays the loading state.
  • hideLoading(): Hides the loading state once the data is ready.
  • showEmptyState(): Shows an empty screen if no data is retrieved.
  • handleError(): Handles error display.

👉 Animations & UI:
Each method uses animations to hide or show views, with calls like:

feedBinding.itemsList.animateHideRecyclerViewAllowingScrolling() feedBinding.refreshRootView.animate(true, 200)
  • itemsList: The list of videos or subscriptions.
  • refreshRootView: A view surrounding the content that allows refreshing.
  • loadingProgressText: A text for the loading indicator.

👉 Refresh & States:
The two key variables are:

  • swipeRefreshLayout.isRefreshing: For "pull-to-refresh".
  • isRefreshing: An internal variable to track if a refresh is in progress.

đŸ§Ș 2. Video Extraction & Result Processing

The key method here is:

override fun handleResult(result: FeedState)

👉 Main Process:

  • It calls ExtractorHelper.getStreamInfo() to retrieve info about a specific video.
  • RxJava allows this operation to be performed asynchronously, with:
.subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread())
  • Schedulers.io(): Executes the task in the background (perfect for network loading).
  • AndroidSchedulers.mainThread(): Updates the UI once the data is loaded.

👉 Result Handling:
On success:

.subscribe({ result: StreamInfo -> val item1 = StreamItem(...) handleLoadedState(FeedState.LoadedState(items = listOf(item1), null, 0)) })
  • StreamItem creates an object representing a video (with its title, URL, duration, etc.).
  • handleLoadedState() updates the UI to display the videos.

On failure:

) { throwable: Throwable? -> println("Error in the request") }

⚠ There’s a small merge conflict in your code here (lines <<<<<<< HEAD and >>>>>>>), which could cause issues! Want to fix it together?

đŸ“ș 3. List Update & Display

When data is loaded, it is displayed with:

groupAdapter.updateAsync(loadedState.items, false)
  • groupAdapter manages the display of videos (possibly with Groupie?).
  • The display mode (grid, card, or list) is adjusted here:
val itemVersion = when (getItemViewMode(requireContext())) { ItemViewMode.GRID -> StreamItem.ItemVersion.GRID ItemViewMode.CARD -> StreamItem.ItemVersion.CARD else -> StreamItem.ItemVersion.NORMAL }

⚠ 4. Advanced Error Handling

There’s also specific error handling, such as when a subscription has been deleted or the content is no longer available:

if (t is FeedLoadService.RequestException && t.cause is ContentNotAvailableException)
  • If a feed no longer exists, an alert is displayed to unsubscribe the user:
AlertDialog.Builder(requireContext()) .setTitle(R.string.feed_load_error) .setPositiveButton(R.string.unsubscribe) { _, _ -> SubscriptionManager(requireContext()).deleteSubscription(...) } .setNegativeButton(R.string.cancel) { _, _ -> }

💡 In Summary:

  • RxJava is at the heart of asynchronous video loading.
  • Animations & UI State are managed via feedBinding.
  • Groupie seems to handle the adapter for displaying feeds.
  • Error Handling: A good mix of generic errors and specific cases (deleted content, closed accounts, etc.).

This code in FeedFragment primarily serves two purposes:

  1. Highlight New Items
    The highlightNewItemsAfter(updateTime: OffsetDateTime) method iterates through the list of items (via groupAdapter) and bolds (via Typeface.DEFAULT_BOLD) and surrounds with a specific border (dashed_border) items whose upload date is later than updateTime.

    âšĄïž Optimization:

    • As soon as an older item is found, the loop stops prematurely with doCheck = false, which is smart since items are sorted in descending chronological order (newest at the top).

    đŸ› ïž Display Update:

    • Once highlighting is done, all affected items are refreshed with groupAdapter.notifyItemRangeChanged(), forcing the UI to update immediately.

  2. Manage New Item Animations
    When new items are detected (highlightCount > 0), the button for new items (newItemsLoadedButton) appears with a "slide up" animation via showNewItemsLoaded().

    ⏳ Automatic Delay:

    • The button remains visible for 10 seconds before automatically disappearing thanks to hideNewItemsLoaded(true, 10000).
    • If animations are disabled on the device (detected via DeviceUtils.hasAnimationsAnimatorDurationEnabled()), the button disappears immediately.

  3. Video Feed Search Management
    The getStreamWithKeyword() method uses RxJava to perform an asynchronous search (via ExtractorHelper.searchFor()).

    • It observes results on the main thread (observeOn(AndroidSchedulers.mainThread())).
    • If results are found, they are added to the InfoListAdapter via the getSuggestionStreamFromSuscribeReturn() method.
    • If nothing is found, it triggers an empty state via showEmptyState().

    ⚠ Potential Issue:
    The return in the subscribe() doesn’t work as expected because RxJava calls are asynchronous. To retrieve the result, you’d need to use a callback or update the state via an observer.

Les deux implémentations présentent des approches assez différentes, et voici les principales comparaisons :

  1. Gestion du chargement des données :

    • Classique : les donnĂ©es sont gĂ©rĂ©es via des appels synchrones et des mises Ă  jour directes des vues (ex. handleResult avec les Ă©tats du flux).
    • RxJava : les donnĂ©es sont chargĂ©es de maniĂšre asynchrone avec Observable, ce qui permet de gĂ©rer plusieurs tĂąches en parallĂšle (extraction des flux, attente avec CountDownLatch, et gestion des erreurs via les chaĂźnes Rx).

  2. Interactions utilisateur :

    • Classique : le clic sur le menu (ex. l'aide) dĂ©clenche directement une boĂźte de dialogue.
    • RxJava : l'interaction peut potentiellement dĂ©clencher des tĂąches asynchrones (ex. une recherche dĂ©clenche l'extraction des donnĂ©es et met Ă  jour l'UI aprĂšs le traitement).

  3. Gestion du cycle de vie :

    • Classique : peu de gestion des dĂ©sabonnements ou du nettoyage des ressources.
    • RxJava : utilise Disposable pour gĂ©rer le cycle de vie des flux et s'assurer qu'on Ă©vite les fuites de mĂ©moire.

  4. Mise Ă  jour de l'interface :

    • Les deux approches mettent Ă  jour le titre, le sous-titre et les textes de rafraĂźchissement, mais dans la version RxJava, ces mises Ă  jour sont souvent dĂ©clenchĂ©es aprĂšs un traitement asynchrone.

  5. Recherche et chargement dynamique :

    • Classique : le chargement semble plutĂŽt passif, en attendant un changement dans le FeedState.
    • RxJava : une recherche par mot-clĂ© (getStreamWithKeyword) permet de filtrer activement les flux vidĂ©o et de mettre Ă  jour les rĂ©sultats de façon dynamique.

En gros, la version RxJava est beaucoup plus réactive et flexible, surtout pour des tùches complexes comme le chargement et la recherche de vidéos. La version classique, elle, est plus simple et directe, mais moins performante dÚs qu'il faut gérer des appels réseau ou des mises à jour parallÚles.

Ce fichier FeedFragment est une classe qui gÚre l'affichage des flux (feeds) dans l'application NewPipe. Plongeons dans les aspects clés :

🌟 HĂ©ritage et initialisation

  • FeedFragment hĂ©rite de BaseStateFragment<FeedState>(), ce qui permet de gĂ©rer des Ă©tats spĂ©cifiques pour l'affichage des flux (chargement, erreur, contenu disponible, etc.).
  • Initialisation des variables :
    • _feedBinding pour le view binding (liaison aux Ă©lĂ©ments de l'UI).
    • disposables pour gĂ©rer les abonnements RxJava et Ă©viter les fuites de mĂ©moire.
    • viewModel pour observer les donnĂ©es des flux grĂące Ă  FeedViewModel.
    • Des Ă©tats sauvegardĂ©s comme listState et des options comme contentFilter.

🏃 Cycle de vie

  • onCreate() : RĂ©cupĂšre les arguments (comme le groupe de flux actuel), et enregistre un listener pour dĂ©tecter les changements dans les prĂ©fĂ©rences utilisateur.
  • onCreateView() : Gonfle le layout.
  • onViewCreated() :
    • Initialise le FeedViewModel avec un factory.
    • Observe le stateLiveData pour rĂ©agir aux changements de donnĂ©es.
    • Configure l'adapter GroupieAdapter pour afficher les Ă©lĂ©ments des flux.
    • GĂšre le scroll listener pour dĂ©tecter les dĂ©filements et afficher/masquer le bouton de nouveaux Ă©lĂ©ments.
  • onPause() et onResume() : Sauvegardent et restaurent l'Ă©tat de la liste (pratique pour Ă©viter que l'utilisateur perde sa position aprĂšs avoir quittĂ© temporairement l'Ă©cran).
  • onDestroy() :
    • LibĂšre les abonnements RxJava avec disposables.dispose().
    • DĂ©senregistre le listener des prĂ©fĂ©rences.
    • Nettoie les animations pour Ă©viter les fuites de mĂ©moire.

đŸ“± Gestion des listes et des vues

  • Mode d'affichage (grille ou liste) :
    • La mĂ©thode setupListViewMode() ajuste le nombre de colonnes selon que l'utilisateur prĂ©fĂšre une vue grille ou liste.
  • Gestion des clics :
    • L'adapter utilise un OnItemClickListener et OnItemLongClickListener pour gĂ©rer les interactions avec chaque flux vidĂ©o.

🔧 Menu et prĂ©fĂ©rences

  • onCreateOptionsMenu() et onOptionsItemSelected() :
    • Ajoutent des options dans le menu (par ex. une aide pour comprendre le mode dĂ©diĂ© de rĂ©cupĂ©ration des flux).
  • Gestion dynamique du sous-titre : Le sous-titre dans la barre d'action est mis Ă  jour selon le groupe de flux actuel.

⚡ RxJava et asynchronisme

  • Les flux de donnĂ©es (vidĂ©os, abonnements, etc.) sont gĂ©rĂ©s de façon asynchrone, avec :
    • CompositeDisposable pour enregistrer et nettoyer les abonnements.
    • Schedulers.io() pour les opĂ©rations en arriĂšre-plan (comme charger les flux depuis la base de donnĂ©es).
    • AndroidSchedulers.mainThread() pour mettre Ă  jour l'interface utilisateur aprĂšs le chargement des donnĂ©es.

Ce code dans le FeedFragment est super riche ! 🌟 Je vais t’expliquer les morceaux clĂ©s, surtout ceux liĂ©s Ă  l’affichage des flux (loading, erreurs, rĂ©sultats) et Ă  l’utilisation de RxJava. On attaque ?

🚀 1. Gestion des Ă©tats de chargement

MĂ©thodes principales :

  • showLoading() : affiche l’état de chargement.
  • hideLoading() : masque le chargement une fois les donnĂ©es prĂȘtes.
  • showEmptyState() : montre un Ă©cran vide si aucune donnĂ©e n’est rĂ©cupĂ©rĂ©e.
  • handleError() : gĂšre l’affichage en cas d’erreur.

👉 Animations & UI :
Chaque méthode utilise des animations pour cacher ou montrer des vues, grùce à des appels comme :

feedBinding.itemsList.animateHideRecyclerViewAllowingScrolling()
feedBinding.refreshRootView.animate(true, 200)
  • itemsList : la liste des vidĂ©os ou abonnements.
  • refreshRootView : une vue qui entoure le contenu et permet l'actualisation.
  • loadingProgressText : un texte pour l’indicateur de chargement.

👉 Refresh & Ă©tats :
Les deux variables clés sont :

  • swipeRefreshLayout.isRefreshing : pour le "pull-to-refresh".
  • isRefreshing : une variable interne pour suivre si une actualisation est en cours.

đŸ§Ș 2. Extraction des vidĂ©os & traitement des rĂ©sultats

La méthode clé ici est :

override fun handleResult(result: FeedState)

👉 Processus principal :

  • Elle appelle ExtractorHelper.getStreamInfo() pour rĂ©cupĂ©rer des infos sur une vidĂ©o spĂ©cifique.
  • RxJava permet d'effectuer cette opĂ©ration de façon asynchrone, avec :
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
  • Schedulers.io() : exĂ©cute la tĂąche en arriĂšre-plan (parfait pour le chargement rĂ©seau).
  • AndroidSchedulers.mainThread() : met Ă  jour l’UI une fois les donnĂ©es chargĂ©es.

👉 Gestion des rĂ©sultats :
En cas de succĂšs :

.subscribe({ result: StreamInfo -> 
    val item1 = StreamItem(...)
    handleLoadedState(FeedState.LoadedState(items = listOf(item1), null, 0))
})
  • StreamItem crĂ©e un objet reprĂ©sentant une vidĂ©o (avec son titre, URL, durĂ©e
).
  • handleLoadedState() met Ă  jour l’UI pour afficher les vidĂ©os.

En cas d’échec :

) { throwable: Throwable? -> 
    println("Erreur dans la requĂȘte")
}

⚠ Il y a un petit conflit de merge dans ton code ici (les lignes <<<<<<< HEAD et >>>>>>>), ça peut poser problĂšme ! Tu veux qu'on rĂšgle ça ensemble ?

đŸ“ș 3. Mise Ă  jour de la liste & affichage

Quand les données sont chargées, elles sont affichées avec :

groupAdapter.updateAsync(loadedState.items, false)
  • groupAdapter gĂšre l’affichage des vidĂ©os (peut-ĂȘtre avec Groupie ?).
  • Le mode d’affichage (grille, carte ou liste) est ajustĂ© ici :
val itemVersion = when (getItemViewMode(requireContext())) {
    ItemViewMode.GRID -> StreamItem.ItemVersion.GRID
    ItemViewMode.CARD -> StreamItem.ItemVersion.CARD
    else -> StreamItem.ItemVersion.NORMAL
}

⚠ 4. Gestion des erreurs avancĂ©es

Il y a aussi une gestion des erreurs spĂ©cifiques, comme quand un abonnement a Ă©tĂ© supprimĂ© ou que le contenu n’est plus dispo :

if (t is FeedLoadService.RequestException && t.cause is ContentNotAvailableException)
  • Si un flux n’existe plus, une alerte s'affiche pour dĂ©sabonner l'utilisateur :
AlertDialog.Builder(requireContext())
    .setTitle(R.string.feed_load_error)
    .setPositiveButton(R.string.unsubscribe) { _, _ ->
        SubscriptionManager(requireContext()).deleteSubscription(...)
    }
    .setNegativeButton(R.string.cancel) { _, _ -> }

💡 En rĂ©sumĂ© :

  • RxJava est au cƓur du chargement asynchrone des vidĂ©os.
  • Animations & Ă©tat de l’UI sont gĂ©rĂ©s via le feedBinding.
  • Groupie semble gĂ©rer l’adapter pour afficher les flux.
  • Gestion des erreurs : un bon mix entre erreurs gĂ©nĂ©riques et cas particuliers (contenus supprimĂ©s, comptes fermĂ©s
).

Ce code dans FeedFragment sert principalement Ă  deux choses :

  1. Mettre en surbrillance les nouveaux éléments
    La méthode highlightNewItemsAfter(updateTime: OffsetDateTime) parcourt la liste des éléments (via groupAdapter) et met en gras (via Typeface.DEFAULT_BOLD) et entoure d'une bordure spécifique (dashed_border) les éléments dont la date d'upload est postérieure à updateTime.

    âšĄïž Optimisation :

    • DĂšs qu'un Ă©lĂ©ment plus ancien est trouvĂ©, la boucle s'arrĂȘte prĂ©maturĂ©ment grĂące Ă  doCheck = false, ce qui est malin puisque les Ă©lĂ©ments sont triĂ©s par ordre chronologique dĂ©croissant (les plus rĂ©cents en haut).

    đŸ› ïž Mise Ă  jour de l'affichage :

    • Une fois le surlignage fait, tous les Ă©lĂ©ments affectĂ©s sont rafraĂźchis avec groupAdapter.notifyItemRangeChanged(), ce qui force l'interface Ă  se mettre Ă  jour immĂ©diatement.

  2. Gérer les animations des nouveaux éléments
    Quand des nouveaux éléments sont détectés (highlightCount > 0), le bouton pour les nouveaux éléments (newItemsLoadedButton) apparaßt avec une animation de "slide up" via showNewItemsLoaded().

    ⏳ DĂ©lai automatique :

    • Le bouton reste visible 10 secondes avant de disparaĂźtre automatiquement grĂące Ă  hideNewItemsLoaded(true, 10000).
    • Si les animations sont dĂ©sactivĂ©es sur l'appareil (dĂ©tectĂ© via DeviceUtils.hasAnimationsAnimatorDurationEnabled()), le bouton disparaĂźt immĂ©diatement.

  3. Gestion de la recherche de flux vidéo
    La méthode getStreamWithKeyword() utilise RxJava pour effectuer une recherche asynchrone (via ExtractorHelper.searchFor()).

    • Elle observe les rĂ©sultats sur le thread principal (observeOn(AndroidSchedulers.mainThread())).
    • Si des rĂ©sultats sont trouvĂ©s, ils sont ajoutĂ©s Ă  l'adaptateur InfoListAdapter grĂące Ă  la mĂ©thode getSuggestionStreamFromSuscribeReturn().
    • Si rien n'est trouvĂ©, elle dĂ©clenche un Ă©tat vide via showEmptyState().

    ⚠ ProblĂšme potentiel :
    Le return dans le subscribe() ne fonctionne pas comme prévu, car les appels RxJava sont asynchrones. Pour récupérer le résultat, il faudrait passer par un callback ou mettre à jour l'état via un observer.