diff options
Diffstat (limited to 'org.fox.ttrss/src/main/java/org/fox/ttrss/MasterActivity.java')
-rw-r--r-- | org.fox.ttrss/src/main/java/org/fox/ttrss/MasterActivity.java | 550 |
1 files changed, 550 insertions, 0 deletions
diff --git a/org.fox.ttrss/src/main/java/org/fox/ttrss/MasterActivity.java b/org.fox.ttrss/src/main/java/org/fox/ttrss/MasterActivity.java new file mode 100644 index 00000000..0df1c48f --- /dev/null +++ b/org.fox.ttrss/src/main/java/org/fox/ttrss/MasterActivity.java @@ -0,0 +1,550 @@ +package org.fox.ttrss; + + +import android.annotation.SuppressLint; +import android.app.AlertDialog; +import android.app.Dialog; +import android.content.DialogInterface; +import android.content.Intent; +import android.content.SharedPreferences; +import android.os.Bundle; +import android.preference.PreferenceManager; +import android.support.v4.app.Fragment; +import android.support.v4.app.FragmentTransaction; +import android.support.v4.widget.DrawerLayout; +import android.support.v7.app.ActionBarDrawerToggle; +import android.support.v7.widget.Toolbar; +import android.util.Log; +import android.view.Gravity; +import android.view.MenuItem; +import android.view.View; + +import com.google.gson.JsonElement; + +import org.fox.ttrss.types.Article; +import org.fox.ttrss.types.ArticleList; +import org.fox.ttrss.types.Feed; +import org.fox.ttrss.types.FeedCategory; +import org.fox.ttrss.widget.SmallWidgetProvider; + +import java.util.Date; +import java.util.HashMap; + +public class MasterActivity extends OnlineActivity implements HeadlinesEventListener { + private final String TAG = this.getClass().getSimpleName(); + + private static final int HEADLINES_REQUEST = 1; + + protected SharedPreferences m_prefs; + protected long m_lastRefresh = 0; + + private boolean m_feedIsSelected = false; + private boolean m_userFeedSelected = false; + + private ActionBarDrawerToggle m_drawerToggle; + private DrawerLayout m_drawerLayout; + + @SuppressLint("NewApi") + @Override + public void onCreate(Bundle savedInstanceState) { + m_prefs = PreferenceManager + .getDefaultSharedPreferences(getApplicationContext()); + + setAppTheme(m_prefs); + + super.onCreate(savedInstanceState); + + setContentView(R.layout.activity_master); + + setSmallScreen(findViewById(R.id.sw600dp_anchor) == null); + + Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar); + setSupportActionBar(toolbar); + + Application.getInstance().load(savedInstanceState); + + m_drawerLayout = (DrawerLayout) findViewById(R.id.headlines_drawer); + + if (m_drawerLayout != null) { + + m_drawerToggle = new ActionBarDrawerToggle(this, m_drawerLayout, R.string.blank, R.string.blank) { + @Override + public void onDrawerOpened(View drawerView) { + super.onDrawerOpened(drawerView); + + getSupportActionBar().show(); + invalidateOptionsMenu(); + } + + @Override + public void onDrawerClosed(View drawerView) { + super.onDrawerClosed(drawerView); + + if (m_prefs.getBoolean("drawer_open_on_start", true)) { + SharedPreferences.Editor editor = m_prefs.edit(); + editor.putBoolean("drawer_open_on_start", false); + editor.apply(); + } + + invalidateOptionsMenu(); + } + }; + + m_drawerLayout.setDrawerListener(m_drawerToggle); + m_drawerToggle.setDrawerIndicatorEnabled(true); + + getSupportActionBar().setDisplayHomeAsUpEnabled(true); + getSupportActionBar().setHomeButtonEnabled(true); + } + + if (savedInstanceState == null) { + if (m_drawerLayout != null && m_prefs.getBoolean("drawer_open_on_start", true)) { + m_drawerLayout.openDrawer(Gravity.START); + } + + final Intent i = getIntent(); + boolean shortcutMode = i.getBooleanExtra("shortcut_mode", false); + + Log.d(TAG, "is_shortcut_mode: " + shortcutMode); + + if (shortcutMode) { + LoginRequest lr = new LoginRequest(this, false, new OnLoginFinishedListener() { + + @Override + public void OnLoginSuccess() { + int feedId = i.getIntExtra("feed_id", 0); + boolean isCat = i.getBooleanExtra("feed_is_cat", false); + String feedTitle = i.getStringExtra("feed_title"); + + Feed tmpFeed = new Feed(feedId, feedTitle, isCat); + + onFeedSelected(tmpFeed, false); + } + + @Override + public void OnLoginFailed() { + login(); + } + }); + + HashMap<String, String> map = new HashMap<String, String>() { + { + put("op", "login"); + put("user", m_prefs.getString("login", "").trim()); + put("password", m_prefs.getString("password", "").trim()); + } + }; + + lr.execute(map); + } + + //m_pullToRefreshAttacher.setRefreshing(true); + + FragmentTransaction ft = getSupportFragmentManager().beginTransaction(); + + if (m_prefs.getBoolean("enable_cats", false)) { + ft.replace(R.id.feeds_fragment, new FeedCategoriesFragment(), FRAG_CATS); + } else { + ft.replace(R.id.feeds_fragment, new FeedsFragment(), FRAG_FEEDS); + } + + if (m_prefs.getBoolean("open_fresh_on_startup", true)) { + HeadlinesFragment hf = new HeadlinesFragment(); + hf.initialize(new Feed(-3, getString(R.string.fresh_articles), false)); + + ft.replace(R.id.headlines_fragment, hf, FRAG_HEADLINES); + } else if (m_drawerLayout != null) { + m_drawerLayout.openDrawer(Gravity.START); + } + + ft.commit(); + + m_feedIsSelected = true; + + checkTrial(true); + + } else { // savedInstanceState != null + //m_actionbarUpEnabled = savedInstanceState.getBoolean("actionbarUpEnabled"); + //m_actionbarRevertDepth = savedInstanceState.getInt("actionbarRevertDepth"); + m_feedIsSelected = savedInstanceState.getBoolean("feedIsSelected"); + m_userFeedSelected = savedInstanceState.getBoolean("userFeedSelected"); + //m_feedWasSelected = savedInstanceState.getBoolean("feedWasSelected"); + + /* if (findViewById(R.id.sw600dp_port_anchor) != null && m_feedWasSelected && m_slidingMenu != null) { + m_slidingMenu.setBehindWidth(getScreenWidthInPixel() * 2/3); + } */ + + if (m_drawerLayout != null && m_feedIsSelected == false) { + m_drawerLayout.openDrawer(Gravity.START); + } + + } + + } + + protected void onPostCreate(Bundle savedInstanceState) { + super.onPostCreate(savedInstanceState); + // Sync the toggle state after onRestoreInstanceState has occurred. + if (m_drawerToggle != null) m_drawerToggle.syncState(); + } + + @Override + protected void initMenu() { + super.initMenu(); + + if (m_menu != null && getSessionId() != null) { + Fragment ff = getSupportFragmentManager().findFragmentByTag(FRAG_FEEDS); + Fragment cf = getSupportFragmentManager().findFragmentByTag(FRAG_CATS); + HeadlinesFragment hf = (HeadlinesFragment)getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES); + + /* if (m_drawerLayout != null) { + boolean isDrawerOpen = m_drawerLayout.isDrawerOpen(Gravity.START); + + m_menu.setGroupVisible(R.id.menu_group_feeds, isDrawerOpen); + m_menu.setGroupVisible(R.id.menu_group_headlines, hf != null && hf.isAdded() && !isDrawerOpen); + } else { + m_menu.setGroupVisible(R.id.menu_group_feeds, (ff != null && ff.isAdded()) || (cf != null && cf.isAdded())); + m_menu.setGroupVisible(R.id.menu_group_headlines, hf != null && hf.isAdded()); + + m_menu.findItem(R.id.update_headlines).setVisible(false); + } */ + + m_menu.setGroupVisible(R.id.menu_group_feeds, (ff != null && ff.isAdded()) || (cf != null && cf.isAdded())); + m_menu.setGroupVisible(R.id.menu_group_headlines, hf != null && hf.isAdded()); + + //m_menu.findItem(R.id.headlines_toggle_sidebar).setVisible(false); + + /* MenuItem item = m_menu.findItem(R.id.show_feeds); + + if (getUnreadOnly()) { + item.setTitle(R.string.menu_all_feeds); + } else { + item.setTitle(R.string.menu_unread_feeds); + } */ + } + } + + public void onFeedSelected(Feed feed) { + onFeedSelected(feed, true); + } + + public void onFeedSelected(Feed feed, final boolean selectedByUser) { + + FragmentTransaction ft = getSupportFragmentManager() + .beginTransaction(); + + HeadlinesFragment hf = new HeadlinesFragment(); + hf.initialize(feed); + + ft.replace(R.id.headlines_fragment, hf, FRAG_HEADLINES); + + ft.commit(); + + m_feedIsSelected = true; + m_userFeedSelected = selectedByUser; + //m_feedWasSelected = true; + + if (m_drawerLayout != null) { + m_drawerLayout.closeDrawers(); + } + + Date date = new Date(); + + if (date.getTime() - m_lastRefresh > 10000) { + m_lastRefresh = date.getTime(); + refresh(false); + } + } + + public void onCatSelected(FeedCategory cat, boolean openAsFeed) { + FeedCategoriesFragment fc = (FeedCategoriesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_CATS); + + //m_pullToRefreshAttacher.setRefreshing(true); + + if (!openAsFeed) { + + if (fc != null) { + fc.setSelectedCategory(null); + } + + FragmentTransaction ft = getSupportFragmentManager() + .beginTransaction(); + + FeedsFragment ff = new FeedsFragment(); + ff.initialize(cat, true); + ft.replace(R.id.feeds_fragment, ff, FRAG_FEEDS); + + ft.addToBackStack(null); + ft.commit(); + + //getSupportActionBar().setDisplayHomeAsUpEnabled(true); + //m_actionbarUpEnabled = true; + //m_actionbarRevertDepth = m_actionbarRevertDepth + 1; + + } else { + + if (fc != null) { + fc.setSelectedCategory(cat); + } + + Feed feed = new Feed(cat.id, cat.title, true); + onFeedSelected(feed); + } + } + + public void onCatSelected(FeedCategory cat) { + onCatSelected(cat, m_prefs.getBoolean("browse_cats_like_feeds", false)); + } + + @Override + public void logout() { + super.logout(); + + finish(); + } + + @Override + public boolean onOptionsItemSelected(MenuItem item) { + if (m_drawerToggle != null && m_drawerToggle.onOptionsItemSelected(item)) { + return true; + } + + switch (item.getItemId()) { + case R.id.headlines_toggle_sort_order: + Dialog dialog = new Dialog(this); + + String sortMode = getSortMode(); + + int selectedIndex = 0; + + if (sortMode.equals("feed_dates")) { + selectedIndex = 1; + } else if (sortMode.equals("date_reverse")) { + selectedIndex = 2; + } else if (sortMode.equals("title")) { + selectedIndex = 3; + } + + AlertDialog.Builder builder = new AlertDialog.Builder(this) + .setTitle(getString(R.string.headlines_sort_articles_title)) + .setSingleChoiceItems( + new String[] { + getString(R.string.headlines_sort_default), + getString(R.string.headlines_sort_newest_first), + getString(R.string.headlines_sort_oldest_first), + getString(R.string.headlines_sort_title) + }, + selectedIndex, new DialogInterface.OnClickListener() { + @Override + public void onClick(DialogInterface dialog, + int which) { + switch (which) { + case 0: + setSortMode("default"); + break; + case 1: + setSortMode("feed_dates"); + break; + case 2: + setSortMode("date_reverse"); + break; + case 3: + setSortMode("title"); + break; + } + dialog.cancel(); + + refresh(); + } + }); + + dialog = builder.create(); + dialog.show(); + + return true; + /* case R.id.show_feeds: + setUnreadOnly(!getUnreadOnly()); + invalidateOptionsMenu(); + refresh(); + return true; */ + /*case R.id.update_feeds: + //m_pullToRefreshAttacher.setRefreshing(true); + refresh(); + return true;*/ + default: + Log.d(TAG, "onOptionsItemSelected, unhandled id=" + item.getItemId()); + return super.onOptionsItemSelected(item); + } + } + + @Override + public void onBackPressed() { + if (m_drawerLayout != null && !m_drawerLayout.isDrawerOpen(Gravity.START) && + (getSupportFragmentManager().getBackStackEntryCount() > 0 || m_userFeedSelected)) { + + m_drawerLayout.openDrawer(Gravity.START); + } else { + super.onBackPressed(); + } + } + + @Override + protected void loginSuccess(boolean refresh) { + invalidateOptionsMenu(); + + if (refresh) refresh(); + } + + @Override + public void onSaveInstanceState(Bundle out) { + super.onSaveInstanceState(out); + + out.putBoolean("feedIsSelected", m_feedIsSelected); + out.putBoolean("userFeedSelected", m_userFeedSelected); + + Application.getInstance().save(out); + } + + @Override + public void onResume() { + super.onResume(); + invalidateOptionsMenu(); + } + + @Override + public void onArticleListSelectionChange(ArticleList m_selectedArticles) { + invalidateOptionsMenu(); + } + + /* public void openFeedArticles(Feed feed) { + //Application.getInstance().m_loadedArticles.clear(); + + Intent intent = new Intent(MasterActivity.this, DetailActivity.class); + intent.putExtra("feed", feed); + intent.putExtra("article", (Article)null); + intent.putExtra("searchQuery", (String)null); + + startActivityForResult(intent, HEADLINES_REQUEST); + overridePendingTransition(R.anim.right_slide_in, 0); + } */ + + public void onArticleSelected(Article article, boolean open) { + if (open) { + HeadlinesFragment hf = (HeadlinesFragment)getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES); + + Intent intent = new Intent(MasterActivity.this, DetailActivity.class); + intent.putExtra("feed", hf.getFeed()); + intent.putExtra("article", article); + intent.putExtra("searchQuery", hf.getSearchQuery()); + //intent.putExtra("articles", (Parcelable)hf.getAllArticles()); + Application.getInstance().tmpArticleList = hf.getAllArticles(); + + /* if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { + startActivityForResult(intent, HEADLINES_REQUEST, ActivityOptions.makeSceneTransitionAnimation(this).toBundle()); + } else { + startActivityForResult(intent, HEADLINES_REQUEST); + } */ + + // mysterious crashes somewhere in gl layer (?) on some feeds if we use activitycompat transitions here on LP so welp + startActivityForResult(intent, HEADLINES_REQUEST); + + + } else { + invalidateOptionsMenu(); + + if (article.unread) { + article.unread = false; + saveArticleUnread(article); + } + } + } + + @Override + public void onStop() { + super.onStop(); + + Intent updateWidgetIntent = new Intent(SmallWidgetProvider.ACTION_REQUEST_UPDATE); + sendBroadcast(updateWidgetIntent); + } + + @Override + public void onArticleSelected(Article article) { + onArticleSelected(article, true); + } + + public void catchupFeed(final Feed feed) { + super.catchupFeed(feed); + refresh(); + } + + @Override + public void onHeadlinesLoaded(boolean appended) { + // TODO Auto-generated method stub + + } + + @Override + protected void onActivityResult(int requestCode, int resultCode, Intent data) { + if (requestCode == HEADLINES_REQUEST && data != null) { + //Application.getInstance().m_activeArticle = null; + + //ArrayList<Article> tmp = data.getParcelableArrayListExtra("articles"); + Article article = data.getParcelableExtra("activeArticle"); + ArticleList articles = Application.getInstance().tmpArticleList; + + if (articles != null) { + HeadlinesFragment hf = (HeadlinesFragment)getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES); + + if (hf != null) { + hf.setArticles(articles); + hf.setActiveArticle(article); + } + } + + + } + } + + public void createFeedShortcut(Feed feed) { + final Intent shortcutIntent = new Intent(this, MasterActivity.class); + shortcutIntent.putExtra("feed_id", feed.id); + shortcutIntent.putExtra("feed_is_cat", feed.is_cat); + shortcutIntent.putExtra("feed_title", feed.title); + shortcutIntent.putExtra("shortcut_mode", true); + + Intent intent = new Intent("com.android.launcher.action.INSTALL_SHORTCUT"); + + intent.putExtra(Intent.EXTRA_SHORTCUT_NAME, feed.title); + intent.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent); + intent.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, Intent.ShortcutIconResource.fromContext(this, R.drawable.ic_launcher)); + intent.putExtra("duplicate", false); + + sendBroadcast(intent); + + toast(R.string.shortcut_has_been_placed_on_the_home_screen); + } + + public void createCategoryShortcut(FeedCategory cat) { + createFeedShortcut(new Feed(cat.id, cat.title, true)); + } + + public void unsubscribeFeed(final Feed feed) { + ApiRequest req = new ApiRequest(getApplicationContext()) { + protected void onPostExecute(JsonElement result) { + refresh(); + } + }; + + @SuppressWarnings("serial") + HashMap<String, String> map = new HashMap<String, String>() { + { + put("sid", getSessionId()); + put("op", "unsubscribeFeed"); + put("feed_id", String.valueOf(feed.id)); + } + }; + + req.execute(map); + + } +} |