2024-03-31 18:40:15 +02:00
|
|
|
package de.danoeh.antennapod.ui.screen.feed;
|
2012-06-16 17:18:37 +02:00
|
|
|
|
2013-06-01 18:29:04 +02:00
|
|
|
import android.content.Context;
|
2021-06-29 22:01:04 +02:00
|
|
|
import android.content.res.Configuration;
|
2015-07-31 10:50:38 +02:00
|
|
|
import android.graphics.LightingColorFilter;
|
2012-06-16 17:18:37 +02:00
|
|
|
import android.os.Bundle;
|
|
|
|
import android.util.Log;
|
2021-06-29 22:01:04 +02:00
|
|
|
import android.view.ContextMenu;
|
2022-02-20 15:52:22 +01:00
|
|
|
import android.view.KeyEvent;
|
2014-07-15 01:00:42 +02:00
|
|
|
import android.view.LayoutInflater;
|
|
|
|
import android.view.MenuItem;
|
|
|
|
import android.view.View;
|
2020-03-12 13:28:30 +01:00
|
|
|
import android.view.ViewGroup;
|
2015-05-09 21:19:22 +02:00
|
|
|
import android.widget.AdapterView;
|
2019-12-19 16:52:37 +01:00
|
|
|
import android.widget.Toast;
|
2024-01-20 17:31:16 +01:00
|
|
|
|
2019-10-17 20:44:00 +02:00
|
|
|
import androidx.annotation.NonNull;
|
2020-03-12 13:28:30 +01:00
|
|
|
import androidx.annotation.Nullable;
|
2021-12-12 20:56:31 +01:00
|
|
|
import androidx.appcompat.content.res.AppCompatResources;
|
2022-02-20 15:52:22 +01:00
|
|
|
import androidx.fragment.app.Fragment;
|
2020-03-17 00:17:21 +01:00
|
|
|
import androidx.recyclerview.widget.RecyclerView;
|
2024-01-20 17:31:16 +01:00
|
|
|
|
2015-07-21 20:04:39 +02:00
|
|
|
import com.bumptech.glide.Glide;
|
2018-10-14 10:26:36 +02:00
|
|
|
import com.bumptech.glide.request.RequestOptions;
|
2023-12-03 16:36:28 +01:00
|
|
|
import com.google.android.material.appbar.MaterialToolbar;
|
2021-06-29 22:01:04 +02:00
|
|
|
import com.google.android.material.snackbar.Snackbar;
|
|
|
|
import com.leinardi.android.speeddial.SpeedDialView;
|
2024-01-20 17:31:16 +01:00
|
|
|
|
2024-03-31 18:40:15 +02:00
|
|
|
import de.danoeh.antennapod.ui.screen.episode.ItemPagerFragment;
|
|
|
|
import de.danoeh.antennapod.ui.screen.SearchFragment;
|
|
|
|
import de.danoeh.antennapod.ui.TransitionEffect;
|
2024-03-29 17:45:14 +01:00
|
|
|
import de.danoeh.antennapod.net.download.serviceinterface.FeedUpdateManager;
|
2024-03-31 18:40:15 +02:00
|
|
|
import de.danoeh.antennapod.ui.screen.download.DownloadLogFragment;
|
|
|
|
import de.danoeh.antennapod.ui.screen.feed.preferences.FeedSettingsFragment;
|
2024-01-20 17:31:16 +01:00
|
|
|
import org.apache.commons.lang3.StringUtils;
|
|
|
|
import org.apache.commons.lang3.Validate;
|
|
|
|
import org.greenrobot.eventbus.EventBus;
|
|
|
|
import org.greenrobot.eventbus.Subscribe;
|
|
|
|
import org.greenrobot.eventbus.ThreadMode;
|
|
|
|
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.concurrent.ExecutionException;
|
|
|
|
|
2012-09-22 12:46:36 +02:00
|
|
|
import de.danoeh.antennapod.R;
|
2014-04-21 12:02:08 +02:00
|
|
|
import de.danoeh.antennapod.activity.MainActivity;
|
2024-03-31 18:40:15 +02:00
|
|
|
import de.danoeh.antennapod.ui.episodeslist.EpisodeItemListAdapter;
|
2024-03-24 21:27:30 +01:00
|
|
|
import de.danoeh.antennapod.event.FeedEvent;
|
2024-03-31 18:40:15 +02:00
|
|
|
import de.danoeh.antennapod.ui.MenuItemUtils;
|
2024-03-25 21:45:43 +01:00
|
|
|
import de.danoeh.antennapod.storage.database.DBReader;
|
2024-03-29 17:45:14 +01:00
|
|
|
import de.danoeh.antennapod.storage.database.DBWriter;
|
2024-03-25 21:45:43 +01:00
|
|
|
import de.danoeh.antennapod.storage.database.FeedItemPermutors;
|
2024-04-05 19:20:27 +02:00
|
|
|
import de.danoeh.antennapod.ui.common.IntentUtils;
|
2024-03-31 18:40:15 +02:00
|
|
|
import de.danoeh.antennapod.ui.share.ShareUtils;
|
|
|
|
import de.danoeh.antennapod.ui.episodeslist.MoreContentListFooterUtil;
|
2022-04-22 22:11:12 +02:00
|
|
|
import de.danoeh.antennapod.databinding.FeedItemListFragmentBinding;
|
|
|
|
import de.danoeh.antennapod.databinding.MultiSelectSpeedDialBinding;
|
2024-03-31 18:40:15 +02:00
|
|
|
import de.danoeh.antennapod.ui.screen.download.DownloadLogDetailsDialog;
|
|
|
|
import de.danoeh.antennapod.ui.FeedItemFilterDialog;
|
2023-05-05 23:09:03 +02:00
|
|
|
import de.danoeh.antennapod.event.EpisodeDownloadEvent;
|
2022-02-20 15:52:22 +01:00
|
|
|
import de.danoeh.antennapod.event.FavoritesEvent;
|
|
|
|
import de.danoeh.antennapod.event.FeedItemEvent;
|
|
|
|
import de.danoeh.antennapod.event.FeedListUpdateEvent;
|
2023-03-14 21:03:45 +01:00
|
|
|
import de.danoeh.antennapod.event.FeedUpdateRunningEvent;
|
2022-02-20 15:52:22 +01:00
|
|
|
import de.danoeh.antennapod.event.PlayerStatusEvent;
|
|
|
|
import de.danoeh.antennapod.event.QueueEvent;
|
|
|
|
import de.danoeh.antennapod.event.UnreadItemsUpdateEvent;
|
|
|
|
import de.danoeh.antennapod.event.playback.PlaybackPositionEvent;
|
2024-03-31 18:40:15 +02:00
|
|
|
import de.danoeh.antennapod.ui.episodeslist.EpisodeMultiSelectActionHandler;
|
|
|
|
import de.danoeh.antennapod.ui.swipeactions.SwipeActions;
|
|
|
|
import de.danoeh.antennapod.ui.episodeslist.FeedItemMenuHandler;
|
2023-05-05 23:09:03 +02:00
|
|
|
import de.danoeh.antennapod.model.download.DownloadResult;
|
2021-07-12 00:03:32 +02:00
|
|
|
import de.danoeh.antennapod.model.feed.Feed;
|
|
|
|
import de.danoeh.antennapod.model.feed.FeedItem;
|
|
|
|
import de.danoeh.antennapod.model.feed.FeedItemFilter;
|
2023-12-03 16:36:28 +01:00
|
|
|
import de.danoeh.antennapod.model.feed.SortOrder;
|
2023-04-07 14:21:52 +02:00
|
|
|
import de.danoeh.antennapod.storage.preferences.UserPreferences;
|
2022-11-01 13:07:18 +01:00
|
|
|
import de.danoeh.antennapod.ui.glide.FastBlurTransformation;
|
2024-03-31 18:40:15 +02:00
|
|
|
import de.danoeh.antennapod.ui.episodeslist.EpisodeItemViewHolder;
|
2022-02-20 15:52:22 +01:00
|
|
|
import io.reactivex.Maybe;
|
2018-09-30 19:58:53 +02:00
|
|
|
import io.reactivex.Observable;
|
|
|
|
import io.reactivex.android.schedulers.AndroidSchedulers;
|
|
|
|
import io.reactivex.disposables.Disposable;
|
|
|
|
import io.reactivex.schedulers.Schedulers;
|
2013-06-01 18:29:04 +02:00
|
|
|
|
2014-04-17 21:40:50 +02:00
|
|
|
/**
|
|
|
|
* Displays a list of FeedItems.
|
|
|
|
*/
|
2020-11-01 11:30:01 +01:00
|
|
|
public class FeedItemlistFragment extends Fragment implements AdapterView.OnItemClickListener,
|
2022-08-04 23:09:38 +02:00
|
|
|
MaterialToolbar.OnMenuItemClickListener, EpisodeItemListAdapter.OnSelectModeListener {
|
2021-07-12 00:03:32 +02:00
|
|
|
public static final String TAG = "ItemlistFragment";
|
2018-01-14 18:04:53 +01:00
|
|
|
private static final String ARGUMENT_FEED_ID = "argument.de.danoeh.antennapod.feed_id";
|
2021-02-15 21:22:33 +01:00
|
|
|
private static final String KEY_UP_ARROW = "up_arrow";
|
2014-04-17 21:40:50 +02:00
|
|
|
|
2020-03-17 00:17:21 +01:00
|
|
|
private FeedItemListAdapter adapter;
|
2021-07-12 00:03:32 +02:00
|
|
|
private SwipeActions swipeActions;
|
2020-03-17 14:23:16 +01:00
|
|
|
private MoreContentListFooterUtil nextPageLoader;
|
2021-02-15 21:22:33 +01:00
|
|
|
private boolean displayUpArrow;
|
2020-03-12 22:11:07 +01:00
|
|
|
private long feedID;
|
|
|
|
private Feed feed;
|
|
|
|
private boolean headerCreated = false;
|
2018-09-30 19:58:53 +02:00
|
|
|
private Disposable disposable;
|
2022-04-22 22:11:12 +02:00
|
|
|
private FeedItemListFragmentBinding viewBinding;
|
|
|
|
private MultiSelectSpeedDialBinding speedDialBinding;
|
2015-09-19 20:39:14 +02:00
|
|
|
|
2014-04-17 21:40:50 +02:00
|
|
|
/**
|
|
|
|
* Creates new ItemlistFragment which shows the Feeditems of a specific
|
|
|
|
* feed. Sets 'showFeedtitle' to false
|
|
|
|
*
|
|
|
|
* @param feedId The id of the feed to show
|
|
|
|
* @return the newly created instance of an ItemlistFragment
|
|
|
|
*/
|
2019-08-30 11:55:45 +02:00
|
|
|
public static FeedItemlistFragment newInstance(long feedId) {
|
|
|
|
FeedItemlistFragment i = new FeedItemlistFragment();
|
2014-04-17 21:40:50 +02:00
|
|
|
Bundle b = new Bundle();
|
|
|
|
b.putLong(ARGUMENT_FEED_ID, feedId);
|
|
|
|
i.setArguments(b);
|
|
|
|
return i;
|
2013-06-01 18:29:04 +02:00
|
|
|
}
|
|
|
|
|
2014-04-17 21:40:50 +02:00
|
|
|
@Override
|
|
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
|
|
super.onCreate(savedInstanceState);
|
|
|
|
|
|
|
|
Bundle args = getArguments();
|
2014-07-06 13:48:38 +02:00
|
|
|
Validate.notNull(args);
|
2014-04-17 21:40:50 +02:00
|
|
|
feedID = args.getLong(ARGUMENT_FEED_ID);
|
|
|
|
}
|
2019-08-31 00:56:21 +02:00
|
|
|
|
2020-03-12 13:28:30 +01:00
|
|
|
@Nullable
|
2013-08-29 14:16:09 +02:00
|
|
|
@Override
|
2020-03-12 13:28:30 +01:00
|
|
|
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
|
|
|
|
@Nullable Bundle savedInstanceState) {
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding = FeedItemListFragmentBinding.inflate(inflater);
|
|
|
|
speedDialBinding = MultiSelectSpeedDialBinding.bind(viewBinding.getRoot());
|
|
|
|
viewBinding.toolbar.inflateMenu(R.menu.feedlist);
|
|
|
|
viewBinding.toolbar.setOnMenuItemClickListener(this);
|
2022-07-09 15:29:15 +02:00
|
|
|
viewBinding.toolbar.setOnLongClickListener(v -> {
|
|
|
|
viewBinding.recyclerView.scrollToPosition(5);
|
|
|
|
viewBinding.recyclerView.post(() -> viewBinding.recyclerView.smoothScrollToPosition(0));
|
|
|
|
viewBinding.appBar.setExpanded(true);
|
|
|
|
return false;
|
|
|
|
});
|
2021-02-15 21:22:33 +01:00
|
|
|
displayUpArrow = getParentFragmentManager().getBackStackEntryCount() != 0;
|
|
|
|
if (savedInstanceState != null) {
|
|
|
|
displayUpArrow = savedInstanceState.getBoolean(KEY_UP_ARROW);
|
|
|
|
}
|
2022-04-22 22:11:12 +02:00
|
|
|
((MainActivity) getActivity()).setupToolbarToggle(viewBinding.toolbar, displayUpArrow);
|
2022-08-19 20:03:40 +02:00
|
|
|
updateToolbar();
|
2020-03-12 13:28:30 +01:00
|
|
|
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.recyclerView.setRecycledViewPool(((MainActivity) getActivity()).getRecycledViewPool());
|
2022-08-28 16:52:29 +02:00
|
|
|
adapter = new FeedItemListAdapter((MainActivity) getActivity());
|
|
|
|
adapter.setOnSelectModeListener(this);
|
|
|
|
viewBinding.recyclerView.setAdapter(adapter);
|
|
|
|
swipeActions = new SwipeActions(this, TAG).attachTo(viewBinding.recyclerView);
|
2022-12-18 18:43:54 +01:00
|
|
|
viewBinding.progressBar.setVisibility(View.VISIBLE);
|
2022-08-28 16:52:29 +02:00
|
|
|
|
2022-04-22 22:11:12 +02:00
|
|
|
ToolbarIconTintManager iconTintManager = new ToolbarIconTintManager(
|
|
|
|
getContext(), viewBinding.toolbar, viewBinding.collapsingToolbar) {
|
2020-03-12 22:11:07 +01:00
|
|
|
@Override
|
|
|
|
protected void doTint(Context themedContext) {
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.toolbar.getMenu().findItem(R.id.refresh_item)
|
2021-12-12 20:56:31 +01:00
|
|
|
.setIcon(AppCompatResources.getDrawable(themedContext, R.drawable.ic_refresh));
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.toolbar.getMenu().findItem(R.id.action_search)
|
2021-12-12 20:56:31 +01:00
|
|
|
.setIcon(AppCompatResources.getDrawable(themedContext, R.drawable.ic_search));
|
2020-03-12 22:11:07 +01:00
|
|
|
}
|
|
|
|
};
|
2020-11-01 11:30:01 +01:00
|
|
|
iconTintManager.updateTint();
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.appBar.addOnOffsetChangedListener(iconTintManager);
|
2020-03-17 14:23:16 +01:00
|
|
|
|
2022-04-22 22:11:12 +02:00
|
|
|
nextPageLoader = new MoreContentListFooterUtil(viewBinding.moreContent.moreContentListFooter);
|
2020-03-17 14:23:16 +01:00
|
|
|
nextPageLoader.setClickListener(() -> {
|
|
|
|
if (feed != null) {
|
2024-03-29 17:45:14 +01:00
|
|
|
FeedUpdateManager.getInstance().runOnce(getContext(), feed, true);
|
2020-03-17 14:23:16 +01:00
|
|
|
}
|
|
|
|
});
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {
|
2020-03-17 14:23:16 +01:00
|
|
|
@Override
|
2020-04-01 20:29:48 +02:00
|
|
|
public void onScrolled(@NonNull RecyclerView view, int deltaX, int deltaY) {
|
|
|
|
super.onScrolled(view, deltaX, deltaY);
|
2020-03-17 14:23:16 +01:00
|
|
|
boolean hasMorePages = feed != null && feed.isPaged() && feed.getNextPageLink() != null;
|
2022-05-14 17:07:45 +02:00
|
|
|
boolean pageLoaderVisible = viewBinding.recyclerView.isScrolledToBottom() && hasMorePages;
|
|
|
|
nextPageLoader.getRoot().setVisibility(pageLoaderVisible ? View.VISIBLE : View.GONE);
|
|
|
|
viewBinding.recyclerView.setPadding(
|
|
|
|
viewBinding.recyclerView.getPaddingLeft(), 0, viewBinding.recyclerView.getPaddingRight(),
|
|
|
|
pageLoaderVisible ? nextPageLoader.getRoot().getMeasuredHeight() : 0);
|
2020-03-17 14:23:16 +01:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2019-04-12 11:28:29 +02:00
|
|
|
EventBus.getDefault().register(this);
|
2020-10-04 15:47:12 +02:00
|
|
|
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.swipeRefresh.setDistanceToTriggerSync(getResources().getInteger(R.integer.swipe_refresh_distance));
|
2024-03-29 17:45:14 +01:00
|
|
|
viewBinding.swipeRefresh.setOnRefreshListener(() ->
|
|
|
|
FeedUpdateManager.getInstance().runOnceOrAsk(requireContext(), feed));
|
2020-10-04 15:47:12 +02:00
|
|
|
|
2019-05-26 18:23:27 +02:00
|
|
|
loadItems();
|
2021-06-29 22:01:04 +02:00
|
|
|
|
|
|
|
// Init action UI (via a FAB Speed Dial)
|
2022-04-22 22:11:12 +02:00
|
|
|
speedDialBinding.fabSD.setOverlayLayout(speedDialBinding.fabSDOverlay);
|
|
|
|
speedDialBinding.fabSD.inflate(R.menu.episodes_apply_action_speeddial);
|
|
|
|
speedDialBinding.fabSD.setOnChangeListener(new SpeedDialView.OnChangeListener() {
|
2021-06-29 22:01:04 +02:00
|
|
|
@Override
|
|
|
|
public boolean onMainActionSelected() {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onToggleChanged(boolean open) {
|
|
|
|
if (open && adapter.getSelectedCount() == 0) {
|
|
|
|
((MainActivity) getActivity()).showSnackbarAbovePlayer(R.string.no_items_selected,
|
|
|
|
Snackbar.LENGTH_SHORT);
|
2022-04-22 22:11:12 +02:00
|
|
|
speedDialBinding.fabSD.close();
|
2021-06-29 22:01:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2022-04-22 22:11:12 +02:00
|
|
|
speedDialBinding.fabSD.setOnActionSelectedListener(actionItem -> {
|
2022-05-08 11:08:34 +02:00
|
|
|
new EpisodeMultiSelectActionHandler(((MainActivity) getActivity()), actionItem.getId())
|
|
|
|
.handleAction(adapter.getSelectedItems());
|
2021-06-29 22:01:04 +02:00
|
|
|
adapter.endSelectMode();
|
|
|
|
return true;
|
|
|
|
});
|
2022-04-22 22:11:12 +02:00
|
|
|
return viewBinding.getRoot();
|
2013-08-29 14:16:09 +02:00
|
|
|
}
|
2013-01-27 00:53:06 +01:00
|
|
|
|
2014-04-17 21:40:50 +02:00
|
|
|
@Override
|
2014-04-22 13:55:20 +02:00
|
|
|
public void onDestroyView() {
|
|
|
|
super.onDestroyView();
|
2014-04-17 21:40:50 +02:00
|
|
|
|
2015-11-30 18:30:07 +01:00
|
|
|
EventBus.getDefault().unregister(this);
|
2019-09-27 13:14:54 +02:00
|
|
|
if (disposable != null) {
|
2018-09-30 19:58:53 +02:00
|
|
|
disposable.dispose();
|
2015-09-19 20:39:14 +02:00
|
|
|
}
|
2022-08-28 16:52:29 +02:00
|
|
|
adapter.endSelectMode();
|
2014-04-17 21:40:50 +02:00
|
|
|
}
|
|
|
|
|
2021-02-15 21:22:33 +01:00
|
|
|
@Override
|
|
|
|
public void onSaveInstanceState(@NonNull Bundle outState) {
|
|
|
|
outState.putBoolean(KEY_UP_ARROW, displayUpArrow);
|
|
|
|
super.onSaveInstanceState(outState);
|
|
|
|
}
|
|
|
|
|
2022-08-19 20:03:40 +02:00
|
|
|
private void updateToolbar() {
|
2020-11-01 11:30:01 +01:00
|
|
|
if (feed == null) {
|
2016-01-13 19:07:16 +01:00
|
|
|
return;
|
|
|
|
}
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.toolbar.getMenu().findItem(R.id.visit_website_item).setVisible(feed.getLink() != null);
|
2023-12-03 16:36:28 +01:00
|
|
|
viewBinding.toolbar.getMenu().findItem(R.id.refresh_complete_item).setVisible(feed.isPaged());
|
|
|
|
if (StringUtils.isBlank(feed.getLink())) {
|
|
|
|
viewBinding.toolbar.getMenu().findItem(R.id.visit_website_item).setVisible(false);
|
|
|
|
}
|
|
|
|
if (feed.isLocalFeed()) {
|
|
|
|
viewBinding.toolbar.getMenu().findItem(R.id.share_item).setVisible(false);
|
|
|
|
}
|
2014-04-21 13:15:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2020-07-26 19:13:38 +02:00
|
|
|
public void onConfigurationChanged(@NonNull Configuration newConfig) {
|
2020-07-19 09:10:35 +02:00
|
|
|
super.onConfigurationChanged(newConfig);
|
|
|
|
int horizontalSpacing = (int) getResources().getDimension(R.dimen.additional_horizontal_spacing);
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.headerContainer.setPadding(
|
|
|
|
horizontalSpacing, viewBinding.header.headerContainer.getPaddingTop(),
|
|
|
|
horizontalSpacing, viewBinding.header.headerContainer.getPaddingBottom());
|
2020-07-19 09:10:35 +02:00
|
|
|
}
|
|
|
|
|
2014-04-21 13:15:33 +02:00
|
|
|
@Override
|
2020-11-01 11:30:01 +01:00
|
|
|
public boolean onMenuItemClick(MenuItem item) {
|
|
|
|
if (feed == null) {
|
|
|
|
((MainActivity) getActivity()).showSnackbarAbovePlayer(
|
|
|
|
R.string.please_wait_for_data, Toast.LENGTH_LONG);
|
2020-10-13 22:49:06 +02:00
|
|
|
return true;
|
2020-11-01 11:30:01 +01:00
|
|
|
}
|
2023-12-03 16:36:28 +01:00
|
|
|
if (item.getItemId() == R.id.visit_website_item) {
|
|
|
|
IntentUtils.openInBrowser(getContext(), feed.getLink());
|
|
|
|
} else if (item.getItemId() == R.id.share_item) {
|
|
|
|
ShareUtils.shareFeedLink(getContext(), feed);
|
|
|
|
} else if (item.getItemId() == R.id.refresh_item) {
|
2024-03-29 17:45:14 +01:00
|
|
|
FeedUpdateManager.getInstance().runOnceOrAsk(getContext(), feed);
|
2023-12-03 16:36:28 +01:00
|
|
|
} else if (item.getItemId() == R.id.refresh_complete_item) {
|
|
|
|
new Thread(() -> {
|
2024-03-23 11:27:55 +01:00
|
|
|
feed.setNextPageLink(feed.getDownloadUrl());
|
2023-12-03 16:36:28 +01:00
|
|
|
feed.setPageNr(0);
|
|
|
|
try {
|
|
|
|
DBWriter.resetPagedFeedPage(feed).get();
|
2024-03-29 17:45:14 +01:00
|
|
|
FeedUpdateManager.getInstance().runOnce(getContext(), feed);
|
2023-12-03 16:36:28 +01:00
|
|
|
} catch (ExecutionException | InterruptedException e) {
|
|
|
|
throw new RuntimeException(e);
|
|
|
|
}
|
|
|
|
}).start();
|
|
|
|
} else if (item.getItemId() == R.id.sort_items) {
|
|
|
|
SingleFeedSortDialog.newInstance(feed).show(getChildFragmentManager(), "SortDialog");
|
|
|
|
} else if (item.getItemId() == R.id.rename_item) {
|
2024-03-31 18:40:15 +02:00
|
|
|
new RenameFeedDialog(getActivity(), feed).show();
|
2023-12-03 16:36:28 +01:00
|
|
|
} else if (item.getItemId() == R.id.remove_feed) {
|
2023-04-07 14:21:52 +02:00
|
|
|
RemoveFeedDialog.show(getContext(), feed, () -> {
|
|
|
|
((MainActivity) getActivity()).loadFragment(UserPreferences.getDefaultPage(), null);
|
|
|
|
// Make sure fragment is hidden before actually starting to delete
|
|
|
|
getActivity().getSupportFragmentManager().executePendingTransactions();
|
|
|
|
});
|
2023-12-03 16:36:28 +01:00
|
|
|
} else if (item.getItemId() == R.id.action_search) {
|
2021-08-08 13:32:21 +02:00
|
|
|
((MainActivity) getActivity()).loadChildFragment(SearchFragment.newInstance(feed.getId(), feed.getTitle()));
|
2023-12-03 16:36:28 +01:00
|
|
|
} else {
|
|
|
|
return false;
|
2014-04-21 13:15:33 +02:00
|
|
|
}
|
2023-12-03 16:36:28 +01:00
|
|
|
return true;
|
2015-05-09 21:19:22 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2020-03-17 00:17:21 +01:00
|
|
|
public boolean onContextItemSelected(@NonNull MenuItem item) {
|
2021-06-29 22:01:04 +02:00
|
|
|
FeedItem selectedItem = adapter.getLongPressedItem();
|
2015-05-09 21:19:22 +02:00
|
|
|
if (selectedItem == null) {
|
2020-03-17 00:17:21 +01:00
|
|
|
Log.i(TAG, "Selected item at current position was null, ignoring selection");
|
2015-05-09 21:19:22 +02:00
|
|
|
return super.onContextItemSelected(item);
|
|
|
|
}
|
2021-06-29 22:01:04 +02:00
|
|
|
if (adapter.onContextItemSelected(item)) {
|
|
|
|
return true;
|
|
|
|
}
|
2019-09-22 21:54:09 +02:00
|
|
|
return FeedItemMenuHandler.onMenuItemClicked(this, item.getItemId(), selectedItem);
|
2015-05-09 21:19:22 +02:00
|
|
|
}
|
|
|
|
|
2014-04-17 21:40:50 +02:00
|
|
|
@Override
|
2020-03-12 13:28:30 +01:00
|
|
|
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
|
2016-03-27 18:26:47 +02:00
|
|
|
MainActivity activity = (MainActivity) getActivity();
|
2024-04-05 19:20:27 +02:00
|
|
|
activity.loadChildFragment(ItemPagerFragment.newInstance(feed.getItems(), feed.getItems().get(position)));
|
2013-06-01 18:29:04 +02:00
|
|
|
}
|
|
|
|
|
2020-05-11 12:23:01 +02:00
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
2015-04-26 13:37:27 +02:00
|
|
|
public void onEvent(FeedEvent event) {
|
2015-11-26 15:57:03 +01:00
|
|
|
Log.d(TAG, "onEvent() called with: " + "event = [" + event + "]");
|
2020-03-12 13:28:30 +01:00
|
|
|
if (event.feedId == feedID) {
|
2015-09-19 20:39:14 +02:00
|
|
|
loadItems();
|
2015-04-26 13:37:27 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-12 11:28:29 +02:00
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
2015-11-26 15:57:03 +01:00
|
|
|
public void onEventMainThread(FeedItemEvent event) {
|
|
|
|
Log.d(TAG, "onEventMainThread() called with: " + "event = [" + event + "]");
|
2020-03-17 00:17:21 +01:00
|
|
|
if (feed == null || feed.getItems() == null) {
|
|
|
|
return;
|
2015-11-26 15:57:03 +01:00
|
|
|
}
|
2020-03-17 00:17:21 +01:00
|
|
|
for (int i = 0, size = event.items.size(); i < size; i++) {
|
|
|
|
FeedItem item = event.items.get(i);
|
2024-04-05 19:20:27 +02:00
|
|
|
int pos = FeedItemEvent.indexOfItemWithId(feed.getItems(), item.getId());
|
2020-03-12 13:28:30 +01:00
|
|
|
if (pos >= 0) {
|
2020-03-17 00:17:21 +01:00
|
|
|
feed.getItems().remove(pos);
|
|
|
|
feed.getItems().add(pos, item);
|
2020-03-20 19:54:55 +01:00
|
|
|
adapter.notifyItemChangedCompat(pos);
|
2015-11-26 15:57:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-12 11:28:29 +02:00
|
|
|
@Subscribe(sticky = true, threadMode = ThreadMode.MAIN)
|
2023-05-05 23:09:03 +02:00
|
|
|
public void onEventMainThread(EpisodeDownloadEvent event) {
|
|
|
|
if (feed == null) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (String downloadUrl : event.getUrls()) {
|
2024-04-05 19:20:27 +02:00
|
|
|
int pos = EpisodeDownloadEvent.indexOfItemWithDownloadUrl(feed.getItems(), downloadUrl);
|
2023-05-05 23:09:03 +02:00
|
|
|
if (pos >= 0) {
|
|
|
|
adapter.notifyItemChangedCompat(pos);
|
2020-03-17 00:17:21 +01:00
|
|
|
}
|
2015-11-26 15:57:03 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-25 17:37:17 +02:00
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
|
|
|
public void onEventMainThread(PlaybackPositionEvent event) {
|
2022-08-28 16:52:29 +02:00
|
|
|
for (int i = 0; i < adapter.getItemCount(); i++) {
|
|
|
|
EpisodeItemViewHolder holder = (EpisodeItemViewHolder)
|
|
|
|
viewBinding.recyclerView.findViewHolderForAdapterPosition(i);
|
|
|
|
if (holder != null && holder.isCurrentlyPlayingItem()) {
|
|
|
|
holder.notifyPlaybackPositionUpdated(event);
|
|
|
|
break;
|
2020-03-17 00:17:21 +01:00
|
|
|
}
|
2019-09-25 17:37:17 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-12 00:03:32 +02:00
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
|
|
|
public void favoritesChanged(FavoritesEvent event) {
|
|
|
|
updateUi();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
|
|
|
public void onQueueChanged(QueueEvent event) {
|
|
|
|
updateUi();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onStartSelectMode() {
|
|
|
|
swipeActions.detach();
|
|
|
|
if (feed.isLocalFeed()) {
|
2022-04-22 22:11:12 +02:00
|
|
|
speedDialBinding.fabSD.removeActionItemById(R.id.download_batch);
|
2021-07-12 00:03:32 +02:00
|
|
|
}
|
2022-09-04 10:56:42 +02:00
|
|
|
speedDialBinding.fabSD.removeActionItemById(R.id.remove_all_inbox_item);
|
2022-04-22 22:11:12 +02:00
|
|
|
speedDialBinding.fabSD.setVisibility(View.VISIBLE);
|
2022-08-19 20:03:40 +02:00
|
|
|
updateToolbar();
|
2021-07-12 00:03:32 +02:00
|
|
|
}
|
|
|
|
|
2021-06-29 22:01:04 +02:00
|
|
|
@Override
|
|
|
|
public void onEndSelectMode() {
|
2022-04-22 22:11:12 +02:00
|
|
|
speedDialBinding.fabSD.close();
|
|
|
|
speedDialBinding.fabSD.setVisibility(View.GONE);
|
|
|
|
swipeActions.attachTo(viewBinding.recyclerView);
|
2021-06-29 22:01:04 +02:00
|
|
|
}
|
|
|
|
|
2019-10-25 11:12:31 +02:00
|
|
|
private void updateUi() {
|
2019-10-25 10:54:20 +02:00
|
|
|
loadItems();
|
|
|
|
}
|
|
|
|
|
2019-10-25 11:12:31 +02:00
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
|
|
|
public void onPlayerStatusChanged(PlayerStatusEvent event) {
|
|
|
|
updateUi();
|
|
|
|
}
|
|
|
|
|
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
|
|
|
public void onUnreadItemsChanged(UnreadItemsUpdateEvent event) {
|
|
|
|
updateUi();
|
|
|
|
}
|
|
|
|
|
2019-10-25 11:19:52 +02:00
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
|
|
|
public void onFeedListChanged(FeedListUpdateEvent event) {
|
2020-08-02 22:43:47 +02:00
|
|
|
if (feed != null && event.contains(feed)) {
|
2019-10-30 19:27:38 +01:00
|
|
|
updateUi();
|
|
|
|
}
|
2019-10-25 11:19:52 +02:00
|
|
|
}
|
2013-08-05 10:45:17 +02:00
|
|
|
|
2023-03-14 21:03:45 +01:00
|
|
|
@Subscribe(sticky = true, threadMode = ThreadMode.MAIN)
|
|
|
|
public void onEventMainThread(FeedUpdateRunningEvent event) {
|
|
|
|
nextPageLoader.setLoadingState(event.isFeedUpdateRunning);
|
|
|
|
if (!event.isFeedUpdateRunning) {
|
2020-03-17 14:23:16 +01:00
|
|
|
nextPageLoader.getRoot().setVisibility(View.GONE);
|
2014-11-10 21:01:41 +01:00
|
|
|
}
|
2024-01-20 17:31:16 +01:00
|
|
|
viewBinding.swipeRefresh.setRefreshing(event.isFeedUpdateRunning);
|
2014-04-17 21:40:50 +02:00
|
|
|
}
|
|
|
|
|
2015-04-26 13:37:27 +02:00
|
|
|
private void refreshHeaderView() {
|
2020-03-20 19:02:46 +01:00
|
|
|
setupHeaderView();
|
2022-04-22 22:11:12 +02:00
|
|
|
if (viewBinding == null || feed == null) {
|
2016-11-19 15:53:17 +01:00
|
|
|
Log.e(TAG, "Unable to refresh header view");
|
2015-08-05 04:03:14 +02:00
|
|
|
return;
|
|
|
|
}
|
2017-06-05 10:55:45 +02:00
|
|
|
loadFeedImage();
|
2020-03-12 13:28:30 +01:00
|
|
|
if (feed.hasLastUpdateFailed()) {
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvFailure.setVisibility(View.VISIBLE);
|
2015-04-26 12:59:01 +02:00
|
|
|
} else {
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvFailure.setVisibility(View.GONE);
|
2015-04-26 12:59:01 +02:00
|
|
|
}
|
2021-03-10 13:30:45 +01:00
|
|
|
if (!feed.getPreferences().getKeepUpdated()) {
|
2024-03-10 08:02:34 +01:00
|
|
|
viewBinding.header.txtvUpdatesDisabled.setText(R.string.updates_disabled_label);
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvUpdatesDisabled.setVisibility(View.VISIBLE);
|
2021-03-10 13:30:45 +01:00
|
|
|
} else {
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvUpdatesDisabled.setVisibility(View.GONE);
|
2021-03-10 13:30:45 +01:00
|
|
|
}
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvTitle.setText(feed.getTitle());
|
|
|
|
viewBinding.header.txtvAuthor.setText(feed.getAuthor());
|
2020-03-12 13:28:30 +01:00
|
|
|
if (feed.getItemFilter() != null) {
|
2015-04-26 13:37:27 +02:00
|
|
|
FeedItemFilter filter = feed.getItemFilter();
|
2020-03-12 13:28:30 +01:00
|
|
|
if (filter.getValues().length > 0) {
|
2024-03-10 08:02:34 +01:00
|
|
|
viewBinding.header.txtvInformation.setText(R.string.filtered_label);
|
2022-04-22 20:53:29 +02:00
|
|
|
viewBinding.header.txtvInformation.setOnClickListener(l ->
|
|
|
|
FeedItemFilterDialog.newInstance(feed).show(getChildFragmentManager(), null));
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvInformation.setVisibility(View.VISIBLE);
|
2015-04-26 13:37:27 +02:00
|
|
|
} else {
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvInformation.setVisibility(View.GONE);
|
2015-04-26 13:37:27 +02:00
|
|
|
}
|
|
|
|
} else {
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvInformation.setVisibility(View.GONE);
|
2015-04-26 13:37:27 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-04-17 21:40:50 +02:00
|
|
|
private void setupHeaderView() {
|
2020-03-17 00:17:21 +01:00
|
|
|
if (feed == null || headerCreated) {
|
2020-03-12 22:11:07 +01:00
|
|
|
return;
|
|
|
|
}
|
2014-07-27 23:29:47 +02:00
|
|
|
|
2015-07-31 10:50:38 +02:00
|
|
|
// https://github.com/bumptech/glide/issues/529
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.imgvBackground.setColorFilter(new LightingColorFilter(0xff666666, 0x000000));
|
|
|
|
viewBinding.header.butShowInfo.setOnClickListener(v -> showFeedInfo());
|
|
|
|
viewBinding.header.imgvCover.setOnClickListener(v -> showFeedInfo());
|
|
|
|
viewBinding.header.butShowSettings.setOnClickListener(v -> {
|
2019-05-26 18:23:27 +02:00
|
|
|
if (feed != null) {
|
2019-09-29 22:19:17 +02:00
|
|
|
FeedSettingsFragment fragment = FeedSettingsFragment.newInstance(feed);
|
2019-12-24 00:06:32 +01:00
|
|
|
((MainActivity) getActivity()).loadChildFragment(fragment, TransitionEffect.SLIDE);
|
2017-06-05 10:55:45 +02:00
|
|
|
}
|
|
|
|
});
|
2022-04-22 20:53:29 +02:00
|
|
|
viewBinding.header.butFilter.setOnClickListener(v ->
|
|
|
|
FeedItemFilterDialog.newInstance(feed).show(getChildFragmentManager(), null));
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.header.txtvFailure.setOnClickListener(v -> showErrorDetails());
|
2017-06-05 10:55:45 +02:00
|
|
|
headerCreated = true;
|
|
|
|
}
|
|
|
|
|
2022-02-20 15:52:22 +01:00
|
|
|
private void showErrorDetails() {
|
|
|
|
Maybe.fromCallable(
|
|
|
|
() -> {
|
2023-05-05 23:09:03 +02:00
|
|
|
List<DownloadResult> feedDownloadLog = DBReader.getFeedDownloadLog(feedID);
|
2022-02-20 15:52:22 +01:00
|
|
|
if (feedDownloadLog.size() == 0 || feedDownloadLog.get(0).isSuccessful()) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
return feedDownloadLog.get(0);
|
|
|
|
})
|
|
|
|
.subscribeOn(Schedulers.io())
|
|
|
|
.observeOn(AndroidSchedulers.mainThread())
|
|
|
|
.subscribe(
|
|
|
|
downloadStatus -> new DownloadLogDetailsDialog(getContext(), downloadStatus).show(),
|
|
|
|
error -> error.printStackTrace(),
|
2023-05-05 23:09:03 +02:00
|
|
|
() -> new DownloadLogFragment().show(getChildFragmentManager(), null));
|
2022-02-20 15:52:22 +01:00
|
|
|
}
|
|
|
|
|
2018-04-13 15:39:51 +02:00
|
|
|
private void showFeedInfo() {
|
2019-05-26 18:23:27 +02:00
|
|
|
if (feed != null) {
|
2019-09-16 00:07:35 +02:00
|
|
|
FeedInfoFragment fragment = FeedInfoFragment.newInstance(feed);
|
2019-12-24 00:06:32 +01:00
|
|
|
((MainActivity) getActivity()).loadChildFragment(fragment, TransitionEffect.SLIDE);
|
2018-04-13 15:39:51 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-05 10:55:45 +02:00
|
|
|
private void loadFeedImage() {
|
2023-05-07 11:43:35 +02:00
|
|
|
Glide.with(this)
|
2021-02-24 15:44:40 +01:00
|
|
|
.load(feed.getImageUrl())
|
2018-10-14 10:26:36 +02:00
|
|
|
.apply(new RequestOptions()
|
|
|
|
.placeholder(R.color.image_readability_tint)
|
|
|
|
.error(R.color.image_readability_tint)
|
|
|
|
.transform(new FastBlurTransformation())
|
|
|
|
.dontAnimate())
|
2022-04-22 22:11:12 +02:00
|
|
|
.into(viewBinding.imgvBackground);
|
2014-12-04 12:16:47 +01:00
|
|
|
|
2023-05-07 11:43:35 +02:00
|
|
|
Glide.with(this)
|
2021-02-24 15:44:40 +01:00
|
|
|
.load(feed.getImageUrl())
|
2018-10-14 10:26:36 +02:00
|
|
|
.apply(new RequestOptions()
|
|
|
|
.placeholder(R.color.light_gray)
|
|
|
|
.error(R.color.light_gray)
|
|
|
|
.fitCenter()
|
|
|
|
.dontAnimate())
|
2022-04-22 22:11:12 +02:00
|
|
|
.into(viewBinding.header.imgvCover);
|
2014-04-17 21:40:50 +02:00
|
|
|
}
|
|
|
|
|
2015-09-19 20:39:14 +02:00
|
|
|
private void loadItems() {
|
2020-03-12 13:28:30 +01:00
|
|
|
if (disposable != null) {
|
2018-09-30 19:58:53 +02:00
|
|
|
disposable.dispose();
|
2014-04-17 21:40:50 +02:00
|
|
|
}
|
2018-09-30 19:58:53 +02:00
|
|
|
disposable = Observable.fromCallable(this::loadData)
|
|
|
|
.subscribeOn(Schedulers.io())
|
2015-09-19 20:39:14 +02:00
|
|
|
.observeOn(AndroidSchedulers.mainThread())
|
2021-03-01 20:47:05 +01:00
|
|
|
.subscribe(
|
|
|
|
result -> {
|
|
|
|
feed = result;
|
2022-08-28 16:52:29 +02:00
|
|
|
swipeActions.setFilter(feed.getItemFilter());
|
2021-03-01 20:47:05 +01:00
|
|
|
refreshHeaderView();
|
2022-12-18 18:43:54 +01:00
|
|
|
viewBinding.progressBar.setVisibility(View.GONE);
|
2022-08-28 16:52:29 +02:00
|
|
|
adapter.setDummyViews(0);
|
|
|
|
adapter.updateItems(feed.getItems());
|
|
|
|
updateToolbar();
|
2021-03-01 20:47:05 +01:00
|
|
|
}, error -> {
|
|
|
|
feed = null;
|
|
|
|
refreshHeaderView();
|
2022-08-28 16:52:29 +02:00
|
|
|
adapter.setDummyViews(0);
|
|
|
|
adapter.updateItems(Collections.emptyList());
|
|
|
|
updateToolbar();
|
2021-03-01 20:47:05 +01:00
|
|
|
Log.e(TAG, Log.getStackTraceString(error));
|
|
|
|
});
|
2014-04-17 21:40:50 +02:00
|
|
|
}
|
|
|
|
|
2021-03-01 20:47:05 +01:00
|
|
|
@Nullable
|
|
|
|
private Feed loadData() {
|
2021-03-03 18:23:29 +01:00
|
|
|
Feed feed = DBReader.getFeed(feedID, true);
|
|
|
|
if (feed == null) {
|
|
|
|
return null;
|
2014-04-17 21:40:50 +02:00
|
|
|
}
|
2021-03-03 18:23:29 +01:00
|
|
|
DBReader.loadAdditionalFeedItemListData(feed.getItems());
|
|
|
|
if (feed.getSortOrder() != null) {
|
2019-10-24 20:01:48 +02:00
|
|
|
List<FeedItem> feedItems = feed.getItems();
|
2019-10-24 20:32:06 +02:00
|
|
|
FeedItemPermutors.getPermutor(feed.getSortOrder()).reorder(feedItems);
|
2019-10-24 20:01:48 +02:00
|
|
|
feed.setItems(feedItems);
|
2019-10-18 23:14:18 +02:00
|
|
|
}
|
2021-03-01 20:47:05 +01:00
|
|
|
return feed;
|
2014-04-17 21:40:50 +02:00
|
|
|
}
|
2020-03-17 00:17:21 +01:00
|
|
|
|
2021-12-14 23:02:49 +01:00
|
|
|
@Subscribe(threadMode = ThreadMode.MAIN)
|
|
|
|
public void onKeyUp(KeyEvent event) {
|
|
|
|
if (!isAdded() || !isVisible() || !isMenuVisible()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
switch (event.getKeyCode()) {
|
|
|
|
case KeyEvent.KEYCODE_T:
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.recyclerView.smoothScrollToPosition(0);
|
2021-12-14 23:02:49 +01:00
|
|
|
break;
|
|
|
|
case KeyEvent.KEYCODE_B:
|
2022-04-22 22:11:12 +02:00
|
|
|
viewBinding.recyclerView.smoothScrollToPosition(adapter.getItemCount() - 1);
|
2021-12-14 23:02:49 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-03-13 10:53:19 +01:00
|
|
|
private class FeedItemListAdapter extends EpisodeItemListAdapter {
|
2020-03-17 00:17:21 +01:00
|
|
|
public FeedItemListAdapter(MainActivity mainActivity) {
|
|
|
|
super(mainActivity);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2020-04-01 20:29:48 +02:00
|
|
|
protected void beforeBindViewHolder(EpisodeItemViewHolder holder, int pos) {
|
|
|
|
holder.coverHolder.setVisibility(View.GONE);
|
2020-03-17 00:17:21 +01:00
|
|
|
}
|
2021-06-29 22:01:04 +02:00
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onCreateContextMenu(ContextMenu menu, View v, ContextMenu.ContextMenuInfo menuInfo) {
|
|
|
|
super.onCreateContextMenu(menu, v, menuInfo);
|
|
|
|
if (!inActionMode()) {
|
|
|
|
menu.findItem(R.id.multi_select).setVisible(true);
|
|
|
|
}
|
2022-03-13 10:53:19 +01:00
|
|
|
MenuItemUtils.setOnClickListeners(menu, FeedItemlistFragment.this::onContextItemSelected);
|
2021-06-29 22:01:04 +02:00
|
|
|
}
|
2020-03-17 00:17:21 +01:00
|
|
|
}
|
2023-12-03 16:36:28 +01:00
|
|
|
|
|
|
|
public static class SingleFeedSortDialog extends ItemSortDialog {
|
|
|
|
private static final String ARG_FEED_ID = "feedId";
|
|
|
|
private static final String ARG_FEED_IS_LOCAL = "isLocal";
|
|
|
|
private static final String ARG_SORT_ORDER = "sortOrder";
|
|
|
|
|
|
|
|
private static SingleFeedSortDialog newInstance(Feed feed) {
|
|
|
|
Bundle bundle = new Bundle();
|
|
|
|
bundle.putLong(ARG_FEED_ID, feed.getId());
|
|
|
|
bundle.putBoolean(ARG_FEED_IS_LOCAL, feed.isLocalFeed());
|
|
|
|
if (feed.getSortOrder() == null) {
|
|
|
|
bundle.putString(ARG_SORT_ORDER, String.valueOf(SortOrder.DATE_NEW_OLD.code));
|
|
|
|
} else {
|
|
|
|
bundle.putString(ARG_SORT_ORDER, String.valueOf(feed.getSortOrder().code));
|
|
|
|
}
|
|
|
|
SingleFeedSortDialog dialog = new SingleFeedSortDialog();
|
|
|
|
dialog.setArguments(bundle);
|
|
|
|
return dialog;
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public void onCreate(@Nullable Bundle savedInstanceState) {
|
|
|
|
super.onCreate(savedInstanceState);
|
|
|
|
sortOrder = SortOrder.fromCodeString(getArguments().getString(ARG_SORT_ORDER));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected void onAddItem(int title, SortOrder ascending, SortOrder descending, boolean ascendingIsDefault) {
|
|
|
|
if (ascending == SortOrder.DATE_OLD_NEW || ascending == SortOrder.DURATION_SHORT_LONG
|
|
|
|
|| ascending == SortOrder.EPISODE_TITLE_A_Z
|
|
|
|
|| (getArguments().getBoolean(ARG_FEED_IS_LOCAL) && ascending == SortOrder.EPISODE_FILENAME_A_Z)) {
|
|
|
|
super.onAddItem(title, ascending, descending, ascendingIsDefault);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
protected void onSelectionChanged() {
|
|
|
|
super.onSelectionChanged();
|
|
|
|
DBWriter.setFeedItemSortOrder(getArguments().getLong(ARG_FEED_ID), sortOrder);
|
|
|
|
}
|
|
|
|
}
|
2021-06-29 22:01:04 +02:00
|
|
|
}
|