当我在android中按下home按钮时，活动重新启动

当我通过TaskManager打开活动时，我的活动恐怕会重新启动

我的DefaultHttpClient对象被视为一个新对象，所以这里我失去了 会议

我试图重写onSaveInstanceState（）方法，但没有用

@Override
        protected void onSaveInstanceState(Bundle outState) {
            super.onSaveInstanceState(outState); // the UI component values are saved here.
        }

---

如何摆脱这个…

您可以对Android应用程序进行子类化：您可以在那里初始化HttpClient并保存引用

使用

activity.getApplication（）

如果会话使用cookie，则可能需要持久cookie存储（如数据库或共享首选项）：

import java.io.ByteArrayInputStream；
导入java.io.ByteArrayOutputStream；
导入java.io.ObjectInputStream；
导入java.io.ObjectOutputStream；
导入java.util.Date；
导入java.util.List；
导入java.util.concurrent.ConcurrentHashMap；
导入java.util.concurrent.CopyOnWriteArrayList；
导入org.apache.http.client.CookieStore；
导入org.apache.http.cookie.cookie；
导入android.content.Context；
导入android.content.SharedReferences；
导入android.text.TextUtils；
/**
*实现Apache HttpClient的持久cookie存储
*{@link CookieStore}接口。Cookie已存储并将保留在服务器上
*应用程序会话之间的用户设备，因为它们已序列化且
*存储在{@link SharedPreferences}中。
*
*/
公共类PersistentCookieStore实现CookieStore{
私有静态最终字符串COOKIE\u PREFS=“CookiePrefsFile”；
私有静态最终字符串COOKIE\u NAME\u STORE=“NAME”；
私有静态最终字符串COOKIE\u NAME\u PREFIX=“COOKIE\ux”；
私有最终ConcurrentHashMap cookies；
私人最终共享参考cookiePrefs；
/**
*构造一个持久的cookie存储。
*/
公共PersistentCookieStore（上下文）{
cookiePrefs=context.getSharedReferences（COOKIE\u PREFS，0）；
cookies=新的ConcurrentHashMap（）；
//将以前存储的任何cookie加载到存储中
String storedCookieNames=cookiePrefs.getString（COOKIE\u NAME\u STORE，
无效）；
if（storedCookieNames！=null）{
字符串[]cookieNames=TextUtils.split（storedCookieNames，“，”）；
for（字符串名称：cookieNames）{
String encodedCookie=cookiePrefs.getString（COOKIE\u NAME\u前缀
+名称（空）；
如果（encodedCookie！=null）{
Cookie decodedCookie=解码Cookie（encodedCookie）；
if（decodedCookie！=null）{
cookies.put（名称、解码cookie）；
}
}
}
//清除过期的饼干
clearExpired（新日期（））；
}
}
@凌驾
公共同步的void addCookie（Cookie Cookie）{
字符串名称=cookie.getName（）+cookie.getDomain（）；
//将cookie保存到本地存储中，或在过期时删除
如果（！cookie.isExpired（new Date（）））{
cookies.put（名称、cookie）；
}否则{
删除（名称）；
}
//将cookie保存到持久存储中
SharedPreferences.Editor prefsWriter=cookiePrefs.edit（）；
prefsWriter.putString（COOKIE\u NAME\u存储，
TextUtils.join（“，”，cookies.keySet（））；
prefsWriter.putString（COOKIE\u NAME\u PREFIX+NAME，
encodeCookie（新的SerializableCookie（cookie））；
prefsWriter.commit（）；
}
@凌驾
公共同步无效清除（）{
//从持久存储中清除cookie
SharedPreferences.Editor prefsWriter=cookiePrefs.edit（）；
for（字符串名称：cookies.keySet（））{
prefsWriter.remove（COOKIE\u NAME\u PREFIX+NAME）；
}
删除（COOKIE\u NAME\u存储）；
prefsWriter.commit（）；
//清除本地商店的cookies
cookies.clear（）；
}
@凌驾
公共同步布尔clearExpired（日期）{
布尔clearedAny=false；
SharedPreferences.Editor prefsWriter=cookiePrefs.edit（）；
对于（ConcurrentHashMap.Entry:cookies.entrySet（））{
字符串名称=entry.getKey（）；
Cookie Cookie=entry.getValue（）；
如果（cookie.isExpired（日期））{
//清除本地商店的cookies
删除（名称）；
//从持久存储中清除cookie
prefsWriter.remove（COOKIE\u NAME\u PREFIX+NAME）；
//我们至少清除了一个
clearedAny=true；
}
}
//更新持久存储中的名称
如果（清除任何）{
prefsWriter.putString（COOKIE\u NAME\u存储，
TextUtils.join（“，”，cookies.keySet（））；
}
prefsWriter.commit（）；
返回clearedAny；
}
@凌驾
公共同步列表getCookies（）{
返回新的CopyOnWriteArrayList（cookies.values（））；
}
//
//Cookie序列化/反序列化
//
受保护的同步字符串编码cookie（SerializableCookie cookie）{
ByteArrayOutputStream os=新建ByteArrayOutputStream（）；
试一试{
ObjectOutputStream outputStream=新的ObjectOutputStream（os）；
outputStream.writeObject（cookie）；
}捕获（例外e）{
返回null；
}
返回byteArrayToHexString（os.toByteArray（））；
}
受保护的同步Cookie解码Cookie（字符串cookieStr）{
字节[]字节=hexStringToByteArray（cookieStr）；
ByteArrayInputStream is=新的ByteArrayInputStream（字节）；
Cookie=null；
试一试{
ObjectInputStream ois=新ObjectInputStream（is）；
cookie=（（SerializableCookie）ois.readObject（））.getCookie（）；
}捕获（例外e）{
e、 printStackTrace（）；
}
返回cookie；
}
//使用so
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Date;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

import org.apache.http.client.CookieStore;
import org.apache.http.cookie.Cookie;

import android.content.Context;
import android.content.SharedPreferences;
import android.text.TextUtils;

/**
 * A persistent cookie store which implements the Apache HttpClient
 * {@link CookieStore} interface. Cookies are stored and will persist on the
 * user's device between application sessions since they are serialized and
 * stored in {@link SharedPreferences}.
 * <p>
 */
public class PersistentCookieStore implements CookieStore {
    private static final String COOKIE_PREFS = "CookiePrefsFile";
    private static final String COOKIE_NAME_STORE = "names";
    private static final String COOKIE_NAME_PREFIX = "cookie_";

    private final ConcurrentHashMap<String, Cookie> cookies;
    private final SharedPreferences cookiePrefs;

    /**
     * Construct a persistent cookie store.
     */
    public PersistentCookieStore(Context context) {
        cookiePrefs = context.getSharedPreferences(COOKIE_PREFS, 0);
        cookies = new ConcurrentHashMap<String, Cookie>();

        // Load any previously stored cookies into the store
        String storedCookieNames = cookiePrefs.getString(COOKIE_NAME_STORE,
                null);
        if (storedCookieNames != null) {
            String[] cookieNames = TextUtils.split(storedCookieNames, ",");
            for (String name : cookieNames) {
                String encodedCookie = cookiePrefs.getString(COOKIE_NAME_PREFIX
                        + name, null);
                if (encodedCookie != null) {
                    Cookie decodedCookie = decodeCookie(encodedCookie);
                    if (decodedCookie != null) {
                        cookies.put(name, decodedCookie);
                    }
                }
            }

            // Clear out expired cookies
            clearExpired(new Date());
        }
    }

    @Override
    public synchronized void addCookie(Cookie cookie) {
        String name = cookie.getName() + cookie.getDomain();

        // Save cookie into local store, or remove if expired
        if (!cookie.isExpired(new Date())) {
            cookies.put(name, cookie);
        } else {
            cookies.remove(name);
        }

        // Save cookie into persistent store
        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
        prefsWriter.putString(COOKIE_NAME_STORE,
                TextUtils.join(",", cookies.keySet()));
        prefsWriter.putString(COOKIE_NAME_PREFIX + name,
                encodeCookie(new SerializableCookie(cookie)));
        prefsWriter.commit();
    }

    @Override
    public synchronized void clear() {
        // Clear cookies from persistent store
        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();
        for (String name : cookies.keySet()) {
            prefsWriter.remove(COOKIE_NAME_PREFIX + name);
        }
        prefsWriter.remove(COOKIE_NAME_STORE);
        prefsWriter.commit();

        // Clear cookies from local store
        cookies.clear();
    }

    @Override
    public synchronized boolean clearExpired(Date date) {
        boolean clearedAny = false;
        SharedPreferences.Editor prefsWriter = cookiePrefs.edit();

        for (ConcurrentHashMap.Entry<String, Cookie> entry : cookies.entrySet()) {
            String name = entry.getKey();
            Cookie cookie = entry.getValue();
            if (cookie.isExpired(date)) {
                // Clear cookies from local store
                cookies.remove(name);

                // Clear cookies from persistent store
                prefsWriter.remove(COOKIE_NAME_PREFIX + name);

                // We've cleared at least one
                clearedAny = true;
            }
        }

        // Update names in persistent store
        if (clearedAny) {
            prefsWriter.putString(COOKIE_NAME_STORE,
                    TextUtils.join(",", cookies.keySet()));
        }
        prefsWriter.commit();

        return clearedAny;
    }

    @Override
    public synchronized List<Cookie> getCookies() {
        return new CopyOnWriteArrayList<Cookie>(cookies.values());
    }

    //
    // Cookie serialization/deserialization
    //

    protected synchronized String encodeCookie(SerializableCookie cookie) {
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        try {
            ObjectOutputStream outputStream = new ObjectOutputStream(os);
            outputStream.writeObject(cookie);
        } catch (Exception e) {
            return null;
        }

        return byteArrayToHexString(os.toByteArray());
    }

    protected synchronized Cookie decodeCookie(String cookieStr) {
        byte[] bytes = hexStringToByteArray(cookieStr);
        ByteArrayInputStream is = new ByteArrayInputStream(bytes);
        Cookie cookie = null;
        try {
            ObjectInputStream ois = new ObjectInputStream(is);
            cookie = ((SerializableCookie) ois.readObject()).getCookie();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return cookie;
    }

    // Using some super basic byte array <-> hex conversions so we don't have
    // to rely on any large Base64 libraries. Can be overridden if you like!
    protected synchronized String byteArrayToHexString(byte[] b) {
        StringBuffer sb = new StringBuffer(b.length * 2);
        for (byte element : b) {
            int v = element & 0xff;
            if (v < 16) {
                sb.append('0');
            }
            sb.append(Integer.toHexString(v));
        }
        return sb.toString().toUpperCase();
    }

    protected synchronized byte[] hexStringToByteArray(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character
                    .digit(s.charAt(i + 1), 16));
        }
        return data;
    }
}

    android:launchMode="singleInstance"
    android:alwaysRetainTaskState="true"

if (!isTaskRoot()) {
    final Intent intent = getIntent();
    final String action = intent.getAction(); 
    if (intent.hasCategory(Intent.CATEGORY_LAUNCHER) && action != null && action.equals(Intent.ACTION_MAIN)) {
        finish();//Launcher Activity is not the root. So,finish it instead of launching
        return;       
    }
}