implement core offline functions

AndroidManifest.xml

@@ -47,6 +47,21 @@
             android:name=".ArticleActivity"
             android:label="@string/app_name" >
         </activity>
+
+        <activity
+            android:name=".offline.OfflineActivity"
+            android:label="@string/app_name" >
+        </activity>
+
+        <activity
+            android:name=".offline.OfflineFeedsActivity"
+            android:label="@string/app_name" >
+        </activity>
+
+        <activity
+            android:name=".offline.OfflineHeadlinesActivity"
+            android:label="@string/app_name" >
+        </activity>
         
         <service
             android:name=".offline.OfflineDownloadService"

src/org/fox/ttrss/ArticleEventListener.java

@@ -1,9 +0,0 @@
-package org.fox.ttrss;
-
-public interface ArticleEventListener {
-
-	void copyToClipboard(String content_url);
-
-	boolean isSmallScreen();
-
-}

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(); 
 	}
 

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;

src/org/fox/ttrss/FeedsEventListener.java

@@ -1,5 +0,0 @@
-package org.fox.ttrss;
-
-public interface FeedsEventListener {
-
-}

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;

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) {
+//		SharedPreferences localPrefs = getSharedPreferences("localprefs", Context.MODE_PRIVATE);
-			Intent i = getIntent();
+
-			
+		SharedPreferences localPrefs = getSharedPreferences("localprefs", Context.MODE_PRIVATE);
-			m_sessionId = i.getStringExtra("sessionId");
-			m_apiLevel = i.getIntExtra("apiLevel", -1);
-		}
-		
-		if (savedInstanceState != null) {
-			m_sessionId = savedInstanceState.getString("sessionId");
-			m_apiLevel = savedInstanceState.getInt("apiLevel");
-			
-			m_unreadOnly = savedInstanceState.getBoolean("unreadOnly");
-			m_unreadArticlesOnly = savedInstanceState.getBoolean("unreadArticlesOnly");
-		}
-		
-		if (!isCompatMode()) {
-			m_headlinesActionModeCallback = new HeadlinesActionModeCallback();
-		}
-		
-		Log.d(TAG, "m_sessionId=" + m_sessionId);
-		Log.d(TAG, "m_apiLevel=" + m_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);
+			}
+			
+			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) {
+		
+			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");
+		
+		Intent intent = new Intent(
+				OnlineActivity.this,
+				OfflineUploadService.class);
+		
+		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 {

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;
+	}
+
+}

src/org/fox/ttrss/offline/OfflineArticleEventListener.java

@@ -0,0 +1,5 @@
+package org.fox.ttrss.offline;
+
+public interface OfflineArticleEventListener {
+
+}

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;
+	}
+
+
+}

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();
+		
+	}
+
+}

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();
+		}
+	}
+}

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();
+	}
+
+}

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);
+	}
+}

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();
+	}
+
+}

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();
+
+
+}

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;
+	}
+	
+}

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();			
+		}
+	}
+
+}

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);
+	    }
+	}
+	
+}