android中ViewFlipper的使用升级

最新推荐文章于 2024-05-08 10:24:55 发布

Elvira_mx

最新推荐文章于 2024-05-08 10:24:55 发布

阅读量841

点赞数 1

分类专栏：动画 android 文章标签： android ViewFlipper 动画轮播网络

本文链接：https://blog.csdn.net/elvira_mx/article/details/45362385

版权

动画同时被 2 个专栏收录

2 篇文章 0 订阅

订阅专栏

android

2 篇文章 0 订阅

订阅专栏

转载，请添加出处哦：http://blog.csdn.net/elvira_mx/article/details/45362385

在前面一篇文章（android中ViewFlipper的简单使用------轮播）已经简单介绍了ViewFlipper，所以，我就不介绍了。

本篇文章说的是ViewFlipper的使用升级，其实，是对于轮播的再度升级而已，吐舌头接下来文章所说的是，动态添加轮播所需要的图片，而且图片还是通过网络所获取的，因为图片不大，所以就先下载到本地进行保存下来，等下次打开时，只要本地有此图片，就直接加载本地的就可以了。对于下载图片的这一块，我是借鉴了郭霖大师的瀑布流中的图片的网络地址和ImageLoader，想了解的可以看一下：http://blog.csdn.net/guolin_blog/article/details/10470797

接下来，就进入正文吧，先看一下activity_main.xml布局，很简单，就只是一个存放图片的ViewFlipper和存放圆点的LinearLayout

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ccc"
    android:orientation="vertical" >
    <ViewFlipper
        android:id="@+id/viewflipper"
        android:layout_width="match_parent"
        android:layout_height="172dp"
        android:layout_margin="10dip"
        android:gravity="center" ></ViewFlipper>
    <LinearLayout
        android:id="@+id/show_dot"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center_horizontal"
        android:orientation="horizontal" ></LinearLayout>
</LinearLayout>

接着呢，就把小圆点制造出来，在dot.xml文件中

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
	<View style="@style/dot_style"/>
</LinearLayout>

上述的style样式，是和之前的一样的，如果看过前一篇文章的话，应该知道怎么写，在这里呢，再说一次吧，千万别说我啰嗦哦。在Style文件中写style样式

<style name="dot_style"> 
        <item name="android:layout_width">5dip</item> 
        <item name="android:layout_height">5dip</item> 
        <item name="android:background">@drawable/dot_normal</item> 
        <item name="android:layout_margin">1.5dip</item> 
</style>

style样式中的@drawable/dot_normal是自己定义的，在res文件下新建一个drawable文件，然后建立xml文件就可以了，这里需要创建两个，一个是圆点选中的状态，一个是未被选中的状态，先展示选中状态dot_focused.xml

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android"
    android:shape="oval" >
    <solid android:color="#aaFFFFFF" />
    <corners android:radius="5dip" />
</shape>

而在未被选中的状态下就只是颜色不一样而已，其他的都雷同，在dot_normal.xml中

<solid android:color="#33000000"/>

好了，以上布局就这么多了，下面是代码的介绍，先看一下存放图片的网络路径吧，在Images.java中。

package com.best.viewflipper;

public class Images {

	public final static String[] imageUrls = new String[] {
			"https://img-my.csdn.net/uploads/201309/01/1378037235_3453.jpg",
			"https://img-my.csdn.net/uploads/201309/01/1378037235_7476.jpg",
			"https://img-my.csdn.net/uploads/201309/01/1378037235_9280.jpg",
			"https://img-my.csdn.net/uploads/201309/01/1378037234_3539.jpg",
			"https://img-my.csdn.net/uploads/201309/01/1378037234_6318.jpg",
			"https://img-my.csdn.net/uploads/201309/01/1378037194_2965.jpg",
			"https://img-my.csdn.net/uploads/201309/01/1378037151_7904.jpg",
			};
}

接着就是处理图片的类，ImageLoader.java

package com.best.viewflipper;

import android.annotation.SuppressLint;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.LruCache;
/**
 * 对图片进行管理的工具类。
 */
public class ImageLoader {

	/**
	 * 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。
	 */
	private static LruCache<String, Bitmap> mMemoryCache;
	/**
	 * ImageLoader的实例。
	 */
	private static ImageLoader mImageLoader;
	@SuppressLint("NewApi")
	private ImageLoader() {
		// 获取应用程序最大可用内存
		int maxMemory = (int) Runtime.getRuntime().maxMemory();
		int cacheSize = maxMemory / 8;
		// 设置图片缓存大小为程序最大可用内存的1/8
		mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
			@Override
			protected int sizeOf(String key, Bitmap bitmap) {
				return bitmap.getByteCount();
			}
		};
	}
	/**
	 * 获取ImageLoader的实例。
	 * 
	 * @return ImageLoader的实例。
	 */
	public static ImageLoader getInstance() {
		if (mImageLoader == null) {
			mImageLoader = new ImageLoader();
		}
		return mImageLoader;
	}
	/**
	 * 将一张图片存储到LruCache中。
	 * 
	 * @param key
	 *            LruCache的键，这里传入图片的URL地址。
	 * @param bitmap
	 *            LruCache的键，这里传入从网络上下载的Bitmap对象。
	 */
	@SuppressLint("NewApi")
	public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
		if (getBitmapFromMemoryCache(key) == null) {
			mMemoryCache.put(key, bitmap);
		}
	}
	/**
	 * 从LruCache中获取一张图片，如果不存在就返回null。
	 * 
	 * @param key
	 *            LruCache的键，这里传入图片的URL地址。
	 * @return 对应传入键的Bitmap对象，或者null。
	 */
	@SuppressLint("NewApi")
	public Bitmap getBitmapFromMemoryCache(String key) {
		return mMemoryCache.get(key);
	}
	public static int calculateInSampleSize(BitmapFactory.Options options,
			int reqWidth) {
		// 源图片的宽度
		final int width = options.outWidth;
		int inSampleSize = 1;
		if (width > reqWidth) {
			// 计算出实际宽度和目标宽度的比率
			final int widthRatio = Math.round((float) width / (float) reqWidth);
			inSampleSize = widthRatio;
		}
		return inSampleSize;
	}
	public static Bitmap decodeSampledBitmapFromResource(String pathName,
			int reqWidth) {
		// 第一次解析将inJustDecodeBounds设置为true，来获取图片大小
		final BitmapFactory.Options options = new BitmapFactory.Options();
		options.inJustDecodeBounds = true;
		BitmapFactory.decodeFile(pathName, options);
		// 调用上面定义的方法计算inSampleSize值  比例
		options.inSampleSize = calculateInSampleSize(options, reqWidth);
		// 使用获取到的inSampleSize值再次解析图片
		options.inJustDecodeBounds = false;
		return BitmapFactory.decodeFile(pathName, options);
	}
}

再接着，就是在MainActivity.java中的代码了，在这里呢，先分解着说，后面再给完整的代码，先说动态添加图片，先创建一个画布给ImageView，之后给他设置属性，让其显示就可以了

//首先实例化一个画布
LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(width,height);
//实例化ImageView控件，存放从网络上获取下来的图片
ImageView imageView = new ImageView(this);
//把画布给ImageView控件，使ImageView显示出来
imageView.setLayoutParams(params);
//给ImageView添加上图片，一开始是一张空的图片，当加载完成后，才真正的展现出图片
imageView.setImageResource(R.drawable.empty_photo);
imageView.setScaleType(ScaleType.FIT_XY);
//添加到显示图片的ViewFlipper中
mViewFlipper.addView(imageView);
//将ImageView存放的List中
mImageList.add(imageView);

然后，动态创建出小圆点，和上面动态创建ImageView差不多，只不过在这里是获取的xml文件的布局而已

//首先，先获取到小圆点实现的布局
LinearLayout dot = (LinearLayout) View.inflate(this, R.layout.dot, null);
//把它添加到显示的区域
mShowDot.addView(dot);
//之后添加的List中，方便后续的管理
mLinearLayoutlist.add(dot);
if(flag){//flag==true时，则为第一次添加，第一次添加时，默认为选中的状态，之后，flag变为false就可以了
	mLinearLayoutlist.get(0).getChildAt(0).setBackgroundResource(R.drawable.dot_focused);
	flag = false;
}

接着就是把所需要下载的图片，放在一个任务当中，进行统一的管理

//将需要进行网络请求加入到任务当中，方便管理
for (int i = 0; i < Images.imageUrls.length; i++) {
	addImage(null,mWidth,mHeight,-1);
	LoadImageTask task = new LoadImageTask();
	mTaskCollection.add(task);
	task.execute(i);
}

下载的任务是继承了AsyncTask方法（异步任务），主要在doInBackground里处理图片的请求，方法有很多，不喜欢的，可以自行更改哦

class LoadImageTask extends AsyncTask<Integer, Void, Bitmap>{

	/**
	 * 记录每个图片对应的位置
	 */
	private int mItemPosition;
	
	public LoadImageTask() {
	}

	/**
	 * 将可重复使用的ImageView传入
	 * 
	 * @param imageView
	 */
	public LoadImageTask(ImageView imageView) {
		mImageView = imageView;
	}

	//处理网络请求的地方
	@Override
	protected Bitmap doInBackground(Integer... params) {
		mItemPosition = params[0];
		//获取相对应的网络图片路径
		mImageUrl = Images.imageUrls[mItemPosition];
		//根据路径名从LruCache中获取一张图片，如果不存在就返回null。
		Bitmap imageBitmap = mImageLoader.getBitmapFromMemoryCache(mImageUrl);
		if (imageBitmap == null) {
			//这样就说明在缓存区域图片不存在，接着需要获取图片
			imageBitmap = loadImage(mImageUrl);
		}
		return imageBitmap;
	}
	@Override
	protected void onPostExecute(Bitmap bitmap) {
		if (bitmap != null) {
			double ratio = bitmap.getWidth() / (mWidth * 1.0);
			int scaledHeight = (int) (bitmap.getHeight() / ratio);
			addImage(bitmap,mWidth,scaledHeight,mItemPosition);
		}
		mTaskCollection.remove(this);
	}
	
	/**
	 * 根据传入的URL，对图片进行加载。如果这张图片已经存在于SD卡中，则直接从SD卡里读取，否则就从网络上下载。
	 * 
	 * @param imageUrl
	 *            图片的URL地址
	 * @return 加载到内存的图片。
	 */
	private Bitmap loadImage(String imageUrl) {
		File imageFile = new File(getImagePath(imageUrl));
		if (!imageFile.exists()) {
			//如果 存放在本地的图片不存在 则在网络上下载  然后将图片存储到LruCache中
			downloadImage(imageUrl);
		}
		if (imageUrl != null) {
			//存在的话 则直接在SD卡中读取 然后将图片存储到LruCache中
			Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(imageFile.getPath(),
					mWidth);
			if (bitmap != null) {
				//获取图片后，以键值对的方式，不图片存于缓冲区当中
				mImageLoader.addBitmapToMemoryCache(imageUrl, bitmap);
				return bitmap;
			}
		}
		return null;
	}
}

根据图片的路径，进行加载

private Bitmap loadImage(String imageUrl) {
	File imageFile = new File(getImagePath(imageUrl));
	if (!imageFile.exists()) {
		//如果 存放在本地的图片不存在 则在网络上下载  然后将图片存储到LruCache中
		downloadImage(imageUrl);
	}
	if (imageUrl != null) {
		//存在的话 则直接在SD卡中读取 然后将图片存储到LruCache中
		Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(imageFile.getPath(),
				mWidth);
		if (bitmap != null) {
			//获取图片后，以键值对的方式，不图片存于缓冲区当中
			mImageLoader.addBitmapToMemoryCache(imageUrl, bitmap);
			return bitmap;
		}
	}
	return null;
}

如果在SD卡中找不到，则需要下载，然后写入到SD卡中

private void downloadImage(String imageUrl) {
	if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
		Log.d("TAG", "monted sdcard");
	} else {
		Log.d("TAG", "has no sdcard");
	}
	HttpURLConnection con = null;
	FileOutputStream fos = null;
	BufferedOutputStream bos = null;
	BufferedInputStream bis = null;
	File imageFile = null;
	try {
		URL url = new URL(imageUrl);
		//根据URL打开网络请求链接
		con = (HttpURLConnection) url.openConnection();
		//设置网络连接超时时间
		con.setConnectTimeout(5 * 1000);
		//设置读取超时时间
		con.setReadTimeout(15 * 1000);
		con.setDoInput(true);
		con.setDoOutput(true);
		//读取到网络获取到的内容
		bis = new BufferedInputStream(con.getInputStream());
		//获取到本地存储图片的路径
		imageFile = new File(getImagePath(imageUrl));
		//输入流
		fos = new FileOutputStream(imageFile);
		bos = new BufferedOutputStream(fos);
		byte[] b = new byte[1024];
		int length;
		//将获取的东西写入到文件当中
		while ((length = bis.read(b)) != -1) {
			bos.write(b, 0, length);
			bos.flush();
		}
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		//结束以后，一定要记得进行关闭
		try {
			if (bis != null) {
				bis.close();
			}
			if (bos != null) {
				bos.close();
			}
			if (con != null) {
				con.disconnect();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	if (imageFile != null) {
		Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(imageFile.getPath(),
				mWidth);
		if (bitmap != null) {
			mImageLoader.addBitmapToMemoryCache(imageUrl, bitmap);
		}
	}
}

获取本地存放图片的路径

private String getImagePath(String imageUrl) {
	int lastSlashIndex = imageUrl.lastIndexOf("/");
	String imageName = imageUrl.substring(lastSlashIndex + 1);
	String imageDir = Environment.getExternalStorageDirectory().getPath()
			+ "/aaImages/";
	File file = new File(imageDir);
	if (!file.exists()) {
		file.mkdirs();
	}
	String imagePath = imageDir + imageName;
	return imagePath;
}

之后就是在图片显示以后，进行的轮播和手势触动时的轮播，在这里我就不再啰嗦了，前篇文章已经提过了，况且代码中有注释，没看过上一篇的，可以看一下完整的代码，接下来就是在MainActivity.java的所有实现的代码

package com.best.viewflipper;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.graphics.Bitmap;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.Window;
import android.widget.ImageView;
import android.widget.ImageView.ScaleType;
import android.widget.LinearLayout;
import android.widget.Toast;
import android.widget.ViewFlipper;

public class MainActivity extends Activity{
	private ViewFlipper mViewFlipper;//这是存放图片区域的控件
	private LinearLayout mShowDot;//显示点区域
	private List<LinearLayout> mLinearLayoutlist;//存放点的View
	private String mImageUrl;//临时存放图片的路径，方便进行加载
	private int mWidth,mHeight;//显示图片区域的宽和高
	private ImageView mImageView;//图片不为空时，可重复使用
	private boolean flag = true;//记录是否是第一次添加的小圆点
	/**
	 * 自动进行轮播的标记：AUTO=1
	 * */
	private static final int AUTO = 0x01;
	/**
	 * 向左滑动 上一张的标记：PREVIOUS=2 
	 * */
	private static final int PREVIOUS = 0x02;
	/**
	 * 向右滑动 下一张的标记：NEXT=3
	 * */
	private static final int NEXT = 0x03;
	/**
	 * 存放显示图片的控件
	 * */
	private List<ImageView> mImageList = new ArrayList<ImageView>();
	/**
	 * 记录所有正在下载或等待下载的任务
	 * */
	private static Set<LoadImageTask> mTaskCollection;
	/**
	 * 对图片进行管理的工具类
	 * */
	private ImageLoader mImageLoader;
	private float x,y;//记录弹起和按下时的坐标
	
	@SuppressLint("HandlerLeak")
	private Handler handler = new Handler() { 
	    @Override
	    public void handleMessage(Message msg)  
	    { 
	        switch (msg.what) {
			case AUTO:
				showNext();
				sendAutoMes();
				break;
			case PREVIOUS:
				//因为是手势触动的原因，所以必须先移除掉自动轮播的模式，否则会出现图片轮播错乱
				handler.removeMessages(AUTO);
				showPre(); 
				sendAutoMes();
				break;
			case NEXT:
				handler.removeMessages(AUTO);
				showNext();
				sendAutoMes();
				break;
			default:
				break;
			}
	    } 
	          
	}; 
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);
		initView();
		sendAutoMes();
		setEvent();
	}
	/**
	 * 动态添加图片
	 * */
	public void addImage(Bitmap bitmap,int width,int height,int id){
		if(bitmap!=null){
			if (mImageView != null) {
				mImageView.setImageBitmap(bitmap);
			} else {
				//添加上已获得到的图片
				mImageList.get(id).setImageBitmap(bitmap);
			}
		}else{
			//首先实例化一个画布
			LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(width,height);
			//实例化ImageView控件，存放从网络上获取下来的图片
			ImageView imageView = new ImageView(this);
			//把画布给ImageView控件，使ImageView显示出来
			imageView.setLayoutParams(params);
			//给ImageView添加上图片，一开始是一张空的图片，当加载完成后，才真正的展现出图片
			imageView.setImageResource(R.drawable.empty_photo);
			imageView.setScaleType(ScaleType.FIT_XY);
			//添加到显示图片的ViewFlipper中
			mViewFlipper.addView(imageView);
			//将ImageView存放的List中
			mImageList.add(imageView);
			addDot();
		}
	}
	
	/**
	 * 动态添加小圆点
	 * */
	public void addDot(){
		//首先，先获取到小圆点实现的布局
		LinearLayout dot = (LinearLayout) View.inflate(this, R.layout.dot, null);
		//把它添加到显示的区域
		mShowDot.addView(dot);
		//之后添加的List中，方便后续的管理
		mLinearLayoutlist.add(dot);
		if(flag){//flag==true时，则为第一次添加，第一次添加时，默认为选中的状态，之后，flag变为false就可以了
			mLinearLayoutlist.get(0).getChildAt(0).setBackgroundResource(R.drawable.dot_focused);
			flag = false;
		}
	}
	/**
	 * 下载图片的任务
	 * */
	class LoadImageTask extends AsyncTask<Integer, Void, Bitmap>{

		/**
		 * 记录每个图片对应的位置
		 */
		private int mItemPosition;
		
		public LoadImageTask() {
		}

		/**
		 * 将可重复使用的ImageView传入
		 * 
		 * @param imageView
		 */
		public LoadImageTask(ImageView imageView) {
			mImageView = imageView;
		}

		//处理网络请求的地方
		@Override
		protected Bitmap doInBackground(Integer... params) {
			mItemPosition = params[0];
			//获取相对应的网络图片路径
			mImageUrl = Images.imageUrls[mItemPosition];
			//根据路径名从LruCache中获取一张图片，如果不存在就返回null。
			Bitmap imageBitmap = mImageLoader.getBitmapFromMemoryCache(mImageUrl);
			if (imageBitmap == null) {
				//这样就说明在缓存区域图片不存在，接着需要获取图片
				imageBitmap = loadImage(mImageUrl);
			}
			return imageBitmap;
		}
		@Override
		protected void onPostExecute(Bitmap bitmap) {
			if (bitmap != null) {
				double ratio = bitmap.getWidth() / (mWidth * 1.0);
				int scaledHeight = (int) (bitmap.getHeight() / ratio);
				addImage(bitmap,mWidth,scaledHeight,mItemPosition);
			}
			mTaskCollection.remove(this);
		}
		
		/**
		 * 根据传入的URL，对图片进行加载。如果这张图片已经存在于SD卡中，则直接从SD卡里读取，否则就从网络上下载。
		 * 
		 * @param imageUrl
		 *            图片的URL地址
		 * @return 加载到内存的图片。
		 */
		private Bitmap loadImage(String imageUrl) {
			File imageFile = new File(getImagePath(imageUrl));
			if (!imageFile.exists()) {
				//如果 存放在本地的图片不存在 则在网络上下载  然后将图片存储到LruCache中
				downloadImage(imageUrl);
			}
			if (imageUrl != null) {
				//存在的话 则直接在SD卡中读取 然后将图片存储到LruCache中
				Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(imageFile.getPath(),
						mWidth);
				if (bitmap != null) {
					//获取图片后，以键值对的方式，不图片存于缓冲区当中
					mImageLoader.addBitmapToMemoryCache(imageUrl, bitmap);
					return bitmap;
				}
			}
			return null;
		}
	}
	/**
	 * 设置手势监听事件
	 * */
	public void setEvent(){
		mViewFlipper.setOnTouchListener(new OnTouchListener() { 
	           
	        @SuppressLint("ClickableViewAccessibility") 
	        @Override
	        public boolean onTouch(View v, MotionEvent event) { 
	            switch(event.getAction()) 
	            { 
		            case MotionEvent.ACTION_DOWN:// 当手按下时，获取X的坐标轴
		               x = event.getX();                
		               Toast.makeText(getApplicationContext(), "down"+event.getX(), Toast.LENGTH_LONG).show(); 
		            break; 
		            case MotionEvent.ACTION_UP: //当手弹起时，获取X的坐标轴，与按下时获得的坐标进行对比
		                y = event.getX();            
		                if(y>x) { 
		                	//发送显示上一张图片的消息
		            		handler.sendEmptyMessage(PREVIOUS); 
		                } else if(x==y) {
		                	//在原位置，无需做任何事
		                    showDetail(); 
		                } else{ 
		                	//发送显示下一张图片的消息
		                    handler.sendEmptyMessage(NEXT); 
		                }                    
		            break;              
		        }                
	            return true; 
	        } 
	    }); 
	}
	
	/**
	 * 发送自动进行轮播的消息
	 * */
	public void sendAutoMes(){
		Message msgs = new Message();
		msgs.what = AUTO;
        handler.sendMessageDelayed(msgs, 2000); 
	}
	/**
	 * 实例化控件
	 * */
	public void initView(){
		mImageLoader = ImageLoader.getInstance();
		mTaskCollection = new HashSet<LoadImageTask>();
		mLinearLayoutlist = new ArrayList<LinearLayout>();
		mViewFlipper = (ViewFlipper) findViewById(R.id.viewflipper);
		mShowDot = (LinearLayout) findViewById(R.id.show_dot);
		mWidth = mViewFlipper.getLayoutParams().width;
        mHeight = mViewFlipper.getLayoutParams().height;
		//将需要进行网络请求加入到任务当中，方便管理
		for (int i = 0; i < Images.imageUrls.length; i++) {
			addImage(null,mWidth,mHeight,-1);
			LoadImageTask task = new LoadImageTask();
			mTaskCollection.add(task);
			task.execute(i);
		}
	}
  
	/**
	 * 滑动显示下一张图片
	 * */
	private void showNext() { 
		mViewFlipper.showNext(); 
		//获取当前显示的的索引值
	    int current = mViewFlipper.getDisplayedChild(); 
	    if(current == 0) { 
	    	mLinearLayoutlist.get(Images.imageUrls.length-1).getChildAt(0).setBackgroundResource(R.drawable.dot_normal); 
	    } else{ 
	    	mLinearLayoutlist.get(current-1).getChildAt(0).setBackgroundResource(R.drawable.dot_normal); 
	    } 
	    mLinearLayoutlist.get(current).getChildAt(0).setBackgroundResource(R.drawable.dot_focused);       
	} 
	/**
	 * 向左滑动  显示上一张图片
	 * */
	private void showPre() { 
		mViewFlipper.showPrevious(); 
		//获取当前显示的的索引值
	    int current = mViewFlipper.getDisplayedChild(); 
	    if(current == Images.imageUrls.length-1) { 
	    	mLinearLayoutlist.get(0).getChildAt(0).setBackgroundResource(R.drawable.dot_normal); 
	    } else{ 
	    	mLinearLayoutlist.get(current+1).getChildAt(0).setBackgroundResource(R.drawable.dot_normal); 
	    } 
	    mLinearLayoutlist.get(current).getChildAt(0).setBackgroundResource(R.drawable.dot_focused);       
	} 
	private void showDetail() { 
	    Toast.makeText(getApplicationContext(),"x=y", Toast.LENGTH_SHORT).show(); 
	} 
	
	/**
	 * 将图片下载到SD卡缓存起来。
	 * 
	 * @param imageUrl
	 *            图片的URL地址。
	 */
	private void downloadImage(String imageUrl) {
		if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
			Log.d("TAG", "monted sdcard");
		} else {
			Log.d("TAG", "has no sdcard");
		}
		HttpURLConnection con = null;
		FileOutputStream fos = null;
		BufferedOutputStream bos = null;
		BufferedInputStream bis = null;
		File imageFile = null;
		try {
			URL url = new URL(imageUrl);
			//根据URL打开网络请求链接
			con = (HttpURLConnection) url.openConnection();
			//设置网络连接超时时间
			con.setConnectTimeout(5 * 1000);
			//设置读取超时时间
			con.setReadTimeout(15 * 1000);
			con.setDoInput(true);
			con.setDoOutput(true);
			//读取到网络获取到的内容
			bis = new BufferedInputStream(con.getInputStream());
			//获取到本地存储图片的路径
			imageFile = new File(getImagePath(imageUrl));
			//输入流
			fos = new FileOutputStream(imageFile);
			bos = new BufferedOutputStream(fos);
			byte[] b = new byte[1024];
			int length;
			//将获取的东西写入到文件当中
			while ((length = bis.read(b)) != -1) {
				bos.write(b, 0, length);
				bos.flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			//结束以后，一定要记得进行关闭
			try {
				if (bis != null) {
					bis.close();
				}
				if (bos != null) {
					bos.close();
				}
				if (con != null) {
					con.disconnect();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		if (imageFile != null) {
			Bitmap bitmap = ImageLoader.decodeSampledBitmapFromResource(imageFile.getPath(),
					mWidth);
			if (bitmap != null) {
				mImageLoader.addBitmapToMemoryCache(imageUrl, bitmap);
			}
		}
	}
	
	/**
	 * 获取图片的本地存储路径。
	 * 
	 * @param imageUrl
	 *            图片的URL地址。
	 * @return 图片的本地存储路径。
	 */
	private String getImagePath(String imageUrl) {
		int lastSlashIndex = imageUrl.lastIndexOf("/");
		String imageName = imageUrl.substring(lastSlashIndex + 1);
		String imageDir = Environment.getExternalStorageDirectory().getPath()
				+ "/aaImages/";
		File file = new File(imageDir);
		if (!file.exists()) {
			file.mkdirs();
		}
		String imagePath = imageDir + imageName;
		return imagePath;
	}
}

对了，还有一点，很重要，那就是权限呀，这个可千万不能忘了，否则写的就都没什么用了呀！！！

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

哈哈，效果图就不给展示了，轮播吗，就那么回事（其实我不会上传动态图，请原谅哦，以后会改进的），结束了！！！
下载资源源码：http://download.csdn.net/detail/elvira_mx/8645431

Elvira_mx

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录