diff options
Diffstat (limited to 'src')
18 files changed, 3339 insertions, 37 deletions
diff --git a/src/org/fox/ttrss/ArticleEventListener.java b/src/org/fox/ttrss/ArticleEventListener.java deleted file mode 100644 index 688c10f1..00000000 --- a/src/org/fox/ttrss/ArticleEventListener.java +++ /dev/null @@ -1,9 +0,0 @@ -package org.fox.ttrss;
-
-public interface ArticleEventListener {
-
- void copyToClipboard(String content_url);
-
- boolean isSmallScreen();
-
-}
diff --git a/src/org/fox/ttrss/ArticleFragment.java b/src/org/fox/ttrss/ArticleFragment.java index 586fb10b..10b87c25 100644 --- a/src/org/fox/ttrss/ArticleFragment.java +++ b/src/org/fox/ttrss/ArticleFragment.java @@ -47,7 +47,7 @@ public class ArticleFragment extends Fragment { private SharedPreferences m_prefs;
private Article m_article;
- private ArticleEventListener m_onlineServices;
+ private OnlineActivity m_activity;
//private Article m_nextArticle;
//private Article m_prevArticle;
@@ -251,7 +251,7 @@ public class ArticleFragment extends Fragment { Attachment attachment = (Attachment) spinner.getSelectedItem();
if (attachment != null) {
- m_onlineServices.copyToClipboard(attachment.content_url);
+ m_activity.copyToClipboard(attachment.content_url);
}
}
});
@@ -268,7 +268,7 @@ public class ArticleFragment extends Fragment { e.printStackTrace();
}
- if (m_onlineServices.isSmallScreen())
+ if (m_activity.isSmallScreen())
web.setOnTouchListener(m_gestureListener);
}
@@ -321,7 +321,7 @@ public class ArticleFragment extends Fragment { super.onAttach(activity);
m_prefs = PreferenceManager.getDefaultSharedPreferences(getActivity().getApplicationContext());
- m_onlineServices = (ArticleEventListener)activity;
+ m_activity = (OnlineActivity)activity;
//m_article = m_onlineServices.getSelectedArticle();
}
diff --git a/src/org/fox/ttrss/FeedsActivity.java b/src/org/fox/ttrss/FeedsActivity.java index 72ca5bff..a03f6270 100644 --- a/src/org/fox/ttrss/FeedsActivity.java +++ b/src/org/fox/ttrss/FeedsActivity.java @@ -21,7 +21,7 @@ import android.view.View; import android.view.Window;
import android.widget.ShareActionProvider;
-public class FeedsActivity extends OnlineActivity implements HeadlinesEventListener, ArticleEventListener {
+public class FeedsActivity extends OnlineActivity implements HeadlinesEventListener {
private final String TAG = this.getClass().getSimpleName();
protected SharedPreferences m_prefs;
diff --git a/src/org/fox/ttrss/FeedsEventListener.java b/src/org/fox/ttrss/FeedsEventListener.java deleted file mode 100644 index 8e6b7bce..00000000 --- a/src/org/fox/ttrss/FeedsEventListener.java +++ /dev/null @@ -1,5 +0,0 @@ -package org.fox.ttrss;
-
-public interface FeedsEventListener {
-
-}
diff --git a/src/org/fox/ttrss/HeadlinesActivity.java b/src/org/fox/ttrss/HeadlinesActivity.java index 2d7a6a3a..b4672f6a 100644 --- a/src/org/fox/ttrss/HeadlinesActivity.java +++ b/src/org/fox/ttrss/HeadlinesActivity.java @@ -18,7 +18,7 @@ import android.view.MenuInflater; import android.view.MenuItem;
import android.view.View;
-public class HeadlinesActivity extends OnlineActivity implements HeadlinesEventListener, ArticleEventListener {
+public class HeadlinesActivity extends OnlineActivity implements HeadlinesEventListener {
private final String TAG = this.getClass().getSimpleName();
protected SharedPreferences m_prefs;
diff --git a/src/org/fox/ttrss/OnlineActivity.java b/src/org/fox/ttrss/OnlineActivity.java index b91a398a..6c65c43b 100644 --- a/src/org/fox/ttrss/OnlineActivity.java +++ b/src/org/fox/ttrss/OnlineActivity.java @@ -4,6 +4,9 @@ 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.types.Article;
import org.fox.ttrss.types.ArticleList;
import org.fox.ttrss.types.Feed;
@@ -16,12 +19,15 @@ import com.google.gson.reflect.TypeToken; import android.app.AlertDialog;
import android.app.Dialog;
+import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
+import android.content.IntentFilter;
import android.content.SharedPreferences;
import android.content.DialogInterface.OnClickListener;
import android.content.DialogInterface.OnMultiChoiceClickListener;
+import android.database.Cursor;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.support.v4.app.FragmentTransaction;
@@ -46,10 +52,29 @@ public class OnlineActivity extends CommonActivity { protected boolean m_unreadOnly = true;
protected boolean m_unreadArticlesOnly = true;
+ protected int m_offlineModeStatus = 0;
private ActionMode m_headlinesActionMode;
private HeadlinesActionModeCallback m_headlinesActionModeCallback;
+ 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);
+ }
+ }
+ };
+
+
private class HeadlinesActionModeCallback implements ActionMode.Callback {
@Override
@@ -106,31 +131,246 @@ public class OnlineActivity extends CommonActivity { setProgressBarIndeterminateVisibility(false);
- if (getIntent().getExtras() != null) {
- Intent i = getIntent();
-
- m_sessionId = i.getStringExtra("sessionId");
- m_apiLevel = i.getIntExtra("apiLevel", -1);
- }
+// SharedPreferences localPrefs = getSharedPreferences("localprefs", Context.MODE_PRIVATE);
+
+ SharedPreferences localPrefs = getSharedPreferences("localprefs", Context.MODE_PRIVATE);
- if (savedInstanceState != null) {
- m_sessionId = savedInstanceState.getString("sessionId");
- m_apiLevel = savedInstanceState.getInt("apiLevel");
+ boolean isOffline = localPrefs.getBoolean("offline_mode_active", false);
+
+ Log.d(TAG, "m_isOffline=" + isOffline);
+
+ setContentView(R.layout.online);
+
+ if (isOffline) {
+ switchOfflineSuccess();
+ } else {
+
+ if (getIntent().getExtras() != null) {
+ Intent i = getIntent();
+
+ m_sessionId = i.getStringExtra("sessionId");
+ m_apiLevel = i.getIntExtra("apiLevel", -1);
+ }
- m_unreadOnly = savedInstanceState.getBoolean("unreadOnly");
- m_unreadArticlesOnly = savedInstanceState.getBoolean("unreadArticlesOnly");
+ if (savedInstanceState != null) {
+ m_sessionId = savedInstanceState.getString("sessionId");
+ m_apiLevel = savedInstanceState.getInt("apiLevel");
+ m_unreadOnly = savedInstanceState.getBoolean("unreadOnly");
+ m_unreadArticlesOnly = savedInstanceState.getBoolean("unreadArticlesOnly");
+ m_offlineModeStatus = savedInstanceState.getInt("offlineModeStatus");
+ }
+
+ if (!isCompatMode()) {
+ m_headlinesActionModeCallback = new HeadlinesActionModeCallback();
+ }
+
+ Log.d(TAG, "m_sessionId=" + m_sessionId);
+ Log.d(TAG, "m_apiLevel=" + m_apiLevel);
}
+ }
+
+ 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) {
- if (!isCompatMode()) {
- m_headlinesActionModeCallback = new HeadlinesActionModeCallback();
+ 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 (m_sessionId != null) {
+ Log.d(TAG, "offline: starting");
+
+ m_offlineModeStatus = 1;
+
+ Intent intent = new Intent(
+ OnlineActivity.this,
+ OfflineDownloadService.class);
+ intent.putExtra("sessionId", m_sessionId);
+
+ 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 onPause() {
+ super.onPause();
+
+ unregisterReceiver(m_broadcastReceiver);
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ }
+
+ private void syncOfflineData() {
+ Log.d(TAG, "offlineSync: starting");
- Log.d(TAG, "m_sessionId=" + m_sessionId);
- Log.d(TAG, "m_apiLevel=" + m_apiLevel);
+ Intent intent = new Intent(
+ OnlineActivity.this,
+ OfflineUploadService.class);
- setContentView(R.layout.online);
+ intent.putExtra("sessionId", m_sessionId);
+
+ 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 (m_sessionId != 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);
+ refresh.putExtra("sessionId", m_sessionId);
+ refresh.putExtra("apiLevel", m_apiLevel);
+ 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() {
if (m_prefs.getString("ttrss_url", "").trim().length() == 0) {
@@ -186,6 +426,9 @@ public class OnlineActivity extends CommonActivity { intent.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
startActivityForResult(intent, 0);
+
+ if (hasPendingOfflineData())
+ syncOfflineData();
finish();
}
@@ -203,7 +446,7 @@ public class OnlineActivity extends CommonActivity { login();
return true;
case R.id.go_offline:
- // FIXME go offline
+ switchOffline();
return true;
case R.id.article_set_note:
if (ap != null && ap.getSelectedArticle() != null) {
@@ -538,6 +781,30 @@ public class OnlineActivity extends CommonActivity { protected void loginFailure() {
m_sessionId = 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();
+ }
}
public boolean getUnreadArticlesOnly() {
@@ -556,12 +823,20 @@ public class OnlineActivity extends CommonActivity { out.putInt("apiLevel", m_apiLevel);
out.putBoolean("unreadOnly", m_unreadOnly);
out.putBoolean("unreadArticlesOnly", m_unreadArticlesOnly);
+ out.putInt("offlineModeStatus", m_offlineModeStatus);
}
@Override
public void onResume() {
super.onResume();
+ 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 (m_sessionId == null) {
login();
} else {
diff --git a/src/org/fox/ttrss/offline/OfflineActivity.java b/src/org/fox/ttrss/offline/OfflineActivity.java new file mode 100644 index 00000000..7fb8c1a9 --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineActivity.java @@ -0,0 +1,192 @@ +package org.fox.ttrss.offline;
+
+import org.fox.ttrss.CommonActivity;
+import org.fox.ttrss.R;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.provider.BaseColumns;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+
+public class OfflineActivity extends CommonActivity {
+ private final String TAG = this.getClass().getSimpleName();
+
+ protected SharedPreferences m_prefs;
+ protected Menu m_menu;
+ protected boolean m_unreadOnly;
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ m_prefs = PreferenceManager
+ .getDefaultSharedPreferences(getApplicationContext());
+
+ if (m_prefs.getString("theme", "THEME_DARK").equals("THEME_DARK")) {
+ setTheme(R.style.DarkTheme);
+ } else {
+ setTheme(R.style.LightTheme);
+ }
+
+ super.onCreate(savedInstanceState);
+
+ setContentView(R.layout.online);
+
+ setLoadingStatus(R.string.blank, false);
+ findViewById(R.id.loading_container).setVisibility(View.GONE);
+
+ initMenu();
+
+ Intent intent = getIntent();
+
+ if (intent.getExtras() != null) {
+ if (intent.getBooleanExtra("initial", false)) {
+ intent = new Intent(OfflineActivity.this, OfflineFeedsActivity.class);
+ intent.setFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
+
+ startActivityForResult(intent, 0);
+ finish();
+ }
+ }
+
+ if (savedInstanceState != null) {
+ m_unreadOnly = savedInstanceState.getBoolean("unreadOnly");
+ }
+ }
+
+ @Override
+ public void onSaveInstanceState(Bundle out) {
+ super.onSaveInstanceState(out);
+
+ out.putBoolean("unreadOnly", m_unreadOnly);
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ switch (item.getItemId()) {
+ case R.id.go_online:
+ switchOnline();
+ return true;
+ default:
+ Log.d(TAG, "onOptionsItemSelected, unhandled id=" + item.getItemId());
+ return super.onOptionsItemSelected(item);
+ }
+ }
+
+
+ @Override
+ public boolean onCreateOptionsMenu(Menu menu) {
+ MenuInflater inflater = getMenuInflater();
+ inflater.inflate(R.menu.offline_menu, menu);
+
+ m_menu = menu;
+
+ initMenu();
+
+ return true;
+ }
+
+ public boolean getUnreadOnly() {
+ return m_unreadOnly;
+ }
+
+ protected void initMenu() {
+ if (m_menu != null) {
+ m_menu.setGroupVisible(R.id.menu_group_headlines, false);
+ m_menu.setGroupVisible(R.id.menu_group_headlines_selection, false);
+ m_menu.setGroupVisible(R.id.menu_group_article, false);
+ m_menu.setGroupVisible(R.id.menu_group_feeds, false);
+ }
+ }
+
+ private void switchOnline() {
+ SharedPreferences localPrefs = getSharedPreferences("localprefs", Context.MODE_PRIVATE);
+ SharedPreferences.Editor editor = localPrefs.edit();
+ editor.putBoolean("offline_mode_active", false);
+ editor.commit();
+
+ Intent refresh = new Intent(this, org.fox.ttrss.OnlineActivity.class);
+ startActivity(refresh);
+ finish();
+ }
+
+ protected Cursor getArticleById(int articleId) {
+ Cursor c = getReadableDb().query("articles", null,
+ BaseColumns._ID + "=?",
+ new String[] { String.valueOf(articleId) }, null, null, null);
+
+ c.moveToFirst();
+
+ return c;
+ }
+
+ protected Cursor getFeedById(int feedId) {
+ Cursor c = getReadableDb().query("feeds", null,
+ BaseColumns._ID + "=?",
+ new String[] { String.valueOf(feedId) }, null, null, null);
+
+ c.moveToFirst();
+
+ return c;
+ }
+
+ protected Cursor getCatById(int catId) {
+ Cursor c = getReadableDb().query("categories", null,
+ BaseColumns._ID + "=?",
+ new String[] { String.valueOf(catId) }, null, null, null);
+
+ c.moveToFirst();
+
+ return c;
+ }
+
+ protected Intent getShareIntent(Cursor article) {
+ String title = article.getString(article.getColumnIndex("title"));
+ String link = article.getString(article.getColumnIndex("link"));
+
+ Intent intent = new Intent(Intent.ACTION_SEND);
+
+ intent.setType("text/plain");
+ intent.putExtra(Intent.EXTRA_SUBJECT, title);
+ intent.putExtra(Intent.EXTRA_TEXT, link);
+
+ return intent;
+ }
+
+ protected void shareArticle(int articleId) {
+
+ Cursor article = getArticleById(articleId);
+
+ if (article != null) {
+ shareArticle(article);
+ article.close();
+ }
+ }
+
+ private void shareArticle(Cursor article) {
+ if (article != null) {
+ Intent intent = getShareIntent(article);
+
+ startActivity(Intent.createChooser(intent,
+ getString(R.id.share_article)));
+ }
+ }
+
+ protected int getSelectedArticleCount() {
+ Cursor c = getReadableDb().query("articles",
+ new String[] { "COUNT(*)" }, "selected = 1", null, null, null,
+ null);
+ c.moveToFirst();
+ int selected = c.getInt(0);
+ c.close();
+
+ return selected;
+ }
+
+}
diff --git a/src/org/fox/ttrss/offline/OfflineArticleEventListener.java b/src/org/fox/ttrss/offline/OfflineArticleEventListener.java new file mode 100644 index 00000000..35b9de28 --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineArticleEventListener.java @@ -0,0 +1,5 @@ +package org.fox.ttrss.offline;
+
+public interface OfflineArticleEventListener {
+
+}
diff --git a/src/org/fox/ttrss/offline/OfflineArticleFragment.java b/src/org/fox/ttrss/offline/OfflineArticleFragment.java new file mode 100644 index 00000000..266c89b2 --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineArticleFragment.java @@ -0,0 +1,269 @@ +package org.fox.ttrss.offline;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.fox.ttrss.OnlineActivity;
+import org.fox.ttrss.R;
+import org.fox.ttrss.util.ImageCacheService;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+
+import android.app.Activity;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.provider.BaseColumns;
+import android.support.v4.app.Fragment;
+import android.text.Html;
+import android.text.method.LinkMovementMethod;
+import android.util.Log;
+import android.util.TypedValue;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.LayoutInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+import android.webkit.WebSettings.LayoutAlgorithm;
+import android.widget.TextView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+
+public class OfflineArticleFragment extends Fragment {
+ @SuppressWarnings("unused")
+ private final String TAG = this.getClass().getSimpleName();
+
+ private SharedPreferences m_prefs;
+ private int m_articleId;
+ private boolean m_isCat = false; // FIXME use
+ private Cursor m_cursor;
+ private OfflineActivity m_activity;
+
+ public OfflineArticleFragment() {
+ super();
+ }
+
+ public OfflineArticleFragment(int articleId) {
+ super();
+ m_articleId = articleId;
+ }
+
+
+ @Override
+ public boolean onContextItemSelected(MenuItem item) {
+ AdapterContextMenuInfo info = (AdapterContextMenuInfo) item
+ .getMenuInfo();
+
+ switch (item.getItemId()) {
+ case R.id.article_link_share:
+ m_activity.shareArticle(m_articleId);
+ return true;
+ case R.id.article_link_copy:
+ if (true) {
+ Cursor article = m_activity.getArticleById(m_articleId);
+
+ if (article != null) {
+ m_activity.copyToClipboard(article.getString(article.getColumnIndex("link")));
+ article.close();
+ }
+ }
+ return true;
+ default:
+ Log.d(TAG, "onContextItemSelected, unhandled id=" + item.getItemId());
+ return super.onContextItemSelected(item);
+ }
+ }
+
+ @Override
+ public void onCreateContextMenu(ContextMenu menu, View v,
+ ContextMenuInfo menuInfo) {
+
+ getActivity().getMenuInflater().inflate(R.menu.article_link_context_menu, menu);
+ menu.setHeaderTitle(m_cursor.getString(m_cursor.getColumnIndex("title")));
+
+ super.onCreateContextMenu(menu, v, menuInfo);
+
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+
+ if (savedInstanceState != null) {
+ m_articleId = savedInstanceState.getInt("articleId");
+ }
+
+ View view = inflater.inflate(R.layout.article_fragment, container, false);
+
+ m_cursor = m_activity.getReadableDb().query("articles LEFT JOIN feeds ON (feed_id = feeds."+BaseColumns._ID+")",
+ new String[] { "articles.*", "feeds.title AS feed_title" }, "articles." + BaseColumns._ID + "=?",
+ new String[] { String.valueOf(m_articleId) }, null, null, null);
+
+ m_cursor.moveToFirst();
+
+ if (m_cursor.isFirst()) {
+
+ TextView title = (TextView)view.findViewById(R.id.title);
+
+ if (title != null) {
+
+ String titleStr;
+
+ if (m_cursor.getString(m_cursor.getColumnIndex("title")).length() > 200)
+ titleStr = m_cursor.getString(m_cursor.getColumnIndex("title")).substring(0, 200) + "...";
+ else
+ titleStr = m_cursor.getString(m_cursor.getColumnIndex("title"));
+
+ title.setMovementMethod(LinkMovementMethod.getInstance());
+ title.setText(Html.fromHtml("<a href=\""+m_cursor.getString(m_cursor.getColumnIndex("link")).trim().replace("\"", "\\\"")+"\">" + titleStr + "</a>"));
+ registerForContextMenu(title);
+ }
+
+ WebView web = (WebView)view.findViewById(R.id.content);
+
+ if (web != null) {
+
+ String content;
+ String cssOverride = "";
+
+ WebSettings ws = web.getSettings();
+ ws.setSupportZoom(true);
+ ws.setBuiltInZoomControls(true);
+
+ web.getSettings().setLayoutAlgorithm(LayoutAlgorithm.SINGLE_COLUMN);
+
+ TypedValue tv = new TypedValue();
+ getActivity().getTheme().resolveAttribute(R.attr.linkColor, tv, true);
+
+ // prevent flicker in ics
+ if (android.os.Build.VERSION.SDK_INT >= 11) {
+ web.setLayerType(View.LAYER_TYPE_SOFTWARE, null);
+ }
+
+ if (m_prefs.getString("theme", "THEME_DARK").equals("THEME_DARK")) {
+ cssOverride = "body { background : transparent; color : #e0e0e0}";
+ //view.setBackgroundColor(android.R.color.black);
+ web.setBackgroundColor(getResources().getColor(android.R.color.transparent));
+ } else {
+ cssOverride = "";
+ }
+
+ String hexColor = String.format("#%06X", (0xFFFFFF & tv.data));
+ cssOverride += " a:link {color: "+hexColor+";} a:visited { color: "+hexColor+";}";
+
+ String articleContent = m_cursor.getString(m_cursor.getColumnIndex("content"));
+ Document doc = Jsoup.parse(articleContent);
+
+ if (doc != null) {
+ if (m_prefs.getBoolean("offline_image_cache_enabled", false)) {
+
+ Elements images = doc.select("img");
+
+ for (Element img : images) {
+ String url = img.attr("src");
+
+ if (ImageCacheService.isUrlCached(url)) {
+ img.attr("src", "file://" + ImageCacheService.getCacheFileName(url));
+ }
+ }
+ }
+
+ // thanks webview for crashing on <video> tag
+ Elements videos = doc.select("video");
+
+ for (Element video : videos)
+ video.remove();
+
+ articleContent = doc.toString();
+ }
+
+ view.findViewById(R.id.attachments_holder).setVisibility(View.GONE);
+
+ String align = m_prefs.getBoolean("justify_article_text", true) ? "text-align : justified" : "";
+
+ switch (Integer.parseInt(m_prefs.getString("font_size", "0"))) {
+ case 0:
+ cssOverride += "body { "+align+"; font-size : 14px; } ";
+ break;
+ case 1:
+ cssOverride += "body { "+align+"; font-size : 18px; } ";
+ break;
+ case 2:
+ cssOverride += "body { "+align+"; font-size : 21px; } ";
+ break;
+ }
+
+ content =
+ "<html>" +
+ "<head>" +
+ "<meta content=\"text/html; charset=utf-8\" http-equiv=\"content-type\">" +
+ "<style type=\"text/css\">" +
+ "body { padding : 0px; margin : 0px; }" +
+ cssOverride +
+ "</style>" +
+ "</head>" +
+ "<body>" + articleContent + "</body></html>";
+
+ try {
+ web.loadDataWithBaseURL(null, content, "text/html", "utf-8", null);
+ } catch (RuntimeException e) {
+ e.printStackTrace();
+ }
+
+
+ }
+
+ TextView dv = (TextView)view.findViewById(R.id.date);
+
+ if (dv != null) {
+ Date d = new Date(m_cursor.getInt(m_cursor.getColumnIndex("updated")) * 1000L);
+ SimpleDateFormat df = new SimpleDateFormat("EEE, dd MMM yyyy, HH:mm");
+ dv.setText(df.format(d));
+ }
+
+ TextView tagv = (TextView)view.findViewById(R.id.tags);
+
+ if (tagv != null) {
+ int feedTitleIndex = m_cursor.getColumnIndex("feed_title");
+
+ if (feedTitleIndex != -1 && m_isCat) {
+ tagv.setText(m_cursor.getString(feedTitleIndex));
+ } else {
+ String tagsStr = m_cursor.getString(m_cursor.getColumnIndex("tags"));
+ tagv.setText(tagsStr);
+ }
+ }
+ }
+
+ return view;
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ m_cursor.close();
+ }
+
+ @Override
+ public void onSaveInstanceState (Bundle out) {
+ super.onSaveInstanceState(out);
+
+ out.putInt("articleId", m_articleId);
+ }
+
+ @Override
+ public void onAttach(Activity activity) {
+ super.onAttach(activity);
+
+ m_prefs = PreferenceManager.getDefaultSharedPreferences(getActivity().getApplicationContext());
+
+ m_activity = (OfflineActivity) activity;
+ }
+
+
+}
diff --git a/src/org/fox/ttrss/offline/OfflineArticlePager.java b/src/org/fox/ttrss/offline/OfflineArticlePager.java new file mode 100644 index 00000000..c6c824f5 --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineArticlePager.java @@ -0,0 +1,150 @@ +package org.fox.ttrss.offline;
+
+import org.fox.ttrss.R;
+
+import android.app.Activity;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteStatement;
+import android.os.Bundle;
+import android.provider.BaseColumns;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentStatePagerAdapter;
+import android.support.v4.view.ViewPager;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+public class OfflineArticlePager extends Fragment {
+ private final String TAG = this.getClass().getSimpleName();
+
+ private PagerAdapter m_adapter;
+ private OfflineActivity m_activity;
+ private OfflineHeadlinesEventListener m_listener;
+ private boolean m_isCat;
+ private int m_feedId;
+ private int m_articleId;
+ private String m_searchQuery = "";
+ private Cursor m_cursor;
+
+ public Cursor createCursor() {
+ String feedClause = null;
+
+ if (m_isCat) {
+ feedClause = "feed_id IN (SELECT "+BaseColumns._ID+" FROM feeds WHERE cat_id = ?)";
+ } else {
+ feedClause = "feed_id = ?";
+ }
+
+ if (m_searchQuery.equals("")) {
+ return m_listener.getReadableDb().query("articles LEFT JOIN feeds ON (feed_id = feeds."+BaseColumns._ID+")",
+ new String[] { "articles."+BaseColumns._ID, "feeds.title AS feed_title" }, feedClause,
+ new String[] { String.valueOf(m_feedId) }, null, null, "updated DESC");
+ } else {
+ return m_listener.getReadableDb().query("articles LEFT JOIN feeds ON (feed_id = feeds."+BaseColumns._ID+")",
+ new String[] { "articles."+BaseColumns._ID },
+ feedClause + " AND (articles.title LIKE '%' || ? || '%' OR content LIKE '%' || ? || '%')",
+ new String[] { String.valueOf(m_feedId), m_searchQuery, m_searchQuery }, null, null, "updated DESC");
+ }
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ if (m_cursor != null && !m_cursor.isClosed()) m_cursor.close();
+ }
+
+ private class PagerAdapter extends FragmentStatePagerAdapter {
+ public PagerAdapter(FragmentManager fm) {
+ super(fm);
+ }
+
+ @Override
+ public Fragment getItem(int position) {
+ Log.d(TAG, "getItem: " + position);
+
+ if (m_cursor.moveToPosition(position)) {
+ return new OfflineArticleFragment(m_cursor.getInt(m_cursor.getColumnIndex(BaseColumns._ID)));
+ }
+
+ return null;
+ }
+
+ @Override
+ public int getCount() {
+ return m_cursor.getCount();
+ }
+ }
+
+ public OfflineArticlePager() {
+ super();
+ }
+
+ public OfflineArticlePager(int articleId, int feedId, boolean isCat) {
+ super();
+
+ m_feedId = feedId;
+ m_isCat = isCat;
+ m_articleId = articleId;
+
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+ View view = inflater.inflate(R.layout.article_pager, container, false);
+
+ m_adapter = new PagerAdapter(getActivity().getSupportFragmentManager());
+
+ m_cursor.moveToFirst();
+
+ int position = 0;
+
+ while (!m_cursor.isLast()) {
+ if (m_cursor.getInt(m_cursor.getColumnIndex(BaseColumns._ID)) == m_articleId) {
+ position = m_cursor.getPosition();
+ break;
+ }
+ m_cursor.moveToNext();
+ }
+
+ ViewPager pager = (ViewPager) view.findViewById(R.id.article_pager);
+
+ pager.setAdapter(m_adapter);
+ pager.setCurrentItem(position);
+ pager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
+
+ @Override
+ public void onPageScrollStateChanged(int arg0) {
+ }
+
+ @Override
+ public void onPageScrolled(int arg0, float arg1, int arg2) {
+ }
+
+ @Override
+ public void onPageSelected(int position) {
+ if (m_cursor.moveToPosition(position)) {
+ int articleId = m_cursor.getInt(m_cursor.getColumnIndex(BaseColumns._ID));
+
+ m_listener.onArticleSelected(articleId, false);
+
+ }
+ }
+ });
+
+ return view;
+ }
+
+ @Override
+ public void onAttach(Activity activity) {
+ super.onAttach(activity);
+
+ m_activity = (OfflineActivity)activity;
+ m_listener = (OfflineHeadlinesEventListener)activity;
+ m_cursor = createCursor();
+
+ }
+
+}
diff --git a/src/org/fox/ttrss/offline/OfflineDownloadService.java b/src/org/fox/ttrss/offline/OfflineDownloadService.java new file mode 100644 index 00000000..28b803e4 --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineDownloadService.java @@ -0,0 +1,452 @@ +package org.fox.ttrss.offline;
+
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.List;
+
+import org.fox.ttrss.ApiRequest;
+import org.fox.ttrss.OnlineActivity;
+import org.fox.ttrss.R;
+import org.fox.ttrss.types.Article;
+import org.fox.ttrss.types.Feed;
+import org.fox.ttrss.types.FeedCategory;
+import org.fox.ttrss.util.DatabaseHelper;
+import org.fox.ttrss.util.ImageCacheService;
+import org.jsoup.Jsoup;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.select.Elements;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningServiceInfo;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteStatement;
+import android.os.Binder;
+import android.os.IBinder;
+import android.preference.PreferenceManager;
+import android.provider.BaseColumns;
+import android.util.Log;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.reflect.TypeToken;
+
+public class OfflineDownloadService extends Service {
+
+ private final String TAG = this.getClass().getSimpleName();
+
+ public static final int NOTIFY_DOWNLOADING = 1;
+ public static final String INTENT_ACTION_SUCCESS = "org.fox.ttrss.intent.action.DownloadComplete";
+ public static final String INTENT_ACTION_CANCEL = "org.fox.ttrss.intent.action.Cancel";
+
+ private static final int OFFLINE_SYNC_SEQ = 40;
+ private static final int OFFLINE_SYNC_MAX = 120 /*500*/;
+
+ private SQLiteDatabase m_writableDb;
+ private SQLiteDatabase m_readableDb;
+ private int m_articleOffset = 0;
+ private String m_sessionId;
+ private NotificationManager m_nmgr;
+
+ private boolean m_downloadInProgress = false;
+ private boolean m_downloadImages = false;
+ private int m_syncMax;
+ private SharedPreferences m_prefs;
+ private boolean m_canProceed = true;
+
+ private final IBinder m_binder = new LocalBinder();
+
+ public class LocalBinder extends Binder {
+ OfflineDownloadService getService() {
+ return OfflineDownloadService.this;
+ }
+ }
+
+ @Override
+ public IBinder onBind(Intent intent) {
+ return m_binder;
+ }
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ m_nmgr = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
+ m_prefs = PreferenceManager
+ .getDefaultSharedPreferences(getApplicationContext());
+
+ m_downloadImages = m_prefs.getBoolean("offline_image_cache_enabled", false);
+ m_syncMax = m_prefs.getInt("offline_sync_max", OFFLINE_SYNC_MAX);
+
+ initDatabase();
+ }
+
+ private void updateNotification(String msg) {
+ Notification notification = new Notification(R.drawable.icon,
+ getString(R.string.notify_downloading_title), System.currentTimeMillis());
+
+ Intent intent = new Intent(this, OnlineActivity.class);
+ intent.setAction(INTENT_ACTION_CANCEL);
+
+ PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
+ intent, 0);
+
+ notification.flags |= Notification.FLAG_ONGOING_EVENT;
+ notification.flags |= Notification.FLAG_ONLY_ALERT_ONCE;
+
+ notification.setLatestEventInfo(this, getString(R.string.notify_downloading_title), msg, contentIntent);
+
+ m_nmgr.notify(NOTIFY_DOWNLOADING, notification);
+ }
+
+ private void updateNotification(int msgResId) {
+ updateNotification(getString(msgResId));
+ }
+
+ private void downloadFailed() {
+ m_readableDb.close();
+ m_writableDb.close();
+
+ m_nmgr.cancel(NOTIFY_DOWNLOADING);
+
+ // TODO send notification to activity?
+
+ m_downloadInProgress = false;
+ stopSelf();
+ }
+
+ private boolean isCacheServiceRunning() {
+ ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
+ for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
+ if ("org.fox.ttrss.ImageCacheService".equals(service.service.getClassName())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public void downloadComplete() {
+ m_downloadInProgress = false;
+
+ // if cache service is running, it will send a finished intent on its own
+ if (!isCacheServiceRunning()) {
+ m_nmgr.cancel(NOTIFY_DOWNLOADING);
+
+ Intent intent = new Intent();
+ intent.setAction(INTENT_ACTION_SUCCESS);
+ intent.addCategory(Intent.CATEGORY_DEFAULT);
+ sendBroadcast(intent);
+ } else {
+ updateNotification(getString(R.string.notify_downloading_images, 0));
+ }
+
+ m_readableDb.close();
+ m_writableDb.close();
+
+ stopSelf();
+ }
+
+ private void initDatabase() {
+ DatabaseHelper dh = new DatabaseHelper(getApplicationContext());
+ m_writableDb = dh.getWritableDatabase();
+ m_readableDb = dh.getReadableDatabase();
+ }
+
+ private synchronized SQLiteDatabase getReadableDb() {
+ return m_readableDb;
+ }
+
+ private synchronized SQLiteDatabase getWritableDb() {
+ return m_writableDb;
+ }
+
+ @SuppressWarnings("unchecked")
+ private void downloadArticles() {
+ Log.d(TAG, "offline: downloading articles... offset=" + m_articleOffset);
+
+ updateNotification(getString(R.string.notify_downloading_articles, m_articleOffset));
+
+ OfflineArticlesRequest req = new OfflineArticlesRequest(this);
+
+ @SuppressWarnings("serial")
+ HashMap<String,String> map = new HashMap<String,String>() {
+ {
+ put("op", "getHeadlines");
+ put("sid", m_sessionId);
+ put("feed_id", "-4");
+ put("view_mode", "unread");
+ put("show_content", "true");
+ put("skip", String.valueOf(m_articleOffset));
+ put("limit", String.valueOf(OFFLINE_SYNC_SEQ));
+ }
+ };
+
+ req.execute(map);
+ }
+
+ private void downloadFeeds() {
+
+ updateNotification(R.string.notify_downloading_feeds);
+
+ getWritableDb().execSQL("DELETE FROM feeds;");
+
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ @Override
+ protected void onPostExecute(JsonElement content) {
+ if (content != null) {
+
+ try {
+ Type listType = new TypeToken<List<Feed>>() {}.getType();
+ List<Feed> feeds = new Gson().fromJson(content, listType);
+
+ SQLiteStatement stmtInsert = getWritableDb().compileStatement("INSERT INTO feeds " +
+ "("+BaseColumns._ID+", title, feed_url, has_icon, cat_id) " +
+ "VALUES (?, ?, ?, ?, ?);");
+
+ for (Feed feed : feeds) {
+ stmtInsert.bindLong(1, feed.id);
+ stmtInsert.bindString(2, feed.title);
+ stmtInsert.bindString(3, feed.feed_url);
+ stmtInsert.bindLong(4, feed.has_icon ? 1 : 0);
+ stmtInsert.bindLong(5, feed.cat_id);
+
+ stmtInsert.execute();
+ }
+
+ stmtInsert.close();
+
+ Log.d(TAG, "offline: done downloading feeds");
+
+ m_articleOffset = 0;
+
+ getWritableDb().execSQL("DELETE FROM articles;");
+
+ if (m_canProceed) {
+ downloadArticles();
+ } else {
+ downloadFailed();
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ updateNotification(R.string.offline_switch_error);
+ downloadFailed();
+ }
+
+ } else {
+ updateNotification(getErrorMessage());
+ downloadFailed();
+ }
+ }
+
+ };
+
+ @SuppressWarnings("serial")
+ HashMap<String,String> map = new HashMap<String,String>() {
+ {
+ put("op", "getFeeds");
+ put("sid", m_sessionId);
+ put("cat_id", "-3");
+ put("unread_only", "true");
+ }
+ };
+
+ req.execute(map);
+ }
+
+ private void downloadCategories() {
+
+ updateNotification(R.string.notify_downloading_feeds);
+
+ getWritableDb().execSQL("DELETE FROM categories;");
+
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ @Override
+ protected void onPostExecute(JsonElement content) {
+ if (content != null) {
+
+ try {
+ Type listType = new TypeToken<List<FeedCategory>>() {}.getType();
+ List<FeedCategory> cats = new Gson().fromJson(content, listType);
+
+ SQLiteStatement stmtInsert = getWritableDb().compileStatement("INSERT INTO categories " +
+ "("+BaseColumns._ID+", title) " +
+ "VALUES (?, ?);");
+
+ for (FeedCategory cat : cats) {
+ stmtInsert.bindLong(1, cat.id);
+ stmtInsert.bindString(2, cat.title);
+
+ stmtInsert.execute();
+ }
+
+ stmtInsert.close();
+
+ Log.d(TAG, "offline: done downloading categories");
+
+ if (m_canProceed) {
+ downloadFeeds();
+ } else {
+ downloadFailed();
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ updateNotification(R.string.offline_switch_error);
+ downloadFailed();
+ }
+
+ } else {
+ updateNotification(getErrorMessage());
+ downloadFailed();
+ }
+ }
+
+ };
+
+ @SuppressWarnings("serial")
+ HashMap<String,String> map = new HashMap<String,String>() {
+ {
+ put("op", "getCategories");
+ put("sid", m_sessionId);
+ //put("cat_id", "-3");
+ put("unread_only", "true");
+ }
+ };
+
+ req.execute(map);
+ }
+
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ m_nmgr.cancel(NOTIFY_DOWNLOADING);
+
+ m_canProceed = false;
+ Log.d(TAG, "onDestroy");
+
+ //m_readableDb.close();
+ //m_writableDb.close();
+ }
+
+ public class OfflineArticlesRequest extends ApiRequest {
+ public OfflineArticlesRequest(Context context) {
+ super(context);
+ }
+
+ @Override
+ protected void onPostExecute(JsonElement content) {
+ if (content != null) {
+ try {
+ Type listType = new TypeToken<List<Article>>() {}.getType();
+ List<Article> articles = new Gson().fromJson(content, listType);
+
+ SQLiteStatement stmtInsert = getWritableDb().compileStatement("INSERT INTO articles " +
+ "("+BaseColumns._ID+", unread, marked, published, updated, is_updated, title, link, feed_id, tags, content) " +
+ "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);");
+
+ for (Article article : articles) {
+
+ String tagsString = "";
+
+ for (String t : article.tags) {
+ tagsString += t + ", ";
+ }
+
+ tagsString = tagsString.replaceAll(", $", "");
+
+ stmtInsert.bindLong(1, article.id);
+ stmtInsert.bindLong(2, article.unread ? 1 : 0);
+ stmtInsert.bindLong(3, article.marked ? 1 : 0);
+ stmtInsert.bindLong(4, article.published ? 1 : 0);
+ stmtInsert.bindLong(5, article.updated);
+ stmtInsert.bindLong(6, article.is_updated ? 1 : 0);
+ stmtInsert.bindString(7, article.title);
+ stmtInsert.bindString(8, article.link);
+ stmtInsert.bindLong(9, article.feed_id);
+ stmtInsert.bindString(10, tagsString); // comma-separated tags
+ stmtInsert.bindString(11, article.content);
+
+ if (m_downloadImages) {
+ Document doc = Jsoup.parse(article.content);
+
+ if (doc != null) {
+ Elements images = doc.select("img");
+
+ for (Element img : images) {
+ String url = img.attr("src");
+
+ if (url.indexOf("://") != -1) {
+ if (!ImageCacheService.isUrlCached(url)) {
+ Intent intent = new Intent(OfflineDownloadService.this,
+ ImageCacheService.class);
+
+ intent.putExtra("url", url);
+ startService(intent);
+ }
+ }
+ }
+ }
+ }
+
+ try {
+ stmtInsert.execute();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ stmtInsert.close();
+
+ //m_canGetMoreArticles = articles.size() == 30;
+ m_articleOffset += articles.size();
+
+ Log.d(TAG, "offline: received " + articles.size() + " articles; canProc=" + m_canProceed);
+
+ if (m_canProceed) {
+ if (articles.size() == OFFLINE_SYNC_SEQ && m_articleOffset < m_syncMax) {
+ downloadArticles();
+ } else {
+ downloadComplete();
+ }
+ } else {
+ downloadFailed();
+ }
+
+ return;
+
+ } catch (Exception e) {
+ updateNotification(R.string.offline_switch_error);
+ Log.d(TAG, "offline: failed: exception when loading articles");
+ e.printStackTrace();
+ downloadFailed();
+ }
+
+ } else {
+ Log.d(TAG, "offline: failed: " + getErrorMessage());
+ updateNotification(getErrorMessage());
+ downloadFailed();
+ }
+ }
+ }
+
+ @Override
+ public void onStart(Intent intent, int startId) {
+ m_sessionId = intent.getStringExtra("sessionId");
+
+ if (!m_downloadInProgress) {
+ if (m_downloadImages) ImageCacheService.cleanupCache(false);
+
+ updateNotification(R.string.notify_downloading_init);
+ m_downloadInProgress = true;
+
+ downloadCategories();
+ }
+ }
+}
diff --git a/src/org/fox/ttrss/offline/OfflineFeedCategoriesFragment.java b/src/org/fox/ttrss/offline/OfflineFeedCategoriesFragment.java new file mode 100644 index 00000000..0d48dc12 --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineFeedCategoriesFragment.java @@ -0,0 +1,307 @@ +package org.fox.ttrss.offline;
+
+import org.fox.ttrss.R;
+import org.fox.ttrss.types.Feed;
+import org.fox.ttrss.types.FeedCategory;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.database.Cursor;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.provider.BaseColumns;
+import android.support.v4.app.Fragment;
+import android.support.v4.widget.SimpleCursorAdapter;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.LayoutInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.TextView;
+
+public class OfflineFeedCategoriesFragment extends Fragment implements OnItemClickListener, OnSharedPreferenceChangeListener {
+ private final String TAG = this.getClass().getSimpleName();
+ private SharedPreferences m_prefs;
+ private FeedCategoryListAdapter m_adapter;
+ private int m_selectedCatId;
+ private Cursor m_cursor;
+ private OfflineFeedsActivity m_activity;
+
+ @Override
+ public void onCreateContextMenu(ContextMenu menu, View v,
+ ContextMenuInfo menuInfo) {
+
+ getActivity().getMenuInflater().inflate(R.menu.category_menu, menu);
+
+ AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
+ Cursor cursor = (Cursor)m_adapter.getItem(info.position);
+
+ if (cursor != null)
+ menu.setHeaderTitle(cursor.getString(cursor.getColumnIndex("title")));
+
+ super.onCreateContextMenu(menu, v, menuInfo);
+
+ }
+
+ public Cursor createCursor() {
+ String unreadOnly = BaseColumns._ID + "> 0 AND " + (m_activity.getUnreadOnly() ? "unread > 0" : "1");
+
+ String order = m_prefs.getBoolean("sort_feeds_by_unread", false) ? "unread DESC, title" : "title";
+
+ return m_activity.getReadableDb().query("cats_unread",
+ null, unreadOnly, null, null, null, order);
+ }
+
+ public void refresh() {
+ if (m_cursor != null && !m_cursor.isClosed()) m_cursor.close();
+
+ m_cursor = createCursor();
+
+ if (m_cursor != null) {
+ m_adapter.changeCursor(m_cursor);
+ m_adapter.notifyDataSetChanged();
+ }
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+ refresh();
+ }
+
+ @Override
+ public boolean onContextItemSelected(MenuItem item) {
+ AdapterContextMenuInfo info = (AdapterContextMenuInfo) item
+ .getMenuInfo();
+
+ switch (item.getItemId()) {
+ case R.id.browse_articles:
+ if (true) {
+ int catId = getCatIdAtPosition(info.position);
+ if (catId != -10000) {
+ m_activity.onCatSelected(catId, true);
+ }
+ }
+ return true;
+ case R.id.browse_feeds:
+ if (true) {
+ int catId = getCatIdAtPosition(info.position);
+ if (catId != -10000) {
+ m_activity.onCatSelected(catId, false);
+ }
+ }
+ return true;
+ case R.id.catchup_category:
+ if (true) {
+ int catId = getCatIdAtPosition(info.position);
+ if (catId != -10000) {
+ m_activity.catchupFeed(catId, true);
+ }
+ }
+ return true;
+ default:
+ Log.d(TAG, "onContextItemSelected, unhandled id=" + item.getItemId());
+ return super.onContextItemSelected(item);
+ }
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+
+ if (savedInstanceState != null) {
+ m_selectedCatId = savedInstanceState.getInt("selectedFeedId");
+ }
+
+ View view = inflater.inflate(R.layout.feeds_fragment, container, false);
+
+ ListView list = (ListView)view.findViewById(R.id.feeds);
+
+ m_cursor = createCursor();
+
+ m_adapter = new FeedCategoryListAdapter(getActivity(), R.layout.feeds_row, m_cursor,
+ new String[] { "title", "unread" }, new int[] { R.id.title, R.id.unread_counter }, 0);
+
+ list.setAdapter(m_adapter);
+ list.setOnItemClickListener(this);
+ list.setEmptyView(view.findViewById(R.id.no_feeds));
+ registerForContextMenu(list);
+
+ view.findViewById(R.id.loading_container).setVisibility(View.GONE);
+
+ return view;
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ if (m_cursor != null && !m_cursor.isClosed()) m_cursor.close();
+ }
+
+ @Override
+ public void onAttach(Activity activity) {
+ super.onAttach(activity);
+
+ m_activity = (OfflineFeedsActivity)activity;
+
+ m_prefs = PreferenceManager.getDefaultSharedPreferences(getActivity().getApplicationContext());
+ m_prefs.registerOnSharedPreferenceChangeListener(this);
+
+ }
+
+ @Override
+ public void onSaveInstanceState (Bundle out) {
+ super.onSaveInstanceState(out);
+
+ out.putInt("selectedFeedId", m_selectedCatId);
+ }
+
+ @Override
+ public void onItemClick(AdapterView<?> av, View view, int position, long id) {
+ ListView list = (ListView)getActivity().findViewById(R.id.feeds);
+
+ if (list != null) {
+ Cursor cursor = (Cursor) list.getItemAtPosition(position);
+
+ if (cursor != null) {
+ int feedId = (int) cursor.getLong(0);
+ Log.d(TAG, "clicked on feed " + feedId);
+
+ m_activity.onCatSelected(feedId);
+
+ if (!m_activity.isSmallScreen())
+ m_selectedCatId = feedId;
+
+ m_adapter.notifyDataSetChanged();
+ }
+ }
+ }
+
+ /* public void setLoadingStatus(int status, boolean showProgress) {
+ if (getView() != null) {
+ TextView tv = (TextView)getView().findViewById(R.id.loading_message);
+
+ if (tv != null) {
+ tv.setText(status);
+ }
+ }
+
+ getActivity().setProgressBarIndeterminateVisibility(showProgress);
+ } */
+
+ private class FeedCategoryListAdapter extends SimpleCursorAdapter {
+
+
+ public FeedCategoryListAdapter(Context context, int layout, Cursor c,
+ String[] from, int[] to, int flags) {
+ super(context, layout, c, from, to, flags);
+ }
+
+ public static final int VIEW_NORMAL = 0;
+ public static final int VIEW_SELECTED = 1;
+
+ public static final int VIEW_COUNT = VIEW_SELECTED+1;
+
+ @Override
+ public int getViewTypeCount() {
+ return VIEW_COUNT;
+ }
+
+ @Override
+ public int getItemViewType(int position) {
+ Cursor cursor = (Cursor) this.getItem(position);
+
+ if (!m_activity.isSmallScreen() && cursor.getLong(0) == m_selectedCatId) {
+ return VIEW_SELECTED;
+ } else {
+ return VIEW_NORMAL;
+ }
+ }
+
+ @Override
+ public View getView(int position, View convertView, ViewGroup parent) {
+ View v = convertView;
+
+ Cursor cursor = (Cursor)getItem(position);
+
+ if (v == null) {
+ int layoutId = R.layout.feeds_row;
+
+ switch (getItemViewType(position)) {
+ case VIEW_SELECTED:
+ layoutId = R.layout.feeds_row_selected;
+ break;
+ }
+
+ LayoutInflater vi = (LayoutInflater)getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+ v = vi.inflate(layoutId, null);
+
+ }
+
+ TextView tt = (TextView) v.findViewById(R.id.title);
+
+ if (tt != null) {
+ tt.setText(cursor.getString(cursor.getColumnIndex("title")));
+ }
+
+ TextView tu = (TextView) v.findViewById(R.id.unread_counter);
+
+ if (tu != null) {
+ tu.setText(String.valueOf(cursor.getInt(cursor.getColumnIndex("unread"))));
+ tu.setVisibility((cursor.getInt(cursor.getColumnIndex("unread")) > 0) ? View.VISIBLE : View.INVISIBLE);
+ }
+
+ ImageView icon = (ImageView)v.findViewById(R.id.icon);
+
+ if (icon != null) {
+ icon.setImageResource(cursor.getInt(cursor.getColumnIndex("unread")) > 0 ? R.drawable.ic_rss : R.drawable.ic_rss_bw);
+ }
+
+ return v;
+ }
+ }
+
+ public void sortCategories() {
+ try {
+ refresh();
+ } catch (NullPointerException e) {
+ // activity is gone?
+ } catch (IllegalStateException e) {
+ // we're probably closing and DB is gone already
+ }
+ }
+
+ @Override
+ public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
+ String key) {
+
+ sortCategories();
+ }
+
+ public int getCatIdAtPosition(int position) {
+ Cursor c = (Cursor)m_adapter.getItem(position);
+
+ if (c != null) {
+ int catId = c.getInt(0);
+ c.close();
+ return catId;
+ }
+
+ return -10000;
+ }
+
+ public void setSelectedFeedId(int feedId) {
+ m_selectedCatId = feedId;
+ refresh();
+ }
+
+}
diff --git a/src/org/fox/ttrss/offline/OfflineFeedsActivity.java b/src/org/fox/ttrss/offline/OfflineFeedsActivity.java new file mode 100644 index 00000000..e44dcc82 --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineFeedsActivity.java @@ -0,0 +1,261 @@ +package org.fox.ttrss.offline;
+
+import org.fox.ttrss.HeadlinesFragment;
+import org.fox.ttrss.R;
+
+import android.content.Intent;
+import android.database.sqlite.SQLiteStatement;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.provider.BaseColumns;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentTransaction;
+import android.util.Log;
+import android.view.MenuItem;
+import android.view.View;
+
+public class OfflineFeedsActivity extends OfflineActivity implements OfflineHeadlinesEventListener {
+ private final String TAG = this.getClass().getSimpleName();
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ m_prefs = PreferenceManager
+ .getDefaultSharedPreferences(getApplicationContext());
+
+ if (m_prefs.getString("theme", "THEME_DARK").equals("THEME_DARK")) {
+ setTheme(R.style.DarkTheme);
+ } else {
+ setTheme(R.style.LightTheme);
+ }
+
+ super.onCreate(savedInstanceState);
+
+ setContentView(R.layout.feeds);
+
+ setSmallScreen(findViewById(R.id.headlines_fragment) == null);
+
+ if (savedInstanceState != null) {
+
+ } else {
+ Intent intent = getIntent();
+
+ if (intent.getIntExtra("feed", -10000) != -10000 || intent.getIntExtra("category", -10000) != -10000 ||
+ intent.getIntExtra("article", -10000) != -10000) {
+
+ FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
+
+ int feedId = intent.getIntExtra("feed", -10000);
+ int catId = intent.getIntExtra("category", -10000);
+ int articleId = intent.getIntExtra("article", -10000);
+ boolean isCat = intent.getBooleanExtra("isCat", false);
+
+ if (articleId != -10000) {
+ ft.replace(R.id.feeds_fragment, new OfflineArticlePager(articleId, feedId, isCat), FRAG_ARTICLE);
+ } else {
+ if (feedId != -10000) {
+ ft.replace(R.id.feeds_fragment, new OfflineHeadlinesFragment(feedId, isCat), FRAG_HEADLINES);
+ }
+
+ if (catId != -10000) {
+ ft.replace(R.id.feeds_fragment, new OfflineFeedsFragment(catId), FRAG_FEEDS);
+ }
+ }
+
+ ft.commit();
+ } else {
+ FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
+
+ if (m_prefs.getBoolean("enable_cats", false)) {
+ ft.replace(R.id.feeds_fragment, new OfflineFeedCategoriesFragment(), FRAG_CATS);
+ } else {
+ ft.replace(R.id.feeds_fragment, new OfflineFeedsFragment(), FRAG_FEEDS);
+ }
+
+ ft.commit();
+ }
+ }
+
+ setLoadingStatus(R.string.blank, false);
+ findViewById(R.id.loading_container).setVisibility(View.GONE);
+
+ initMenu();
+ }
+
+ protected void refresh() {
+ OfflineFeedsFragment ff = (OfflineFeedsFragment) getSupportFragmentManager()
+ .findFragmentByTag(FRAG_FEEDS);
+
+ if (ff != null) {
+ ff.refresh();
+ }
+
+ OfflineFeedCategoriesFragment cf = (OfflineFeedCategoriesFragment) getSupportFragmentManager()
+ .findFragmentByTag(FRAG_CATS);
+
+ if (cf != null) {
+ cf.refresh();
+ }
+
+ /* OfflineHeadlinesFragment ohf = (OfflineHeadlinesFragment) getSupportFragmentManager()
+ .findFragmentByTag(FRAG_HEADLINES);
+
+ if (ohf != null) {
+ ohf.refresh();
+ } */
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ switch (item.getItemId()) {
+ case R.id.show_feeds:
+ m_unreadOnly = !m_unreadOnly;
+ initMenu();
+ refresh();
+ return true;
+ default:
+ Log.d(TAG, "onOptionsItemSelected, unhandled id=" + item.getItemId());
+ return super.onOptionsItemSelected(item);
+ }
+ }
+
+ @Override
+ public void onSaveInstanceState(Bundle out) {
+ super.onSaveInstanceState(out);
+
+ }
+
+ public void initMenu() {
+ super.initMenu();
+
+ if (m_menu != null) {
+ Fragment ff = getSupportFragmentManager().findFragmentByTag(FRAG_FEEDS);
+ Fragment cf = getSupportFragmentManager().findFragmentByTag(FRAG_CATS);
+ OfflineArticlePager af = (OfflineArticlePager) getSupportFragmentManager().findFragmentByTag(FRAG_ARTICLE);
+ OfflineHeadlinesFragment hf = (OfflineHeadlinesFragment)getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES);
+
+ m_menu.setGroupVisible(R.id.menu_group_feeds, (ff != null && ff.isAdded()) || (cf != null && cf.isAdded()));
+
+ m_menu.setGroupVisible(R.id.menu_group_article, af != null && af.isAdded());
+
+ m_menu.setGroupVisible(R.id.menu_group_headlines, hf != null && hf.isAdded() && getSelectedArticleCount() == 0);
+ m_menu.setGroupVisible(R.id.menu_group_headlines_selection, hf != null && hf.isAdded() && getSelectedArticleCount() != 0);
+
+ 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 onCatSelected(int catId) {
+ onCatSelected(catId, m_prefs.getBoolean("browse_cats_like_feeds", false));
+ }
+
+ public void onCatSelected(int catId, boolean openAsFeed) {
+ FragmentTransaction ft = getSupportFragmentManager()
+ .beginTransaction();
+
+ if (openAsFeed) {
+ onFeedSelected(catId, true, true);
+ } else {
+ if (isSmallScreen()) {
+ Intent intent = new Intent(OfflineFeedsActivity.this, OfflineFeedsActivity.class);
+ intent.putExtra("category", catId);
+
+ startActivityForResult(intent, 0);
+ } else {
+ OfflineFeedsFragment ff = new OfflineFeedsFragment(catId);
+
+ ft.replace(R.id.feeds_fragment, ff, FRAG_FEEDS);
+ }
+ }
+ ft.addToBackStack(null);
+
+ ft.commit();
+
+ }
+
+ public void onFeedSelected(int feedId) {
+ onFeedSelected(feedId, false, true);
+ }
+
+ public void onFeedSelected(int feedId, boolean isCat, boolean open) {
+
+ if (open) {
+ if (isSmallScreen()) {
+
+ Intent intent = new Intent(OfflineFeedsActivity.this, OfflineFeedsActivity.class);
+ intent.putExtra("feed", feedId);
+ intent.putExtra("isCat", isCat);
+
+ startActivityForResult(intent, 0);
+
+ } else {
+
+ // TODO open OfflineHeadlinesFragment on R.id.headlines_fragment
+
+ }
+ }
+ }
+
+ public void catchupFeed(int feedId, boolean isCat) {
+ if (isCat) {
+ SQLiteStatement stmt = getWritableDb().compileStatement(
+ "UPDATE articles SET unread = 0 WHERE feed_id IN (SELECT "+
+ BaseColumns._ID+" FROM feeds WHERE cat_id = ?)");
+ stmt.bindLong(1, feedId);
+ stmt.execute();
+ stmt.close();
+ } else {
+ SQLiteStatement stmt = getWritableDb().compileStatement(
+ "UPDATE articles SET unread = 0 WHERE feed_id = ?");
+ stmt.bindLong(1, feedId);
+ stmt.execute();
+ stmt.close();
+ }
+
+ refresh();
+ }
+
+ @Override
+ public void onArticleSelected(int articleId, boolean open) {
+ SQLiteStatement stmt = getWritableDb().compileStatement(
+ "UPDATE articles SET unread = 0 " + "WHERE " + BaseColumns._ID
+ + " = ?");
+
+ stmt.bindLong(1, articleId);
+ stmt.execute();
+ stmt.close();
+
+ if (open) {
+ if (isSmallScreen()) {
+
+ OfflineHeadlinesFragment hf = (OfflineHeadlinesFragment) getSupportFragmentManager().findFragmentByTag(FRAG_HEADLINES);
+
+ Intent intent = new Intent(OfflineFeedsActivity.this, OfflineFeedsActivity.class);
+ intent.putExtra("feed", hf.getFeedId());
+ intent.putExtra("isCat", hf.getFeedIsCat());
+ intent.putExtra("article", articleId);
+
+ startActivityForResult(intent, 0);
+
+ } else {
+
+ // TODO open OfflineHeadlinesActivity
+
+
+ }
+ } else {
+ refresh();
+ }
+
+ }
+
+ @Override
+ public void onArticleSelected(int articleId) {
+ onArticleSelected(articleId, true);
+ }
+}
diff --git a/src/org/fox/ttrss/offline/OfflineFeedsFragment.java b/src/org/fox/ttrss/offline/OfflineFeedsFragment.java new file mode 100644 index 00000000..d70c247d --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineFeedsFragment.java @@ -0,0 +1,331 @@ +package org.fox.ttrss.offline;
+
+import java.io.File;
+
+import org.fox.ttrss.R;
+import org.fox.ttrss.types.Feed;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Bundle;
+import android.os.Environment;
+import android.preference.PreferenceManager;
+import android.provider.BaseColumns;
+import android.support.v4.app.Fragment;
+import android.support.v4.widget.SimpleCursorAdapter;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.LayoutInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.TextView;
+
+public class OfflineFeedsFragment extends Fragment implements OnItemClickListener, OnSharedPreferenceChangeListener {
+ private final String TAG = this.getClass().getSimpleName();
+ private SharedPreferences m_prefs;
+ private FeedListAdapter m_adapter;
+ private static final String ICON_PATH = "/data/org.fox.ttrss/icons/";
+ private int m_selectedFeedId;
+ private int m_catId = -1;
+ private boolean m_enableFeedIcons;
+ private Cursor m_cursor;
+ private OfflineFeedsActivity m_activity;
+
+ public OfflineFeedsFragment() {
+ //
+ }
+
+ public OfflineFeedsFragment(int catId) {
+ m_catId = catId;
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+ refresh();
+ }
+
+ @Override
+ public boolean onContextItemSelected(MenuItem item) {
+ AdapterContextMenuInfo info = (AdapterContextMenuInfo) item
+ .getMenuInfo();
+ switch (item.getItemId()) {
+ case R.id.catchup_feed:
+ int feedId = getFeedIdAtPosition(info.position);
+ if (feedId != -10000) {
+ m_activity.catchupFeed(feedId, false);
+ }
+ return true;
+ default:
+ Log.d(TAG, "onContextItemSelected, unhandled id=" + item.getItemId());
+ return super.onContextItemSelected(item);
+ }
+ }
+
+ @Override
+ public void onCreateContextMenu(ContextMenu menu, View v,
+ ContextMenuInfo menuInfo) {
+
+ getActivity().getMenuInflater().inflate(R.menu.feed_menu, menu);
+
+ AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
+ Cursor cursor = (Cursor)m_adapter.getItem(info.position);
+
+ if (cursor != null)
+ menu.setHeaderTitle(cursor.getString(cursor.getColumnIndex("title")));
+
+ super.onCreateContextMenu(menu, v, menuInfo);
+
+ }
+
+ public Cursor createCursor() {
+ String unreadOnly = m_activity.getUnreadOnly() ? "unread > 0" : "1";
+ String order = m_prefs.getBoolean("sort_feeds_by_unread", false) ? "unread DESC, title" : "title";
+
+ if (m_catId != -1) {
+ return m_activity.getReadableDb().query("feeds_unread",
+ null, unreadOnly + " AND cat_id = ?", new String[] { String.valueOf(m_catId) }, null, null, order);
+ } else {
+ return m_activity.getReadableDb().query("feeds_unread",
+ null, unreadOnly, null, null, null, order);
+ }
+ }
+
+ public void refresh() {
+ if (m_cursor != null && !m_cursor.isClosed()) m_cursor.close();
+
+ m_cursor = createCursor();
+
+ if (m_cursor != null) {
+ m_adapter.changeCursor(m_cursor);
+ m_adapter.notifyDataSetChanged();
+ }
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+
+ if (savedInstanceState != null) {
+ m_selectedFeedId = savedInstanceState.getInt("selectedFeedId");
+ m_catId = savedInstanceState.getInt("catId");
+ }
+
+ View view = inflater.inflate(R.layout.feeds_fragment, container, false);
+
+ ListView list = (ListView)view.findViewById(R.id.feeds);
+
+ m_cursor = createCursor();
+
+ m_adapter = new FeedListAdapter(getActivity(), R.layout.feeds_row, m_cursor,
+ new String[] { "title", "unread" }, new int[] { R.id.title, R.id.unread_counter }, 0);
+
+ list.setAdapter(m_adapter);
+ list.setOnItemClickListener(this);
+ list.setEmptyView(view.findViewById(R.id.no_feeds));
+ registerForContextMenu(list);
+
+ view.findViewById(R.id.loading_container).setVisibility(View.GONE);
+
+ m_enableFeedIcons = m_prefs.getBoolean("download_feed_icons", false);
+
+ return view;
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ if (m_cursor != null && !m_cursor.isClosed()) m_cursor.close();
+ }
+
+ @Override
+ public void onAttach(Activity activity) {
+ super.onAttach(activity);
+
+ m_activity = (OfflineFeedsActivity)activity;
+
+ m_prefs = PreferenceManager.getDefaultSharedPreferences(getActivity().getApplicationContext());
+ m_prefs.registerOnSharedPreferenceChangeListener(this);
+
+ }
+
+ @Override
+ public void onSaveInstanceState (Bundle out) {
+ super.onSaveInstanceState(out);
+
+ out.putInt("selectedFeedId", m_selectedFeedId);
+ out.putInt("catId", m_catId);
+ }
+
+ @Override
+ public void onItemClick(AdapterView<?> av, View view, int position, long id) {
+ ListView list = (ListView)getActivity().findViewById(R.id.feeds);
+
+ if (list != null) {
+ Cursor cursor = (Cursor) list.getItemAtPosition(position);
+
+ if (cursor != null) {
+ int feedId = (int) cursor.getLong(0);
+ Log.d(TAG, "clicked on feed " + feedId);
+
+ m_activity.onFeedSelected(feedId);
+
+ if (!m_activity.isSmallScreen())
+ m_selectedFeedId = feedId;
+
+ m_adapter.notifyDataSetChanged();
+ }
+ }
+ }
+
+ /* public void setLoadingStatus(int status, boolean showProgress) {
+ if (getView() != null) {
+ TextView tv = (TextView)getView().findViewById(R.id.loading_message);
+
+ if (tv != null) {
+ tv.setText(status);
+ }
+ }
+
+ getActivity().setProgressBarIndeterminateVisibility(showProgress);
+ } */
+
+ private class FeedListAdapter extends SimpleCursorAdapter {
+
+
+ public FeedListAdapter(Context context, int layout, Cursor c,
+ String[] from, int[] to, int flags) {
+ super(context, layout, c, from, to, flags);
+ }
+
+ public static final int VIEW_NORMAL = 0;
+ public static final int VIEW_SELECTED = 1;
+
+ public static final int VIEW_COUNT = VIEW_SELECTED+1;
+
+ @Override
+ public int getViewTypeCount() {
+ return VIEW_COUNT;
+ }
+
+ @Override
+ public int getItemViewType(int position) {
+ Cursor cursor = (Cursor) this.getItem(position);
+
+ if (!m_activity.isSmallScreen() && cursor.getLong(0) == m_selectedFeedId) {
+ return VIEW_SELECTED;
+ } else {
+ return VIEW_NORMAL;
+ }
+ }
+
+ @Override
+ public View getView(int position, View convertView, ViewGroup parent) {
+ View v = convertView;
+
+ Cursor cursor = (Cursor)getItem(position);
+
+ if (v == null) {
+ int layoutId = R.layout.feeds_row;
+
+ switch (getItemViewType(position)) {
+ case VIEW_SELECTED:
+ layoutId = R.layout.feeds_row_selected;
+ break;
+ }
+
+ LayoutInflater vi = (LayoutInflater)getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+ v = vi.inflate(layoutId, null);
+
+ }
+
+ TextView tt = (TextView) v.findViewById(R.id.title);
+
+ if (tt != null) {
+ tt.setText(cursor.getString(cursor.getColumnIndex("title")));
+ }
+
+ TextView tu = (TextView) v.findViewById(R.id.unread_counter);
+
+ if (tu != null) {
+ tu.setText(String.valueOf(cursor.getInt(cursor.getColumnIndex("unread"))));
+ tu.setVisibility((cursor.getInt(cursor.getColumnIndex("unread")) > 0) ? View.VISIBLE : View.INVISIBLE);
+ }
+
+ ImageView icon = (ImageView)v.findViewById(R.id.icon);
+
+ if (icon != null) {
+
+ if (m_enableFeedIcons) {
+
+ File storage = Environment.getExternalStorageDirectory();
+
+ File iconFile = new File(storage.getAbsolutePath() + ICON_PATH + cursor.getInt(cursor.getColumnIndex(BaseColumns._ID)) + ".ico");
+ if (iconFile.exists()) {
+ Bitmap bmpOrig = BitmapFactory.decodeFile(iconFile.getAbsolutePath());
+ if (bmpOrig != null) {
+ icon.setImageBitmap(bmpOrig);
+ }
+ } else {
+ icon.setImageResource(cursor.getInt(cursor.getColumnIndex("unread")) > 0 ? R.drawable.ic_rss : R.drawable.ic_rss_bw);
+ }
+
+ } else {
+ icon.setImageResource(cursor.getInt(cursor.getColumnIndex("unread")) > 0 ? R.drawable.ic_rss : R.drawable.ic_rss_bw);
+ }
+
+ }
+
+ return v;
+ }
+ }
+
+ public void sortFeeds() {
+ try {
+ refresh();
+ } catch (NullPointerException e) {
+ // activity is gone?
+ } catch (IllegalStateException e) {
+ // we're probably closing and DB is gone already
+ }
+ }
+
+ @Override
+ public void onSharedPreferenceChanged(SharedPreferences sharedPreferences,
+ String key) {
+
+ sortFeeds();
+ m_enableFeedIcons = m_prefs.getBoolean("download_feed_icons", false);
+
+ }
+
+ public int getFeedIdAtPosition(int position) {
+ Cursor c = (Cursor)m_adapter.getItem(position);
+
+ if (c != null) {
+ int feedId = c.getInt(0);
+ c.close();
+ return feedId;
+ }
+
+ return -10000;
+ }
+
+ public void setSelectedFeedId(int feedId) {
+ m_selectedFeedId = feedId;
+ refresh();
+ }
+
+}
diff --git a/src/org/fox/ttrss/offline/OfflineHeadlinesEventListener.java b/src/org/fox/ttrss/offline/OfflineHeadlinesEventListener.java new file mode 100644 index 00000000..392f59ec --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineHeadlinesEventListener.java @@ -0,0 +1,17 @@ +package org.fox.ttrss.offline;
+
+import android.database.sqlite.SQLiteDatabase;
+
+public interface OfflineHeadlinesEventListener {
+
+ void onArticleSelected(int articleId, boolean open);
+ void onArticleSelected(int articleId);
+
+ SQLiteDatabase getReadableDb();
+ SQLiteDatabase getWritableDb();
+ boolean isSmallScreen();
+ boolean isPortrait();
+ void initMenu();
+
+
+}
diff --git a/src/org/fox/ttrss/offline/OfflineHeadlinesFragment.java b/src/org/fox/ttrss/offline/OfflineHeadlinesFragment.java new file mode 100644 index 00000000..6445d94d --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineHeadlinesFragment.java @@ -0,0 +1,585 @@ +package org.fox.ttrss.offline;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.TimeZone;
+
+import org.fox.ttrss.R;
+import org.fox.ttrss.types.Article;
+import org.fox.ttrss.types.ArticleList;
+import org.jsoup.Jsoup;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteStatement;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.provider.BaseColumns;
+import android.support.v4.app.Fragment;
+import android.support.v4.widget.SimpleCursorAdapter;
+import android.text.Html;
+import android.text.Html.ImageGetter;
+import android.text.method.LinkMovementMethod;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.LayoutInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.AdapterView.AdapterContextMenuInfo;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.CheckBox;
+import android.widget.ImageButton;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.TextView;
+
+public class OfflineHeadlinesFragment extends Fragment implements OnItemClickListener {
+ public static enum ArticlesSelection { ALL, NONE, UNREAD };
+
+ private final String TAG = this.getClass().getSimpleName();
+
+ private int m_feedId;
+ private boolean m_feedIsCat = false;
+ private int m_activeArticleId;
+ private boolean m_combinedMode = true;
+ private String m_searchQuery = "";
+
+ private SharedPreferences m_prefs;
+
+ private Cursor m_cursor;
+ private ArticleListAdapter m_adapter;
+
+ private OfflineHeadlinesEventListener m_listener;
+
+ private ImageGetter m_dummyGetter = new ImageGetter() {
+
+ @Override
+ public Drawable getDrawable(String source) {
+ return new BitmapDrawable();
+ }
+
+ };
+
+ public OfflineHeadlinesFragment(int feedId, boolean isCat) {
+ m_feedId = feedId;
+ m_feedIsCat = isCat;
+ }
+
+ public OfflineHeadlinesFragment() {
+ //
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ if (m_cursor != null && !m_cursor.isClosed()) m_cursor.close();
+ }
+
+ public int getSelectedArticleCount() {
+ Cursor c = m_listener.getReadableDb().query("articles",
+ new String[] { "COUNT(*)" }, "selected = 1", null, null, null, null);
+ c.moveToFirst();
+ int selected = c.getInt(0);
+ c.close();
+
+ return selected;
+ }
+
+ @Override
+ public boolean onContextItemSelected(MenuItem item) {
+ AdapterContextMenuInfo info = (AdapterContextMenuInfo) item
+ .getMenuInfo();
+
+ switch (item.getItemId()) {
+ case R.id.set_labels:
+ if (true) {
+ }
+ return true;
+ case R.id.article_set_note:
+ if (true) {
+ }
+ return true;
+
+ case R.id.article_link_copy:
+ if (true) {
+ }
+ return true;
+ case R.id.selection_toggle_marked:
+ if (true) {
+ }
+ return true;
+ case R.id.selection_toggle_published:
+ if (true) {
+ }
+ return true;
+ case R.id.selection_toggle_unread:
+ if (true) {
+ }
+ return true;
+ case R.id.share_article:
+ if (true) {
+ }
+ return true;
+ case R.id.catchup_above:
+ if (true) {
+ }
+ return true;
+ default:
+ Log.d(TAG, "onContextItemSelected, unhandled id=" + item.getItemId());
+ return super.onContextItemSelected(item);
+ }
+ }
+
+ @Override
+ public void onCreateContextMenu(ContextMenu menu, View v,
+ ContextMenuInfo menuInfo) {
+
+ getActivity().getMenuInflater().inflate(R.menu.headlines_context_menu, menu);
+
+ if (getSelectedArticleCount() > 0) {
+ menu.setHeaderTitle(R.string.headline_context_multiple);
+ menu.setGroupVisible(R.id.menu_group_single_article, false);
+ } else {
+ AdapterContextMenuInfo info = (AdapterContextMenuInfo)menuInfo;
+ Cursor c = getArticleAtPosition(info.position);
+ menu.setHeaderTitle(c.getString(c.getColumnIndex("title")));
+ //c.close();
+ menu.setGroupVisible(R.id.menu_group_single_article, true);
+ }
+
+ super.onCreateContextMenu(menu, v, menuInfo);
+
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+ refresh();
+ }
+
+ public void refresh() {
+ if (m_cursor != null && !m_cursor.isClosed()) m_cursor.close();
+
+ m_cursor = createCursor();
+
+ if (m_cursor != null) {
+ m_adapter.changeCursor(m_cursor);
+ m_adapter.notifyDataSetChanged();
+ }
+ }
+
+ @Override
+ public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+
+ if (savedInstanceState != null) {
+ m_feedId = savedInstanceState.getInt("feedId");
+ m_activeArticleId = savedInstanceState.getInt("activeArticleId");
+ //m_selectedArticles = savedInstanceState.getParcelableArrayList("selectedArticles");
+ m_combinedMode = savedInstanceState.getBoolean("combinedMode");
+ m_searchQuery = (String) savedInstanceState.getCharSequence("searchQuery");
+ m_feedIsCat = savedInstanceState.getBoolean("feedIsCat");
+ }
+
+ View view = inflater.inflate(R.layout.headlines_fragment, container, false);
+
+ m_cursor = createCursor();
+
+ ListView list = (ListView)view.findViewById(R.id.headlines);
+ m_adapter = new ArticleListAdapter(getActivity(), R.layout.headlines_row, m_cursor,
+ new String[] { "title" }, new int[] { R.id.title }, 0);
+
+ list.setAdapter(m_adapter);
+ list.setOnItemClickListener(this);
+ list.setEmptyView(view.findViewById(R.id.no_headlines));
+ registerForContextMenu(list);
+
+ if (m_listener.isSmallScreen() || m_listener.isPortrait())
+ view.findViewById(R.id.headlines_fragment).setPadding(0, 0, 0, 0);
+
+ getActivity().setProgressBarIndeterminateVisibility(false);
+
+ return view;
+ }
+
+ public Cursor createCursor() {
+ String feedClause = null;
+
+ if (m_feedIsCat) {
+ feedClause = "feed_id IN (SELECT "+BaseColumns._ID+" FROM feeds WHERE cat_id = ?)";
+ } else {
+ feedClause = "feed_id = ?";
+ }
+
+ if (m_searchQuery.equals("")) {
+ return m_listener.getReadableDb().query("articles LEFT JOIN feeds ON (feed_id = feeds."+BaseColumns._ID+")",
+ new String[] { "articles.*", "feeds.title AS feed_title" }, feedClause,
+ new String[] { String.valueOf(m_feedId) }, null, null, "updated DESC");
+ } else {
+ return m_listener.getReadableDb().query("articles LEFT JOIN feeds ON (feed_id = feeds."+BaseColumns._ID+")",
+ new String[] { "articles.*", "feeds.title AS feed_title" },
+ feedClause + " AND (articles.title LIKE '%' || ? || '%' OR content LIKE '%' || ? || '%')",
+ new String[] { String.valueOf(m_feedId), m_searchQuery, m_searchQuery }, null, null, "updated DESC");
+ }
+ }
+
+ @Override
+ public void onAttach(Activity activity) {
+ super.onAttach(activity);
+ m_listener = (OfflineHeadlinesEventListener)activity;
+
+ m_prefs = PreferenceManager.getDefaultSharedPreferences(getActivity().getApplicationContext());
+ m_combinedMode = m_prefs.getBoolean("combined_mode", false);
+ }
+
+ @Override
+ public void onItemClick(AdapterView<?> av, View view, int position, long id) {
+ ListView list = (ListView)av;
+
+ Log.d(TAG, "onItemClick=" + position);
+
+ if (list != null) {
+ Cursor cursor = (Cursor)list.getItemAtPosition(position);
+
+ int articleId = cursor.getInt(0);
+
+ if (!m_listener.isSmallScreen()) {
+ m_activeArticleId = articleId;
+ }
+
+ if (!m_combinedMode) {
+ m_listener.onArticleSelected(articleId);
+ }
+
+ refresh();
+ }
+ }
+
+ @Override
+ public void onSaveInstanceState (Bundle out) {
+ super.onSaveInstanceState(out);
+
+ out.putInt("feedId", m_feedId);
+ out.putInt("activeArticleId", m_activeArticleId);
+ //out.putParcelableArrayList("selectedArticles", m_selectedArticles);
+ out.putBoolean("combinedMode", m_combinedMode);
+ out.putCharSequence("searchQuery", m_searchQuery);
+ out.putBoolean("feedIsCat", m_feedIsCat);
+ }
+
+ /* public void setLoadingStatus(int status, boolean showProgress) {
+ if (getView() != null) {
+ TextView tv = (TextView)getView().findViewById(R.id.loading_message);
+
+ if (tv != null) {
+ tv.setText(status);
+ }
+ }
+
+ getActivity().setProgressBarIndeterminateVisibility(showProgress);
+ } */
+
+ private class ArticleListAdapter extends SimpleCursorAdapter {
+ public ArticleListAdapter(Context context, int layout, Cursor c,
+ String[] from, int[] to, int flags) {
+ super(context, layout, c, from, to, flags);
+ // TODO Auto-generated constructor stub
+ }
+
+ public static final int VIEW_NORMAL = 0;
+ public static final int VIEW_UNREAD = 1;
+ public static final int VIEW_SELECTED = 2;
+ public static final int VIEW_LOADMORE = 3;
+
+ public static final int VIEW_COUNT = VIEW_LOADMORE+1;
+
+
+ public int getViewTypeCount() {
+ return VIEW_COUNT;
+ }
+
+ @Override
+ public int getItemViewType(int position) {
+ Cursor c = (Cursor) getItem(position);
+
+ //Log.d(TAG, "@gIVT " + position + " " + c.getInt(0) + " vs " + m_activeArticleId);
+
+ if (c.getInt(0) == m_activeArticleId) {
+ return VIEW_SELECTED;
+ } else if (c.getInt(c.getColumnIndex("unread")) == 1) {
+ return VIEW_UNREAD;
+ } else {
+ return VIEW_NORMAL;
+ }
+ }
+
+ @Override
+ public View getView(int position, View convertView, ViewGroup parent) {
+
+ View v = convertView;
+
+ Cursor article = (Cursor)getItem(position);
+ final int articleId = article.getInt(0);
+
+ if (v == null) {
+ int layoutId = R.layout.headlines_row;
+
+ switch (getItemViewType(position)) {
+ case VIEW_LOADMORE:
+ layoutId = R.layout.headlines_row_loadmore;
+ break;
+ case VIEW_UNREAD:
+ layoutId = R.layout.headlines_row_unread;
+ break;
+ case VIEW_SELECTED:
+ layoutId = R.layout.headlines_row_selected;
+ break;
+ }
+
+ LayoutInflater vi = (LayoutInflater)getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+ v = vi.inflate(layoutId, null);
+
+ // http://code.google.com/p/android/issues/detail?id=3414
+ ((ViewGroup)v).setDescendantFocusability(ViewGroup.FOCUS_BLOCK_DESCENDANTS);
+ }
+
+ TextView tt = (TextView)v.findViewById(R.id.title);
+
+ if (tt != null) {
+ if (m_combinedMode) {
+ tt.setMovementMethod(LinkMovementMethod.getInstance());
+ tt.setText(Html.fromHtml("<a href=\""+article.getString(article.getColumnIndex("link")).trim().replace("\"", "\\\"")+"\">" +
+ article.getString(article.getColumnIndex("title")) + "</a>"));
+ } else {
+ tt.setText(Html.fromHtml(article.getString(article.getColumnIndex("title"))));
+ }
+ }
+
+ TextView ft = (TextView)v.findViewById(R.id.feed_title);
+
+ int feedTitleIndex = article.getColumnIndex("feed_title");
+
+ if (ft != null && feedTitleIndex != -1 && m_feedIsCat) {
+ String feedTitle = article.getString(feedTitleIndex);
+
+ if (feedTitle != null) {
+ ft.setText(feedTitle);
+ } else {
+ ft.setVisibility(View.GONE);
+ }
+ } else if (ft != null) {
+ ft.setVisibility(View.GONE);
+ }
+
+ ImageView marked = (ImageView)v.findViewById(R.id.marked);
+
+ if (marked != null) {
+ marked.setImageResource(article.getInt(article.getColumnIndex("marked")) == 1 ? android.R.drawable.star_on : android.R.drawable.star_off);
+
+ marked.setOnClickListener(new OnClickListener() {
+
+ @Override
+ public void onClick(View v) {
+ SQLiteStatement stmtUpdate = m_listener.getWritableDb().compileStatement("UPDATE articles SET marked = NOT marked " +
+ "WHERE " + BaseColumns._ID + " = ?");
+
+ stmtUpdate.bindLong(1, articleId);
+ stmtUpdate.execute();
+ stmtUpdate.close();
+
+ refresh();
+ }
+ });
+ }
+
+ ImageView published = (ImageView)v.findViewById(R.id.published);
+
+ if (published != null) {
+ published.setImageResource(article.getInt(article.getColumnIndex("published")) == 1 ? R.drawable.ic_rss : R.drawable.ic_rss_bw);
+
+ published.setOnClickListener(new OnClickListener() {
+
+ @Override
+ public void onClick(View v) {
+ SQLiteStatement stmtUpdate = m_listener.getWritableDb().compileStatement("UPDATE articles SET published = NOT published " +
+ "WHERE " + BaseColumns._ID + " = ?");
+
+ stmtUpdate.bindLong(1, articleId);
+ stmtUpdate.execute();
+ stmtUpdate.close();
+
+ refresh();
+ }
+ });
+ }
+
+ TextView te = (TextView)v.findViewById(R.id.excerpt);
+
+ if (te != null) {
+ if (!m_combinedMode) {
+ String excerpt = Jsoup.parse(article.getString(article.getColumnIndex("content"))).text();
+
+ if (excerpt.length() > 100)
+ excerpt = excerpt.substring(0, 100) + "...";
+
+ te.setText(excerpt);
+ } else {
+ te.setVisibility(View.GONE);
+ }
+ }
+
+ /* ImageView separator = (ImageView)v.findViewById(R.id.headlines_separator);
+
+ if (separator != null && m_offlineServices.isSmallScreen()) {
+ separator.setVisibility(View.GONE);
+ } */
+
+ TextView content = (TextView)v.findViewById(R.id.content);
+
+ if (content != null) {
+ if (m_combinedMode) {
+ content.setMovementMethod(LinkMovementMethod.getInstance());
+
+ content.setText(Html.fromHtml(article.getString(article.getColumnIndex("content")), m_dummyGetter, null));
+
+ switch (Integer.parseInt(m_prefs.getString("font_size", "0"))) {
+ case 0:
+ content.setTextSize(15F);
+ break;
+ case 1:
+ content.setTextSize(18F);
+ break;
+ case 2:
+ content.setTextSize(21F);
+ break;
+ }
+ } else {
+ content.setVisibility(View.GONE);
+ }
+ }
+
+ v.findViewById(R.id.attachments_holder).setVisibility(View.GONE);
+
+ TextView dv = (TextView) v.findViewById(R.id.date);
+
+ if (dv != null) {
+ Date d = new Date((long)article.getInt(article.getColumnIndex("updated")) * 1000);
+ DateFormat df = new SimpleDateFormat("MMM dd, HH:mm");
+ df.setTimeZone(TimeZone.getDefault());
+ dv.setText(df.format(d));
+ }
+
+ CheckBox cb = (CheckBox) v.findViewById(R.id.selected);
+
+ if (cb != null) {
+ cb.setChecked(article.getInt(article.getColumnIndex("selected")) == 1);
+ cb.setOnClickListener(new OnClickListener() {
+
+ @Override
+ public void onClick(View view) {
+ CheckBox cb = (CheckBox)view;
+
+ SQLiteStatement stmtUpdate = m_listener.getWritableDb().compileStatement("UPDATE articles SET selected = ? " +
+ "WHERE " + BaseColumns._ID + " = ?");
+
+ stmtUpdate.bindLong(1, cb.isChecked() ? 1 : 0);
+ stmtUpdate.bindLong(2, articleId);
+ stmtUpdate.execute();
+ stmtUpdate.close();
+
+ refresh();
+
+ m_listener.initMenu();
+
+ }
+ });
+ }
+
+ ImageButton ib = (ImageButton) v.findViewById(R.id.article_menu_button);
+
+ if (ib != null) {
+ ib.setVisibility(android.os.Build.VERSION.SDK_INT >= 10 ? View.VISIBLE : View.GONE);
+ ib.setOnClickListener(new OnClickListener() {
+ @Override
+ public void onClick(View v) {
+ getActivity().openContextMenu(v);
+ }
+ });
+ }
+
+ return v;
+ }
+ }
+
+ public void notifyUpdated() {
+ m_adapter.notifyDataSetChanged();
+ }
+
+ public void setActiveArticleId(int articleId) {
+ m_activeArticleId = articleId;
+ // m_adapter.notifyDataSetChanged();
+
+ ListView list = (ListView)getView().findViewById(R.id.headlines);
+
+ if (list != null) {
+ list.setSelection(getArticleIdPosition(articleId));
+ }
+ }
+
+ public Cursor getArticleAtPosition(int position) {
+ return (Cursor) m_adapter.getItem(position);
+ }
+
+ public int getArticleIdAtPosition(int position) {
+ /*Cursor c = getArticleAtPosition(position);
+
+ if (c != null) {
+ int id = c.getInt(0);
+ return id;
+ } */
+
+ return (int) m_adapter.getItemId(position);
+ }
+
+ public int getActiveArticleId() {
+ return m_activeArticleId;
+ }
+
+ public int getArticleIdPosition(int articleId) {
+ for (int i = 0; i < m_adapter.getCount(); i++) {
+ if (articleId == m_adapter.getItemId(i))
+ return i;
+ }
+
+ return 0;
+ }
+
+ public int getArticleCount() {
+ return m_adapter.getCount();
+ }
+
+ public void setSearchQuery(String query) {
+ if (!m_searchQuery.equals(query)) {
+ m_searchQuery = query;
+ refresh();
+ }
+ }
+
+ public int getFeedId() {
+ return m_feedId;
+ }
+
+ public boolean getFeedIsCat() {
+ return m_feedIsCat;
+ }
+
+}
diff --git a/src/org/fox/ttrss/offline/OfflineUploadService.java b/src/org/fox/ttrss/offline/OfflineUploadService.java new file mode 100644 index 00000000..dd4c829f --- /dev/null +++ b/src/org/fox/ttrss/offline/OfflineUploadService.java @@ -0,0 +1,264 @@ +package org.fox.ttrss.offline;
+
+import java.util.HashMap;
+
+import org.fox.ttrss.ApiRequest;
+import org.fox.ttrss.OnlineActivity;
+import org.fox.ttrss.R;
+import org.fox.ttrss.util.DatabaseHelper;
+
+import android.app.IntentService;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.util.Log;
+
+import com.google.gson.JsonElement;
+
+public class OfflineUploadService extends IntentService {
+ private final String TAG = this.getClass().getSimpleName();
+
+ public static final int NOTIFY_UPLOADING = 2;
+ public static final String INTENT_ACTION_SUCCESS = "org.fox.ttrss.intent.action.UploadComplete";
+
+ private SQLiteDatabase m_writableDb;
+ private SQLiteDatabase m_readableDb;
+ private String m_sessionId;
+ private NotificationManager m_nmgr;
+ private boolean m_uploadInProgress = false;
+
+ public OfflineUploadService() {
+ super("OfflineUploadService");
+ }
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ m_nmgr = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
+ initDatabase();
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ m_nmgr.cancel(NOTIFY_UPLOADING);
+ }
+
+ private void updateNotification(String msg) {
+ Notification notification = new Notification(R.drawable.icon,
+ getString(R.string.notify_uploading_title), System.currentTimeMillis());
+
+ PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
+ new Intent(this, OnlineActivity.class), 0);
+
+ notification.flags |= Notification.FLAG_ONGOING_EVENT;
+ notification.flags |= Notification.FLAG_ONLY_ALERT_ONCE;
+
+ notification.setLatestEventInfo(this, getString(R.string.notify_uploading_title), msg, contentIntent);
+
+ m_nmgr.notify(NOTIFY_UPLOADING, notification);
+ }
+
+ private void updateNotification(int msgResId) {
+ updateNotification(getString(msgResId));
+ }
+
+ private void initDatabase() {
+ DatabaseHelper dh = new DatabaseHelper(getApplicationContext());
+ m_writableDb = dh.getWritableDatabase();
+ m_readableDb = dh.getReadableDatabase();
+ }
+
+ private synchronized SQLiteDatabase getReadableDb() {
+ return m_readableDb;
+ }
+
+ private synchronized SQLiteDatabase getWritableDb() {
+ return m_writableDb;
+ }
+
+ private void uploadRead() {
+ Log.d(TAG, "syncing modified offline data... (read)");
+
+ final String ids = getModifiedIds(ModifiedCriteria.READ);
+
+ if (ids.length() > 0) {
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ @Override
+ protected void onPostExecute(JsonElement result) {
+ if (result != null) {
+ uploadMarked();
+ } else {
+ updateNotification(getErrorMessage());
+ uploadFailed();
+ }
+ }
+ };
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", m_sessionId);
+ put("op", "updateArticle");
+ put("article_ids", ids);
+ put("mode", "0");
+ put("field", "2");
+ }
+ };
+
+ req.execute(map);
+ } else {
+ uploadMarked();
+ }
+ }
+
+ private enum ModifiedCriteria {
+ READ, MARKED, PUBLISHED
+ };
+
+ private String getModifiedIds(ModifiedCriteria criteria) {
+
+ String criteriaStr = "";
+
+ switch (criteria) {
+ case READ:
+ criteriaStr = "unread = 0";
+ break;
+ case MARKED:
+ criteriaStr = "marked = 1";
+ break;
+ case PUBLISHED:
+ criteriaStr = "published = 1";
+ break;
+ }
+
+ Cursor c = getReadableDb().query("articles", null,
+ "modified = 1 AND " + criteriaStr, null, null, null, null);
+
+ String tmp = "";
+
+ while (c.moveToNext()) {
+ tmp += c.getInt(0) + ",";
+ }
+
+ tmp = tmp.replaceAll(",$", "");
+
+ c.close();
+
+ return tmp;
+ }
+
+ private void uploadMarked() {
+ Log.d(TAG, "syncing modified offline data... (marked)");
+
+ final String ids = getModifiedIds(ModifiedCriteria.MARKED);
+
+ if (ids.length() > 0) {
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ @Override
+ protected void onPostExecute(JsonElement result) {
+ if (result != null) {
+ uploadPublished();
+ } else {
+ updateNotification(getErrorMessage());
+ uploadFailed();
+ }
+ }
+ };
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", m_sessionId);
+ put("op", "updateArticle");
+ put("article_ids", ids);
+ put("mode", "0");
+ put("field", "0");
+ }
+ };
+
+ req.execute(map);
+ } else {
+ uploadPublished();
+ }
+ }
+
+ private void uploadFailed() {
+ m_readableDb.close();
+ m_writableDb.close();
+
+ // TODO send notification to activity?
+
+ m_uploadInProgress = false;
+ }
+
+ private void uploadSuccess() {
+ getWritableDb().execSQL("UPDATE articles SET modified = 0");
+
+ Intent intent = new Intent();
+ intent.setAction(INTENT_ACTION_SUCCESS);
+ intent.addCategory(Intent.CATEGORY_DEFAULT);
+ sendBroadcast(intent);
+
+ m_readableDb.close();
+ m_writableDb.close();
+
+ m_uploadInProgress = false;
+
+ m_nmgr.cancel(NOTIFY_UPLOADING);
+ }
+
+ private void uploadPublished() {
+ Log.d(TAG, "syncing modified offline data... (published)");
+
+ final String ids = getModifiedIds(ModifiedCriteria.MARKED);
+
+ if (ids.length() > 0) {
+ ApiRequest req = new ApiRequest(getApplicationContext()) {
+ @Override
+ protected void onPostExecute(JsonElement result) {
+ if (result != null) {
+ uploadSuccess();
+ } else {
+ updateNotification(getErrorMessage());
+ uploadFailed();
+ }
+ }
+ };
+
+ @SuppressWarnings("serial")
+ HashMap<String, String> map = new HashMap<String, String>() {
+ {
+ put("sid", m_sessionId);
+ put("op", "updateArticle");
+ put("article_ids", ids);
+ put("mode", "0");
+ put("field", "1");
+ }
+ };
+
+ req.execute(map);
+ } else {
+ uploadSuccess();
+ }
+ }
+
+
+ @Override
+ protected void onHandleIntent(Intent intent) {
+ m_sessionId = intent.getStringExtra("sessionId");
+
+ if (!m_uploadInProgress) {
+ m_uploadInProgress = true;
+
+ updateNotification(R.string.notify_uploading_sending_data);
+
+ uploadRead();
+ }
+ }
+
+}
diff --git a/src/org/fox/ttrss/util/ImageCacheService.java b/src/org/fox/ttrss/util/ImageCacheService.java new file mode 100644 index 00000000..30bc6022 --- /dev/null +++ b/src/org/fox/ttrss/util/ImageCacheService.java @@ -0,0 +1,208 @@ +package org.fox.ttrss.util;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Date;
+
+import org.fox.ttrss.OnlineActivity;
+import org.fox.ttrss.R;
+import org.fox.ttrss.offline.OfflineDownloadService;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningServiceInfo;
+import android.app.IntentService;
+import android.app.Notification;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Intent;
+import android.os.Environment;
+
+public class ImageCacheService extends IntentService {
+
+ private final String TAG = this.getClass().getSimpleName();
+
+ public static final int NOTIFY_DOWNLOADING = 1;
+
+ private static final String CACHE_PATH = "/data/org.fox.ttrss/image-cache/";
+
+ private int m_imagesDownloaded = 0;
+
+ private NotificationManager m_nmgr;
+
+ public ImageCacheService() {
+ super("ImageCacheService");
+ }
+
+ private boolean isDownloadServiceRunning() {
+ ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
+ for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) {
+ if ("org.fox.ttrss.OfflineDownloadService".equals(service.service.getClassName())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ m_nmgr = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);
+ }
+
+ public static boolean isUrlCached(String url) {
+ String hashedUrl = md5(url);
+
+ File storage = Environment.getExternalStorageDirectory();
+
+ File file = new File(storage.getAbsolutePath() + CACHE_PATH + "/" + hashedUrl + ".png");
+
+ return file.exists();
+ }
+
+ public static String getCacheFileName(String url) {
+ String hashedUrl = md5(url);
+
+ File storage = Environment.getExternalStorageDirectory();
+
+ File file = new File(storage.getAbsolutePath() + CACHE_PATH + "/" + hashedUrl + ".png");
+
+ return file.getAbsolutePath();
+ }
+
+ public static void cleanupCache(boolean deleteAll) {
+ if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
+ File storage = Environment.getExternalStorageDirectory();
+ File cachePath = new File(storage.getAbsolutePath() + CACHE_PATH);
+
+ long now = new Date().getTime();
+
+ if (cachePath.isDirectory()) {
+ for (File file : cachePath.listFiles()) {
+ if (deleteAll || now - file.lastModified() > 1000*60*60*24*7) {
+ file.delete();
+ }
+ }
+ }
+ }
+ }
+
+ protected static String md5(String s) {
+ try {
+ MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
+ digest.update(s.getBytes());
+ byte messageDigest[] = digest.digest();
+
+ StringBuffer hexString = new StringBuffer();
+ for (int i=0; i<messageDigest.length; i++)
+ hexString.append(Integer.toHexString(0xFF & messageDigest[i]));
+
+ return hexString.toString();
+
+ } catch (NoSuchAlgorithmException e) {
+ e.printStackTrace();
+ }
+
+ return null;
+ }
+
+ private InputStream getStream(String urlString) {
+ try {
+ URL url = new URL(urlString);
+ URLConnection urlConnection = url.openConnection();
+ urlConnection.setConnectTimeout(250);
+ return urlConnection.getInputStream();
+ } catch (Exception ex) {
+ return null;
+ }
+ }
+
+ private void updateNotification(String msg) {
+ Notification notification = new Notification(R.drawable.icon,
+ getString(R.string.notify_downloading_title), System.currentTimeMillis());
+
+ PendingIntent contentIntent = PendingIntent.getActivity(this, 0,
+ new Intent(this, OnlineActivity.class), 0);
+
+ notification.flags |= Notification.FLAG_ONGOING_EVENT;
+ notification.flags |= Notification.FLAG_ONLY_ALERT_ONCE;
+
+ notification.setLatestEventInfo(this, getString(R.string.notify_downloading_title), msg, contentIntent);
+
+ m_nmgr.notify(NOTIFY_DOWNLOADING, notification);
+ }
+
+ /* private void updateNotification(int msgResId) {
+ updateNotification(getString(msgResId));
+ } */
+
+ @Override
+ protected void onHandleIntent(Intent intent) {
+ String url = intent.getStringExtra("url");
+
+ //Log.d(TAG, "got request to download URL=" + url);
+
+ if (!Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()))
+ return;
+
+ String hashedUrl = md5(url);
+
+ File storage = Environment.getExternalStorageDirectory();
+ File cachePath = new File(storage.getAbsolutePath() + CACHE_PATH);
+ if (!cachePath.exists()) cachePath.mkdirs();
+
+ if (cachePath.isDirectory() && hashedUrl != null) {
+ File outputFile = new File(cachePath.getAbsolutePath() + "/" + hashedUrl + ".png");
+
+ if (!outputFile.exists()) {
+
+ //Log.d(TAG, "downloading to " + outputFile.getAbsolutePath());
+
+ InputStream is = getStream(url);
+
+ if (is != null) {
+ try {
+ FileOutputStream fos = new FileOutputStream(outputFile);
+
+ byte[] buffer = new byte[1024];
+ int len = 0;
+ while ((len = is.read(buffer)) != -1) {
+ fos.write(buffer, 0, len);
+ }
+
+ fos.close();
+ is.close();
+
+ m_imagesDownloaded++;
+
+ updateNotification(getString(R.string.notify_downloading_images, m_imagesDownloaded));
+
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+
+ if (!isDownloadServiceRunning()) {
+ m_nmgr.cancel(NOTIFY_DOWNLOADING);
+
+ Intent success = new Intent();
+ success.setAction(OfflineDownloadService.INTENT_ACTION_SUCCESS);
+ success.addCategory(Intent.CATEGORY_DEFAULT);
+ sendBroadcast(success);
+ }
+ }
+
+}
|