如何在Android中从给定的URL下载并保存图像？
如何在Android中下载和保存图像
Answers:
从2015年12月30日开始编辑-图片下载终极指南
最近的主要更新：2016年3月31日
TL; DR也停止说话，只给我密码！！
跳到这篇文章的底部，将
BasicImageDownloader（此处的 Javadoc版本）复制到您的项目中，实现该OnImageLoaderListener接口，您就完成了。注意：尽管可以
BasicImageDownloader处理可能的错误，并且可以防止万一出现任何问题而使您的应用崩溃，但它不会对下载的内容执行任何后处理（例如缩小尺寸）Bitmaps。
由于这篇文章已经引起了很多关注，我决定完全对其进行重新设计，以防止人们使用不赞成使用的技术，不良的编程习惯或做一些愚蠢的事情-例如寻找“ hacks”在主线程上运行网络或接受所有SSL证书。
我创建了一个名为“ Image Downloader”的演示项目，该项目演示了如何使用我自己的下载器实现，Android内置的DownloadManager以及一些流行的开源库来下载（和保存）图像。您可以查看完整的源代码或在GitHub上下载项目。
注意：我尚未调整SDK 23+（棉花糖）的权限管理，因此该项目的目标是SDK 22+（棒棒糖）。
在本文结尾的结论中，我将分享我的拙见提到的每种特定图像下载方式的正确用例。
让我们从一个自己的实现开始（您可以在文章末尾找到代码）。首先，这是Basic ImageDownloader就是这样。它所做的只是连接到给定的url，读取数据并尝试将其解码为Bitmap，并OnImageLoaderListener在适当时触发接口回调。这种方法的优点-简单易行，您可以清楚地了解正在发生的事情。如果您只需要下载/显示并保存一些图像，则无需担心维护内存/磁盘缓存，这是一个不错的选择。
注意：如果图像较大，则可能需要将其缩小。
-
Android DownloadManager是一种让系统为您处理下载的方法。实际上，它能够下载任何类型的文件，而不仅仅是图像。您可以让下载以静默方式进行并且对用户不可见，或者可以使用户在通知区域中看到下载。您也可以注册一个BroadcastReceiver下载完成后，您以获得通知。设置非常简单，有关示例代码，请参见链接的项目。
DownloadManager如果您还想显示图像，通常不建议使用，因为您需要读取和解码保存的文件，而不仅仅是将下载的文件设置Bitmap为ImageView。的DownloadManager你应用中跟踪的下载进度也没有提供任何API。
-
现在介绍伟大的东西-库。他们不仅可以下载和显示图像，还可以做更多的事情，包括：创建和管理内存/磁盘缓存，调整图像大小，转换图像等等。
我将从Volley开始，Volley是Google创建的功能强大的库，并在官方文档中进行了介绍。Volley是一个通用的网络库，不专门处理图像，但它具有用于管理图像的强大API。
您将需要实现一个Singleton类来管理Volley请求，并且一切顺利。
您可能需要ImageView用Volley's 代替NetworkImageView，因此下载基本上变成了一种：
((NetworkImageView) findViewById(R.id.myNIV)).setImageUrl(url, MySingleton.getInstance(this).getImageLoader());如果您需要更多控制权，这就是ImageRequest用Volley 创建的样子：
ImageRequest imgRequest = new ImageRequest(url, new Response.Listener<Bitmap>() {
@Override
public void onResponse(Bitmap response) {
//do stuff
}
}, 0, 0, ImageView.ScaleType.CENTER_CROP, Bitmap.Config.ARGB_8888,
new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
//do stuff
}
});值得一提的是，Volley通过提供VolleyError可帮助您确定错误的确切原因的类，具有出色的错误处理机制。如果您的应用程序需要进行大量的网络连接并且管理图像不是主要目的，那么Volley就是您的理想选择。
-
Square的毕加索（Picasso）是一个著名的图书馆，它将为您完成所有图像加载工作。使用毕加索仅显示图像就很简单：
Picasso.with(myContext)
.load(url)
.into(myImageView); 默认情况下，毕加索会管理磁盘/内存缓存，因此您无需担心。要获得更多控制权，您可以实施Target接口并将其用于将图像加载到其中-这将提供类似于Volley示例的回调。查看演示项目中的示例。
Picasso还允许您将转换应用于下载的图像，并且周围甚至还有其他库可以扩展这些API。也工作得非常好于RecyclerView/ ListView/ GridView。
-
Universal Image Loader是另一个非常流行的库，用于图像管理。它使用自己的ImageLoader（一旦初始化）就拥有一个全局实例，该实例可用于以单行代码下载图像：
ImageLoader.getInstance().displayImage(url, myImageView);如果要跟踪下载进度或访问下载的内容Bitmap：
ImageLoader.getInstance().displayImage(url, myImageView, opts,
new ImageLoadingListener() {
@Override
public void onLoadingStarted(String imageUri, View view) {
//do stuff
}
@Override
public void onLoadingFailed(String imageUri, View view, FailReason failReason) {
//do stuff
}
@Override
public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {
//do stuff
}
@Override
public void onLoadingCancelled(String imageUri, View view) {
//do stuff
}
}, new ImageLoadingProgressListener() {
@Override
public void onProgressUpdate(String imageUri, View view, int current, int total) {
//do stuff
}
});opts此示例中的参数是一个DisplayImageOptions对象。请参阅演示项目以了解更多信息。
与Volley类似，UIL提供了FailReason使您能够检查下载失败时出了什么问题的类。默认情况下，如果您未明确指示UIL维护内存/磁盘高速缓存，请注意。
注意：作者已经提到，自2015年11月27日起，他将不再维护该项目。但是，由于有许多贡献者，我们希望Universal Image Loader能够继续存在。
-
Facebook的Fresco是最新的（IMO）最先进的库，它将图像管理提升到了一个新的水平：从避免BitmapsJava堆（在Lollipop之前）到支持动画格式和渐进式JPEG流。
要了解有关Fresco背后的思想和技术的更多信息，请参阅此文章。
基本用法很简单。请注意，您Fresco.initialize(Context);只需要调用 一次，这在Application该类中比较可取。多次初始化Fresco可能会导致无法预料的行为和OOM错误。
Fresco使用Drawees显示图像，您可以将它们视为ImageViews：
<com.facebook.drawee.view.SimpleDraweeView
android:id="@+id/drawee"
android:layout_width="match_parent"
android:layout_height="match_parent"
fresco:fadeDuration="500"
fresco:actualImageScaleType="centerCrop"
fresco:placeholderImage="@drawable/placeholder_grey"
fresco:failureImage="@drawable/error_orange"
fresco:placeholderImageScaleType="fitCenter"
fresco:failureImageScaleType="centerInside"
fresco:retryImageScaleType="centerCrop"
fresco:progressBarImageScaleType="centerInside"
fresco:progressBarAutoRotateInterval="1000"
fresco:roundAsCircle="false" />如您所见，已经在XML中定义了很多东西（包括转换选项），因此，显示图像所需要做的就是一线处理：
mDrawee.setImageURI(Uri.parse(url));Fresco提供了扩展的自定义API，在某些情况下，该API可能非常复杂，并且要求用户仔细阅读文档（是的，有时需要 RTFM）。
我已经将渐进JPEG和动画图像的示例包含到示例项目中。
结论-“我已经学到了很多很棒的东西，现在应该使用什么？”
请注意，以下文字反映了我的个人观点，不应作为假设。
- 如果您只需要下载/保存/显示一些图像，不要计划在其中使用它们，
Recycler-/Grid-/ListView也不需要一堆图像即可显示，那么BasicImageDownloader应该可以满足您的需求。 - 如果您的应用由于用户或自动操作而保存了图片（或其他文件），并且您不需要经常显示图片，请使用Android DownloadManager。
- 万一您的应用程序进行了大量的网络连接，传输/接收
JSON数据，处理图像，但这些不是该应用程序的主要目的，请使用Volley。 - 您的应用是以图像/媒体为重点的，您想对图像进行一些转换，并且不想打扰复杂的API：使用Picasso（注意：不提供任何API来跟踪中间下载状态）或Universal Image装载机
- 如果您的应用只涉及图像，则需要高级功能（如显示动画格式），并且准备阅读文档，请使用Fresco。
以防万一您错过了演示项目的Github链接。
这是 BasicImageDownloader.java
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.support.annotation.NonNull;
import android.util.Log;
import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashSet;
import java.util.Set;
public class BasicImageDownloader {
private OnImageLoaderListener mImageLoaderListener;
private Set<String> mUrlsInProgress = new HashSet<>();
private final String TAG = this.getClass().getSimpleName();
public BasicImageDownloader(@NonNull OnImageLoaderListener listener) {
this.mImageLoaderListener = listener;
}
public interface OnImageLoaderListener {
void onError(ImageError error);
void onProgressChange(int percent);
void onComplete(Bitmap result);
}
public void download(@NonNull final String imageUrl, final boolean displayProgress) {
if (mUrlsInProgress.contains(imageUrl)) {
Log.w(TAG, "a download for this url is already running, " +
"no further download will be started");
return;
}
new AsyncTask<Void, Integer, Bitmap>() {
private ImageError error;
@Override
protected void onPreExecute() {
mUrlsInProgress.add(imageUrl);
Log.d(TAG, "starting download");
}
@Override
protected void onCancelled() {
mUrlsInProgress.remove(imageUrl);
mImageLoaderListener.onError(error);
}
@Override
protected void onProgressUpdate(Integer... values) {
mImageLoaderListener.onProgressChange(values[0]);
}
@Override
protected Bitmap doInBackground(Void... params) {
Bitmap bitmap = null;
HttpURLConnection connection = null;
InputStream is = null;
ByteArrayOutputStream out = null;
try {
connection = (HttpURLConnection) new URL(imageUrl).openConnection();
if (displayProgress) {
connection.connect();
final int length = connection.getContentLength();
if (length <= 0) {
error = new ImageError("Invalid content length. The URL is probably not pointing to a file")
.setErrorCode(ImageError.ERROR_INVALID_FILE);
this.cancel(true);
}
is = new BufferedInputStream(connection.getInputStream(), 8192);
out = new ByteArrayOutputStream();
byte bytes[] = new byte[8192];
int count;
long read = 0;
while ((count = is.read(bytes)) != -1) {
read += count;
out.write(bytes, 0, count);
publishProgress((int) ((read * 100) / length));
}
bitmap = BitmapFactory.decodeByteArray(out.toByteArray(), 0, out.size());
} else {
is = connection.getInputStream();
bitmap = BitmapFactory.decodeStream(is);
}
} catch (Throwable e) {
if (!this.isCancelled()) {
error = new ImageError(e).setErrorCode(ImageError.ERROR_GENERAL_EXCEPTION);
this.cancel(true);
}
} finally {
try {
if (connection != null)
connection.disconnect();
if (out != null) {
out.flush();
out.close();
}
if (is != null)
is.close();
} catch (Exception e) {
e.printStackTrace();
}
}
return bitmap;
}
@Override
protected void onPostExecute(Bitmap result) {
if (result == null) {
Log.e(TAG, "factory returned a null result");
mImageLoaderListener.onError(new ImageError("downloaded file could not be decoded as bitmap")
.setErrorCode(ImageError.ERROR_DECODE_FAILED));
} else {
Log.d(TAG, "download complete, " + result.getByteCount() +
" bytes transferred");
mImageLoaderListener.onComplete(result);
}
mUrlsInProgress.remove(imageUrl);
System.gc();
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
public interface OnBitmapSaveListener {
void onBitmapSaved();
void onBitmapSaveError(ImageError error);
}
public static void writeToDisk(@NonNull final File imageFile, @NonNull final Bitmap image,
@NonNull final OnBitmapSaveListener listener,
@NonNull final Bitmap.CompressFormat format, boolean shouldOverwrite) {
if (imageFile.isDirectory()) {
listener.onBitmapSaveError(new ImageError("the specified path points to a directory, " +
"should be a file").setErrorCode(ImageError.ERROR_IS_DIRECTORY));
return;
}
if (imageFile.exists()) {
if (!shouldOverwrite) {
listener.onBitmapSaveError(new ImageError("file already exists, " +
"write operation cancelled").setErrorCode(ImageError.ERROR_FILE_EXISTS));
return;
} else if (!imageFile.delete()) {
listener.onBitmapSaveError(new ImageError("could not delete existing file, " +
"most likely the write permission was denied")
.setErrorCode(ImageError.ERROR_PERMISSION_DENIED));
return;
}
}
File parent = imageFile.getParentFile();
if (!parent.exists() && !parent.mkdirs()) {
listener.onBitmapSaveError(new ImageError("could not create parent directory")
.setErrorCode(ImageError.ERROR_PERMISSION_DENIED));
return;
}
try {
if (!imageFile.createNewFile()) {
listener.onBitmapSaveError(new ImageError("could not create file")
.setErrorCode(ImageError.ERROR_PERMISSION_DENIED));
return;
}
} catch (IOException e) {
listener.onBitmapSaveError(new ImageError(e).setErrorCode(ImageError.ERROR_GENERAL_EXCEPTION));
return;
}
new AsyncTask<Void, Void, Void>() {
private ImageError error;
@Override
protected Void doInBackground(Void... params) {
FileOutputStream fos = null;
try {
fos = new FileOutputStream(imageFile);
image.compress(format, 100, fos);
} catch (IOException e) {
error = new ImageError(e).setErrorCode(ImageError.ERROR_GENERAL_EXCEPTION);
this.cancel(true);
} finally {
if (fos != null) {
try {
fos.flush();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
@Override
protected void onCancelled() {
listener.onBitmapSaveError(error);
}
@Override
protected void onPostExecute(Void result) {
listener.onBitmapSaved();
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
public static Bitmap readFromDisk(@NonNull File imageFile) {
if (!imageFile.exists() || imageFile.isDirectory()) return null;
return BitmapFactory.decodeFile(imageFile.getAbsolutePath());
}
public interface OnImageReadListener {
void onImageRead(Bitmap bitmap);
void onReadFailed();
}
public static void readFromDiskAsync(@NonNull File imageFile, @NonNull final OnImageReadListener listener) {
new AsyncTask<String, Void, Bitmap>() {
@Override
protected Bitmap doInBackground(String... params) {
return BitmapFactory.decodeFile(params[0]);
}
@Override
protected void onPostExecute(Bitmap bitmap) {
if (bitmap != null)
listener.onImageRead(bitmap);
else
listener.onReadFailed();
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, imageFile.getAbsolutePath());
}
public static final class ImageError extends Throwable {
private int errorCode;
public static final int ERROR_GENERAL_EXCEPTION = -1;
public static final int ERROR_INVALID_FILE = 0;
public static final int ERROR_DECODE_FAILED = 1;
public static final int ERROR_FILE_EXISTS = 2;
public static final int ERROR_PERMISSION_DENIED = 3;
public static final int ERROR_IS_DIRECTORY = 4;
public ImageError(@NonNull String message) {
super(message);
}
public ImageError(@NonNull Throwable error) {
super(error.getMessage(), error.getCause());
this.setStackTrace(error.getStackTrace());
}
public ImageError setErrorCode(int code) {
this.errorCode = code;
return this;
}
public int getErrorCode() {
return errorCode;
}
}
}
将图片作为byte []的onPictureTaken（）回调怎么办？可以直接从相机获取该图片的URL吗？还是基本的旧outputStream（）是Android中不使用内置意图保存相机拍摄的照片的唯一方法？这似乎很奇怪，因为在onPictureTaken之后自然要做的事情就是保存它。这样做是否没有特别的支持？
—
Tombola 2013年
@Tombola嗨！这篇文章是关于从网上下载图片的。但是要回答您的问题（据我所知）：保存摄像机图像的常用方法是从中获取
—
Droidman
Cursor（在onActivityResult()方法中）其路径，然后Bitmap使用该路径创建路径。是的，如果要将图像保存到SD ，您将无法避免使用a FileOutputStream和a ByteArrayOutputStream。
@BartBurg这个问题是关于下载和保存图像的。但是您在某些时候是正确的，因为有一个write方法，为了完整性起见也应该有一个read方法。我将在下次更新中将其添加到此帖子中。
—
Droidman '16
您能否提供使用此BasicImageDownloader的示例？
—
Jaydev '16
我刚从解决这个问题开始，我想分享完整的代码，这些代码可以下载，保存到sdcard（并隐藏文件名）并检索图像，最后检查图像是否已经存在。网址来自数据库，因此可以使用id轻松地唯一地使用文件名。
首先下载图片
private class GetImages extends AsyncTask<Object, Object, Object> {
private String requestUrl, imagename_;
private ImageView view;
private Bitmap bitmap ;
private FileOutputStream fos;
private GetImages(String requestUrl, ImageView view, String _imagename_) {
this.requestUrl = requestUrl;
this.view = view;
this.imagename_ = _imagename_ ;
}
@Override
protected Object doInBackground(Object... objects) {
try {
URL url = new URL(requestUrl);
URLConnection conn = url.openConnection();
bitmap = BitmapFactory.decodeStream(conn.getInputStream());
} catch (Exception ex) {
}
return null;
}
@Override
protected void onPostExecute(Object o) {
if(!ImageStorage.checkifImageExists(imagename_))
{
view.setImageBitmap(bitmap);
ImageStorage.saveToSdCard(bitmap, imagename_);
}
}
}然后创建一个用于保存和检索文件的类
public class ImageStorage {
public static String saveToSdCard(Bitmap bitmap, String filename) {
String stored = null;
File sdcard = Environment.getExternalStorageDirectory() ;
File folder = new File(sdcard.getAbsoluteFile(), ".your_specific_directory");//the dot makes this directory hidden to the user
folder.mkdir();
File file = new File(folder.getAbsoluteFile(), filename + ".jpg") ;
if (file.exists())
return stored ;
try {
FileOutputStream out = new FileOutputStream(file);
bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);
out.flush();
out.close();
stored = "success";
} catch (Exception e) {
e.printStackTrace();
}
return stored;
}
public static File getImage(String imagename) {
File mediaImage = null;
try {
String root = Environment.getExternalStorageDirectory().toString();
File myDir = new File(root);
if (!myDir.exists())
return null;
mediaImage = new File(myDir.getPath() + "/.your_specific_directory/"+imagename);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return mediaImage;
}
public static boolean checkifImageExists(String imagename)
{
Bitmap b = null ;
File file = ImageStorage.getImage("/"+imagename+".jpg");
String path = file.getAbsolutePath();
if (path != null)
b = BitmapFactory.decodeFile(path);
if(b == null || b.equals(""))
{
return false ;
}
return true ;
}
}然后要访问图像，请首先检查它是否已经存在，然后下载
if(ImageStorage.checkifImageExists(imagename))
{
File file = ImageStorage.getImage("/"+imagename+".jpg");
String path = file.getAbsolutePath();
if (path != null){
b = BitmapFactory.decodeFile(path);
imageView.setImageBitmap(b);
}
} else {
new GetImages(imgurl, imageView, imagename).execute() ;
}
注意：虽然此示例通常可以工作，但是它不提供任何错误处理，并且对
—
Droidman '16
AsyncTask优点（正确使用参数化，并行执行..）缺乏一些基本的了解。请参阅以下我的示例以获取详细信息。 PS。对于那些可能出于某种原因认为我写这本书来提升自己的代码的人：不，我只是指出在给定示例中可以看到的问题。
是的，Droidman，我同意你的观点。这段代码应视为模板，一个人必须自己完成，包括错误处理。顺便说一下，您的代码也缺少错误处理。如果发生IOException，您的连接和流将发生什么？
—
Androider 2016年
@Androider请仔细查看我的
—
Droidman
download方法，特别doInBackground是我使用的任务的方法。一个IOException将落在该catch (Throwable e)块中，导致ImageError返回并onError()触发回调。该ImageError对象将包含原始堆栈跟踪以及发生的原因Exception
是的，但是您的连接不会断开并且您的信息流也不会关闭
—
Androider
@Androider啊，我明白你的意思了。尽管我从未在测试设备上发现任何可疑的泄漏，但是在其他设备上这种行为可能有所不同。感谢您的提示-我已更新代码
—
Droidman '16
为什么您真的需要自己的代码才能下载它？仅将您的URI传递给下载管理器怎么样？
public void downloadFile(String uRl) {
File direct = new File(Environment.getExternalStorageDirectory()
+ "/AnhsirkDasarp");
if (!direct.exists()) {
direct.mkdirs();
}
DownloadManager mgr = (DownloadManager) getActivity().getSystemService(Context.DOWNLOAD_SERVICE);
Uri downloadUri = Uri.parse(uRl);
DownloadManager.Request request = new DownloadManager.Request(
downloadUri);
request.setAllowedNetworkTypes(
DownloadManager.Request.NETWORK_WIFI
| DownloadManager.Request.NETWORK_MOBILE)
.setAllowedOverRoaming(false).setTitle("Demo")
.setDescription("Something useful. No, really.")
.setDestinationInExternalPublicDir("/AnhsirkDasarp", "fileName.jpg");
mgr.enqueue(request);
}
api> 8的完美示例。
—
Jeeten Parmar 2014年
您的代码非常适合一张图片！如果我想从服务器中的图像文件中下载更多图片（100张图片），该怎么办？
—
Kostantinos Ibra 2016年
我收到一条消息说文件已损坏！
—
Anup
也许是.setDestinationInExternalPublicDir（“ / AnhsirkDasarp”，“ fileName.jpg”）;
—
专家希望成为
我们如何知道它是成功下载还是失败
—
Prabs
它可能会帮助你..
Button download_image = (Button)bigimagedialog.findViewById(R.id.btn_downloadimage);
download_image.setOnClickListener(new View.OnClickListener()
{
public void onClick(View v)
{
boolean success = (new File("/sdcard/dirname")).mkdir();
if (!success)
{
Log.w("directory not created", "directory not created");
}
try
{
URL url = new URL("YOUR_URL");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
connection.setDoInput(true);
connection.connect();
InputStream input = connection.getInputStream();
Bitmap myBitmap = BitmapFactory.decodeStream(input);
String data1 = String.valueOf(String.format("/sdcard/dirname/%d.jpg",System.currentTimeMillis()));
FileOutputStream stream = new FileOutputStream(data1);
ByteArrayOutputStream outstream = new ByteArrayOutputStream();
myBitmap.compress(Bitmap.CompressFormat.JPEG, 85, outstream);
byte[] byteArray = outstream.toByteArray();
stream.write(byteArray);
stream.close();
Toast.makeText(getApplicationContext(), "Downloading Completed", Toast.LENGTH_SHORT).show();
}
catch (Exception e)
{
e.printStackTrace();
}
}
});我有一个简单的解决方案，可以正常工作。该代码不是我的，我在此链接上找到了。以下是要遵循的步骤：
1.在下载图像之前，让我们编写一种将位图保存到android内部存储器中的图像文件中的方法。它需要一个上下文，最好是通过getApplicationContext（）在应用程序上下文中使用传递。该方法可以转储到Activity类或其他util类中。
public void saveImage(Context context, Bitmap b, String imageName)
{
FileOutputStream foStream;
try
{
foStream = context.openFileOutput(imageName, Context.MODE_PRIVATE);
b.compress(Bitmap.CompressFormat.PNG, 100, foStream);
foStream.close();
}
catch (Exception e)
{
Log.d("saveImage", "Exception 2, Something went wrong!");
e.printStackTrace();
}
}2.现在，我们有了一种将位图保存到andorid中的图像文件中的方法，让我们编写AsyncTask来通过url下载图像。该私有类需要作为子类放置在Activity类中。下载图像后，在onPostExecute方法中，它将调用上面定义的saveImage方法来保存图像。注意，图像名称被硬编码为“ my_image.png”。
private class DownloadImage extends AsyncTask<String, Void, Bitmap> {
private String TAG = "DownloadImage";
private Bitmap downloadImageBitmap(String sUrl) {
Bitmap bitmap = null;
try {
InputStream inputStream = new URL(sUrl).openStream(); // Download Image from URL
bitmap = BitmapFactory.decodeStream(inputStream); // Decode Bitmap
inputStream.close();
} catch (Exception e) {
Log.d(TAG, "Exception 1, Something went wrong!");
e.printStackTrace();
}
return bitmap;
}
@Override
protected Bitmap doInBackground(String... params) {
return downloadImageBitmap(params[0]);
}
protected void onPostExecute(Bitmap result) {
saveImage(getApplicationContext(), result, "my_image.png");
}
}3.定义了用于下载映像的AsyncTask，但是我们需要执行它才能运行该AsyncTask。为此，请在Activity类的onCreate方法中或您认为合适的按钮或其他位置的onClick方法中编写此行。
new DownloadImage().execute("http://developer.android.com/images/activity_lifecycle.png");该图像应保存在/data/data/your.app.packagename/files/my_image.jpeg中，请查看此帖子以从您的设备访问此目录。
IMO可以解决问题！如果您需要进一步的步骤，例如加载图像，则可以执行以下额外步骤：
4.下载图像后，我们需要一种从内部存储器加载图像位图的方法，以便可以使用它。让我们写一个加载图像位图的方法。此方法需要两个参数，一个上下文和一个图像文件名，没有完整路径，context.openFileInput（imageName）将在上述saveImage方法中保存该文件名时在保存目录中查找该文件。
public Bitmap loadImageBitmap(Context context, String imageName) {
Bitmap bitmap = null;
FileInputStream fiStream;
try {
fiStream = context.openFileInput(imageName);
bitmap = BitmapFactory.decodeStream(fiStream);
fiStream.close();
} catch (Exception e) {
Log.d("saveImage", "Exception 3, Something went wrong!");
e.printStackTrace();
}
return bitmap;
}5.现在，我们拥有设置ImageView或您要在其上使用该图像的任何其他View的图像所需的一切。保存图像时，我们将图像名称硬编码为“ my_image.jpeg”，现在可以将此图像名称传递给上述loadImageBitmap方法以获取位图并将其设置为ImageView。
someImageView.setImageBitmap(loadImageBitmap(getApplicationContext(), "my_image.jpeg"));6.通过图像名称获取图像的完整路径。
File file = getApplicationContext().getFileStreamPath("my_image.jpeg");
String imageFullPath = file.getAbsolutePath();7.检查图像文件是否存在。
文件文件=
getApplicationContext().getFileStreamPath("my_image.jpeg");
if (file.exists()) Log.d("file", "my_image.jpeg exists!");删除图像文件。
文件file = getApplicationContext（）。getFileStreamPath（“ my_image.jpeg”）; 如果（file.delete（））Log.d（“文件”，“ my_image.jpeg已删除！”）;
此代码在我的项目中完美运行
downloadImagesToSdCard(imagepath,imagepath);
private void downloadImagesToSdCard(String downloadUrl,String imageName)
{
try
{
URL url = new URL("www.xxx.com"+downloadUrl);
/* making a directory in sdcard */
// String sdCard=Environment.getExternalStorageDirectory().toString();
ContextWrapper cw = new ContextWrapper(getActivity());
// path to /data/data/yourapp/app_data/imageDir
File directory = cw.getDir("files", Context.MODE_PRIVATE);
File myDir = new File(directory,"folder");
/* if specified not exist create new */
if(!myDir.exists())
{
myDir.mkdir();
Log.v("", "inside mkdir");
}
/* checks the file and if it already exist delete */
String fname = imageName;
File file = new File (myDir, fname);
Log.d("file===========path", ""+file);
if (file.exists ())
file.delete ();
/* Open a connection */
URLConnection ucon = url.openConnection();
InputStream inputStream = null;
HttpURLConnection httpConn = (HttpURLConnection)ucon;
httpConn.setRequestMethod("GET");
httpConn.connect();
inputStream = httpConn.getInputStream();
/*if (httpConn.getResponseCode() == HttpURLConnection.HTTP_OK)
{
inputStream = httpConn.getInputStream();
}*/
FileOutputStream fos = new FileOutputStream(file);
int totalSize = httpConn.getContentLength();
int downloadedSize = 0;
byte[] buffer = new byte[1024];
int bufferLength = 0;
while ( (bufferLength = inputStream.read(buffer)) >0 )
{
fos.write(buffer, 0, bufferLength);
downloadedSize += bufferLength;
Log.i("Progress:","downloadedSize:"+downloadedSize+"totalSize:"+ totalSize) ;
}
fos.close();
Log.d("test", "Image Saved in sdcard..");
viewimage();
}
catch(IOException io)
{
io.printStackTrace();
}
catch(Exception e)
{
e.printStackTrace();
}
}
public void viewimage()
{
String path = serialnumber+".png";
ContextWrapper cw = new ContextWrapper(getActivity());
//path to /data/data/yourapp/app_data/dirName
File directory = cw.getDir("files", Context.MODE_PRIVATE);
File mypath=new File(directory,"folder/"+path);
Bitmap b;
try {
b = BitmapFactory.decodeStream(new FileInputStream(mypath));
// b.compress(format, quality, stream)
profile_image.setImageBitmap(Bitmap.createScaledBitmap(b, 120, 120, false));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
嗨，谢谢你的贡献。请注意，上述将图片保存到应用程序的私有存储中的方法有2个缺点：1）图片仅对您的应用程序可用； 2）您应避免将图像保存到应用程序的私有存储中，因为它不适合大容量内容。
—
Droidman 2015年
试试这个
try
{
Bitmap bmp = null;
URL url = new URL("Your_URL");
URLConnection conn = url.openConnection();
bmp = BitmapFactory.decodeStream(conn.getInputStream());
File f = new File(Environment.getExternalStorageDirectory(),System.currentTimeMillis() + ".jpg");
if(f.exists())
f.delete();
f.createNewFile();
Bitmap bitmap = bmp;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.PNG, 0 /*ignored for PNG*/, bos);
byte[] bitmapdata = bos.toByteArray();
FileOutputStream fos = new FileOutputStream(f);
fos.write(bitmapdata);
fos.flush();
fos.close();
Log.e(TAG, "imagepath: "+f );
}
catch (Exception e)
{
e.printStackTrace();
}public class testCrop extends AppCompatActivity {
ImageView iv;
String imagePath = "https://style.pk/wp-content/uploads/2015/07/omer-Shahzad-performed-umrah-600x548.jpg";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.testcrpop);
iv = (ImageView) findViewById(R.id.testCrop);
imageDownload image = new imageDownload(testCrop.this, iv);
image.execute(imagePath);
}
class imageDownload extends AsyncTask<String, Integer, Bitmap> {
Context context;
ImageView imageView;
Bitmap bitmap;
InputStream in = null;
int responseCode = -1;
//constructor.
public imageDownload(Context context, ImageView imageView) {
this.context = context;
this.imageView = imageView;
}
@Override
protected void onPreExecute() {
}
@Override
protected Bitmap doInBackground(String... params) {
try {
URL url = new URL(params[0]);
HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
httpURLConnection.setDoOutput(true);
httpURLConnection.connect();
responseCode = httpURLConnection.getResponseCode();
if (responseCode == HttpURLConnection.HTTP_OK) {
in = httpURLConnection.getInputStream();
bitmap = BitmapFactory.decodeStream(in);
in.close();
}
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return bitmap;
}
@Override
protected void onPostExecute(Bitmap data) {
imageView.setImageBitmap(data);
saveImage(data);
}
private void saveImage(Bitmap data) {
File createFolder = new File(Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES),"test");
createFolder.mkdir();
File saveImage = new File(createFolder,"downloadimage.jpg");
try {
OutputStream outputStream = new FileOutputStream(saveImage);
data.compress(Bitmap.CompressFormat.JPEG,100,outputStream);
outputStream.flush();
outputStream.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}输出值
确保您添加了将数据写入内存的权限
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>正如Google所言，暂时不要忘记在清单的外部存储中添加可读性：
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />来源：http : //developer.android.com/training/basics/data-storage/files.html#GetWritePermission