API tools faq
paste
Guest User

Navigation Drawer with Scroll View

a guest
Aug 13th, 2014
345
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 96.85 KB | None | 0 0
raw download clone embed print report
  1. public class MessageList extends ListActivity implements
  2.         MessageListFragmentListener, MessageViewFragmentListener,
  3.         OnBackStackChangedListener, OnSwipeGestureListener,
  4.         OnSwitchCompleteListener {
  5.  
  6.     // for this activity
  7.     private static final String EXTRA_SEARCH = "search";
  8.     private static final String EXTRA_NO_THREADING = "no_threading";
  9.  
  10.     private static final String ACTION_SHORTCUT = "shortcut";
  11.     private static final String EXTRA_SPECIAL_FOLDER = "special_folder";
  12.  
  13.     private static final String EXTRA_MESSAGE_REFERENCE = "message_reference";
  14.  
  15.     // used for remote search
  16.     public static final String EXTRA_SEARCH_ACCOUNT = "com.bernard.beaconportal.activities.search_account";
  17.     private static final String EXTRA_SEARCH_FOLDER = "com.bernard.beaconportal.activities.search_folder";
  18.  
  19.     private static final String STATE_DISPLAY_MODE = "displayMode";
  20.     private static final String STATE_MESSAGE_LIST_WAS_DISPLAYED = "messageListWasDisplayed";
  21.  
  22.     // Used for navigating to next/previous message
  23.     private static final int PREVIOUS = 1;
  24.     private static final int NEXT = 2;
  25.  
  26.     private static final String EXTRA_ACCOUNT = "account";
  27.  
  28.     private static final String EXTRA_FROM_SHORTCUT = "fromShortcut";
  29.  
  30.     private static final boolean REFRESH_REMOTE = true;
  31.  
  32.     private ListView mListView;
  33.  
  34.     private FolderListAdapter mAdapter;
  35.  
  36.     private LayoutInflater mInflater;
  37.  
  38.     private static final String TAG = "K9MailExtension";
  39.  
  40.     public static final String PREF_NAME = "pref_name";
  41.  
  42.     static final Uri k9AccountsUri = Uri
  43.             .parse("content://com.bernard.beaconportal.activities.messageprovider/accounts/");
  44.     static final String k9UnreadUri = "content://com.bernard.beaconportal.activities.messageprovider/account_unread/";
  45.     static final String k9MessageProvider = "content://com.bernard.beaconportal.activities.messageprovider/";
  46.  
  47.     ContentObserver contentObserver = null;
  48.     BroadcastReceiver receiver = null;
  49.     IntentFilter filter = null;
  50.    
  51.     private FolderListHandler mHandler = new FolderListHandler();
  52.  
  53.    
  54.  
  55.     private FontSizes mFontSizes = K9.getFontSizes();
  56.     private Context context;
  57.  
  58.     private MenuItem mRefreshMenuItem;
  59.     private View mActionBarProgressView;
  60.  
  61.    
  62.    
  63.    
  64.    
  65.    
  66.     public static void actionDisplaySearch(Context context,
  67.             SearchSpecification search, boolean noThreading, boolean newTask) {
  68.         actionDisplaySearch(context, search, noThreading, newTask, true);
  69.     }
  70.  
  71.     public static void actionDisplaySearch(Context context,
  72.             SearchSpecification search, boolean noThreading, boolean newTask,
  73.             boolean clearTop) {
  74.         context.startActivity(intentDisplaySearch(context, search, noThreading,
  75.                 newTask, clearTop));
  76.     }
  77.  
  78.     public static Intent intentDisplaySearch(Context context,
  79.             SearchSpecification search, boolean noThreading, boolean newTask,
  80.             boolean clearTop) {
  81.         Intent intent = new Intent(context, MessageList.class);
  82.         intent.putExtra(EXTRA_SEARCH, search);
  83.         intent.putExtra(EXTRA_NO_THREADING, noThreading);
  84.  
  85.         if (clearTop) {
  86.             intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  87.         }
  88.         if (newTask) {
  89.             intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  90.         }
  91.  
  92.         return intent;
  93.     }
  94.  
  95.     public static Intent shortcutIntent(Context context, String specialFolder) {
  96.         Intent intent = new Intent(context, MessageList.class);
  97.         intent.setAction(ACTION_SHORTCUT);
  98.         intent.putExtra(EXTRA_SPECIAL_FOLDER, specialFolder);
  99.         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  100.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  101.  
  102.         return intent;
  103.     }
  104.  
  105.     public static Intent actionDisplayMessageIntent(Context context,
  106.             MessageReference messageReference) {
  107.         Intent intent = new Intent(context, MessageList.class);
  108.         intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  109.         intent.putExtra(EXTRA_MESSAGE_REFERENCE, messageReference);
  110.         return intent;
  111.     }
  112.  
  113.     private enum DisplayMode {
  114.         MESSAGE_LIST, MESSAGE_VIEW, SPLIT_VIEW
  115.     }
  116.  
  117.     private StorageManager.StorageListener mStorageListener = new StorageListenerImplementation();
  118.  
  119.     private android.app.ActionBar mActionBar;
  120.     private View mActionBarMessageList;
  121.     private View mActionBarMessageView;
  122.     private MessageTitleView mActionBarSubject;
  123.     private TextView mActionBarTitle;
  124.     private TextView mActionBarSubTitle;
  125.     private TextView mActionBarUnread;
  126.     private android.view.Menu mMenu;
  127.  
  128.     DrawerLayout mDrawerLayout;
  129.     LinearLayout mDrawerLinear;
  130.     com.bernard.beaconportal.activities.activity.VerticalScrollview mScrollView;
  131.     TextView mWelcomePerson;
  132.     ListView mDrawerList;
  133.     ListView mDrawerList_Inbox;
  134.    
  135.     ActionBarDrawerToggle mDrawerToggle;
  136.     MenuListAdapter mMenuAdapter;
  137.     MenuListAdapter mMenuAdapter_Inbox;
  138.     String actionbar_colors, background_colorsString;
  139.     private String Show_View;
  140.     String[] title;
  141.     String[] count;
  142.     int[] icon;
  143.     String[] title_Inbox;
  144.     String[] count_Inbox;
  145.     int[] icon_Inbox;
  146.     private String counterss;
  147.     private int counters;
  148.     Fragment fragment1 = new FragmentsView();
  149.     Fragment fragment2 = new FragmentsHomeworkDue();
  150.     Fragment fragment3 = new FragmentSettings();
  151.     private CharSequence mDrawerTitle;
  152.     private CharSequence mTitle;
  153.  
  154.     private int shared1;
  155.  
  156.     private int countersss1;
  157.  
  158.     private int mUnreadMessageCount = 0;
  159.  
  160.     private String due_tommorow_shared, due_tommorow_shared_content;
  161.  
  162.     private List<Due_Today_List> due_today_list;
  163.  
  164.     private List<String> read_due_today_list;
  165.  
  166.     private String K9count;
  167.  
  168.     private View swipe;
  169.  
  170.     private int shared;
  171.  
  172.     private int countersss;
  173.  
  174.     private ArrayAdapter<Due_Today_List> adapter;
  175.  
  176.     private ViewGroup mMessageViewContainer;
  177.     private View mMessageViewPlaceHolder;
  178.  
  179.     private MessageListFragment mMessageListFragment;
  180.     private MessageViewFragment mMessageViewFragment;
  181.     private int mFirstBackStackId = -1;
  182.  
  183.     private Account mAccount;
  184.     private String mFolderName;
  185.     private LocalSearch mSearch;
  186.     private boolean mSingleFolderMode;
  187.     private boolean mSingleAccountMode;
  188.  
  189.     private K9FragmentActivity mK9FragmentActivity;
  190.  
  191.     private K9ActivityCommon mBase;
  192.  
  193.     private BaseAccount mSelectedContextAccount;
  194.  
  195.     private ProgressBar mActionBarProgress;
  196.     private android.view.MenuItem mMenuButtonCheckMail;
  197.     private View mActionButtonIndeterminateProgress;
  198.     private int mLastDirection = (K9.messageViewShowNext()) ? NEXT : PREVIOUS;
  199.  
  200.     /**
  201.      * {@code true} if the message list should be displayed as flat list (i.e.
  202.      * no threading) regardless whether or not message threading was enabled in
  203.      * the settings. This is used for filtered views, e.g. when only displaying
  204.      * the unread messages in a folder.
  205.      */
  206.     private boolean mNoThreading;
  207.    
  208.     private String K9counts;
  209.  
  210.     private MessageList currentActivity;
  211.  
  212.     private DisplayMode mDisplayMode;
  213.     private MessageReference mMessageReference;
  214.  
  215.     /**
  216.      * {@code true} when the message list was displayed once. This is used in
  217.      * {@link #onBackPressed()} to decide whether to go from the message view to
  218.      * the message list or finish the activity.
  219.      */
  220.     private boolean mMessageListWasDisplayed = false;
  221.     private ViewSwitcher mViewSwitcher;
  222.  
  223.    
  224.        class FolderListHandler extends Handler {
  225.  
  226.            
  227.  
  228.  
  229.             public void newFolders(final List<FolderInfoHolder> newFolders) {
  230.                 runOnUiThread(new Runnable() {
  231.                     public void run() {
  232.                         mAdapter.mFolders.clear();
  233.                         mAdapter.mFolders.addAll(newFolders);
  234.                         mAdapter.mFilteredFolders = mAdapter.mFolders;
  235.                         mHandler.dataChanged();
  236.                     }
  237.                 });
  238.             }
  239.  
  240.             public void workingAccount(final int res) {
  241.                 runOnUiThread(new Runnable() {
  242.                     public void run() {
  243.                         String toastText = getString(res, mAccount.getDescription());
  244.                         Toast toast = Toast.makeText(getApplication(), toastText, Toast.LENGTH_SHORT);
  245.                         toast.show();
  246.                     }
  247.                 });
  248.             }
  249.  
  250.             public void accountSizeChanged(final long oldSize, final long newSize) {
  251.                 runOnUiThread(new Runnable() {
  252.                     public void run() {
  253.                         String toastText = getString(R.string.account_size_changed, mAccount.getDescription(), SizeFormatter.formatSize(getApplication(), oldSize), SizeFormatter.formatSize(getApplication(), newSize));
  254.  
  255.                         Toast toast = Toast.makeText(getApplication(), toastText, Toast.LENGTH_LONG);
  256.                         toast.show();
  257.                     }
  258.                 });
  259.             }
  260.  
  261.             public void folderLoading(final String folder, final boolean loading) {
  262.                 runOnUiThread(new Runnable() {
  263.                     public void run() {
  264.                         FolderInfoHolder folderHolder = mAdapter.getFolder(folder);
  265.  
  266.  
  267.                         if (folderHolder != null) {
  268.                             folderHolder.loading = loading;
  269.                         }
  270.  
  271.                     }
  272.                 });
  273.             }
  274.  
  275.             public void progress(final boolean progress) {
  276.                 // Make sure we don't try this before the menu is initialized
  277.                 // this could happen while the activity is initialized.
  278.                 if (mRefreshMenuItem == null) {
  279.                     return;
  280.                 }
  281.  
  282.                 runOnUiThread(new Runnable() {
  283.                     public void run() {
  284.                         if (progress) {
  285.                             mRefreshMenuItem.setActionView(mActionBarProgressView);
  286.                         } else {
  287.                             mRefreshMenuItem.setActionView(null);
  288.                         }
  289.                     }
  290.                 });
  291.  
  292.             }
  293.  
  294.             public void dataChanged() {
  295.                 runOnUiThread(new Runnable() {
  296.                     public void run() {
  297.                         mAdapter.notifyDataSetChanged();
  298.                     }
  299.                 });
  300.             }
  301.         }
  302.  
  303.         /**
  304.         * This class is responsible for reloading the list of local messages for a
  305.         * given folder, notifying the adapter that the message have been loaded and
  306.         * queueing up a remote update of the folder.
  307.          */
  308.  
  309.         private void checkMail(FolderInfoHolder folder) {
  310.             TracingPowerManager pm = TracingPowerManager.getPowerManager(this);
  311.             final TracingWakeLock wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "FolderList checkMail");
  312.             wakeLock.setReferenceCounted(false);
  313.             wakeLock.acquire(K9.WAKE_LOCK_TIMEOUT);
  314.             MessagingListener listener = new MessagingListener() {
  315.                 @Override
  316.                 public void synchronizeMailboxFinished(Account account, String folder, int totalMessagesInMailbox, int numNewMessages) {
  317.                     if (!account.equals(mAccount)) {
  318.                         return;
  319.                     }
  320.                     wakeLock.release();
  321.                 }
  322.  
  323.                 @Override
  324.                 public void synchronizeMailboxFailed(Account account, String folder,
  325.                 String message) {
  326.                     if (!account.equals(mAccount)) {
  327.                         return;
  328.                     }
  329.                     wakeLock.release();
  330.                 }
  331.             };
  332.             MessagingController.getInstance(getApplication()).synchronizeMailbox(mAccount, folder.name, listener, null);
  333.             sendMail(mAccount);
  334.         }
  335.  
  336.         public static Intent actionHandleAccountIntent(Context context, Account account, boolean fromShortcut) {
  337.             Intent intent = new Intent(context, FolderList.class);
  338.             intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
  339.             intent.putExtra(EXTRA_ACCOUNT, account.getUuid());
  340.  
  341.             if (fromShortcut) {
  342.                 intent.putExtra(EXTRA_FROM_SHORTCUT, true);
  343.             }
  344.  
  345.             return intent;
  346.         }
  347.  
  348.         public static void actionHandleAccount(Context context, Account account) {
  349.             Intent intent = actionHandleAccountIntent(context, account, false);
  350.             context.startActivity(intent);
  351.         }
  352.    
  353.    
  354.     @Override
  355.     public void onCreate(Bundle savedInstanceState) {
  356.         super.onCreate(savedInstanceState);
  357.  
  358.         Log.d(TAG, "onCreate()");
  359.  
  360.         String packageName = "com.bernard.beaconportal.activities";
  361.  
  362.         int versionNumber = 0;
  363.  
  364.         try {
  365.             PackageInfo pi = getApplicationContext().getPackageManager()
  366.                     .getPackageInfo(packageName, PackageManager.GET_META_DATA);
  367.             versionNumber = pi.versionCode;
  368.             String versionName = pi.versionName;
  369.  
  370.             Log.d(TAG, "K-9 is installed - " + versionNumber + " "
  371.                     + versionName);
  372.  
  373.         } catch (NameNotFoundException e) {
  374.             Log.d(TAG, "K-9 not found");
  375.         }
  376.  
  377.         if (versionNumber <= 16024) {
  378.             // Register a listener for broadcasts (needed for the older versions
  379.             // of k9)
  380.             Log.d(TAG, "Initialising BroadcastReceiver for old K-9 version");
  381.             receiver = new BroadcastReceiver() {
  382.                 @Override
  383.                 public void onReceive(Context context, Intent intent) {
  384.                     Log.d(TAG, "receiver.onReceive()");
  385.                     doRefresh();
  386.                 }
  387.             };
  388.  
  389.             filter = new IntentFilter();
  390.             filter.addAction("com.bernard.beaconportal.activities.intent.action.EMAIL_RECEIVED");
  391.             filter.addAction("com.bernard.beaconportal.activities.intent.action.EMAIL_DELETED");
  392.             filter.addDataScheme("email");
  393.             registerReceiver(receiver, filter);
  394.         } else {
  395.             // Register our own content observer, rather than using
  396.             // addWatchContentUris()
  397.             // since DashClock might not have permission to access the database
  398.             Log.d(TAG, "Initialising ContentObserver for new K-9 version");
  399.             contentObserver = new ContentObserver(null) {
  400.                 @Override
  401.                 public void onChange(boolean selfChange) {
  402.                     Log.d(TAG, "contentResolver.onChange()");
  403.                     doRefresh();
  404.                 }
  405.             };
  406.             getContentResolver().registerContentObserver(
  407.                     Uri.parse(k9UnreadUri), true, contentObserver);
  408.         }
  409.  
  410.         doRefresh();
  411.        
  412.         if (UpgradeDatabases.actionUpgradeDatabases(this, getIntent())) {
  413.             finish();
  414.             return;
  415.         }
  416.  
  417.         if (useSplitView()) {
  418.             setContentView(R.layout.split_drawer_main);
  419.         } else {
  420.             setContentView(R.layout.drawermain1);
  421.             mViewSwitcher = (ViewSwitcher) findViewById(R.id.container);
  422.             mViewSwitcher.setFirstInAnimation(AnimationUtils.loadAnimation(
  423.                     this, R.anim.slide_in_left));
  424.             mViewSwitcher.setFirstOutAnimation(AnimationUtils.loadAnimation(
  425.                     this, R.anim.slide_out_right));
  426.             mViewSwitcher.setSecondInAnimation(AnimationUtils.loadAnimation(
  427.                     this, R.anim.slide_in_right));
  428.             mViewSwitcher.setSecondOutAnimation(AnimationUtils.loadAnimation(
  429.                     this, R.anim.slide_out_left));
  430.             mViewSwitcher.setOnSwitchCompleteListener(this);
  431.         }
  432.        
  433.         initializeActionBar();
  434.        
  435.         mListView = getListView();
  436.         mListView.setScrollBarStyle(View.SCROLLBARS_INSIDE_OVERLAY);
  437.         mListView.setLongClickable(true);
  438.         mListView.setFastScrollEnabled(true);
  439.         mListView.setScrollingCacheEnabled(false);
  440.         mListView.setOnItemClickListener(new OnItemClickListener() {
  441.             public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
  442.                 onOpenFolder(((FolderInfoHolder)mAdapter.getItem(position)).name);
  443.             }
  444.         });
  445.         registerForContextMenu(mListView);
  446.  
  447.         mListView.setSaveEnabled(true);
  448.  
  449.         mInflater = getLayoutInflater();
  450.  
  451.         onNewIntent(getIntent());
  452.  
  453.         context = this;
  454.  
  455.        
  456.  
  457.         SharedPreferences sharedpre = getSharedPreferences("show_view",
  458.                 Context.MODE_PRIVATE);
  459.  
  460.         Show_View = sharedpre.getString("show_view", "");
  461.  
  462.        
  463.  
  464.         SharedPreferences Today_Homework = getApplicationContext()
  465.                 .getSharedPreferences("due_today", Context.MODE_PRIVATE);
  466.  
  467.         SharedPreferences counts = getSharedPreferences("due_today",
  468.                 Context.MODE_PRIVATE);
  469.  
  470.         K9counts = counts.getString("inbox", null);
  471.  
  472.         counterss = counts.getString("homeworkdue", null);
  473.  
  474.        
  475.         title_Inbox = new String[] {"Inbox"};
  476.        
  477.         icon_Inbox = new int[] {R.drawable.ic_action_email};
  478.        
  479.         count_Inbox = new String[] {K9counts};
  480.        
  481.         if (Show_View.equals("Homework Due")) {
  482.  
  483.             title = new String[] { "Homework Due", "Schedule",
  484.                     "Options", "Logout" };
  485.  
  486.             icon = new int[] { R.drawable.ic_action_duehomework,
  487.                     R.drawable.ic_action_go_to_today, R.drawable.ic_action_settings,
  488.                     R.drawable.ic_action_logout };
  489.  
  490.             if (counterss == null && counterss.isEmpty()) {
  491.  
  492.                 count = new String[] { "", "", "", "" };
  493.  
  494.             } else {
  495.  
  496.                 count = new String[] { counterss, "", "", "" };
  497.  
  498.             }
  499.  
  500.         } else {
  501.  
  502.             if (counterss == null && counterss.isEmpty()) {
  503.  
  504.                 count = new String[] { "", "", "", "" };
  505.  
  506.             } else {
  507.  
  508.                 count = new String[] { "", counterss,  "", "" };
  509.  
  510.             }
  511.  
  512.             title = new String[] { "Schedule", "Homework Due",
  513.                     "Options", "Logout" };
  514.  
  515.             icon = new int[] { R.drawable.ic_action_go_to_today,
  516.                     R.drawable.ic_action_duehomework,
  517.                      R.drawable.ic_action_settings,
  518.                     R.drawable.ic_action_logout };
  519.  
  520.         }
  521.        
  522.         LayoutInflater inflater = getLayoutInflater();
  523.        
  524.         View header_inbox = (View) inflater.inflate(R.layout.header_inbox, null);
  525.        
  526.         View header_folders = (View) inflater.inflate(R.layout.header_folders, null);
  527.        
  528.         View header_drawer = (View) inflater.inflate(R.layout.header_drawer, null);
  529.        
  530.         mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout);
  531.  
  532.         mDrawerLinear = (LinearLayout) findViewById(R.id.left_drawer);
  533.  
  534.         mDrawerList_Inbox = (ListView) findViewById(R.id.listview_inbox);
  535.  
  536.         mDrawerList = (ListView) findViewById(R.id.listview_drawer);
  537.        
  538.        
  539.        
  540.         mDrawerList_Inbox.addHeaderView(header_inbox, null, false);
  541.        
  542.        
  543.         mListView.addHeaderView(header_folders, null, false);
  544.        
  545.         mDrawerList.addHeaderView(header_drawer, null, false);
  546.        
  547.        
  548.        
  549.         Utility.setListViewHeightBasedOnChildren(mDrawerList);
  550.         Utility.setListViewHeightBasedOnChildren(mDrawerList_Inbox);
  551.         Utility.setListViewHeightBasedOnChildren(mListView);
  552.  
  553.         mDrawerLayout.setDrawerShadow(R.drawable.drawer_shadow,
  554.                 GravityCompat.START);
  555.        
  556.         mMenuAdapter_Inbox = new MenuListAdapter(MessageList.this, title_Inbox, icon_Inbox, count_Inbox);
  557.        
  558.         mDrawerList_Inbox.setAdapter(mMenuAdapter_Inbox);
  559.        
  560.        
  561.        
  562.         mDrawerList_Inbox.setOnItemClickListener(new DrawerItemClickListener_Inbox());
  563.        
  564.        
  565.  
  566.         mMenuAdapter = new MenuListAdapter(MessageList.this, title, icon, count);
  567.  
  568.         mDrawerList.setAdapter(mMenuAdapter);
  569.        
  570.        
  571.        
  572.         mDrawerList.setOnItemClickListener(new DrawerItemClickListener());
  573.  
  574.         if (savedInstanceState == null) {
  575.             selectItem_Inbox(1);
  576.         }
  577.  
  578.         SharedPreferences sharedpref = getSharedPreferences("actionbar_color",
  579.                 Context.MODE_PRIVATE);
  580.  
  581.         if (!sharedpref.contains("actionbar_color")) {
  582.  
  583.             getActionBar().setBackgroundDrawable(
  584.                     new ColorDrawable(Color.parseColor("#03a9f4")));
  585.  
  586.         } else {
  587.  
  588.             actionbar_colors = sharedpref.getString("actionbar_color", null);
  589.  
  590.             getActionBar().setBackgroundDrawable(
  591.                     new ColorDrawable(Color.parseColor(actionbar_colors)));
  592.  
  593.         }
  594.  
  595.         android.app.ActionBar bar = getActionBar();
  596.  
  597.         bar.setIcon(new ColorDrawable(getResources().getColor(
  598.                 android.R.color.transparent)));
  599.         // Enable gesture detection for MessageLists
  600.          //setupGestureDetector(this);
  601.  
  602.         if (!decodeExtras(getIntent())) {
  603.             return;
  604.         }
  605.  
  606.         findFragments();
  607.         initializeDisplayMode(savedInstanceState);
  608.         initializeLayout();
  609.         initializeFragments();
  610.         displayViews();
  611.  
  612.         ChangeLog cl = new ChangeLog(this);
  613.         if (cl.isFirstRun()) {
  614.             cl.getLogDialog().show();
  615.            
  616.         }
  617.     }
  618.  
  619.    
  620.    
  621.  
  622.     public void onNewIntent(Intent intent) {
  623.         setIntent(intent); // onNewIntent doesn't autoset our "internal" intent
  624.  
  625.         mUnreadMessageCount = 0;
  626.         String accountUuid = intent.getStringExtra(EXTRA_ACCOUNT);
  627.         mAccount = Preferences.getPreferences(this).getAccount(accountUuid);
  628.  
  629. //        if (mAccount == null) {
  630. //            // This shouldn't normally happen. But apparently it does. See issue 2261.
  631. //            finish();
  632. //            return;
  633. //        }
  634.  
  635.         if (intent.getBooleanExtra(EXTRA_FROM_SHORTCUT, false) &&
  636.                    !K9.FOLDER_NONE.equals(mAccount.getAutoExpandFolderName())) {
  637.             onOpenFolder(mAccount.getAutoExpandFolderName());
  638.             finish();
  639.         } else {
  640.             initializeActivityView();
  641.         }
  642.        
  643.         if (mFirstBackStackId >= 0) {
  644.             getFragmentManager().popBackStackImmediate(mFirstBackStackId,
  645.                     FragmentManager.POP_BACK_STACK_INCLUSIVE);
  646.             mFirstBackStackId = -1;
  647.         }
  648.         removeMessageListFragment();
  649.         removeMessageViewFragment();
  650.  
  651.         mMessageReference = null;
  652.         mSearch = null;
  653.         mFolderName = null;
  654.  
  655.         if (!decodeExtras(intent)) {
  656.             return;
  657.         }
  658.  
  659.         initializeDisplayMode(null);
  660.         initializeFragments();
  661.         displayViews();
  662.     }
  663.    
  664.     private void initializeActivityView() {
  665.         mAdapter = new FolderListAdapter();
  666.         restorePreviousData();
  667.  
  668.         setListAdapter(mAdapter);
  669.         getListView().setTextFilterEnabled(mAdapter.getFilter() != null); // should never be false but better safe then sorry
  670.     }
  671.  
  672.     @SuppressWarnings("unchecked")
  673.     private void restorePreviousData() {
  674.         final Object previousData = getLastNonConfigurationInstance();
  675.  
  676.         if (previousData != null) {
  677.             mAdapter.mFolders = (ArrayList<FolderInfoHolder>) previousData;
  678.             mAdapter.mFilteredFolders = Collections.unmodifiableList(mAdapter.mFolders);
  679.         }
  680.     }
  681.    
  682.     @Override
  683.     public Object onRetainNonConfigurationInstance() {
  684.         return (mAdapter == null) ? null : mAdapter.mFolders;
  685.     }
  686.    
  687.     @Override
  688.     public boolean onKeyDown(int keyCode, KeyEvent event) {
  689.         //Shortcuts that work no matter what is selected
  690.         switch (keyCode) {
  691.         case KeyEvent.KEYCODE_Q: {
  692.             onAccounts();
  693.             return true;
  694.         }
  695.  
  696.         case KeyEvent.KEYCODE_S: {
  697.             onEditAccount();
  698.             return true;
  699.         }
  700.  
  701.         case KeyEvent.KEYCODE_H: {
  702.             Toast toast = Toast.makeText(this, R.string.folder_list_help_key, Toast.LENGTH_LONG);
  703.             toast.show();
  704.             return true;
  705.         }
  706.  
  707.         case KeyEvent.KEYCODE_1: {
  708.             setDisplayMode(FolderMode.FIRST_CLASS);
  709.             return true;
  710.         }
  711.         case KeyEvent.KEYCODE_2: {
  712.             setDisplayMode(FolderMode.FIRST_AND_SECOND_CLASS);
  713.             return true;
  714.         }
  715.         case KeyEvent.KEYCODE_3: {
  716.             setDisplayMode(FolderMode.NOT_SECOND_CLASS);
  717.             return true;
  718.         }
  719.         case KeyEvent.KEYCODE_4: {
  720.             setDisplayMode(FolderMode.ALL);
  721.             return true;
  722.         }
  723.         }//switch
  724.  
  725.  
  726.         return super.onKeyDown(keyCode, event);
  727.     }//onKeyDown
  728.  
  729.     private void setDisplayMode(FolderMode newMode) {
  730.         mAccount.setFolderDisplayMode(newMode);
  731.         mAccount.save(Preferences.getPreferences(this));
  732.         if (mAccount.getFolderPushMode() != FolderMode.NONE) {
  733.             MailService.actionRestartPushers(this, null);
  734.         }
  735.         mAdapter.getFilter().filter(null);
  736.         onRefresh(false);
  737.     }
  738.  
  739.  
  740.     private void onRefresh(final boolean forceRemote) {
  741.  
  742.         MessagingController.getInstance(getApplication()).listFolders(mAccount, forceRemote, mAdapter.mListener);
  743.  
  744.     }
  745.  
  746.     private void onEditPrefs() {
  747.         Prefs.actionPrefs(this);
  748.     }
  749.     private void onEditAccount() {
  750.         AccountSettings.actionSettings(this, mAccount);
  751.     }
  752.  
  753.     private void onAccounts() {
  754.         Accounts.listAccounts(this);
  755.         finish();
  756.     }
  757.  
  758.     private void onEmptyTrash(final Account account) {
  759.         mHandler.dataChanged();
  760.  
  761.         MessagingController.getInstance(getApplication()).emptyTrash(account, null);
  762.     }
  763.  
  764.     private void onClearFolder(Account account, String folderName) {
  765.         // There has to be a cheaper way to get at the localFolder object than this
  766.         LocalFolder localFolder = null;
  767.         try {
  768.             if (account == null || folderName == null || !account.isAvailable(MessageList.this)) {
  769.                 Log.i(K9.LOG_TAG, "not clear folder of unavailable account");
  770.                 return;
  771.             }
  772.             localFolder = account.getLocalStore().getFolder(folderName);
  773.             localFolder.open(Folder.OPEN_MODE_RW);
  774.             localFolder.clearAllMessages();
  775.         } catch (Exception e) {
  776.             Log.e(K9.LOG_TAG, "Exception while clearing folder", e);
  777.         } finally {
  778.             if (localFolder != null) {
  779.                 localFolder.close();
  780.             }
  781.         }
  782.  
  783.         onRefresh(!REFRESH_REMOTE);
  784.     }
  785.  
  786.  
  787.  
  788.  
  789.  
  790.     private void sendMail(Account account) {
  791.         MessagingController.getInstance(getApplication()).sendPendingMessages(account, mAdapter.mListener);
  792.     }
  793.    
  794.     @Override
  795.     public boolean onSearchRequested() {
  796.          Bundle appData = new Bundle();
  797.          appData.putString(MessageList.EXTRA_SEARCH_ACCOUNT, mAccount.getUuid());
  798.          startSearch(null, false, appData, false);
  799.          return true;
  800.      }
  801.  
  802.     private void onOpenFolder(String folder) {
  803.         LocalSearch search = new LocalSearch(folder);
  804.         search.addAccountUuid(mAccount.getUuid());
  805.         search.addAllowedFolder(folder);
  806.         MessageList.actionDisplaySearch(this, search, false, false);
  807.     }
  808.  
  809.     private void onCompact(Account account) {
  810.         mHandler.workingAccount(R.string.compacting_account);
  811.         MessagingController.getInstance(getApplication()).compact(account, null);
  812.     }
  813.  
  814.     @Override public boolean onContextItemSelected(android.view.MenuItem item) {
  815.         AdapterContextMenuInfo info = (AdapterContextMenuInfo) item .getMenuInfo();
  816.         FolderInfoHolder folder = (FolderInfoHolder) mAdapter.getItem(info.position);
  817.  
  818.         switch (item.getItemId()) {
  819.         case R.id.clear_local_folder:
  820.             onClearFolder(mAccount, folder.name);
  821.             break;
  822.         case R.id.refresh_folder:
  823.             checkMail(folder);
  824.             break;
  825.         case R.id.folder_settings:
  826.             FolderSettings.actionSettings(this, mAccount, folder.name);
  827.             break;
  828.         }
  829.  
  830.         return super.onContextItemSelected(item);
  831.     }
  832.  
  833.     @Override public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
  834.         super.onCreateContextMenu(menu, v, menuInfo);
  835.         AdapterContextMenuInfo info = (AdapterContextMenuInfo) menuInfo;
  836.         getMenuInflater().inflate(R.menu.folder_context, menu);
  837.  
  838.         FolderInfoHolder folder = (FolderInfoHolder) mAdapter.getItem(info.position);
  839.  
  840.         menu.setHeaderTitle(folder.displayName);
  841.     }
  842.  
  843.     class FolderListAdapter extends BaseAdapter implements Filterable {
  844.         private ArrayList<FolderInfoHolder> mFolders = new ArrayList<FolderInfoHolder>();
  845.         private List<FolderInfoHolder> mFilteredFolders = Collections.unmodifiableList(mFolders);
  846.         private Filter mFilter = new FolderListFilter();
  847.  
  848.         public Object getItem(long position) {
  849.             return getItem((int)position);
  850.         }
  851.  
  852.         public Object getItem(int position) {
  853.             return mFilteredFolders.get(position);
  854.         }
  855.  
  856.  
  857.         public long getItemId(int position) {
  858.             return mFilteredFolders.get(position).folder.getName().hashCode() ;
  859.         }
  860.  
  861.         public int getCount() {
  862.             return mFilteredFolders.size();
  863.         }
  864.  
  865.         @Override
  866.         public boolean isEnabled(int item) {
  867.             return true;
  868.         }
  869.  
  870.         @Override
  871.         public boolean areAllItemsEnabled() {
  872.             return true;
  873.         }
  874.  
  875.         private ActivityListener mListener = new ActivityListener() {
  876.             @Override
  877.             public void informUserOfStatus() {
  878.                
  879.                 mHandler.dataChanged();
  880.             }
  881.             @Override
  882.             public void accountStatusChanged(BaseAccount account, AccountStats stats) {
  883.                 if (!account.equals(mAccount)) {
  884.                     return;
  885.                 }
  886.                 if (stats == null) {
  887.                     return;
  888.                 }
  889.                 mUnreadMessageCount = stats.unreadMessageCount;
  890.                
  891.             }
  892.  
  893.             @Override
  894.             public void listFoldersStarted(Account account) {
  895.                 if (account.equals(mAccount)) {
  896.                     mHandler.progress(true);
  897.                 }
  898.                 super.listFoldersStarted(account);
  899.  
  900.             }
  901.  
  902.             @Override
  903.             public void listFoldersFailed(Account account, String message) {
  904.                 if (account.equals(mAccount)) {
  905.  
  906.                     mHandler.progress(false);
  907.                 }
  908.                 super.listFoldersFailed(account, message);
  909.             }
  910.  
  911.             @Override
  912.             public void listFoldersFinished(Account account) {
  913.                 if (account.equals(mAccount)) {
  914.  
  915.                     mHandler.progress(false);
  916.                     MessagingController.getInstance(getApplication()).refreshListener(mAdapter.mListener);
  917.                     mHandler.dataChanged();
  918.                 }
  919.                 super.listFoldersFinished(account);
  920.  
  921.             }
  922.  
  923.             @Override
  924.             public void listFolders(Account account, Folder[] folders) {
  925.                 if (account.equals(mAccount)) {
  926.  
  927.                     List<FolderInfoHolder> newFolders = new LinkedList<FolderInfoHolder>();
  928.                     List<FolderInfoHolder> topFolders = new LinkedList<FolderInfoHolder>();
  929.  
  930.                     Account.FolderMode aMode = account.getFolderDisplayMode();
  931.                     Preferences prefs = Preferences.getPreferences(getApplication().getApplicationContext());
  932.                     for (Folder folder : folders) {
  933.                         try {
  934.                             folder.refresh(prefs);
  935.  
  936.                             Folder.FolderClass fMode = folder.getDisplayClass();
  937.  
  938.                             if ((aMode == Account.FolderMode.FIRST_CLASS && fMode != Folder.FolderClass.FIRST_CLASS)
  939.                                     || (aMode == Account.FolderMode.FIRST_AND_SECOND_CLASS &&
  940.                                         fMode != Folder.FolderClass.FIRST_CLASS &&
  941.                                         fMode != Folder.FolderClass.SECOND_CLASS)
  942.                             || (aMode == Account.FolderMode.NOT_SECOND_CLASS && fMode == Folder.FolderClass.SECOND_CLASS)) {
  943.                                 continue;
  944.                             }
  945.                         } catch (MessagingException me) {
  946.                             Log.e(K9.LOG_TAG, "Couldn't get prefs to check for displayability of folder " + folder.getName(), me);
  947.                         }
  948.  
  949.                         FolderInfoHolder holder = null;
  950.  
  951.                         int folderIndex = getFolderIndex(folder.getName());
  952.                         if (folderIndex >= 0) {
  953.                             holder = (FolderInfoHolder) getItem(folderIndex);
  954.                         }
  955.  
  956.                         if (holder == null) {
  957.                             holder = new FolderInfoHolder(context, folder, mAccount, -1);
  958.                         } else {
  959.                             holder.populate(context, folder, mAccount, -1);
  960.  
  961.                         }
  962.                         if (folder.isInTopGroup()) {
  963.                             topFolders.add(holder);
  964.                         } else {
  965.                             newFolders.add(holder);
  966.                         }
  967.                     }
  968.                     Collections.sort(newFolders);
  969.                     Collections.sort(topFolders);
  970.                     topFolders.addAll(newFolders);
  971.                     mHandler.newFolders(topFolders);
  972.                 }
  973.                 super.listFolders(account, folders);
  974.             }
  975.  
  976.             @Override
  977.             public void synchronizeMailboxStarted(Account account, String folder) {
  978.                 super.synchronizeMailboxStarted(account, folder);
  979.                 if (account.equals(mAccount)) {
  980.  
  981.                     mHandler.progress(true);
  982.                     mHandler.folderLoading(folder, true);
  983.                     mHandler.dataChanged();
  984.                 }
  985.  
  986.             }
  987.  
  988.             @Override
  989.             public void synchronizeMailboxFinished(Account account, String folder, int totalMessagesInMailbox, int numNewMessages) {
  990.                 super.synchronizeMailboxFinished(account, folder, totalMessagesInMailbox, numNewMessages);
  991.                 if (account.equals(mAccount)) {
  992.                     mHandler.progress(false);
  993.                     mHandler.folderLoading(folder, false);
  994.  
  995.                     refreshFolder(account, folder);
  996.                 }
  997.  
  998.             }
  999.  
  1000.             private void refreshFolder(Account account, String folderName) {
  1001.                 // There has to be a cheaper way to get at the localFolder object than this
  1002.                 Folder localFolder = null;
  1003.                 try {
  1004.                     if (account != null && folderName != null) {
  1005.                         if (!account.isAvailable(MessageList.this)) {
  1006.                             Log.i(K9.LOG_TAG, "not refreshing folder of unavailable account");
  1007.                             return;
  1008.                         }
  1009.                         localFolder = account.getLocalStore().getFolder(folderName);
  1010.                         FolderInfoHolder folderHolder = getFolder(folderName);
  1011.                         if (folderHolder != null) {
  1012.                             folderHolder.populate(context, localFolder, mAccount, -1);
  1013.                             folderHolder.flaggedMessageCount = -1;
  1014.  
  1015.                             mHandler.dataChanged();
  1016.                         }
  1017.                     }
  1018.                 } catch (Exception e) {
  1019.                     Log.e(K9.LOG_TAG, "Exception while populating folder", e);
  1020.                 } finally {
  1021.                     if (localFolder != null) {
  1022.                         localFolder.close();
  1023.                     }
  1024.                 }
  1025.  
  1026.             }
  1027.  
  1028.             @Override
  1029.             public void synchronizeMailboxFailed(Account account, String folder, String message) {
  1030.                 super.synchronizeMailboxFailed(account, folder, message);
  1031.                 if (!account.equals(mAccount)) {
  1032.                     return;
  1033.                 }
  1034.  
  1035.  
  1036.                 mHandler.progress(false);
  1037.  
  1038.                 mHandler.folderLoading(folder, false);
  1039.  
  1040.                 //   String mess = truncateStatus(message);
  1041.  
  1042.                 //   mHandler.folderStatus(folder, mess);
  1043.                 FolderInfoHolder holder = getFolder(folder);
  1044.  
  1045.                 if (holder != null) {
  1046.                     holder.lastChecked = 0;
  1047.                 }
  1048.  
  1049.                 mHandler.dataChanged();
  1050.  
  1051.             }
  1052.  
  1053.             @Override
  1054.             public void setPushActive(Account account, String folderName, boolean enabled) {
  1055.                 if (!account.equals(mAccount)) {
  1056.                     return;
  1057.                 }
  1058.                 FolderInfoHolder holder = getFolder(folderName);
  1059.  
  1060.                 if (holder != null) {
  1061.                     holder.pushActive = enabled;
  1062.  
  1063.                     mHandler.dataChanged();
  1064.                 }
  1065.             }
  1066.  
  1067.  
  1068.             @Override
  1069.             public void messageDeleted(Account account, String folder, Message message) {
  1070.                 synchronizeMailboxRemovedMessage(account, folder, message);
  1071.             }
  1072.  
  1073.             @Override
  1074.             public void emptyTrashCompleted(Account account) {
  1075.                 if (account.equals(mAccount)) {
  1076.                     refreshFolder(account, mAccount.getTrashFolderName());
  1077.                 }
  1078.             }
  1079.  
  1080.             @Override
  1081.             public void folderStatusChanged(Account account, String folderName, int unreadMessageCount) {
  1082.                 if (account.equals(mAccount)) {
  1083.                     refreshFolder(account, folderName);
  1084.                     informUserOfStatus();
  1085.                 }
  1086.             }
  1087.  
  1088.             @Override
  1089.             public void sendPendingMessagesCompleted(Account account) {
  1090.                 super.sendPendingMessagesCompleted(account);
  1091.                 if (account.equals(mAccount)) {
  1092.                     refreshFolder(account, mAccount.getOutboxFolderName());
  1093.                 }
  1094.             }
  1095.  
  1096.             @Override
  1097.             public void sendPendingMessagesStarted(Account account) {
  1098.                 super.sendPendingMessagesStarted(account);
  1099.  
  1100.                 if (account.equals(mAccount)) {
  1101.                     mHandler.dataChanged();
  1102.                 }
  1103.             }
  1104.  
  1105.             @Override
  1106.             public void sendPendingMessagesFailed(Account account) {
  1107.                 super.sendPendingMessagesFailed(account);
  1108.                 if (account.equals(mAccount)) {
  1109.                     refreshFolder(account, mAccount.getOutboxFolderName());
  1110.                 }
  1111.             }
  1112.  
  1113.             @Override
  1114.             public void accountSizeChanged(Account account, long oldSize, long newSize) {
  1115.                 if (account.equals(mAccount)) {
  1116.                     mHandler.accountSizeChanged(oldSize, newSize);
  1117.                 }
  1118.             }
  1119.         };
  1120.  
  1121.  
  1122.         public int getFolderIndex(String folder) {
  1123.             FolderInfoHolder searchHolder = new FolderInfoHolder();
  1124.             searchHolder.name = folder;
  1125.             return   mFilteredFolders.indexOf(searchHolder);
  1126.         }
  1127.  
  1128.         public FolderInfoHolder getFolder(String folder) {
  1129.             FolderInfoHolder holder = null;
  1130.  
  1131.             int index = getFolderIndex(folder);
  1132.             if (index >= 0) {
  1133.                 holder = (FolderInfoHolder) getItem(index);
  1134.                 if (holder != null) {
  1135.                     return holder;
  1136.                 }
  1137.             }
  1138.             return null;
  1139.         }
  1140.  
  1141.         public View getView(int position, View convertView, ViewGroup parent) {
  1142.             if (position <= getCount()) {
  1143.                 return  getItemView(position, convertView, parent);
  1144.             } else {
  1145.                 Log.e(K9.LOG_TAG, "getView with illegal positon=" + position
  1146.                       + " called! count is only " + getCount());
  1147.                 return null;
  1148.             }
  1149.         }
  1150.  
  1151.         public View getItemView(int itemPosition, View convertView, ViewGroup parent) {
  1152.             FolderInfoHolder folder = (FolderInfoHolder) getItem(itemPosition);
  1153.             View view;
  1154.             if (convertView != null) {
  1155.                 view = convertView;
  1156.             } else {
  1157.                 view = mInflater.inflate(R.layout.folder_list_item, parent, false);
  1158.             }
  1159.  
  1160.             FolderViewHolder holder = (FolderViewHolder) view.getTag();
  1161.  
  1162.             if (holder == null) {
  1163.                 holder = new FolderViewHolder();
  1164.                 holder.folderName = (TextView) view.findViewById(R.id.folder_name);
  1165.                 holder.newMessageCount = (TextView) view.findViewById(R.id.new_message_count);
  1166.                 holder.flaggedMessageCount = (TextView) view.findViewById(R.id.flagged_message_count);
  1167.                 holder.newMessageCountWrapper = (View) view.findViewById(R.id.new_message_count_wrapper);
  1168.                 holder.flaggedMessageCountWrapper = (View) view.findViewById(R.id.flagged_message_count_wrapper);
  1169.                 holder.newMessageCountIcon = (View) view.findViewById(R.id.new_message_count_icon);
  1170.                 holder.flaggedMessageCountIcon = (View) view.findViewById(R.id.flagged_message_count_icon);
  1171.  
  1172.                 holder.folderStatus = (TextView) view.findViewById(R.id.folder_status);
  1173.                 holder.activeIcons = (RelativeLayout) view.findViewById(R.id.active_icons);
  1174.                 holder.chip = view.findViewById(R.id.chip);
  1175.                 holder.folderListItemLayout = (LinearLayout)view.findViewById(R.id.folder_list_item_layout);
  1176.                 holder.rawFolderName = folder.name;
  1177.  
  1178.                 view.setTag(holder);
  1179.             }
  1180.  
  1181.             if (folder == null) {
  1182.                 return view;
  1183.             }
  1184.  
  1185.             final String folderStatus;
  1186.  
  1187.             if (folder.loading) {
  1188.                 folderStatus = getString(R.string.status_loading);
  1189.             } else if (folder.status != null) {
  1190.                 folderStatus = folder.status;
  1191.             } else if (folder.lastChecked != 0) {
  1192.                 long now = System.currentTimeMillis();
  1193.                 int flags = DateUtils.FORMAT_SHOW_TIME | DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR;
  1194.                 CharSequence formattedDate;
  1195.  
  1196.                 if (Math.abs(now - folder.lastChecked) > DateUtils.WEEK_IN_MILLIS) {
  1197.                     formattedDate = getString(R.string.preposition_for_date,
  1198.                             DateUtils.formatDateTime(context, folder.lastChecked, flags));
  1199.                 } else {
  1200.                     formattedDate = DateUtils.getRelativeTimeSpanString(folder.lastChecked,
  1201.                             now, DateUtils.MINUTE_IN_MILLIS, flags);
  1202.                 }
  1203.  
  1204.                 folderStatus = getString(folder.pushActive
  1205.                         ? R.string.last_refresh_time_format_with_push
  1206.                         : R.string.last_refresh_time_format,
  1207.                         formattedDate);
  1208.             } else {
  1209.                 folderStatus = null;
  1210.             }
  1211.  
  1212.             holder.folderName.setText(folder.displayName);
  1213.             if (folderStatus != null) {
  1214.                 holder.folderStatus.setText(folderStatus);
  1215.                 holder.folderStatus.setVisibility(View.VISIBLE);
  1216.             } else {
  1217.                 holder.folderStatus.setVisibility(View.GONE);
  1218.             }
  1219.  
  1220.             if(folder.unreadMessageCount == -1) {
  1221.                folder.unreadMessageCount = 0;
  1222.                 try {
  1223.                     folder.unreadMessageCount  = folder.folder.getUnreadMessageCount();
  1224.                 } catch (Exception e) {
  1225.                     Log.e(K9.LOG_TAG, "Unable to get unreadMessageCount for " + mAccount.getDescription() + ":"
  1226.                           + folder.name);
  1227.                 }
  1228.             }
  1229.             if (folder.unreadMessageCount > 0) {
  1230.                 holder.newMessageCount.setText(Integer.toString(folder.unreadMessageCount));
  1231.                 holder.newMessageCountWrapper.setOnClickListener(
  1232.                         createUnreadSearch(mAccount, folder));
  1233.                 holder.newMessageCountWrapper.setVisibility(View.VISIBLE);
  1234.                 holder.newMessageCountIcon.setBackgroundDrawable(
  1235.                         mAccount.generateColorChip(false, false, false, false, false).drawable());
  1236.             } else {
  1237.                 holder.newMessageCountWrapper.setVisibility(View.GONE);
  1238.             }
  1239.  
  1240.             if (folder.flaggedMessageCount == -1) {
  1241.                 folder.flaggedMessageCount = 0;
  1242.                 try {
  1243.                     folder.flaggedMessageCount = folder.folder.getFlaggedMessageCount();
  1244.                 } catch (Exception e) {
  1245.                     Log.e(K9.LOG_TAG, "Unable to get flaggedMessageCount for " + mAccount.getDescription() + ":"
  1246.                           + folder.name);
  1247.                 }
  1248.  
  1249.                     }
  1250.  
  1251.             if (K9.messageListStars() && folder.flaggedMessageCount > 0) {
  1252.                 holder.flaggedMessageCount.setText(Integer.toString(folder.flaggedMessageCount));
  1253.                 holder.flaggedMessageCountWrapper.setOnClickListener(
  1254.                         createFlaggedSearch(mAccount, folder));
  1255.                 holder.flaggedMessageCountWrapper.setVisibility(View.VISIBLE);
  1256.                 holder.flaggedMessageCountIcon.setBackgroundDrawable(
  1257.                         mAccount.generateColorChip(false, false, false, false,true).drawable());
  1258.             } else {
  1259.                 holder.flaggedMessageCountWrapper.setVisibility(View.GONE);
  1260.             }
  1261.  
  1262.             holder.activeIcons.setOnClickListener(new OnClickListener() {
  1263.                 public void onClick(View v) {
  1264.                     Toast toast = Toast.makeText(getApplication(), getString(R.string.tap_hint), Toast.LENGTH_SHORT);
  1265.                     toast.show();
  1266.                 }
  1267.             });
  1268.  
  1269.             holder.chip.setBackgroundColor(mAccount.getChipColor());
  1270.  
  1271.  
  1272.             mFontSizes.setViewTextSize(holder.folderName, mFontSizes.getFolderName());
  1273.  
  1274.             if (K9.wrapFolderNames()) {
  1275.                 holder.folderName.setEllipsize(null);
  1276.                 holder.folderName.setSingleLine(false);
  1277.             }
  1278.             else {
  1279.                 holder.folderName.setEllipsize(TruncateAt.START);
  1280.                 holder.folderName.setSingleLine(true);
  1281.             }
  1282.             mFontSizes.setViewTextSize(holder.folderStatus, mFontSizes.getFolderStatus());
  1283.  
  1284.             return view;
  1285.         }
  1286.  
  1287.         private OnClickListener createFlaggedSearch(Account account, FolderInfoHolder folder) {
  1288.             String searchTitle = getString(R.string.search_title,
  1289.                     getString(R.string.message_list_title, account.getDescription(),
  1290.                             folder.displayName),
  1291.                     getString(R.string.flagged_modifier));
  1292.  
  1293.             LocalSearch search = new LocalSearch(searchTitle);
  1294.             search.and(Searchfield.FLAGGED, "1", Attribute.EQUALS);
  1295.  
  1296.             search.addAllowedFolder(folder.name);
  1297.             search.addAccountUuid(account.getUuid());
  1298.  
  1299.             return new FolderClickListener(search);
  1300.         }
  1301.  
  1302.         private OnClickListener createUnreadSearch(Account account, FolderInfoHolder folder) {
  1303.             String searchTitle = getString(R.string.search_title,
  1304.                     getString(R.string.message_list_title, account.getDescription(),
  1305.                             folder.displayName),
  1306.                     getString(R.string.unread_modifier));
  1307.  
  1308.             LocalSearch search = new LocalSearch(searchTitle);
  1309.             search.and(Searchfield.READ, "1", Attribute.NOT_EQUALS);
  1310.  
  1311.             search.addAllowedFolder(folder.name);
  1312.             search.addAccountUuid(account.getUuid());
  1313.  
  1314.             return new FolderClickListener(search);
  1315.         }
  1316.  
  1317.         @Override
  1318.         public boolean hasStableIds() {
  1319.             return true;
  1320.         }
  1321.  
  1322.         public boolean isItemSelectable(int position) {
  1323.             return true;
  1324.         }
  1325.  
  1326.         public void setFilter(final Filter filter) {
  1327.             this.mFilter = filter;
  1328.         }
  1329.  
  1330.         public Filter getFilter() {
  1331.             return mFilter;
  1332.         }
  1333.  
  1334.         /**
  1335.          * Filter to search for occurences of the search-expression in any place of the
  1336.          * folder-name instead of doing jsut a prefix-search.
  1337.          *
  1338.          * @author [email protected]
  1339.          */
  1340.         public class FolderListFilter extends Filter {
  1341.             private CharSequence mSearchTerm;
  1342.  
  1343.             public CharSequence getSearchTerm() {
  1344.                 return mSearchTerm;
  1345.             }
  1346.  
  1347.             /**
  1348.              * Do the actual search.
  1349.              * {@inheritDoc}
  1350.              *
  1351.              * @see #publishResults(CharSequence, FilterResults)
  1352.              */
  1353.             @Override
  1354.             protected FilterResults performFiltering(CharSequence searchTerm) {
  1355.                 mSearchTerm = searchTerm;
  1356.                 FilterResults results = new FilterResults();
  1357.  
  1358.                 Locale locale = Locale.getDefault();
  1359.                 if ((searchTerm == null) || (searchTerm.length() == 0)) {
  1360.                     ArrayList<FolderInfoHolder> list = new ArrayList<FolderInfoHolder>(mFolders);
  1361.                     results.values = list;
  1362.                     results.count = list.size();
  1363.                 } else {
  1364.                     final String searchTermString = searchTerm.toString().toLowerCase(locale);
  1365.                     final String[] words = searchTermString.split(" ");
  1366.                     final int wordCount = words.length;
  1367.  
  1368.                     final ArrayList<FolderInfoHolder> newValues = new ArrayList<FolderInfoHolder>();
  1369.  
  1370.                     for (final FolderInfoHolder value : mFolders) {
  1371.                         if (value.displayName == null) {
  1372.                             continue;
  1373.                         }
  1374.                         final String valueText = value.displayName.toLowerCase(locale);
  1375.  
  1376.                         for (int k = 0; k < wordCount; k++) {
  1377.                             if (valueText.contains(words[k])) {
  1378.                                 newValues.add(value);
  1379.                                 break;
  1380.                             }
  1381.                         }
  1382.                     }
  1383.  
  1384.                     results.values = newValues;
  1385.                     results.count = newValues.size();
  1386.                 }
  1387.  
  1388.                 return results;
  1389.             }
  1390.  
  1391.             /**
  1392.              * Publish the results to the user-interface.
  1393.              * {@inheritDoc}
  1394.              */
  1395.             @SuppressWarnings("unchecked")
  1396.             @Override
  1397.             protected void publishResults(CharSequence constraint, FilterResults results) {
  1398.                 //noinspection unchecked
  1399.                 mFilteredFolders = Collections.unmodifiableList((ArrayList<FolderInfoHolder>) results.values);
  1400.                 // Send notification that the data set changed now
  1401.                 notifyDataSetChanged();
  1402.             }
  1403.         }
  1404.     }
  1405.  
  1406.     static class FolderViewHolder {
  1407.         public TextView folderName;
  1408.  
  1409.         public TextView folderStatus;
  1410.  
  1411.         public TextView newMessageCount;
  1412.         public TextView flaggedMessageCount;
  1413.         public View newMessageCountIcon;
  1414.         public View flaggedMessageCountIcon;
  1415.         public View newMessageCountWrapper;
  1416.         public View flaggedMessageCountWrapper;
  1417.  
  1418.         public RelativeLayout activeIcons;
  1419.         public String rawFolderName;
  1420.         public View chip;
  1421.         public LinearLayout folderListItemLayout;
  1422.     }
  1423.  
  1424.     private class FolderClickListener implements OnClickListener {
  1425.  
  1426.         final LocalSearch search;
  1427.  
  1428.         FolderClickListener(LocalSearch search) {
  1429.             this.search = search;
  1430.         }
  1431.  
  1432.         @Override
  1433.         public void onClick(View v) {
  1434.             MessageList.actionDisplaySearch(MessageList.this, search, true, false);
  1435.         }
  1436.     }
  1437.    
  1438.    
  1439.  
  1440.     /**
  1441.      * Get references to existing fragments if the activity was restarted.
  1442.      */
  1443.     private void findFragments() {
  1444.         FragmentManager fragmentManager = getFragmentManager();
  1445.         mMessageListFragment = (MessageListFragment) fragmentManager
  1446.                 .findFragmentById(R.id.message_list_container);
  1447.         mMessageViewFragment = (MessageViewFragment) fragmentManager
  1448.                 .findFragmentById(R.id.message_view_container);
  1449.     }
  1450.  
  1451.     /**
  1452.      * Create fragment instances if necessary.
  1453.      *
  1454.      * @see #findFragments()
  1455.      */
  1456.     private void initializeFragments() {
  1457.         FragmentManager fragmentManager = getFragmentManager();
  1458.         fragmentManager.addOnBackStackChangedListener(this);
  1459.  
  1460.         boolean hasMessageListFragment = (mMessageListFragment != null);
  1461.  
  1462.         if (!hasMessageListFragment) {
  1463.             FragmentTransaction ft = fragmentManager.beginTransaction();
  1464.             mMessageListFragment = MessageListFragment.newInstance(mSearch,
  1465.                     false, (K9.isThreadedViewEnabled() && !mNoThreading));
  1466.             ft.add(R.id.message_list_container, mMessageListFragment);
  1467.             ft.commit();
  1468.         }
  1469.  
  1470.         // Check if the fragment wasn't restarted and has a MessageReference in
  1471.         // the arguments. If
  1472.         // so, open the referenced message.
  1473.         if (!hasMessageListFragment && mMessageViewFragment == null
  1474.                 && mMessageReference != null) {
  1475.             openMessage(mMessageReference);
  1476.         }
  1477.     }
  1478.  
  1479.     /**
  1480.      * Set the initial display mode (message list, message view, or split view).
  1481.      *
  1482.      * <p>
  1483.      * <strong>Note:</strong> This method has to be called after
  1484.      * {@link #findFragments()} because the result depends on the availability
  1485.      * of a {@link MessageViewFragment} instance.
  1486.      * </p>
  1487.      *
  1488.      * @param savedInstanceState
  1489.      *            The saved instance state that was passed to the activity as
  1490.      *            argument to {@link #onCreate(Bundle)}. May be {@code null}.
  1491.      */
  1492.     private void initializeDisplayMode(Bundle savedInstanceState) {
  1493.         if (useSplitView()) {
  1494.             mDisplayMode = DisplayMode.SPLIT_VIEW;
  1495.             return;
  1496.         }
  1497.  
  1498.         if (savedInstanceState != null) {
  1499.             DisplayMode savedDisplayMode = (DisplayMode) savedInstanceState
  1500.                     .getSerializable(STATE_DISPLAY_MODE);
  1501.             if (savedDisplayMode != DisplayMode.SPLIT_VIEW) {
  1502.                 mDisplayMode = savedDisplayMode;
  1503.                 return;
  1504.             }
  1505.         }
  1506.  
  1507.         if (mMessageViewFragment != null || mMessageReference != null) {
  1508.             mDisplayMode = DisplayMode.MESSAGE_VIEW;
  1509.         } else {
  1510.             mDisplayMode = DisplayMode.MESSAGE_LIST;
  1511.         }
  1512.     }
  1513.  
  1514.     private boolean useSplitView() {
  1515.         SplitViewMode splitViewMode = K9.getSplitViewMode();
  1516.         int orientation = getResources().getConfiguration().orientation;
  1517.  
  1518.         return (splitViewMode == SplitViewMode.ALWAYS || (splitViewMode == SplitViewMode.WHEN_IN_LANDSCAPE && orientation == Configuration.ORIENTATION_LANDSCAPE));
  1519.     }
  1520.  
  1521.     private void initializeLayout() {
  1522.         mMessageViewContainer = (ViewGroup) findViewById(R.id.message_view_container);
  1523.         mMessageViewPlaceHolder = getLayoutInflater().inflate(
  1524.                 R.layout.empty_message_view, null);
  1525.     }
  1526.  
  1527.     private void displayViews() {
  1528.         switch (mDisplayMode) {
  1529.         case MESSAGE_LIST: {
  1530.             showMessageList();
  1531.             break;
  1532.         }
  1533.         case MESSAGE_VIEW: {
  1534.             showMessageView();
  1535.             break;
  1536.         }
  1537.         case SPLIT_VIEW: {
  1538.             mMessageListWasDisplayed = true;
  1539.             if (mMessageViewFragment == null) {
  1540.                 showMessageViewPlaceHolder();
  1541.             } else {
  1542.                 MessageReference activeMessage = mMessageViewFragment
  1543.                         .getMessageReference();
  1544.                 if (activeMessage != null) {
  1545.                     mMessageListFragment.setActiveMessage(activeMessage);
  1546.                 }
  1547.             }
  1548.             break;
  1549.         }
  1550.         }
  1551.     }
  1552.  
  1553.     private boolean decodeExtras(Intent intent) {
  1554.         String action = intent.getAction();
  1555.         if (Intent.ACTION_VIEW.equals(action) && intent.getData() != null) {
  1556.             Uri uri = intent.getData();
  1557.             List<String> segmentList = uri.getPathSegments();
  1558.  
  1559.             String accountId = segmentList.get(0);
  1560.             Collection<Account> accounts = Preferences.getPreferences(this)
  1561.                     .getAvailableAccounts();
  1562.             for (Account account : accounts) {
  1563.                 if (String.valueOf(account.getAccountNumber())
  1564.                         .equals(accountId)) {
  1565.                     mMessageReference = new MessageReference();
  1566.                     mMessageReference.accountUuid = account.getUuid();
  1567.                     mMessageReference.folderName = segmentList.get(1);
  1568.                     mMessageReference.uid = segmentList.get(2);
  1569.                     break;
  1570.                 }
  1571.             }
  1572.         } else if (ACTION_SHORTCUT.equals(action)) {
  1573.             // Handle shortcut intents
  1574.             String specialFolder = intent.getStringExtra(EXTRA_SPECIAL_FOLDER);
  1575.             if (SearchAccount.UNIFIED_INBOX.equals(specialFolder)) {
  1576.                 mSearch = SearchAccount.createUnifiedInboxAccount(this)
  1577.                         .getRelatedSearch();
  1578.             } else if (SearchAccount.ALL_MESSAGES.equals(specialFolder)) {
  1579.                 mSearch = SearchAccount.createAllMessagesAccount(this)
  1580.                         .getRelatedSearch();
  1581.             }
  1582.         } else if (intent.getStringExtra(SearchManager.QUERY) != null) {
  1583.             // check if this intent comes from the system search ( remote )
  1584.             if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
  1585.                 // Query was received from Search Dialog
  1586.                 String query = intent.getStringExtra(SearchManager.QUERY);
  1587.  
  1588.                 mSearch = new LocalSearch(getString(R.string.search_results));
  1589.                 mSearch.setManualSearch(true);
  1590.                 mNoThreading = true;
  1591.  
  1592.                 mSearch.or(new SearchCondition(Searchfield.SENDER,
  1593.                         Attribute.CONTAINS, query));
  1594.                 mSearch.or(new SearchCondition(Searchfield.SUBJECT,
  1595.                         Attribute.CONTAINS, query));
  1596.                 mSearch.or(new SearchCondition(Searchfield.MESSAGE_CONTENTS,
  1597.                         Attribute.CONTAINS, query));
  1598.  
  1599.                 Bundle appData = intent.getBundleExtra(SearchManager.APP_DATA);
  1600.                 if (appData != null) {
  1601.                     mSearch.addAccountUuid(appData
  1602.                             .getString(EXTRA_SEARCH_ACCOUNT));
  1603.                     // searches started from a folder list activity will provide
  1604.                     // an account, but no folder
  1605.                     if (appData.getString(EXTRA_SEARCH_FOLDER) != null) {
  1606.                         mSearch.addAllowedFolder(appData
  1607.                                 .getString(EXTRA_SEARCH_FOLDER));
  1608.                     }
  1609.                 } else {
  1610.                     mSearch.addAccountUuid(LocalSearch.ALL_ACCOUNTS);
  1611.                 }
  1612.             }
  1613.         } else {
  1614.             // regular LocalSearch object was passed
  1615.             mSearch = intent.getParcelableExtra(EXTRA_SEARCH);
  1616.             mNoThreading = intent.getBooleanExtra(EXTRA_NO_THREADING, false);
  1617.         }
  1618.  
  1619.         if (mMessageReference == null) {
  1620.             mMessageReference = intent
  1621.                     .getParcelableExtra(EXTRA_MESSAGE_REFERENCE);
  1622.         }
  1623.  
  1624.         if (mMessageReference != null) {
  1625.             mSearch = new LocalSearch();
  1626.             mSearch.addAccountUuid(mMessageReference.accountUuid);
  1627.             mSearch.addAllowedFolder(mMessageReference.folderName);
  1628.         }
  1629.  
  1630.         if (mSearch == null) {
  1631.             // We've most likely been started by an old unread widget
  1632.             String accountUuid = intent.getStringExtra("account");
  1633.             String folderName = intent.getStringExtra("folder");
  1634.  
  1635.             mSearch = new LocalSearch(folderName);
  1636.             mSearch.addAccountUuid((accountUuid == null) ? "invalid"
  1637.                     : accountUuid);
  1638.             if (folderName != null) {
  1639.                 mSearch.addAllowedFolder(folderName);
  1640.             }
  1641.         }
  1642.  
  1643.         Preferences prefs = Preferences.getPreferences(getApplicationContext());
  1644.  
  1645.         String[] accountUuids = mSearch.getAccountUuids();
  1646.         if (mSearch.searchAllAccounts()) {
  1647.             Account[] accounts = prefs.getAccounts();
  1648.             mSingleAccountMode = (accounts.length == 1);
  1649.             if (mSingleAccountMode) {
  1650.                 mAccount = accounts[0];
  1651.             }
  1652.         } else {
  1653.             mSingleAccountMode = (accountUuids.length == 1);
  1654.             if (mSingleAccountMode) {
  1655.                 mAccount = prefs.getAccount(accountUuids[0]);
  1656.             }
  1657.         }
  1658.         mSingleFolderMode = mSingleAccountMode
  1659.                 && (mSearch.getFolderNames().size() == 1);
  1660.  
  1661.         if (mSingleAccountMode
  1662.                 && (mAccount == null || !mAccount.isAvailable(this))) {
  1663.             Log.i(K9.LOG_TAG, "not opening MessageList of unavailable account");
  1664.             onAccountUnavailable();
  1665.             return false;
  1666.         }
  1667.  
  1668.         if (mSingleFolderMode) {
  1669.             mFolderName = mSearch.getFolderNames().get(0);
  1670.         }
  1671.  
  1672.         // now we know if we are in single account mode and need a subtitle
  1673.         mActionBarSubTitle.setVisibility((!mSingleFolderMode) ? View.GONE
  1674.                 : View.VISIBLE);
  1675.  
  1676.         return true;
  1677.     }
  1678.  
  1679.     @Override
  1680.     public void onPause() {
  1681.         super.onPause();
  1682.  
  1683.         StorageManager.getInstance(getApplication()).removeListener(
  1684.                 mStorageListener);
  1685.         MessagingController.getInstance(getApplication()).removeListener(mAdapter.mListener);
  1686.         mAdapter.mListener.onPause(this);
  1687.     }
  1688.  
  1689.     @Override
  1690.     public void onResume() {
  1691.         super.onResume();
  1692.  
  1693.          if (!mAccount.isAvailable(this)) {
  1694.                 Log.i(K9.LOG_TAG, "account unavaliabale, not showing folder-list but account-list");
  1695.                 Accounts.listAccounts(this);
  1696.                 finish();
  1697.                 return;
  1698.             }
  1699.             if (mAdapter == null)
  1700.                 initializeActivityView();
  1701.  
  1702.            
  1703.  
  1704.             MessagingController.getInstance(getApplication()).addListener(mAdapter.mListener);
  1705.             //mAccount.refresh(Preferences.getPreferences(this));
  1706.             MessagingController.getInstance(getApplication()).getAccountStats(this, mAccount, mAdapter.mListener);
  1707.  
  1708.             onRefresh(!REFRESH_REMOTE);
  1709.  
  1710.             MessagingController.getInstance(getApplication()).notifyAccountCancel(this, mAccount);
  1711.             mAdapter.mListener.onResume(this);
  1712.        
  1713.         if (!(this instanceof Search)) {
  1714.             // necessary b/c no guarantee Search.onStop will be called before
  1715.             // MessageList.onResume
  1716.             // when returning from search results
  1717.             Search.setActive(false);
  1718.         }
  1719.  
  1720.         if (mAccount != null && !mAccount.isAvailable(this)) {
  1721.             onAccountUnavailable();
  1722.             return;
  1723.         }
  1724.         StorageManager.getInstance(getApplication()).addListener(
  1725.                 mStorageListener);
  1726.     }
  1727.  
  1728.     @Override
  1729.     public void onSaveInstanceState(Bundle outState) {
  1730.         super.onSaveInstanceState(outState);
  1731.  
  1732.         outState.putSerializable(STATE_DISPLAY_MODE, mDisplayMode);
  1733.         outState.putBoolean(STATE_MESSAGE_LIST_WAS_DISPLAYED,
  1734.                 mMessageListWasDisplayed);
  1735.     }
  1736.  
  1737.    
  1738.    
  1739.    
  1740.     @Override
  1741.     public void onRestoreInstanceState(Bundle savedInstanceState) {
  1742.         mMessageListWasDisplayed = savedInstanceState
  1743.                 .getBoolean(STATE_MESSAGE_LIST_WAS_DISPLAYED);
  1744.     }
  1745.  
  1746.     private void initializeActionBar() {
  1747.         mActionBar = getActionBar();
  1748.  
  1749.         mActionBar.setDisplayShowCustomEnabled(true);
  1750.         mActionBar.setCustomView(R.layout.actionbar_custom);
  1751.  
  1752.         View customView = mActionBar.getCustomView();
  1753.         mActionBarMessageList = customView
  1754.                 .findViewById(R.id.actionbar_message_list);
  1755.         mActionBarMessageView = customView
  1756.                 .findViewById(R.id.actionbar_message_view);
  1757.         mActionBarSubject = (MessageTitleView) customView
  1758.                 .findViewById(R.id.message_title_view);
  1759.         mActionBarTitle = (TextView) customView
  1760.                 .findViewById(R.id.actionbar_title_first);
  1761.         mActionBarSubTitle = (TextView) customView
  1762.                 .findViewById(R.id.actionbar_title_sub);
  1763.         mActionBarUnread = (TextView) customView
  1764.                 .findViewById(R.id.actionbar_unread_count);
  1765.         mActionBarProgress = (ProgressBar) customView
  1766.                 .findViewById(R.id.actionbar_progress);
  1767.         mActionButtonIndeterminateProgress = getLayoutInflater().inflate(
  1768.                 R.layout.actionbar_indeterminate_progress_actionview, null);
  1769.  
  1770.         mActionBar.setDisplayHomeAsUpEnabled(true);
  1771.     }
  1772.  
  1773.     public void setupGestureDetector(OnSwipeGestureListener listener) {
  1774.         mBase.setupGestureDetector(listener);
  1775.     }
  1776.  
  1777.     @Override
  1778.     public boolean dispatchKeyEvent(KeyEvent event) {
  1779.         boolean ret = false;
  1780.         if (KeyEvent.ACTION_DOWN == event.getAction()) {
  1781.             ret = onCustomKeyDown(event.getKeyCode(), event);
  1782.         }
  1783.         if (!ret) {
  1784.             ret = super.dispatchKeyEvent(event);
  1785.         }
  1786.         return ret;
  1787.     }
  1788.  
  1789.     @Override
  1790.     public void onBackPressed() {
  1791.         if (mDisplayMode == DisplayMode.MESSAGE_VIEW
  1792.                 && mMessageListWasDisplayed) {
  1793.             showMessageList();
  1794.         } else {
  1795.             super.onBackPressed();
  1796.         }
  1797.     }
  1798.  
  1799.     /**
  1800.      * Handle hotkeys
  1801.      *
  1802.      * <p>
  1803.      * This method is called by {@link #dispatchKeyEvent(KeyEvent)} before any
  1804.      * view had the chance to consume this key event.
  1805.      * </p>
  1806.      *
  1807.      * @param keyCode
  1808.      *            The value in {@code event.getKeyCode()}.
  1809.      * @param event
  1810.      *            Description of the key event.
  1811.      *
  1812.      * @return {@code true} if this event was consumed.
  1813.      */
  1814.     public boolean onCustomKeyDown(final int keyCode, final KeyEvent event) {
  1815.         switch (keyCode) {
  1816.         case KeyEvent.KEYCODE_VOLUME_UP: {
  1817.             if (mMessageViewFragment != null
  1818.                     && mDisplayMode != DisplayMode.MESSAGE_LIST
  1819.                     && K9.useVolumeKeysForNavigationEnabled()) {
  1820.                 showPreviousMessage();
  1821.                 return true;
  1822.             } else if (mDisplayMode != DisplayMode.MESSAGE_VIEW
  1823.                     && K9.useVolumeKeysForListNavigationEnabled()) {
  1824.                 mMessageListFragment.onMoveUp();
  1825.                 return true;
  1826.             }
  1827.  
  1828.             break;
  1829.         }
  1830.         case KeyEvent.KEYCODE_VOLUME_DOWN: {
  1831.             if (mMessageViewFragment != null
  1832.                     && mDisplayMode != DisplayMode.MESSAGE_LIST
  1833.                     && K9.useVolumeKeysForNavigationEnabled()) {
  1834.                 showNextMessage();
  1835.                 return true;
  1836.             } else if (mDisplayMode != DisplayMode.MESSAGE_VIEW
  1837.                     && K9.useVolumeKeysForListNavigationEnabled()) {
  1838.                 mMessageListFragment.onMoveDown();
  1839.                 return true;
  1840.             }
  1841.  
  1842.             break;
  1843.         }
  1844.         case KeyEvent.KEYCODE_C: {
  1845.             mMessageListFragment.onCompose();
  1846.             return true;
  1847.         }
  1848.         case KeyEvent.KEYCODE_Q: {
  1849.             if (mMessageListFragment != null
  1850.                     && mMessageListFragment.isSingleAccountMode()) {
  1851.                 onShowFolderList();
  1852.             }
  1853.             return true;
  1854.         }
  1855.         case KeyEvent.KEYCODE_O: {
  1856.             mMessageListFragment.onCycleSort();
  1857.             return true;
  1858.         }
  1859.         case KeyEvent.KEYCODE_I: {
  1860.             mMessageListFragment.onReverseSort();
  1861.             return true;
  1862.         }
  1863.         case KeyEvent.KEYCODE_DEL:
  1864.         case KeyEvent.KEYCODE_D: {
  1865.             if (mDisplayMode == DisplayMode.MESSAGE_LIST) {
  1866.                 mMessageListFragment.onDelete();
  1867.             } else if (mMessageViewFragment != null) {
  1868.                 mMessageViewFragment.onDelete();
  1869.             }
  1870.             return true;
  1871.         }
  1872.         case KeyEvent.KEYCODE_S: {
  1873.             mMessageListFragment.toggleMessageSelect();
  1874.             return true;
  1875.         }
  1876.         case KeyEvent.KEYCODE_G: {
  1877.             if (mDisplayMode == DisplayMode.MESSAGE_LIST) {
  1878.                 mMessageListFragment.onToggleFlagged();
  1879.             } else if (mMessageViewFragment != null) {
  1880.                 mMessageViewFragment.onToggleFlagged();
  1881.             }
  1882.             return true;
  1883.         }
  1884.         case KeyEvent.KEYCODE_M: {
  1885.             if (mDisplayMode == DisplayMode.MESSAGE_LIST) {
  1886.                 mMessageListFragment.onMove();
  1887.             } else if (mMessageViewFragment != null) {
  1888.                 mMessageViewFragment.onMove();
  1889.             }
  1890.             return true;
  1891.         }
  1892.         case KeyEvent.KEYCODE_V: {
  1893.             if (mDisplayMode == DisplayMode.MESSAGE_LIST) {
  1894.                 mMessageListFragment.onArchive();
  1895.             } else if (mMessageViewFragment != null) {
  1896.                 mMessageViewFragment.onArchive();
  1897.             }
  1898.             return true;
  1899.         }
  1900.         case KeyEvent.KEYCODE_Y: {
  1901.             if (mDisplayMode == DisplayMode.MESSAGE_LIST) {
  1902.                 mMessageListFragment.onCopy();
  1903.             } else if (mMessageViewFragment != null) {
  1904.                 mMessageViewFragment.onCopy();
  1905.             }
  1906.             return true;
  1907.         }
  1908.         case KeyEvent.KEYCODE_Z: {
  1909.             if (mDisplayMode == DisplayMode.MESSAGE_LIST) {
  1910.                 mMessageListFragment.onToggleRead();
  1911.             } else if (mMessageViewFragment != null) {
  1912.                 mMessageViewFragment.onToggleRead();
  1913.             }
  1914.             return true;
  1915.         }
  1916.         case KeyEvent.KEYCODE_F: {
  1917.             if (mMessageViewFragment != null) {
  1918.                 mMessageViewFragment.onForward();
  1919.             }
  1920.             return true;
  1921.         }
  1922.         case KeyEvent.KEYCODE_A: {
  1923.             if (mMessageViewFragment != null) {
  1924.                 mMessageViewFragment.onReplyAll();
  1925.             }
  1926.             return true;
  1927.         }
  1928.         case KeyEvent.KEYCODE_R: {
  1929.             if (mMessageViewFragment != null) {
  1930.                 mMessageViewFragment.onReply();
  1931.             }
  1932.             return true;
  1933.         }
  1934.         case KeyEvent.KEYCODE_J:
  1935.         case KeyEvent.KEYCODE_P: {
  1936.             if (mMessageViewFragment != null) {
  1937.                 showPreviousMessage();
  1938.             }
  1939.             return true;
  1940.         }
  1941.         case KeyEvent.KEYCODE_N:
  1942.         case KeyEvent.KEYCODE_K: {
  1943.             if (mMessageViewFragment != null) {
  1944.                 showNextMessage();
  1945.             }
  1946.             return true;
  1947.         }
  1948.         /*
  1949.          * FIXME case KeyEvent.KEYCODE_Z: { mMessageViewFragment.zoom(event);
  1950.          * return true; }
  1951.          */
  1952.         case KeyEvent.KEYCODE_H: {
  1953.             Toast toast = Toast.makeText(this, R.string.message_list_help_key,
  1954.                     Toast.LENGTH_LONG);
  1955.             toast.show();
  1956.             return true;
  1957.         }
  1958.  
  1959.         }
  1960.  
  1961.         return false;
  1962.     }
  1963.  
  1964.     @Override
  1965.     public boolean onKeyUp(int keyCode, KeyEvent event) {
  1966.         // Swallow these events too to avoid the audible notification of a
  1967.         // volume change
  1968.         if (K9.useVolumeKeysForListNavigationEnabled()) {
  1969.             if ((keyCode == KeyEvent.KEYCODE_VOLUME_UP)
  1970.                     || (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN)) {
  1971.                 if (K9.DEBUG)
  1972.                     Log.v(K9.LOG_TAG, "Swallowed key up.");
  1973.                 return true;
  1974.             }
  1975.         }
  1976.         return super.onKeyUp(keyCode, event);
  1977.     }
  1978.  
  1979.    
  1980.  
  1981.     private void onShowFolderList() {
  1982.         FolderList.actionHandleAccount(this, mAccount);
  1983.         finish();
  1984.     }
  1985.  
  1986.    
  1987.  
  1988.     @Override
  1989.     public boolean onOptionsItemSelected(android.view.MenuItem item) {
  1990.         int itemId = item.getItemId();
  1991.         switch (itemId) {
  1992.         case android.R.id.home: {
  1993.  
  1994.             goBack();
  1995.             return true;
  1996.         }
  1997.         case R.id.compose: {
  1998.             mMessageListFragment.onCompose();
  1999.             return true;
  2000.         }
  2001.         case R.id.toggle_message_view_theme: {
  2002.             onToggleTheme();
  2003.             return true;
  2004.         }
  2005.         // MessageList
  2006.         case R.id.check_mail: {
  2007.             mMessageListFragment.checkMail();
  2008.             return true;
  2009.         }
  2010.         case R.id.set_sort_date: {
  2011.             mMessageListFragment.changeSort(SortType.SORT_DATE);
  2012.             return true;
  2013.         }
  2014.         case R.id.set_sort_arrival: {
  2015.             mMessageListFragment.changeSort(SortType.SORT_ARRIVAL);
  2016.             return true;
  2017.         }
  2018.         case R.id.set_sort_subject: {
  2019.             mMessageListFragment.changeSort(SortType.SORT_SUBJECT);
  2020.             return true;
  2021.         }
  2022.         case R.id.set_sort_sender: {
  2023.             mMessageListFragment.changeSort(SortType.SORT_SENDER);
  2024.             return true;
  2025.         }
  2026.         case R.id.set_sort_flag: {
  2027.             mMessageListFragment.changeSort(SortType.SORT_FLAGGED);
  2028.             return true;
  2029.         }
  2030.         case R.id.set_sort_unread: {
  2031.             mMessageListFragment.changeSort(SortType.SORT_UNREAD);
  2032.             return true;
  2033.         }
  2034.         case R.id.set_sort_attach: {
  2035.             mMessageListFragment.changeSort(SortType.SORT_ATTACHMENT);
  2036.             return true;
  2037.         }
  2038.         case R.id.select_all: {
  2039.             mMessageListFragment.selectAll();
  2040.             return true;
  2041.         }
  2042.         case R.id.app_settings: {
  2043.             onEditPrefs();
  2044.             return true;
  2045.         }
  2046.         case R.id.account_settings: {
  2047.             onEditAccount();
  2048.             return true;
  2049.         }
  2050.         case R.id.search: {
  2051.             mMessageListFragment.onSearchRequested();
  2052.             return true;
  2053.         }
  2054.         case R.id.search_remote: {
  2055.             mMessageListFragment.onRemoteSearch();
  2056.             return true;
  2057.         }
  2058.         case R.id.mark_all_as_read: {
  2059.             mMessageListFragment.markAllAsRead();
  2060.             return true;
  2061.         }
  2062.         case R.id.show_folder_list: {
  2063.             onShowFolderList();
  2064.             return true;
  2065.         }
  2066.         // MessageView
  2067.         case R.id.next_message: {
  2068.             showNextMessage();
  2069.             return true;
  2070.         }
  2071.         case R.id.previous_message: {
  2072.             showPreviousMessage();
  2073.             return true;
  2074.         }
  2075.         case R.id.delete: {
  2076.             mMessageViewFragment.onDelete();
  2077.             return true;
  2078.         }
  2079.         case R.id.reply: {
  2080.             mMessageViewFragment.onReply();
  2081.             return true;
  2082.         }
  2083.         case R.id.reply_all: {
  2084.             mMessageViewFragment.onReplyAll();
  2085.             return true;
  2086.         }
  2087.         case R.id.forward: {
  2088.             mMessageViewFragment.onForward();
  2089.             return true;
  2090.         }
  2091.         case R.id.share: {
  2092.             mMessageViewFragment.onSendAlternate();
  2093.             return true;
  2094.         }
  2095.         case R.id.toggle_unread: {
  2096.             mMessageViewFragment.onToggleRead();
  2097.             return true;
  2098.         }
  2099.         case R.id.archive:
  2100.         case R.id.refile_archive: {
  2101.             mMessageViewFragment.onArchive();
  2102.             return true;
  2103.         }
  2104.         case R.id.spam:
  2105.         case R.id.refile_spam: {
  2106.             mMessageViewFragment.onSpam();
  2107.             return true;
  2108.         }
  2109.         case R.id.move:
  2110.         case R.id.refile_move: {
  2111.             mMessageViewFragment.onMove();
  2112.             return true;
  2113.         }
  2114.         case R.id.copy:
  2115.         case R.id.refile_copy: {
  2116.             mMessageViewFragment.onCopy();
  2117.             return true;
  2118.         }
  2119.         case R.id.select_text: {
  2120.             mMessageViewFragment.onSelectText();
  2121.             return true;
  2122.         }
  2123.         case R.id.show_headers:
  2124.         case R.id.hide_headers: {
  2125.             mMessageViewFragment.onToggleAllHeadersView();
  2126.             updateMenu();
  2127.             return true;
  2128.         }
  2129.         }
  2130.  
  2131.         if (!mSingleFolderMode) {
  2132.             // None of the options after this point are "safe" for search
  2133.             // results
  2134.             // TODO: This is not true for "unread" and "starred" searches in
  2135.             // regular folders
  2136.             return false;
  2137.         }
  2138.  
  2139.         switch (itemId) {
  2140.         case R.id.send_messages: {
  2141.             mMessageListFragment.onSendPendingMessages();
  2142.             return true;
  2143.         }
  2144.         case R.id.folder_settings: {
  2145.             if (mFolderName != null) {
  2146.                 FolderSettings.actionSettings(this, mAccount, mFolderName);
  2147.             }
  2148.             return true;
  2149.         }
  2150.         case R.id.expunge: {
  2151.             mMessageListFragment.onExpunge();
  2152.             return true;
  2153.         }
  2154.         default: {
  2155.             return super.onOptionsItemSelected(item);
  2156.         }
  2157.         }
  2158.     }
  2159.  
  2160.     @Override
  2161.     public boolean onCreateOptionsMenu(android.view.Menu menu) {
  2162.         getMenuInflater().inflate(R.menu.message_list_option, menu);
  2163.         mMenu = menu;
  2164.         mMenuButtonCheckMail = menu.findItem(R.id.check_mail);
  2165.         return true;
  2166.     }
  2167.  
  2168.     public boolean onPrepareOptionsMenu(Menu menu) {
  2169.         configureMenu(menu);
  2170.         return true;
  2171.     }
  2172.  
  2173.     /**
  2174.      * Hide menu items not appropriate for the current context.
  2175.      *
  2176.      * <p>
  2177.      * <strong>Note:</strong> Please adjust the comments in
  2178.      * {@code res/menu/message_list_option.xml} if you change the visibility of
  2179.      * a menu item in this method.
  2180.      * </p>
  2181.      *
  2182.      * @param mMenu2
  2183.      *            The {@link Menu} instance that should be modified. May be
  2184.      *            {@code null}; in that case the method does nothing and
  2185.      *            immediately returns.
  2186.      */
  2187.     private void configureMenu(android.view.Menu mMenu2) {
  2188.         if (mMenu2 == null) {
  2189.             return;
  2190.         }
  2191.  
  2192.         // Set visibility of account/folder settings menu items
  2193.         if (mMessageListFragment == null) {
  2194.             mMenu2.findItem(R.id.account_settings).setVisible(false);
  2195.             mMenu2.findItem(R.id.folder_settings).setVisible(false);
  2196.         } else {
  2197.             mMenu2.findItem(R.id.account_settings).setVisible(
  2198.                     mMessageListFragment.isSingleAccountMode());
  2199.             mMenu2.findItem(R.id.folder_settings).setVisible(
  2200.                     mMessageListFragment.isSingleFolderMode());
  2201.         }
  2202.  
  2203.         /*
  2204.          * Set visibility of menu items related to the message view
  2205.          */
  2206.  
  2207.         if (mDisplayMode == DisplayMode.MESSAGE_LIST
  2208.                 || mMessageViewFragment == null
  2209.                 || !mMessageViewFragment.isInitialized()) {
  2210.             mMenu2.findItem(R.id.next_message).setVisible(false);
  2211.             mMenu2.findItem(R.id.previous_message).setVisible(false);
  2212.             mMenu2.findItem(R.id.single_message_options).setVisible(false);
  2213.             mMenu2.findItem(R.id.delete).setVisible(false);
  2214.             mMenu2.findItem(R.id.compose).setVisible(false);
  2215.             mMenu2.findItem(R.id.archive).setVisible(false);
  2216.             mMenu2.findItem(R.id.move).setVisible(false);
  2217.             mMenu2.findItem(R.id.copy).setVisible(false);
  2218.             mMenu2.findItem(R.id.spam).setVisible(false);
  2219.             mMenu2.findItem(R.id.refile).setVisible(false);
  2220.             mMenu2.findItem(R.id.toggle_unread).setVisible(false);
  2221.             mMenu2.findItem(R.id.select_text).setVisible(false);
  2222.             mMenu2.findItem(R.id.toggle_message_view_theme).setVisible(false);
  2223.             mMenu2.findItem(R.id.show_headers).setVisible(false);
  2224.             mMenu2.findItem(R.id.hide_headers).setVisible(false);
  2225.         } else {
  2226.             // hide prev/next buttons in split mode
  2227.             if (mDisplayMode != DisplayMode.MESSAGE_VIEW) {
  2228.                 mMenu2.findItem(R.id.next_message).setVisible(false);
  2229.                 mMenu2.findItem(R.id.previous_message).setVisible(false);
  2230.             } else {
  2231.                 MessageReference ref = mMessageViewFragment
  2232.                         .getMessageReference();
  2233.                 boolean initialized = (mMessageListFragment != null && mMessageListFragment
  2234.                         .isLoadFinished());
  2235.                 boolean canDoPrev = (initialized && !mMessageListFragment
  2236.                         .isFirst(ref));
  2237.                 boolean canDoNext = (initialized && !mMessageListFragment
  2238.                         .isLast(ref));
  2239.  
  2240.                 MenuItem prev = mMenu2.findItem(R.id.previous_message);
  2241.                 prev.setEnabled(canDoPrev);
  2242.                 //prev.getIcon().setAlpha(canDoPrev ? 255 : 127);
  2243.  
  2244.                 //MenuItem next = menu.findItem(R.id.next_message);
  2245.                 //next.setEnabled(canDoNext);
  2246.                 //next.getIcon().setAlpha(canDoNext ? 255 : 127);
  2247.             }
  2248.  
  2249.             MenuItem toggleTheme = mMenu2
  2250.                     .findItem(R.id.toggle_message_view_theme);
  2251.             if (K9.useFixedMessageViewTheme()) {
  2252.                 toggleTheme.setVisible(false);
  2253.             } else {
  2254.                 // Set title of menu item to switch to dark/light theme
  2255.                 if (K9.getK9MessageViewTheme() == K9.Theme.DARK) {
  2256.                     toggleTheme
  2257.                             .setTitle(R.string.message_view_theme_action_light);
  2258.                 } else {
  2259.                     toggleTheme
  2260.                             .setTitle(R.string.message_view_theme_action_dark);
  2261.                 }
  2262.                 toggleTheme.setVisible(true);
  2263.             }
  2264.  
  2265.             // Set title of menu item to toggle the read state of the currently
  2266.             // displayed message
  2267.             if (mMessageViewFragment.isMessageRead()) {
  2268.                 mMenu2.findItem(R.id.toggle_unread).setTitle(
  2269.                         R.string.mark_as_unread_action);
  2270.             } else {
  2271.                 mMenu2.findItem(R.id.toggle_unread).setTitle(
  2272.                         R.string.mark_as_read_action);
  2273.             }
  2274.  
  2275.             // Jellybean has built-in long press selection support
  2276.             mMenu2.findItem(R.id.select_text).setVisible(
  2277.                     Build.VERSION.SDK_INT < 16);
  2278.  
  2279.             mMenu2.findItem(R.id.delete).setVisible(
  2280.                     K9.isMessageViewDeleteActionVisible());
  2281.  
  2282.             /*
  2283.              * Set visibility of copy, move, archive, spam in action bar and
  2284.              * refile submenu
  2285.              */
  2286.             if (mMessageViewFragment.isCopyCapable()) {
  2287.                 mMenu2.findItem(R.id.copy).setVisible(
  2288.                         K9.isMessageViewCopyActionVisible());
  2289.                 mMenu2.findItem(R.id.refile_copy).setVisible(true);
  2290.             } else {
  2291.                 mMenu2.findItem(R.id.copy).setVisible(false);
  2292.                 mMenu2.findItem(R.id.refile_copy).setVisible(false);
  2293.             }
  2294.  
  2295.             if (mMessageViewFragment.isMoveCapable()) {
  2296.                 boolean canMessageBeArchived = mMessageViewFragment
  2297.                         .canMessageBeArchived();
  2298.                 boolean canMessageBeMovedToSpam = mMessageViewFragment
  2299.                         .canMessageBeMovedToSpam();
  2300.  
  2301.                 mMenu2.findItem(R.id.move).setVisible(
  2302.                         K9.isMessageViewMoveActionVisible());
  2303.                 mMenu2.findItem(R.id.archive).setVisible(
  2304.                         canMessageBeArchived
  2305.                                 && K9.isMessageViewArchiveActionVisible());
  2306.                 mMenu2.findItem(R.id.spam).setVisible(
  2307.                         canMessageBeMovedToSpam
  2308.                                 && K9.isMessageViewSpamActionVisible());
  2309.  
  2310.                 mMenu2.findItem(R.id.refile_move).setVisible(true);
  2311.                 mMenu2.findItem(R.id.refile_archive).setVisible(
  2312.                         canMessageBeArchived);
  2313.                 mMenu2.findItem(R.id.refile_spam).setVisible(
  2314.                         canMessageBeMovedToSpam);
  2315.             } else {
  2316.                 mMenu2.findItem(R.id.move).setVisible(false);
  2317.                 mMenu2.findItem(R.id.archive).setVisible(false);
  2318.                 mMenu2.findItem(R.id.spam).setVisible(false);
  2319.  
  2320.                 mMenu2.findItem(R.id.refile).setVisible(false);
  2321.             }
  2322.  
  2323.             if (mMessageViewFragment.allHeadersVisible()) {
  2324.                 mMenu2.findItem(R.id.show_headers).setVisible(false);
  2325.             } else {
  2326.                 mMenu2.findItem(R.id.hide_headers).setVisible(false);
  2327.             }
  2328.         }
  2329.  
  2330.         /*
  2331.          * Set visibility of menu items related to the message list
  2332.          */
  2333.  
  2334.         // Hide both search menu items by default and enable one when
  2335.         // appropriate
  2336.         mMenu2.findItem(R.id.search).setVisible(false);
  2337.         mMenu2.findItem(R.id.search_remote).setVisible(false);
  2338.  
  2339.         if (mDisplayMode == DisplayMode.MESSAGE_VIEW
  2340.                 || mMessageListFragment == null
  2341.                 || !mMessageListFragment.isInitialized()) {
  2342.             mMenu2.findItem(R.id.check_mail).setVisible(false);
  2343.             mMenu2.findItem(R.id.set_sort).setVisible(false);
  2344.             mMenu2.findItem(R.id.select_all).setVisible(false);
  2345.             mMenu2.findItem(R.id.send_messages).setVisible(false);
  2346.             mMenu2.findItem(R.id.expunge).setVisible(false);
  2347.             mMenu2.findItem(R.id.mark_all_as_read).setVisible(false);
  2348.             mMenu2.findItem(R.id.show_folder_list).setVisible(false);
  2349.         } else {
  2350.             mMenu2.findItem(R.id.set_sort).setVisible(true);
  2351.             mMenu2.findItem(R.id.select_all).setVisible(true);
  2352.             mMenu2.findItem(R.id.compose).setVisible(true);
  2353.             mMenu2.findItem(R.id.mark_all_as_read).setVisible(
  2354.                     mMessageListFragment.isMarkAllAsReadSupported());
  2355.  
  2356.             if (!mMessageListFragment.isSingleAccountMode()) {
  2357.                 mMenu2.findItem(R.id.expunge).setVisible(false);
  2358.                 mMenu2.findItem(R.id.send_messages).setVisible(false);
  2359.                 mMenu2.findItem(R.id.show_folder_list).setVisible(false);
  2360.             } else {
  2361.                 mMenu2.findItem(R.id.send_messages).setVisible(
  2362.                         mMessageListFragment.isOutbox());
  2363.                 mMenu2.findItem(R.id.expunge).setVisible(
  2364.                         mMessageListFragment.isRemoteFolder()
  2365.                                 && mMessageListFragment
  2366.                                         .isAccountExpungeCapable());
  2367.                 mMenu2.findItem(R.id.show_folder_list).setVisible(true);
  2368.             }
  2369.  
  2370.             mMenu2.findItem(R.id.check_mail).setVisible(
  2371.                     mMessageListFragment.isCheckMailSupported());
  2372.  
  2373.             // If this is an explicit local search, show the option to search on
  2374.             // the server
  2375.             if (!mMessageListFragment.isRemoteSearch()
  2376.                     && mMessageListFragment.isRemoteSearchAllowed()) {
  2377.                 mMenu2.findItem(R.id.search_remote).setVisible(true);
  2378.             } else if (!mMessageListFragment.isManualSearch()) {
  2379.                 mMenu2.findItem(R.id.search).setVisible(true);
  2380.             }
  2381.         }
  2382.     }
  2383.  
  2384.     protected void onAccountUnavailable() {
  2385.         finish();
  2386.         // TODO inform user about account unavailability using Toast
  2387.         Accounts.listAccounts(this);
  2388.     }
  2389.  
  2390.     public void setActionBarTitle(String title) {
  2391.         mActionBarTitle.setText(title);
  2392.     }
  2393.  
  2394.     public void setActionBarSubTitle(String subTitle) {
  2395.         mActionBarSubTitle.setText(subTitle);
  2396.     }
  2397.  
  2398.     public void setActionBarUnread(int unread) {
  2399.         if (unread == 0) {
  2400.             mActionBarUnread.setVisibility(View.GONE);
  2401.         } else {
  2402.             mActionBarUnread.setVisibility(View.VISIBLE);
  2403.             mActionBarUnread.setText(Integer.toString(unread));
  2404.            
  2405.            
  2406.         }
  2407.     }
  2408.  
  2409.     @Override
  2410.     public void setMessageListTitle(String title) {
  2411.         setActionBarTitle(title);
  2412.     }
  2413.  
  2414.     @Override
  2415.     public void setMessageListSubTitle(String subTitle) {
  2416.         setActionBarSubTitle(subTitle);
  2417.     }
  2418.  
  2419.     @Override
  2420.     public void setUnreadCount(int unread) {
  2421.         setActionBarUnread(unread);
  2422.     }
  2423.  
  2424.     @Override
  2425.     public void setMessageListProgress(int progress) {
  2426.         setProgress(progress);
  2427.     }
  2428.  
  2429.     @Override
  2430.     public void openMessage(MessageReference messageReference) {
  2431.         Preferences prefs = Preferences.getPreferences(getApplicationContext());
  2432.         Account account = prefs.getAccount(messageReference.accountUuid);
  2433.         String folderName = messageReference.folderName;
  2434.  
  2435.         if (folderName.equals(account.getDraftsFolderName())) {
  2436.             MessageCompose.actionEditDraft(this, messageReference);
  2437.         } else {
  2438.             mMessageViewContainer.removeView(mMessageViewPlaceHolder);
  2439.  
  2440.             if (mMessageListFragment != null) {
  2441.                 mMessageListFragment.setActiveMessage(messageReference);
  2442.             }
  2443.  
  2444.             MessageViewFragment fragment = MessageViewFragment
  2445.                     .newInstance(messageReference);
  2446.             FragmentTransaction ft = getFragmentManager().beginTransaction();
  2447.             ft.replace(R.id.message_view_container, fragment);
  2448.             mMessageViewFragment = fragment;
  2449.             ft.commit();
  2450.  
  2451.             if (mDisplayMode != DisplayMode.SPLIT_VIEW) {
  2452.                 showMessageView();
  2453.             }
  2454.         }
  2455.     }
  2456.  
  2457.     @Override
  2458.     public void onResendMessage(Message message) {
  2459.         MessageCompose.actionEditDraft(this, message.makeMessageReference());
  2460.     }
  2461.  
  2462.     @Override
  2463.     public void onForward(Message message) {
  2464.         MessageCompose.actionForward(this, message.getFolder().getAccount(),
  2465.                 message, null);
  2466.     }
  2467.  
  2468.     @Override
  2469.     public void onReply(Message message) {
  2470.         MessageCompose.actionReply(this, message.getFolder().getAccount(),
  2471.                 message, false, null);
  2472.     }
  2473.  
  2474.     @Override
  2475.     public void onReplyAll(Message message) {
  2476.         MessageCompose.actionReply(this, message.getFolder().getAccount(),
  2477.                 message, true, null);
  2478.     }
  2479.  
  2480.     @Override
  2481.     public void onCompose(Account account) {
  2482.         MessageCompose.actionCompose(this, account);
  2483.     }
  2484.  
  2485.     @Override
  2486.     public void showMoreFromSameSender(String senderAddress) {
  2487.         LocalSearch tmpSearch = new LocalSearch("From " + senderAddress);
  2488.         tmpSearch.addAccountUuids(mSearch.getAccountUuids());
  2489.         tmpSearch.and(Searchfield.SENDER, senderAddress, Attribute.CONTAINS);
  2490.  
  2491.         MessageListFragment fragment = MessageListFragment.newInstance(
  2492.                 tmpSearch, false, false);
  2493.  
  2494.         addMessageListFragment(fragment, true);
  2495.     }
  2496.  
  2497.     @Override
  2498.     public void onBackStackChanged() {
  2499.         findFragments();
  2500.  
  2501.         if (mDisplayMode == DisplayMode.SPLIT_VIEW) {
  2502.             showMessageViewPlaceHolder();
  2503.         }
  2504.  
  2505.         configureMenu(mMenu);
  2506.     }
  2507.  
  2508.     @Override
  2509.     public void onSwipeRightToLeft(MotionEvent e1, MotionEvent e2) {
  2510.         if (mMessageListFragment != null
  2511.                 && mDisplayMode != DisplayMode.MESSAGE_VIEW) {
  2512.             mMessageListFragment.onSwipeRightToLeft(e1, e2);
  2513.         }
  2514.     }
  2515.  
  2516.     @Override
  2517.     public void onSwipeLeftToRight(MotionEvent e1, MotionEvent e2) {
  2518.         if (mMessageListFragment != null
  2519.                 && mDisplayMode != DisplayMode.MESSAGE_VIEW) {
  2520.             mMessageListFragment.onSwipeLeftToRight(e1, e2);
  2521.         }
  2522.     }
  2523.  
  2524.     private final class StorageListenerImplementation implements
  2525.             StorageManager.StorageListener {
  2526.         @Override
  2527.         public void onUnmount(String providerId) {
  2528.             if (mAccount != null
  2529.                     && providerId.equals(mAccount.getLocalStorageProviderId())) {
  2530.                 runOnUiThread(new Runnable() {
  2531.                     @Override
  2532.                     public void run() {
  2533.                         onAccountUnavailable();
  2534.                     }
  2535.                 });
  2536.             }
  2537.         }
  2538.  
  2539.         @Override
  2540.         public void onMount(String providerId) {
  2541.             // no-op
  2542.         }
  2543.     }
  2544.  
  2545.     private void addMessageListFragment(MessageListFragment fragment,
  2546.             boolean addToBackStack) {
  2547.         FragmentTransaction ft = getFragmentManager().beginTransaction();
  2548.  
  2549.         ft.replace(R.id.message_list_container, fragment);
  2550.         if (addToBackStack)
  2551.             ft.addToBackStack(null);
  2552.  
  2553.         mMessageListFragment = fragment;
  2554.  
  2555.         int transactionId = ft.commit();
  2556.         if (transactionId >= 0 && mFirstBackStackId < 0) {
  2557.             mFirstBackStackId = transactionId;
  2558.         }
  2559.     }
  2560.  
  2561.     @Override
  2562.     public boolean startSearch(Account account, String folderName) {
  2563.         // If this search was started from a MessageList of a single folder,
  2564.         // pass along that folder info
  2565.         // so that we can enable remote search.
  2566.         if (account != null && folderName != null) {
  2567.             final Bundle appData = new Bundle();
  2568.             appData.putString(EXTRA_SEARCH_ACCOUNT, account.getUuid());
  2569.             appData.putString(EXTRA_SEARCH_FOLDER, folderName);
  2570.             startSearch(null, false, appData, false);
  2571.         } else {
  2572.             // TODO Handle the case where we're searching from within a search
  2573.             // result.
  2574.             startSearch(null, false, null, false);
  2575.         }
  2576.  
  2577.         return true;
  2578.     }
  2579.  
  2580.     @Override
  2581.     public void showThread(Account account, String folderName, long threadRootId) {
  2582.         showMessageViewPlaceHolder();
  2583.  
  2584.         LocalSearch tmpSearch = new LocalSearch();
  2585.         tmpSearch.addAccountUuid(account.getUuid());
  2586.         tmpSearch.and(Searchfield.THREAD_ID, String.valueOf(threadRootId),
  2587.                 Attribute.EQUALS);
  2588.  
  2589.         MessageListFragment fragment = MessageListFragment.newInstance(
  2590.                 tmpSearch, true, false);
  2591.         addMessageListFragment(fragment, true);
  2592.     }
  2593.  
  2594.     private void showMessageViewPlaceHolder() {
  2595.         removeMessageViewFragment();
  2596.  
  2597.         // Add placeholder view if necessary
  2598.         if (mMessageViewPlaceHolder.getParent() == null) {
  2599.             mMessageViewContainer.addView(mMessageViewPlaceHolder);
  2600.         }
  2601.  
  2602.         mMessageListFragment.setActiveMessage(null);
  2603.     }
  2604.  
  2605.     /**
  2606.      * Remove MessageViewFragment if necessary.
  2607.      */
  2608.     private void removeMessageViewFragment() {
  2609.         if (mMessageViewFragment != null) {
  2610.             FragmentTransaction ft = getFragmentManager().beginTransaction();
  2611.             ft.remove(mMessageViewFragment);
  2612.             mMessageViewFragment = null;
  2613.             ft.commit();
  2614.  
  2615.             showDefaultTitleView();
  2616.         }
  2617.     }
  2618.  
  2619.     private void removeMessageListFragment() {
  2620.         if (mMessageViewFragment != null) {
  2621.         FragmentTransaction ft = getFragmentManager().beginTransaction();
  2622.         ft.remove(mMessageListFragment);
  2623.         mMessageListFragment = null;
  2624.         ft.commit();
  2625.         }
  2626.     }
  2627.  
  2628.     @Override
  2629.     public void remoteSearchStarted() {
  2630.         // Remove action button for remote search
  2631.         configureMenu(mMenu);
  2632.     }
  2633.  
  2634.     @Override
  2635.     public void goBack() {
  2636.         FragmentManager fragmentManager = getFragmentManager();
  2637.         if (mDisplayMode == DisplayMode.MESSAGE_VIEW) {
  2638.             showMessageList();
  2639.         } else if (fragmentManager.getBackStackEntryCount() > 0) {
  2640.             fragmentManager.popBackStack();
  2641.         } else if (mMessageListFragment.isManualSearch()) {
  2642.             finish();
  2643.         } else if (!mSingleFolderMode) {
  2644.             onAccounts();
  2645.         } else {
  2646.             onShowFolderList();
  2647.         }
  2648.     }
  2649.  
  2650.     @Override
  2651.     public void enableActionBarProgress(boolean enable) {
  2652.         if (mMenuButtonCheckMail != null && mMenuButtonCheckMail.isVisible()) {
  2653.             mActionBarProgress.setVisibility(ProgressBar.GONE);
  2654.             if (enable) {
  2655.                 mMenuButtonCheckMail
  2656.                         .setActionView(mActionButtonIndeterminateProgress);
  2657.             } else {
  2658.                 mMenuButtonCheckMail.setActionView(null);
  2659.             }
  2660.         } else {
  2661.             if (mMenuButtonCheckMail != null)
  2662.                 mMenuButtonCheckMail.setActionView(null);
  2663.             if (enable) {
  2664.                 mActionBarProgress.setVisibility(ProgressBar.VISIBLE);
  2665.             } else {
  2666.                 mActionBarProgress.setVisibility(ProgressBar.GONE);
  2667.             }
  2668.         }
  2669.     }
  2670.  
  2671.     private void restartActivity() {
  2672.         // restart the current activity, so that the theme change can be applied
  2673.         if (Build.VERSION.SDK_INT < 11) {
  2674.             Intent intent = getIntent();
  2675.             intent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
  2676.             finish();
  2677.             overridePendingTransition(0, 0); // disable animations to speed up
  2678.                                                 // the switch
  2679.             startActivity(intent);
  2680.             overridePendingTransition(0, 0);
  2681.         } else {
  2682.             recreate();
  2683.         }
  2684.     }
  2685.  
  2686.     @Override
  2687.     public void displayMessageSubject(String subject) {
  2688.         if (mDisplayMode == DisplayMode.MESSAGE_VIEW) {
  2689.             mActionBarSubject.setText(subject);
  2690.         }
  2691.     }
  2692.  
  2693.     @Override
  2694.     public void onReply(Message message, PgpData pgpData) {
  2695.         MessageCompose.actionReply(this, mAccount, message, false,
  2696.                 pgpData.getDecryptedData());
  2697.     }
  2698.  
  2699.     @Override
  2700.     public void onReplyAll(Message message, PgpData pgpData) {
  2701.         MessageCompose.actionReply(this, mAccount, message, true,
  2702.                 pgpData.getDecryptedData());
  2703.     }
  2704.  
  2705.     @Override
  2706.     public void onForward(Message mMessage, PgpData mPgpData) {
  2707.         MessageCompose.actionForward(this, mAccount, mMessage,
  2708.                 mPgpData.getDecryptedData());
  2709.     }
  2710.  
  2711.     @Override
  2712.     public void showNextMessageOrReturn() {
  2713.         if (K9.messageViewReturnToList() || !showLogicalNextMessage()) {
  2714.             if (mDisplayMode == DisplayMode.SPLIT_VIEW) {
  2715.                 showMessageViewPlaceHolder();
  2716.             } else {
  2717.                 showMessageList();
  2718.             }
  2719.         }
  2720.     }
  2721.  
  2722.     /**
  2723.      * Shows the next message in the direction the user was displaying messages.
  2724.      *
  2725.      * @return {@code true}
  2726.      */
  2727.     private boolean showLogicalNextMessage() {
  2728.         boolean result = false;
  2729.         if (mLastDirection == NEXT) {
  2730.             result = showNextMessage();
  2731.         } else if (mLastDirection == PREVIOUS) {
  2732.             result = showPreviousMessage();
  2733.         }
  2734.  
  2735.         if (!result) {
  2736.             result = showNextMessage() || showPreviousMessage();
  2737.         }
  2738.  
  2739.         return result;
  2740.     }
  2741.  
  2742.     @Override
  2743.     public void setProgress(boolean enable) {
  2744.         setProgressBarIndeterminateVisibility(enable);
  2745.     }
  2746.  
  2747.     @Override
  2748.     public void messageHeaderViewAvailable(MessageHeader header) {
  2749.         mActionBarSubject.setMessageHeader(header);
  2750.     }
  2751.  
  2752.     private boolean showNextMessage() {
  2753.         MessageReference ref = mMessageViewFragment.getMessageReference();
  2754.         if (ref != null) {
  2755.             if (mMessageListFragment.openNext(ref)) {
  2756.                 mLastDirection = NEXT;
  2757.                 return true;
  2758.             }
  2759.         }
  2760.         return false;
  2761.     }
  2762.  
  2763.     private boolean showPreviousMessage() {
  2764.         MessageReference ref = mMessageViewFragment.getMessageReference();
  2765.         if (ref != null) {
  2766.             if (mMessageListFragment.openPrevious(ref)) {
  2767.                 mLastDirection = PREVIOUS;
  2768.                 return true;
  2769.             }
  2770.         }
  2771.         return false;
  2772.     }
  2773.  
  2774.     private void showMessageList() {
  2775.         mMessageListWasDisplayed = true;
  2776.         mDisplayMode = DisplayMode.MESSAGE_LIST;
  2777.         mViewSwitcher.showFirstView();
  2778.  
  2779.         mMessageListFragment.setActiveMessage(null);
  2780.  
  2781.         showDefaultTitleView();
  2782.         configureMenu(mMenu);
  2783.     }
  2784.  
  2785.     private void showMessageView() {
  2786.         mDisplayMode = DisplayMode.MESSAGE_VIEW;
  2787.  
  2788.         if (!mMessageListWasDisplayed) {
  2789.             mViewSwitcher.setAnimateFirstView(false);
  2790.         }
  2791.         mViewSwitcher.showSecondView();
  2792.  
  2793.         showMessageTitleView();
  2794.         configureMenu(mMenu);
  2795.     }
  2796.  
  2797.     @Override
  2798.     public void updateMenu() {
  2799.         invalidateOptionsMenu();
  2800.     }
  2801.  
  2802.     @Override
  2803.     public void disableDeleteAction() {
  2804.         mMenu.findItem(R.id.delete).setEnabled(false);
  2805.     }
  2806.  
  2807.     private void onToggleTheme() {
  2808.         if (K9.getK9MessageViewTheme() == K9.Theme.DARK) {
  2809.             K9.setK9MessageViewThemeSetting(K9.Theme.LIGHT);
  2810.         } else {
  2811.             K9.setK9MessageViewThemeSetting(K9.Theme.DARK);
  2812.         }
  2813.  
  2814.         new Thread(new Runnable() {
  2815.             @Override
  2816.             public void run() {
  2817.                 Context appContext = getApplicationContext();
  2818.                 Preferences prefs = Preferences.getPreferences(appContext);
  2819.                 Editor editor = prefs.getPreferences().edit();
  2820.                 K9.save(editor);
  2821.                 editor.commit();
  2822.             }
  2823.         }).start();
  2824.  
  2825.         restartActivity();
  2826.     }
  2827.  
  2828.     private void showDefaultTitleView() {
  2829.         mActionBarMessageView.setVisibility(View.GONE);
  2830.         mActionBarMessageList.setVisibility(View.VISIBLE);
  2831.  
  2832.         if (mMessageListFragment != null) {
  2833.             mMessageListFragment.updateTitle();
  2834.         }
  2835.  
  2836.         mActionBarSubject.setMessageHeader(null);
  2837.     }
  2838.  
  2839.     private void showMessageTitleView() {
  2840.         mActionBarMessageList.setVisibility(View.GONE);
  2841.         mActionBarMessageView.setVisibility(View.VISIBLE);
  2842.  
  2843.         if (mMessageViewFragment != null) {
  2844.             displayMessageSubject(null);
  2845.             mMessageViewFragment.updateTitle();
  2846.         }
  2847.     }
  2848.  
  2849.     @Override
  2850.     public void onSwitchComplete(int displayedChild) {
  2851.         if (displayedChild == 0) {
  2852.             removeMessageViewFragment();
  2853.         }
  2854.     }
  2855.  
  2856.     @Override
  2857.     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
  2858.         super.onActivityResult(requestCode, resultCode, data);
  2859.  
  2860.         // handle OpenPGP results from PendingIntents in OpenPGP view
  2861.         // must be handled in this main activity, because
  2862.         // startIntentSenderForResult() does not support Fragments
  2863.         MessageOpenPgpView openPgpView = (MessageOpenPgpView) findViewById(R.id.layout_decrypt_openpgp);
  2864.         if (openPgpView != null
  2865.                 && openPgpView.handleOnActivityResult(requestCode, resultCode,
  2866.                         data)) {
  2867.             return;
  2868.         }
  2869.     }
  2870.  
  2871.     public void inbox() {
  2872.  
  2873.         Intent intent = new Intent(MessageList.this, Accounts.class);
  2874.  
  2875.         startActivity(intent);
  2876.  
  2877.     }
  2878.    
  2879.     public void to_main(){
  2880.        
  2881.         Intent intent = new Intent(MessageList.this, MainActivity.class);
  2882.  
  2883.         finish();
  2884.        
  2885.         startActivity(intent);
  2886.        
  2887.     }
  2888.    
  2889.    
  2890.    
  2891.     public class DrawerItemClickListener_Inbox implements
  2892.     ListView.OnItemClickListener {
  2893. @Override
  2894. public void onItemClick(AdapterView<?> parent, View view, int position1,
  2895.         long id) {
  2896.     selectItem_Inbox(position1);
  2897. }
  2898. }
  2899.    
  2900.    
  2901.    
  2902. private void selectItem_Inbox(int position1) {
  2903.  
  2904.             String clicked1 = mDrawerList_Inbox.getItemAtPosition(position1).toString();
  2905.            
  2906.            
  2907.             System.out.println(clicked1);
  2908.            
  2909.             if(clicked1.contains("Inbox")) {
  2910.            
  2911.                 inbox();
  2912.            
  2913.         }
  2914.    
  2915.             mDrawerList_Inbox.setItemChecked(position1, true);
  2916.  
  2917.             mDrawerLayout.closeDrawer(mDrawerLinear);
  2918.            
  2919. }
  2920.    
  2921.  
  2922.     public class DrawerItemClickListener implements
  2923.             ListView.OnItemClickListener {
  2924.         @Override
  2925.         public void onItemClick(AdapterView<?> parent, View view, int position,
  2926.                 long id) {
  2927.             selectItem(position);
  2928.         }
  2929.     }
  2930.    
  2931.  
  2932.     private void selectItem(int position) {
  2933.  
  2934.        
  2935.  
  2936.         if (Show_View.equals("Homework Due")) {
  2937.  
  2938.             String clicked = mDrawerList.getItemAtPosition(position).toString();
  2939.            
  2940.            
  2941.             System.out.println(clicked);
  2942.            
  2943.             if(clicked.contains("Inbox")) {
  2944.            
  2945.                 inbox();
  2946.                
  2947.             }
  2948.            
  2949.             if(clicked.contains("Schedule")) {
  2950.                
  2951.                 SharedPreferences.Editor localEditor = getSharedPreferences(
  2952.                         "return_to_main", Context.MODE_PRIVATE).edit();
  2953.  
  2954.                 localEditor.putString("fragment_to_start", "0");
  2955.  
  2956.                 localEditor.commit();
  2957.                
  2958.                 to_main();
  2959.                
  2960.             }
  2961.                
  2962.             if(clicked.contains("Homework Due")) {
  2963.                
  2964.                 SharedPreferences.Editor localEditor1 = getSharedPreferences(
  2965.                         "return_to_main", Context.MODE_PRIVATE).edit();
  2966.  
  2967.                 localEditor1.putString("fragment_to_start", "1");
  2968.  
  2969.                 localEditor1.commit();
  2970.                 to_main();
  2971.                
  2972.             }
  2973.            
  2974.             if(clicked.contains("Options")){
  2975.                
  2976.                 SharedPreferences.Editor localEditor2 = getSharedPreferences(
  2977.                         "return_to_main", Context.MODE_PRIVATE).edit();
  2978.  
  2979.                 localEditor2.putString("fragment_to_start", "3");
  2980.  
  2981.                 localEditor2.commit();
  2982.                 to_main();
  2983.        
  2984.                
  2985.             }
  2986.            
  2987.            
  2988.             if(clicked.contains("Logout")){
  2989.                
  2990.                
  2991.             }
  2992.  
  2993.  
  2994.         } else {
  2995.  
  2996. String clicked = mDrawerList.getItemAtPosition(position).toString();
  2997.  
  2998.  
  2999.  
  3000. System.out.println(clicked);
  3001.            
  3002.             if(clicked.contains("Inbox")) {
  3003.            
  3004.                 inbox();
  3005.                
  3006.             }
  3007.            
  3008.             if(clicked.contains("Schedule")) {
  3009.                
  3010.                 SharedPreferences.Editor localEditor = getSharedPreferences(
  3011.                         "return_to_main", Context.MODE_PRIVATE).edit();
  3012.  
  3013.                 localEditor.putString("fragment_to_start", "0");
  3014.  
  3015.                 localEditor.commit();
  3016.                
  3017.                 to_main();
  3018.                
  3019.             }
  3020.                
  3021.             if(clicked.contains("Homework Due")) {
  3022.                
  3023.                 SharedPreferences.Editor localEditor1 = getSharedPreferences(
  3024.                         "return_to_main", Context.MODE_PRIVATE).edit();
  3025.  
  3026.                 localEditor1.putString("fragment_to_start", "1");
  3027.  
  3028.                 localEditor1.commit();
  3029.                 to_main();
  3030.                
  3031.             }
  3032.            
  3033.             if(clicked.contains("Options")){
  3034.                
  3035.                 SharedPreferences.Editor localEditor2 = getSharedPreferences(
  3036.                         "return_to_main", Context.MODE_PRIVATE).edit();
  3037.  
  3038.                 localEditor2.putString("fragment_to_start", "3");
  3039.  
  3040.                 localEditor2.commit();
  3041.                 to_main();
  3042.                
  3043.             }
  3044.            
  3045.            
  3046.             if(clicked.contains("Logout")){
  3047.                
  3048.                
  3049.             }
  3050.  
  3051.         }
  3052.  
  3053.        
  3054.  
  3055.         mDrawerList.setItemChecked(position, true);
  3056.  
  3057.         mDrawerLayout.closeDrawer(mDrawerLinear);
  3058.     }
  3059.  
  3060.     protected void onUpdateData(int reason) {
  3061.         Log.d(TAG, "onUpdateData(" + reason + ")");
  3062.         doRefresh();
  3063.     }
  3064.  
  3065.     @Override
  3066.     public void onDestroy() {
  3067.         super.onDestroy();
  3068.         Log.d(TAG, "onDestroy()");
  3069.         if (contentObserver != null) {
  3070.             getContentResolver().unregisterContentObserver(contentObserver);
  3071.             contentObserver = null;
  3072.         }
  3073.         if (receiver != null) {
  3074.             unregisterReceiver(receiver);
  3075.             receiver = null;
  3076.         }
  3077.     }
  3078.  
  3079.     protected void doRefresh() {
  3080.         Log.d(TAG, "doRefresh()");
  3081.  
  3082.         int countssssss = getUnreadK9Count(this);
  3083.  
  3084.         Log.d(TAG, "" + countssssss + " unread emails");
  3085.  
  3086.     }
  3087.  
  3088.     public static class CursorHandler {
  3089.         private List<Cursor> cursors = new ArrayList<Cursor>();
  3090.  
  3091.         public Cursor add(Cursor c) {
  3092.             if (c != null)
  3093.                 cursors.add(c);
  3094.             return c;
  3095.         }
  3096.  
  3097.         public void closeAll() {
  3098.             for (Cursor c : cursors) {
  3099.                 if (!c.isClosed())
  3100.                     c.close();
  3101.             }
  3102.         }
  3103.     }
  3104.  
  3105.     private static int k9UnreadCount = 0;
  3106.  
  3107.     public static int getUnreadK9Count(Context context) {
  3108.         refreshUnreadK9Count(context);
  3109.  
  3110.         return k9UnreadCount;
  3111.     }
  3112.  
  3113.     private static int getUnreadK9Count(Context context, int accountNumber) {
  3114.         CursorHandler ch = new CursorHandler();
  3115.         try {
  3116.             Cursor cur = ch.add(context.getContentResolver().query(
  3117.                     Uri.parse(k9UnreadUri + "/" + accountNumber + "/"), null,
  3118.                     null, null, null));
  3119.             if (cur != null) {
  3120.                 Log.d(TAG, "k9: " + cur.getCount() + " unread rows returned");
  3121.  
  3122.                 if (cur.getCount() > 0) {
  3123.                     cur.moveToFirst();
  3124.                     int unread = 0;
  3125.                     int nameIndex = cur.getColumnIndex("accountName");
  3126.                     int unreadIndex = cur.getColumnIndex("unread");
  3127.                     do {
  3128.                         String acct = cur.getString(nameIndex);
  3129.                         int unreadForAcct = cur.getInt(unreadIndex);
  3130.                         Log.d(TAG, "k9: " + acct + " - " + unreadForAcct
  3131.                                 + " unread");
  3132.                         unread += unreadForAcct;
  3133.                     } while (cur.moveToNext());
  3134.                     cur.close();
  3135.                     return unread;
  3136.                 }
  3137.             } else {
  3138.                 Log.d(TAG, "Failed to query k9 unread contentprovider.");
  3139.             }
  3140.         } catch (IllegalStateException e) {
  3141.             Log.d(TAG, "k-9 unread uri unknown.");
  3142.         }
  3143.         return 0;
  3144.     }
  3145.  
  3146.     public static void refreshUnreadK9Count(Context context) {
  3147.         int accounts = getK9AccountCount(context);
  3148.         if (accounts > 0) {
  3149.             int countssssss = 0;
  3150.             for (int acct = 0; acct < accounts; ++acct) {
  3151.                 countssssss += getUnreadK9Count(context, acct);
  3152.             }
  3153.             k9UnreadCount = countssssss;
  3154.         }
  3155.     }
  3156.  
  3157.     public static int getK9AccountCount(Context context) {
  3158.         CursorHandler ch = new CursorHandler();
  3159.         try {
  3160.             Cursor cur = ch.add(context.getContentResolver().query(
  3161.                     k9AccountsUri, null, null, null, null));
  3162.             if (cur != null) {
  3163.                 // if (Preferences.logging) Log.d(MetaWatch.TAG,
  3164.                 // "k9: "+cur.getCount()+ " account rows returned");
  3165.  
  3166.                 int count = cur.getCount();
  3167.  
  3168.                 return count;
  3169.             } else {
  3170.                 // if (Preferences.logging) Log.d(MetaWatch.TAG,
  3171.                 // "Failed to query k9 unread contentprovider.");
  3172.             }
  3173.         } catch (IllegalStateException e) {
  3174.             // if (Preferences.logging) Log.d(MetaWatch.TAG,
  3175.             // "k-9 accounts uri unknown.");
  3176.         } catch (java.lang.SecurityException e) {
  3177.             // if (Preferences.logging) Log.d(MetaWatch.TAG,
  3178.             // "Permissions failure accessing k-9 databases");
  3179.         } finally {
  3180.             ch.closeAll();
  3181.         }
  3182.         return 0;
  3183.  
  3184.     }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!