¿HttpGet maneja las cookies automáticamente?

Question

Me gustaría conservar una sesión mientras me conecto al servidor usando HttpGet y necesito entender cómo maneja las cookies.

El desarrollador del servidor dice que maneja todas las cookies por sí mismo. Uso la solicitud de HttpGet para acceder al servidor de la siguiente manera: InputStream isResponse = null;

HttpGet httpget = new HttpGet(strUrl); 
    HttpResponse response = mClient.execute(httpget); 

    HttpEntity entity = response.getEntity(); 
    isResponse = entity.getContent(); 
    responseBody = convertStreamToString(isResponse); 

    return responseBody; 

1. ¿Debo hacer algo más? ¿Pone la cookie en mi dispositivo automáticamente y el método HttpGet sabe usarla para mantener el ID de sesión usando la cookie?

2. ¿Cómo puedo verificar si la cookie existe en mi dispositivo, para saber si la sesión está "viva"?

3. En caso uso el siguiente código para obtener la cookie:

   CookieStore cookieStore = new BasicCookieStore(); 
   
   // Create local HTTP context 
   HttpContext localContext = new BasicHttpContext(); 
   // Bind custom cookie store to the local context 
   localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore); 
   
   HttpGet httpget = new HttpGet(strUrl); 
   HttpResponse response = mClient.execute(httpget,localContext); 
   

qué el HttpGet todavía maneja las galletas de la misma que antes?

1. Veo que DefaultHttpClient (mClient en el código anterior) tiene su propia CookieStore. ¿Cómo puedo guardar sus cookies y cargarlas la próxima vez que lo creo?

Answer 1

Entonces ... Después de craqueo mi cabeza durante horas e implementar mi propia primitiva CookieStore, encontré la implementación Android Asynchronous Http Client, que incluye una agradable PersistentCookieStore que funciona genial! Simplemente añade el frasco para mi proyecto y lo utilizaron como sigue:

PersistentCookieStore cookieStore = new PersistentCookieStore(context); 
DefaultHttpClient mClient = new DefaultHttpClient();  
mClient.setCookieStore(cookieStore); 

y eso es todo! Las cookies se guardan y reutilizan cuando la aplicación se abre de nuevo.

Gracias James Smith, donde quiera que estés. Hiciste feliz a al menos un hombre.

Si alguien interesado en mi propia implementación primitiva (que también funciona) aquí está:

package com.pinhassi.android.utilslib; 

import java.util.Date; 
import java.util.List; 

import org.apache.http.cookie.Cookie; 
import org.apache.http.impl.client.BasicCookieStore; 
import org.apache.http.impl.cookie.BasicClientCookie; 

import android.content.Context; 
import android.content.SharedPreferences; 
import android.content.SharedPreferences.Editor; 

public class MyPersistentCookieStore extends BasicCookieStore { 
private static final String COOKIES_LIST = "CookiesList"; 
private static final String COOKIES_NAMES = "CookiesNames"; 

private Context mContext; 
/** 
* 
*/ 
public MyPersistentCookieStore(Context context) { 
    super(); 
    mContext = context; 
    load(); 
} 

@Override 
public synchronized void clear(){ 
    super.clear(); 
    save(); 
} 

@Override 
public synchronized boolean clearExpired(Date date){ 
    boolean res = super.clearExpired(date); 
    save(); 
    return res; 
} 

@Override 
public synchronized void addCookie(Cookie cookie){ 
    super.addCookie(cookie); 
    save(); 
} 

@Override 
public synchronized void addCookies(Cookie[] cookie){ 
    super.addCookies(cookie); 
    save(); 
} 

public synchronized void save() 
{ 
    Editor editor = mContext.getSharedPreferences(COOKIES_LIST, Context.MODE_PRIVATE).edit(); 
    editor.clear(); 
    List <Cookie> cookies = this.getCookies(); 
    StringBuilder sb = new StringBuilder(); 
    for (Cookie cookie : cookies) 
    { 
     editor.putString(cookie.getName(),cookie.getValue()); 
     sb.append(cookie.getName()+";"); 
    } 
    editor.putString(COOKIES_NAMES,sb.toString()); 
    editor.commit(); 
} 

public synchronized void load() 
{ 
    SharedPreferences prefs = mContext.getSharedPreferences(COOKIES_LIST, Context.MODE_PRIVATE); 
    String [] cookies = prefs.getString(COOKIES_NAMES,"").split(";"); 
    for (String cookieName : cookies){ 
     String cookieValue = prefs.getString(cookieName, null); 
     if (cookieValue!=null) 
      super.addCookie(new BasicClientCookie(cookieName,cookieValue)); 
    } 

    } 

} 

Answer 2

No, las cookies no se gestionan automáticamente. Para guardar las cookies utilizan automáticamente BasicCookeStore

Más información sobre el uso está aquí: http://hc.apache.org/httpcomponents-client-ga/tutorial/html/statemgmt.html

Véase también esta respuesta: Android HttpClient persistent cookies

Answer 3

no he tenido que preocuparse por las cookies. Cuando creo mi DefaultHttpClient y hago el httpclient.execute(httpget); como here, el objeto almacena la sesión en él. Así que primero hago el inicio de sesión y luego puedo usar las funciones privadas de mi API. Si quiero cerrar la sesión, creo una nueva instancia de mi objeto DefaultHttpClient o llamo a la función de cierre de sesión.

lo tanto, en caso de que quiera utilizar la información de la cookie de utilizar el CookieStore, si no sólo tiene que utilizar una instancia singleton para mantener vivo el objeto DefaultHttpClient