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.Collection;
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 {
        

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

    public ImageAdapter(Context c) {
        mContext = c;
        
        String path = Environment.getExternalStorageDirectory().getPath() + "/Side9" ;
        
        
        
        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") );
        

        String thumbPath =  path + "/.thumb/";
        
        File thumbDir = new File(thumbPath);
        if (! thumbDir.exists()) {
                thumbDir.mkdirs();
        }
        
        
        for (File f : files) {
                
                ImageEntry entry = new ImageEntry();
                entry.path = f.getPath(); 

                String fileName = f.getName();
                File thumb = new File ( thumbPath + fileName );
                
                if (! thumb.exists() || thumb.lastModified() < f.lastModified()) {
                        Bitmap bmp = BitmapFactory.decodeFile( f.getPath() );
                        Bitmap scaled =  Bitmap.createScaledBitmap(bmp, bmp.getWidth()/4, bmp.getHeight()/4, true);
                        entry.thumb = scaled;
                        try {
                                FileOutputStream fos = new FileOutputStream(thumb);
                                scaled.compress(CompressFormat.JPEG, 90, fos);   
                                fos.close();
                                
                        } catch (IOException e) {
                                Log.e("Side9", "error", e);
                        }
                        
                } else {
                        Bitmap thumbBmp = BitmapFactory.decodeFile( thumb.getPath());
                        entry.thumb = thumbBmp;
                }
                
                /* 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() );
        
        thumbSize = getSize();
    }
    
    public void orderByPath() {
        Collections.sort(mImages, new ImageEntry.PathComparator());
        this.notifyDataSetChanged();
    }
    
    public void orderByCaption() {
        Collections.sort(mImages, new ImageEntry.CaptionComparator());
        this.notifyDataSetChanged();
    }
    

    public int getCount() {
        return mImages.size();
    }

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

    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;
                 }
    }

    public View getView(int position, View convertView, ViewGroup parent) {
        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( mImages.get(position).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;
        }
        

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