salve community,
è il mio primo post qui, ma seguo tantissimo i vostri consigli e tutorials. ho un'enorme problema, spero possiate aiutarmi poichè ne vale la tesi
vi spiego:
la mia esigenza è quella di poter inviare delle immagini dal mio dispositivo android ad un server.
Ho utilizzato il codice suggerito dal libro di testo di Massimo carli per quanto riguarda l'invio di file mime. Il pacchetto viene correttamente inviato, il problema risiede nel file JSP, come faccio a far memorizzare il file? inizialmente avevo utilizzato un file .jsp complesso, ma con risultati irrilevanti, dopodichè ho detto vado per gradi e sono partito dalla cosa più semplice: capire se il contenuto fosse effettivamente trasferito. Ecco il file .jsp creato:
<%@ page import="java.net.*"%>
<%@ page import="java.io.*" %>
<%
InputStream in=request.getInputStream();
byte[] ch=new byte[4048];
int len=0;
while((len=in.read(ch))>-1) {
out.write(new String(ch,0,len));
}
in.close();
%>Con questo script .jsp riesco esclusivamente a visualizzare sul mio dispositivo Android (attraverso un ResponseHandler) il contenuto del pacchetto MIME completo. L'immagine chiaramente restituisce una stringa (che suppongo sia la codifica testuale) . Questi i file lato Client (android):
Questo è il file SendFilehttprequest.java:
public class SendFileHttpClientTestActivity extends Activity {
private final static String LOG_TAG = "ThreadSafeHttpClientTestActivity";
private final static int WAITING_PROGRESS_DIALOG_ID = 1;
private final static String TARGET_URL ="http://10.0.2.2:8080/tesi/upload.jsp";
private Handler myHandler;
private ProgressDialog progressDialog;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
final TextView outputView = (TextView) findViewById(R.id.outputView);
myHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
outputView.setText(msg.obj.toString());
Log.i(LOG_TAG, msg.obj.toString());
}
};
}
public void sendHttpRequest(View button) {
Thread workerThread = new Thread(new Runnable() {
@Override
public void run() {
try {
CustomApplication ca = (CustomApplication)getApplication();
HttpClient httpClient = ca.getThreadSafeHttpClient();
HttpPost request = new HttpPost();
URI targetUri = new URI(TARGET_URL);
request.setURI(targetUri);
InputStream imageIS = getResources().openRawResource(R.drawable.hamburger);
//byte[] imageBytes = IOUtils.toByteArray(imageIS);
// Creiamo un oggetto di tipo InpuStreamBody che ci permette di
// inserire l'array di byte all'interno di un MultiPart
InputStreamBody imagePart = new InputStreamBody(imageIS,"imageToUpload");
// Creiamo una Entity di tipo MultiPart
MultipartEntity mpEntity = new MultipartEntity();
mpEntity.addPart("name", new StringBody("value1"));
mpEntity.addPart("imageToUpload", imagePart);
// Impostiamo l'entit‡ nella request
request.setEntity(mpEntity);
// A questo punto invochiamo il server
httpClient.execute(request, myResponseHandler);
} catch (Exception e) {
showMessageOnOutput(e.getMessage());
Log.e(LOG_TAG, e.getMessage());
} finally {
dismissDialog(WAITING_PROGRESS_DIALOG_ID);
}
}
});
// Visualizziamo una Dialog di attesa
showDialog(WAITING_PROGRESS_DIALOG_ID);
// Lo avviamo
workerThread.start();
}
@Override
protected Dialog onCreateDialog(int id) {
switch (id) {
case WAITING_PROGRESS_DIALOG_ID:
progressDialog = new ProgressDialog(this,
ProgressDialog.STYLE_SPINNER);
progressDialog.setTitle("HTTP Connection");
progressDialog.setMessage("Connecting...");
progressDialog.setIndeterminate(true);
return progressDialog;
default:
return null;
}
}
/**
* Invia un messaggio all'Handler relativo al MainThread per la sua
* visualizzazione nella TextView di output
*
* @param message
* Messaggio da visualizzare
*/
private void showMessageOnOutput(String message) {
Message messageToSend = myHandler.obtainMessage();
messageToSend.obj = message;
myHandler.sendMessage(messageToSend);
}
private final ResponseHandler<String> myResponseHandler = new ResponseHandler<String>() {
@Override
public String handleResponse(HttpResponse response)
throws ClientProtocolException, IOException {
// Estraiamo il risultato dalla risposta. Otteniamo quindi il content
// da cui leggere le informazioni
InputStream content = response.getEntity().getContent();
byte[] buffer = new byte[1024];
int numRead = 0;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while((numRead=content.read(buffer))!=-1){
baos.write(buffer, 0, numRead);
}
// Chiudiamo lo stream
content.close();
// Otteniamo il risultato
String result = new String(baos.toByteArray());
showMessageOnOutput(result);
return result;
}
};
}mentre questo è il file CustomApplication il quale imposta i parametri della connessione:
public class CustomApplication extends Application {
/*
* Tag del Log
*/
private final static String LOG_TAG = "CustomApplication";
/*
* Riferimento all'HttpClient
*/
private HttpClient httpClient;
@Override
public void onCreate() {
super.onCreate();
// Inizializziamo il riferimento all'HttpClient Thread Safe
httpClient = createHttpClient();
}
@Override
public void onLowMemory() {
super.onLowMemory();
Log.i(LOG_TAG,"Low Memory!!");
// Rilasciamo le risorse del client
releaseHttpClient();
}
@Override
public void onTerminate() {
super.onTerminate();
Log.i(LOG_TAG,"Terminate CustomApplication");
// Rilasciamo le risorse del client
releaseHttpClient();
}
/**
* @return Il riferimento all'HttpClient ThreadSafe
*/
public HttpClient getThreadSafeHttpClient(){
return httpClient;
}
/*
* Incapsula la logica di creazione del client
*/
private final HttpClient createHttpClient(){
// Per creare il corrispondente ThreadSafeClientConnManager abbiamo
// bisogno delle informazioni relative al tipo di protocollo che intendiamo
// gestire. Nel nostro caso definiamo il supporto per l'HTTP e l'HTTPS attraverso
// la definizione di alcuni parametri e schemi
HttpParams httpParams = new BasicHttpParams();
// Impostiamo la versione del protocollo HTTP alla 1.1
HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
// Impostiamo il charset di default
HttpProtocolParams.setContentCharset(httpParams, HTTP.DEFAULT_CONTENT_CHARSET);
// Dobbiamo quindi descrivere quelli che sono i protocolli che intendiamo
// gestire associando a ciascuno uno schema ed una Factory delle connessioni
// Socket da utilizzare
SchemeRegistry schemeRegistry = new SchemeRegistry();
// Gestiamo il protocollo HTTP nella porta 80
Scheme httpScheme = new Scheme("http",PlainSocketFactory.getSocketFactory(),80);
schemeRegistry.register(httpScheme);
// Gestiamo il protocollo HTTPS nella porta 443
Scheme httpsScheme = new Scheme("https",SSLSocketFactory.getSocketFactory(),443);
schemeRegistry.register(httpsScheme);
// Creiamo il ThreadSafeClientConnManager e lo assegnamo al client
ClientConnectionManager tsConnManager = new ThreadSafeClientConnManager(httpParams,schemeRegistry);
HttpClient tmpClient = new DefaultHttpClient(tsConnManager,httpParams);
// ritorniamo l'oggetto creato
Log.i(LOG_TAG,"HttpClient Created!");
return tmpClient;
}
/*
* Questo metodo permette di liberare le risorse occupate dal client ovvero
* le diverse connessioni utilizzate. Per questo motivo andiamo a chiudere
* le connessioni attraverso il ConnectionManager
*/
private final void releaseHttpClient(){
if(httpClient!=null && httpClient.getConnectionManager()!=null){
// Se esiste il ConnectionManager del client lo chiudiamo
httpClient.getConnectionManager().shutdown();
Log.i(LOG_TAG,"Releasing Connections");
}
}
}Qualcuno può darmi qualche guida su come memorizzare l'immagine sul server?Ho anche visto le librerie commons-fileUpload e commons-io messe a disposizione da apache tomcat ma senza ottenere risultati.
Vi prego sarò grato a chiunque mi dia una mano!!
Saluto
MF
