Android在ImageView上直接显示网络图片

亲测可用,若有疑问请私信 

   在原生的ImageView中,没有一个方法是可以直接显示网络的图片的,当我们经常需要显示网络图片时,每次都有一大堆的操作,这会很麻烦,今天就教大家在ImageView上轻松显示网络图片。

自定义ImageView方法

写一个类让它继承ImageView,并增加一个setImageURL(path)方法

 
  1. import android.content.Context;

  2. import android.graphics.Bitmap;

  3. import android.graphics.BitmapFactory;

  4. import android.os.Handler;

  5. import android.os.Message;

  6. import android.util.AttributeSet;

  7. import android.widget.ImageView;

  8. import android.widget.Toast;

  9. import java.io.IOException;

  10. import java.io.InputStream;

  11. import java.net.HttpURLConnection;

  12. import java.net.URL;

  13. public class MyImageView extends ImageView {

  14. public static final int GET_DATA_SUCCESS = 1;

  15. public static final int NETWORK_ERROR = 2;

  16. public static final int SERVER_ERROR = 3;

  17. //子线程不能操作UI,通过Handler设置图片

  18. private Handler handler = new Handler() {

  19. @Override

  20. public void handleMessage(Message msg) {

  21. switch (msg.what){

  22. case GET_DATA_SUCCESS:

  23. Bitmap bitmap = (Bitmap) msg.obj;

  24. setImageBitmap(bitmap);

  25. break;

  26. case NETWORK_ERROR:

  27. Toast.makeText(getContext(),"网络连接失败",Toast.LENGTH_SHORT).show();

  28. break;

  29. case SERVER_ERROR:

  30. Toast.makeText(getContext(),"服务器发生错误",Toast.LENGTH_SHORT).show();

  31. break;

  32. }

  33. }

  34. };

  35. public MyImageView(Context context, AttributeSet attrs, int defStyleAttr) {

  36. super(context, attrs, defStyleAttr);

  37. }

  38. public MyImageView(Context context) {

  39. super(context);

  40. }

  41. public MyImageView(Context context, AttributeSet attrs) {

  42. super(context, attrs);

  43. }

  44. //设置网络图片

  45. public void setImageURL(final String path) {

  46. //开启一个线程用于联网

  47. new Thread() {

  48. @Override

  49. public void run() {

  50. try {

  51. //把传过来的路径转成URL

  52. URL url = new URL(path);

  53. //获取连接

  54. HttpURLConnection connection = (HttpURLConnection) url.openConnection();

  55. //使用GET方法访问网络

  56. connection.setRequestMethod("GET");

  57. //超时时间为10秒

  58. connection.setConnectTimeout(10000);

  59. //获取返回码

  60. int code = connection.getResponseCode();

  61. if (code == 200) {

  62. InputStream inputStream = connection.getInputStream();

  63. //使用工厂把网络的输入流生产Bitmap

  64. Bitmap bitmap = BitmapFactory.decodeStream(inputStream);

  65. //利用Message把图片发给Handler

  66. Message msg = Message.obtain();

  67. msg.obj = bitmap;

  68. msg.what = GET_DATA_SUCCESS;

  69. handler.sendMessage(msg);

  70.               inputStream.close();

  71. }else {

  72. //服务启发生错误

  73. handler.sendEmptyMessage(SERVER_ERROR);

  74. }

  75. } catch (IOException e) {

  76. e.printStackTrace();

  77. //网络连接错误

  78. handler.sendEmptyMessage(NETWORK_ERROR);

  79. }

  80. }

  81. }.start();

  82. }

  83. }

在布局上不能使用ImageView,要使用MyImageView,要把刚才重写的一个MyImageView的全路径写上

 
  1. <Button

  2. android:text="加载网络图片"

  3. android:layout_width="match_parent"

  4. android:layout_height="wrap_content"

  5. android:id="@+id/button" />

  6. <com.example.dell.myapplication.MyImageView

  7. android:id="@+id/image_view"

  8. android:layout_width="match_parent"

  9. android:layout_height="match_parent" />

在MainActivity上,只要调用setImageURL(),直接把网络的图片路径写上就可以显示网络的图片了

 
  1. final MyImageView myImageView = (MyImageView) findViewById(R.id.image_view);

  2. Button button = (Button) findViewById(R.id.button);

  3. button.setOnClickListener(new View.OnClickListener() {

  4. @Override

  5. public void onClick(View v) {

  6.           //直接把网络的图片路径写上就可以显示网络的图片了

  7. myImageView.setImageURL("https://pic.cnblogs.com/avatar/1142647/20170416093225.png");

  8. }

  9. });

最后别忘了添加访问网络的权限

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

效果图

压缩

       这是比较简单的从网络获取照片,直接在ImageView上显示,但是你有没有考虑过如果网络的图片很大,已经超出了手机屏幕的大小,如果还是加载原图的话无疑是浪费内存,还有可能造成内存溢出,所以我们有必要对网络的图片进行压缩,下面就开始讲网络图片的压缩。

首先获取ImageView要显示的宽度和高度

 
  1. /**

  2. * 获取ImageView实际的宽度

  3. * @return 返回ImageView实际的宽度

  4. */

  5. public int realImageViewWith() {

  6. DisplayMetrics displayMetrics = getContext().getResources().getDisplayMetrics();

  7. ViewGroup.LayoutParams layoutParams = getLayoutParams();

  8. //如果ImageView设置了宽度就可以获取实在宽带

  9. int width = getWidth();

  10. if (width <= 0) {

  11. //如果ImageView没有设置宽度,就获取父级容器的宽度

  12. width = layoutParams.width;

  13. }

  14. if (width <= 0) {

  15. //获取ImageView宽度的最大值

  16. width = getMaxWidth();

  17. }

  18. if (width <= 0) {

  19. //获取屏幕的宽度

  20. width = displayMetrics.widthPixels;

  21. }

  22. Log.e("ImageView实际的宽度", String.valueOf(width));

  23. return width;

  24. }

  25. /**

  26. * 获取ImageView实际的高度

  27. * @return 返回ImageView实际的高度

  28. */

  29. public int realImageViewHeight() {

  30. DisplayMetrics displayMetrics = getContext().getResources().getDisplayMetrics();

  31. ViewGroup.LayoutParams layoutParams = getLayoutParams();

  32. //如果ImageView设置了高度就可以获取实在宽度

  33. int height = getHeight();

  34. if (height <= 0) {

  35. //如果ImageView没有设置高度,就获取父级容器的高度

  36. height = layoutParams.height;

  37. }

  38. if (height <= 0) {

  39. //获取ImageView高度的最大值

  40. height = getMaxHeight();

  41. }

  42. if (height <= 0) {

  43. //获取ImageView高度的最大值

  44. height = displayMetrics.heightPixels;

  45. }

  46. Log.e("ImageView实际的高度", String.valueOf(height));

  47. return height;

  48. }

然后是通过网络图片的大小计算要压缩的比率

 
  1. /**

  2. * 获得需要压缩的比率

  3. *

  4. * @param options 需要传入已经BitmapFactory.decodeStream(is, null, options);

  5. * @return 返回压缩的比率,最小为1

  6. */

  7. public int getInSampleSize(BitmapFactory.Options options) {

  8. int inSampleSize = 1;

  9. int realWith = realImageViewWith();

  10. int realHeight = realImageViewHeight();

  11. int outWidth = options.outWidth;

  12. Log.e("网络图片实际的宽度", String.valueOf(outWidth));

  13. int outHeight = options.outHeight;

  14. Log.e("网络图片实际的高度", String.valueOf(outHeight));

  15. //获取比率最大的那个

  16. if (outWidth > realWith || outHeight > realHeight) {

  17. int withRadio = Math.round(outWidth / realWith);

  18. int heightRadio = Math.round(outHeight / realHeight);

  19. inSampleSize = withRadio > heightRadio ? withRadio : heightRadio;

  20. }

  21. Log.e("压缩比率", String.valueOf(inSampleSize));

  22. return inSampleSize;

  23. }

获得压缩比率后,就可以进行压缩了

 
  1. /**

  2. * 根据输入流返回一个压缩的图片

  3. * @param input 图片的输入流

  4. * @return 压缩的图片

  5. */

  6. public Bitmap getCompressBitmap(InputStream input) {

  7. //因为InputStream要使用两次,但是使用一次就无效了,所以需要复制两个

  8. ByteArrayOutputStream baos = new ByteArrayOutputStream();

  9. try {

  10. byte[] buffer = new byte[1024];

  11. int len;

  12. while ((len = input.read(buffer)) > -1 ) {

  13. baos.write(buffer, 0, len);

  14. }

  15. baos.flush();

  16. } catch (IOException e) {

  17. e.printStackTrace();

  18. }

  19. //复制新的输入流

  20. InputStream is = new ByteArrayInputStream(baos.toByteArray());

  21. InputStream is2 = new ByteArrayInputStream(baos.toByteArray());

  22. //只是获取网络图片的大小,并没有真正获取图片

  23. BitmapFactory.Options options = new BitmapFactory.Options();

  24. options.inJustDecodeBounds = true;

  25. BitmapFactory.decodeStream(is, null, options);

  26. //获取图片并进行压缩

  27. options.inSampleSize = getInSampleSize(options);

  28. options.inJustDecodeBounds = false;

  29. return BitmapFactory.decodeStream(is2, null, options);

  30. }

最后就是在setImageURL()的方法中把 Bitmap bitmap = BitmapFactory.decodeStream(inputStream); 改成下面的方法

Bitmap bitmap = getCompressBitmap(inputStream);

缓存

有时候提高运行效率和节省流量,经常会使用的缓存,数据缓存后就算没有网络都可以使用,下面就开始学习缓存吧,我这种缓存不是正规的缓存技术。

将setImageURL()方法改成如下,并增加两全局变量imagePath、isUseCache;

 
  1. //是否启用缓存

  2. public boolean isUseCache = false;

  3.    private String imagePath;

  4. //设置网络图片

  5. public void setImageURL(String path) {

  6. imagePath = path;

  7. if (isUseCache){

  8. useCacheImage();

  9. }else {

  10. useNetWorkImage();

  11. }

  12. }

把之前setImageURL()的大部分功能放到useNetWorkImage()方法中,增加一个判断:是否缓存图片

 
  1. //使用网络图片显示

  2. public void useNetWorkImage(){

  3. //开启一个线程用于联网

  4. new Thread() {

  5. @Override

  6. public void run() {

  7. try {

  8. //把传过来的路径转成URL

  9. URL url = new URL(imagePath);

  10. //获取连接

  11. HttpURLConnection connection = (HttpURLConnection) url.openConnection();

  12. //使用GET方法访问网络

  13. connection.setRequestMethod("GET");

  14. //超时时间为10秒

  15. connection.setConnectTimeout(10000);

  16. //获取返回码

  17. int code = connection.getResponseCode();

  18. if (code == 200) {

  19. Bitmap bitmap;

  20. //获取网络输入流

  21. InputStream inputStream = connection.getInputStream();

  22. //判断是否使用缓存图片

  23. if (isUseCache){

  24. //因为InputStream要使用两次,但是使用一次就无效了,所以需要复制两个

  25. ByteArrayOutputStream baos = new ByteArrayOutputStream();

  26. try {

  27. byte[] buffer = new byte[1024];

  28. int len;

  29. while ((len = inputStream.read(buffer)) > -1) {

  30. baos.write(buffer, 0, len);

  31. }

  32. baos.flush();

  33. } catch (IOException e) {

  34. e.printStackTrace();

  35. }

  36. //复制新的输入流

  37. InputStream is = new ByteArrayInputStream(baos.toByteArray());

  38. InputStream is2 = new ByteArrayInputStream(baos.toByteArray());

  39. //调用压缩方法显示图片

  40. bitmap = getCompressBitmap(is);

  41. //调用缓存图片方法

  42. cacheImage(is2);

  43. }else {

  44. //调用压缩方法

  45. bitmap = getCompressBitmap(inputStream);

  46. }

  47. //利用Message把图片发给Handler

  48. Message msg = Message.obtain();

  49. msg.obj = bitmap;

  50. msg.what = GET_DATA_SUCCESS;

  51. handler.sendMessage(msg);

  52. inputStream.close();

  53. } else {

  54. //服务启发生错误

  55. handler.sendEmptyMessage(SERVER_ERROR);

  56. }

  57. } catch (IOException e) {

  58. e.printStackTrace();

  59. //网络连接错误

  60. handler.sendEmptyMessage(NETWORK_ERROR);

  61. }

  62. }

  63. }.start();

  64. }

 创建一个方法用于根据传了的网址生成一个独一无二文件,之后会根据这个路径生成图片和查找是否有缓存图片

 
  1. /**

  2. * 根据网址生成一个文件名

  3. * @return 文件名

  4. */

  5. public String getURLPath() {

  6. StringBuilder urlStr2 = new StringBuilder();

  7. String[] strings = imagePath.split("\\/");

  8. for (String string : strings) {

  9. urlStr2.append(string);

  10. }

  11. Log.e("MyImageView","文件名:"+urlStr2.toString());

  12. return urlStr2.toString();

  13. }

根据生成的路径缓存图片

 
  1. /**

  2. * 缓存网络的图片

  3. * @param inputStream 网络的输入流

  4. */

  5. public void cacheImage(InputStream inputStream) {

  6. try {

  7. File file = new File(getContext().getCacheDir(), getURLPath());

  8. FileOutputStream fos = new FileOutputStream(file);

  9. int len;

  10. byte[] buffer = new byte[1024];

  11. while ((len = inputStream.read(buffer)) != -1) {

  12. fos.write(buffer, 0, len);

  13. }

  14. fos.close();

  15. Log.e("MyImageView","缓存成功");

  16. } catch (IOException e) {

  17. e.printStackTrace();

  18. Log.e("MyImageView","缓存失败");

  19. }

  20. }

最后就可以直接使用缓存图片了

 
  1. //使用缓存图片

  2. public void useCacheImage() {

  3. //创建路径一样的文件

  4. File file = new File(getContext().getCacheDir(), getURLPath());

  5. //判断文件是否存在

  6. if (file != null && file.length() > 0) {

  7. //使用本地图片

  8. try {

  9. InputStream inputStream = new FileInputStream(file);

  10. //调用压缩方法显示图片

  11. Bitmap bitmap = getCompressBitmap(inputStream);

  12. //利用Message把图片发给Handler

  13. Message msg = Message.obtain();

  14. msg.obj = bitmap;

  15. msg.what = GET_DATA_SUCCESS;

  16. handler.sendMessage(msg);

  17. Log.e("MyImageView","使用缓存图片");

  18. } catch (FileNotFoundException e) {

  19. e.printStackTrace();

  20. }

  21. }else {

  22. //使用网络图片

  23. useNetWorkImage();

  24. Log.e("MyImageView","使用网络图片");

  25. }

  26. }

现在就可以使用缓存了,记得要吧isUseCache设置成true

 
  1. //直接把网络的图片路径写上就可以显示网络的图片了

  2. String url = "https://pic.cnblogs.com/avatar/1142647/20170416093225.png";

  3. //设置成true才会启动缓存,默认是false

  4. myImageView.isUseCache = true;

  5. myImageView.setImageURL(url);

整篇MyImageView.java的代码

 
  1. import android.content.Context;

  2. import android.graphics.Bitmap;

  3. import android.graphics.BitmapFactory;

  4. import android.os.Handler;

  5. import android.os.Message;

  6. import android.util.AttributeSet;

  7. import android.util.DisplayMetrics;

  8. import android.util.Log;

  9. import android.view.ViewGroup;

  10. import android.widget.ImageView;

  11. import android.widget.Toast;

  12. import java.io.ByteArrayInputStream;

  13. import java.io.ByteArrayOutputStream;

  14. import java.io.File;

  15. import java.io.FileInputStream;

  16. import java.io.FileNotFoundException;

  17. import java.io.FileOutputStream;

  18. import java.io.IOException;

  19. import java.io.InputStream;

  20. import java.net.HttpURLConnection;

  21. import java.net.URL;

  22. public class MyImageView extends ImageView {

  23. private String imagePath;

  24. //是否启用缓存

  25. public boolean isUseCache = false;

  26. public static final int GET_DATA_SUCCESS = 1;

  27. public static final int NETWORK_ERROR = 2;

  28. public static final int SERVER_ERROR = 3;

  29. //子线程不能操作UI,通过Handler设置图片

  30. private Handler handler = new Handler() {

  31. @Override

  32. public void handleMessage(Message msg) {

  33. switch (msg.what) {

  34. case GET_DATA_SUCCESS:

  35. Bitmap bitmap = (Bitmap) msg.obj;

  36. setImageBitmap(bitmap);

  37. break;

  38. case NETWORK_ERROR:

  39. Toast.makeText(getContext(), "网络连接失败", Toast.LENGTH_SHORT).show();

  40. break;

  41. case SERVER_ERROR:

  42. Toast.makeText(getContext(), "服务器发生错误", Toast.LENGTH_SHORT).show();

  43. break;

  44. }

  45. }

  46. };

  47. public MyImageView(Context context, AttributeSet attrs, int defStyleAttr) {

  48. super(context, attrs, defStyleAttr);

  49. }

  50. public MyImageView(Context context) {

  51. super(context);

  52. }

  53. public MyImageView(Context context, AttributeSet attrs) {

  54. super(context, attrs);

  55. }

  56. //设置网络图片

  57. public void setImageURL(String path) {

  58. imagePath = path;

  59. if (isUseCache){

  60. useCacheImage();

  61. }else {

  62. useNetWorkImage();

  63. }

  64. }

  65. //使用网络图片显示

  66. public void useNetWorkImage(){

  67. //开启一个线程用于联网

  68. new Thread() {

  69. @Override

  70. public void run() {

  71. try {

  72. //把传过来的路径转成URL

  73. URL url = new URL(imagePath);

  74. //获取连接

  75. HttpURLConnection connection = (HttpURLConnection) url.openConnection();

  76. //使用GET方法访问网络

  77. connection.setRequestMethod("GET");

  78. //超时时间为10秒

  79. connection.setConnectTimeout(10000);

  80. //获取返回码

  81. int code = connection.getResponseCode();

  82. if (code == 200) {

  83. Bitmap bitmap;

  84. //获取网络输入流

  85. InputStream inputStream = connection.getInputStream();

  86. //判断是否使用缓存图片

  87. if (isUseCache){

  88. //因为InputStream要使用两次,但是使用一次就无效了,所以需要复制两个

  89. ByteArrayOutputStream baos = new ByteArrayOutputStream();

  90. try {

  91. byte[] buffer = new byte[1024];

  92. int len;

  93. while ((len = inputStream.read(buffer)) > -1) {

  94. baos.write(buffer, 0, len);

  95. }

  96. baos.flush();

  97. } catch (IOException e) {

  98. e.printStackTrace();

  99. }

  100. //复制新的输入流

  101. InputStream is = new ByteArrayInputStream(baos.toByteArray());

  102. InputStream is2 = new ByteArrayInputStream(baos.toByteArray());

  103. //调用压缩方法显示图片

  104. bitmap = getCompressBitmap(is);

  105. //调用缓存图片方法

  106. cacheImage(is2);

  107. }else {

  108. //调用压缩方法

  109. bitmap = getCompressBitmap(inputStream);

  110. }

  111. //利用Message把图片发给Handler

  112. Message msg = Message.obtain();

  113. msg.obj = bitmap;

  114. msg.what = GET_DATA_SUCCESS;

  115. handler.sendMessage(msg);

  116. inputStream.close();

  117. } else {

  118. //服务启发生错误

  119. handler.sendEmptyMessage(SERVER_ERROR);

  120. }

  121. } catch (IOException e) {

  122. e.printStackTrace();

  123. //网络连接错误

  124. handler.sendEmptyMessage(NETWORK_ERROR);

  125. }

  126. }

  127. }.start();

  128. }

  129. //使用缓存图片

  130. public void useCacheImage() {

  131. //创建路径一样的文件

  132. File file = new File(getContext().getCacheDir(), getURLPath());

  133. //判断文件是否存在

  134. if (file != null && file.length() > 0) {

  135. //使用本地图片

  136. try {

  137. InputStream inputStream = new FileInputStream(file);

  138. //调用压缩方法显示图片

  139. Bitmap bitmap = getCompressBitmap(inputStream);

  140. //利用Message把图片发给Handler

  141. Message msg = Message.obtain();

  142. msg.obj = bitmap;

  143. msg.what = GET_DATA_SUCCESS;

  144. handler.sendMessage(msg);

  145. Log.e("MyImageView","使用缓存图片");

  146. } catch (FileNotFoundException e) {

  147. e.printStackTrace();

  148. }

  149. }else {

  150. //使用网络图片

  151. useNetWorkImage();

  152. Log.e("MyImageView","使用网络图片");

  153. }

  154. }

  155. /**

  156. * 缓存网络的图片

  157. * @param inputStream 网络的输入流

  158. */

  159. public void cacheImage(InputStream inputStream) {

  160. try {

  161. File file = new File(getContext().getCacheDir(), getURLPath());

  162. FileOutputStream fos = new FileOutputStream(file);

  163. int len;

  164. byte[] buffer = new byte[1024];

  165. while ((len = inputStream.read(buffer)) != -1) {

  166. fos.write(buffer, 0, len);

  167. }

  168. fos.close();

  169. Log.e("MyImageView","缓存成功");

  170. } catch (IOException e) {

  171. e.printStackTrace();

  172. Log.e("MyImageView","缓存失败");

  173. }

  174. }

  175. /**

  176. * 根据网址生成一个文件名

  177. * @return 文件名

  178. */

  179. public String getURLPath() {

  180. StringBuilder urlStr2 = new StringBuilder();

  181. String[] strings = imagePath.split("\\/");

  182. for (String string : strings) {

  183. urlStr2.append(string);

  184. }

  185. Log.e("MyImageView","文件名:"+urlStr2.toString());

  186. return urlStr2.toString();

  187. }

  188. /**

  189. * 根据输入流返回一个压缩的图片

  190. *

  191. * @param input 图片的输入流

  192. * @return 压缩的图片

  193. */

  194. public Bitmap getCompressBitmap(InputStream input) {

  195. //因为InputStream要使用两次,但是使用一次就无效了,所以需要复制两个

  196. ByteArrayOutputStream baos = new ByteArrayOutputStream();

  197. try {

  198. byte[] buffer = new byte[1024];

  199. int len;

  200. while ((len = input.read(buffer)) > -1) {

  201. baos.write(buffer, 0, len);

  202. }

  203. baos.flush();

  204. } catch (IOException e) {

  205. e.printStackTrace();

  206. }

  207. //复制新的输入流

  208. InputStream is = new ByteArrayInputStream(baos.toByteArray());

  209. InputStream is2 = new ByteArrayInputStream(baos.toByteArray());

  210. //只是获取网络图片的大小,并没有真正获取图片

  211. BitmapFactory.Options options = new BitmapFactory.Options();

  212. options.inJustDecodeBounds = true;

  213. BitmapFactory.decodeStream(is, null, options);

  214. //获取图片并进行压缩

  215. options.inSampleSize = getInSampleSize(options);

  216. options.inJustDecodeBounds = false;

  217. return BitmapFactory.decodeStream(is2, null, options);

  218. }

  219. /**

  220. * 获得需要压缩的比率

  221. *

  222. * @param options 需要传入已经BitmapFactory.decodeStream(is, null, options);

  223. * @return 返回压缩的比率,最小为1

  224. */

  225. public int getInSampleSize(BitmapFactory.Options options) {

  226. int inSampleSize = 1;

  227. int realWith = realImageViewWith();

  228. int realHeight = realImageViewHeight();

  229. int outWidth = options.outWidth;

  230. Log.e("网络图片实际的宽度", String.valueOf(outWidth));

  231. int outHeight = options.outHeight;

  232. Log.e("网络图片实际的高度", String.valueOf(outHeight));

  233. //获取比率最大的那个

  234. if (outWidth > realWith || outHeight > realHeight) {

  235. int withRadio = Math.round(outWidth / realWith);

  236. int heightRadio = Math.round(outHeight / realHeight);

  237. inSampleSize = withRadio > heightRadio ? withRadio : heightRadio;

  238. }

  239. Log.e("压缩比率", String.valueOf(inSampleSize));

  240. return inSampleSize;

  241. }

  242. /**

  243. * 获取ImageView实际的宽度

  244. *

  245. * @return 返回ImageView实际的宽度

  246. */

  247. public int realImageViewWith() {

  248. DisplayMetrics displayMetrics = getContext().getResources().getDisplayMetrics();

  249. ViewGroup.LayoutParams layoutParams = getLayoutParams();

  250. //如果ImageView设置了宽度就可以获取实在宽带

  251. int width = getWidth();

  252. if (width <= 0) {

  253. //如果ImageView没有设置宽度,就获取父级容器的宽度

  254. width = layoutParams.width;

  255. }

  256. if (width <= 0) {

  257. //获取ImageView宽度的最大值

  258. width = getMaxWidth();

  259. }

  260. if (width <= 0) {

  261. //获取屏幕的宽度

  262. width = displayMetrics.widthPixels;

  263. }

  264. Log.e("ImageView实际的宽度", String.valueOf(width));

  265. return width;

  266. }

  267. /**

  268. * 获取ImageView实际的高度

  269. *

  270. * @return 返回ImageView实际的高度

  271. */

  272. public int realImageViewHeight() {

  273. DisplayMetrics displayMetrics = getContext().getResources().getDisplayMetrics();

  274. ViewGroup.LayoutParams layoutParams = getLayoutParams();

  275. //如果ImageView设置了高度就可以获取实在宽度

  276. int height = getHeight();

  277. if (height <= 0) {

  278. //如果ImageView没有设置高度,就获取父级容器的高度

  279. height = layoutParams.height;

  280. }

  281. if (height <= 0) {

  282. //获取ImageView高度的最大值

  283. height = getMaxHeight();

  284. }

  285. if (height <= 0) {

  286. //获取ImageView高度的最大值

  287. height = displayMetrics.heightPixels;

  288. }

  289. Log.e("ImageView实际的高度", String.valueOf(height));

  290. return height;

  291. }

  292. }

 使用网络图片的效果图

使用缓存图片的效果图

 

使用图片加载框架Glide

 在这开源非常发达的时代,肯定会有大牛为我们做了个种各样的开源框架,根本不需要我们做这么复杂的工作,下面就简单使用图片加载框架Glide

在使用前要添加Glide的依赖库

compile 'com.github.bumptech.glide:glide:4.0.0'

刚才的条件不变,把点击事件的操作换成下面两行代码

 
  1. String url = "https://pic.cnblogs.com/avatar/1142647/20170416093225.png";

  2. Glide.with(MainActivity.this).load(url).into(myImageView);

是不是非常简单,有了这个开源库,你还愿意写那一大堆的代码吗,我想不会,更强大的是它已经有缓存功能,这一切它都帮你做好了。

加载网络图片的效果图

使用缓存的效果图

既然那么强大的开源库,我们就简单地了解它是如何使用的,先看看with()方法的源码,它可以接收6中参数,所以在各种情况下都能使用

 
  1. public static RequestManager with(Context context) {

  2. return getRetriever(context).get(context);

  3. }

  4. public static RequestManager with(Activity activity) {

  5. return getRetriever(activity).get(activity);

  6. }

  7. public static RequestManager with(FragmentActivity activity) {

  8. return getRetriever(activity).get(activity);

  9. }

  10. public static RequestManager with(android.app.Fragment fragment) {

  11. return getRetriever(fragment.getActivity()).get(fragment);

  12. }

  13. public static RequestManager with(Fragment fragment) {

  14. return getRetriever(fragment.getActivity()).get(fragment);

  15. }

  16. public static RequestManager with(View view) {

  17. return getRetriever(view.getContext()).get(view);

  18. }

然后是load()方法,虽然只有一个方法,但是所能做的事情却不少,比如我刚才只是传了一个String类型的,它就可以帮我加载了网络的图片,它还支持File(加载本地图片)、int(加载应用文件的源)、byte[](字节流)、Uri

 
  1. public RequestBuilder<Drawable> load(@Nullable Object model) {

  2. return asDrawable().load(model);

  3. }

 我们就试试加载应用的图片

Glide.with(MainActivity.this).load(R.mipmap.ic_launcher).into(myImageView);

效果图

最后是into()方法,就是把我们要显示的ImageView加载进去,那就大功告成了。

重复使用过程Glide-->with()-->load()-->into()

项目源代码:doi-tools-center

  • 1
    点赞
  • 5
    收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论 1
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值