Archivi tag: app code

come scaricare (download) una immagine da web (url) usando AsyncTask in Android

asynctask steps
asynctask steps
LA CHIAMATA
new DownloadImageTask(holder.imageview).execute(urlImgS);


LA ASYNCTASK
		
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);
}
}
}//AsyncTask
Annunci

Come e quando si usa AsyncTask in android (thread) – code esempio

 

Un’attività asincrona è definita da un calcolo che viene eseguito su un thread (filo o processo) in background (sottofondo) e il cui risultato è condiviso e pubblicato sul thread UI (processo della UI).

android AsyncTask
android AsyncTask (image  lucadentella)

Un thread o thread di esecuzione, in informatica, è una suddivisione di un processo in due o più filoni o sotto processi, che vengono eseguiti con-correntemente da un sistema di elaborazione.

AsyncTask consente un uso corretto e semplice del thread UI (processo o filo principale della Interfaccia Utente).

Questa classe consente di eseguire operazioni in background (sottofondo) e di condividere i loro risultati sul thread UI ossia sul filo o processo dell’interfaccia utente, senza dover gestire processi/fili o utilizzare maipolatori di eventi (handlers).

AsyncTask è stato progettato per essere una classe di supporto per Thread ed Handler e non costituisce framework di thread generico.
AsyncTask dovrebbe idealmente essere utilizzato per operazioni di breve durata (pochi secondi al massimo).

Se è necessario conservare un thread (filo) in esecuzione per lunghi periodi di tempo, si consiglia vivamente di utilizzare le varie API fornite dal pacchetto java.util.concurrent package tali come Executor, ThreadPoolExecutor e FutureTask.

Un compito asincrono è definito da 3 tipi generici, chiamati (params, progress, result), e di 4 momenti (passaggi nel tempo), chiamati respettivamente OnPreExecute, doInBackground, onProgressUpdate e OnPostExecute.

params, progress, result

 

Android Code Esempio AsyncTask

LA CHIAMATA

package com.apps.xxxx.xxxx;

import android.app.Activity;
...
public class MainActivity extends Activity {
   ...
  public GridView gridview;
  @Override
  protected void onCreate(Bundle savedInstanceState)      {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.activity_main1);
     
     // Creating a new non-ui thread
     jsonAsyncTask downloadTask = new jsonAsyncTask();
     ...
 }
}


I QUATTRO (TRE) PASSAGGI
(attenzione ai parametri generici...params, progress, result ... String, Void, String)

/** AsyncTask to download json data */
private class jsonAsyncTask extends AsyncTask
<String, Void, String> {

ProgressDialog dialog;
@Override
protected void onPreExecute() {
   super.onPreExecute();
   //dialog
   dialog = new ProgressDialog(MainActivity.this);
   dialog.setTitle("Connecting server  ");
   dialog.setMessage("Loading, please wait");
   dialog.setIndeterminate(true);
   dialog.setCancelable(false);
   dialog.show();
 }
//last param String
  String data = null;

@Override
protected String doInBackground(String... url) {
try{
   data = getJSONString(url[0]);
   }catch(Exception e){
    return "notok";
   }
    return "ok";
  }

/** Invoked by the Android on "doInBackground" is executed */

@Override
protected void onPostExecute(String result) {
dialog.dismiss();
//dialog.cancel();
//adapter.notifyDataSetChanged();
 if(result =="ok") {
  adapter = new ItemAdapter(MainActivity.this, R.layout.row, listitems);
   gridview.setAdapter(adapter);
  }else{
   showToast("Unable to fetch data from server");                
  }//endif
 }//onPosExecute
}//AsyncTask

come fare il parsering dei dati in formato Json in Android

del formato json si deve conoscere …

appissue json rest http
appissue json rest http

In primo luogo si deve analizzare i dati, gli oggetti o le stringhe in formato Json.

In particolare Items è un oggetto, conformato da un Array da oggetti con CodPro, Brand, FormattedFullPrice.

{"Items": 
   [
	{
	"CodPro": "2234567899",
	"Brand": "XXX ZZZ",	
	"FormattedFullPrice": "Euro 2,620.00",
	},
        {
	"CodPro": "2234123456",
	"Brand": "ALPHA",	
	"FormattedFullPrice": "Euro 1,120.00",
	},
        {
	"CodPro": "2234234567",
	"Brand": "BETA",	
	"FormattedFullPrice": "Euro 1,112.00",
	},
   ]
}

dopo si devono creare le classi per gestire l’oggetto Item. creare la Classe Items con gli getters e setters e infine creare le constanti per gestire i nomi dei componenti degli array di oggetti.

LA CLASSE ITEMS

public class Items{
  private String brand;
  private String codPro;
  private String formattedFullPrice; 
  	
  
  public String getBrand(){
	return this.brand;
 }
public void setBrand(String brand){
	this.brand = brand;
 }
 public String getCodPro(){
	return this.codPro;
 }
 public void setCodPro(String cod10){
	this.codPro = codPro;
 }
 public String getFormattedFullPrice(){
	return this.formattedFullPrice;
 }
 public void setFormattedFullPrice(String  formattedFullPrice){
	this.formattedFullPrice = formattedFullPrice;
}
 	
}
...

LE VARIABILI

 private static final String ENTITY_NAME = "Items";  
 private static final String BRAND = "Brand";
 private static final String CODPRO = "CodPro";
 private static final String FORMATTEDFULLPRICE = "FormattedFullPrice"; 
PARSERING

private Boolean parseJson(String jsonString) {
 String myS;
 try {
  JSONObject jsono = new JSONObject(jsonString);
  JSONArray jarray = jsono.getJSONArray(ENTITY_NAME);

  for (int i = 0; i < jarray.length(); i++) {
    JSONObject object = jarray.getJSONObject(i);
    Items item = new Items();
    item.setCodPro(object.getString(CODPRO));
    item.setBrand(object.getString(BRAND));         item.setFormattedFullPrice(object.getString
    (FORMATTEDFULLPRICE));
    /* myS = (item.getCod10() + " " + item.getBrand()  + " " + item.getCod10());
    Log.d("item iessimo " , myS);*/
    listitems.add(item);
  }//endfor*/
  //test
  /*for (int i = 0; i < jarray.length(); i++) {
    Log.d(" *** ***   iesimo ",   listitems.get(i).getCod10());
   }*/
 } catch (JSONException e) {
      Log.d("Parse Json error ",e.toString());
      return false;
  }//endcarch
 return true;
}

Come usare HttpURLConnection in Android

Una URLConnection per HTTP (RFC 2616) consente di inviare e ricevere dati attraverso il web.

appissue json
appissue json

Questi dati possono essere di qualsiasi tipo e lunghezza.

Questa classe può essere utilizzata per inviare e ricevere dati in streaming cui lunghezza non è nota in anticipo.

  • Ottenere un nuovo HttpURLConnection chiamando URL.openConnection () e lanciando il risultato di HttpURLConnection.
  • Preparare la richiesta. La struttura primaria di una richiesta è suo URI. (la richiesta può comprendere anchei metadati quali le credenziali, i tipi di contenuti preferiti e cookies di sessione.
    Opzionalmente si può caricare un corpo della richiesta.
  • Le istanze devono essere configurati con setDoOutput (vero) se includono un corpo.
  • I dati vengono trasmessi ad un flusso restituito da getOutputStream ().
  • si legge la risposta. Il corpo di risposta può essere letto dal flusso restituito da getInputStream (). Se la risposta non ha corpo, il metodo restituisce un flusso di vuoto.
  • Disconnect. Una volta che il corpo della risposta è stato letto, il HttpURLConnection dovrebbe essere chiuso chiamando disconnessione().  Questa  disconnessione rilascia le risorse detenute dalla connessione in modo che possano essere chiusi o riutilizzati.

vedi su android reference HttpURLConnection


private String getJSONString(String strUrl){
  InputStream is = null;
  URL url = null;
  BufferedReader br = null;
  StringBuilder sb = new StringBuilder();
   HttpURLConnection conn = null;
  String jsonString = null;
  try {
      url = new URL(strUrl);
      conn = HttpURLConnection)url.openConnection();
      //set the timeout in milliseconds
      conn.setReadTimeout(15000);
      //set the timeout in milliseconds
      conn.setConnectTimeout(15000);
      conn.setRequestMethod("GET");
      conn.setDoInput(true);
      conn.connect();

      // Log.d("-----url 1 ", String.valueOf(url));
      int response = conn.getResponseCode();
      is = new BufferedInputStream(conn.getInputStream());
      //Log.d("!!!!!!!!is  2", String.valueOf(is));
      br = new BufferedReader(new InputStreamReader(is));
      byte[] b = new byte[1024];
      // to implement try catch…
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      //readstream
      while ( is.read(b) != -1) {
        baos.write(b);
      }
      //Log.d("+sb 3 ", String.valueOf(sb));
      //String JSONResp= new String(baos.toByteArray());
       byte[] data1 = baos.toByteArray();
      // to implement try catch…
      jsonString = new String(data1);
      //Log.d("JSON jsonSTRing  ", jsonString);
      //call parse json data
       myFlag = parseJson(jsonString);
  } catch (MalformedURLException e) {
       e.printStackTrace();
  } catch (java.net.ProtocolException e) {
       e.printStackTrace();
  } catch (IOException e) {
       e.printStackTrace();
  }finally{
      if(br!=null){
          try {
              br.close();
              is.close();
          } catch (IOException e) {
              e.printStackTrace();
          }
          if(conn!=null) {
              conn.disconnect();
          }
      }
  }
  return jsonString;
}