summaryrefslogtreecommitdiff
path: root/orgfoxttrss/src/main/java/org/fox/ttrss/OnlineActivity.java
diff options
context:
space:
mode:
Diffstat (limited to 'orgfoxttrss/src/main/java/org/fox/ttrss/OnlineActivity.java')
-rw-r--r--orgfoxttrss/src/main/java/org/fox/ttrss/OnlineActivity.java1765
1 files changed, 1765 insertions, 0 deletions
diff --git a/orgfoxttrss/src/main/java/org/fox/ttrss/OnlineActivity.java b/orgfoxttrss/src/main/java/org/fox/ttrss/OnlineActivity.java
new file mode 100644
index 00000000..e33a02b7
--- /dev/null
+++ b/orgfoxttrss/src/main/java/org/fox/ttrss/OnlineActivity.java
@@ -0,0 +1,1765 @@
+package org.fox.ttrss;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.List;
+
+import org.fox.ttrss.offline.OfflineActivity;
+import org.fox.ttrss.offline.OfflineDownloadService;
+import org.fox.ttrss.offline.OfflineUploadService;
+import org.fox.ttrss.share.SubscribeActivity;
+import org.fox.ttrss.types.Article;
+import org.fox.ttrss.types.ArticleList;
+import org.fox.ttrss.types.Feed;
+import org.fox.ttrss.types.Label;
+import org.fox.ttrss.widget.SmallWidgetProvider;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.select.Elements;
+
+import android.annotation.TargetApi;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.ActivityNotFoundException;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.content.DialogInterface.OnMultiChoiceClickListener;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.support.v7.view.ActionMode;
+import android.util.Log;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.Window;
+import android.widget.EditText;
+import android.widget.SearchView;
+import android.widget.TextView;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.reflect.TypeToken;
+import com.nostra13.universalimageloader.core.ImageLoader;
+import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;
+
+public class OnlineActivity extends CommonActivity {
+ private final String TAG = this.getClass().getSimpleName();
+
+ private final static int TRIAL_DAYS = 8;
+
+ protected SharedPreferences m_prefs;
+ protected Menu m_menu;
+
+ protected int m_offlineModeStatus = 0;
+
+ private ActionMode m_headlinesActionMode;
+ private HeadlinesActionModeCallback m_headlinesActionModeCallback;
+
+ private String m_lastImageHitTestUrl;
+
+ //protected PullToRefreshAttacher m_pullToRefreshAttacher;
+
+ protected abstract class OnLoginFinishedListener {
+ public abstract void OnLoginSuccess();
+ public abstract void OnLoginFailed();
+ };
+
+ private BroadcastReceiver m_broadcastReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context content, Intent intent) {
+
+ if (intent.getAction().equals(OfflineDownloadService.INTENT_ACTION_SUCCESS)) {
+
+ m_offlineModeStatus = 2;
+
+ switchOffline();
+
+ } else if (intent.getAction().equals(OfflineUploadService.INTENT_ACTION_SUCCESS)) {
+ Log.d(TAG, "offline upload service reports success");
+ toast(R.string.offline_sync_success);
+ }
+ }
+ };
+
+
+ @TargetApi(11)
+ private class HeadlinesActionModeCallback implements ActionMode.Callback {
+
+ @Override
+ public boolean onPrepareActionMode(ActionMode mode, Menu menu) {
+ return false;
+ }
+
+ @Override
+ public void onDestroyActionMode(ActionMode mode) {
+ m_headlinesActionMode = null;
+
+ HeadlinesFragment hf = (HeadlinesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES);
+
+ if (hf != null) {
+ ArticleList selected = hf.getSelectedArticles();
+ if (selected.size() > 0) {
+ selected.clear();
+ initMenu();
+ hf.notifyUpdated();
+ }
+ }
+ }
+
+ @Override
+ public boolean onCreateActionMode(ActionMode mode, Menu menu) {
+
+ MenuInflater inflater = getMenuInflater();
+ inflater.inflate(R.menu.headlines_action_menu, menu);
+
+ return true;
+ }
+
+ @Override
+ public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
+ onOptionsItemSelected(item);
+ return false;
+ }
+ };
+
+ protected String getSessionId() {
+ return GlobalState.getInstance().m_sessionId;
+ }
+
+ protected void setSessionId(String sessionId) {
+ GlobalState.getInstance().m_sessionId = sessionId;
+ }
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ ApiRequest.disableConnectionReuseIfNecessary();
+
+ // we use that before parent onCreate so let's init locally
+ m_prefs = PreferenceManager
+ .getDefaultSharedPreferences(getApplicationContext());
+
+ setAppTheme(m_prefs);
+
+ super.onCreate(savedInstanceState);
+
+ if (canUseProgress()) {
+ requestWindowFeature(Window.FEATURE_PROGRESS);
+ }
+
+ //requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
+
+ setProgressBarVisibility(false);
+ setProgressBarIndeterminateVisibility(false);
+
+// SharedPreferences localPrefs = getSharedPreferences("localprefs", Context.MODE_PRIVATE);
+
+ SharedPreferences localPrefs = getSharedPreferences("localprefs", Context.MODE_PRIVATE);
+
+ boolean isOffline = localPrefs.getBoolean("offline_mode_active", false);
+
+ Log.d(TAG, "m_isOffline=" + isOffline);
+
+ setContentView(R.layout.login);
+
+ setStatusBarTint();
+
+ ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(getApplicationContext()).build();
+ ImageLoader.getInstance().init(config);
+ ImageLoader.getInstance().clearDiskCache();
+
+ //m_pullToRefreshAttacher = PullToRefreshAttacher.get(this);
+
+ if (isOffline) {
+ switchOfflineSuccess();
+ } else {
+ checkTrial(false);
+
+ /* if (getIntent().getExtras() != null) {
+ Intent i = getIntent();
+ } */
+
+ if (savedInstanceState != null) {
+ m_offlineModeStatus = savedInstanceState.getInt("offlineModeStatus");
+ }
+
+ m_headlinesActionModeCallback = new HeadlinesActionModeCallback();
+ }
+ }
+
+ protected boolean canUseProgress() {
+ return GlobalState.getInstance().m_canUseProgress;
+ }
+
+ private void switchOffline() {
+ if (m_offlineModeStatus == 2) {
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(
+ OnlineActivity.this)
+ .setMessage(R.string.dialog_offline_success)
+ .setPositiveButton(R.string.dialog_offline_go,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ m_offlineModeStatus = 0;
+
+ SharedPreferences localPrefs = getSharedPreferences("localprefs", Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = localPrefs.edit();
+ editor.putBoolean("offline_mode_active", true);
+ editor.commit();
+
+ Intent offline = new Intent(
+ OnlineActivity.this,
+ OfflineActivity.class);
+ offline.putExtra("initial", true);
+ startActivity(offline);
+ finish();
+ }
+ })
+ .setNegativeButton(R.string.dialog_cancel,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ m_offlineModeStatus = 0;
+
+ }
+ });
+
+ AlertDialog dlg = builder.create();
+ dlg.show();
+
+ } else if (m_offlineModeStatus == 0) {
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(this)
+ .setMessage(R.string.dialog_offline_switch_prompt)
+ .setPositiveButton(R.string.dialog_offline_go,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ if (getSessionId() != null) {
+ Log.d(TAG, "offline: starting");
+
+ m_offlineModeStatus = 1;
+
+ Intent intent = new Intent(
+ OnlineActivity.this,
+ OfflineDownloadService.class);
+ intent.putExtra("sessionId", getSessionId());
+
+ startService(intent);
+ }
+ }
+ })
+ .setNegativeButton(R.string.dialog_cancel,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+ //
+ }
+ });
+
+ AlertDialog dlg = builder.create();
+ dlg.show();
+ } else if (m_offlineModeStatus == 1) {
+ cancelOfflineSync();
+ }
+ }
+
+ private boolean hasPendingOfflineData() {
+ try {
+ Cursor c = getReadableDb().query("articles",
+ new String[] { "COUNT(*)" }, "modified = 1", null, null, null,
+ null);
+ if (c.moveToFirst()) {
+ int modified = c.getInt(0);
+ c.close();
+
+ return modified > 0;
+ }
+ } catch (IllegalStateException e) {
+ // db is closed? ugh
+ }
+
+ return false;
+ }
+
+ private boolean hasOfflineData() {
+ try {
+ Cursor c = getReadableDb().query("articles",
+ new String[] { "COUNT(*)" }, null, null, null, null, null);
+ if (c.moveToFirst()) {
+ int modified = c.getInt(0);
+ c.close();
+
+ return modified > 0;
+ }
+ } catch (IllegalStateException e) {
+ // db is closed?
+ }
+
+ return false;
+ }
+
+ @Override
+ public void onStop() {
+ super.onStop();
+
+ Intent initialUpdateIntent = new Intent(SmallWidgetProvider.FORCE_UPDATE_ACTION);
+ sendBroadcast(initialUpdateIntent);
+ }
+
+ @Override
+ public void onPause() {
+ super.onPause();
+
+ unregisterReceiver(m_broadcastReceiver);
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ }
+
+ private void syncOfflineData() {
+ Log.d(TAG, "offlineSync: starting");
+
+ Intent intent = new Intent(
+ OnlineActivity.this,
+ OfflineUploadService.class);
+
+ intent.putExtra("sessionId", getSessionId());
+
+ startService(intent);
+ }
+
+ private void cancelOfflineSync() {
+ AlertDialog.Builder builder = new AlertDialog.Builder(this)
+ .setMessage(R.string.dialog_offline_sync_in_progress)
+ .setNegativeButton(R.string.dialog_offline_sync_stop,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ if (getSessionId() != null) {
+ Log.d(TAG, "offline: stopping");
+
+ m_offlineModeStatus = 0;
+
+ Intent intent = new Intent(
+ OnlineActivity.this,
+ OfflineDownloadService.class);
+
+ stopService(intent);
+
+ dialog.dismiss();
+
+ restart();
+ }
+ }
+ })
+ .setPositiveButton(R.string.dialog_offline_sync_continue,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ dialog.dismiss();
+
+ restart();
+ }
+ });
+
+ AlertDialog dlg = builder.create();
+ dlg.show();
+ }
+
+ public void restart() {
+ Intent refresh = new Intent(OnlineActivity.this, OnlineActivity.class);
+ startActivity(refresh);
+ finish();
+ }
+
+ private void switchOfflineSuccess() {
+ logout();
+ // setLoadingStatus(R.string.blank, false);
+
+ SharedPreferences.Editor editor = m_prefs.edit();
+ editor.putBoolean("offline_mode_active", true);
+ editor.commit();
+
+ Intent offline = new Intent(OnlineActivity.this, OfflineActivity.class);
+ offline.putExtra("initial", true);
+ offline.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
+
+ startActivityForResult(offline, 0);
+
+ finish();
+
+ }
+
+ public void login() {
+ login(false, null);
+ }
+
+ public void login(boolean refresh) {
+ login(refresh, null);
+ }
+
+ public void login(boolean refresh, OnLoginFinishedListener listener) {
+ if (m_prefs.getString("ttrss_url", "").trim().length() == 0) {
+
+ setLoadingStatus(R.string.login_need_configure, false);
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setMessage(R.string.dialog_need_configure_prompt)
+ .setCancelable(false)
+ .setPositiveButton(R.string.dialog_open_preferences, new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int id) {
+ // launch preferences
+
+ Intent intent = new Intent(OnlineActivity.this,
+ PreferencesActivity.class);
+ startActivityForResult(intent, 0);
+ }
+ })
+ .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
+ public void onClick(DialogInterface dialog, int id) {
+ dialog.cancel();
+ }
+ });
+ AlertDialog alert = builder.create();
+ alert.show();
+
+ } else {
+ setLoadingStatus(R.string.login_in_progress, true);
+
+ LoginRequest ar = new LoginRequest(getApplicationContext(), refresh, listener);
+
+ 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());
+ }
+ };
+
+ ar.execute(map);
+
+ setLoadingStatus(R.string.login_in_progress, true);
+ }
+ }
+
+ protected void loginSuccess(boolean refresh) {
+ setLoadingStatus(R.string.blank, false);
+
+ initMenu();
+
+ Intent intent = new Intent(OnlineActivity.this, FeedsActivity.class);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
+
+ startActivityForResult(intent, 0);
+ overridePendingTransition(0, 0);
+
+ if (hasPendingOfflineData())
+ syncOfflineData();
+
+ finish();
+ }
+
+ public void checkTrial(boolean notify) {
+ boolean isTrial = getPackageManager().checkSignatures(
+ getPackageName(), "org.fox.ttrss.key") != PackageManager.SIGNATURE_MATCH;
+
+ if (isTrial) {
+ long firstStart = m_prefs.getLong("date_firstlaunch_trial", -1);
+
+ if (firstStart == -1) {
+ firstStart = System.currentTimeMillis();
+
+ SharedPreferences.Editor editor = m_prefs.edit();
+ editor.putLong("date_firstlaunch_trial", firstStart);
+ editor.commit();
+ }
+
+ if (!notify && System.currentTimeMillis() > firstStart + (TRIAL_DAYS * 24 * 60 * 60 * 1000)) {
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(this)
+ .setTitle(R.string.trial_expired)
+ .setMessage(R.string.trial_expired_message)
+ .setCancelable(false)
+ .setPositiveButton(getString(R.string.trial_purchase),
+ new OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ openUnlockUrl();
+ finish();
+
+ }
+ })
+ .setNegativeButton(getString(R.string.cancel),
+ new OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ finish();
+
+ }
+ });
+
+ AlertDialog dialog = builder.create();
+ dialog.show();
+
+ } else {
+ long daysLeft = Math.round((firstStart + (TRIAL_DAYS * 24 * 60 * 60 * 1000) - System.currentTimeMillis()) / (24 * 60 * 60 * 1000));
+
+ if (notify) {
+ toast(getString(R.string.trial_mode_prompt, Long.valueOf(daysLeft)));
+ }
+ }
+ } else if (notify) {
+ //toast(R.string.trial_thanks);
+ }
+ }
+
+ private void openUnlockUrl() {
+ try {
+ Intent intent = new Intent(Intent.ACTION_VIEW,
+ Uri.parse("market://details?id=org.fox.ttrss.key"));
+ startActivity(intent);
+ } catch (ActivityNotFoundException ae) {
+ try {
+ Intent intent = new Intent(Intent.ACTION_VIEW,
+ Uri.parse("https://play.google.com/store/apps/details?id=org.fox.ttrss.key"));
+ startActivity(intent);
+ } catch (Exception e) {
+ e.printStackTrace();
+ toast(R.string.error_other_error);
+ }
+ }
+ }
+
+ @Override
+ public boolean onContextItemSelected(android.view.MenuItem item) {
+ /* AdapterContextMenuInfo info = (AdapterContextMenuInfo) item
+ .getMenuInfo(); */
+
+ final ArticlePager ap = (ArticlePager)getSupportFragmentManager().findFragmentByTag(FRAG_ARTICLE);
+
+ switch (item.getItemId()) {
+ case R.id.article_img_open:
+ if (getLastContentImageHitTestUrl() != null) {
+ try {
+ Intent intent = new Intent(Intent.ACTION_VIEW,
+ Uri.parse(getLastContentImageHitTestUrl()));
+ startActivity(intent);
+ } catch (Exception e) {
+ e.printStackTrace();
+ toast(R.string.error_other_error);
+ }
+ }
+ return true;
+ case R.id.article_img_copy:
+ if (getLastContentImageHitTestUrl() != null) {
+ copyToClipboard(getLastContentImageHitTestUrl());
+ }
+ return true;
+ case R.id.article_img_share:
+ if (getLastContentImageHitTestUrl() != null) {
+ Intent intent = new Intent(Intent.ACTION_SEND);
+
+ intent.setType("image/png");
+ intent.putExtra(Intent.EXTRA_SUBJECT, getLastContentImageHitTestUrl());
+ intent.putExtra(Intent.EXTRA_TEXT, getLastContentImageHitTestUrl());
+
+ startActivity(Intent.createChooser(intent, getLastContentImageHitTestUrl()));
+ }
+ return true;
+ case R.id.article_img_view_caption:
+ if (getLastContentImageHitTestUrl() != null) {
+
+ // Android doesn't give us an easy way to access title tags;
+ // we'll use Jsoup on the body text to grab the title text
+ // from the first image tag with this url. This will show
+ // the wrong text if an image is used multiple times.
+ Document doc = Jsoup.parse(ap.getSelectedArticle().content);
+ Elements es = doc.getElementsByAttributeValue("src", getLastContentImageHitTestUrl());
+ if (es.size() > 0){
+ if (es.get(0).hasAttr("title")){
+ Dialog dia = new Dialog(this);
+ if (es.get(0).hasAttr("alt")){
+ dia.setTitle(es.get(0).attr("alt"));
+ } else {
+ dia.setTitle(es.get(0).attr("title"));
+ }
+ TextView titleText = new TextView(this);
+
+ if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN) {
+ titleText.setPaddingRelative(24, 24, 24, 24);
+ } else {
+ titleText.setPadding(24, 24, 24, 24);
+ }
+
+ titleText.setTextSize(16);
+ titleText.setText(es.get(0).attr("title"));
+ dia.setContentView(titleText);
+ dia.show();
+ } else {
+ toast(R.string.no_caption_to_display);
+ }
+ } else {
+ toast(R.string.no_caption_to_display);
+ }
+ }
+ return true;
+ case R.id.article_link_share:
+ if (ap != null && ap.getSelectedArticle() != null) {
+ shareArticle(ap.getSelectedArticle());
+ }
+ return true;
+ case R.id.article_link_copy:
+ Log.d(TAG, "article_link_copy");
+ if (ap != null && ap.getSelectedArticle() != null) {
+ copyToClipboard(ap.getSelectedArticle().link);
+ }
+ return true;
+ default:
+ Log.d(TAG, "onContextItemSelected, unhandled id=" + item.getItemId());
+ return super.onContextItemSelected(item);
+ }
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ final HeadlinesFragment hf = (HeadlinesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES);
+ final ArticlePager ap = (ArticlePager)getSupportFragmentManager().findFragmentByTag(FRAG_ARTICLE);
+
+ switch (item.getItemId()) {
+ /* case android.R.id.home:
+ finish();
+ return true; */
+ case R.id.headlines_toggle_sidebar:
+ if (true && !isSmallScreen()) {
+ View v = findViewById(R.id.headlines_fragment);
+
+ if (v != null) {
+ SharedPreferences.Editor editor = m_prefs.edit();
+ editor.putBoolean("headlines_hide_sidebar", !m_prefs.getBoolean("headlines_hide_sidebar", false));
+ editor.commit();
+
+ v.setVisibility(m_prefs.getBoolean("headlines_hide_sidebar", false) ? View.GONE : View.VISIBLE);
+ }
+ }
+ return true;
+ case R.id.subscribe_to_feed:
+ Intent subscribe = new Intent(OnlineActivity.this, SubscribeActivity.class);
+ startActivityForResult(subscribe, 0);
+ return true;
+ case R.id.toggle_attachments:
+ if (true) {
+ Article article = ap.getSelectedArticle();
+
+ if (article != null && article.attachments != null && article.attachments.size() > 0) {
+ CharSequence[] items = new CharSequence[article.attachments.size()];
+ final CharSequence[] itemUrls = new CharSequence[article.attachments.size()];
+
+ for (int i = 0; i < article.attachments.size(); i++) {
+ items[i] = article.attachments.get(i).title != null ? article.attachments.get(i).content_url :
+ article.attachments.get(i).content_url;
+
+ itemUrls[i] = article.attachments.get(i).content_url;
+ }
+
+ Dialog dialog = new Dialog(OnlineActivity.this);
+ AlertDialog.Builder builder = new AlertDialog.Builder(OnlineActivity.this)
+ .setTitle(R.string.attachments_prompt)
+ .setCancelable(true)
+ .setSingleChoiceItems(items, 0, new OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ //
+ }
+ }).setNeutralButton(R.string.attachment_copy, new OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ int selectedPosition = ((AlertDialog)dialog).getListView().getCheckedItemPosition();
+
+ copyToClipboard((String)itemUrls[selectedPosition]);
+ }
+ }).setPositiveButton(R.string.attachment_view, new OnClickListener() {
+
+ @Override
+ public void onClick(DialogInterface dialog, int id) {
+ int selectedPosition = ((AlertDialog)dialog).getListView().getCheckedItemPosition();
+
+ Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse((String)itemUrls[selectedPosition]));
+ startActivity(browserIntent);
+
+ dialog.cancel();
+ }
+ }).setNegativeButton(R.string.dialog_cancel, new OnClickListener() {
+
+ @Override
+ public void onClick(DialogInterface dialog, int id) {
+ dialog.cancel();
+ }
+ });
+
+ dialog = builder.create();
+ dialog.show();
+ }
+ }
+ return true;
+ case R.id.donate:
+ if (true) {
+ openUnlockUrl();
+ }
+ return true;
+ case R.id.logout:
+ logout();
+ return true;
+ case R.id.login:
+ login();
+ return true;
+ case R.id.go_offline:
+ switchOffline();
+ return true;
+ case R.id.article_set_note:
+ if (ap != null && ap.getSelectedArticle() != null) {
+ editArticleNote(ap.getSelectedArticle());
+ }
+ return true;
+ case R.id.preferences:
+ Intent intent = new Intent(OnlineActivity.this,
+ PreferencesActivity.class);
+ startActivityForResult(intent, 0);
+ return true;
+ case R.id.search:
+ if (hf != null && isCompatMode()) {
+ Dialog dialog = new Dialog(this);
+
+ final EditText edit = new EditText(this);
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(this)
+ .setTitle(R.string.search)
+ .setPositiveButton(getString(R.string.search),
+ new OnClickListener() {
+
+ @Override
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ String query = edit.getText().toString().trim();
+
+ hf.setSearchQuery(query);
+
+ }
+ })
+ .setNegativeButton(getString(R.string.cancel),
+ new OnClickListener() {
+
+ @Override
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ //
+
+ }
+ }).setView(edit);
+
+ dialog = builder.create();
+ dialog.show();
+ }
+ return true;
+ case R.id.headlines_mark_as_read:
+ if (hf != null) {
+
+ int count = hf.getUnreadArticles().size();
+
+ boolean confirm = m_prefs.getBoolean("confirm_headlines_catchup", true);
+
+ if (count > 0) {
+ if (confirm) {
+ AlertDialog.Builder builder = new AlertDialog.Builder(
+ OnlineActivity.this)
+ .setMessage(getString(R.string.mark_num_headlines_as_read, count))
+ .setPositiveButton(R.string.catchup,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ catchupVisibleArticles();
+
+ }
+ })
+ .setNegativeButton(R.string.dialog_cancel,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+
+ }
+ });
+
+ AlertDialog dlg = builder.create();
+ dlg.show();
+ } else {
+ catchupVisibleArticles();
+ }
+ }
+ }
+ return true;
+ case R.id.headlines_view_mode:
+ if (hf != null) {
+ Dialog dialog = new Dialog(this);
+
+ String viewMode = getViewMode();
+
+ //Log.d(TAG, "viewMode:" + getViewMode());
+
+ int selectedIndex = 0;
+
+ if (viewMode.equals("all_articles")) {
+ selectedIndex = 1;
+ } else if (viewMode.equals("marked")) {
+ selectedIndex = 2;
+ } else if (viewMode.equals("published")) {
+ selectedIndex = 3;
+ } else if (viewMode.equals("unread")) {
+ selectedIndex = 4;
+ }
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(this)
+ .setTitle(R.string.headlines_set_view_mode)
+ .setSingleChoiceItems(
+ new String[] {
+ getString(R.string.headlines_adaptive),
+ getString(R.string.headlines_all_articles),
+ getString(R.string.headlines_starred),
+ getString(R.string.headlines_published),
+ getString(R.string.headlines_unread) },
+ selectedIndex, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog,
+ int which) {
+ switch (which) {
+ case 0:
+ setViewMode("adaptive");
+ break;
+ case 1:
+ setViewMode("all_articles");
+ break;
+ case 2:
+ setViewMode("marked");
+ break;
+ case 3:
+ setViewMode("published");
+ break;
+ case 4:
+ setViewMode("unread");
+ break;
+ }
+ dialog.cancel();
+
+ refresh();
+ }
+ });
+
+ dialog = builder.create();
+ dialog.show();
+
+ }
+ return true;
+ case R.id.headlines_select:
+ if (hf != null) {
+ Dialog dialog = new Dialog(this);
+ AlertDialog.Builder builder = new AlertDialog.Builder(this)
+ .setTitle(R.string.headlines_select_dialog)
+ .setSingleChoiceItems(
+ new String[] {
+ getString(R.string.headlines_select_all),
+ getString(R.string.headlines_select_unread),
+ getString(R.string.headlines_select_none) },
+ 0, new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog,
+ int which) {
+ switch (which) {
+ case 0:
+ hf.setSelection(HeadlinesFragment.ArticlesSelection.ALL);
+ break;
+ case 1:
+ hf.setSelection(HeadlinesFragment.ArticlesSelection.UNREAD);
+ break;
+ case 2:
+ hf.setSelection(HeadlinesFragment.ArticlesSelection.NONE);
+ break;
+ }
+ dialog.cancel();
+ initMenu();
+ }
+ });
+
+ dialog = builder.create();
+ dialog.show();
+ }
+ return true;
+ case R.id.share_article:
+ if (ap != null) {
+ shareArticle(ap.getSelectedArticle());
+ }
+ return true;
+ case R.id.toggle_marked:
+ if (ap != null & ap.getSelectedArticle() != null) {
+ Article a = ap.getSelectedArticle();
+ a.marked = !a.marked;
+ saveArticleMarked(a);
+ if (hf != null) hf.notifyUpdated();
+ }
+ return true;
+ /* case R.id.selection_select_none:
+ if (hf != null) {
+ ArticleList selected = hf.getSelectedArticles();
+ if (selected.size() > 0) {
+ selected.clear();
+ initMenu();
+ hf.notifyUpdated();
+ }
+ }
+ return true; */
+ case R.id.selection_toggle_unread:
+ if (hf != null) {
+ ArticleList selected = hf.getSelectedArticles();
+
+ if (selected.size() > 0) {
+ for (Article a : selected)
+ a.unread = !a.unread;
+
+ toggleArticlesUnread(selected);
+ hf.notifyUpdated();
+ initMenu();
+ }
+ }
+ return true;
+ case R.id.selection_toggle_marked:
+ if (hf != null) {
+ ArticleList selected = hf.getSelectedArticles();
+
+ if (selected.size() > 0) {
+ for (Article a : selected)
+ a.marked = !a.marked;
+
+ toggleArticlesMarked(selected);
+ hf.notifyUpdated();
+ initMenu();
+ }
+ }
+ return true;
+ case R.id.selection_toggle_published:
+ if (hf != null) {
+ ArticleList selected = hf.getSelectedArticles();
+
+ if (selected.size() > 0) {
+ for (Article a : selected)
+ a.published = !a.published;
+
+ toggleArticlesPublished(selected);
+ hf.notifyUpdated();
+ initMenu();
+ }
+ }
+ return true;
+ case R.id.toggle_published:
+ if (ap != null && ap.getSelectedArticle() != null) {
+ Article a = ap.getSelectedArticle();
+ a.published = !a.published;
+ saveArticlePublished(a);
+ if (hf != null) hf.notifyUpdated();
+ }
+ return true;
+ case R.id.catchup_above:
+ if (hf != null) {
+ if (ap != null && ap.getSelectedArticle() != null) {
+ Article article = ap.getSelectedArticle();
+
+ ArticleList articles = hf.getAllArticles();
+ ArticleList tmp = new ArticleList();
+ for (Article a : articles) {
+ if (article.id == a.id)
+ break;
+
+ if (a.unread) {
+ a.unread = false;
+ tmp.add(a);
+ }
+ }
+ if (tmp.size() > 0) {
+ toggleArticlesUnread(tmp);
+ hf.notifyUpdated();
+ initMenu();
+ }
+ }
+ }
+ return true;
+ case R.id.set_unread:
+ if (ap != null && ap.getSelectedArticle() != null) {
+ Article a = ap.getSelectedArticle();
+
+ if (a != null) {
+ a.unread = !a.unread;
+ saveArticleUnread(a);
+ }
+
+ if (hf != null) hf.notifyUpdated();
+ }
+ return true;
+ case R.id.set_labels:
+ if (ap != null && ap.getSelectedArticle() != null) {
+ if (getApiLevel() != 7) {
+ editArticleLabels(ap.getSelectedArticle());
+ } else {
+ toast(R.string.server_function_not_available);
+ }
+
+ }
+ return true;
+ case R.id.update_headlines:
+ if (hf != null) {
+ //m_pullToRefreshAttacher.setRefreshing(true);
+ hf.refresh(false, true);
+ }
+ return true;
+ default:
+ Log.d(TAG, "onOptionsItemSelected, unhandled id=" + item.getItemId());
+ return super.onOptionsItemSelected(item);
+ }
+ }
+
+ protected void catchupVisibleArticles() {
+ final HeadlinesFragment hf = (HeadlinesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES);
+
+ if (hf != null) {
+ ArticleList articles = hf.getUnreadArticles();
+
+ for (Article a : articles)
+ a.unread = false;
+
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ protected void onPostExecute(JsonElement result) {
+ if (hf.isAdded()) {
+ hf.refresh(false);
+ }
+ }
+ };
+
+ final String articleIds = articlesToIdString(articles);
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "updateArticle");
+ put("article_ids", articleIds);
+ put("mode", "0");
+ put("field", "2");
+ }
+ };
+ req.execute(map);
+ }
+ }
+
+ public void editArticleNote(final Article article) {
+ String note = "";
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(this);
+ builder.setTitle(article.title);
+ final EditText topicEdit = new EditText(this);
+ topicEdit.setText(note);
+ builder.setView(topicEdit);
+
+ builder.setPositiveButton(R.string.article_set_note, new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ String note = topicEdit.getText().toString().trim();
+
+ saveArticleNote(article, note);
+ article.published = true;
+ article.note = note;
+
+ saveArticlePublished(article);
+
+ HeadlinesFragment hf = (HeadlinesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES);
+ if (hf != null) hf.notifyUpdated();
+ }
+ });
+
+ builder.setNegativeButton(R.string.dialog_cancel, new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog, int which) {
+ //
+ }
+ });
+
+ AlertDialog dialog = builder.create();
+ dialog.show();
+ }
+
+ public void editArticleLabels(Article article) {
+ final int articleId = article.id;
+
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ @Override
+ protected void onPostExecute(JsonElement result) {
+ if (result != null) {
+ Type listType = new TypeToken<List<Label>>() {}.getType();
+ final List<Label> labels = new Gson().fromJson(result, listType);
+
+ CharSequence[] items = new CharSequence[labels.size()];
+ final int[] itemIds = new int[labels.size()];
+ boolean[] checkedItems = new boolean[labels.size()];
+
+ for (int i = 0; i < labels.size(); i++) {
+ items[i] = labels.get(i).caption;
+ itemIds[i] = labels.get(i).id;
+ checkedItems[i] = labels.get(i).checked;
+ }
+
+ Dialog dialog = new Dialog(OnlineActivity.this);
+ AlertDialog.Builder builder = new AlertDialog.Builder(OnlineActivity.this)
+ .setTitle(R.string.article_set_labels)
+ .setMultiChoiceItems(items, checkedItems, new OnMultiChoiceClickListener() {
+
+ @Override
+ public void onClick(DialogInterface dialog, int which, final boolean isChecked) {
+ final int labelId = itemIds[which];
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "setArticleLabel");
+ put("label_id", String.valueOf(labelId));
+ put("article_ids", String.valueOf(articleId));
+ if (isChecked) put("assign", "true");
+ }
+ };
+
+ ApiRequest req = new ApiRequest(m_context);
+ req.execute(map);
+
+ }
+ }).setPositiveButton(R.string.dialog_close, new OnClickListener() {
+
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ dialog.cancel();
+ }
+ });
+
+ dialog = builder.create();
+ dialog.show();
+
+ }
+ }
+ };
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "getLabels");
+ put("article_id", String.valueOf(articleId));
+ }
+ };
+
+ req.execute(map);
+ }
+
+ protected void logout() {
+ setSessionId(null);
+
+ findViewById(R.id.loading_container).setVisibility(View.VISIBLE);
+ setLoadingStatus(R.string.login_ready, false);
+
+ initMenu();
+ }
+
+ protected void loginFailure() {
+ setSessionId(null);
+ initMenu();
+
+ if (hasOfflineData()) {
+
+ AlertDialog.Builder builder = new AlertDialog.Builder(
+ OnlineActivity.this)
+ .setMessage(R.string.dialog_offline_prompt)
+ .setPositiveButton(R.string.dialog_offline_go,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+ switchOfflineSuccess();
+ }
+ })
+ .setNegativeButton(R.string.dialog_cancel,
+ new Dialog.OnClickListener() {
+ public void onClick(DialogInterface dialog,
+ int which) {
+ //
+ }
+ });
+
+ AlertDialog dlg = builder.create();
+ dlg.show();
+ }
+ }
+
+ @Override
+ public void onSaveInstanceState(Bundle out) {
+ super.onSaveInstanceState(out);
+
+ out.putInt("offlineModeStatus", m_offlineModeStatus);
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+
+ ApiRequest.trustAllHosts(m_prefs.getBoolean("ssl_trust_any", false),
+ m_prefs.getBoolean("ssl_trust_any_host", false));
+
+ IntentFilter filter = new IntentFilter();
+ filter.addAction(OfflineDownloadService.INTENT_ACTION_SUCCESS);
+ filter.addAction(OfflineUploadService.INTENT_ACTION_SUCCESS);
+ filter.addCategory(Intent.CATEGORY_DEFAULT);
+
+ registerReceiver(m_broadcastReceiver, filter);
+
+ if (getSessionId() == null) {
+ login();
+ } else {
+ loginSuccess(false);
+ }
+ }
+
+ public Menu getMenu() {
+ return m_menu;
+ }
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ MenuInflater inflater = getMenuInflater();
+ inflater.inflate(R.menu.main_menu, menu);
+
+ m_menu = menu;
+
+ initMenu();
+
+ List<PackageInfo> pkgs = getPackageManager()
+ .getInstalledPackages(0);
+
+ for (PackageInfo p : pkgs) {
+ if ("org.fox.ttrss.key".equals(p.packageName)) {
+ Log.d(TAG, "license apk found");
+ menu.findItem(R.id.donate).setVisible(false);
+ break;
+ }
+ }
+
+ return true;
+ }
+
+ protected int getApiLevel() {
+ return GlobalState.getInstance().m_apiLevel;
+ }
+
+ protected void setApiLevel(int apiLevel) {
+ GlobalState.getInstance().m_apiLevel = apiLevel;
+ }
+
+ @SuppressWarnings({ "unchecked", "serial" })
+ public void saveArticleUnread(final Article article) {
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ protected void onPostExecute(JsonElement result) {
+ //toast(R.string.article_set_unread);
+ initMenu();
+ }
+ };
+
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "updateArticle");
+ put("article_ids", String.valueOf(article.id));
+ put("mode", article.unread ? "1" : "0");
+ put("field", "2");
+ }
+ };
+
+ req.execute(map);
+ }
+
+ public void saveArticleMarked(final Article article) {
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ protected void onPostExecute(JsonElement result) {
+ //toast(article.marked ? R.string.notify_article_marked : R.string.notify_article_unmarked);
+ initMenu();
+ }
+ };
+
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "updateArticle");
+ put("article_ids", String.valueOf(article.id));
+ put("mode", article.marked ? "1" : "0");
+ put("field", "0");
+ }
+ };
+
+ req.execute(map);
+ }
+
+ @SuppressWarnings({ "unchecked", "serial" })
+ public void saveArticlePublished(final Article article) {
+
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ protected void onPostExecute(JsonElement result) {
+ //toast(article.published ? R.string.notify_article_published : R.string.notify_article_unpublished);
+ initMenu();
+ }
+ };
+
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "updateArticle");
+ put("article_ids", String.valueOf(article.id));
+ put("mode", article.published ? "1" : "0");
+ put("field", "1");
+ }
+ };
+
+ req.execute(map);
+ }
+
+ @SuppressWarnings({ "unchecked", "serial" })
+ public void saveArticleNote(final Article article, final String note) {
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ protected void onPostExecute(JsonElement result) {
+ toast(R.string.notify_article_note_set);
+ }
+ };
+
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "updateArticle");
+ put("article_ids", String.valueOf(article.id));
+ put("mode", "1");
+ put("data", note);
+ put("field", "3");
+ }
+ };
+
+ req.execute(map);
+ }
+
+ public static String articlesToIdString(ArticleList articles) {
+ String tmp = "";
+
+ for (Article a : articles)
+ tmp += String.valueOf(a.id) + ",";
+
+ return tmp.replaceAll(",$", "");
+ }
+
+ public void shareText(String text) {
+
+ Intent intent = new Intent(Intent.ACTION_SEND);
+
+ intent.setType("text/plain");
+ intent.putExtra(Intent.EXTRA_TEXT, text);
+
+ startActivity(Intent.createChooser(intent, text));
+ }
+
+ public void shareArticle(Article article) {
+ if (article != null) {
+
+ Intent intent = getShareIntent(article);
+
+ startActivity(Intent.createChooser(intent,
+ getString(R.string.share_article)));
+ }
+ }
+
+ protected Intent getShareIntent(Article article) {
+ Intent intent = new Intent(Intent.ACTION_SEND);
+
+ intent.setType("text/plain");
+ intent.putExtra(Intent.EXTRA_SUBJECT, article.title);
+ intent.putExtra(Intent.EXTRA_TEXT, article.link);
+
+ return intent;
+ }
+
+ @Override
+ public boolean onKeyDown(int keyCode, KeyEvent event) {
+ if (m_prefs.getBoolean("use_volume_keys", false)) {
+ ArticlePager ap = (ArticlePager) getSupportFragmentManager().findFragmentByTag(FRAG_ARTICLE);
+
+ if (ap != null && ap.isAdded()) {
+ switch (keyCode) {
+ case KeyEvent.KEYCODE_VOLUME_UP:
+ ap.selectArticle(false);
+ return true;
+ case KeyEvent.KEYCODE_VOLUME_DOWN:
+ ap.selectArticle(true);
+ return true;
+ }
+ }
+ }
+
+ return super.onKeyDown(keyCode, event);
+ }
+
+ // Handle onKeyUp too to suppress beep
+ @Override
+ public boolean onKeyUp(int keyCode, KeyEvent event) {
+ if (m_prefs.getBoolean("use_volume_keys", false)) {
+
+ switch (keyCode) {
+ case KeyEvent.KEYCODE_VOLUME_UP:
+ case KeyEvent.KEYCODE_VOLUME_DOWN:
+ return true;
+ }
+ }
+
+ return super.onKeyUp(keyCode, event);
+ }
+
+ public void catchupFeed(final Feed feed) {
+ Log.d(TAG, "catchupFeed=" + 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", "catchupFeed");
+ put("feed_id", String.valueOf(feed.id));
+ if (feed.is_cat)
+ put("is_cat", "1");
+ }
+ };
+
+ req.execute(map);
+ }
+
+ public void toggleArticlesMarked(final ArticleList articles) {
+ ApiRequest req = new ApiRequest(getApplicationContext());
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "updateArticle");
+ put("article_ids", articlesToIdString(articles));
+ put("mode", "2");
+ put("field", "0");
+ }
+ };
+
+ req.execute(map);
+ }
+
+ public void toggleArticlesUnread(final ArticleList articles) {
+ ApiRequest req = new ApiRequest(getApplicationContext());
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "updateArticle");
+ put("article_ids", articlesToIdString(articles));
+ put("mode", "2");
+ put("field", "2");
+ }
+ };
+
+ req.execute(map);
+ //refresh();
+ }
+
+ public void toggleArticlesPublished(final ArticleList articles) {
+ ApiRequest req = new ApiRequest(getApplicationContext());
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "updateArticle");
+ put("article_ids", articlesToIdString(articles));
+ put("mode", "2");
+ put("field", "1");
+ }
+ };
+
+ req.execute(map);
+ }
+
+
+ protected void initMenu() {
+ if (m_menu != null) {
+ if (getSessionId() != null) {
+ m_menu.setGroupVisible(R.id.menu_group_logged_in, true);
+ m_menu.setGroupVisible(R.id.menu_group_logged_out, false);
+ } else {
+ m_menu.setGroupVisible(R.id.menu_group_logged_in, false);
+ m_menu.setGroupVisible(R.id.menu_group_logged_out, true);
+ }
+
+ m_menu.setGroupVisible(R.id.menu_group_headlines, false);
+ m_menu.setGroupVisible(R.id.menu_group_article, false);
+ m_menu.setGroupVisible(R.id.menu_group_feeds, false);
+
+ m_menu.findItem(R.id.set_labels).setEnabled(getApiLevel() >= 1);
+ m_menu.findItem(R.id.article_set_note).setEnabled(getApiLevel() >= 1);
+ m_menu.findItem(R.id.subscribe_to_feed).setEnabled(getApiLevel() >= 5);
+
+ MenuItem search = m_menu.findItem(R.id.search);
+ search.setEnabled(getApiLevel() >= 2);
+
+ ArticlePager ap = (ArticlePager) getSupportFragmentManager().findFragmentByTag(FRAG_ARTICLE);
+
+ if (ap != null) {
+ Article article = ap.getSelectedArticle();
+
+ if (article != null) {
+ m_menu.findItem(R.id.toggle_marked).setIcon(article.marked ? R.drawable.ic_important_light :
+ R.drawable.ic_unimportant_light);
+
+ m_menu.findItem(R.id.toggle_published).setIcon(article.published ? R.drawable.ic_menu_published_light :
+ R.drawable.ic_menu_unpublished_light);
+
+ m_menu.findItem(R.id.set_unread).setIcon(article.unread ? R.drawable.ic_unread_light :
+ R.drawable.ic_read_light);
+ }
+ }
+
+ HeadlinesFragment hf = (HeadlinesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES);
+
+ if (hf != null) {
+ if (hf.getSelectedArticles().size() > 0 && m_headlinesActionMode == null) {
+ m_headlinesActionMode = startSupportActionMode(m_headlinesActionModeCallback);
+ } else if (hf.getSelectedArticles().size() == 0 && m_headlinesActionMode != null) {
+ m_headlinesActionMode.finish();
+ }
+ }
+
+ if (!isCompatMode()) {
+ SearchView searchView = (SearchView) search.getActionView();
+
+ if (searchView != null) {
+ searchView.setOnQueryTextListener(new SearchView.OnQueryTextListener() {
+ private String query = "";
+
+ @Override
+ public boolean onQueryTextSubmit(String query) {
+ HeadlinesFragment frag = (HeadlinesFragment) getSupportFragmentManager()
+ .findFragmentByTag(FRAG_HEADLINES);
+
+ if (frag != null) {
+ frag.setSearchQuery(query);
+ this.query = query;
+ }
+
+ return false;
+ }
+
+ @Override
+ public boolean onQueryTextChange(String newText) {
+ if (newText.equals("") && !newText.equals(this.query)) {
+ HeadlinesFragment frag = (HeadlinesFragment) getSupportFragmentManager()
+ .findFragmentByTag(FRAG_HEADLINES);
+
+ if (frag != null) {
+ frag.setSearchQuery(newText);
+ this.query = newText;
+ }
+ }
+
+ return false;
+ }
+ });
+ }
+ }
+ }
+ }
+
+ protected void refresh(boolean includeHeadlines) {
+ FeedCategoriesFragment cf = (FeedCategoriesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_CATS);
+
+ if (cf != null) {
+ cf.refresh(false);
+ }
+
+ FeedsFragment ff = (FeedsFragment) getSupportFragmentManager().findFragmentByTag(FRAG_FEEDS);
+
+ if (ff != null) {
+ ff.refresh(false);
+ }
+
+ if (includeHeadlines) {
+ HeadlinesFragment hf = (HeadlinesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES);
+
+ if (hf != null) {
+ hf.refresh(false);
+ }
+
+ ArticlePager af = (ArticlePager) getSupportFragmentManager().findFragmentByTag(FRAG_ARTICLE);
+
+ if (af != null) {
+ af.refresh(false);
+ }
+ }
+ }
+
+ protected void refresh() {
+ refresh(true);
+ }
+
+ protected class LoginRequest extends ApiRequest {
+ boolean m_refreshAfterLogin = false;
+ OnLoginFinishedListener m_listener;
+
+ public LoginRequest(Context context, boolean refresh, OnLoginFinishedListener listener) {
+ super(context);
+ m_refreshAfterLogin = refresh;
+ m_listener = listener;
+ }
+
+ @SuppressWarnings("unchecked")
+ protected void onPostExecute(JsonElement result) {
+ if (result != null) {
+ try {
+ JsonObject content = result.getAsJsonObject();
+
+ if (content != null) {
+ setSessionId(content.get("session_id").getAsString());
+
+ JsonElement apiLevel = content.get("api_level");
+
+ GlobalState.getInstance().m_canUseProgress = m_canUseProgress;
+
+ Log.d(TAG, "Authenticated! canUseProgress=" + m_canUseProgress);
+
+ if (apiLevel != null) {
+ setApiLevel(apiLevel.getAsInt());
+ Log.d(TAG, "Received API level: " + getApiLevel());
+
+ if (m_listener != null) {
+ m_listener.OnLoginSuccess();
+ } else {
+ loginSuccess(m_refreshAfterLogin);
+ }
+
+ } else {
+
+ ApiRequest req = new ApiRequest(m_context) {
+ protected void onPostExecute(JsonElement result) {
+ setApiLevel(0);
+
+ if (result != null) {
+ try {
+ setApiLevel(result.getAsJsonObject().get("level").getAsInt());
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ } else if (m_lastError != ApiError.API_UNKNOWN_METHOD) {
+ // Unknown method means old tt-rss, in that case we assume API 0 and continue
+
+ setLoadingStatus(getErrorMessage(), false);
+
+ if (m_listener != null) {
+ m_listener.OnLoginFailed();
+ } else {
+ loginFailure();
+ }
+
+ return;
+ }
+
+ Log.d(TAG, "Received API level: " + getApiLevel());
+
+ loginSuccess(m_refreshAfterLogin);
+
+ return;
+ }
+ };
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", getSessionId());
+ put("op", "getApiLevel");
+ }
+ };
+
+ req.execute(map);
+
+ setLoadingStatus(R.string.loading_message, true);
+ }
+
+ return;
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ setSessionId(null);
+ setLoadingStatus(getErrorMessage(), false);
+
+ loginFailure();
+ }
+
+ }
+
+ public void setViewMode(String viewMode) {
+ SharedPreferences.Editor editor = m_prefs.edit();
+ editor.putString("view_mode", viewMode);
+ editor.commit();
+ }
+
+ public String getViewMode() {
+ return m_prefs.getString("view_mode", "adaptive");
+ }
+
+ public void setLastContentImageHitTestUrl(String url) {
+ m_lastImageHitTestUrl = url;
+ }
+
+ public String getLastContentImageHitTestUrl() {
+ return m_lastImageHitTestUrl;
+ }
+
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-29 00:49:41 +0000