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