Wie lade ich eine ImageView per URL in Android? [geschlossen]

Wie verwendet man ein Bild, auf das durch eine URL verwiesen wird ImageView?

Vom Android-Entwickler :

// show The Image in a ImageView
new DownloadImageTask((ImageView) findViewById(R.id.imageView1))
            .execute("http://java.sogeti.nl/JavaBlog/wp-content/uploads/2009/04/android_icon_256.png");

public void onClick(View v) {
    startActivity(new Intent(this, IndexActivity.class));
    finish();

}

private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
    ImageView bmImage;

    public DownloadImageTask(ImageView bmImage) {
        this.bmImage = bmImage;
    }

    protected Bitmap doInBackground(String... urls) {
        String urldisplay = urls[0];
        Bitmap mIcon11 = null;
        try {
            InputStream in = new java.net.URL(urldisplay).openStream();
            mIcon11 = BitmapFactory.decodeStream(in);
        } catch (Exception e) {
            Log.e("Error", e.getMessage());
            e.printStackTrace();
        }
        return mIcon11;
    }

    protected void onPostExecute(Bitmap result) {
        bmImage.setImageBitmap(result);
    }
}

Stellen Sie sicher, dass Sie die folgenden Berechtigungen für den AndroidManifest.xmlZugriff auf das Internet festgelegt haben.

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

1. Picasso ermöglicht das problemlose Laden von Bildern in Ihre Anwendung - häufig in einer Codezeile!

Verwenden Sie Gradle:

implementation 'com.squareup.picasso:picasso:2.71828'

Nur eine Codezeile!

Picasso.get().load("http://i.imgur.com/DvpvklR.png").into(imageView);

2. Glide Eine Bibliothek zum Laden und Zwischenspeichern von Bildern für Android, die sich auf reibungsloses Scrollen konzentriert

Verwenden Sie Gradle:

repositories {
  mavenCentral() 
  google()
}

dependencies {
   implementation 'com.github.bumptech.glide:glide:4.7.1'
   annotationProcessor 'com.github.bumptech.glide:compiler:4.7.1'
}

// Für eine einfache Ansicht:

  Glide.with(this).load("http://i.imgur.com/DvpvklR.png").into(imageView);

3. fresco ist ein leistungsstarkes System zum Anzeigen von Bildern in Android-Anwendungen . Fresco kümmert sich um das Laden und Anzeigen von Bildern, sodass Sie dies nicht tun müssen.

Erste Schritte mit Fresco

Sie müssen zuerst das Bild herunterladen

public static Bitmap loadBitmap(String url) {
    Bitmap bitmap = null;
    InputStream in = null;
    BufferedOutputStream out = null;

    try {
        in = new BufferedInputStream(new URL(url).openStream(), IO_BUFFER_SIZE);

        final ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
        out = new BufferedOutputStream(dataStream, IO_BUFFER_SIZE);
        copy(in, out);
        out.flush();

        final byte[] data = dataStream.toByteArray();
        BitmapFactory.Options options = new BitmapFactory.Options();
        //options.inSampleSize = 1;

        bitmap = BitmapFactory.decodeByteArray(data, 0, data.length,options);
    } catch (IOException e) {
        Log.e(TAG, "Could not load Bitmap from: " + url);
    } finally {
        closeStream(in);
        closeStream(out);
    }

    return bitmap;
}

Verwenden Sie dann die Imageview.setImageBitmap, um die Bitmap in der ImageView festzulegen

Ich habe eine Klasse geschrieben, um damit umzugehen, da es in meinen verschiedenen Projekten ein wiederkehrendes Bedürfnis zu sein scheint:

https://github.com/koush/UrlImageViewHelper

UrlImageViewHelper füllt eine ImageView mit einem Bild, das unter einer URL gefunden wird.

Das Beispiel führt eine Google Bildsuche durch und lädt / zeigt die Ergebnisse asynchron an.

UrlImageViewHelper lädt automatisch alle Bild-URLs der BitmapDrawables herunter, speichert sie und speichert sie zwischen. Doppelte URLs werden nicht zweimal in den Speicher geladen. Der Bitmap-Speicher wird mithilfe einer schwachen Referenz-Hash-Tabelle verwaltet. Sobald das Bild nicht mehr von Ihnen verwendet wird, wird der Müll automatisch gesammelt.

Wie auch immer, die Leute bitten meinen Kommentar, ihn als Antwort zu posten. Ich poste.

URL newurl = new URL(photo_url_str); 
mIcon_val = BitmapFactory.decodeStream(newurl.openConnection().getInputStream());
profile_photo.setImageBitmap(mIcon_val);

Die oben akzeptierte Antwort ist großartig, wenn Sie das Bild basierend auf einem Schaltflächenklick laden. Wenn Sie es jedoch in einer neuen Aktivität ausführen, friert es die Benutzeroberfläche für ein oder zwei Sekunden ein. Als ich mich umsah, stellte ich fest, dass eine einfache Asynctask dieses Problem beseitigte.

Um eine Asynctask zu verwenden, fügen Sie diese Klasse am Ende Ihrer Aktivität hinzu:

private class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
    ImageView bmImage;

    public DownloadImageTask(ImageView bmImage) {
        this.bmImage = bmImage;
    }

    protected Bitmap doInBackground(String... urls) {
        String urldisplay = urls[0];
        Bitmap mIcon11 = null;
        try {
            InputStream in = new java.net.URL(urldisplay).openStream();
            mIcon11 = BitmapFactory.decodeStream(in);
        } catch (Exception e) {
            Log.e("Error", e.getMessage());
            e.printStackTrace();
        }
        return mIcon11;
    }

    protected void onPostExecute(Bitmap result) {
        bmImage.setImageBitmap(result);
    }    
}

Rufen Sie von Ihrer onCreate () -Methode aus Folgendes auf:

new DownloadImageTask((ImageView) findViewById(R.id.imageView1))
        .execute(MY_URL_STRING);

Das Ergebnis ist eine schnell geladene Aktivität und eine Bildansicht, die je nach Netzwerkgeschwindigkeit des Benutzers einen Sekundenbruchteil später angezeigt wird.

Sie können diese LoadingImageView-Ansicht auch verwenden, um ein Bild von einer URL zu laden:

http://blog.blundellapps.com/imageview-with-loading-spinner/

Nachdem Sie die Klassendatei über diesen Link hinzugefügt haben, können Sie eine URL-Bildansicht instanziieren:

in xml:

<com.blundell.tut.LoaderImageView
  android:id="@+id/loaderImageView"
  android:layout_width="wrap_content"
  android:layout_height="wrap_content"
  image="http://developer.android.com/images/dialog_buttons.png"
 />

In Code:

final LoaderImageView image = new LoaderImageView(this, "http://developer.android.com/images/dialog_buttons.png");

Und aktualisieren Sie es mit:

image.setImageDrawable("http://java.sogeti.nl/JavaBlog/wp-content/uploads/2009/04/android_icon_256.png");

public class LoadWebImg extends Activity {

String image_URL=
 "http://java.sogeti.nl/JavaBlog/wp-content/uploads/2009/04/android_icon_256.png";

   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);

       ImageView bmImage = (ImageView)findViewById(R.id.image);
    BitmapFactory.Options bmOptions;
    bmOptions = new BitmapFactory.Options();
    bmOptions.inSampleSize = 1;
    Bitmap bm = LoadImage(image_URL, bmOptions);
    bmImage.setImageBitmap(bm);
   }

   private Bitmap LoadImage(String URL, BitmapFactory.Options options)
   {       
    Bitmap bitmap = null;
    InputStream in = null;       
       try {
           in = OpenHttpConnection(URL);
           bitmap = BitmapFactory.decodeStream(in, null, options);
           in.close();
       } catch (IOException e1) {
       }
       return bitmap;               
   }

private InputStream OpenHttpConnection(String strURL) throws IOException{
 InputStream inputStream = null;
 URL url = new URL(strURL);
 URLConnection conn = url.openConnection();

 try{
  HttpURLConnection httpConn = (HttpURLConnection)conn;
  httpConn.setRequestMethod("GET");
  httpConn.connect();

  if (httpConn.getResponseCode() == HttpURLConnection.HTTP_OK) {
   inputStream = httpConn.getInputStream();
  }
 }
 catch (Exception ex)
 {
 }
 return inputStream;
}
}

Hallo, ich habe den einfachsten Code, versuche dies

    public class ImageFromUrlExample extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.main);  
            ImageView imgView =(ImageView)findViewById(R.id.ImageView01);
            Drawable drawable = LoadImageFromWebOperations("http://www.androidpeople.com/wp-content/uploads/2010/03/android.png");
            imgView.setImageDrawable(drawable);

    }

    private Drawable LoadImageFromWebOperations(String url)
    {
          try{
        InputStream is = (InputStream) new URL(url).getContent();
        Drawable d = Drawable.createFromStream(is, "src name");
        return d;
      }catch (Exception e) {
        System.out.println("Exc="+e);
        return null;
      }
    }
   }

main.xml

  <LinearLayout 
    android:id="@+id/LinearLayout01"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    xmlns:android="http://schemas.android.com/apk/res/android">
   <ImageView 
       android:id="@+id/ImageView01"
       android:layout_height="wrap_content" 
       android:layout_width="wrap_content"/>

Versuche dies

Die beste moderne Bibliothek für eine solche Aufgabe ist meiner Meinung nach Picasso by Square. Es ermöglicht das Laden eines Bildes in eine ImageView per URL mit einem Einzeiler:

Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);

Ich habe kürzlich hier einen Thread gefunden , da ich für eine Listenansicht mit Bildern etwas Ähnliches tun muss, aber das Prinzip ist einfach, wie Sie in der ersten dort gezeigten Beispielklasse lesen können (von jleedev). Sie erhalten den Eingabestream des Bildes (aus dem Web)

private InputStream fetch(String urlString) throws MalformedURLException, IOException {
    DefaultHttpClient httpClient = new DefaultHttpClient();
    HttpGet request = new HttpGet(urlString);
    HttpResponse response = httpClient.execute(request);
    return response.getEntity().getContent();
}

Anschließend speichern Sie das Bild als Drawable und können es an die ImageView übergeben (über setImageDrawable). Schauen Sie sich noch einmal aus dem oberen Code-Snippet den gesamten Thread an.

InputStream is = fetch(urlString);
Drawable drawable = Drawable.createFromStream(is, "src");

Viele gute Infos hier ... Ich habe kürzlich eine Klasse namens SmartImageView gefunden, die bisher sehr gut zu funktionieren scheint. Sehr einfach zu integrieren und zu verwenden.

http://loopj.com/android-smart-image-view/

https://github.com/loopj/android-smart-image-view

UPDATE : Am Ende habe ich einen Blog-Beitrag darüber geschrieben. Lesen Sie daher die Hilfe zur Verwendung von SmartImageView.

2. UPDATE : Ich benutze jetzt immer Picasso dafür (siehe oben) und kann es nur empfehlen. :) :)

Dies ist eine späte Antwort, wie oben vorgeschlagen AsyncTask, und nachdem ich ein bisschen gegoogelt habe, habe ich einen weiteren Weg für dieses Problem gefunden.

Drawable drawable = Drawable.createFromStream((InputStream) new URL("url").getContent(), "src");

imageView.setImageDrawable(drawable);

Hier ist die komplette Funktion:

public void loadMapPreview () {
    //start a background thread for networking
    new Thread(new Runnable() {
        public void run(){
            try {
                //download the drawable
                final Drawable drawable = Drawable.createFromStream((InputStream) new URL("url").getContent(), "src");
                //edit the view in the UI thread
                imageView.post(new Runnable() {
                    public void run() {
                        imageView.setImageDrawable(drawable);
                    }
                });
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }).start();
}

Vergessen Sie nicht, die folgenden Berechtigungen hinzuzufügen, AndroidManifest.xmlum auf das Internet zuzugreifen.

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

Ich habe es selbst versucht und habe noch kein Problem.

imageView.setImageBitmap(BitmapFactory.decodeStream(imageUrl.openStream()));//try/catch IOException and MalformedURLException outside

Das wird dir helfen...

Definieren Sie die Bildansicht und laden Sie das Bild hinein .....

Imageview i = (ImageView) vv.findViewById(R.id.img_country);
i.setImageBitmap(DownloadFullFromUrl(url));

Dann definieren Sie diese Methode:

    public Bitmap DownloadFullFromUrl(String imageFullURL) {
    Bitmap bm = null;
    try {
        URL url = new URL(imageFullURL);
        URLConnection ucon = url.openConnection();
        InputStream is = ucon.getInputStream();
        BufferedInputStream bis = new BufferedInputStream(is);
        ByteArrayBuffer baf = new ByteArrayBuffer(50);
        int current = 0;
        while ((current = bis.read()) != -1) {
            baf.append((byte) current);
        }
        bm = BitmapFactory.decodeByteArray(baf.toByteArray(), 0,
                baf.toByteArray().length);
    } catch (IOException e) {
        Log.d("ImageManager", "Error: " + e);
    }
    return bm;
}

    String img_url= //url of the image
    URL url=new URL(img_url);
    Bitmap bmp; 
    bmp=BitmapFactory.decodeStream(url.openConnection().getInputStream());
    ImageView iv=(ImageView)findviewById(R.id.imageview);
    iv.setImageBitmap(bmp);

Version mit Ausnahmebehandlung und asynchroner Aufgabe:

AsyncTask<URL, Void, Boolean> asyncTask = new AsyncTask<URL, Void, Boolean>() {
    public Bitmap mIcon_val;
    public IOException error;

    @Override
    protected Boolean doInBackground(URL... params) {
        try {
            mIcon_val = BitmapFactory.decodeStream(params[0].openConnection().getInputStream());
        } catch (IOException e) {
            this.error = e;
            return false;
        }
        return true;
    }

    @Override
    protected void onPostExecute(Boolean success) {
        super.onPostExecute(success);
        if (success) {
            image.setImageBitmap(mIcon_val);
        } else {
            image.setImageBitmap(defaultImage);
        }
    }
};
try {
    URL url = new URL(url);
    asyncTask.execute(url);
} catch (MalformedURLException e) {
    e.printStackTrace();
}

    private Bitmap getImageBitmap(String url) {
        Bitmap bm = null;
        try {
            URL aURL = new URL(url);
            URLConnection conn = aURL.openConnection();
            conn.connect();
            InputStream is = conn.getInputStream();
            BufferedInputStream bis = new BufferedInputStream(is);
            bm = BitmapFactory.decodeStream(bis);
            bis.close();
            is.close();
       } catch (IOException e) {
           Log.e(TAG, "Error getting bitmap", e);
       }
       return bm;
    } 

Eine einfache und saubere Möglichkeit, dies zu tun, ist die Verwendung der Open-Source-Bibliothek Prime .

Dieser Code ist getestet, er funktioniert vollständig.

URL req = new URL(
"http://java.sogeti.nl/JavaBlog/wp-content/uploads/2009/04/android_icon_256.png"
);
Bitmap mIcon_val = BitmapFactory.decodeStream(req.openConnection()
                  .getInputStream());

Arbeiten für imageView in einem beliebigen Container, z. B. Listenansicht-Rasteransicht, normales Layout

 private class LoadImagefromUrl extends AsyncTask< Object, Void, Bitmap > {
        ImageView ivPreview = null;

        @Override
        protected Bitmap doInBackground( Object... params ) {
            this.ivPreview = (ImageView) params[0];
            String url = (String) params[1];
            System.out.println(url);
            return loadBitmap( url );
        }

        @Override
        protected void onPostExecute( Bitmap result ) {
            super.onPostExecute( result );
            ivPreview.setImageBitmap( result );
        }
    }

    public Bitmap loadBitmap( String url ) {
        URL newurl = null;
        Bitmap bitmap = null;
        try {
            newurl = new URL( url );
            bitmap = BitmapFactory.decodeStream( newurl.openConnection( ).getInputStream( ) );
        } catch ( MalformedURLException e ) {
            e.printStackTrace( );
        } catch ( IOException e ) {

            e.printStackTrace( );
        }
        return bitmap;
    }
/** Usage **/
  new LoadImagefromUrl( ).execute( imageView, url );

Versuchen Sie es auf diese Weise und hoffen Sie, dass dies Ihnen bei der Lösung Ihres Problems hilft.

Hier erkläre ich, wie die externe Bibliothek "AndroidQuery" zum Laden von Bildern von URL / Server auf asynchrone Weise verwendet wird, wobei auch geladene Bilder in Gerätedateien oder Cache-Bereiche zwischengespeichert werden.

• Laden Sie hier die Bibliothek "AndroidQuery" herunter
• Kopieren Sie diese JAR-Datei in den Projektbibliotheksordner und fügen Sie sie hinzu
• Jetzt zeige ich eine Demo zur Verwendung.

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center">

        <FrameLayout
            android:layout_width="wrap_content"
            android:layout_height="wrap_content">

            <ImageView
                android:id="@+id/imageFromUrl"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:adjustViewBounds="true"/>
            <ProgressBar
                android:id="@+id/pbrLoadImage"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_gravity="center"/>

        </FrameLayout>
    </LinearLayout>

MainActivity.java

public class MainActivity extends Activity {

private AQuery aQuery;
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    aQuery = new AQuery(this);
    aQuery.id(R.id.imageFromUrl).progress(R.id.pbrLoadImage).image("http://itechthereforeiam.com/wp-content/uploads/2013/11/android-gone-packing.jpg",true,true);
 }
}

Note : Here I just implemented common method to load image from url/server but you can use various types of method which can be provided by "AndroidQuery"to load your image easily.

Android Query kann das für Sie und vieles mehr erledigen (wie Cache und Ladevorgang).

Schauen Sie sich hier an .

Ich denke, das ist der beste Ansatz.