src/com/android/camera/data/FixedFirstDataAdapter.java

   1 /*
   2  * Copyright (C) 2013 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.camera.data;
  18
  19 import android.content.Context;
  20 import android.net.Uri;
  21 import android.os.AsyncTask;
  22 import android.view.View;
  23
  24 import com.android.camera.debug.Log;
  25 import com.android.camera.filmstrip.DataAdapter;
  26 import com.android.camera.filmstrip.ImageData;
  27
  28 /**
  29  * A {@link LocalDataAdapter} which puts a {@link LocalData} fixed at the first
  30  * position. It's done by combining a {@link LocalData} and another
  31  * {@link LocalDataAdapter}.
  32  */
  33 public class FixedFirstDataAdapter extends AbstractLocalDataAdapterWrapper
  34         implements DataAdapter.Listener {
  35
  36     @SuppressWarnings("unused")
  37     private static final Log.Tag TAG = new Log.Tag("FixedFirstDataAdpt");
  38
  39     private LocalData mFirstData;
  40     private Listener mListener;
  41
  42     /**
  43      * Constructor.
  44      *
  45      * @param context Valid Android context.
  46      * @param wrappedAdapter The {@link LocalDataAdapter} to be wrapped.
  47      * @param firstData The {@link LocalData} to be placed at the first
  48      *            position.
  49      */
  50     public FixedFirstDataAdapter(
  51             Context context,
  52             LocalDataAdapter wrappedAdapter,
  53             LocalData firstData) {
  54         super(context, wrappedAdapter);
  55         if (firstData == null) {
  56             throw new AssertionError("data is null");
  57         }
  58         mFirstData = firstData;
  59     }
  60
  61     @Override
  62     public LocalData getLocalData(int dataID) {
  63         if (dataID == 0) {
  64             return mFirstData;
  65         }
  66         return mAdapter.getLocalData(dataID - 1);
  67     }
  68
  69     @Override
  70     public void removeData(int dataID) {
  71         if (dataID > 0) {
  72             mAdapter.removeData(dataID - 1);
  73         }
  74     }
  75
  76     @Override
  77     public int findDataByContentUri(Uri uri) {
  78         int pos = mAdapter.findDataByContentUri(uri);
  79         if (pos != -1) {
  80             return pos + 1;
  81         }
  82         return -1;
  83     }
  84
  85     @Override
  86     public void updateData(int pos, LocalData data) {
  87         if (pos == 0) {
  88             mFirstData = data;
  89             if (mListener != null) {
  90                 mListener.onDataUpdated(new UpdateReporter() {
  91                     @Override
  92                     public boolean isDataRemoved(int dataID) {
  93                         return false;
  94                     }
  95
  96                     @Override
  97                     public boolean isDataUpdated(int dataID) {
  98                         return (dataID == 0);
  99                     }
 100                 });
 101             }
 102         } else {
 103             mAdapter.updateData(pos - 1, data);
 104         }
 105     }
 106
 107     @Override
 108     public int getTotalNumber() {
 109         return (mAdapter.getTotalNumber() + 1);
 110     }
 111
 112     @Override
 113     public View getView(Context context, View recycled, int dataID) {
 114         if (dataID == 0) {
 115             return mFirstData.getView(
 116                     context, recycled, mSuggestedWidth, mSuggestedHeight, 0, null, false);
 117         }
 118         return mAdapter.getView(context, recycled, dataID - 1);
 119     }
 120
 121     @Override
 122     public int getItemViewType(int dataId) {
 123         if (dataId == 0) {
 124             return mFirstData.getItemViewType().ordinal();
 125         }
 126         return mAdapter.getItemViewType(dataId);
 127     }
 128
 129     @Override
 130     public void resizeView(Context context, int dataID, View view, int w, int h) {
 131         // Do nothing.
 132     }
 133
 134     @Override
 135     public ImageData getImageData(int dataID) {
 136         if (dataID == 0) {
 137             return mFirstData;
 138         }
 139         return mAdapter.getImageData(dataID - 1);
 140     }
 141
 142     @Override
 143     public void setListener(Listener listener) {
 144         mListener = listener;
 145         mAdapter.setListener((listener == null) ? null : this);
 146         // The first data is always there. Thus, When the listener is set,
 147         // we should call listener.onDataLoaded().
 148         if (mListener != null) {
 149             mListener.onDataLoaded();
 150         }
 151     }
 152
 153     @Override
 154     public boolean canSwipeInFullScreen(int dataID) {
 155         if (dataID == 0) {
 156             return mFirstData.canSwipeInFullScreen();
 157         }
 158         return mAdapter.canSwipeInFullScreen(dataID - 1);
 159     }
 160
 161     @Override
 162     public void onDataLoaded() {
 163         if (mListener == null) {
 164             return;
 165         }
 166         mListener.onDataUpdated(new UpdateReporter() {
 167             @Override
 168             public boolean isDataRemoved(int dataID) {
 169                 return false;
 170             }
 171
 172             @Override
 173             public boolean isDataUpdated(int dataID) {
 174                 return (dataID != 0);
 175             }
 176         });
 177     }
 178
 179     @Override
 180     public void onDataUpdated(final UpdateReporter reporter) {
 181         mListener.onDataUpdated(new UpdateReporter() {
 182             @Override
 183             public boolean isDataRemoved(int dataID) {
 184                 return (dataID != 0) && reporter.isDataRemoved(dataID - 1);
 185             }
 186
 187             @Override
 188             public boolean isDataUpdated(int dataID) {
 189                 return (dataID != 0) && reporter.isDataUpdated(dataID - 1);
 190             }
 191         });
 192     }
 193
 194     @Override
 195     public void onDataInserted(int dataID, ImageData data) {
 196         mListener.onDataInserted(dataID + 1, data);
 197     }
 198
 199     @Override
 200     public void onDataRemoved(int dataID, ImageData data) {
 201         mListener.onDataRemoved(dataID + 1, data);
 202     }
 203
 204     @Override
 205     public AsyncTask updateMetadata(int dataId) {
 206         if (dataId > 0) {
 207             return mAdapter.updateMetadata(dataId - 1);
 208         } else {
 209             MetadataLoader.loadMetadata(mContext, mFirstData);
 210         }
 211         return null;
 212     }
 213
 214     @Override
 215     public boolean isMetadataUpdated(int dataId) {
 216         if (dataId > 0) {
 217         return mAdapter.isMetadataUpdated(dataId - 1);
 218         } else {
 219             return mFirstData.isMetadataUpdated();
 220         }
 221     }
 222 }