mirror of https://github.com/TeamNewPipe/NewPipe
571 lines
24 KiB
Java
571 lines
24 KiB
Java
package org.schabi.newpipe.fragments.channel;
|
|
|
|
import android.content.Intent;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.support.annotation.Nullable;
|
|
import android.support.v4.app.Fragment;
|
|
import android.support.v4.content.ContextCompat;
|
|
import android.support.v7.app.ActionBar;
|
|
import android.support.v7.widget.LinearLayoutManager;
|
|
import android.support.v7.widget.RecyclerView;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
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.Button;
|
|
import android.widget.ImageView;
|
|
import android.widget.TextView;
|
|
import android.widget.Toast;
|
|
|
|
import com.jakewharton.rxbinding2.view.RxView;
|
|
|
|
import org.schabi.newpipe.ImageErrorLoadingListener;
|
|
import org.schabi.newpipe.R;
|
|
import org.schabi.newpipe.database.subscription.SubscriptionEntity;
|
|
import org.schabi.newpipe.extractor.InfoItem;
|
|
import org.schabi.newpipe.extractor.channel.ChannelInfo;
|
|
import org.schabi.newpipe.fragments.BaseFragment;
|
|
import org.schabi.newpipe.fragments.SubscriptionService;
|
|
import org.schabi.newpipe.fragments.search.OnScrollBelowItemsListener;
|
|
import org.schabi.newpipe.info_list.InfoItemBuilder;
|
|
import org.schabi.newpipe.info_list.InfoListAdapter;
|
|
import org.schabi.newpipe.util.Constants;
|
|
import org.schabi.newpipe.util.NavigationHelper;
|
|
import org.schabi.newpipe.workers.ChannelExtractorWorker;
|
|
|
|
import java.io.Serializable;
|
|
import java.text.NumberFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
import io.reactivex.Observer;
|
|
import io.reactivex.android.schedulers.AndroidSchedulers;
|
|
import io.reactivex.annotations.NonNull;
|
|
import io.reactivex.disposables.CompositeDisposable;
|
|
import io.reactivex.disposables.Disposable;
|
|
import io.reactivex.functions.Action;
|
|
import io.reactivex.functions.Consumer;
|
|
import io.reactivex.functions.Function;
|
|
import io.reactivex.schedulers.Schedulers;
|
|
|
|
import static org.schabi.newpipe.util.AnimationUtils.animateView;
|
|
|
|
public class ChannelFragment extends BaseFragment implements ChannelExtractorWorker.OnChannelInfoReceive {
|
|
private final String TAG = "ChannelFragment@" + Integer.toHexString(hashCode());
|
|
|
|
private static final String INFO_LIST_KEY = "info_list_key";
|
|
private static final String CHANNEL_INFO_KEY = "channel_info_key";
|
|
private static final String PAGE_NUMBER_KEY = "page_number_key";
|
|
|
|
private static final int BUTTON_DEBOUNCE_INTERVAL = 100;
|
|
|
|
private InfoListAdapter infoListAdapter;
|
|
|
|
private ChannelExtractorWorker currentChannelWorker;
|
|
private ChannelInfo currentChannelInfo;
|
|
private int serviceId = -1;
|
|
private String channelName = "";
|
|
private String channelUrl = "";
|
|
private String feedUrl = "";
|
|
private int pageNumber = 0;
|
|
private boolean hasNextPage = true;
|
|
|
|
private SubscriptionService subscriptionService;
|
|
|
|
private CompositeDisposable disposables;
|
|
private Disposable subscribeButtonMonitor;
|
|
|
|
/*//////////////////////////////////////////////////////////////////////////
|
|
// Views
|
|
//////////////////////////////////////////////////////////////////////////*/
|
|
|
|
private RecyclerView channelVideosList;
|
|
|
|
private View headerRootLayout;
|
|
private ImageView headerChannelBanner;
|
|
private ImageView headerAvatarView;
|
|
private TextView headerTitleView;
|
|
private TextView headerSubscribersTextView;
|
|
private Button headerSubscribeButton;
|
|
|
|
/*////////////////////////////////////////////////////////////////////////*/
|
|
|
|
public ChannelFragment() {
|
|
}
|
|
|
|
public static Fragment getInstance(int serviceId, String channelUrl, String name) {
|
|
ChannelFragment instance = new ChannelFragment();
|
|
instance.setChannel(serviceId, channelUrl, name);
|
|
return instance;
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////////////////
|
|
// Fragment's LifeCycle
|
|
//////////////////////////////////////////////////////////////////////////*/
|
|
|
|
@Override
|
|
public void onCreate(Bundle savedInstanceState) {
|
|
if (DEBUG) Log.d(TAG, "onCreate() called with: savedInstanceState = [" + savedInstanceState + "]");
|
|
super.onCreate(savedInstanceState);
|
|
setHasOptionsMenu(true);
|
|
if (savedInstanceState != null) {
|
|
channelUrl = savedInstanceState.getString(Constants.KEY_URL);
|
|
channelName = savedInstanceState.getString(Constants.KEY_TITLE);
|
|
serviceId = savedInstanceState.getInt(Constants.KEY_SERVICE_ID, -1);
|
|
|
|
pageNumber = savedInstanceState.getInt(PAGE_NUMBER_KEY, 0);
|
|
Serializable serializable = savedInstanceState.getSerializable(CHANNEL_INFO_KEY);
|
|
if (serializable instanceof ChannelInfo) currentChannelInfo = (ChannelInfo) serializable;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
|
|
if (DEBUG) Log.d(TAG, "onCreateView() called with: inflater = [" + inflater + "], container = [" + container + "], savedInstanceState = [" + savedInstanceState + "]");
|
|
return inflater.inflate(R.layout.fragment_channel, container, false);
|
|
}
|
|
|
|
@Override
|
|
public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
|
|
super.onViewCreated(view, savedInstanceState);
|
|
|
|
if (currentChannelInfo == null) loadPage(0);
|
|
else handleChannelInfo(currentChannelInfo, false, false);
|
|
}
|
|
|
|
@Override
|
|
public void onDestroyView() {
|
|
if (DEBUG) Log.d(TAG, "onDestroyView() called");
|
|
headerAvatarView.setImageBitmap(null);
|
|
headerChannelBanner.setImageBitmap(null);
|
|
channelVideosList.removeAllViews();
|
|
|
|
channelVideosList = null;
|
|
headerRootLayout = null;
|
|
headerChannelBanner = null;
|
|
headerAvatarView = null;
|
|
headerTitleView = null;
|
|
headerSubscribersTextView = null;
|
|
headerSubscribeButton = null;
|
|
|
|
if (disposables != null) disposables.dispose();
|
|
if (subscribeButtonMonitor != null) subscribeButtonMonitor.dispose();
|
|
disposables = null;
|
|
subscribeButtonMonitor = null;
|
|
subscriptionService = null;
|
|
|
|
super.onDestroyView();
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
if (DEBUG) Log.d(TAG, "onResume() called");
|
|
super.onResume();
|
|
if (wasLoading.getAndSet(false) && (currentChannelWorker == null || !currentChannelWorker.isRunning())) {
|
|
loadPage(pageNumber);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onStop() {
|
|
if (DEBUG) Log.d(TAG, "onStop() called");
|
|
super.onStop();
|
|
wasLoading.set(currentChannelWorker != null && currentChannelWorker.isRunning());
|
|
if (currentChannelWorker != null && currentChannelWorker.isRunning()) currentChannelWorker.cancel();
|
|
}
|
|
|
|
@Override
|
|
public void onSaveInstanceState(Bundle outState) {
|
|
if (DEBUG) Log.d(TAG, "onSaveInstanceState() called with: outState = [" + outState + "]");
|
|
super.onSaveInstanceState(outState);
|
|
outState.putString(Constants.KEY_URL, channelUrl);
|
|
outState.putString(Constants.KEY_TITLE, channelName);
|
|
outState.putInt(Constants.KEY_SERVICE_ID, serviceId);
|
|
|
|
outState.putSerializable(INFO_LIST_KEY, infoListAdapter.getItemsList());
|
|
outState.putSerializable(CHANNEL_INFO_KEY, currentChannelInfo);
|
|
outState.putInt(PAGE_NUMBER_KEY, pageNumber);
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////////////////
|
|
// Menu
|
|
//////////////////////////////////////////////////////////////////////////*/
|
|
@Override
|
|
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
|
|
if (DEBUG) Log.d(TAG, "onCreateOptionsMenu() called with: menu = [" + menu + "], inflater = [" + inflater + "]");
|
|
super.onCreateOptionsMenu(menu, inflater);
|
|
inflater.inflate(R.menu.menu_channel, menu);
|
|
|
|
ActionBar supportActionBar = activity.getSupportActionBar();
|
|
if (supportActionBar != null) {
|
|
supportActionBar.setDisplayShowTitleEnabled(true);
|
|
supportActionBar.setDisplayHomeAsUpEnabled(true);
|
|
}
|
|
menu.findItem(R.id.menu_item_rss).setVisible( !TextUtils.isEmpty(feedUrl) );
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
if (DEBUG) Log.d(TAG, "onOptionsItemSelected() called with: item = [" + item + "]");
|
|
super.onOptionsItemSelected(item);
|
|
switch (item.getItemId()) {
|
|
case R.id.menu_item_openInBrowser: {
|
|
Intent intent = new Intent();
|
|
intent.setAction(Intent.ACTION_VIEW);
|
|
intent.setData(Uri.parse(channelUrl));
|
|
startActivity(Intent.createChooser(intent, getString(R.string.choose_browser)));
|
|
return true;
|
|
}
|
|
case R.id.menu_item_rss: {
|
|
Intent intent = new Intent();
|
|
intent.setAction(Intent.ACTION_VIEW);
|
|
intent.setData(Uri.parse(currentChannelInfo.feed_url));
|
|
startActivity(intent);
|
|
return true;
|
|
}
|
|
case R.id.menu_item_share: {
|
|
Intent intent = new Intent();
|
|
intent.setAction(Intent.ACTION_SEND);
|
|
intent.putExtra(Intent.EXTRA_TEXT, channelUrl);
|
|
intent.setType("text/plain");
|
|
startActivity(Intent.createChooser(intent, getString(R.string.share_dialog_title)));
|
|
return true;
|
|
}
|
|
default:
|
|
return super.onOptionsItemSelected(item);
|
|
}
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////////////////
|
|
// Init's
|
|
//////////////////////////////////////////////////////////////////////////*/
|
|
|
|
@Override
|
|
protected void initViews(View rootView, Bundle savedInstanceState) {
|
|
super.initViews(rootView, savedInstanceState);
|
|
|
|
channelVideosList = (RecyclerView) rootView.findViewById(R.id.channel_streams_view);
|
|
|
|
channelVideosList.setLayoutManager(new LinearLayoutManager(activity));
|
|
if (infoListAdapter == null) {
|
|
infoListAdapter = new InfoListAdapter(activity);
|
|
if (savedInstanceState != null) {
|
|
//noinspection unchecked
|
|
ArrayList<InfoItem> serializable = (ArrayList<InfoItem>) savedInstanceState.getSerializable(INFO_LIST_KEY);
|
|
infoListAdapter.addInfoItemList(serializable);
|
|
}
|
|
}
|
|
|
|
channelVideosList.setAdapter(infoListAdapter);
|
|
headerRootLayout = activity.getLayoutInflater().inflate(R.layout.channel_header, channelVideosList, false);
|
|
infoListAdapter.setHeader(headerRootLayout);
|
|
infoListAdapter.setFooter(activity.getLayoutInflater().inflate(R.layout.pignate_footer, channelVideosList, false));
|
|
|
|
headerChannelBanner = (ImageView) headerRootLayout.findViewById(R.id.channel_banner_image);
|
|
headerAvatarView = (ImageView) headerRootLayout.findViewById(R.id.channel_avatar_view);
|
|
headerTitleView = (TextView) headerRootLayout.findViewById(R.id.channel_title_view);
|
|
headerSubscribersTextView = (TextView) headerRootLayout.findViewById(R.id.channel_subscriber_view);
|
|
headerSubscribeButton = (Button) headerRootLayout.findViewById(R.id.channel_subscribe_button);
|
|
|
|
disposables = new CompositeDisposable();
|
|
subscriptionService = SubscriptionService.getInstance( getContext() );
|
|
}
|
|
|
|
protected void initListeners() {
|
|
super.initListeners();
|
|
|
|
infoListAdapter.setOnStreamInfoItemSelectedListener(new InfoItemBuilder.OnInfoItemSelectedListener() {
|
|
@Override
|
|
public void selected(int serviceId, String url, String title) {
|
|
if (DEBUG) Log.d(TAG, "selected() called with: serviceId = [" + serviceId + "], url = [" + url + "], title = [" + title + "]");
|
|
NavigationHelper.openVideoDetailFragment(getFragmentManager(), serviceId, url, title);
|
|
}
|
|
});
|
|
|
|
channelVideosList.clearOnScrollListeners();
|
|
channelVideosList.addOnScrollListener(new OnScrollBelowItemsListener() {
|
|
@Override
|
|
public void onScrolledDown(RecyclerView recyclerView) {
|
|
if ((currentChannelWorker == null || !currentChannelWorker.isRunning()) && hasNextPage && !isLoading.get()) {
|
|
pageNumber++;
|
|
loadMoreVideos();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
@Override
|
|
protected void reloadContent() {
|
|
if (DEBUG) Log.d(TAG, "reloadContent() called");
|
|
currentChannelInfo = null;
|
|
infoListAdapter.clearStreamItemList();
|
|
loadPage(0);
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////////////////
|
|
// Channel Subscription
|
|
//////////////////////////////////////////////////////////////////////////*/
|
|
|
|
private void monitorSubscription(final int serviceId,
|
|
final String channelUrl,
|
|
final ChannelInfo info) {
|
|
subscriptionService.subscriptionTable().findAll(serviceId, channelUrl)
|
|
.toObservable()
|
|
.observeOn(AndroidSchedulers.mainThread())
|
|
.subscribe(getSubscribeButtonMonitor(serviceId, channelUrl, info));
|
|
}
|
|
|
|
private Function<Object, Object> mapOnSubscribe(final SubscriptionEntity subscription) {
|
|
return new Function<Object, Object>() {
|
|
@Override
|
|
public Object apply(@NonNull Object o) throws Exception {
|
|
subscriptionService.subscriptionTable().insert( subscription );
|
|
return o;
|
|
}
|
|
};
|
|
}
|
|
|
|
private Function<Object, Object> mapOnUnsubscribe(final SubscriptionEntity subscription) {
|
|
return new Function<Object, Object>() {
|
|
@Override
|
|
public Object apply(@NonNull Object o) throws Exception {
|
|
subscriptionService.subscriptionTable().delete( subscription );
|
|
return o;
|
|
}
|
|
};
|
|
}
|
|
|
|
private Observer<List<SubscriptionEntity>> getSubscribeButtonMonitor(final int serviceId,
|
|
final String channelUrl,
|
|
final ChannelInfo info) {
|
|
return new Observer<List<SubscriptionEntity>>() {
|
|
@Override
|
|
public void onSubscribe(Disposable d) {
|
|
disposables.add( d );
|
|
}
|
|
|
|
@Override
|
|
public void onNext(List<SubscriptionEntity> subscriptionEntities) {
|
|
if (subscribeButtonMonitor != null) subscribeButtonMonitor.dispose();
|
|
|
|
if (subscriptionEntities.isEmpty()) {
|
|
if (DEBUG) Log.d(TAG, "No subscription to this channel!");
|
|
SubscriptionEntity channel = new SubscriptionEntity();
|
|
channel.setServiceId( serviceId );
|
|
channel.setUrl( channelUrl );
|
|
channel.setData(info.channel_name, info.avatar_url, "", info.subscriberCount);
|
|
|
|
subscribeButtonMonitor = monitorSubscribeButton(headerSubscribeButton, mapOnSubscribe(channel));
|
|
|
|
headerSubscribeButton.setText(R.string.subscribe_button_title);
|
|
} else {
|
|
if (DEBUG) Log.d(TAG, "Found subscription to this channel!");
|
|
final SubscriptionEntity subscription = subscriptionEntities.get(0);
|
|
subscribeButtonMonitor = monitorSubscribeButton(headerSubscribeButton, mapOnUnsubscribe(subscription));
|
|
|
|
headerSubscribeButton.setText(R.string.subscribed_button_title);
|
|
}
|
|
|
|
headerSubscribeButton.setVisibility(View.VISIBLE);
|
|
}
|
|
|
|
@Override
|
|
public void onError(Throwable throwable) {
|
|
Log.e(TAG, "Status get failed", throwable);
|
|
headerSubscribeButton.setVisibility(View.INVISIBLE);
|
|
}
|
|
|
|
@Override
|
|
public void onComplete() {}
|
|
};
|
|
}
|
|
|
|
private Disposable monitorSubscribeButton(final Button subscribeButton,
|
|
final Function<Object, Object> action) {
|
|
final Consumer<Object> onNext = new Consumer<Object>() {
|
|
@Override
|
|
public void accept(@NonNull Object o) throws Exception {
|
|
if (DEBUG) Log.d(TAG, "Changed subscription status to this channel!");
|
|
}
|
|
};
|
|
|
|
final Consumer<Throwable> onError = new Consumer<Throwable>() {
|
|
@Override
|
|
public void accept(@NonNull Throwable throwable) throws Exception {
|
|
if (DEBUG) Log.e(TAG, "Subscription Fatal Error: ", throwable.getCause());
|
|
Toast.makeText(getContext(), R.string.subscription_change_failed, Toast.LENGTH_SHORT).show();
|
|
}
|
|
};
|
|
|
|
/* Emit clicks from main thread unto io thread */
|
|
return RxView.clicks(subscribeButton)
|
|
.subscribeOn(AndroidSchedulers.mainThread())
|
|
.observeOn(Schedulers.io())
|
|
.debounce(BUTTON_DEBOUNCE_INTERVAL, TimeUnit.MILLISECONDS) // Ignore rapid clicks
|
|
.map(action)
|
|
.subscribe(onNext, onError);
|
|
}
|
|
|
|
private Disposable updateSubscription(final int serviceId,
|
|
final String channelUrl,
|
|
final ChannelInfo info) {
|
|
final Action onComplete = new Action() {
|
|
@Override
|
|
public void run() throws Exception {
|
|
if (DEBUG) Log.d(TAG, "Updated subscription: " + channelUrl);
|
|
}
|
|
};
|
|
|
|
final Consumer<Throwable> onError = new Consumer<Throwable>() {
|
|
@Override
|
|
public void accept(@NonNull Throwable throwable) throws Exception {
|
|
Log.e(TAG, "Subscription Update Fatal Error: ", throwable);
|
|
Toast.makeText(getContext(), R.string.subscription_update_failed, Toast.LENGTH_SHORT).show();
|
|
}
|
|
};
|
|
|
|
return subscriptionService.updateChannelInfo(serviceId, channelUrl, info)
|
|
.observeOn(AndroidSchedulers.mainThread())
|
|
.subscribe(onComplete, onError);
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////////////////
|
|
// Utils
|
|
//////////////////////////////////////////////////////////////////////////*/
|
|
|
|
private String buildSubscriberString(long count) {
|
|
String out = NumberFormat.getNumberInstance().format(count);
|
|
out += " " + getString(count > 1 ? R.string.subscriber_plural : R.string.subscriber);
|
|
return out;
|
|
}
|
|
|
|
private void loadPage(int page) {
|
|
if (DEBUG) Log.d(TAG, "loadPage() called with: page = [" + page + "]");
|
|
if (currentChannelWorker != null && currentChannelWorker.isRunning()) currentChannelWorker.cancel();
|
|
isLoading.set(true);
|
|
pageNumber = page;
|
|
infoListAdapter.showFooter(false);
|
|
|
|
animateView(loadingProgressBar, true, 200);
|
|
animateView(errorPanel, false, 200);
|
|
|
|
imageLoader.cancelDisplayTask(headerChannelBanner);
|
|
imageLoader.cancelDisplayTask(headerAvatarView);
|
|
|
|
headerSubscribeButton.setVisibility(View.GONE);
|
|
headerSubscribersTextView.setVisibility(View.GONE);
|
|
|
|
headerTitleView.setText(channelName != null ? channelName : "");
|
|
headerChannelBanner.setImageDrawable(ContextCompat.getDrawable(activity, R.drawable.channel_banner));
|
|
headerAvatarView.setImageDrawable(ContextCompat.getDrawable(activity, R.drawable.buddy));
|
|
if (activity.getSupportActionBar() != null) activity.getSupportActionBar().setTitle(channelName != null ? channelName : "");
|
|
|
|
currentChannelWorker = new ChannelExtractorWorker(activity, serviceId, channelUrl, page, false, this);
|
|
currentChannelWorker.start();
|
|
}
|
|
|
|
private void loadMoreVideos() {
|
|
if (DEBUG) Log.d(TAG, "loadMoreVideos() called");
|
|
if (currentChannelWorker != null && currentChannelWorker.isRunning()) currentChannelWorker.cancel();
|
|
isLoading.set(true);
|
|
currentChannelWorker = new ChannelExtractorWorker(activity, serviceId, channelUrl, pageNumber, true, this);
|
|
currentChannelWorker.start();
|
|
}
|
|
|
|
private void setChannel(int serviceId, String channelUrl, String name) {
|
|
this.serviceId = serviceId;
|
|
this.channelUrl = channelUrl;
|
|
this.channelName = name;
|
|
}
|
|
|
|
private void handleChannelInfo(ChannelInfo info, boolean onlyVideos, boolean addVideos) {
|
|
currentChannelInfo = info;
|
|
|
|
animateView(errorPanel, false, 300);
|
|
animateView(channelVideosList, true, 200);
|
|
animateView(loadingProgressBar, false, 200);
|
|
|
|
if (!onlyVideos) {
|
|
feedUrl = info.feed_url;
|
|
if (activity.getSupportActionBar() != null) activity.getSupportActionBar().invalidateOptionsMenu();
|
|
|
|
headerRootLayout.setVisibility(View.VISIBLE);
|
|
//animateView(loadingProgressBar, false, 200, null);
|
|
|
|
if (!TextUtils.isEmpty(info.channel_name)) {
|
|
if (activity.getSupportActionBar() != null) activity.getSupportActionBar().setTitle(info.channel_name);
|
|
headerTitleView.setText(info.channel_name);
|
|
channelName = info.channel_name;
|
|
} else channelName = "";
|
|
|
|
if (!TextUtils.isEmpty(info.banner_url)) {
|
|
imageLoader.displayImage(info.banner_url, headerChannelBanner, displayImageOptions, new ImageErrorLoadingListener(activity, getView(), info.service_id));
|
|
}
|
|
|
|
if (!TextUtils.isEmpty(info.avatar_url)) {
|
|
headerAvatarView.setVisibility(View.VISIBLE);
|
|
imageLoader.displayImage(info.avatar_url, headerAvatarView, displayImageOptions, new ImageErrorLoadingListener(activity, getView(), info.service_id));
|
|
}
|
|
|
|
if (info.subscriberCount != -1) {
|
|
headerSubscribersTextView.setText(buildSubscriberString(info.subscriberCount));
|
|
headerSubscribersTextView.setVisibility(View.VISIBLE);
|
|
} else headerSubscribersTextView.setVisibility(View.GONE);
|
|
|
|
if (disposables != null) disposables.clear();
|
|
if (subscribeButtonMonitor != null) subscribeButtonMonitor.dispose();
|
|
disposables.add( updateSubscription(serviceId, channelUrl, info) );
|
|
monitorSubscription(serviceId, channelUrl, info);
|
|
|
|
infoListAdapter.showFooter(true);
|
|
}
|
|
|
|
hasNextPage = info.hasNextPage;
|
|
if (!hasNextPage) infoListAdapter.showFooter(false);
|
|
|
|
//if (!listRestored) {
|
|
if (addVideos) infoListAdapter.addInfoItemList(info.related_streams);
|
|
//}
|
|
}
|
|
|
|
@Override
|
|
protected void setErrorMessage(String message, boolean showRetryButton) {
|
|
super.setErrorMessage(message, showRetryButton);
|
|
|
|
animateView(channelVideosList, false, 200);
|
|
currentChannelInfo = null;
|
|
}
|
|
|
|
/*//////////////////////////////////////////////////////////////////////////
|
|
// OnChannelInfoReceiveListener
|
|
//////////////////////////////////////////////////////////////////////////*/
|
|
|
|
@Override
|
|
public void onReceive(ChannelInfo info, boolean onlyVideos) {
|
|
if (DEBUG) Log.d(TAG, "onReceive() called with: info = [" + info + "]");
|
|
if (info == null || isRemoving() || !isVisible()) return;
|
|
|
|
handleChannelInfo(info, onlyVideos, true);
|
|
isLoading.set(false);
|
|
}
|
|
|
|
@Override
|
|
public void onError(int messageId) {
|
|
if (DEBUG) Log.d(TAG, "onError() called with: messageId = [" + messageId + "]");
|
|
setErrorMessage(getString(messageId), true);
|
|
}
|
|
|
|
@Override
|
|
public void onUnrecoverableError(Exception exception) {
|
|
if (DEBUG) Log.d(TAG, "onUnrecoverableError() called with: exception = [" + exception + "]");
|
|
activity.finish();
|
|
}
|
|
}
|