AutoCompleteTextView实现简单的输入提示功能

AutoCompleteTextView就是类是百度搜索引擎中的一个下拉框了，就是我们输入内容时自动匹配内容出来了，下面我们一起来看看小编整理的例子。 在Android应用开发中，ListView数据的刷新经常用，我们都熟悉，如果我们在ListView实现Item局部刷新，刷新的同时实现下载进度条局部更新呢？本文来告诉你。

对于ListView数据的刷新大家都知道，改变Adapter的数据源，然后调用Adapter的notifyDateSetChanged()方法即可。

但是在做公司项目的时候，有个下载模块，因为可能同时下载好几个数据，所以用的listview展示所有正在下载的内容。因为下载进度要实时更新，所以要不停的调用notifyDateSetChanged刷新数据。这样会不停的重新绘制整个listview的界面，性能开销非常大。而且如果每个item有图片的话，每个item的图片都需要重新加载，就算图片做了内存缓存，刷新一下图片也会闪一下，不停的刷新就会导致各个item的图片不停的闪，体验一点都不好。

那么对于上面问题，有没有解决办法呢？当然是有的。我们可以针对某一个item进行局部更新，而不影响其它没有修改的item。那么具体如何实现的呢？我们看下面的代码。

private void updateView(int itemIndex) {
    //得到第一个可显示控件的位置，
    int visiblePosition = mListView.getFirstVisiblePosition();
    //只有当要更新的view在可见的位置时才更新，不可见时，跳过不更新
    if (itemIndex - visiblePosition >= 0) {
        //得到要更新的item的view
        View view = mListView.getChildAt(itemIndex - visiblePosition);
        //调用adapter更新界面
        mAdapter.updateView(view, itemIndex);
    }
}

这个函数主要是根据传入的itemIndex来获取第itemIndex的数据所显示的view。itemIndex就是要修改的数据再List集合中的位置，比如我这里下载进度有更新，发了一个广播这里接收到了，需要修改该下载内容的进度条，广播接收器可以这么写：

@Override
public void onReceive(Context context, Intent intent) {
    AppContent appContent = intent.getParcelableExtra("appContent");
    if(appContent == null) return;
    int itemIndex = 0;
    for(AppContent appContent1 : mList) {
        if(appContent.getUrl().equals(appContent1.getUrl())) {
            itemIndex = mList.indexOf(appContent1);
            appContent1.setDownloadPercent(appContent.getDownloadPercent());
            break;
        }
    }
    updateView(itemIndex);
}

下面看Adapter的具体代码：

public class AppContentAdapter extends BaseAdapter{

    private List<AppContent> mDates = null;
    private Context mContext;

    public AppContentAdapter(Context context) {
        this.mContext = context;
    }

    @Override
    public int getCount() {
        return mDates.size();
    }

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

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

    public void setDates(List<AppContent> mDates) {
        this.mDates = mDates;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ViewHolder holder = null;
        if (convertView == null) {
            holder = new ViewHolder();
            convertView = LayoutInflater.from(mContext).inflate(
                    R.layout.listitem_download, null);
            holder.statusIcon = (DownloadPercentView) convertView.findViewById(R.id.status_icon);
            holder.name = (TextView) convertView.findViewById(R.id.name);
            holder.downloadPercent = (TextView) convertView.findViewById(R.id.download_percent);
            holder.progressBar = (ProgressBar) convertView.findViewById(R.id.progressbar);
            convertView.setTag(holder);
        } else {
            holder = (ViewHolder) convertView.getTag();
        }
        setData(holder, position);
        return convertView;
    }

    /**
     * 设置viewHolder的数据
     * @param holder
     * @param itemIndex
     */
    private void setData(ViewHolder holder, int itemIndex) {
        AppContent appContent = mDates.get(itemIndex);
        holder.name.setText(appContent.getName());
        holder.progressBar.setProgress(appContent.getDownloadPercent());
        setIconByStatus(holder.statusIcon, appContent.getStatus());
        if(appContent.getStatus() == AppContent.Status.PENDING) {
            holder.downloadPercent.setVisibility(View.INVISIBLE);
        } else {
            holder.downloadPercent.setVisibility(View.VISIBLE);
            holder.statusIcon.setProgress(appContent.getDownloadPercent());
            holder.downloadPercent.setText("下载进度：" + appContent.getDownloadPercent() + "%");
        }
    }


    /**
     * 局部刷新
     * @param view
     * @param itemIndex
     */
    public void updateView(View view, int itemIndex) {
        if(view == null) {
            return;
        }
        //从view中取得holder
        ViewHolder holder = (ViewHolder) view.getTag();
        holder.statusIcon = (DownloadPercentView) view.findViewById(R.id.status_icon);
        holder.name = (TextView) view.findViewById(R.id.name);
        holder.downloadPercent = (TextView) view.findViewById(R.id.download_percent);
        holder.progressBar = (ProgressBar) view.findViewById(R.id.progressbar);
        setData(holder, itemIndex);
    }

    /**
     * 根据状态设置图标
     * @param downloadPercentView
     * @param status
     */
    private void setIconByStatus(DownloadPercentView downloadPercentView, AppContent.Status status) {
        downloadPercentView.setVisibility(View.VISIBLE);
        if(status == AppContent.Status.PENDING) {
            downloadPercentView.setStatus(DownloadPercentView.STATUS_PEDDING);
        }
        if(status == AppContent.Status.DOWNLOADING) {
            downloadPercentView.setStatus(DownloadPercentView.STATUS_DOWNLOADING);
        }
        if(status == AppContent.Status.WAITING) {
            downloadPercentView.setStatus(DownloadPercentView.STATUS_WAITING);
        }
        if(status == AppContent.Status.PAUSED) {
            downloadPercentView.setStatus(DownloadPercentView.STATUS_PAUSED);
        }
        if(status == AppContent.Status.FINISHED) {
            downloadPercentView.setStatus(DownloadPercentView.STATUS_FINISHED);
        }
    }

    private class ViewHolder {
        private DownloadPercentView statusIcon;
        private TextView name;
        private TextView downloadPercent;
        private ProgressBar progressBar;
    }
}


ListView中 局部刷新Item 实现下载进度条局部更新

当更新当前正在下载的任务的时候，使用 notifyDataSetChanged()；方法会使整个页面都会刷新。

而且进度更新比较频繁，这就造成了内存的消耗和页面卡顿（在进度更新很频繁的情况），笔者甚至出现了卡住页面无法进行操作的情况。

所以想到了能不能局部刷新某个Item。也查了下资料，问题解决。

解决思路：

通过listview.getFirstVisiblePosition（）方法获取到显示的item的首个位置 ，再根据position， 计算出view的位置。获取到具体的view后，对view进行操作，就能够实现局部刷新了。

关键代码：

 public void updateView(int itemIndex) {  
        //得到第一个可显示控件的位置，  
        int visiblePosition = mListView.getFirstVisiblePosition();  
        //只有当要更新的view在可见的位置时才更新，不可见时，跳过不更新  
        if (itemIndex - visiblePosition >= 0) {  
            //得到要更新的item的view  
            View view = mListView.getChildAt(itemIndex - visiblePosition);  
            //从view中取得holder  
            ViewHolder holder = (ViewHolder) view.getTag();  

            HashMap<String, Object> item = data.get(itemIndex);  
            //获取到具体的控件，
            holder.name = (TextView) view.findViewById(R.id.name);  
            holder.process = (ProcessBar) view.findViewById(R.id.process);  
            .......
            //对控件进行操作
            holder.process.setMax(item.get("max"));
            holder.process.setProgress(item.get("progress"));
            ......
     
        }         
    } 

下面我们一起来看一篇关于 解决：Bitmap too large to be uploaded into a texture exception问题解决办法。

最近做项目发现其他手机没有问题，但是出现了一个手机报异常，最难过的是不显示报错信息，弄了很久，才发现了一句话：Bitmap too large to be uploaded into a texture exception，百度一下才知道怎么回事。简单说就是硬件加速的时候，对图片的大小有限制。不同设备可能有不同的最大值。这个问题悲催的地方是，程序貌似没有捕获到这个exception, 结果是程序也不报错，图片也显示不出来。只有看debug log才能发现这个error message.

一个解决的方法是禁止硬件加速，简单粗暴：

代码如下	复制代码
<application android:hardwareAccelerated="false" ...>

比较好的解决方法是类似google map的实现：将图片分成不同的块，每次加载需要的块。android提供了一个方法：

http://developer.android.com/reference/android/graphics/BitmapRegionDecoder.html

代码如下	复制代码
public void drawBitmap (Bitmap bitmap, Rect src, RectF dst, Paint paint) public Bitmap decodeRegion (Rect rect, BitmapFactory.Options options)

采取上述操作后，就可以加载很多图片，同时也可以显示超级大图了。

还有用ImageLoad加载图片，如果出现这个问题我们可以这样处理：

可以对ImageView设置最大高度和最大宽度：

 

代码如下	复制代码
android:maxHeight="1000dip"   android:maxWidth="1000dip"

同时相应的scaleType为FIT_CENTER  FIT_XY   FIT_START FIT_END CENTER_INSIDE

在上面这些scaleType下，当bitmap的高和宽一个大于所设的最大值时,imageloader会自动处理，按比例缩放。当scaleType为 MATRIX  CENTER  CENTER_CROP时  要高宽两者都大于所设的最大值时，imageloder才会处理。

下面我们一起来看一篇Android Design Support Library 02 — CollapsingToolbarLayout&&CardView问题解决办法。

Material Design的第二篇更新啦！这次介绍两个控件CollapsingToolbarLayout&&CardView

1、CollapsingToolbarLayout

5.0之后，折叠效果的App出现了，前段时间google在material design的设计中也推出了这个控件。
Ok，还是先上视频！

代码如下

复制代码

<android.support.design.widget.AppBarLayout         android:layout_width="match_parent"         android:layout_height="256dp"         android:fitsSystemWindows="true">         <android.support.design.widget.CollapsingToolbarLayout             android:id="@+id/collapsing_toolbar_layout"             android:layout_width="match_parent"             android:layout_height="match_parent"             app:contentScrim="#30469b"             app:expandedTitleMarginStart="48dp"             app:layout_scrollFlags="scroll|exitUntilCollapsed">                <ImageView                 android:layout_width="match_parent"                 android:layout_height="match_parent"                 android:scaleType="centerCrop"                 android:src="@mipmap/bg"                 app:layout_collapseMode="parallax"                 app:layout_collapseParallaxMultiplier="0.7"  />                <android.support.v7.widget.Toolbar                 android:id="@+id/toolbar"                 android:layout_width="match_parent"                 android:layout_height="?attr/actionBarSize"                 app:layout_collapseMode="pin" />         </android.support.design.widget.CollapsingToolbarLayout>     </android.support.design.widget.AppBarLayout>

官方提示，使用CollasingToolbarLayout和Toolbar，title用CollapsingToolbar来设置
This setup uses CollapsingToolbarLayout’s app:layout_collapseMode=”pin” to ensure that the Toolbar itself remains pinned to the top of the screen while the view collapses. Even better, when you use CollapsingToolbarLayout and Toolbar together, the title will automatically appear larger when the layout is fully visible, then transition to its default size as it is collapsed. Note that in those cases, you should call setTitle() on the CollapsingToolbarLayout, rather than on the Toolbar itself.

2、CardView

实现了卡片式的并且有阴影效果。

代码如下

复制代码

<android.support.v7.widget.CardView        android:layout_width="match_parent"        android:layout_height="wrap_content"        android:layout_margin="@dimen/card_margin">          <LinearLayout            style="@style/Widget.CardContent"            android:layout_width="match_parent"            android:layout_height="wrap_content">              <TextView                android:layout_width="match_parent"                android:layout_height="wrap_content"                android:text="界冢伊奈帆（かいづか いなほ）"                android:textAppearance="@style/TextAppearance.AppCompat.Title" />              <TextView                android:layout_width="match_parent"                android:layout_height="wrap_content"                android:text="主人公。居住在地..." />              <ImageView                android:id="@+id/iv_ynf"                android:layout_width="wrap_content"                android:layout_height="wrap_content" />          </LinearLayout> </android.support.v7.widget.CardView>

Android开发语言是Java，所以也分主线程、子线程，那么我们如何要主线程来向子线程发送消息，希望子线程来处理，该如何实现呢？

有时候，我们也可能碰到这样子的一种需求：需要主线程来向子线程发送消息，希望子线程来完成什么任务。如果这样子应该怎么做呢？这就是这篇文章将要讨论的内容。

一、HandlerThread类

主线程发送消息给子线程，通常思维逻辑就是：其实很简单，在主线程中实例化一个Handler，然后让他与子线程相关联（只要它与子线程的Looper相关联即可），这样子它处理的消息就是该子线程中的消息队列，而处理的逻辑都是在该子线程中执行的，不会占用主线程的时间。那么我们就来实现一下，看看这样子到底行得通还是行不通。新建项目，修改它的MainActivity的代码，如下即可：

package com.example.handldertest;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.widget.TextView;
public class ThreadHandlerActivity extends Activity{
    
    //创建子线程
    class MyThread extends Thread{
        private Looper looper;//取出该子线程的Looper
        public void run() {
         
            Looper.prepare();//创建该子线程的Looper
            looper = Looper.myLooper();//取出该子线程的Looper
            Looper.loop();//只要调用了该方法才能不断循环取出消息
        }
    }
    
    private TextView tv;
    private MyThread thread;
    
    
    private Handler mHandler;//将mHandler指定轮询的Looper
    
    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            tv = new TextView(this);
            tv.setText("Handler实验");
            setContentView(tv);
            thread = new MyThread();
            thread.start();//千万别忘记开启这个线程
            //下面是主线程发送消息
            mHandler = new Handler(thread.looper){
                public void handleMessage(android.os.Message msg) {
                    Log.d("当前子线程是----->", Thread.currentThread()+"");
                };
            };
            mHandler.sendEmptyMessage(1);
    }
}

好了，现在运行该程序。有没有得到预期的结果呢？显然没有，因为报错误了，如下：

这是一个空指针错误。这是为什么呢？仔细思考，也不难发现原因。因为当主线程走到第38行时，此时子线程的Looper对象还没有被创建出来，那么此时thread.looper肯定为空了。其实这个时间是很不好控制的，当然了，你可以让主线程休眠2秒后再执行第38行以后的代码。但是如果有很多个子线程都需要主线程类给其分配任务怎么办？？那简直要乱套了。所以我们就更好的解决方式。就是android显然也考虑到了这个问题，于是它我们提供了一个HandlerThread类。这个类是专门处理这个问题的。

当主线程中有耗时的操作时，需要在子线程中完成，通常我们就把这个逻辑放在HandlerThread的对象中执行（该对象就是一个子线程），然后在需要开始执行逻辑的地方发送一个Message来通知一下就可以了。下面我们就修改上面的代码，看一看如何使用HandlerThread这个类。修改MainActivity中的代码如下：

package com.example.handldertest;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.widget.TextView;
public class ThreadHandlerActivity extends Activity{
    
    
    private TextView tv;
    private Handler mHandler;//将mHandler指定轮询的Looper
    
    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            tv = new TextView(this);
            tv.setText("Handler实验");
            setContentView(tv);
        
            //实例化一个特殊的线程HandlerThread，必须给其指定一个名字
            HandlerThread thread = new HandlerThread("handler thread");
            thread.start();//千万不要忘记开启这个线程
            //将mHandler与thread相关联
            mHandler = new Handler(thread.getLooper()){
                public void handleMessage(android.os.Message msg) {
                    Log.d("当前子线程是----->", Thread.currentThread()+"");
                };
            };
            mHandler.sendEmptyMessage(1);//发送消息
    }
}

运行程序，打印的结果如下：

从打印结果来看，当前子线程的名字正是我们所起的那个名字“handler thread"。

你会有疑问，表面上看HandlerThread并没有创建自己的Looper啊？而且既然是一个线程，那么我们肯定也能重写它的run方法吧。在解答你的疑问之前，我们不妨重写它的run方法来看一看会有什么结果。将代码修改如下：

package com.example.handldertest;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.widget.TextView;
public class ThreadHandlerActivity extends Activity{
    
    
    private TextView tv;
    private Handler mHandler;//将mHandler指定轮询的Looper
    
    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            tv = new TextView(this);
            tv.setText("Handler实验");
            setContentView(tv);
        
            //实例化一个特殊的线程HandlerThread，必须给其指定一个名字
            HandlerThread thread = new HandlerThread("handler thread"){
                @Override
                public void run() {
                    for(int i=0;i<3;i++){
                        Log.d("handler thread run ",i+"");
                    }
                }
            };
//            HandlerThread thread = new HandlerThread("handler thread");
            thread.start();//千万不要忘记开启这个线程
            //将mHandler与thread相关联
            mHandler = new Handler(thread.getLooper()){
                public void handleMessage(android.os.Message msg) {
                    Log.d("当前子线程是----->", Thread.currentThread()+"");
                };
            };
            mHandler.sendEmptyMessage(1);//发送消息
    }
}

红色部分就是我们重写了它的run方法。再云运行程序，打印的结果如下：

for循环的打印结果正常，但是为什么没有打印出”当前子线程“呢。其实这正是我们要解释的地方。还记得上一篇文章中实现与子线程相关联的的Handler，我们是怎么做的吗？没读过的朋友看以点击链接（http://www.cnblogs.com/fuly550871915/p/4889838.html）。其实我们实现Handlei与线程的关联正是写在run方法中的。而对于HandlerThread这样的线程，也是如此。我们翻看这个类的源代码，找到它的run方法，如下：

@Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

    

在源代码的第4行，进行了实例化自己的Looper，如果继续追踪源代码翻看其getLooper方法你会发现，如果一个Handler在与HandlerThread进行绑定时，发现Looper为空，Handler则会一直等待直到Looper被创建出来为止，然后才继续执行后续的代码。所以我们重写了HandlerThread的run方法，肯定就不会去创建Looper对象，那么绑定的Handler就会永远处于等待状态，自然而然就不会打印出”当前子线程“信息了。这也是为什么我们要使用HandlerThread这个特殊的线程，因为使用这个，我们不必关心多线程会混乱，Looper会为空等一系列问题，只要去关心我们要实现的逻辑就行了。

好了，现在做一下简单的总结吧。

 小结：
1. Handler与哪个线程的Looper相关联，那么它的消息处理逻辑就在与之相关的线程中执行，相应的消息的走向也就在相关联的MessageQueue中。（最常见的就是Handler与主线程关联，那么接收Looper回传的消息后的逻辑就会在主线程中执行）
2. 当主线程中需要与子线程进行通信时（比如将耗时操作放在子线程中），建议使用HandlerThread。同时要注意，千万不要去重写它的run方法。

二、一个主线程与子线程互相通信的例子

知识点都说完了。下面我们来写一个具体的例子实践一下吧。新建一个项目，修改它的MainActivity代码，如下：

package com.example.handldertest;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.util.Log;
import android.widget.TextView;
public class ThreadHandlerActivity extends Activity{
    
    
    private TextView tv;
    private Handler mHandler;//与子线程关联的Handler
    private Handler handler;//与主线程关联的Handler
    
    protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            tv = new TextView(this);
            tv.setText("Handler实验");
            setContentView(tv);
        
            //实例化一个特殊的线程HandlerThread，必须给其指定一个名字
            HandlerThread thread = new HandlerThread("handler thread");
            thread.start();//千万不要忘记开启这个线程
            //将mHandler与thread相关联
            mHandler = new Handler(thread.getLooper()){
                public void handleMessage(android.os.Message msg) {
                    Log.d("我是子线程----->", Thread.currentThread()+"");
                    handler.sendEmptyMessage(1);//发送消息给主线程
                };
            };
            
            handler = new Handler(){
                public void handleMessage(android.os.Message msg) {
                    Log.d("我是主线程----->", Thread.currentThread()+"");
                    mHandler.sendEmptyMessage(1);//发送消息给子线程
                };
            };
            mHandler.sendEmptyMessage(1);//发送消息
            handler.sendEmptyMessage(1);//发送消息
    }
}

注释很详细，不解释 了。运行程序，结果如下：

这样子，就会一直循环下去，轮流打印出主线程和子线程。




Android主线程、子线程通信（Thread+handler）

Android是基于Java的，所以也分主线程，子线程！
主线程：实现业务逻辑、UI绘制更新、各子线程串连，类似于将军；
子线程：完成耗时（联网取数据、SD卡数据加载、后台长时间运行）操作，类似于小兵；

一、子线程向主线程发消息（Thread+handler）：

1、主线程中定义Handler：

Handler mHandler = new Handler(){  
  
    @Override  
    public void handleMessage(Message msg) {  
        super.handleMessage(msg);  
        switch (msg.what) {  
        case 0:  
            //do something,refresh UI;  
            break;  
        default:  
            break;  
        }  
    }  
      
};

    
2、子线程处理完耗时操作之后发消息给主线程，更新UI：

mHandler.sendEmptyMessage(0);  

这样在子线程与主线程任务分工的条件下完成了消息交互；

二、主线程向子线程发送消息（Thread+handler）：

主线程碰到耗时操作要子线程完成，此时发通知给子线程，操作步骤如下：

1、子线程中定义Handler，Handler定义在哪个线程中，就跟那个线程绑定，在线程中绑定Handler需要调用Looper.prepare();方法，主线程中不调用是因为主线程默认帮你调用了；

public class LoopThread implements Runnable {  
  
    public Handler mHandler = null;  
  
    @Override  
    public void run() {  
        Looper.prepare();  
        mHandler = new Handler() {  
            public void handleMessage(Message msg) {  
                String result = NetUtil.getJsonContent("北京");  
                //完成了获取北京天气的操作；  
                Log.i("test", "handler"+result);  
            }  
        };  
        Looper.loop();  
    }  
  
}

其中Looper.prepare();和Looper.loop();维护了一个消息队列，等待消息注入并在子线程中执行；

2、主线程中这样调用：


lThread.mHandler.sendEmptyMessage(0);  

主线程向子线程发消息，让子线程执行指定的操作，在Android中还有一种方法，即：HandlerThread，看下面的例子：

HandlerThread handlerThread = new HandlerThread("jerome");  
handlerThread.start();  
  
/** 
 * 这里要将HandlerThread创建的looper传递给threadHandler，即完成绑定； 
 */  
threadHandler = new Handler(handlerThread.getLooper()) {  
  
    @Override  
    public void handleMessage(Message msg) {  
        super.handleMessage(msg);  
        switch (msg.what) {  
        case 0:  
这儿可以做耗时的操作；  
            Log.i("jerome", "hello,I am sub thread");  
            break;  
        default:  
            break;  
        }  
    }  
};