Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 Google Inc. |
| 3 | * Licensed to The Android Open Source Project. |
| 4 | * |
| 5 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | * you may not use this file except in compliance with the License. |
| 7 | * You may obtain a copy of the License at |
| 8 | * |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | * |
| 11 | * Unless required by applicable law or agreed to in writing, software |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | * See the License for the specific language governing permissions and |
| 15 | * limitations under the License. |
| 16 | */ |
| 17 | |
| 18 | package com.android.mail.browse; |
| 19 | |
| 20 | import android.app.Fragment; |
| 21 | import android.app.FragmentManager; |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 22 | import android.content.res.Resources; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 23 | import android.database.Cursor; |
| 24 | import android.database.DataSetObserver; |
| 25 | import android.os.Bundle; |
| 26 | import android.os.Parcelable; |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 27 | import android.support.v4.view.ViewPager; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 28 | import android.view.ViewGroup; |
| 29 | |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 30 | import com.android.mail.R; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 31 | import com.android.mail.providers.Account; |
| 32 | import com.android.mail.providers.Conversation; |
| 33 | import com.android.mail.providers.Folder; |
| 34 | import com.android.mail.providers.UIProvider; |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 35 | import com.android.mail.ui.AbstractConversationViewFragment; |
Andy Huang | 090db1e | 2012-07-25 13:25:28 -0700 | [diff] [blame] | 36 | import com.android.mail.ui.ActivityController; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 37 | import com.android.mail.ui.ConversationViewFragment; |
Andy Huang | 351ad4e | 2012-12-06 16:04:58 -0800 | [diff] [blame] | 38 | import com.android.mail.ui.SecureConversationViewFragment; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 39 | import com.android.mail.utils.FragmentStatePagerAdapter2; |
Paul Westbrook | b334c90 | 2012-06-25 11:42:46 -0700 | [diff] [blame] | 40 | import com.android.mail.utils.LogTag; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 41 | import com.android.mail.utils.LogUtils; |
| 42 | |
Andy Huang | 7d64612 | 2012-09-05 19:41:44 -0700 | [diff] [blame] | 43 | public class ConversationPagerAdapter extends FragmentStatePagerAdapter2 |
| 44 | implements ViewPager.OnPageChangeListener { |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 45 | |
| 46 | private final DataSetObserver mListObserver = new ListObserver(); |
Andy Huang | 090db1e | 2012-07-25 13:25:28 -0700 | [diff] [blame] | 47 | private final DataSetObserver mFolderObserver = new FolderObserver(); |
| 48 | private ActivityController mController; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 49 | private final Bundle mCommonFragmentArgs; |
| 50 | private final Conversation mInitialConversation; |
Andy Huang | b373e3e | 2012-06-29 19:18:47 -0700 | [diff] [blame] | 51 | private final Account mAccount; |
| 52 | private final Folder mFolder; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 53 | /** |
| 54 | * In singleton mode, this adapter ignores the cursor contents and size, and acts as if the |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 55 | * data set size is exactly size=1, with {@link #getDefaultConversation()} at position 0. |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 56 | */ |
| 57 | private boolean mSingletonMode = true; |
| 58 | /** |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 59 | * Similar to singleton mode, but once enabled, detached mode is permanent for this adapter. |
| 60 | */ |
| 61 | private boolean mDetachedMode = false; |
| 62 | /** |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 63 | * Adapter methods may trigger a data set change notification in the middle of a ViewPager |
| 64 | * update, but they are not safe to handle, so we have to ignore them. This will not ignore |
| 65 | * pager-external updates; it's impossible to be notified of an external change during |
| 66 | * an update. |
| 67 | * |
| 68 | * TODO: Queue up changes like this, if there ever are any that actually modify the data set. |
| 69 | * Right now there are none. Such a change would have to be of the form: instantiation or |
| 70 | * setPrimary somehow adds or removes items from the conversation cursor. Crazy! |
| 71 | */ |
| 72 | private boolean mSafeToNotify; |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 73 | /** |
| 74 | * Need to keep this around to look up pager title strings. |
| 75 | */ |
| 76 | private Resources mResources; |
| 77 | /** |
| 78 | * This isn't great to create a circular dependency, but our usage of {@link #getPageTitle(int)} |
| 79 | * requires knowing which page is the currently visible to dynamically name offscreen pages |
| 80 | * "newer" and "older". And {@link #setPrimaryItem(ViewGroup, int, Object)} does not work well |
| 81 | * because it isn't updated as often as {@link ViewPager#getCurrentItem()} is. |
| 82 | * <p> |
| 83 | * We must be careful to null out this reference when the pager and adapter are decoupled to |
| 84 | * minimize dangling references. |
| 85 | */ |
| 86 | private ViewPager mPager; |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 87 | private boolean mSanitizedHtml; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 88 | |
Paul Westbrook | b334c90 | 2012-06-25 11:42:46 -0700 | [diff] [blame] | 89 | private static final String LOG_TAG = LogTag.getLogTag(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 90 | |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 91 | private static final String BUNDLE_DETACHED_MODE = |
| 92 | ConversationPagerAdapter.class.getName() + "-detachedmode"; |
| 93 | |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 94 | public ConversationPagerAdapter(Resources res, FragmentManager fm, Account account, |
| 95 | Folder folder, Conversation initialConversation) { |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 96 | super(fm, false /* enableSavedStates */); |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 97 | mResources = res; |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 98 | mCommonFragmentArgs = AbstractConversationViewFragment.makeBasicArgs(account, folder); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 99 | mInitialConversation = initialConversation; |
Andy Huang | b373e3e | 2012-06-29 19:18:47 -0700 | [diff] [blame] | 100 | mAccount = account; |
| 101 | mFolder = folder; |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 102 | mSanitizedHtml = mAccount.supportsCapability |
| 103 | (UIProvider.AccountCapabilities.SANITIZED_HTML); |
Andy Huang | b373e3e | 2012-06-29 19:18:47 -0700 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | public boolean matches(Account account, Folder folder) { |
| 107 | return mAccount != null && mFolder != null && mAccount.matches(account) |
| 108 | && mFolder.equals(folder); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 109 | } |
| 110 | |
| 111 | public void setSingletonMode(boolean enabled) { |
| 112 | if (mSingletonMode != enabled) { |
| 113 | mSingletonMode = enabled; |
| 114 | notifyDataSetChanged(); |
| 115 | } |
| 116 | } |
| 117 | |
| 118 | public boolean isSingletonMode() { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 119 | return mSingletonMode; |
| 120 | } |
| 121 | |
mindyp | 77fb5be | 2012-09-26 15:43:40 -0700 | [diff] [blame] | 122 | public boolean isDetached() { |
| 123 | return mDetachedMode; |
| 124 | } |
| 125 | |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 126 | public boolean isPagingDisabled() { |
| 127 | return mSingletonMode || mDetachedMode || getCursor() == null; |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 128 | } |
| 129 | |
Paul Westbrook | 4de145b | 2012-12-19 16:43:25 -0800 | [diff] [blame] | 130 | private ConversationCursor getCursor() { |
Vikram Aggarwal | a91d00b | 2013-01-18 12:00:37 -0800 | [diff] [blame^] | 131 | if (mDetachedMode) { |
| 132 | // In detached mode, the pager is decoupled from the cursor. Nothing should rely on the |
| 133 | // cursor at this point. |
| 134 | return null; |
| 135 | } |
Andy Huang | 090db1e | 2012-07-25 13:25:28 -0700 | [diff] [blame] | 136 | if (mController == null) { |
Vikram Aggarwal | 192fac1 | 2012-07-25 16:44:55 -0700 | [diff] [blame] | 137 | // Happens when someone calls setActivityController(null) on us. This is done in |
| 138 | // ConversationPagerController.stopListening() to indicate that the Conversation View |
| 139 | // is going away *very* soon. |
Andy Huang | 3825f3d | 2012-08-29 16:44:12 -0700 | [diff] [blame] | 140 | LogUtils.i(LOG_TAG, "Pager adapter has a null controller. If the conversation view" |
Vikram Aggarwal | 192fac1 | 2012-07-25 16:44:55 -0700 | [diff] [blame] | 141 | + " is going away, this is fine. Otherwise, the state is inconsistent"); |
Andy Huang | 8775ffa | 2012-06-27 16:40:04 -0700 | [diff] [blame] | 142 | return null; |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 143 | } |
| 144 | |
Andy Huang | 090db1e | 2012-07-25 13:25:28 -0700 | [diff] [blame] | 145 | return mController.getConversationListCursor(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 146 | } |
| 147 | |
| 148 | @Override |
| 149 | public Fragment getItem(int position) { |
| 150 | final Conversation c; |
| 151 | |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 152 | if (isPagingDisabled()) { |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 153 | // cursor-less adapter is a size-1 cursor that points to mInitialConversation. |
| 154 | // sanity-check |
| 155 | if (position != 0) { |
| 156 | LogUtils.wtf(LOG_TAG, "pager cursor is null and position is non-zero: %d", |
| 157 | position); |
| 158 | } |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 159 | c = getDefaultConversation(); |
Vikram Aggarwal | c769422 | 2012-04-23 13:37:01 -0700 | [diff] [blame] | 160 | c.position = 0; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 161 | } else { |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 162 | final Cursor cursor = getCursor(); |
Andy Huang | 8775ffa | 2012-06-27 16:40:04 -0700 | [diff] [blame] | 163 | if (cursor == null) { |
| 164 | LogUtils.wtf(LOG_TAG, "unable to get ConversationCursor, pos=%d", position); |
| 165 | return null; |
| 166 | } |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 167 | if (!cursor.moveToPosition(position)) { |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 168 | LogUtils.wtf(LOG_TAG, "unable to seek to ConversationCursor pos=%d (%s)", position, |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 169 | cursor); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 170 | return null; |
| 171 | } |
| 172 | // TODO: switch to something like MessageCursor or AttachmentCursor |
| 173 | // to re-use these models |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 174 | c = new Conversation(cursor); |
Vikram Aggarwal | c769422 | 2012-04-23 13:37:01 -0700 | [diff] [blame] | 175 | c.position = position; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 176 | } |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 177 | final Fragment f = getConversationViewFragment(c); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 178 | LogUtils.d(LOG_TAG, "IN PagerAdapter.getItem, frag=%s subj=%s", f, c.subject); |
| 179 | return f; |
| 180 | } |
| 181 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 182 | private AbstractConversationViewFragment getConversationViewFragment(Conversation c) { |
| 183 | if (mSanitizedHtml) { |
| 184 | return ConversationViewFragment.newInstance(mCommonFragmentArgs, c); |
| 185 | } else { |
| 186 | return SecureConversationViewFragment.newInstance(mCommonFragmentArgs, c); |
| 187 | } |
| 188 | } |
| 189 | |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 190 | @Override |
| 191 | public int getCount() { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 192 | if (isPagingDisabled()) { |
Andy Huang | 3825f3d | 2012-08-29 16:44:12 -0700 | [diff] [blame] | 193 | LogUtils.d(LOG_TAG, "IN CPA.getCount, returning 1 (effective singleton). cursor=%s", |
| 194 | getCursor()); |
Andy Huang | 8775ffa | 2012-06-27 16:40:04 -0700 | [diff] [blame] | 195 | return 1; |
| 196 | } |
| 197 | final Cursor cursor = getCursor(); |
| 198 | if (cursor == null) { |
| 199 | return 0; |
| 200 | } |
| 201 | return cursor.getCount(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 202 | } |
| 203 | |
| 204 | @Override |
| 205 | public int getItemPosition(Object item) { |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 206 | if (!(item instanceof AbstractConversationViewFragment)) { |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 207 | LogUtils.wtf(LOG_TAG, "getItemPosition received unexpected item: %s", item); |
| 208 | } |
| 209 | |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 210 | final AbstractConversationViewFragment fragment = (AbstractConversationViewFragment) item; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 211 | return getConversationPosition(fragment.getConversation()); |
| 212 | } |
| 213 | |
| 214 | @Override |
| 215 | public void setPrimaryItem(ViewGroup container, int position, Object object) { |
| 216 | LogUtils.d(LOG_TAG, "IN PagerAdapter.setPrimaryItem, pos=%d, frag=%s", position, |
| 217 | object); |
| 218 | super.setPrimaryItem(container, position, object); |
| 219 | } |
| 220 | |
| 221 | @Override |
| 222 | public CharSequence getPageTitle(int position) { |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 223 | final String title; |
| 224 | final int currentPosition = mPager.getCurrentItem(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 225 | |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 226 | if (isPagingDisabled()) { |
Andy Huang | 68459a7 | 2012-08-09 19:09:38 -0700 | [diff] [blame] | 227 | title = null; |
| 228 | } else if (position == currentPosition) { |
Andy Huang | 090db1e | 2012-07-25 13:25:28 -0700 | [diff] [blame] | 229 | int total = getCount(); |
| 230 | if (mController != null) { |
| 231 | final Folder f = mController.getFolder(); |
| 232 | if (f != null && f.totalCount > total) { |
| 233 | total = f.totalCount; |
| 234 | } |
| 235 | } |
| 236 | title = mResources.getString(R.string.conversation_count, position + 1, total); |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 237 | } else { |
Andy Huang | 68459a7 | 2012-08-09 19:09:38 -0700 | [diff] [blame] | 238 | title = mResources.getString(position < currentPosition ? |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 239 | R.string.conversation_newer : R.string.conversation_older); |
| 240 | } |
| 241 | return title; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | @Override |
| 245 | public Parcelable saveState() { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 246 | LogUtils.d(LOG_TAG, "IN PagerAdapter.saveState. this=%s", this); |
| 247 | Bundle state = (Bundle) super.saveState(); // superclass uses a Bundle |
| 248 | if (state == null) { |
| 249 | state = new Bundle(); |
| 250 | } |
| 251 | state.putBoolean(BUNDLE_DETACHED_MODE, mDetachedMode); |
| 252 | return state; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | @Override |
| 256 | public void restoreState(Parcelable state, ClassLoader loader) { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 257 | LogUtils.d(LOG_TAG, "IN PagerAdapter.restoreState. this=%s", this); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 258 | super.restoreState(state, loader); |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 259 | if (state != null) { |
| 260 | Bundle b = (Bundle) state; |
| 261 | b.setClassLoader(loader); |
| 262 | mDetachedMode = b.getBoolean(BUNDLE_DETACHED_MODE); |
| 263 | } |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 264 | } |
| 265 | |
| 266 | @Override |
| 267 | public void startUpdate(ViewGroup container) { |
| 268 | mSafeToNotify = false; |
| 269 | super.startUpdate(container); |
| 270 | } |
| 271 | |
| 272 | @Override |
| 273 | public void finishUpdate(ViewGroup container) { |
| 274 | super.finishUpdate(container); |
| 275 | mSafeToNotify = true; |
| 276 | } |
| 277 | |
| 278 | @Override |
| 279 | public void notifyDataSetChanged() { |
| 280 | if (!mSafeToNotify) { |
| 281 | LogUtils.d(LOG_TAG, "IN PagerAdapter.notifyDataSetChanged, ignoring unsafe update"); |
| 282 | return; |
| 283 | } |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 284 | |
Vikram Aggarwal | a91d00b | 2013-01-18 12:00:37 -0800 | [diff] [blame^] | 285 | // If we are in detached mode, changes to the cursor are of no interest to us, but they may |
| 286 | // be to parent classes. |
| 287 | |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 288 | // when the currently visible item disappears from the dataset: |
| 289 | // if the new version of the currently visible item has zero messages: |
| 290 | // notify the list controller so it can handle this 'current conversation gone' case |
| 291 | // (by backing out of conversation mode) |
| 292 | // else |
| 293 | // 'detach' the conversation view from the cursor, keeping the current item as-is but |
| 294 | // disabling swipe (effectively the same as singleton mode) |
Vikram Aggarwal | a91d00b | 2013-01-18 12:00:37 -0800 | [diff] [blame^] | 295 | if (mController != null && !mDetachedMode) { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 296 | final Conversation currConversation = mController.getCurrentConversation(); |
| 297 | final int pos = getConversationPosition(currConversation); |
Vikram Aggarwal | 49e0e99 | 2012-09-21 13:53:15 -0700 | [diff] [blame] | 298 | if (pos == POSITION_NONE && getCursor() != null && currConversation != null) { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 299 | // enable detached mode and do no more here. the fragment itself will figure out |
| 300 | // if the conversation is empty (using message list cursor) and back out if needed. |
| 301 | mDetachedMode = true; |
Vikram Aggarwal | a91d00b | 2013-01-18 12:00:37 -0800 | [diff] [blame^] | 302 | mController.setDetachedMode(); |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 303 | LogUtils.i(LOG_TAG, "CPA: current conv is gone, reverting to detached mode. c=%s", |
| 304 | currConversation.uri); |
mindyp | 36280f3 | 2012-09-09 16:11:23 -0700 | [diff] [blame] | 305 | } else { |
mindyp | 8995554 | 2012-09-13 09:58:16 -0700 | [diff] [blame] | 306 | // notify unaffected fragment items of the change, so they can |
| 307 | // re-render |
| 308 | // (the change may have been to the labels for a single |
| 309 | // conversation, for example) |
mindyp | 26d4d2d | 2012-09-18 17:30:32 -0700 | [diff] [blame] | 310 | final AbstractConversationViewFragment frag = |
| 311 | (AbstractConversationViewFragment) getFragmentAt(pos); |
mindyp | 1698247 | 2012-09-18 16:13:51 -0700 | [diff] [blame] | 312 | final Cursor cursor = getCursor(); |
Andy Huang | 9d3fd92 | 2012-09-26 22:23:58 -0700 | [diff] [blame] | 313 | if (frag != null && cursor.moveToPosition(pos) && frag.isUserVisible()) { |
mindyp | 1698247 | 2012-09-18 16:13:51 -0700 | [diff] [blame] | 314 | // reload what we think is in the current position. |
mindyp | b2b98ba | 2012-09-24 14:13:58 -0700 | [diff] [blame] | 315 | Conversation conv = new Conversation(cursor); |
mindyp | a825aae | 2012-09-25 10:12:53 -0700 | [diff] [blame] | 316 | conv.position = pos; |
mindyp | b2b98ba | 2012-09-24 14:13:58 -0700 | [diff] [blame] | 317 | frag.onConversationUpdated(conv); |
| 318 | mController.setCurrentConversation(conv); |
mindyp | 1698247 | 2012-09-18 16:13:51 -0700 | [diff] [blame] | 319 | } |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 320 | } |
| 321 | } |
| 322 | |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 323 | super.notifyDataSetChanged(); |
| 324 | } |
| 325 | |
| 326 | @Override |
| 327 | public void setItemVisible(Fragment item, boolean visible) { |
| 328 | super.setItemVisible(item, visible); |
mindyp | f4fce12 | 2012-09-14 15:55:33 -0700 | [diff] [blame] | 329 | final AbstractConversationViewFragment fragment = (AbstractConversationViewFragment) item; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 330 | fragment.setExtraUserVisibleHint(visible); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 331 | } |
| 332 | |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 333 | private Conversation getDefaultConversation() { |
| 334 | Conversation c = (mController != null) ? mController.getCurrentConversation() : null; |
| 335 | if (c == null) { |
| 336 | c = mInitialConversation; |
| 337 | } |
| 338 | return c; |
| 339 | } |
| 340 | |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 341 | public int getConversationPosition(Conversation conv) { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 342 | if (isPagingDisabled()) { |
Andy Huang | 1ee96b2 | 2012-08-24 20:19:53 -0700 | [diff] [blame] | 343 | if (conv != getDefaultConversation()) { |
Vikram Aggarwal | 49e0e99 | 2012-09-21 13:53:15 -0700 | [diff] [blame] | 344 | LogUtils.d(LOG_TAG, "unable to find conversation in singleton mode. c=%s", conv); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 345 | return POSITION_NONE; |
| 346 | } |
| 347 | return 0; |
| 348 | } |
| 349 | |
Paul Westbrook | 4de145b | 2012-12-19 16:43:25 -0800 | [diff] [blame] | 350 | final ConversationCursor cursor = getCursor(); |
Vikram Aggarwal | 49e0e99 | 2012-09-21 13:53:15 -0700 | [diff] [blame] | 351 | if (cursor == null || conv == null) { |
Andy Huang | 8775ffa | 2012-06-27 16:40:04 -0700 | [diff] [blame] | 352 | return POSITION_NONE; |
| 353 | } |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 354 | |
Andy Huang | ca85441 | 2012-04-20 19:55:38 -0700 | [diff] [blame] | 355 | int result = POSITION_NONE; |
Paul Westbrook | c8f2a3c | 2013-01-08 13:57:24 -0800 | [diff] [blame] | 356 | final int pos = cursor.getConversationPosition(conv.id); |
| 357 | if (pos >= 0) { |
| 358 | LogUtils.d(LOG_TAG, "pager adapter found repositioned convo '%s' at pos=%d", |
| 359 | conv.subject, pos); |
| 360 | result = pos; |
Andy Huang | ca85441 | 2012-04-20 19:55:38 -0700 | [diff] [blame] | 361 | } |
| 362 | |
| 363 | return result; |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 364 | } |
| 365 | |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 366 | public void setPager(ViewPager pager) { |
Andy Huang | 7d64612 | 2012-09-05 19:41:44 -0700 | [diff] [blame] | 367 | if (mPager != null) { |
| 368 | mPager.setOnPageChangeListener(null); |
| 369 | } |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 370 | mPager = pager; |
Andy Huang | 7d64612 | 2012-09-05 19:41:44 -0700 | [diff] [blame] | 371 | if (mPager != null) { |
| 372 | mPager.setOnPageChangeListener(this); |
| 373 | } |
Andy Huang | 22ecc77 | 2012-05-16 16:11:54 -0700 | [diff] [blame] | 374 | } |
| 375 | |
Andy Huang | 090db1e | 2012-07-25 13:25:28 -0700 | [diff] [blame] | 376 | public void setActivityController(ActivityController controller) { |
| 377 | if (mController != null) { |
| 378 | mController.unregisterConversationListObserver(mListObserver); |
Andy Huang | 8601644 | 2012-08-29 16:58:24 -0700 | [diff] [blame] | 379 | mController.unregisterFolderObserver(mFolderObserver); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 380 | } |
Andy Huang | 090db1e | 2012-07-25 13:25:28 -0700 | [diff] [blame] | 381 | mController = controller; |
| 382 | if (mController != null) { |
| 383 | mController.registerConversationListObserver(mListObserver); |
Andy Huang | 8601644 | 2012-08-29 16:58:24 -0700 | [diff] [blame] | 384 | mController.registerFolderObserver(mFolderObserver); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 385 | |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 386 | notifyDataSetChanged(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 387 | } else { |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 388 | // We're being torn down; do not notify. |
| 389 | // Let the pager controller manage pager lifecycle. |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 390 | } |
| 391 | } |
| 392 | |
Andy Huang | 7d64612 | 2012-09-05 19:41:44 -0700 | [diff] [blame] | 393 | @Override |
| 394 | public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { |
| 395 | // no-op |
| 396 | } |
| 397 | |
| 398 | @Override |
| 399 | public void onPageSelected(int position) { |
Vikram Aggarwal | 66db04c | 2012-10-04 16:04:04 -0700 | [diff] [blame] | 400 | if (mController == null) { |
| 401 | return; |
Andy Huang | 7d64612 | 2012-09-05 19:41:44 -0700 | [diff] [blame] | 402 | } |
Vikram Aggarwal | 66db04c | 2012-10-04 16:04:04 -0700 | [diff] [blame] | 403 | final Cursor cursor = getCursor(); |
| 404 | if (cursor == null || !cursor.moveToPosition(position)) { |
| 405 | // No valid cursor or it doesn't have the position we want. Bail. |
| 406 | return; |
| 407 | } |
| 408 | final Conversation c = new Conversation(cursor); |
| 409 | c.position = position; |
| 410 | LogUtils.d(LOG_TAG, "pager adapter setting current conv: %s", c.subject); |
| 411 | mController.setCurrentConversation(c); |
Andy Huang | 7d64612 | 2012-09-05 19:41:44 -0700 | [diff] [blame] | 412 | } |
| 413 | |
| 414 | @Override |
| 415 | public void onPageScrollStateChanged(int state) { |
| 416 | // no-op |
| 417 | } |
| 418 | |
Andy Huang | 090db1e | 2012-07-25 13:25:28 -0700 | [diff] [blame] | 419 | // update the pager title strip as the Folder's conversation count changes |
| 420 | private class FolderObserver extends DataSetObserver { |
| 421 | @Override |
| 422 | public void onChanged() { |
| 423 | notifyDataSetChanged(); |
| 424 | } |
| 425 | } |
| 426 | |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 427 | // update the pager dataset as the Controller's cursor changes |
| 428 | private class ListObserver extends DataSetObserver { |
| 429 | @Override |
| 430 | public void onChanged() { |
Andy Huang | e3df1ad | 2012-04-24 17:15:23 -0700 | [diff] [blame] | 431 | notifyDataSetChanged(); |
Andy Huang | 632721e | 2012-04-11 16:57:26 -0700 | [diff] [blame] | 432 | } |
| 433 | @Override |
| 434 | public void onInvalidated() { |
| 435 | } |
| 436 | } |
| 437 | |
| 438 | } |