Autore Topic: Connessione SSL e passaggio dati  (Letto 829 volte)

Offline GhostEnd

  • Nuovo arrivato
  • *
  • Post: 17
  • Respect: 0
    • Mostra profilo
Connessione SSL e passaggio dati
« il: 07 Maggio 2015, 23:21:20 CEST »
0
Salve a tutti,
ho un app che contiene un login e dopo essersi loggati permette di fare numerose operazioni su un database (ad esempio condivisione di dati ecc,ecc,).
Ora ho 2 problemi, l'app deve garantire la sicurezza dei dati inviati al server e quindi è necessario implementare una connessione HTTPS.. Ora qualcuno sa come si imposta il mio certificato SSL (.pem) nei parametri di connessione? Fin'ora sono riuscito solo ad autorizzare tutti i certificati

Inoltre, è possibile salvare una variabile di sessione che mi permette di fare delle richieste alle pagine solo se risulto loggato?
ad esempio sul mio server risiede la pagina:    login.php
io vorrei che l'utente potesse accedere alle altre pagine (ad esempio connessione.php) solo se prima si è autenticato. perchè adesso mi affido solo al login di android quindi se uno esegue una richiesta ad una pagina senza effettuare il login (ovviamente inviando i dati in POST corretti) può eseguire modifiche sul database.

Offline bradipao

  • Moderatore globale
  • Utente storico
  • *****
  • Post: 4043
  • keep it simple
  • Respect: +567
    • Github
    • Google+
    • bradipao
    • Mostra profilo
  • Dispositivo Android:
    Nexus 5
  • Play Store ID:
    Bradipao
  • Sistema operativo:
    W7
Re:Connessione SSL e passaggio dati
« Risposta #1 il: 08 Maggio 2015, 08:01:13 CEST »
0
Per il primo problema temo di avere della lacune, perchè ho sempre pensato che il certificato SSL debba essere installato nel server, non nel client.

Per il secondo, se devi tracciare sessioni e login, devi abilitare i cookie del client.
NON rispondo a domande nei messaggi privati
Bradipao @ Play Store

Offline GhostEnd

  • Nuovo arrivato
  • *
  • Post: 17
  • Respect: 0
    • Mostra profilo
Re:Connessione SSL e passaggio dati
« Risposta #2 il: 08 Maggio 2015, 14:03:46 CEST »
0
Tranquillo in realtà sono io che ho delle lacune, però sono arrivato alla conclusioni che da android posso far accettare tutti i certificati alla connessione quindi autofirmati, non autofirmati o scaduti (che in teoria è un metodo non sicuro) oppure autorizzare solo la comunicazione con un certificato conosciuto (ad esempio solo il mio autofirmato), solo che mi sfugge come si possa far riconoscere il mio e non tutti.

Offline felasandroid

  • Utente normale
  • ***
  • Post: 345
  • Respect: +10
    • Github
    • balduzziantonio
    • balduzziantonio.unifi
    • Mostra profilo
  • Dispositivo Android:
    Huawei P8 Lite
  • Play Store ID:
    FelasTech
  • Sistema operativo:
    Windows 10
Re:Connessione SSL e passaggio dati
« Risposta #3 il: 09 Maggio 2015, 09:04:14 CEST »
0
Ciao allora prima di tutto il server deve avere il suo certificato (almeno questo è di norma), così la app (e l'utente) sa che contatta un server sicuro. Per una maggiore sicurezza puoi far verificare al server che il client sia quello giusto attraverso un certificato, si ha quindi il Mutual SSL/TLS Authentication.
Ti spiego a grandi linee il procedimento.
Supponiamo tu abbia un certificato (non autofirmato) per il tuo server (necessario per la connessione HTTPS) che hai messo in un keystore.

1) Si crea un certificato autofimato per il client (la app) questo verrà messo in un keystore:

Creo la chiave:
Codice: [Seleziona]
openssl genrsa -des3 -out client_key.pem 2048Creo il certificato di durata 365 gg:
Codice: [Seleziona]
openssl req -new -x509 -key client_key.pem -out client.pem -days 365
Ora grazie al tool KeyExplorer : http://keystore-explorer.sourceforge.net/ posso combinare i due e creare un keystore per il client (mi raccomando in BKS)

2) Il passo successivo è quello di crearsi il truststore per il client, lo creo sempre col tool prima citato e gli inserisco il certificato del server

3) devo fare anche un truststore per il server dove inserire il certificato autofirmato del client

Ora abbiamo un keystore e truststore sia per il client che per il server.
Passiamo ora alla "ciccia" del problema:

4)Creare la connessione HTTPS con una custom SSLSocket utilizzando il framework Volley (si può importare con gradle):

Il mio consiglio è utilizzare questo stupendo framework che ti permette di fare tutto e non è così complicato. Serve anche importare la libreria:

Codice: [Seleziona]
compile files('libs/khandroid-httpclient-4.2.3.jar')
Prima creao una classe che mi estende il DefaultHttpClient, in questo modo (alcuni costruttori si possono anche togliere):


Codice (Java): [Seleziona]
public class SslHttpClient extends DefaultHttpClient {
    private static final int HTTP_DEFAULT_PORT = 80;
    private static final String HTTP_SCHEME = "http";
    private static final int HTTP_DEFAULT_HTTPS_PORT = 443;
    private static final String HTTP_SSL_SCHEME = "https";

    private InputStream mTrustKeyStore;
    private InputStream mKeyStore;

    private String mKeyStorePassword;
    private int mHttpsPort;


    public SslHttpClient(InputStream keyStore, String keyStorePassword) {
        mTrustKeyStore = keyStore;
        mKeyStorePassword = keyStorePassword;
        mHttpsPort = HTTP_DEFAULT_HTTPS_PORT;
    }


    public SslHttpClient(InputStream TrustKeyStore, String keyStorePassword, int httpPort, InputStream keyStore) {
        mTrustKeyStore = TrustKeyStore;
        mKeyStore = keyStore;
        mKeyStorePassword = keyStorePassword;
        mHttpsPort = httpPort;
    }

    public SslHttpClient(InputStream TrustKeyStore, String keyStorePassword, int httpPort) {
        mTrustKeyStore = TrustKeyStore;
        mKeyStorePassword = keyStorePassword;
        mHttpsPort = httpPort;
        mKeyStore =null;
    }


    public SslHttpClient(ClientConnectionManager conman,
            InputStream keyStore,
            String keyStorePassword) {
        super(conman);
        mTrustKeyStore = keyStore;
        mKeyStorePassword = keyStorePassword;
    }


    public SslHttpClient(final ClientConnectionManager conman,
                         final HttpParams params,
                         InputStream keyStore,
                         String keyStorePassword) {
        super(conman, checkForInvalidParams(params));
        this.mTrustKeyStore = keyStore;
        this.mKeyStorePassword = keyStorePassword;
    }



    public SslHttpClient(final HttpParams params, InputStream keyStore, String keyStorePassword) {
        super(null, checkForInvalidParams(params));
        this.mTrustKeyStore = keyStore;
        this.mKeyStorePassword = keyStorePassword;
    }


    @SuppressWarnings("deprecation")
    // we check intentionally for an old parameter
    private static HttpParams checkForInvalidParams(HttpParams params) {
        String className = (String) params
                .getParameter(ClientPNames.CONNECTION_MANAGER_FACTORY_CLASS_NAME);
        if (className != null) {
            throw new IllegalArgumentException("Don't try to pass ClientPNames.CONNECTION_MANAGER_FACTORY_CLASS_NAME parameter. We use our own connection manager factory anyway...");
        }

        return params;
    }


    @Override
    protected ClientConnectionManager createClientConnectionManager() {
        SchemeRegistry registry = new SchemeRegistry();

        PlainSocketFactory pfs = PlainSocketFactory.getSocketFactory();

        Scheme s = new Scheme(HTTP_SCHEME, HTTP_DEFAULT_PORT, pfs);
        registry.register(s);

        PoolingClientConnectionManager ret;
        try {


            registry.register(new Scheme(HTTP_SSL_SCHEME, mHttpsPort, new SslSocketFactory(mTrustKeyStore, mKeyStorePassword,mKeyStore)));


            ret = new PoolingClientConnectionManager(registry);
        } catch (GeneralSecurityException e) {
            throw new IllegalStateException(e);
        }

        return ret;
    }


    public void setHttpsPort(int httpsPort) {
        mHttpsPort = httpsPort;
    }
}

Poi creiamo la SSLSocket personalizzata:

Codice (Java): [Seleziona]
class SslSocketFactory extends SSLSocketFactory {

    private static KeyManager[] mKeyManager;

    public SslSocketFactory(InputStream mTrustKeyStore, String keyStorePassword, InputStream keyStore) throws GeneralSecurityException {
        super(createSSLContext(mTrustKeyStore, keyStorePassword,keyStore), STRICT_HOSTNAME_VERIFIER);


    }


    private static SSLContext createSSLContext(InputStream mTrustKeyStore, String keyStorePassword,InputStream keyStore) throws GeneralSecurityException {
        SSLContext sslcontext = null;
        KeyStore key =null;
        try {

            if (keyStore!=null){

            key = KeyStore.getInstance("BKS");
            key.load(keyStore, keyStorePassword.toCharArray());
            KeyManagerFactory kmf = KeyManagerFactory
                    .getInstance(KeyManagerFactory.getDefaultAlgorithm());
            kmf.init(key, keyStorePassword.toCharArray());
            mKeyManager = kmf.getKeyManagers();

            }
            else{

            mKeyManager = null;

            }



          sslcontext = SSLContext.getInstance("TLS");


            sslcontext.init(mKeyManager, new TrustManager[] { new SsX509TrustManager(mTrustKeyStore, keyStorePassword) }, null);
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException("Failure initializing default SSL context", e);
        } catch (KeyManagementException e) {
            throw new IllegalStateException("Failure initializing default SSL context", e);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return sslcontext;
    }
}    

e la SsX509TrustManager:

Codice (Java): [Seleziona]
public class SsX509TrustManager implements javax.net.ssl.X509TrustManager {

    private ArrayList<X509TrustManager> mX509TrustManagers = new ArrayList<X509TrustManager>();


    protected SsX509TrustManager(InputStream keyStore, String keyStorePassword) throws GeneralSecurityException {
        // first add original trust manager
        final TrustManagerFactory originalFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
        originalFactory.init((KeyStore) null);
        for( TrustManager tm : originalFactory.getTrustManagers() ) {
            if (tm instanceof X509TrustManager) {
                mX509TrustManagers.add( (X509TrustManager)tm );
            }
        }


        // them add our custom trust manager
        X509TrustManager mX509TrustManagerCustom = fetchTrustManager(keyStore, keyStorePassword);
        if (mX509TrustManagerCustom != null) {
            mX509TrustManagers.add(mX509TrustManagerCustom);
        } else {
            throw new IllegalArgumentException("Keystore is valid but cannot find TrustManagerFactory of type X509TrustManager.");
        }
    }


    private javax.net.ssl.X509TrustManager fetchTrustManager(InputStream keyStore, String keyStorePassword) throws GeneralSecurityException {
        javax.net.ssl.X509TrustManager ret = null;

        TrustManagerFactory tmf = prepareTrustManagerFactory(keyStore, keyStorePassword);
        TrustManager tms[] = tmf.getTrustManagers();

        for (int i = 0; i < tms.length; i++) {
            if (tms[i] instanceof javax.net.ssl.X509TrustManager) {
                ret = (javax.net.ssl.X509TrustManager) tms[i];
//              break;
            }
        }
       
        return ret;
    }


    private TrustManagerFactory prepareTrustManagerFactory(InputStream keyStore, String keyStorePassword) throws GeneralSecurityException {
        TrustManagerFactory ret = null;
       
        KeyStore ks;
        ks = KeyStore.getInstance("BKS");
        try {
            ks.load(keyStore, keyStorePassword.toCharArray());
        } catch (IOException e) {
            throw new GeneralSecurityException("Problem reading keystore stream", e);
        }
        ret = TrustManagerFactory.getInstance("X509");
        ret.init(ks);
       
        return ret;
    }


    @Override
    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {


    }


    @Override
    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        boolean ok = false;
        for( X509TrustManager tm : mX509TrustManagers ) {
            try {
                tm.checkServerTrusted(chain,authType);
                ok = true;
                break;
            } catch( CertificateException e ) {
                // ignore
            }
        }
        if (!ok) {
            throw new CertificateException();
        }
    }

   
    @Override
    public X509Certificate[] getAcceptedIssuers() {
        final ArrayList<X509Certificate> list = new ArrayList<X509Certificate>();
        for( X509TrustManager tm : mX509TrustManagers )
            list.addAll(Arrays.asList(tm.getAcceptedIssuers()));
        return list.toArray(new X509Certificate[list.size()]);
    }

}

Ultima classe che ci serve è quella che estende HttpStack:

Codice (Java): [Seleziona]
public class ExtHttpClientStack implements HttpStack {
    protected final HttpClient mClient;

    private final static String HEADER_CONTENT_TYPE = "Content-Type";


    public ExtHttpClientStack(HttpClient client) {
        mClient = client;
    }


    private static void addHeaders(HttpUriRequest httpRequest, Map<String, String> headers) {
        for (String key : headers.keySet()) {
            httpRequest.setHeader(key, headers.get(key));
        }
    }


    @SuppressWarnings("unused")
    private static List<NameValuePair> getPostParameterPairs(Map<String, String> postParams) {
        List<NameValuePair> result = new ArrayList<NameValuePair>(postParams.size());
        for (String key : postParams.keySet()) {
            result.add(new BasicNameValuePair(key, postParams.get(key)));
        }
        return result;
    }


    @Override
    public org.apache.http.HttpResponse performRequest(Request<?> request,
                                                       Map<String, String> additionalHeaders)
           throws IOException, AuthFailureError {
       
        HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);
        addHeaders(httpRequest, additionalHeaders);
        addHeaders(httpRequest, request.getHeaders());
        onPrepareRequest(httpRequest);
        HttpParams httpParams = httpRequest.getParams();
        int timeoutMs = request.getTimeoutMs();
        // TODO: Reevaluate this connection timeout based on more wide-scale
        // data collection and possibly different for wifi vs. 3G.
        HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
        HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);

        HttpResponse resp = mClient.execute(httpRequest);

        return convertResponseNewToOld(resp);
    }


    private org.apache.http.HttpResponse convertResponseNewToOld(HttpResponse resp)
            throws IllegalStateException, IOException {
       
        ProtocolVersion protocolVersion = new ProtocolVersion(resp.getProtocolVersion()
                .getProtocol(),
                                                              resp.getProtocolVersion().getMajor(),
                                                              resp.getProtocolVersion().getMinor());

        StatusLine responseStatus = new BasicStatusLine(protocolVersion,
                                                        resp.getStatusLine().getStatusCode(),
                                                        resp.getStatusLine().getReasonPhrase());

        BasicHttpResponse response = new BasicHttpResponse(responseStatus);
        org.apache.http.HttpEntity ent = convertEntityNewToOld(resp.getEntity());
        response.setEntity(ent);

        for (Header h : resp.getAllHeaders()) {
            org.apache.http.Header header = convertheaderNewToOld(h);
            response.addHeader(header);
        }

        return response;
    }


    private org.apache.http.HttpEntity convertEntityNewToOld(HttpEntity ent)
            throws IllegalStateException, IOException {
       
        BasicHttpEntity ret = new BasicHttpEntity();
        if (ent != null) {
            ret.setContent(ent.getContent());
            ret.setContentLength(ent.getContentLength());
            Header h;
            h = ent.getContentEncoding();
            if (h != null) {
                ret.setContentEncoding(convertheaderNewToOld(h));
            }
            h = ent.getContentType();
            if (h != null) {
                ret.setContentType(convertheaderNewToOld(h));
            }
        }

        return ret;
    }


    private org.apache.http.Header convertheaderNewToOld(Header header) {
        org.apache.http.Header ret = new BasicHeader(header.getName(), header.getValue());
        return ret;
    }


    /**
     * Creates the appropriate subclass of HttpUriRequest for passed in request.
     */

    @SuppressWarnings("deprecation")
    /* protected */static HttpUriRequest createHttpRequest(Request<?> request,
                                                           Map<String, String> additionalHeaders)
                           throws AuthFailureError {
        switch (request.getMethod()) {
            case Method.DEPRECATED_GET_OR_POST: {
                // This is the deprecated way that needs to be handled for backwards compatibility.
                // If the request's post body is null, then the assumption is that the request is
                // GET.  Otherwise, it is assumed that the request is a POST.
                byte[] postBody = request.getPostBody();
                if (postBody != null) {
                    HttpPost postRequest = new HttpPost(request.getUrl());
                    postRequest.addHeader(HEADER_CONTENT_TYPE, request.getPostBodyContentType());
                    HttpEntity entity;
                    entity = new ByteArrayEntity(postBody);
                    postRequest.setEntity(entity);
                    return postRequest;
                } else {
                    return new HttpGet(request.getUrl());
                }
            }
            case Method.GET:
                return new HttpGet(request.getUrl());
            case Method.DELETE:
                return new HttpDelete(request.getUrl());
            case Method.POST: {
                HttpPost postRequest = new HttpPost(request.getUrl());
                postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(postRequest, request);
                return postRequest;
            }
            case Method.PUT: {
                HttpPut putRequest = new HttpPut(request.getUrl());
                putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
                setEntityIfNonEmptyBody(putRequest, request);
                return putRequest;
            }
            default:
                throw new IllegalStateException("Unknown request method.");
        }
    }


    private static void setEntityIfNonEmptyBody(HttpEntityEnclosingRequestBase httpRequest,
                                                Request<?> request) throws AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            HttpEntity entity = new ByteArrayEntity(body);
            httpRequest.setEntity(entity);
        }
    }


    /**
     * Called before the request is executed using the underlying HttpClient.
     *
     * <p>
     * Overwrite in subclasses to augment the request.
     * </p>
     */

    protected void onPrepareRequest(HttpUriRequest request) throws IOException {
        // Nothing.
    }
}

Ci siamo quasi, ora c'è da configurare Volley e siamo apposto.
Prima di tutto devi inserire nella cartella /res/raw il keystore e truststore del client.
Io consiglio di crearsi un AppController che estenda Application così da avere un unico punto di gestione network:
Codice (Java): [Seleziona]
public class ApplicationController extends Application {


    private ProgressDialog progressDialog;

    /**
     * Log or request TAG
     */

    public static final String TAG = "VolleyPatterns";

    public static final String TAG_APPLICATION = "Activity AppController";

    /**
     * Global request queue for Volley
     */

    private RequestQueue mRequestQueue;

    private static String mUrlRestWS;
    private static String mPass = "passstore2015";

    /**
     * A singleton instance of the application class for easy access in other places
     */

    private static ApplicationController sInstance;

    @Override
    public void onCreate() {
        super.onCreate();

        mUrlRestWS = getString(R.string.path_server);
        // initialize the singleton
        sInstance = this;
    }

    /**
     * @return ApplicationController singleton instance
     */

    public static synchronized ApplicationController getInstance() {
        return sInstance;
    }

    /**
     * @return The Volley Request queue, the queue will be created if it is null
     */

    public RequestQueue getRequestQueue() {
        // lazy initialize the request queue, the queue instance will be
        // created when it is accessed for the first time
        if (mRequestQueue == null) {


            // Replace R.raw.clienttruststore with your trust keystore in this import server cert
            // va bene sia per local che per remoto
            InputStream trustKeyStore = getResources().openRawResource(R.raw.clienttruststore);

            // Replace R.raw.client with your client keystore
            InputStream keyStore = getResources().openRawResource(R.raw.clientkeystore);

            mRequestQueue = Volley.newRequestQueue(getApplicationContext(),
                    new ExtHttpClientStack(new SslHttpClient(trustKeyStore, mPass, 443, keyStore)));

            Log.d(TAG_APPLICATION, "Creata un'instanza di Request");
        }

        return mRequestQueue;
    }

    public static String getmUrlRestWS() {
        return mUrlRestWS;
    }

    /**
     * Adds the specified request to the global queue, if tag is specified
     * then it is used else Default TAG is used.
     *
     * @param req
     * @param tag
     */

    public <T> void addToRequestQueue(Request<T> req, String tag) {
        // set the default tag if tag is empty
        req.setTag(TextUtils.isEmpty(tag) ? TAG : tag);

        Log.d(TAG_APPLICATION , req.getUrl());
        getRequestQueue().add(req);


    }
    /**
     * Adds the specified request to the global queue using the Default TAG.
     *
     * @param req
     */

    public <T> void addToRequestQueue(Request<T> req) {
        // set the default tag if tag is empty
        req.setTag(TAG);

        getRequestQueue().add(req);
    }
    /**
     * Cancels all pending requests by the specified TAG, it is important
     * to specify a TAG so that the pending/ongoing requests can be cancelled.
     *
     * @param tag
     */

    public void cancelPendingRequests(Object tag) {
        if (mRequestQueue != null) {

            Log.d(TAG_APPLICATION, " Cancello richieste");
            mRequestQueue.cancelAll(tag);
        }
    }


    public void showProgressBar(Activity act) {


        progressDialog = new ProgressDialog(act);
        progressDialog.setMessage(getResources().getString(R.string.progress_bar_title));
        progressDialog.setCancelable(false);
        progressDialog.show();



    }

    public void dismissProgressBar() {

        progressDialog.dismiss();
    }
}

Ci creiamo anche una classe per gestire gli eventuali errori di rete:

Codice (Java): [Seleziona]
public class VolleyErrorHelper {



    public static final String TAG_Volley_Error_Helper = "VolleyErrorHelper";


    /**
     * Returns appropriate message which is to be displayed to the user
     * against the specified error object.
     *
     * @param error
     * @param context
     * @return
     */

    public static String getMessage(Object error, Context context) {
        if (error instanceof TimeoutError) {

            Log.d(TAG_Volley_Error_Helper,context.getResources().getString(R.string.generic_server_down));
            Log.d(TAG_Volley_Error_Helper,error.toString());


            return context.getResources().getString(R.string.generic_server_down);
        }
        else if (isServerProblem(error)) {

            return handleServerError(error, context);
        }
        else if (isNetworkProblem(error)) {


            Log.d(TAG_Volley_Error_Helper,context.getResources().getString(R.string.no_internet));

            Log.d(TAG_Volley_Error_Helper,error.toString());
            return context.getResources().getString(R.string.no_internet);
        }

        Log.d(TAG_Volley_Error_Helper,context.getResources().getString(R.string.generic_error));
        Log.d(TAG_Volley_Error_Helper,error.toString());


        return context.getResources().getString(R.string.generic_error);
    }

    /**
     * Determines whether the error is related to network
     * @param error
     * @return
     */

    private static boolean isNetworkProblem(Object error) {
        return (error instanceof NetworkError) || (error instanceof NoConnectionError);
    }
    /**
     * Determines whether the error is related to server
     * @param error
     * @return
     */

    private static boolean isServerProblem(Object error) {
        return (error instanceof ServerError) || (error instanceof AuthFailureError);
    }
    /**
     * Handles the server error, tries to determine whether to show a stock message or to
     * show a message retrieved from the server.
     *
     * @param err
     * @param context
     * @return
     */

    private static String handleServerError(Object err, Context context) {
        VolleyError error = (VolleyError) err;

        NetworkResponse response = error.networkResponse;

        if (response != null) {
            switch (response.statusCode) {
                case 404:
                    return context.getResources().getString(R.string.generic_server_down);
                case 422:
                case 401:
                    try {
                        // server might return error like this { "error": "Some error occured" }
                        // Use "Gson" to parse the result
                        HashMap<String, String> result = new Gson().fromJson(new String(response.data),
                                new TypeToken<Map<String, String>>() {
                                }.getType());

                        if (result != null && result.containsKey("error")) {
                            Log.d(TAG_Volley_Error_Helper,"404 o 422 o 401");
                            Log.d(TAG_Volley_Error_Helper,error.toString());


                            return result.get("error");
                        }

                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // invalid request
                    return error.getMessage();

                default:
                    Log.d(TAG_Volley_Error_Helper,context.getResources().getString(R.string.generic_server_down));
                    Log.d(TAG_Volley_Error_Helper,error.toString());


                    return context.getResources().getString(R.string.generic_server_down);
            }
        }
        Log.d(TAG_Volley_Error_Helper,context.getResources().getString(R.string.generic_error));
        Log.d(TAG_Volley_Error_Helper,error.toString());


        return context.getResources().getString(R.string.generic_error);
    }
}

Ora supponiamo di fare una richiesta passando come parametri un oggetto JSON e ottenere di risposta sempre un oggetto JSON (si può fare anche semplicemente GET e ottenere una stringa di risposta), per fare la richieste basta fare in :

Codice (Java): [Seleziona]
JsonObjectRequest mRequest = new JsonObjectRequest(
                mUrl,  new JSONObject(params),
                createMyReqSuccessListener(),
                createMyReqErrorListener()) {
           
        };

        //Imposto il TimeOut 20 secondi
        mRequest.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));


        ApplicationController.getInstance().addToRequestQueue(mRequest, "call API");
        ApplicationController.getInstance().showProgressBar(Activity.this);

private Response.Listener<JSONObject> createMyReqSuccessListener() {
        return new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {

               //TODO quello che vuoi fare con la risposta

                ApplicationController.getInstance().dismissProgressBar();


            }
        };
    }

    private Response.ErrorListener createMyReqErrorListener() {
        return new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {

                VolleyErrorHelper.getMessage(error, Activity.this);
                ApplicationController.getInstance().dismissProgressBar();


            }
        };
    }

Se può essere utile posso postarlo tra i tutorial fatemi sapere
« Ultima modifica: 09 Maggio 2015, 13:46:04 CEST da felasandroid »

Offline GhostEnd

  • Nuovo arrivato
  • *
  • Post: 17
  • Respect: 0
    • Mostra profilo
Re:Connessione SSL e passaggio dati
« Risposta #4 il: 10 Maggio 2015, 01:16:09 CEST »
0
Grazie del tutorial molto completo, appena mi si propagano i dns del dominio e compro il certificato (non autofirmato) provo e vediamo cosa ne esce.
Per la questione login e accesso alle altre pagine del sito, l'unica soluzione è salvare i cookie? Se io inviassi in tutte le richieste post username e password a tutte le pagine in modo da riautenticarmi sarebbe una una pazzia vero? Avrei una perdita in termini di prestazioni del server che deve ogni volta effettuare un accesso al database per controllare se l'utente esiste o no?

Offline ciopper90

  • Utente junior
  • **
  • Post: 106
  • Respect: +4
    • Mostra profilo
Re:Connessione SSL e passaggio dati
« Risposta #5 il: 10 Maggio 2015, 08:48:40 CEST »
0
Si può verificare lato client un certificato SSL auto firmato. La guida non me la ricordo ma a grandi linee deve essere come quella sopra.

Effettuare il login ogni operazione non è una cosa intelligente. Rimane sicuramente molto più comodo effettuare un login e utilizzare i cookie della sessione.

Offline GhostEnd

  • Nuovo arrivato
  • *
  • Post: 17
  • Respect: 0
    • Mostra profilo
Re:Connessione SSL e passaggio dati
« Risposta #6 il: 10 Maggio 2015, 12:00:16 CEST »
0
E' disponibile qualche guida aggiornata su come usare i cookie di sessione in android?

Offline ciopper90

  • Utente junior
  • **
  • Post: 106
  • Respect: +4
    • Mostra profilo
Re:Connessione SSL e passaggio dati
« Risposta #7 il: 10 Maggio 2015, 15:55:17 CEST »
0
Questo non lo so perche io l'ho non li ho direttamente usati. Ma credo che basti modificare la parte web. Di default vengono mantenuti in molti casi