Home | History | Annotate | Download | only in data 
      1 /*
      2  * Copyright (C) 2010 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.gallery3d.data;
     18 
     19 import android.content.Context;
     20 import android.content.res.Resources;
     21 
     22 import com.android.gallery3d.R;
     23 
     24 import java.util.ArrayList;
     25 
     26 public class SizeClustering extends Clustering {
     27     @SuppressWarnings("unused")
     28     private static final String TAG = "SizeClustering";
     29 
     30     private Context mContext;
     31     private ArrayList<Path>[] mClusters;
     32     private String[] mNames;
     33     private long mMinSizes[];
     34 
     35     private static final long MEGA_BYTES = 1024L*1024;
     36     private static final long GIGA_BYTES = 1024L*1024*1024;
     37 
     38     private static final long[] SIZE_LEVELS = {
     39         0,
     40         1 * MEGA_BYTES,
     41         10 * MEGA_BYTES,
     42         100 * MEGA_BYTES,
     43         1 * GIGA_BYTES,
     44         2 * GIGA_BYTES,
     45         4 * GIGA_BYTES,
     46     };
     47 
     48     public SizeClustering(Context context) {
     49         mContext = context;
     50     }
     51 
     52     @SuppressWarnings("unchecked")
     53     @Override
     54     public void run(MediaSet baseSet) {
     55         @SuppressWarnings("unchecked")
     56         final ArrayList<Path>[] group = new ArrayList[SIZE_LEVELS.length];
     57         baseSet.enumerateTotalMediaItems(new MediaSet.ItemConsumer() {
     58             @Override
     59             public void consume(int index, MediaItem item) {
     60                 // Find the cluster this item belongs to.
     61                 long size = item.getSize();
     62                 int i;
     63                 for (i = 0; i < SIZE_LEVELS.length - 1; i++) {
     64                     if (size < SIZE_LEVELS[i + 1]) {
     65                         break;
     66                     }
     67                 }
     68 
     69                 ArrayList<Path> list = group[i];
     70                 if (list == null) {
     71                     list = new ArrayList<Path>();
     72                     group[i] = list;
     73                 }
     74                 list.add(item.getPath());
     75             }
     76         });
     77 
     78         int count = 0;
     79         for (int i = 0; i < group.length; i++) {
     80             if (group[i] != null) {
     81                 count++;
     82             }
     83         }
     84 
     85         mClusters = new ArrayList[count];
     86         mNames = new String[count];
     87         mMinSizes = new long[count];
     88 
     89         Resources res = mContext.getResources();
     90         int k = 0;
     91         // Go through group in the reverse order, so the group with the largest
     92         // size will show first.
     93         for (int i = group.length - 1; i >= 0; i--) {
     94             if (group[i] == null) continue;
     95 
     96             mClusters[k] = group[i];
     97             if (i == 0) {
     98                 mNames[k] = String.format(
     99                         res.getString(R.string.size_below), getSizeString(i + 1));
    100             } else if (i == group.length - 1) {
    101                 mNames[k] = String.format(
    102                         res.getString(R.string.size_above), getSizeString(i));
    103             } else {
    104                 String minSize = getSizeString(i);
    105                 String maxSize = getSizeString(i + 1);
    106                 mNames[k] = String.format(
    107                         res.getString(R.string.size_between), minSize, maxSize);
    108             }
    109             mMinSizes[k] = SIZE_LEVELS[i];
    110             k++;
    111         }
    112     }
    113 
    114     private String getSizeString(int index) {
    115         long bytes = SIZE_LEVELS[index];
    116         if (bytes >= GIGA_BYTES) {
    117             return (bytes / GIGA_BYTES) + "GB";
    118         } else {
    119             return (bytes / MEGA_BYTES) + "MB";
    120         }
    121     }
    122 
    123     @Override
    124     public int getNumberOfClusters() {
    125         return mClusters.length;
    126     }
    127 
    128     @Override
    129     public ArrayList<Path> getCluster(int index) {
    130         return mClusters[index];
    131     }
    132 
    133     @Override
    134     public String getClusterName(int index) {
    135         return mNames[index];
    136     }
    137 
    138     public long getMinSize(int index) {
    139         return mMinSizes[index];
    140     }
    141 }
    142