Jak pobrać i zapisać obraz z podanego adresu w Androidzie?

Edytuj od 30.12.2015 - Kompletny przewodnik po pobieraniu obrazów

Ostatnia ważna aktualizacja: 31 marca 2016 r

TL; DR aka przestań mówić, po prostu daj mi kod !!

Przejdź do końca tego postu, skopiuj BasicImageDownloader(wersję javadoc tutaj ) do swojego projektu, zaimplementuj OnImageLoaderListenerinterfejs i gotowe.

Uwaga : chociaż BasicImageDownloaderobsługuje możliwe błędy i zapobiega awariom aplikacji w przypadku, gdy coś pójdzie nie tak, nie wykona ona żadnego przetwarzania końcowego (np. Zmniejszenia rozmiaru) pobranego pliku Bitmaps.

Ponieważ ten post spotkał się z dużym zainteresowaniem, zdecydowałem się całkowicie go przerobić, aby ludzie nie używali przestarzałych technologii, złych praktyk programowania lub po prostu robienia głupich rzeczy - takich jak szukanie „hacków” do uruchomienia sieci w głównym wątku lub akceptuj wszystkie certyfikaty SSL.

Stworzyłem projekt demonstracyjny o nazwie „Image Downloader”, który pokazuje, jak pobrać (i zapisać) obraz przy użyciu mojej własnej implementacji programu do pobierania, wbudowanego systemu Android, DownloadManagera także niektórych popularnych bibliotek open source. Możesz wyświetlić pełny kod źródłowy lub pobrać projekt na GitHub .

Uwaga : nie dostosowałem jeszcze zarządzania uprawnieniami dla SDK 23+ (Marshmallow), dlatego projekt jest ukierunkowany na SDK 22 (Lollipop).

W podsumowaniu na końcu tego posta podzielę się moją skromną opinią na temat właściwego przypadku użycia dla każdego określonego sposobu pobierania obrazu, o którym wspomniałem.

Zacznijmy od własnej implementacji (kod znajdziesz na końcu postu). Przede wszystkim jest to Basic ImageDownloader i to wszystko. Wszystko, co robi, to łączy się z podanym adresem URL, odczytuje dane i próbuje je zdekodować jako a Bitmap, wywołując w razie potrzeby OnImageLoaderListenerwywołania zwrotne interfejsu. Zaleta tego podejścia - jest proste i masz jasny przegląd tego, co się dzieje. Dobry sposób, jeśli wszystko, czego potrzebujesz, to pobieranie / wyświetlanie i zapisywanie niektórych obrazów, podczas gdy nie zależy Ci na utrzymywaniu pamięci podręcznej / pamięci podręcznej dysku.

Uwaga: w przypadku dużych obrazów może być konieczne ich zmniejszenie .

-

Android DownloadManager to sposób, aby system zajął się pobieraniem za Ciebie. W rzeczywistości jest w stanie pobierać wszelkiego rodzaju pliki, nie tylko obrazy. Możesz pozwolić, aby pobieranie odbywało się cicho i niewidoczne dla użytkownika, lub możesz umożliwić użytkownikowi wyświetlanie pobierania w obszarze powiadomień. Możesz także zarejestrować, BroadcastReceiveraby otrzymywać powiadomienia po zakończeniu pobierania. Konfiguracja jest dość prosta, zapoznaj się z połączonym projektem, aby uzyskać przykładowy kod.

Korzystanie z DownloadManagerpliku nie jest ogólnie dobrym pomysłem, jeśli chcesz również wyświetlić obraz, ponieważ musiałbyś odczytać i zdekodować zapisany plik zamiast po prostu ustawić pobrany plik Bitmapna plik ImageView. DownloadManagerRównież nie zawiera żadnych API dla ciebie app śledzić postęp pobierania.

-

Teraz wprowadzenie wspaniałego materiału - bibliotek. Mogą zrobić znacznie więcej niż tylko pobieranie i wyświetlanie obrazów, w tym: tworzenie i zarządzanie pamięcią podręczną / dyskową pamięcią podręczną, zmianę rozmiaru obrazów, przekształcanie ich i nie tylko.

Zacznę od Volley , potężnej biblioteki stworzonej przez Google i objętej oficjalną dokumentacją. Będąc biblioteką sieciową ogólnego przeznaczenia, która nie specjalizuje się w obrazach, Volley oferuje dość potężne API do zarządzania obrazami.

Będziesz musiał zaimplementować klasę Singleton do zarządzania żądaniami Volley i gotowe.

Możesz zamienić swój plik na ImageViewVolley NetworkImageView, więc pobieranie w zasadzie staje się jednowierszowe:

((NetworkImageView) findViewById(R.id.myNIV)).setImageUrl(url, MySingleton.getInstance(this).getImageLoader());

Jeśli potrzebujesz większej kontroli, tak wygląda tworzenie za ImageRequestpomocą 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
                }
            });

Warto wspomnieć, że Volley posiada doskonały mechanizm obsługi błędów, zapewniając VolleyErrorklasę, która pomaga określić dokładną przyczynę błędu. Jeśli Twoja aplikacja dużo pracuje w sieci, a zarządzanie obrazami nie jest jej głównym celem, to Volley to idealne rozwiązanie dla Ciebie.

-

Square's Picasso to dobrze znana biblioteka, która zajmie się ładowaniem wszystkich obrazów. Samo wyświetlenie obrazu za pomocą Picassa jest tak proste, jak:

 Picasso.with(myContext)
       .load(url)
       .into(myImageView); 

Domyślnie Picasso zarządza pamięcią podręczną dysku / pamięci, więc nie musisz się tym martwić. Aby uzyskać większą kontrolę, możesz zaimplementować Targetinterfejs i użyć go do załadowania obrazu - zapewni to wywołania zwrotne podobne do przykładu Volley. Sprawdź przykładowy projekt.

Picasso pozwala również zastosować transformacje do pobranego obrazu, a istnieją nawet inne biblioteki, które rozszerzają ten interfejs API. Działa również bardzo dobrze w RecyclerView/ ListView/ GridView.

-

Universal Image Loader to kolejna bardzo popularna biblioteka służąca do zarządzania obrazami. Używa swojej własnej, ImageLoaderktóra (po zainicjowaniu) ma globalną instancję, której można użyć do pobrania obrazów w jednej linii kodu:

  ImageLoader.getInstance().displayImage(url, myImageView);

Jeśli chcesz śledzić postęp pobierania lub uzyskać dostęp do pobranych 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
                }
            });

optsArgumentem w tym przykładzie jestDisplayImageOptions obiekt. Zapoznaj się z projektem demonstracyjnym, aby dowiedzieć się więcej.

Podobnie jak Volley, UIL zapewnia FailReason klasę, która umożliwia sprawdzenie, co poszło nie tak w przypadku niepowodzenia pobierania. Domyślnie UIL utrzymuje pamięć / podręczną pamięć dyskową, jeśli wyraźnie nie powiesz mu, aby tego nie robił.

Uwaga : autor wspomniał, że od 27 listopada 2015 r. Nie zajmuje się już projektem. Ale ponieważ jest wielu współpracowników, możemy mieć nadzieję, że Universal Image Loader będzie nadal działać.

-

Facebook Fresco to najnowsza i (IMO) najbardziej zaawansowana biblioteka, która przenosi zarządzanie obrazami na nowy poziom: od trzymania Bitmapssię stosu java (przed Lollipopem) do obsługi animowanych formatów i progresywnego przesyłania strumieniowego JPEG .

Aby dowiedzieć się więcej o pomysłach i technikach stojących za Fresco, przeczytaj ten post .

Podstawowe użycie jest dość proste. Pamiętaj, że wystarczy zadzwonić Fresco.initialize(Context);tylko raz, najlepiej wApplication zajęciach. Inicjowanie Fresco więcej niż raz może prowadzić do nieprzewidywalnego zachowania i błędów OOM.

Fresco używa Drawees do wyświetlania obrazów, możesz o nich myśleć jako o 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" />

Jak widać, wiele rzeczy (w tym opcje transformacji) jest już zdefiniowanych w XML, więc wszystko, co musisz zrobić, aby wyświetlić obraz, to jednolinijkowy:

 mDrawee.setImageURI(Uri.parse(url));

Fresco zapewnia rozszerzone API do dostosowywania, które w pewnych okolicznościach może być dość skomplikowane i wymaga od użytkownika uważnego przeczytania dokumentacji (tak, czasami potrzebujesz RTFM).

Do przykładowego projektu dołączyłem przykłady progresywnych plików JPEG i animowanych obrazów.

Wniosek - „Dowiedziałem się o wspaniałych rzeczach, czego powinienem teraz użyć?”

Zwróć uwagę, że poniższy tekst odzwierciedla moją osobistą opinię i nie powinien być traktowany jako postulat.

• Jeśli potrzebujesz tylko pobrać / zapisać / wyświetlić niektóre obrazy, nie planuj ich używać w a Recycler-/Grid-/ListViewi nie potrzebujesz całej grupy obrazów, aby były gotowe do wyświetlenia, BasicImageDownloader powinien odpowiadać Twoim potrzebom.
• Jeśli Twoja aplikacja zapisuje obrazy (lub inne pliki) w wyniku działania użytkownika lub zautomatyzowanej akcji i nie chcesz, aby obrazy były często wyświetlane, użyj narzędzia Android DownloadManager .
• Jeśli Twoja aplikacja dużo korzysta z sieci, przesyła / odbiera JSONdane, współpracuje z obrazami, ale to nie jest głównym celem aplikacji, przejdź do Volley .
• Twoja aplikacja jest skoncentrowana na obrazach / mediach, chcesz zastosować pewne przekształcenia do obrazów i nie chcesz zawracać sobie głowy złożonym interfejsem API: użyj Picassa (Uwaga: nie zapewnia żadnego interfejsu API do śledzenia pośredniego stanu pobierania) lub Universal Image Ładowarka
• Jeśli Twoja aplikacja dotyczy wyłącznie obrazów, potrzebujesz zaawansowanych funkcji, takich jak wyświetlanie animowanych formatów, i jesteś gotowy do czytania dokumentów, przejdź do Fresco .

Jeśli to przegapiłeś, link Github do projektu demonstracyjnego.

A oto plik 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;
        }
      }
   }

Właśnie przyszedłem z rozwiązania tego problemu i chciałbym udostępnić cały kod, który można pobrać, zapisać na karcie SD (i ukryć nazwę pliku) i pobrać obrazy, a na koniec sprawdza, czy obraz już tam jest. Adres URL pochodzi z bazy danych, więc nazwę pliku można łatwo określić za pomocą id.

najpierw pobierz obrazy

   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_); 
            }  
        }  
   }

Następnie utwórz klasę do zapisywania i pobierania plików

  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 ;
}
  }

Następnie Aby uzyskać dostęp do obrazów, najpierw sprawdź, czy już tam jest, a jeśli nie, pobierz

          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() ; 
            }

Dlaczego naprawdę potrzebujesz własnego kodu, aby go pobrać? Co powiesz na przekazanie swojego identyfikatora URI do menedżera pobierania?

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);

}

to może ci pomóc ...

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();
                            }
                        }
                    });

Mam proste rozwiązanie, które działa doskonale. Kod nie jest mój, znalazłem go pod tym linkiem . Oto kroki, które należy wykonać:

1. Przed pobraniem obrazu napiszmy metodę zapisywania bitmapy do pliku obrazu w pamięci wewnętrznej Androida. Potrzebuje kontekstu, lepiej użyć przepustki w kontekście aplikacji przez getApplicationContext (). Tę metodę można wrzucić do klasy Activity lub innych klas użytkowych.

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. Teraz mamy metodę zapisywania bitmapy do pliku obrazu w andorid, napiszmy AsyncTask do pobierania obrazów z adresu URL. Ta prywatna klasa musi być umieszczona w Twojej klasie Activity jako podklasa. Po pobraniu obrazu w metodzie onPostExecute wywołuje zdefiniowaną powyżej metodę saveImage, aby zapisać obraz. Uwaga, nazwa obrazu jest zakodowana na stałe jako „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 do pobrania obrazu jest zdefiniowany, ale musimy go wykonać, aby uruchomić ten AsyncTask. Aby to zrobić, napisz ten wiersz w swojej metodzie onCreate w swojej klasie Activity lub w metodzie onClick przycisku lub w innym miejscu, które uważasz za stosowne.

new DownloadImage().execute("http://developer.android.com/images/activity_lifecycle.png");

Obraz powinien być zapisany w /data/data/your.app.packagename/files/my_image.jpeg, sprawdź ten post, aby uzyskać dostęp do tego katalogu z twojego urządzenia.

IMO to rozwiązuje problem! Jeśli chcesz wykonać dalsze kroki, takie jak załadowanie obrazu, możesz wykonać następujące dodatkowe kroki:

4. Po pobraniu obrazu potrzebujemy sposobu załadowania mapy bitowej obrazu z pamięci wewnętrznej, abyśmy mogli z niej skorzystać. Napiszmy metodę ładowania bitmapy obrazu. Ta metoda przyjmuje dwa parametry, kontekst i nazwę pliku obrazu, bez pełnej ścieżki, context.openFileInput (nazwa_obrazu) wyszuka plik w katalogu zapisu, gdy ta nazwa pliku została zapisana w powyższej metodzie 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. Teraz mamy wszystko, czego potrzebowaliśmy do ustawienia obrazu ImageView lub innych widoków, w których chcesz używać tego obrazu. Kiedy zapisujemy obraz, zakodowaliśmy na stałe nazwę obrazu jako „my_image.jpeg”, teraz możemy przekazać tę nazwę obrazu do powyższej metody loadImageBitmap, aby pobrać mapę bitową i ustawić ją na ImageView.

someImageView.setImageBitmap(loadImageBitmap(getApplicationContext(), "my_image.jpeg"));

6. Aby uzyskać pełną ścieżkę obrazu według nazwy obrazu.

File file            = getApplicationContext().getFileStreamPath("my_image.jpeg");
String imageFullPath = file.getAbsolutePath();

7. Sprawdź, czy plik obrazu istnieje.

Plik plik =

getApplicationContext().getFileStreamPath("my_image.jpeg");
if (file.exists()) Log.d("file", "my_image.jpeg exists!");

8. Aby usunąć plik obrazu.

   File file = getApplicationContext (). GetFileStreamPath ("my_image.jpeg"); if (file.delete ()) Log.d ("plik", "mój_image.jpeg usunięty!");

ten kod doskonale działa w moim projekcie

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();
                }
        }

Spróbuj tego

 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();
            }
        }
    }
}

WYNIK

Upewnij się, że dodałeś uprawnienia do zapisywania danych w pamięci

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

Post @Droidman jest dość obszerny. Volley działa dobrze z małymi danymi o wielkości kilku kilobajtów. Kiedy próbowałem użyć „BasicImageDownloader.java”, Android Studio ostrzegło mnie, że klasa AsyncTask powinna być statyczna lub mogą występować przecieki. Użyłem Volley w innej aplikacji testowej, która ciągle się zawieszała z powodu wycieków, więc martwię się, czy użyję Volley do pobierania obrazów (obrazy mogą mieć kilka 100 kB).

Użyłem Picassa i działało dobrze, jest mała zmiana (prawdopodobnie aktualizacja Picassa) od tego co napisałem powyżej. Poniższy kod zadziałał dla mnie:

    public static void imageDownload(Context ctx, String url){
    Picasso.get().load(yourURL)
            .into(getTarget(url));
}
private static Target getTarget(final String url){

    Target target2 = new Target() {
        @Override
        public void onBitmapLoaded(final Bitmap bitmap, Picasso.LoadedFrom from) {
            new Thread(new Runnable() {

                @Override
                public void run() {

                    File file = new File(localPath + "/"+"YourImageFile.jpg");
                    try {
                        file.createNewFile();
                        FileOutputStream ostream = new FileOutputStream(file);
                        bitmap.compress(Bitmap.CompressFormat.JPEG, 80, ostream);
                        ostream.flush();
                        ostream.close();
                    } catch (IOException e) {
                        Log.e("IOException", e.getLocalizedMessage());
                    }
                }
            }).start();
        }

        @Override
        public void onBitmapFailed(Exception e, Drawable errorDrawable) {
        }

        @Override
        public void onPrepareLoad(Drawable placeHolderDrawable) {
        }
    };
    return target;
}

Jak mówi Google, na razie nie zapomnij dodać w manifeście również czytelnego na pamięci zewnętrznej:

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

Źródło: http://developer.android.com/training/basics/data-storage/files.html#GetWritePermission