src/com/owncloud/android/ui/preview/PreviewImagePagerAdapter.java

   1 /* ownCloud Android client application
   2  *   Copyright (C) 2012-2013  ownCloud Inc.
   3  *
   4  *   This program is free software: you can redistribute it and/or modify
   5  *   it under the terms of the GNU General Public License version 2,
   6  *   as published by the Free Software Foundation.
   7  *
   8  *   This program is distributed in the hope that it will be useful,
   9  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  *   GNU General Public License for more details.
  12  *
  13  *   You should have received a copy of the GNU General Public License
  14  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  15  *
  16  */
  17 package com.owncloud.android.ui.preview;
  18
  19 import java.util.HashMap;
  20 import java.util.HashSet;
  21 import java.util.Map;
  22 import java.util.Set;
  23 import java.util.Vector;
  24
  25 import android.accounts.Account;
  26 import android.support.v4.app.Fragment;
  27 import android.support.v4.app.FragmentManager;
  28 import android.support.v4.app.FragmentStatePagerAdapter;
  29 import android.view.ViewGroup;
  30
  31 import com.owncloud.android.datamodel.DataStorageManager;
  32 import com.owncloud.android.datamodel.OCFile;
  33 import com.owncloud.android.ui.fragment.FileFragment;
  34
  35 /**
  36  * Adapter class that provides Fragment instances
  37  *
  38  * @author David A. Velasco
  39  */
  40 //public class PreviewImagePagerAdapter extends PagerAdapter {
  41 public class PreviewImagePagerAdapter extends FragmentStatePagerAdapter {
  42
  43     private static final String TAG = PreviewImagePagerAdapter.class.getSimpleName();
  44
  45     private Vector<OCFile> mImageFiles;
  46     private Account mAccount;
  47     private Set<Object> mObsoleteFragments;
  48     private Set<Integer> mObsoletePositions;
  49     private Set<Integer> mDownloadErrors;
  50     private DataStorageManager mStorageManager;
  51
  52     private Map<Integer, FileFragment> mCachedFragments;
  53
  54     /*
  55     private final FragmentManager mFragmentManager;
  56     private FragmentTransaction mCurTransaction = null;
  57     private ArrayList<Fragment.SavedState> mSavedState = new ArrayList<Fragment.SavedState>();
  58     private ArrayList<Fragment> mFragments = new ArrayList<Fragment>();
  59     private Fragment mCurrentPrimaryItem = null;
  60     */
  61
  62     /**
  63      * Constructor.
  64      *
  65      * @param fragmentManager   {@link FragmentManager} instance that will handle the {@link Fragment}s provided by the adapter.
  66      * @param parentFolder      Folder where images will be searched for.
  67      * @param storageManager    Bridge to database.
  68      */
  69     public PreviewImagePagerAdapter(FragmentManager fragmentManager, OCFile parentFolder, Account account, DataStorageManager storageManager) {
  70         super(fragmentManager);
  71
  72         if (fragmentManager == null) {
  73             throw new IllegalArgumentException("NULL FragmentManager instance");
  74         }
  75         if (parentFolder == null) {
  76             throw new IllegalArgumentException("NULL parent folder");
  77         }
  78         if (storageManager == null) {
  79             throw new IllegalArgumentException("NULL storage manager");
  80         }
  81
  82         mAccount = account;
  83         mStorageManager = storageManager;
  84         mImageFiles = mStorageManager.getDirectoryImages(parentFolder);
  85         mObsoleteFragments = new HashSet<Object>();
  86         mObsoletePositions = new HashSet<Integer>();
  87         mDownloadErrors = new HashSet<Integer>();
  88         //mFragmentManager = fragmentManager;
  89         mCachedFragments = new HashMap<Integer, FileFragment>();
  90     }
  91
  92
  93     /**
  94      * Returns the image files handled by the adapter.
  95      *
  96      * @return  A vector with the image files handled by the adapter.
  97      */
  98     protected OCFile getFileAt(int position) {
  99         return mImageFiles.get(position);
 100     }
 101
 102
 103     public Fragment getItem(int i) {
 104         OCFile file = mImageFiles.get(i);
 105         Fragment fragment = null;
 106         if (file.isDown()) {
 107             fragment = new PreviewImageFragment(file, mAccount, mObsoletePositions.contains(Integer.valueOf(i)));
 108
 109         } else if (mDownloadErrors.contains(Integer.valueOf(i))) {
 110             fragment = new FileDownloadFragment(file, mAccount, true);
 111             ((FileDownloadFragment)fragment).setError(true);
 112             mDownloadErrors.remove(Integer.valueOf(i));
 113
 114         } else {
 115             fragment = new FileDownloadFragment(file, mAccount, mObsoletePositions.contains(Integer.valueOf(i)));
 116         }
 117         mObsoletePositions.remove(Integer.valueOf(i));
 118         return fragment;
 119     }
 120
 121     public int getFilePosition(OCFile file) {
 122         return mImageFiles.indexOf(file);
 123     }
 124
 125     @Override
 126     public int getCount() {
 127         return mImageFiles.size();
 128     }
 129
 130     @Override
 131     public CharSequence getPageTitle(int position) {
 132         return mImageFiles.get(position).getFileName();
 133     }
 134
 135
 136     public void updateFile(int position, OCFile file) {
 137         FileFragment fragmentToUpdate = mCachedFragments.get(Integer.valueOf(position));
 138         if (fragmentToUpdate != null) {
 139             mObsoleteFragments.add(fragmentToUpdate);
 140         }
 141         mObsoletePositions.add(Integer.valueOf(position));
 142         mImageFiles.set(position, file);
 143     }
 144
 145
 146     public void updateWithDownloadError(int position) {
 147         FileFragment fragmentToUpdate = mCachedFragments.get(Integer.valueOf(position));
 148         if (fragmentToUpdate != null) {
 149             mObsoleteFragments.add(fragmentToUpdate);
 150         }
 151         mDownloadErrors.add(Integer.valueOf(position));
 152     }
 153
 154     public void clearErrorAt(int position) {
 155         FileFragment fragmentToUpdate = mCachedFragments.get(Integer.valueOf(position));
 156         if (fragmentToUpdate != null) {
 157             mObsoleteFragments.add(fragmentToUpdate);
 158         }
 159         mDownloadErrors.remove(Integer.valueOf(position));
 160     }
 161
 162
 163     @Override
 164     public int getItemPosition(Object object) {
 165         if (mObsoleteFragments.contains(object)) {
 166             mObsoleteFragments.remove(object);
 167             return POSITION_NONE;
 168         }
 169         return super.getItemPosition(object);
 170     }
 171
 172
 173     @Override
 174     public Object instantiateItem(ViewGroup container, int position) {
 175         Object fragment = super.instantiateItem(container, position);
 176         mCachedFragments.put(Integer.valueOf(position), (FileFragment)fragment);
 177         return fragment;
 178     }
 179
 180     @Override
 181     public void destroyItem(ViewGroup container, int position, Object object) {
 182        mCachedFragments.remove(Integer.valueOf(position));
 183        super.destroyItem(container, position, object);
 184     }
 185
 186
 187     public boolean pendingErrorAt(int position) {
 188         return mDownloadErrors.contains(Integer.valueOf(position));
 189     }
 190
 191
 192
 193     /* -*
 194      * Called when a change in the shown pages is going to start being made.
 195      *
 196      * @param   container   The containing View which is displaying this adapter's page views.
 197      *- /
 198     @Override
 199     public void startUpdate(ViewGroup container) {
 200         Log.e(TAG, "** startUpdate");
 201     }
 202
 203     @Override
 204     public Object instantiateItem(ViewGroup container, int position) {
 205         Log.e(TAG, "** instantiateItem " + position);
 206
 207         if (mFragments.size() > position) {
 208             Fragment fragment = mFragments.get(position);
 209             if (fragment != null) {
 210                 Log.e(TAG, "** \t returning cached item");
 211                 return fragment;
 212             }
 213         }
 214
 215         if (mCurTransaction == null) {
 216             mCurTransaction = mFragmentManager.beginTransaction();
 217         }
 218
 219         Fragment fragment = getItem(position);
 220         if (mSavedState.size() > position) {
 221             Fragment.SavedState savedState = mSavedState.get(position);
 222             if (savedState != null) {
 223                 // TODO WATCH OUT:
 224                 // * The Fragment must currently be attached to the FragmentManager.
 225                 // * A new Fragment created using this saved state must be the same class type as the Fragment it was created from.
 226                 // * The saved state can not contain dependencies on other fragments -- that is it can't use putFragment(Bundle, String, Fragment)
 227                 //   to store a fragment reference
 228                 fragment.setInitialSavedState(savedState);
 229             }
 230         }
 231         while (mFragments.size() <= position) {
 232             mFragments.add(null);
 233         }
 234         fragment.setMenuVisibility(false);
 235         mFragments.set(position, fragment);
 236         //Log.e(TAG, "** \t adding fragment at position " + position + ", containerId " + container.getId());
 237         mCurTransaction.add(container.getId(), fragment);
 238
 239         return fragment;
 240     }
 241
 242     @Override
 243     public void destroyItem(ViewGroup container, int position, Object object) {
 244         Log.e(TAG, "** destroyItem " + position);
 245         Fragment fragment = (Fragment)object;
 246
 247         if (mCurTransaction == null) {
 248             mCurTransaction = mFragmentManager.beginTransaction();
 249         }
 250         Log.e(TAG, "** \t removing fragment at position " + position);
 251         while (mSavedState.size() <= position) {
 252             mSavedState.add(null);
 253         }
 254         mSavedState.set(position, mFragmentManager.saveFragmentInstanceState(fragment));
 255         mFragments.set(position, null);
 256
 257         mCurTransaction.remove(fragment);
 258     }
 259
 260     @Override
 261     public void setPrimaryItem(ViewGroup container, int position, Object object) {
 262         Fragment fragment = (Fragment)object;
 263         if (fragment != mCurrentPrimaryItem) {
 264             if (mCurrentPrimaryItem != null) {
 265                 mCurrentPrimaryItem.setMenuVisibility(false);
 266             }
 267             if (fragment != null) {
 268                 fragment.setMenuVisibility(true);
 269             }
 270             mCurrentPrimaryItem = fragment;
 271         }
 272     }
 273
 274     @Override
 275     public void finishUpdate(ViewGroup container) {
 276         Log.e(TAG, "** finishUpdate (start)");
 277         if (mCurTransaction != null) {
 278             mCurTransaction.commitAllowingStateLoss();
 279             mCurTransaction = null;
 280             mFragmentManager.executePendingTransactions();
 281         }
 282         Log.e(TAG, "** finishUpdate (end)");
 283     }
 284
 285     @Override
 286     public boolean isViewFromObject(View view, Object object) {
 287         return ((Fragment)object).getView() == view;
 288     }
 289
 290     @Override
 291     public Parcelable saveState() {
 292         Bundle state = null;
 293         if (mSavedState.size() > 0) {
 294             state = new Bundle();
 295             Fragment.SavedState[] savedStates = new Fragment.SavedState[mSavedState.size()];
 296             mSavedState.toArray(savedStates);
 297             state.putParcelableArray("states", savedStates);
 298         }
 299         for (int i=0; i<mFragments.size(); i++) {
 300             Fragment fragment = mFragments.get(i);
 301             if (fragment != null) {
 302                 if (state == null) {
 303                     state = new Bundle();
 304                 }
 305                 String key = "f" + i;
 306                 mFragmentManager.putFragment(state, key, fragment);
 307             }
 308         }
 309         return state;
 310     }
 311
 312     @Override
 313     public void restoreState(Parcelable state, ClassLoader loader) {
 314         if (state != null) {
 315             Bundle bundle = (Bundle)state;
 316             bundle.setClassLoader(loader);
 317             Parcelable[] states = bundle.getParcelableArray("states");
 318             mSavedState.clear();
 319             mFragments.clear();
 320             if (states != null) {
 321                 for (int i=0; i<states.length; i++) {
 322                     mSavedState.add((Fragment.SavedState)states[i]);
 323                 }
 324             }
 325             Iterable<String> keys = bundle.keySet();
 326             for (String key: keys) {
 327                 if (key.startsWith("f")) {
 328                     int index = Integer.parseInt(key.substring(1));
 329                     Fragment f = mFragmentManager.getFragment(bundle, key);
 330                     if (f != null) {
 331                         while (mFragments.size() <= index) {
 332                             mFragments.add(null);
 333                         }
 334                         f.setMenuVisibility(false);
 335                         mFragments.set(index, f);
 336                     } else {
 337                         Log.w(TAG, "Bad fragment at key " + key);
 338                     }
 339                 }
 340             }
 341         }
 342     }
 343     */
 344 }