image adapter for coverflow
<p>These are the activity and Image Adapter that I used for my CoverFlow. But I want to load all the images that I have saved in an sd card directory with this cover flow. How Can I do that? I have saved my images in an sd card directory called All. I want to load images from that folder. Any help is appreciated.</p>

<pre><code>public class CoverFlowExample extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        CoverFlow coverFlow;
        coverFlow = new CoverFlow(this);

        coverFlow.setAdapter(new ImageAdapter(this));

        ImageAdapter coverImageAdapter =  new ImageAdapter(this);

        coverImageAdapter.createReflectedImages();

        coverFlow.setAdapter(coverImageAdapter);

        coverFlow.setSpacing(-15);
        coverFlow.setSelection(8, true);


        setContentView(coverFlow);

        //Use this if you want to use XML layout file
        //setContentView(R.layout.main);
        //coverFlow =  (CoverFlow) findViewById(R.id.coverflow);


    }

    public class ImageAdapter extends BaseAdapter {
            int mGalleryItemBackground;
            private Context mContext;

            private FileInputStream fis;

            private Integer[] mImageIds = {

                    R.drawable.top,
                    R.drawable.bottom,
                    R.drawable.top,
                    R.drawable.bottom,
                    R.drawable.top,
                    R.drawable.bottom,
                    R.drawable.top,
                    R.drawable.bottom,
                    R.drawable.top

            };

            private ImageView[] mImages;

            public ImageAdapter(Context c) {
                mContext = c;
                mImages = new ImageView[mImageIds.length];
            }
            public boolean createReflectedImages() {
                    //The gap we want between the reflection and the original image
                    final int reflectionGap = 7;


                    int index = 0;
                    for (int imageId : mImageIds) {
                        Bitmap originalImage = BitmapFactory.decodeResource(getResources(), 
                                imageId);
                        int width = originalImage.getWidth();
                        int height = originalImage.getHeight();


                        //This will not scale but will flip on the Y axis
                        Matrix matrix = new Matrix();
                        matrix.preScale(1, -1);

                        //Create a Bitmap with the flip matrix applied to it.
                        //We only want the bottom half of the image
                        Bitmap reflectionImage = Bitmap.createBitmap(originalImage, 0, height/2, width, height/2, matrix, false);


                        //Create a new bitmap with same width but taller to fit reflection
                        Bitmap bitmapWithReflection = Bitmap.createBitmap(width 
                          , (height + height/2), Config.ARGB_8888);

                       //Create a new Canvas with the bitmap that's big enough for
                       //the image plus gap plus reflection
                       Canvas canvas = new Canvas(bitmapWithReflection);
                       //Draw in the original image
                       canvas.drawBitmap(originalImage, 0, 0, null);
                       //Draw in the gap
                       Paint deafaultPaint = new Paint();
                       canvas.drawRect(0, height, width, height + reflectionGap, deafaultPaint);
                       //Draw in the reflection
                       canvas.drawBitmap(reflectionImage,0, height + reflectionGap, null);

                       //Create a shader that is a linear gradient that covers the reflection
                       Paint paint = new Paint(); 
                       LinearGradient shader = new LinearGradient(0, originalImage.getHeight(), 0, 
                         bitmapWithReflection.getHeight() + reflectionGap, 0x70ffffff, 0x00ffffff, 
                         TileMode.CLAMP); 
                       //Set the paint to use this shader (linear gradient)
                       paint.setShader(shader); 
                       //Set the Transfer mode to be porter duff and destination in
                       paint.setXfermode(new PorterDuffXfermode(Mode.DST_IN)); 
                       //Draw a rectangle using the paint with our linear gradient
                       canvas.drawRect(0, height, width, 
                         bitmapWithReflection.getHeight() + reflectionGap, paint); 

                       ImageView imageView = new ImageView(mContext);
                       imageView.setImageBitmap(bitmapWithReflection);
                       imageView.setLayoutParams(new CoverFlow.LayoutParams(120, 180));
                       imageView.setScaleType(ScaleType.MATRIX);
                       mImages[index++] = imageView;

                    }
                    return true;
            }

            public int getCount() {
                return mImageIds.length;
            }

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

            public long getItemId(int position) {
                return position;
            }

            public View getView(int position, View convertView, ViewGroup parent) {

                //Use this code if you want to load from resources
               // ImageView i = new ImageView(mContext);
                //i.setImageResource(mImageIds[position]);
               //i.setLayoutParams(new CoverFlow.LayoutParams(130, 130));
                //i.setScaleType(ImageView.ScaleType.MATRIX);           
                //return i;

                return mImages[position];
            }
             /** Returns the size (0.0f to 1.0f) of the views 
             * depending on the 'offset' to the center. */ 
             public float getScale(boolean focused, int offset) { 
               /* Formula: 1 / (2 ^ offset) */ 
                 return Math.max(0, 1.0f / (float)Math.pow(2, Math.abs(offset))); 
             } 

        }

    }
</code></pre>
