internet - Cómo descargar y guardar una imagen en Android

como guardar fotos de google en galeria

Question

¿Cómo se puede descargar y guardar una imagen desde una url determinada en Android?

Answer 1

Prueba esto

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

Answer 2

Editar a partir del 30.12.2015 - La guía definitiva para la descarga de imágenes

última gran actualización: 31 de marzo de 2016

TL; DR alias deja de hablar, solo dame el código !!

Pase al final de esta publicación, copie BasicImageDownloader (versión de javadoc here ) en su proyecto, implemente la interfaz OnImageLoaderListener y listo.

Nota : aunque BasicImageDownloader maneja posibles errores y evitará que su aplicación se bloquee en caso de que algo salga mal, no realizará ningún postprocesamiento (por ejemplo, reducción de tamaño) en los Bitmaps descargados.

Como esta publicación ha recibido bastante atención, he decidido volver a trabajarla por completo para evitar que las personas usen tecnologías obsoletas, malas prácticas de programación o simplemente hagan cosas tontas, como buscar "hacks" para ejecutar la red en el hilo principal o aceptar todos los certificados SSL.

Creé un proyecto de demostración llamado "Image Downloader" que muestra cómo descargar (y guardar) una imagen usando mi propia implementación de descarga, el DownloadManager integrado de Android y algunas bibliotecas populares de código abierto. Puede ver el código fuente completo o descargar el proyecto en GitHub .

Nota : aún no ajustó la administración de permisos para SDK 23+ (Marshmallow), por lo que el proyecto se está dirigiendo al SDK 22 (Lollipop).

En mi conclusión al final de esta publicación, compartiré mi humilde opinión sobre el uso apropiado de cada forma particular de descarga de imágenes que he mencionado.

Comencemos con una implementación propia (puede encontrar el código al final de la publicación). En primer lugar, este es un ImageDownloader básico y eso es todo. Todo lo que hace es conectarse a la url determinada, leer los datos e intentar decodificarla como un Bitmap , lo que activa la devolución de llamada de la interfaz OnImageLoaderListener cuando corresponda. La ventaja de este enfoque es simple y tiene una visión clara de lo que está sucediendo. Una buena forma de hacerlo si todo lo que necesita es descargar / visualizar y guardar algunas imágenes, mientras que no le importa mantener una memoria / memoria caché.

Nota: en el caso de imágenes grandes, es posible que deba reducirlas .

-

Android DownloadManager es una forma de dejar que el sistema maneje la descarga por usted. En realidad es capaz de descargar cualquier tipo de archivos, no solo imágenes. Puede permitir que la descarga ocurra silenciosa e invisible para el usuario, o puede permitir que el usuario vea la descarga en el área de notificación. También puede registrar un BroadcastReceiver para recibir una notificación después de que se complete la descarga. La configuración es bastante sencilla, consulte el proyecto vinculado para obtener un código de muestra.

Usar el DownloadManager generalmente no es una buena idea si también desea mostrar la imagen, ya que necesitaría leer y decodificar el archivo guardado en lugar de simplemente configurar el Bitmap descargado en un ImageView . DownloadManager tampoco proporciona ninguna API para su aplicación para rastrear el progreso de la descarga.

-

Ahora la introducción de las cosas geniales: las bibliotecas. Pueden hacer mucho más que solo descargar y mostrar imágenes, incluyendo: crear y administrar la memoria / memoria caché, cambiar el tamaño de las imágenes, transformarlas y más.

Comenzaré con Volley , una poderosa biblioteca creada por Google y cubierta por la documentación oficial. Si bien es una biblioteca de redes de propósito general que no se especializa en imágenes, Volley presenta una API bastante poderosa para administrar imágenes.

Tendrá que implementar una clase Singleton para administrar las solicitudes de Volley y estará listo.

Es posible que desee reemplazar su ImageView con NetworkImageView de Volley, por lo que la descarga básicamente se convierte en una sola línea:

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

Si necesita más control, esto es lo que parece crear ImageRequest con 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
                }
            });

Vale la pena mencionar que Volley presenta un excelente mecanismo de manejo de errores al proporcionar la clase VolleyError que le ayuda a determinar la causa exacta de un error. Si su aplicación tiene muchas funciones de red y la administración de imágenes no es su objetivo principal, entonces puede personalizarlo para usted.

-

Square''s Picasso es una biblioteca muy conocida que hará todas las cosas de carga de imágenes para ti. Solo mostrar una imagen usando Picasso es tan simple como:

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

Por defecto, Picasso administra el disco / memoria caché para que no tenga que preocuparse por eso. Para obtener más control, puede implementar la interfaz de Target y usarla para cargar su imagen, esto proporcionará devoluciones de llamada similares al ejemplo de Volley. Consulte el proyecto de demostración para ver ejemplos.

Picasso también le permite aplicar transformaciones a la imagen descargada e incluso hay otras bibliotecas alrededor que extienden esas API. También funciona muy bien en un RecyclerView / ListView / GridView .

-

Universal Image Loader es otra biblioteca muy popular que sirve para el manejo de imágenes. Utiliza su propio ImageLoader que (una vez inicializado) tiene una instancia global que puede usarse para descargar imágenes en una sola línea de código:

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

Si desea seguir el progreso de la descarga o acceder al Bitmap descargado:

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

El argumento opts en este ejemplo es un objeto DisplayImageOptions . Consulte el proyecto de demostración para obtener más información.

Similar a Volley, UIL proporciona la clase FailReason que le permite verificar qué falló en la falla de descarga. Por defecto, UIL mantiene una caché de memoria / disco si no le dice explícitamente que no lo haga.

Nota : el autor ha mencionado que ya no está manteniendo el proyecto hasta el 27 de noviembre de 2015. Pero dado que hay muchos colaboradores, podemos esperar que el Universal Image Loader siga vivo.

-

Facebook Fresco es la biblioteca más nueva e innovadora (IMO) que lleva la administración de imágenes a un nuevo nivel: desde mantener Bitmaps fuera del montón de Java (anterior a Lollipop) hasta admitir formatos animados y transmisión JPEG progresiva .

Para obtener más información sobre las ideas y técnicas detrás de Fresco, consulte esta publicación .

El uso básico es bastante simple. Tenga en cuenta que deberá llamar a Fresco.initialize(Context); solo una vez, preferiblemente en la clase de Application . Inicializar Fresco más de una vez puede provocar un comportamiento impredecible y errores OOM.

Fresco usa Drawee para mostrar imágenes, puedes pensar en ellas a partir de ImageView s:

    <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" />

Como puede ver, muchas cosas (incluidas las opciones de transformación) ya están definidas en XML, por lo que todo lo que necesita hacer para mostrar una imagen es de una sola línea:

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

Fresco proporciona una API de personalización extendida, que, bajo ciertas circunstancias, puede ser bastante compleja y requiere que el usuario lea los documentos con cuidado (sí, algunas veces necesita RTFM).

He incluido ejemplos para JPEG progresivos e imágenes animadas en el proyecto de muestra.

Conclusión: "He aprendido sobre las cosas geniales, ¿qué debería usar ahora?"

Tenga en cuenta que el siguiente texto refleja mi opinión personal y no debe tomarse como un postulado.

• Si solo necesita descargar / guardar / mostrar algunas imágenes, no planea usarlas en un Recycler-/Grid-/ListView y no necesita un montón de imágenes para estar listas para la visualización, el BasicImageDownloader debe ajustarse a su necesariamente.
• Si su aplicación guarda imágenes (u otros archivos) como resultado de un usuario o una acción automatizada y no necesita que las imágenes se muestren a menudo, use el DownloadManager de Android.
• En caso de que su aplicación haga muchas conexiones de red, transmita / reciba datos de JSON , trabaje con imágenes, pero esos no son el propósito principal de la aplicación, vaya con Volley .
• Su aplicación está enfocada en imágenes / medios, le gustaría aplicar algunas transformaciones a las imágenes y no quiere molestarse con la API compleja: use Picasso (Nota: no proporciona ninguna API para seguir el estado de descarga intermedia) o Universal Image Cargador
• Si su aplicación tiene que ver con imágenes, necesita funciones avanzadas como la visualización de formatos animados y está listo para leer los documentos, vaya con Fresco .

En caso de que te lo hayas perdido, el enlace de Github para el proyecto de demostración.

Y aquí está el 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;
        }
      }
   }

Answer 3

¿Por qué realmente necesitas tu propio código para descargarlo? ¿Qué tal si le pasas el URI al Administrador de descargas?

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

}

Answer 4

Acabo de resolver este problema y me gustaría compartir el código completo que puede descargar, guardar en la tarjeta SD (y ocultar el nombre del archivo) y recuperar las imágenes, y finalmente comprueba si la imagen ya está allí. La url proviene de la base de datos, por lo que el nombre de archivo puede utilizarse de manera única y única.

primeras descargas de imágenes

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

Luego crea una clase para guardar y recuperar los archivos

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

Luego, para acceder a las imágenes primero verifique si ya están allí si no, luego descargue

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

Answer 5

Como dice Google, por ahora, no olvide agregar también legible en el almacenamiento externo en el manifiesto:

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

Fuente: http://developer.android.com/training/basics/data-storage/files.html#GetWritePermission

Answer 6

Tengo una solución simple que funciona a la perfección. El código no es mío, lo encontré en este link . Estos son los pasos a seguir:

1. Antes de descargar la imagen, vamos a escribir un método para guardar el mapa de bits en un archivo de imagen en el almacenamiento interno en Android. Necesita un contexto, mejor utilizar el pase en el contexto de la aplicación mediante getApplicationContext (). Este método se puede descargar en su clase de actividad u otras clases de utilidades.

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. Ahora tenemos un método para guardar bitmap en un archivo de imagen en andorid, vamos a escribir AsyncTask para descargar imágenes por url. Esta clase privada debe colocarse en su clase de Actividad como una subclase. Después de descargar la imagen, en el método onPostExecute, llama al método saveImage definido anteriormente para guardar la imagen. Tenga en cuenta que el nombre de la imagen está codificado como "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. La AsyncTask para descargar la imagen está definida, pero necesitamos ejecutarla para ejecutar esa AsyncTask. Para hacerlo, escriba esta línea en su método onCreate en su clase Activity, o en un método onClick de un botón u otros lugares que considere oportuno.

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

La imagen debe guardarse en /data/data/your.app.packagename/files/my_image.jpeg, verifique esta publicación para acceder a este directorio desde su dispositivo.

¡IMO esto resuelve el problema! Si desea más pasos, como cargar la imagen, puede seguir estos pasos adicionales:

4. Después de descargar la imagen, necesitamos una manera de cargar el mapa de bits de la imagen desde el almacenamiento interno, para que podamos usarlo. Vamos a escribir el método para cargar el mapa de bits de la imagen. Este método toma dos parámetros, un contexto y un nombre de archivo de imagen, sin la ruta completa, context.openFileInput (imageName) buscará el archivo en el directorio de guardar cuando este nombre de archivo se guardó en el método saveImage anterior.

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. Ahora tenemos todo lo que necesitamos para configurar la imagen de un ImageView o cualquier otra vista en la que quiera usar la imagen. Cuando guardamos la imagen, codificamos el nombre de la imagen como "my_image.jpeg", ahora podemos pasar este nombre de imagen al método anterior de loadImageBitmap para obtener el mapa de bits y establecerlo en un ImageView.

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

6. Para obtener la ruta completa de la imagen por nombre de imagen.

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

7. Verifique si el archivo de imagen existe.

Archivo de archivo =

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

8. Para eliminar el archivo de imagen.

   Archivo file = getApplicationContext (). GetFileStreamPath ("my_image.jpeg"); if (file.delete ()) Log.d ("archivo", "my_image.jpeg eliminado!");

Answer 7

este código funciona perfectamente en mi proyecto

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

Answer 8

podría ayudarte ...

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

Answer 9

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

SALIDA

Asegúrate de haber agregado permiso para escribir datos en la memoria

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