thoerup/side9/ImageAdapter.java

package dk.thoerup.side9;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Comparator;

import java.util.Collections;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Bitmap.CompressFormat;
import android.os.Environment;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.BaseAdapter;
import android.widget.GridView;
import android.widget.ImageView;
import android.widget.Toast;

public class ImageAdapter extends BaseAdapter {
        final static String DIR_NAME = "/Side9";
        final static String THUMBDIR_NAME = "/.thumb/";

        //int mGalleryItemBackground;
    private Context mContext;
    
    ArrayList<ImageEntry> mImages = new ArrayList<ImageEntry>();
    
    int thumbSize;
    

    public ImageAdapter(Context c) {
        mContext = c;
        
        String path = Environment.getExternalStorageDirectory().getPath() + DIR_NAME ;
                
        
        File root = new File(path);
        
        if (root.exists() == false) {
                Toast.makeText(mContext, "Side9 folder not found on sdcard", Toast.LENGTH_LONG).show();
                return;
        } 

        File files[] = root.listFiles( new ExtensionFilter("jpg") );
                
        
        for (File f : files) {          
                ImageEntry entry = new ImageEntry();
                entry.path = f.getPath(); 

                //entry.thumb = generateAndLoadThumb(f);

                
                /* load captions */
                String infoFileName = f.getPath().replace(".jpg", ".txt");

                File infoFile = new File(infoFileName);
                if (infoFile.exists() ) { 
                        entry.caption = cleanString( getFileContent(infoFile) );
                } else {
                        entry.caption = "";
                }               
            
                mImages.add(entry);
        }
        
        Collections.sort(mImages,  new ImageEntry.PathComparator() );        
        preloadImages(0,30);
        
        thumbSize = getSize();
    }
    
    public void cleanUp() {
        mImages.clear();
    }

    
    public void preloadImages(int offset, int count) {
        final int max = mImages.size();
        
        for (int i=offset; i<(offset+count) && i<max; i++) {
                ImageEntry entry = mImages.get(i);
                
                if (entry.thumb == null) {
                        entry.thumb = generateAndLoadThumb( new File(entry.path) );
                }
        }       
    }
    
    public static Bitmap generateAndLoadThumb(File image) {
        
        File thumbDir = new File(Environment.getExternalStorageDirectory().getPath() + DIR_NAME + THUMBDIR_NAME);
        String fileName = image.getName();
        File thumb = new File ( thumbDir.getPath() + "/" + fileName );
        
        Bitmap thumbBmp = null;
        
        if (! thumbDir.exists()) {
                thumbDir.mkdirs();
        }
        
        if (! thumb.exists() || thumb.lastModified() < image.lastModified()) {
                Bitmap bmp = BitmapFactory.decodeFile( image.getPath() );
                thumbBmp =  Bitmap.createScaledBitmap(bmp, bmp.getWidth()/4, bmp.getHeight()/4, true);

                try {
                        FileOutputStream fos = new FileOutputStream(thumb);
                        thumbBmp.compress(CompressFormat.JPEG, 90, fos);   
                        fos.close();
                        
                } catch (IOException e) {
                        Log.e("Side9", "error", e);
                }
                
        } else {
                thumbBmp = BitmapFactory.decodeFile( thumb.getPath());
        }       
        return thumbBmp;
    }
    
    private void orderImages(Comparator<ImageEntry> comparator) {
        Collections.sort(mImages, comparator);
        preloadImages(0,30);
        this.notifyDataSetChanged();            
    }
    
    public void orderByPath() {
        orderImages( new ImageEntry.PathComparator());
    }
    
    public void orderByCaption() {
        orderImages(new ImageEntry.CaptionComparator());
    }
    
    @Override
    public int getCount() {
        return mImages.size();
    }

    @Override
    public Object getItem(int position) {
        return position;
    }

    @Override
    public long getItemId(int position) {
        return position;
    }
    
    public ImageEntry getImageEntry(int position) {
        return mImages.get(position);
    }
    
    public ArrayList<ImageEntry> getImages() {
        return mImages;
    }
    
    private int getSize() {
                 DisplayMetrics metrics = new DisplayMetrics();
                 WindowManager wmgr = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
                 wmgr.getDefaultDisplay().getMetrics(metrics);
                 if (metrics.widthPixels < 480) {
                         return 150;
                 } else {
                         return 200;
                 }
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        
        if (position >= mImages.size()) {
                return null;
        }
        
        ImageEntry currentEntry = mImages.get(position);

        if (currentEntry.thumb == null ) {
                File thumb = new File ( currentEntry.path );
                currentEntry.thumb = generateAndLoadThumb(thumb);
        }
        
        ImageView imageView;
        if (convertView == null) {  // if it's not recycled, initialize some attributes
            imageView = new ImageView(mContext);
            imageView.setLayoutParams(new GridView.LayoutParams(thumbSize, thumbSize));
            imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
            imageView.setAdjustViewBounds(true);   
            imageView.setPadding(4, 4, 4, 4);
        } else {
            imageView = (ImageView) convertView;
        }

        //imageView.setImageURI(  Uri.parse(mThumbPaths.get(position)) );
        imageView.setImageBitmap( currentEntry.thumb );
        return imageView;
    }
    
        String getFileContent(File filename) {
                try {
                        RandomAccessFile raf = new RandomAccessFile(filename, "r");
                        int size = (int)raf.length();
                        byte buf[] = new byte[size];
                        
                        raf.readFully(buf);                     
                        raf.close();
                        
                        return new String(buf);                 
                } catch (IOException e) {
                        Log.e("Side9", "Error", e);
                        return "";
                }
        }
        
        String cleanString(String input) { //trim and remove double spaces
                String res = input.trim();
                while ( res.contains( "  ")) {
                        res = res.replace("  ", " ");
                }
                
                return res;
        }
        
        public String getItemCaption(int idx) {
                return mImages.get(idx).caption.split(" ")[0].replace(',', ' ');
        }
        
        public String getItemFilename(int idx) {
                File f = new File(mImages.get(idx).path);
                return f.getName().split("_")[0];
        }
        

    class ExtensionFilter implements FilenameFilter {
        private String mExt;
        public ExtensionFilter(String ext) {
                mExt = ext;
        }

                @Override
                public boolean accept(File dir, String filename) {
                        String parts[] = filename.split("\\.");
                        if (parts.length > 1) {
                                String ext = parts[ parts.length -1];
                                if (ext.equals(mExt)) {
                                        return true;
                                }
                        }
                        return false;
                }
        
    }
}
1	torben	790	package dk.thoerup.side9;
2
3			import java.io.File;
4	torben	1013	import java.io.FileOutputStream;
5	torben	925	import java.io.FilenameFilter;
6	torben	1013	import java.io.IOException;
7	torben	1185	import java.io.RandomAccessFile;
8	torben	790	import java.util.ArrayList;
9	torben	1230	import java.util.Comparator;
10	torben	1224
11	torben	1185	import java.util.Collections;
12	torben	790
13			import android.content.Context;
14			import android.graphics.Bitmap;
15			import android.graphics.BitmapFactory;
16	torben	1013	import android.graphics.Bitmap.CompressFormat;
17	torben	790	import android.os.Environment;
18	torben	915	import android.util.DisplayMetrics;
19	torben	1013	import android.util.Log;
20	torben	790	import android.view.View;
21			import android.view.ViewGroup;
22	torben	915	import android.view.WindowManager;
23	torben	790	import android.widget.BaseAdapter;
24			import android.widget.GridView;
25			import android.widget.ImageView;
26	torben	912	import android.widget.Toast;
27	torben	790
28			public class ImageAdapter extends BaseAdapter {
29	torben	1222	final static String DIR_NAME = "/Side9";
30			final static String THUMBDIR_NAME = "/.thumb/";
31	torben	1185
32	torben	1223	//int mGalleryItemBackground;
33	torben	790	private Context mContext;
34
35	torben	1185	ArrayList<ImageEntry> mImages = new ArrayList<ImageEntry>();
36	torben	915
37	torben	1185	int thumbSize;
38	torben	1222
39	torben	790
40	torben	1222
41	torben	790	public ImageAdapter(Context c) {
42			mContext = c;
43
44	torben	1222	String path = Environment.getExternalStorageDirectory().getPath() + DIR_NAME ;
45
46	torben	790
47			File root = new File(path);
48	torben	912
49			if (root.exists() == false) {
50			Toast.makeText(mContext, "Side9 folder not found on sdcard", Toast.LENGTH_LONG).show();
51			return;
52			}
53	torben	925
54			File files[] = root.listFiles( new ExtensionFilter("jpg") );
55	torben	1222
56	torben	912
57	torben	1222	for (File f : files) {
58	torben	1185	ImageEntry entry = new ImageEntry();
59			entry.path = f.getPath();
60	torben	1013
61	torben	1223	//entry.thumb = generateAndLoadThumb(f);
62	torben	1222
63	torben	1013
64	torben	1185	/* load captions */
65			String infoFileName = f.getPath().replace(".jpg", ".txt");
66
67			File infoFile = new File(infoFileName);
68			if (infoFile.exists() ) {
69			entry.caption = cleanString( getFileContent(infoFile) );
70			} else {
71			entry.caption = "";
72			}
73
74			mImages.add(entry);
75	torben	1013	}
76
77	torben	1230	Collections.sort(mImages, new ImageEntry.PathComparator() );
78			preloadImages(0,30);
79	torben	1185
80			thumbSize = getSize();
81	torben	790	}
82	torben	1185
83	torben	1212	public void cleanUp() {
84			mImages.clear();
85			}
86	torben	1229
87	torben	1212
88	torben	1229	public void preloadImages(int offset, int count) {
89			final int max = mImages.size();
90
91			for (int i=offset; i<(offset+count) && i<max; i++) {
92			ImageEntry entry = mImages.get(i);
93
94			if (entry.thumb == null) {
95			entry.thumb = generateAndLoadThumb( new File(entry.path) );
96			}
97			}
98			}
99
100	torben	1223	public static Bitmap generateAndLoadThumb(File image) {
101
102			File thumbDir = new File(Environment.getExternalStorageDirectory().getPath() + DIR_NAME + THUMBDIR_NAME);
103			String fileName = image.getName();
104			File thumb = new File ( thumbDir.getPath() + "/" + fileName );
105
106			Bitmap thumbBmp = null;
107
108			if (! thumbDir.exists()) {
109			thumbDir.mkdirs();
110			}
111
112			if (! thumb.exists() \|\| thumb.lastModified() < image.lastModified()) {
113			Bitmap bmp = BitmapFactory.decodeFile( image.getPath() );
114			thumbBmp = Bitmap.createScaledBitmap(bmp, bmp.getWidth()/4, bmp.getHeight()/4, true);
115
116			try {
117			FileOutputStream fos = new FileOutputStream(thumb);
118			thumbBmp.compress(CompressFormat.JPEG, 90, fos);
119			fos.close();
120
121			} catch (IOException e) {
122			Log.e("Side9", "error", e);
123			}
124
125			} else {
126			thumbBmp = BitmapFactory.decodeFile( thumb.getPath());
127			}
128			return thumbBmp;
129			}
130
131	torben	1230	private void orderImages(Comparator<ImageEntry> comparator) {
132			Collections.sort(mImages, comparator);
133			preloadImages(0,30);
134			this.notifyDataSetChanged();
135			}
136
137	torben	1185	public void orderByPath() {
138	torben	1230	orderImages( new ImageEntry.PathComparator());
139	torben	1185	}
140
141			public void orderByCaption() {
142	torben	1230	orderImages(new ImageEntry.CaptionComparator());
143	torben	1185	}
144
145	torben	1224	@Override
146	torben	790	public int getCount() {
147	torben	1185	return mImages.size();
148	torben	790	}
149
150	torben	1224	@Override
151	torben	790	public Object getItem(int position) {
152			return position;
153			}
154
155	torben	1224	@Override
156	torben	790	public long getItemId(int position) {
157			return position;
158			}
159
160	torben	1185	public ImageEntry getImageEntry(int position) {
161			return mImages.get(position);
162	torben	790	}
163	torben	915
164	torben	1185	public ArrayList<ImageEntry> getImages() {
165			return mImages;
166	torben	925	}
167
168	torben	915	private int getSize() {
169			DisplayMetrics metrics = new DisplayMetrics();
170			WindowManager wmgr = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
171			wmgr.getDefaultDisplay().getMetrics(metrics);
172			if (metrics.widthPixels < 480) {
173			return 150;
174			} else {
175			return 200;
176			}
177			}
178	torben	790
179	torben	1224	@Override
180	torben	790	public View getView(int position, View convertView, ViewGroup parent) {
181	torben	1223
182			if (position >= mImages.size()) {
183			return null;
184			}
185
186			ImageEntry currentEntry = mImages.get(position);
187
188			if (currentEntry.thumb == null ) {
189			File thumb = new File ( currentEntry.path );
190			currentEntry.thumb = generateAndLoadThumb(thumb);
191			}
192
193	torben	790	ImageView imageView;
194			if (convertView == null) { // if it's not recycled, initialize some attributes
195			imageView = new ImageView(mContext);
196	torben	1185	imageView.setLayoutParams(new GridView.LayoutParams(thumbSize, thumbSize));
197	torben	790	imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
198			imageView.setAdjustViewBounds(true);
199			imageView.setPadding(4, 4, 4, 4);
200			} else {
201			imageView = (ImageView) convertView;
202			}
203
204	torben	1013	//imageView.setImageURI( Uri.parse(mThumbPaths.get(position)) );
205	torben	1223	imageView.setImageBitmap( currentEntry.thumb );
206	torben	790	return imageView;
207	torben	925	}
208
209	torben	1185	String getFileContent(File filename) {
210			try {
211			RandomAccessFile raf = new RandomAccessFile(filename, "r");
212			int size = (int)raf.length();
213			byte buf[] = new byte[size];
214
215	torben	1186	raf.readFully(buf);
216			raf.close();
217
218	torben	1185	return new String(buf);
219			} catch (IOException e) {
220			Log.e("Side9", "Error", e);
221			return "";
222			}
223			}
224
225			String cleanString(String input) { //trim and remove double spaces
226			String res = input.trim();
227			while ( res.contains( " ")) {
228			res = res.replace(" ", " ");
229			}
230
231			return res;
232			}
233
234	torben	1622	public String getItemCaption(int idx) {
235			return mImages.get(idx).caption.split(" ")[0].replace(',', ' ');
236			}
237
238			public String getItemFilename(int idx) {
239			File f = new File(mImages.get(idx).path);
240			return f.getName().split("_")[0];
241			}
242
243	torben	1185
244
245
246
247	torben	925	class ExtensionFilter implements FilenameFilter {
248			private String mExt;
249			public ExtensionFilter(String ext) {
250			mExt = ext;
251			}
252	torben	790
253	torben	925	@Override
254			public boolean accept(File dir, String filename) {
255			String parts[] = filename.split("\\.");
256			if (parts.length > 1) {
257			String ext = parts[ parts.length -1];
258			if (ext.equals(mExt)) {
259			return true;
260			}
261			}
262			return false;
263			}
264
265	torben	790	}
266			}