• Android 超高仿微信图片选择器 图片该这么加载

     
    转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/39943731，本文出自：【张鸿洋的博客】

    1、概述

    关于手机图片加载器，在当今像素随随便便破千万的时代，一张图片占据的内存都相当可观，作为高大尚程序猿的我们，有必要掌握图片的压缩，缓存等处理，以到达纵使你有万张照片，纵使你的像素再高，我们也能正确的显示所有的图片。当然了，单纯显示图片没撒意思，我们决定高仿一下微信的图片选择器，在此，感谢微信！本篇博客将基于以下两篇博客：

    Android 快速开发系列 打造万能的ListView GridView 适配器  将使用我们打造的CommonAdapter作为我们例子中GridView以及ListView的适配器

    Android Handler 异步消息处理机制的妙用 创建强大的图片加载类 将使用我们自己写的ImageLoader作为我们的图片加载的核心类

    如果你没看过也没关系，等看完本篇博客，可以结合以上两篇再进行充分理解一下。

    好了，首先贴一下效果图：

    动态图实在是录不出来，大家自己打开微信点击发表图片，或者聊天窗口发送图片，大致和微信的效果一样~

    简单描述一下：

    1、默认显示图片最多的文件夹图片，以及底部显示图片总数量；如上图1；

    2、点击底部，弹出popupWindow，popupWindow包含所有含有图片的文件夹，以及显示每个文件夹中图片数量；如上图2；注：此时Activity变暗

    3、选择任何文件夹，进入该文件夹图片显示，可以点击选择图片，当然了，点击已选择的图片则会取消选择；如上图3；注：选中图片变暗

    当然了，最重要的效果一定流畅，不能动不动OOM~~

    本人测试手机小米2s，图片6802张，未出现OOM异常，效果也是非常流畅，堪比图库~

    不过存在bug在所难免，大家可以留言说下自己发现的bug；文末会提供源码下载。

    好了，下面就可以代码的征程了~

    2、图片的列表页

    首先对手机中图片进行扫描，拿到图片数量最多的，直接显示在GridView上；并且扫描结束，得到一个所有包含图片的文件夹信息的List；

    对于文件夹信息，我们单独创建了一个Bean:

    [java] view plaincopy
     
    1. package com.zhy.bean;  
    2.   
    3. public class ImageFloder  
    4. {  
    5.     /** 
    6.      * 图片的文件夹路径 
    7.      */  
    8.     private String dir;  
    9.   
    10.     /** 
    11.      * 第一张图片的路径 
    12.      */  
    13.     private String firstImagePath;  
    14.   
    15.     /** 
    16.      * 文件夹的名称 
    17.      */  
    18.     private String name;  
    19.   
    20.     /** 
    21.      * 图片的数量 
    22.      */  
    23.     private int count;  
    24.   
    25.     public String getDir()  
    26.     {  
    27.         return dir;  
    28.     }  
    29.   
    30.     public void setDir(String dir)  
    31.     {  
    32.         this.dir = dir;  
    33.         int lastIndexOf = this.dir.lastIndexOf("/");  
    34.         this.name = this.dir.substring(lastIndexOf);  
    35.     }  
    36.   
    37.     public String getFirstImagePath()  
    38.     {  
    39.         return firstImagePath;  
    40.     }  
    41.   
    42.     public void setFirstImagePath(String firstImagePath)  
    43.     {  
    44.         this.firstImagePath = firstImagePath;  
    45.     }  
    46.   
    47.     public String getName()  
    48.     {  
    49.         return name;  
    50.     }  
    51.     public int getCount()  
    52.     {  
    53.         return count;  
    54.     }  
    55.   
    56.     public void setCount(int count)  
    57.     {  
    58.         this.count = count;  
    59.     }  
    60.   
    61.       
    62.   
    63. }  

    用来存储当前文件夹的路径，当前文件夹包含多少张图片，以及第一张图片路径用于做文件夹的图标；注：文件夹的名称，我们在set文件夹的路径的时候，自动提取，仔细看下setDir这个方法。

    接下来就是扫描手机图片的代码了：

    [java] view plaincopy
     
    1. @Override  
    2.     protected void onCreate(Bundle savedInstanceState)  
    3.     {  
    4.         super.onCreate(savedInstanceState);  
    5.         setContentView(R.layout.activity_main);  
    6.   
    7.         DisplayMetrics outMetrics = new DisplayMetrics();  
    8.         getWindowManager().getDefaultDisplay().getMetrics(outMetrics);  
    9.         mScreenHeight = outMetrics.heightPixels;  
    10.   
    11.         initView();  
    12.         getImages();  
    13.         initEvent();  
    14.   
    15.     }  
    16.   
    17.       
    18.   
    19.     /** 
    20.      * 利用ContentProvider扫描手机中的图片，此方法在运行在子线程中 完成图片的扫描，最终获得jpg最多的那个文件夹 
    21.      */  
    22.     private void getImages()  
    23.     {  
    24.         if (!Environment.getExternalStorageState().equals(  
    25.                 Environment.MEDIA_MOUNTED))  
    26.         {  
    27.             Toast.makeText(this, "暂无外部存储", Toast.LENGTH_SHORT).show();  
    28.             return;  
    29.         }  
    30.         // 显示进度条  
    31.         mProgressDialog = ProgressDialog.show(this, null, "正在加载...");  
    32.   
    33.         new Thread(new Runnable()  
    34.         {  
    35.             @Override  
    36.             public void run()  
    37.             {  
    38.   
    39.                 String firstImage = null;  
    40.   
    41.                 Uri mImageUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;  
    42.                 ContentResolver mContentResolver = MainActivity.this  
    43.                         .getContentResolver();  
    44.   
    45.                 // 只查询jpeg和png的图片  
    46.                 Cursor mCursor = mContentResolver.query(mImageUri, null,  
    47.                         MediaStore.Images.Media.MIME_TYPE + "=? or "  
    48.                                 + MediaStore.Images.Media.MIME_TYPE + "=?",  
    49.                         new String[] { "image/jpeg", "image/png" },  
    50.                         MediaStore.Images.Media.DATE_MODIFIED);  
    51.   
    52.                 Log.e("TAG", mCursor.getCount() + "");  
    53.                 while (mCursor.moveToNext())  
    54.                 {  
    55.                     // 获取图片的路径  
    56.                     String path = mCursor.getString(mCursor  
    57.                             .getColumnIndex(MediaStore.Images.Media.DATA));  
    58.   
    59.                     Log.e("TAG", path);  
    60.                     // 拿到第一张图片的路径  
    61.                     if (firstImage == null)  
    62.                         firstImage = path;  
    63.                     // 获取该图片的父路径名  
    64.                     File parentFile = new File(path).getParentFile();  
    65.                     if (parentFile == null)  
    66.                         continue;  
    67.                     String dirPath = parentFile.getAbsolutePath();  
    68.                     ImageFloder imageFloder = null;  
    69.                     // 利用一个HashSet防止多次扫描同一个文件夹（不加这个判断，图片多起来还是相当恐怖的~~）  
    70.                     if (mDirPaths.contains(dirPath))  
    71.                     {  
    72.                         continue;  
    73.                     } else  
    74.                     {  
    75.                         mDirPaths.add(dirPath);  
    76.                         // 初始化imageFloder  
    77.                         imageFloder = new ImageFloder();  
    78.                         imageFloder.setDir(dirPath);  
    79.                         imageFloder.setFirstImagePath(path);  
    80.                     }  
    81.   
    82.                     int picSize = parentFile.list(new FilenameFilter()  
    83.                     {  
    84.                         @Override  
    85.                         public boolean accept(File dir, String filename)  
    86.                         {  
    87.                             if (filename.endsWith(".jpg")  
    88.                                     || filename.endsWith(".png")  
    89.                                     || filename.endsWith(".jpeg"))  
    90.                                 return true;  
    91.                             return false;  
    92.                         }  
    93.                     }).length;  
    94.                     totalCount += picSize;  
    95.   
    96.                     imageFloder.setCount(picSize);  
    97.                     mImageFloders.add(imageFloder);  
    98.   
    99.                     if (picSize > mPicsSize)  
    100.                     {  
    101.                         mPicsSize = picSize;  
    102.                         mImgDir = parentFile;  
    103.                     }  
    104.                 }  
    105.                 mCursor.close();  
    106.   
    107.                 // 扫描完成，辅助的HashSet也就可以释放内存了  
    108.                 mDirPaths = null;  
    109.   
    110.                 // 通知Handler扫描图片完成  
    111.                 mHandler.sendEmptyMessage(0x110);  
    112.   
    113.             }  
    114.         }).start();  
    115.   
    116.     }  

    ps：运行出现空指针的话，在81行的位置添加判断，if(parentFile.list()==null)continue ， 切记~~~有些图片比较诡异~~; 

    initView就不看了，都是些findViewById;

    getImages主要就是扫描图片的代码，我们开启了一个Thread进行扫描，扫描完成以后，我们得到了图片最多文件夹路径（mImgDir），手机中图片数量（totalCount）；以及所有包含图片文件夹信息（mImageFloders）

    然后我们通过handler发送消息，在handleMessage里面：

    1、创建GridView的适配器，为我们的GridView设置适配器，显示图片；

    2、有了mImageFloders，就可以创建我们的popupWindow了

    看一眼我们的Handler

    [java] view plaincopy
     
    1. private Handler mHandler = new Handler()  
    2.     {  
    3.         public void handleMessage(android.os.Message msg)  
    4.         {  
    5.             mProgressDialog.dismiss();  
    6.             //为View绑定数据  
    7.             data2View();  
    8.             //初始化展示文件夹的popupWindw  
    9.             initListDirPopupWindw();  
    10.         }  
    11.     };  

    可以看到分别干了上述的两件事：
    [java] view plaincopy
     
    1. /** 
    2.      * 为View绑定数据 
    3.      */  
    4.     private void data2View()  
    5.     {  
    6.         if (mImgDir == null)  
    7.         {  
    8.             Toast.makeText(getApplicationContext(), "擦，一张图片没扫描到",  
    9.                     Toast.LENGTH_SHORT).show();  
    10.             return;  
    11.         }  
    12.   
    13.         mImgs = Arrays.asList(mImgDir.list());  
    14.         /** 
    15.          * 可以看到文件夹的路径和图片的路径分开保存，极大的减少了内存的消耗； 
    16.          */  
    17.         mAdapter = new MyAdapter(getApplicationContext(), mImgs,  
    18.                 R.layout.grid_item, mImgDir.getAbsolutePath());  
    19.         mGirdView.setAdapter(mAdapter);  
    20.         mImageCount.setText(totalCount + "张");  
    21.     };  

    data2View就是我们当前Activity上所有的View设置数据了。

    看到这里还用到了一个Adapter，我们GridView的：

    [java] view plaincopy
     
    1. package com.zhy.imageloader;  
    2.   
    3. import java.util.LinkedList;  
    4. import java.util.List;  
    5.   
    6. import android.content.Context;  
    7. import android.graphics.Color;  
    8. import android.view.View;  
    9. import android.view.View.OnClickListener;  
    10. import android.widget.ImageView;  
    11.   
    12. import com.zhy.utils.CommonAdapter;  
    13.   
    14. public class MyAdapter extends CommonAdapter<String>  
    15. {  
    16.   
    17.     /** 
    18.      * 用户选择的图片，存储为图片的完整路径 
    19.      */  
    20.     public static List<String> mSelectedImage = new LinkedList<String>();  
    21.   
    22.     /** 
    23.      * 文件夹路径 
    24.      */  
    25.     private String mDirPath;  
    26.   
    27.     public MyAdapter(Context context, List<String> mDatas, int itemLayoutId,  
    28.             String dirPath)  
    29.     {  
    30.         super(context, mDatas, itemLayoutId);  
    31.         this.mDirPath = dirPath;  
    32.     }  
    33.   
    34.     @Override  
    35.     public void convert(final com.zhy.utils.ViewHolder helper, final String item)  
    36.     {  
    37.         // 设置no_pic  
    38.         helper.setImageResource(R.id.id_item_image, R.drawable.pictures_no);  
    39.         // 设置no_selected  
    40.         helper.setImageResource(R.id.id_item_select,  
    41.                 R.drawable.picture_unselected);  
    42.         // 设置图片  
    43.         helper.setImageByUrl(R.id.id_item_image, mDirPath + "/" + item);  
    44.   
    45.         final ImageView mImageView = helper.getView(R.id.id_item_image);  
    46.         final ImageView mSelect = helper.getView(R.id.id_item_select);  
    47.   
    48.         mImageView.setColorFilter(null);  
    49.         // 设置ImageView的点击事件  
    50.         mImageView.setOnClickListener(new OnClickListener()  
    51.         {  
    52.             // 选择，则将图片变暗，反之则反之  
    53.             @Override  
    54.             public void onClick(View v)  
    55.             {  
    56.   
    57.                 // 已经选择过该图片  
    58.                 if (mSelectedImage.contains(mDirPath + "/" + item))  
    59.                 {  
    60.                     mSelectedImage.remove(mDirPath + "/" + item);  
    61.                     mSelect.setImageResource(R.drawable.picture_unselected);  
    62.                     mImageView.setColorFilter(null);  
    63.                 } else  
    64.                 // 未选择该图片  
    65.                 {  
    66.                     mSelectedImage.add(mDirPath + "/" + item);  
    67.                     mSelect.setImageResource(R.drawable.pictures_selected);  
    68.                     mImageView.setColorFilter(Color.parseColor("#77000000"));  
    69.                 }  
    70.   
    71.             }  
    72.         });  
    73.   
    74.         /** 
    75.          * 已经选择过的图片，显示出选择过的效果 
    76.          */  
    77.         if (mSelectedImage.contains(mDirPath + "/" + item))  
    78.         {  
    79.             mSelect.setImageResource(R.drawable.pictures_selected);  
    80.             mImageView.setColorFilter(Color.parseColor("#77000000"));  
    81.         }  
    82.   
    83.     }  
    84. }  

    可以看到我们GridView的Adapter继承了我们的CommonAdapter，如果不知道CommonAdapter为何物，可以去看看万能适配器那篇博文；

    我们现在只需要实现convert方法：

    在convert中，我们设置图片，设置事件等，对于图片的变暗，我们使用的是ImageView的setColorFilter ；根据Url加载图片的操作封装在helper.setImageByUrl(view,url)中，内部使用的是我们自己定义的ImageLoader，包括错乱处理都已经封装了，图片策略我们使用的是LIFO后进先出；不清楚的可以看文章一开始说明的那两篇博文，对于CommonAdapter以及ImageLoader都有从无到有的详细打造过程；

    到此我们的第一个Activity的所有的任务就完成了~~~

    3、展现文件夹的PopupWindow

    现在我们要实现，点击底部的布局弹出我们的文件夹选择框，并且我们弹出框后面的Activity要变暗；

    不急着贴代码，我们先考虑下PopupWindow怎么用最好，我们的PopupWindow需要设置布局文件，需要初始化View，需要初始化事件，还需要和Activity交互~~

    那么肯定的，我们使用独立的类，这个类和Activity很相似，在里面initView(),initEvent()之类的。

    我们创建了一个popupWindow使用的超类：

    [java] view plaincopy
     
    1. package com.zhy.utils;  
    2.   
    3. import java.util.List;  
    4.   
    5. import android.content.Context;  
    6. import android.graphics.drawable.BitmapDrawable;  
    7. import android.view.MotionEvent;  
    8. import android.view.View;  
    9. import android.view.View.OnTouchListener;  
    10. import android.widget.PopupWindow;  
    11.   
    12. public abstract class BasePopupWindowForListView<T> extends PopupWindow  
    13. {  
    14.     /** 
    15.      * 布局文件的最外层View 
    16.      */  
    17.     protected View mContentView;  
    18.     protected Context context;  
    19.     /** 
    20.      * ListView的数据集 
    21.      */  
    22.     protected List<T> mDatas;  
    23.   
    24.     public BasePopupWindowForListView(View contentView, int width, int height,  
    25.             boolean focusable)  
    26.     {  
    27.         this(contentView, width, height, focusable, null);  
    28.     }  
    29.   
    30.     public BasePopupWindowForListView(View contentView, int width, int height,  
    31.             boolean focusable, List<T> mDatas)  
    32.     {  
    33.         this(contentView, width, height, focusable, mDatas, new Object[0]);  
    34.   
    35.     }  
    36.   
    37.     public BasePopupWindowForListView(View contentView, int width, int height,  
    38.             boolean focusable, List<T> mDatas, Object... params)  
    39.     {  
    40.         super(contentView, width, height, focusable);  
    41.         this.mContentView = contentView;  
    42.         context = contentView.getContext();  
    43.         if (mDatas != null)  
    44.             this.mDatas = mDatas;  
    45.   
    46.         if (params != null && params.length > 0)  
    47.         {  
    48.             beforeInitWeNeedSomeParams(params);  
    49.         }  
    50.   
    51.         setBackgroundDrawable(new BitmapDrawable());  
    52.         setTouchable(true);  
    53.         setOutsideTouchable(true);  
    54.         setTouchInterceptor(new OnTouchListener()  
    55.         {  
    56.             @Override  
    57.             public boolean onTouch(View v, MotionEvent event)  
    58.             {  
    59.                 if (event.getAction() == MotionEvent.ACTION_OUTSIDE)  
    60.                 {  
    61.                     dismiss();  
    62.                     return true;  
    63.                 }  
    64.                 return false;  
    65.             }  
    66.         });  
    67.         initViews();  
    68.         initEvents();  
    69.         init();  
    70.     }  
    71.   
    72.     protected abstract void beforeInitWeNeedSomeParams(Object... params);  
    73.   
    74.     public abstract void initViews();  
    75.   
    76.     public abstract void initEvents();  
    77.   
    78.     public abstract void init();  
    79.   
    80.     public View findViewById(int id)  
    81.     {  
    82.         return mContentView.findViewById(id);  
    83.     }  
    84.   
    85.     protected static int dpToPx(Context context, int dp)  
    86.     {  
    87.         return (int) (context.getResources().getDisplayMetrics().density * dp + 0.5f);  
    88.     }  
    89.   
    90. }  

    也就是封装了一下popupWindow常用的一些设置，然后使用了类似模版方法模式，约束子类，必须实现initView，initEvent，init等方法
    [java] view plaincopy
     
    1. package com.zhy.imageloader;  
    2.   
    3. import java.util.List;  
    4.   
    5. import android.view.View;  
    6. import android.widget.AdapterView;  
    7. import android.widget.AdapterView.OnItemClickListener;  
    8. import android.widget.ListView;  
    9.   
    10. import com.zhy.bean.ImageFloder;  
    11. import com.zhy.utils.BasePopupWindowForListView;  
    12. import com.zhy.utils.CommonAdapter;  
    13. import com.zhy.utils.ViewHolder;  
    14.   
    15. public class ListImageDirPopupWindow extends BasePopupWindowForListView<ImageFloder>  
    16. {  
    17.     private ListView mListDir;  
    18.   
    19.     public ListImageDirPopupWindow(int width, int height,  
    20.             List<ImageFloder> datas, View convertView)  
    21.     {  
    22.         super(convertView, width, height, true, datas);  
    23.     }  
    24.   
    25.     @Override  
    26.     public void initViews()  
    27.     {  
    28.         mListDir = (ListView) findViewById(R.id.id_list_dir);  
    29.         mListDir.setAdapter(new CommonAdapter<ImageFloder>(context, mDatas,  
    30.                 R.layout.list_dir_item)  
    31.         {  
    32.             @Override  
    33.             public void convert(ViewHolder helper, ImageFloder item)  
    34.             {  
    35.                 helper.setText(R.id.id_dir_item_name, item.getName());  
    36.                 helper.setImageByUrl(R.id.id_dir_item_image,  
    37.                         item.getFirstImagePath());  
    38.                 helper.setText(R.id.id_dir_item_count, item.getCount() + "张");  
    39.             }  
    40.         });  
    41.     }  
    42.   
    43.     public interface OnImageDirSelected  
    44.     {  
    45.         void selected(ImageFloder floder);  
    46.     }  
    47.   
    48.     private OnImageDirSelected mImageDirSelected;  
    49.   
    50.     public void setOnImageDirSelected(OnImageDirSelected mImageDirSelected)  
    51.     {  
    52.         this.mImageDirSelected = mImageDirSelected;  
    53.     }  
    54.   
    55.     @Override  
    56.     public void initEvents()  
    57.     {  
    58.         mListDir.setOnItemClickListener(new OnItemClickListener()  
    59.         {  
    60.             @Override  
    61.             public void onItemClick(AdapterView<?> parent, View view,  
    62.                     int position, long id)  
    63.             {  
    64.   
    65.                 if (mImageDirSelected != null)  
    66.                 {  
    67.                     mImageDirSelected.selected(mDatas.get(position));  
    68.                 }  
    69.             }  
    70.         });  
    71.     }  
    72.   
    73.     @Override  
    74.     public void init()  
    75.     {  
    76.         // TODO Auto-generated method stub  
    77.   
    78.     }  
    79.   
    80.     @Override  
    81.     protected void beforeInitWeNeedSomeParams(Object... params)  
    82.     {  
    83.         // TODO Auto-generated method stub  
    84.     }  
    85.   
    86. }  
    好了，现在就是我们正在的popupWindow咯，布局文件夹主要是个ListView，所以在initView里面，我们得设置它的适配器；当然了，这里的适配器依然用我们的CommonAdapter，几行代码搞定~~

    然后我们需要和Activity交互，当我们点击某个文件夹的时候，外层的Activity需要改变它GridView的数据源，展示我们点击文件夹的图片；

    关于交互，我们从Activity的角度去看弹出框，Activity想知道什么，只想知道选择了别的文件夹来告诉我，所以我们创建一个接口OnImageDirSelected，对Activity设置回调；

    这里还可以这么写：就是把popupWindow的ListView公布出去，然后在Activity里面使用popupWindow.getListView(),setOnItemClickListener，这么做，个人觉得不好，耦合度太高，客户简单改下需求“这个文件夹展示，给我们换了，换成GridView”，呵呵，此时，你需要到处去修改Activity里面的代码，因为你Activity里面竟然还有个popupWindow.getListView。

    好了，扯多了，初始化事件的代码：

    [java] view plaincopy
     
    1. @Override  
    2.     public void initEvents()  
    3.     {  
    4.         mListDir.setOnItemClickListener(new OnItemClickListener()  
    5.         {  
    6.             @Override  
    7.             public void onItemClick(AdapterView<?> parent, View view,  
    8.                     int position, long id)  
    9.             {  
    10.   
    11.                 if (mImageDirSelected != null)  
    12.                 {  
    13.                     mImageDirSelected.selected(mDatas.get(position));  
    14.                 }  
    15.             }  
    16.         });  
    17.     }  

    如果有人设置了回调，我们就调用；

    到此，整个popupWindow就出炉了，接下来就看啥时候让它展示了；

    4、选择不同的文件夹

    上面说道，当扫描图片完成，拿到包含图片的文件夹信息列表；这个列表就是我们popupWindow所需的数据，所以我们的popupWindow的初始化在handleMessage（上面贴了handler的代码）里面：

    在handleMessage里面调用initListDirPopupWindw

    [java] view plaincopy
     
    1. /** 
    2.      * 初始化展示文件夹的popupWindw 
    3.      */  
    4.     private void initListDirPopupWindw()  
    5.     {  
    6.         mListImageDirPopupWindow = new ListImageDirPopupWindow(  
    7.                 LayoutParams.MATCH_PARENT, (int) (mScreenHeight * 0.7),  
    8.                 mImageFloders, LayoutInflater.from(getApplicationContext())  
    9.                         .inflate(R.layout.list_dir, null));  
    10.   
    11.         mListImageDirPopupWindow.setOnDismissListener(new OnDismissListener()  
    12.         {  
    13.   
    14.             @Override  
    15.             public void onDismiss()  
    16.             {  
    17.                 // 设置背景颜色变暗  
    18.                 WindowManager.LayoutParams lp = getWindow().getAttributes();  
    19.                 lp.alpha = 1.0f;  
    20.                 getWindow().setAttributes(lp);  
    21.             }  
    22.         });  
    23.         // 设置选择文件夹的回调  
    24.         mListImageDirPopupWindow.setOnImageDirSelected(this);  
    25.     }  
    我们初始化我们的popupWindow，设置了关闭对话框的回调，已经设置了选择不同文件夹的回调；
    这里仅仅是初始化，下面看我们合适将其弹出的，其实整个Activity也就一个事件，点击弹出该对话框，所以看Activity的initEvents方法：
    [java] view plaincopy
     
    1. private void initEvent()  
    2.     {  
    3.         /** 
    4.          * 为底部的布局设置点击事件，弹出popupWindow 
    5.          */  
    6.         mBottomLy.setOnClickListener(new OnClickListener()  
    7.         {  
    8.             @Override  
    9.             public void onClick(View v)  
    10.             {  
    11.                 mListImageDirPopupWindow  
    12.                         .setAnimationStyle(R.style.anim_popup_dir);  
    13.                 mListImageDirPopupWindow.showAsDropDown(mBottomLy, 0, 0);  
    14.   
    15.                 // 设置背景颜色变暗  
    16.                 WindowManager.LayoutParams lp = getWindow().getAttributes();  
    17.                 lp.alpha = .3f;  
    18.                 getWindow().setAttributes(lp);  
    19.             }  
    20.         });  
    21.     }  

    可以看到，我们为底部布局设置点击事件；设置popupWindow的弹出与消失的动画；已经让Activity背景变暗变亮，通过改变Window alpha实现的。变亮在弹出框消息的监听里面~~

    动画的文件就不贴了，大家自己看源码；

    popupWindow弹出了，用户此时可以选择不同的文件夹，那么现在该看选择后的回调的代码了：

    我们的Activity实现了该接口，直接看实现的方法：

    [java] view plaincopy
     
    1. @Override  
    2. public void selected(ImageFloder floder)  
    3. {  
    4.   
    5.     mImgDir = new File(floder.getDir());  
    6.     mImgs = Arrays.asList(mImgDir.list(new FilenameFilter()  
    7.     {  
    8.         @Override  
    9.         public boolean accept(File dir, String filename)  
    10.         {  
    11.             if (filename.endsWith(".jpg") || filename.endsWith(".png")  
    12.                     || filename.endsWith(".jpeg"))  
    13.                 return true;  
    14.             return false;  
    15.         }  
    16.     }));  
    17.     /** 
    18.      * 可以看到文件夹的路径和图片的路径分开保存，极大的减少了内存的消耗； 
    19.      */  
    20.     mAdapter = new MyAdapter(getApplicationContext(), mImgs,  
    21.             R.layout.grid_item, mImgDir.getAbsolutePath());  
    22.     mGirdView.setAdapter(mAdapter);  
    23.     // mAdapter.notifyDataSetChanged();  
    24.     mImageCount.setText(floder.getCount() + "张");  
    25.     mChooseDir.setText(floder.getName());  
    26.     mListImageDirPopupWindow.dismiss();  
    27.   
    28. }  

    我们改变了GridView的适配器，以及底部的控件上的文件夹名称，文件数量等等；

    好了，到此结束；整篇由于篇幅原因没有贴任何布局文件，大家自己通过源码查看；

    在此希望大家可以通过该案例，能够去其糟粕，取其精华，学习其中值得借鉴的代码风格，不要真的当作一个例子去学习~~

    源码点击下载  

    ps：请真机测试，反正我的模拟器扫描不到图片~

    ps：运行出现空指针的话，在getImages中添加判断，if(parentFile.list()==null)continue ， 切记~~~具体位置，上面有说; 
  • 相关阅读:
    Android入门第六篇之ListView (一)
    mysql触发器的作用及语法
    查询记录时rs.previous()的使用
    Microsoft Visual C++ Runtime Library Runtime Error的解决的方法
    Ubuntu中编译链接Opencv应用的简便方式
    24点经典算法
    CMS系统简介（从简介到使用）
    编程学习资源
    Django是什么
    Thinkphp中的自动验证
  • 原文地址：https://www.cnblogs.com/xgjblog/p/4723828.html
Copyright © 2020-2023  润新知