Java 类java.net.CookieStore 实例源码

/**
 * @param cookiesHeader
 */
private static String updateWebkitResponseCookies(List<String> cookiesHeader, String requestUrl) {
    //write webkit cookie
    final CookieStore cookieStore = getCookieManager().getCookieStore();
    if (cookieStore != null && cookiesHeader != null) {

        StringBuffer cookie = new StringBuffer();
        for (String cookieHeader : cookiesHeader) {
            cookie.append(cookieHeader).append(";");
        }
        android.webkit.CookieManager cookieManager = android.webkit.CookieManager.getInstance();
        if (cookieManager != null && cookie.length() > 0) {
            String cookieStr = cookie.toString();
            LogUtil.d(TAG, "write-webkit", cookieStr);
            cookieManager.setCookie(requestUrl, cookieStr);
        }
    }
    return null;
}

/**
 * write net cookies
 *
 * @param cookiesHeader
 */
private static void updateNetResponseCookies(List<String> cookiesHeader) {
    //write net cookie
    final CookieStore cookieStore = getCookieManager().getCookieStore();
    if (cookieStore != null && cookiesHeader != null) {
        HttpCookie cookieStr = null;
        for (String cookieHeader : cookiesHeader) {
            if (cookieHeader != null) {
                List<HttpCookie> cookies = HttpCookie.parse(cookieHeader);
                if (cookies != null && cookies.size() > 0) {
                    cookieStr = cookies.get(0);
                    LogUtil.d(TAG, "write-net", cookieStr);
                    cookieStore.add(null, cookieStr);
                }
            }
        }
    }
}

/**
 * Finds the ref tag cookie associated with a project. Returns `null` if no cookie has yet been set.
 */
protected static @Nullable HttpCookie findRefTagCookieForProject(final @NonNull Project project,
  final @NonNull CookieManager cookieManager, final @NonNull SharedPreferences sharedPreferences) {

  final String cookieName = cookieNameForProject(project);

  // First try finding the cookie in the cookie store
  final CookieStore cookieStore = cookieManager.getCookieStore();
  for (final HttpCookie cookie : cookieStore.getCookies()) {
    if (cookieName.equals(cookie.getName())) {
      return cookie;
    }
  }

  // If we can't find it in the cookie store let's look in shared prefs
  final String cookieValue = sharedPreferences.getString(cookieName, null);
  if (cookieValue != null) {
    return buildCookieWithValueAndProject(cookieValue, project);
  }

  return null;
}

public static void syncWebViewCookies(@NonNull Context context, @NonNull CookieStore cookieStore) {
    CookieSyncManager.createInstance(context);
    CookieManager cookieManager = CookieManager.getInstance();
    cookieManager.setAcceptCookie(true);
    cookieManager.removeSessionCookie();
    cookieManager.removeAllCookie();

    List<URI> urls = cookieStore.getURIs();
    for (URI url : urls) {
        List<HttpCookie> cookies = cookieStore.get(url);
        for (HttpCookie cookie : cookies) {
            cookieManager.setCookie(url.toString(), cookie.toString());
        }

        L.w("Cookies", cookieManager.getCookie(url.toString()));
    }

    CookieSyncManager.getInstance().sync();
}

/**
 * Clear the local stored authorization data
 */
public void clearAuthorizationData() {
    preferences.accessToken.clear();
    preferences.idToken.clear();
    preferences.userIdentity.clear();
    if (BMSClient.getInstance() != null && BMSClient.getInstance().getCookieManager() != null) {
        CookieStore cookieStore = BMSClient.getInstance().getCookieManager().getCookieStore();
        if(cookieStore != null) {
            for (URI uri : cookieStore.getURIs()) {
                for (HttpCookie cookie : cookieStore.get(uri)) {
                    if (cookie.getName().equals(TAI_COOKIE_NAME)) {
                        cookieStore.remove(uri, cookie);
                    }
                }
            }
        }
    }
}

private void resetCookie() {
    settings.edit().remove(prefKey).apply();
    authCookie = "";
    try {
        /*
        This step is *required* for PNA, and nicety for other services. PNA won't let you
        log in if you're still holding on to a valid authcookie, so we clear them out.
         */
        URI loginURI = URI.create(url.getHost());
        CookieStore cookies = ((CookieManager) CookieHandler.getDefault()).getCookieStore();
        for (HttpCookie cookie : cookies.get(loginURI)) {
            cookies.remove(loginURI, cookie);
        }
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    }
    cookieHasBeenSet = false;
}

protected void setAuthCookieVal(String authCookie, String domain) {
    this.authCookie = authCookie;
    settings.edit().putString(prefKey, authCookie).apply();

    /*
    this is technically unnecessary if OkHttp handled the authentication, because it will
    have already set the cookies in the CookieHandler. It doesn't seem to cause any issues
    just to re-add the cookies, though
     */
    HttpCookie httpCookie = new HttpCookie(authCookieKey, authCookie);
    httpCookie.setDomain(domain);
    try {
        CookieStore cookies = ((CookieManager) CookieHandler.getDefault()).getCookieStore();
        cookies.add(URI.create(domain), httpCookie);
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    }
    cookieHasBeenSet = true;
    android.webkit.CookieManager.getInstance().setCookie(domain, httpCookie.getName() + "=" + httpCookie.getValue());
    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP) {
        android.webkit.CookieManager.getInstance().flush();
    } else {
        CookieSyncManager.getInstance().sync();
    }
}

@Test
public void shouldAddCookieToSharedPreferences() throws URISyntaxException {
    URI uri = URI.create("http://google.com");
    CookieStore store = new CookieTray(preferences);
    HttpCookie httpCookie = new HttpCookie("name", "value");
    store.add(uri, httpCookie);
    String cookieVal = new SerializableCookie(httpCookie).asString();
    verify(editor).putString(uri.toString() + "|" + httpCookie.getName(), cookieVal);
}

@Test
public void shouldBeAbleToRemoveCookie() {
    addCookies(1, false);
    CookieStore store = new CookieTray(preferences);
    store.remove(URI.create("http://google.com/home0"), new HttpCookie("name0", "value0"));
    verify(editor).remove("http://google.com/home0|name0");
}

@Test
public void shouldBeAbleToRemoveAllCookies() {
    doReturn(editor).when(editor).clear();
    CookieStore store = new CookieTray(preferences);
    store.removeAll();
    verify(editor).clear();
    assertTrue("No cookies should be present after removing", store.getCookies().isEmpty());
}

/**
 * clear net cookies
 */
public static void clearNetCookies() {
    java.net.CookieManager cookieManager = getCookieManager();
    CookieStore cookieStore = cookieManager.getCookieStore();
    if (cookieStore != null) {
        cookieStore.removeAll();
    }
}

/**
 * net cookies
 */
private static String getNetRequestCookies() {
    final CookieStore cookieStore = getCookieManager().getCookieStore();
    //net cookie
    if (cookieStore != null) {
        final List<HttpCookie> cookies = cookieStore.getCookies();
        if (cookies != null && cookies.size() > 0) {
            //While joining the Cookies, use ',' or ';' as needed. Most of the server are using ';'
            final String netCookie = TextUtils.join(";", cookies);
            LogUtil.d(TAG, "get-net", netCookie);
            return netCookie;
        }
    }
    return null;
}

private void getUinAndPsessionid()
        throws InterruptedException, ExecutionException, TimeoutException, URISyntaxException {
    LOGGER.debug("开始获取uin和psessionid");

    {
        CookieStore cookieStore = httpClient.getCookieStore();
        cookieStore.add(new URI("qq.com"), new HttpCookie("pgv_info", "ssid=s" + RandomUtil.numberString(10)));
        cookieStore.add(new URI("qq.com"), new HttpCookie("pgv_pvid", RandomUtil.numberString(10)));
        httpClient
                .newRequest(
                        "https://ui.ptlogin2.qq.com/cgi-bin/login?daid=164&target=self&style=16&mibao_css=m_webqq&appid=501004106&enable_qlogin=0&no_verifyimg=1&s_url=http%3A%2F%2Fw.qq.com%2Fproxy.html&f_url=loginerroralert&strong_login=1&login_state=10&t=20131024001")
                .method(HttpMethod.GET).agent(ApiURL.USER_AGENT).header("Referer", "http://w.qq.com/")
                .header("Upgrade-Insecure-Requests", "1").send();
    }

    httpClient.newRequest("http://d1.web2.qq.com/proxy.html?v=20151105001&callback=1&id=2").method(HttpMethod.GET)
            .agent(ApiURL.USER_AGENT).header("Referer", "http://w.qq.com/").header("Upgrade-Insecure-Requests", "1")
            .send();

    JsonObject r = new JsonObject();
    r.addProperty("ptwebqq", ptwebqq);
    r.addProperty("clientid", Client_ID);
    r.addProperty("psessionid", "");
    r.addProperty("status", "online");

    ContentResponse response = post(ApiURL.GET_UIN_AND_PSESSIONID, r);
    JsonObject result = getJsonObjectResult(response);
    this.psessionid = result.get("psessionid").getAsString();
    this.uin = result.get("uin").getAsLong();
    this.selfUserStatus = result.get("status").getAsString();
}

public static void writeTo(
        @NotNull CookieStore store,
        @NotNull OutputStream stream
) throws IOException {
    HashMap<URI, List<SerializableHttpCookie>> cookieMap =
            new HashMap<URI, List<SerializableHttpCookie>>();

    List<URI> uris = store.getURIs();
    for (URI uri : uris) {
        List<HttpCookie> cookies = store.get(uri);
        List<SerializableHttpCookie> serializableHttpCookies =
                new ArrayList<SerializableHttpCookie>(cookies.size());
        for (HttpCookie cookie : cookies) {
            serializableHttpCookies.add(SerializableHttpCookie.of(cookie));
        }
        cookieMap.put(uri, serializableHttpCookies);
    }

    ByteArrayOutputStream os = new ByteArrayOutputStream();
    ObjectOutputStream oos = null;
    try {
        oos = new ObjectOutputStream(os);
        oos.writeObject(cookieMap);
        oos.flush();
        stream.write(os.toByteArray());
    } finally {
        IOUtils.closeQuietly(os);
        IOUtils.closeQuietly(oos);
    }
}

@SuppressWarnings("unchecked")
public static void readFrom(
        @NotNull CookieStore store,
        @NotNull InputStream stream
) throws IOException {
    HashMap<URI, List<SerializableHttpCookie>> cookieMap = null;

    ByteArrayInputStream is = new ByteArrayInputStream(IOUtils.toByteArray(stream));
    ObjectInputStream ois = null;
    try {
        ois = new ObjectInputStream(is);
        Object object = ois.readObject();
        if (object instanceof HashMap) {
            cookieMap = (HashMap<URI, List<SerializableHttpCookie>>) object;
        }
    } catch (ClassNotFoundException e) {
        throw new IllegalStateException(e);
    } finally {
        IOUtils.closeQuietly(is);
        IOUtils.closeQuietly(ois);
    }

    if (cookieMap == null) return;

    for (URI uri : cookieMap.keySet()) {
        List<SerializableHttpCookie> cookies = cookieMap.get(uri);
        for (SerializableHttpCookie cookie : cookies) {
            store.add(uri, cookie.toHttpCookie());
        }
    }

}

static void checkCookieNullUri() throws Exception {
    //get a cookie store implementation and add a cookie to the store with null URI
    CookieStore cookieStore = (new CookieManager()).getCookieStore();
    //Check if removeAll() retrurns false on an empty CookieStore
    if (cookieStore.removeAll()) {
        fail = true;
    }
    checkFail("removeAll on empty store should return false");
    HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
    cookie.setDomain("foo.com");
    cookieStore.add(null, cookie);

    //Retrieve added cookie
    URI uri = new URI("http://foo.com");
    List<HttpCookie> addedCookieList = cookieStore.get(uri);

    //Verify CookieStore behaves well
    if (addedCookieList.size() != 1) {
       fail = true;
    }
    checkFail("Abnormal size of cookie jar");

    for (HttpCookie chip : addedCookieList) {
        if (!chip.equals(cookie)) {
             fail = true;
        }
    }
    checkFail("Cookie not retrieved from Cookie Jar");
    boolean ret = cookieStore.remove(null,cookie);
    if (!ret) {
        fail = true;
    }
    checkFail("Abnormal removal behaviour from Cookie Jar");
}

static void checkCookieNullUri() throws Exception {
    //get a cookie store implementation and add a cookie to the store with null URI
    CookieStore cookieStore = (new CookieManager()).getCookieStore();
    //Check if removeAll() retrurns false on an empty CookieStore
    if (cookieStore.removeAll()) {
        fail = true;
    }
    checkFail("removeAll on empty store should return false");
    HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
    cookie.setDomain("foo.com");
    cookieStore.add(null, cookie);

    //Retrieve added cookie
    URI uri = new URI("http://foo.com");
    List<HttpCookie> addedCookieList = cookieStore.get(uri);

    //Verify CookieStore behaves well
    if (addedCookieList.size() != 1) {
       fail = true;
    }
    checkFail("Abnormal size of cookie jar");

    for (HttpCookie chip : addedCookieList) {
        if (!chip.equals(cookie)) {
             fail = true;
        }
    }
    checkFail("Cookie not retrieved from Cookie Jar");
    boolean ret = cookieStore.remove(null,cookie);
    if (!ret) {
        fail = true;
    }
    checkFail("Abnormal removal behaviour from Cookie Jar");
}

/**
 * Clears the cookies in the given cookie handler. Cookies can only be cleared if the
 * cookieHandler is a CookieManager with a non-null CookieStore.
 *
 * @param cookieHandler the cookie handler where cookies should be cleared
 * @return true if cookies were cleared; false otherwise
 */
public static boolean clearCookies(CookieHandler cookieHandler) {
  if (cookieHandler instanceof CookieManager) {
    CookieManager cookieManager = (CookieManager) cookieHandler;
    CookieStore cookieStore = cookieManager.getCookieStore();
    if (cookieStore != null) {
      cookieStore.removeAll();
      return true;
    }
  }
  return false;
}

/**
 * Remove authorization by removing session cookie
 */
static void deauthorize() {
    if (cookieManager != null) {
        CookieStore store = cookieManager.getCookieStore();
        store.removeAll();
    }
}

static void checkCookieNullUri() throws Exception {
    //get a cookie store implementation and add a cookie to the store with null URI
    CookieStore cookieStore = (new CookieManager()).getCookieStore();
    //Check if removeAll() retrurns false on an empty CookieStore
    if (cookieStore.removeAll()) {
        fail = true;
    }
    checkFail("removeAll on empty store should return false");
    HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
    cookie.setDomain("foo.com");
    cookieStore.add(null, cookie);

    //Retrieve added cookie
    URI uri = new URI("http://foo.com");
    List<HttpCookie> addedCookieList = cookieStore.get(uri);

    //Verify CookieStore behaves well
    if (addedCookieList.size() != 1) {
       fail = true;
    }
    checkFail("Abnormal size of cookie jar");

    for (HttpCookie chip : addedCookieList) {
        if (!chip.equals(cookie)) {
             fail = true;
        }
    }
    checkFail("Cookie not retrieved from Cookie Jar");
    boolean ret = cookieStore.remove(null,cookie);
    if (!ret) {
        fail = true;
    }
    checkFail("Abnormal removal behaviour from Cookie Jar");
}

public boolean isLoggedIn() {
    final CookieStore cookieStore = HttpClientFactory.getInstance().getCookieStore();
    boolean found = false;

    for (final HttpCookie cookie : cookieStore.getCookies()) {
        if ("pass_enabled".equals(cookie.getName()) && "1".equals(cookie.getValue())) {
            found = true;
        }
    }

    return found;
}

@Test
public void testStoredCookieRefTagForProject() {
  final CookieManager cookieManager = new CookieManager();
  final CookieStore cookieStore = cookieManager.getCookieStore();
  final Project project = ProjectFactory.project();
  final RefTag refTag = RefTag.recommended();

  // set the cookie and retrieve the ref tag
  cookieStore.add(null, new HttpCookie("ref_" + project.id(), refTag.tag() + "%3F" + SystemUtils.secondsSinceEpoch()));
  final RefTag retrievedRefTag = RefTagUtils.storedCookieRefTagForProject(project, cookieManager, sharedPreferences);

  assertNotNull(retrievedRefTag);
  assertEquals(refTag, retrievedRefTag);
}

@Test
public void testFindRefTagCookieForProject_WhenCookieExists() {
  final CookieManager cookieManager = new CookieManager();
  final CookieStore cookieStore = cookieManager.getCookieStore();
  final Project project = ProjectFactory.project();
  final RefTag refTag = RefTag.recommended();

  // set and retrieve the cookie
  cookieStore.add(null, new HttpCookie("ref_" + project.id(), refTag.tag() + "%3F" + SystemUtils.secondsSinceEpoch()));
  final HttpCookie cookie = RefTagUtils.findRefTagCookieForProject(project, cookieManager, sharedPreferences);

  assertNotNull(cookie);
  assertEquals(RefTagUtils.cookieNameForProject(project), cookie.getName());
  assertEquals(RefTagUtils.cookieValueForRefTag(refTag), cookie.getValue());
}

static void checkCookieNullUri() throws Exception {
    //get a cookie store implementation and add a cookie to the store with null URI
    CookieStore cookieStore = (new CookieManager()).getCookieStore();
    //Check if removeAll() retrurns false on an empty CookieStore
    if (cookieStore.removeAll()) {
        fail = true;
    }
    checkFail("removeAll on empty store should return false");
    HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
    cookie.setDomain("foo.com");
    cookieStore.add(null, cookie);

    //Retrieve added cookie
    URI uri = new URI("http://foo.com");
    List<HttpCookie> addedCookieList = cookieStore.get(uri);

    //Verify CookieStore behaves well
    if (addedCookieList.size() != 1) {
       fail = true;
    }
    checkFail("Abnormal size of cookie jar");

    for (HttpCookie chip : addedCookieList) {
        if (!chip.equals(cookie)) {
             fail = true;
        }
    }
    checkFail("Cookie not retrieved from Cookie Jar");
    boolean ret = cookieStore.remove(null,cookie);
    if (!ret) {
        fail = true;
    }
    checkFail("Abnormal removal behaviour from Cookie Jar");
}

static void checkCookieNullUri() throws Exception {
    //get a cookie store implementation and add a cookie to the store with null URI
    CookieStore cookieStore = (new CookieManager()).getCookieStore();
    //Check if removeAll() retrurns false on an empty CookieStore
    if (cookieStore.removeAll()) {
        fail = true;
    }
    checkFail("removeAll on empty store should return false");
    HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
    cookie.setDomain("foo.com");
    cookieStore.add(null, cookie);

    //Retrieve added cookie
    URI uri = new URI("http://foo.com");
    List<HttpCookie> addedCookieList = cookieStore.get(uri);

    //Verify CookieStore behaves well
    if (addedCookieList.size() != 1) {
       fail = true;
    }
    checkFail("Abnormal size of cookie jar");

    for (HttpCookie chip : addedCookieList) {
        if (!chip.equals(cookie)) {
             fail = true;
        }
    }
    checkFail("Cookie not retrieved from Cookie Jar");
    boolean ret = cookieStore.remove(null,cookie);
    if (!ret) {
        fail = true;
    }
    checkFail("Abnormal removal behaviour from Cookie Jar");
}

public static CookieStore initInMemoryCookieStore() {
    CookieStore cookieStore = CookieStoreHolder.getCookieStore();
    if (cookieStore == null) {
        CookieManager cm = new CookieManager();
        cm.setCookiePolicy(CookiePolicy.ACCEPT_ALL);
        CookieStoreHolder.setCookieStore(cm.getCookieStore());
    } else {
        cookieStore.removeAll();
    }

    return cookieStore;
}

public WebkitCookieManager(Context context, CookieStore store, CookiePolicy cookiePolicy) {
    super(null, cookiePolicy);
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
        CookieSyncManager.createInstance(context);
    }
    webkitCookieManager = android.webkit.CookieManager.getInstance();
    webkitCookieManager.setAcceptCookie(true);
}

private boolean searchCookieStoreForValue(String value, CookieStore store) {
    for (HttpCookie c : store.getCookies()) {
        if (c.getValue().equals(value)) {
            return true;
        }
    }
    return false;
}

private boolean searchCookieStoreForValue(String value, CookieStore store) {
    for (HttpCookie c : store.getCookies()) {
        if (c.getValue().equals(value)) {
            return true;
        }
    }
    return false;
}

/**
 * Clears the cookies in the given cookie handler. Cookies can only be cleared if the
 * cookieHandler is a CookieManager with a non-null CookieStore.
 *
 * @param cookieHandler the cookie handler where cookies should be cleared
 * @return true if cookies were cleared; false otherwise
 */
public static boolean clearCookies(CookieHandler cookieHandler) {
  if (cookieHandler instanceof CookieManager) {
    CookieManager cookieManager = (CookieManager) cookieHandler;
    CookieStore cookieStore = cookieManager.getCookieStore();
    if (cookieStore != null) {
      cookieStore.removeAll();
      return true;
    }
  }
  return false;
}

private static void clearDownloaderCookies() {
  CookieHandler handler = CookieHandler.getDefault();
  if (handler != null && handler instanceof CookieManager) {
    CookieStore cookies = ((CookieManager) handler).getCookieStore();
    cookies.removeAll();
    CookieHandler.setDefault(null);
  }
}

static void checkCookieNullUri() throws Exception {
    //get a cookie store implementation and add a cookie to the store with null URI
    CookieStore cookieStore = (new CookieManager()).getCookieStore();
    //Check if removeAll() retrurns false on an empty CookieStore
    if (cookieStore.removeAll()) {
        fail = true;
    }
    checkFail("removeAll on empty store should return false");
    HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
    cookie.setDomain("foo.com");
    cookieStore.add(null, cookie);

    //Retrieve added cookie
    URI uri = new URI("http://foo.com");
    List<HttpCookie> addedCookieList = cookieStore.get(uri);

    //Verify CookieStore behaves well
    if (addedCookieList.size() != 1) {
       fail = true;
    }
    checkFail("Abnormal size of cookie jar");

    for (HttpCookie chip : addedCookieList) {
        if (!chip.equals(cookie)) {
             fail = true;
        }
    }
    checkFail("Cookie not retrieved from Cookie Jar");
    boolean ret = cookieStore.remove(null,cookie);
    if (!ret) {
        fail = true;
    }
    checkFail("Abnormal removal behaviour from Cookie Jar");
}

static void checkCookieNullUri() throws Exception {
    //get a cookie store implementation and add a cookie to the store with null URI
    CookieStore cookieStore = (new CookieManager()).getCookieStore();
    //Check if removeAll() retrurns false on an empty CookieStore
    if (cookieStore.removeAll()) {
        fail = true;
    }
    checkFail("removeAll on empty store should return false");
    HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
    cookie.setDomain("foo.com");
    cookieStore.add(null, cookie);

    //Retrieve added cookie
    URI uri = new URI("http://foo.com");
    List<HttpCookie> addedCookieList = cookieStore.get(uri);

    //Verify CookieStore behaves well
    if (addedCookieList.size() != 1) {
       fail = true;
    }
    checkFail("Abnormal size of cookie jar");

    for (HttpCookie chip : addedCookieList) {
        if (!chip.equals(cookie)) {
             fail = true;
        }
    }
    checkFail("Cookie not retrieved from Cookie Jar");
    boolean ret = cookieStore.remove(null,cookie);
    if (!ret) {
        fail = true;
    }
    checkFail("Abnormal removal behaviour from Cookie Jar");
}

public static synchronized boolean setup()
{
    Settings settings = DataStoreManager.getSettings();
    gmtOffset = settings.getGmtOffset();
    sugarUrl = settings.getCrmUrl();
    api = new SugarApi(sugarUrl);
    try
    {
        session = api.getSugarSession(new SugarCredentials(settings.getUser(), settings.getPassword()));

        String sessionId = session.getSessionID();

        CookieManager manager = new CookieManager();
        manager.setCookiePolicy(CookiePolicy.ACCEPT_ALL);
        CookieStore store = manager.getCookieStore();
        store.add(new URI(sugarUrl), new HttpCookie("PHPSESSID", sessionId));
        CookieHandler.setDefault(manager);


        return true;
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }

    return false;
}

/**
 * Sets logged in user id from COOKIE_USER_ID if cookieStore has it
 */
private void initUserIdFromCookies() {
    CookieStore cookieStore = cookieManager.getCookieStore();
    try {
        List<HttpCookie> cookies = cookieStore.get(new URI(EcoMapAPIContract.ECOMAP_SERVER_URL));
        for (HttpCookie cookie : cookies) {
            if (cookie.getName().equals(EcoMapAPIContract.COOKIE_USER_ID)) {
                setUserId(cookie.getValue());
            }
        }
    } catch (URISyntaxException e) {
        Log.e(LOG_TAG, e.getMessage(), e);
    }
}

public void testCookieStoreRemoveAll() throws URISyntaxException {
    CookieStore cookieStore = new CookieManager().getCookieStore();
    cookieStore.add(new URI("http://code.google.com/"), new HttpCookie("a", "android"));
    assertTrue(cookieStore.removeAll());
    assertEquals(Collections.<URI>emptyList(), cookieStore.getURIs());
    assertEquals(Collections.<HttpCookie>emptyList(), cookieStore.getCookies());
    assertFalse("Expected removeAll() to return false when the call doesn't mutate the store",
            cookieStore.removeAll());  // RI6 fails this
}

public void testCookieStoreAddAcceptsConflictingUri() throws URISyntaxException {
    CookieStore cookieStore = new CookieManager().getCookieStore();
    HttpCookie cookieA = new HttpCookie("a", "android");
    cookieA.setDomain(".android.com");
    cookieA.setPath("/source/");
    cookieStore.add(new URI("http://google.com/source/"), cookieA);
    assertEquals(Arrays.asList(cookieA), cookieStore.getCookies());
}

public void testCookieStoreRemoveRequiresUri() throws URISyntaxException {
    CookieStore cookieStore = new CookieManager().getCookieStore();
    HttpCookie cookieA = new HttpCookie("a", "android");
    cookieStore.add(new URI("http://android.com/source/"), cookieA);
    assertFalse("Expected remove() to take the cookie URI into account.", // RI6 fails this
            cookieStore.remove(new URI("http://code.google.com/"), cookieA));
    assertEquals(Arrays.asList(cookieA), cookieStore.getCookies());
}

public Builder enableCookies(CookieStore cookieStore, CookiePolicy cookiePolicy) {
  if (cookiePolicy == null) {
    throw new NullPointerException("CookiePolicy may not be null");
  }
  this.cookieHandler = new CookieManager(cookieStore, cookiePolicy);
  return this;
}

static void checkCookieNullUri() throws Exception {
    //get a cookie store implementation and add a cookie to the store with null URI
    CookieStore cookieStore = (new CookieManager()).getCookieStore();
    //Check if removeAll() retrurns false on an empty CookieStore
    if (cookieStore.removeAll()) {
        fail = true;
    }
    checkFail("removeAll on empty store should return false");
    HttpCookie cookie = new HttpCookie("MY_COOKIE", "MY_COOKIE_VALUE");
    cookie.setDomain("foo.com");
    cookieStore.add(null, cookie);

    //Retrieve added cookie
    URI uri = new URI("http://foo.com");
    List<HttpCookie> addedCookieList = cookieStore.get(uri);

    //Verify CookieStore behaves well
    if (addedCookieList.size() != 1) {
       fail = true;
    }
    checkFail("Abnormal size of cookie jar");

    for (HttpCookie chip : addedCookieList) {
        if (!chip.equals(cookie)) {
             fail = true;
        }
    }
    checkFail("Cookie not retrieved from Cookie Jar");
    boolean ret = cookieStore.remove(null,cookie);
    if (!ret) {
        fail = true;
    }
    checkFail("Abnormal removal behaviour from Cookie Jar");
}