Archivi tag: 2015

Tutorial risorse e video corsi per imparare Java JSF in Eclipse – prima PARTE

Tutorial risorse e video corsi per imparare Java JSF  in Eclipse – WTP tools con Apache Tomcat

In questo post, si presenterà un elenco di collegamenti a risorse, tutorial e corsi video utili alla creazione delle java web application (desktop), con Eclipse e Apache Server utilizzando le Facelet di JSF 2.0.

java server pages jsf dynamic web apps java appissue
java server pages jsf
dynamic web apps
java appissue

how to use Java JSF into Eclipse with Apache Tomcat Server ? which are the best practices ?

jse apache tomcat eclipse
appissue: how to use Java JSF into Eclipse with Apache Tomcat Server

Gradle da dove iniziare ? – principi fondamentali – Build Language Reference – 2015

FONTE ORIGINALE (docs.gradle.org)
FONTE IMMAGINI (www.drdobbs.com)

Gradle build è un programma, che utilizza un linguaggio chiamato Groovy(linguaggio di programmazione ad oggetti per la Piattaforma Java alternativo al linguaggio Java).

Gradle gestisce diversi compiti (task), ogni task è un oggetto (object) che ha una API e deve compiere una lista di attività, la forma delle task utilizza a directed acyclic graph algorithm.

Introduzione

Questa guida descrive i vari tipi che compongono il linguaggio di “Build” Gradle o DSL (Linguaggio di Dominio Specifico).

Gradle appissue
Gradle appissue

Alcuni principi fondamentali

Ci sono alcuni concetti di base che si dovrebbero capire, che vi aiuteranno  a scrivere degli scripts in Gradle.

In primo luogo, gli scripts Gradle sono degli script di configurazione (realizzazione). Come lo script viene eseguito, si configura un oggetto di un tipo particolare. Un esempio, di come viene eseguito uno script di Build (configurazione), si configura un oggetto di tipo di Progetto (Project). Questo oggetto è chiamato l’oggetto delegato(Delegate) dello script.

La tabella seguente mostra il delegato per ogni tipo di script Gradle.

Tipi di script                                                                                     Delegati come istanza di

Build script (di configurazione o realizzazione)           Project (progetto)

Init script (di inizializzazione)                                                  Gradle

Settings script (di impostazioni)                                             Settings (Impostazioni)

Le proprietà ei metodi dell’oggetto delegato sono disponibili per il suo utilizzo nello script.

In secondo luogo, ogni script Gradle implementa uno script di tipo interfaccia(script interface) . Questa interfaccia definisce una serie di proprietà e di metodi che è possibile utilizzare all’interno dello script.

Struttura dello script di configurazione(build)
Uno script di build è composta da zero o più dichiarazioni  di blocchi di script. Le dichiarazioni possono includere metodo di chiamate, assegnazioni di proprietà, e delle definizioni di variabili locali.   Un blocco di script è una metodo chiamante che prende una clousure come parametro. La clousure è trattata come una configurazione  di una clousure che consente di configurare come eseguire (execute) un oggetto delegato.

Gradle appissue
Gradle appissue

Come capire le Clousure ? (a.d.t)
come particolare tecnica di mantenimento dello stato –  una inner function è una funzione che viene definita all’interno di un’altra funzione). vedi (http://stacktrace.it/2007/12/22/javascript-closures/

  • clousure come una una funzione che può essere assegnata ad una variabile e che è in grado di interagire con le variabili presenti nell’ambiente che la definisce** ( vedi http://www.sullaprogrammazione.com/le-closures-e-c.html e http://gafter.blogspot.it/
  • Una clousure è una forma di funzione anonima. Si dichiara con la seguente sintassi:  { parametri formali => istruzioni o espressione }. Parametri formali, dichiarazioni, e l’espressione sono facoltativi in questa clausola. Ad esempio, {int x => x + 1} è una funzione che prende un singolo argomento int e restituisce il suo valore incrementato di 1. La closure può essere richiamata dal Invoke Method. Ad esempio, {int x => x + 1} .invoke (10) chiamerà la chiusura con l’argomento 10.(vedi http://tronicek.blogspot.it/2007/12/closures-closure-is-form-of-anonymous_28.html)
gradle code android vs maven appissue
gradle code android vs maven appissue

I blocchi di scripts di livello superiore sono elencati di seguito.
allprojects { }  
Configura questo progetto(project) e ciascuno dei suoi sotto-progetti(sub-projects).
artifacts { }
Configura gli elementi (artifacts) pubblicate(rilasciate) per questo progetto(project).
buildscript { }
Configura classpath* di build (configurazione) per questo progetto(project)
configurations { }  
Definisce le configurazioni di dipendenza(dependencies)  per questo progetto.
dependencies { }
Configura le dipendenze per questo progetto.
repositories { } 
Configura i repository per questo progetto.
sourceSets { }
Configura impostazioni di origine (source sets)  di questo progetto.
subprojects { }
Configura i sotto-progetti di questo progetto.
publishing { }
Configura le PublishingExtension aggiunte dal plugin di rilascio(pubblicazione).

Uno script di build(impostazioni) è anche uno script Groovy, e quindi può contenere quegli elementi consentiti in uno script Groovy, quali le definizioni dei metodi e le definizioni di classe.

TIPI FONDAMENTALI

Di seguito sono elencati alcuni dei tipi di base che vengono utilizzati negli script di Gradle:

Project (progetto)
Questa interfaccia è l’API principale utilizzata per interagire con Gradle attraverso  il proprio file di build (grade.build)    Da Project(progetto), si ha accesso programmatico a tutte le funzioni di Gradle.

Task (compito)
Una task(compito) rappresenta un pezzo unico e atomica di lavoro per un file di build(impostazioni), come ad esempio la compilazione delle classi o la generazione di un javadoc.

 Gradle
Rappresenta una invocazione(chiamata) a Gradle.

 Settings  (impostazioni)
Rappresenta e dichiara la configurazione necessaria per istanziare e configurare le gerarchie del progetto(project), istanze che faranno parte del suo file di build (file di configurazione).  

Script    (copione)
Questa interfaccia è implementata da tutti gli script(copioni) di  Gradle con il fine di aggiungere alcuni dei metodi specifici di Gradle. Non appena si compila la classe dello script se implementerà questa interfaccia , e si potranno  allora utilizzare direttamente tutti i metodi e proprietà dichiarati nella interfaccia.

 JavaToolChain (catena di strumenti per codice sorgente java)
Una serie di strumenti  per permettere il building(le impostazioni di debug o rilascio) da codice sorgente provenienti da java (from Java source).

 SourceSet
Un SourceSet(impostazioni di sorgente) rappresenta un gruppo logico java di sorgenti(code) e  resources.

 SourceSetOutput (directory di output)
Una raccolta di tutte le directory di output (classi compilate, le risorse processate, ecc) – si noti che SourceSetOutput estende FileCollection.

 IncrementalTaskInputs (compiti incrementli)
Consente di accedere a tutti i file di input che devono essere trattati da un compito incrementale.

Configuration (Configurazione)
unaConfigurazione rappresenta un gruppo di elaborati con  le loro dipendenze. Trova maggiori informazioni sulla configurazione della dichiarazione di dipendenze o sulla gestione delle configurazioni nei documenti per ConfigurationContainer.            

 ResolutionStrategy
Definisce le strategie intorno alla risoluzione delle dipendenze. Ad esempio, costringendo d utilizzare certe versioni di dipendenza, le sostituzioni, la risoluzione dei conflitti o il timeout snapshot.

ArtifactResolutionQuery
Un costruttore  per definire una query in grado di risolvere specifici componenti provenienti da  elaborati software selezionati.

ComponentSelection
Rappresenta una tupla di  componenti selettori,  dentro un modulo e di una versione candidata , da essere valutare in una regola di selezione di componenti.

 ComponentSelectionRules
Rappresenta un contenitore per regole di selezione dei componenti. Le regole possono essere applicate come parte della resolutionStrategy di una configurazione e i singoli componenti possono essere espressamente accettati  o respinti dalla regola. I componenti che non sono stati né accettati né respinti saranno soggetti alle strategie di versione di default corrispondenti.

 ConventionProperty
ConventionProperty può essere assegnata ma non può essere mutata(anche se l’oggetto è mutevole!)

 ExtensionAware
Gli oggetti che possono essere estesi a runtime con altri oggetti.

 ExtraPropertiesExtension
Aggiuntivo, ad-hoc, proprietà per gli oggetti del dominio Gradle.

 PublishingExtension
La configurazione di come “pubblicare” rilasciare i diversi componenti di un progetto.

 Report (Rapporto)
Un rapporto basato su file da creare.

 Reporting (Segnalazioni)
Un oggetto che fornisce opzioni di reporting.

 ReportContainer
Un contenitore di oggetti tipo report, che rappresentano potenziali rapporti(reports).

 ReportingExtension
Un’estensione di progetto chiamato “report”, che fornisce le impostazioni di segnalazione (reporting) di base e le utility.

 IvyPublication
Un IvyPublication è la rappresentazione / configurazione di  come Gradle dovrebbe pubblicare qualcosa in formato Ivy, al interno di un repository Ivy. Aggiungendo  direttamente una chiamata Ivy alla pubblicazione (publishing). il contenitore di Publications del progetto fornirà  IvyPublication come tipo.

 IvyArtifact
Un artefatto(elaborato)  pubblicato come parte di una IvyPublication.

 IvyArtifactSet
Una collezione di IvyArtifacts da includere in una IvyPublication. Essendo un DomainObjectSet, una IvyArtifactSet fornisce metodi utili per l’interrogazione, il filtraggio, e la applicazione di azioni specifiche al set (insieme) di IvyArtifacts.

 IvyModuleDescriptorSpec
Il descrittore di qualsiasi pubblicazione Ivy.

 MavenPublication
Un MavenPublication è la rappresentazione / configurazione di come Gradle dovrebbe pubblicare qualcosa in formato Maven. Si aggiunge direttamente un il nome Maven alla pubblicazione (publishing). il contenitore di Publication del progetto fornirà MavenPublication come tipo.

 MavenArtifact
Un artefatto(elaborato)  pubblicato come parte di una MavenPublication(rilascio).

 MavenArtifactSet
Una collezione di MavenArtifacts da includere in una MavenPublication. Essendo un DomainObjectSet, un aMavenArtifactSet fornisce metodi utili per l’interrogazione, il filtraggio, e applicazione di  azioni specifiche al set (insieme) di MavenArtifacts.

 MavenPom
Il POM per una pubblicazione Maven. Il metodo MavenPom.withXml () può essere utilizzato per modificare il descrittore dopo che è stato generato in base ai dati di pubblicazione.

 PluginDependenciesSpec
Il DSL per dichiarare i plugin da utilizzare all’interno  uno script.

 PluginDependencySpec
Una specifica mutabile di una dipendenza all’interno di un plugin.

 ResourceHandler (gestore delle risorse)
Fornisce l’accesso ai metodi  di utilità di specifiche risorse, per esempio i metodi di fabbrica che creano svariate  risorse.

 TextResourceFactory (costruttore)
Crea TextResources garantite da fonti come le stringhe, file e le voci di archivio.

 TIPI DI CONTAINER
Tipi di container che gestiscono i vari elementi dichiarativi (ad esempio le dipendenze, le configurazioni, i manufatti, etc.):

 ConfigurationContainer
Un ConfigurationContainer è responsabile delle dichiarazioni e della gestione delle configurazioni(.(impostazioni di configurazione). Vedere anche Configurazione

RepositoryHandler
Un RepositoryHandler gestisce una serie di repository, consentendo ad essi (repository ) di essere  da definiti (impostati) e di essere filtrati (interrogati attraverso filtri e query).

DependencyHandler
Un DependencyHandler consente di dichiarare le dipendenze. Le dipendenze sono raggruppate i in configurazioni (vedere Configurazione).

ArtifactHandler
Questa classe serve a definire artefatti (elaborati – documenti) da pubblicare e aggiungerli alle configurazioni. La creazione di artefatti di pubblicazione (rilascio) non significa dovere creare un archivio. Ciò che si crea è un oggetto di dominio che rappresenta un file da pubblicare insieme e contiene informazioni  su come dovrebbe essere pubblicato (ad esempio, il nome).

FONTE VIDEO (youtube Gladeware)

Come diventare uno sviluppatore Android – (android skills 2015)

FONTE ORIGINALE (by 

Si sa che le app mobile (applicazioni per mobile)  collegano sempre più gente del pianeta, e permettono agli utenti di tutto il mondo ad interattuare o  interagire  in modo sempre più interessante e innovativo come non si era mai immaginato, il lavoro dello sviluppatore app mobile è diventato sempre più arricchente, appagante, e necessario per l’economia globale moderna.

Le applicazioni per cellulari che usiamo ogni giorno hanno cambiato il nostro modo di comunicare e di consumare intrattenimento, anche il nostro modo di imparare le cose sul mondo.  Non sarebbe male se si pensasi allo sviluppo delle mobile app come ad una delle industrie di lavoro più cool (di moda – più trainante) del momento.

Quindi, come si fa a diventare uno sviluppatore di applicazioni per mobile (appmobile – mobileapp developer ) ?

Ecco la sua versione essenziale : si sceglie una delle piattaforme – come Android ,iOS o Windows Mobile – si apprendono le competenze tecniche di base, se si cimenta  sulle proprie competenze trasversali -migliorandole (soft skills), e ci si diventa.

Come diventare uno sviluppatore Android ?

Ma veniamo in un  po più in dettaglio. Qui, stiamo andando ad affrontare la prospettiva di diventare uno sviluppatore di Android appositamente (dedicato ).

Perché Android?

Android a livello globale, è il leader indiscusso della quota di mercato degli smartphone. Grazie alla crescita dei mercati emergenti come il Messico, la Turchia e il Brasile, quella posizione dominante non tramuterà nel breve periodo.

android developer
android developer

Grafico via 9to5Mac

facendo si che questa preponderanza di mercato si traduca in una grave  difficoltà, per la sicurezza del lavoro degli sviluppatori di Android.

Inoltre, la piattaforma Android è open source (l’intero codice sorgente di Android è consultabile (browsable)  e condivisibile, anche se con un po di software proprietario come Google Play), rendendo l’ecosistema di sviluppatori dinamico e collettivamente arricchente.

Gli sviluppatori di Android condividono consigli, trucchi e tutorial con tutta la comunità Android, e dal momento che Google gli aiuta  con lo sviluppo di strumenti come Google Play Services  per tutte le attività comuni delle app:  come l’accesso, l’autenticazione, la posizione e la archiviazione di dati,  cosi permettendo agli sviluppatori di Android di concentrarsi sulla costruzione delle ‘funzionalità di base’  delle loro applicazioni

In sostanza, si tratta di un momento particolarmente emozionante per lanciare una carriera nello sviluppo di Android. Vi è una fonte sana di posti di lavoro, la domanda di applicazioni Android promette di aumentare in futuro, e le tecnologie – app indossabile e app TV-  stanno intrigantemente avanzando.

Le Abilità o Competenze richieste (Hard Skills): cosa imparare

Per prima cosa: le competenze tecniche. siccome lo Sviluppo di Android può essere fatto su un computer Mac, PC Windows o Linux. Avrete anche bisogno di un dispositivo Android (è possibile utilizzare un emulatore come Genymotion per lo sviluppo, ma alla fine ti consigliamo di provare su un dispositivo reale).

Ecco il breve elenco degli strumenti da conoscere (must-know skills) per diventare uno sviluppatore Android.

Java

L’elemento più fondamentale  per lo sviluppo con Android è il linguaggio di programmazione Java. Per essere un  sviluppatore Android di successo, è necessario stare bene con i concetti di Java come loop, liste, variabili e strutture di controllo.  Java è uno dei linguaggi di programmazione più utilizzati dagli sviluppatori di software di oggi, in modo cheimparare i suoi pro e  contro ci metterà in una buona posizione per trovare lavoro. (qualcuno dal mondo di sviluppo back-end?) Anche al di là della piattaforma Android.

SQL

Avrete anche bisogno di imparare le basi di SQL per gestire e organizzare i database all’interno delle applicazioni Android.   SQL è un linguaggio per esprimere le query (filtri chiamate) e cosi consultare e recuperare dati o informazioni dai database. Una volta imparate a scrivere (filtri e query), non ci saranno domande che non si possano chiedere ai tuoi database (dati).

SDK- Android Software Development Kit e Android Studio

Una delle parti migliori dello sviluppo per Android è che gli strumenti necessari sono gratuiti e facili da ottenere. L’SDK Android è disponibile per il download free-of-charge -gratis -, come lo è anche Android Studio, l’ambiente di sviluppo integrato ufficiale (IDE) per lo sviluppo di applicazioni Android.     Android Studio è il programma principale con cui gli sviluppatori a scrivere codice e assemblare le loro applicazioni da vari pacchetti e le librerie. L’Android SDK include codice di esempio, librerie software, utili strumenti di codifica, e molto di più per aiutarvi a costruire, testare, e debug-gare (mettere appunto)  le vostre applicazioni Android.

Un altro punto rilevante di sviluppare per Android è la facilità del processo di distribuzione (deploy)  delle app. Una volta che si è pronti per inviare la tua applicazione a Google Play Store, basta registrarsi con un account editore/sviluppatore – Google Play publisher account -(che include il pagamento di una tassa di 25 dollari tramite Google Wallet), seguire passo a passo tutte le voci della lista di lancio di Android (launch checklist), pubblicare la app attraverso il Developer Google Play Console, attendere la approvazione di Google, e vederla apparire. Semplice e soddisfacente.

XML

I programmatori usano XML per descrivere i dati. Le basi della sintassi XML sarà utile – a pieno titolo  – nel vostro viaggio  degli sviluppatori Android  per sviluppare diversi compiti, come la progettazione di interfaccie utente (UI), presentazione( layout) e analisi dei dati alimentati o provenienti da internet. Molto di ciò che è necessario per XML può essere fatto attraverso Android Studio, ma è costruttivo essere fondato nelle basi di questo linguaggio di markup.

Le Abilità o Competenze richieste (Hard Skills): Come imparare a dimostrare di averle

Per gli sviluppatori di Android abbondano  le resource (strumenti) per potere cosi affinare le proprie competenze e  condividere suggerimenti e migliori pratiche (best practice).    Alcuni preferiti del settore includono Stack OverflowAndroid Weekly, il  Android Dev subreddit, vogella tutorials, YouTube(lezioni di Youtube), e il sito ufficiale di  Google per gli sviluppatori Android Developers site—specialmente il Building Your First App modulo.    Se sei un allievo della carta stampata, ci sono del libri molto popolari di Android come  Head First Java, Android Programming (programmazione) : Pushing the Limits(superare i limiti), e Java: A Beginner’s Guide( Guida per principianti di Java.)

Quando si inizia a pensare ad attrarre delle nuove  opportunità di lavoro, e alla vendita (migliore presentazione)  di se stessi come validi candidati,  è importante prendere in considerazione di mettere in in mostra il proprio lavoro sviluppato su Android (apps) nei siti come suon LinkedInXing, attraverso un portfoglio – cartella di (app) personale online, o su siti come e BehanceGitHub.    Gomito a gomito, di persona o  in forma virtuale, incontrarsi con altri sviluppatori Android e con molteplici responsabili delle assunzioni o reclutatori tramite Meetup (incontri conferenze) , tali come droidcon, e concentratori di gruppi o reti digitali (hubs) come LinkedIn groups, Twitter chats, e Quora feeds (sviluppi e notizie). Lei non saprà mai cosa potrà imparare, o a chi potrà mai trovare ?

Le competenze e abilità trasversali (soft skills)

Come per qualsiasi lavoro, non è sufficiente essere completo o senza difetti a livello tecnico, devi fare in modo di affinare le proprie abilità interpersonali tanto quanto quelle di codifica (scrittura analisi di codice).

Perseveranza (e pazienza … a.d.t.)

La pratica rende perfetti davvero quando si parla di sviluppo delle applicazioni. Inevitabilmente, si troveranno dei posti di blocco o degli ostacoli nel processo di sviluppo, in particolare agli inizi dello stesso.  Avrete bisogno di un gran cumulo di perseveranza per poterlo utilizzare a dovere nei momenti frustranti. Per fortuna, dal momento che Android è open-source, cosi che gli sviluppatori di Android potranno  usufruire di librerie e di  framework – pieni di lavori condivisi (codice example)  creati e pubblicati su siti come GitHub.

Avere un atteggiamento Collaborativo

L’atteggiamento Collaborativo è una richiesta di vitale importanza, nella maggior parte dei lavori offerti agli sviluppatori.   Anche se si sta lavorando in un solo progetto, sarà inevitabile dovere lavorare  insieme con altre persone, tali come specialisti in grafica e design (grafici) , personale del marketing, o della alta direzione aziendale (top managers).  Inizia a prendere confidenza con l’accettare semplicemente (umilmente a.d.t)  i feedback (appunti, commenti, e/ o suggerimenti migliorativi) sul proprio lavoro, giungendo a compromessi  con i colleghi, e collaborando con gli altri partecipanti  del progetto per cosi  creare dei prodotti eccezionali.

Sete di conoscenza

Tutti i buoni sviluppatori, mobile e non, sono impegnati nella formazione continua e permanente. Soprattutto nel paesaggio del rapido sviluppo di applicazioni mobile:  con l’avvento di app indossabili, app TV, app per le auto, e altro ancora, gli sviluppatori mobile devono tenere gli occhi e le orecchie aperte alle nuove tecnologie e alle mutabilità continua delle “migliori pratiche”.   Non importa il  livello  raggiunto delle loro conoscenze,essi  non si fermano mai nello  indagare, esplorare, giocare attorno, e fare delle domande.

Sintesi (the bottom line)

Le mobile applicazioni hanno una richiesta altissima, oggi più che che mai, il che rende questo momento uno fra il più incredibile  per lanciare propria carriera come sviluppatore Android. Con l’allargamento Androidoltre lo spazio dei consumatori al lavoro e all’istruzione, e continua a spingere le frontiere i limiti consolidando ricche esperienze utente di tipo cross-device(attraverso molteplice dispositivi) con il nuovo Material design language, Sono tempi eccitanti (momento particolarmente emozionante)  per tuffarsi nello sviluppo di Android. Quindi, andare avanti, con i i piedi per prima. L’acqua è calda (tiepida a.d.t.!).

Molte grazie agli sviluppatori esperti per conto di Google: Enrique López-Mañas (eenriquelopez) ed Etienne Caron, e allo sviluppatore per conto di Udacity Eric Gonzalez per i loro contributi e commenti tecnici all’interno di questo articolo.

a.d.t. (annotazione del traduttore Carmen Vargas)

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

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

lista di collegamenti (links) sulle api (apis) per lo sviluppo app web e mobile

in questa pagina si presenta una lista con collegamenti internet per aiutare il lettore a conoscere meglio e più consapevolmente il  mondo delle API per lo sviluppo web e mobile.

appissue api mobile app italia
fonte immagini : http://www.businessinsider.com/the-best-social-networking-apps-for-iphone-android-and-windows-phone-2014-10?op=1&IR=T

ecco una anteprima

continua all’interno di questa pagina fonte http://www.programmableweb.com/