在新开项目中需要我们完成的动作ActivityQueueManager 、BaseActivity、SharedPreferencesUtil

1.ActivityQueueManager

当我们写一个android项目时，很多时候我们都想自己管理我们的activity队列，比如当我们开启新的activity时就加人到队列，当我们finish时就从队列中删除。这样还有一个很明显的好处就是，当我们退出应用时直接遍历这个队列把其中加人的activity挨个finish掉即可。

这里我们需要提供出来的方法：

• 添加一个activity（pushActivity）
• 删除一个activity（popActivity）
• 获取队列中最上层activity（pop）
• 获取队列中的某一个activity（popIndex）
• 删除掉队列中所有的activity，退出应用使用（finishAllActivity）
• 关闭掉队列中的最上层的N个activity，很多应用需要的一个方法（closeNumberActivities）

下面为java代码：

public class ActivityQueueManager {

    private static final ActivityQueueManager mInstance = new ActivityQueueManager();

    private final static String TAG = ActivityQueueManager.class.getSimpleName();
    private static LinkedList<Activity> mQueue;

    private ActivityQueueManager() {
        ActivityQueueManager.mQueue = new LinkedList<Activity>();
    }

    /**
     * push activity to queue
     * 
     * @param activity
     * @return void
     * @throws
     */
    public void pushActivity(Activity activity) {
        mInstance.doPushActivity(activity);
        Log.v(TAG, "pushActivity size=" + mQueue.size() + " name=" + activity.getLocalClassName());
    }

    /**
     * pop activity from queue
     * 
     * @param activity
     * @return void
     * @throws
     */
    public void popActivity(Activity activity) {
        mInstance.doPopActivity(activity);
        Log.v(TAG, "popActivity size=" + mQueue.size() + " name=" + activity.getLocalClassName());
    }

    /**
     * pop the stack top activity
     * 
     * @return Activity
     * @throws
     */
    public Activity pop() {
        if (mQueue != null && mQueue.size() > 0) {
            return mQueue.peek();
        } else {
            return null;
        }
    }

    /**
     * pop the postion activity
     * 
     * @return Activity
     * @throws
     */
    public Activity popIndex(int postion) {
        if (mQueue != null && mQueue.size() > postion) {
            return mQueue.get(postion);
        } else {
            return null;
        }
    }

    /**
     * finish all activity from queue
     * 
     * @return void
     * @throws
     */
    public void finishAllActivity() {
        mInstance.doFinishAll();
    }

    @SuppressLint("NewApi")
    public void doPushActivity(Activity activity) {
        // 解决系统2.2版本的bug
        if (android.os.Build.VERSION.SDK_INT > Build.VERSION_CODES.FROYO) {
            mQueue.push(activity);
        } else {
            mQueue.addFirst(activity);
        }
    }

    public void doPopActivity(Activity activity) {
        if (ActivityQueueManager.mQueue.contains(activity)) {
            ActivityQueueManager.mQueue.remove(activity);
        }
    }

    public void doFinishAll() {
        Iterator<Activity> it = mQueue.iterator();
        while (it.hasNext()) {
            Activity a = it.next();
            it.remove();
            a.finish();
        }
    }

    public static ActivityQueueManager getInstance() {
        return mInstance;
    }

    public LinkedList<Activity> getActivityLinkQueue() {
        return mQueue;
    }

    public int getSize() {
        return mQueue.size();
    }


    /**
     * 关闭N个activities
     * @param closeNumberActivities 关闭activity的个数
     */
    public void closeNumberActivities(int closeNumberActivities) {
        // 关闭个数小于1的时候直接跳出
        if (closeNumberActivities <= 0) {
            return;
        }
        LinkedList<Activity> mActivities = mQueue;
        if (mActivities != null && mActivities.size() <= 1) {
            return;
        }

        try {
            int countTemp = 0;
            // 倒序遍历acitivty
            for (int i = mActivities.size() - 1; i >= 0; i--) {
                // 如果当前页面为NativeAppActivity，则直接finish();
                Activity mActivity = mActivities.get(i);
                if (mActivity != null ) {
                    mActivity.finish();
                    mActivities.remove(mActivity);
                }
                // 其他情况下finish掉activity
                else {
                    // 当前页面不能是最后一页
                    if (mActivities.size() > 1 ) {
                        mActivity.finish();
                        mActivities.remove(mActivity);
                        countTemp ++;
                    } else {
                        i = -1;
                    }
                }
                // 退出循环
                if (countTemp == closeNumberActivities) {
                    i = -1;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

下面就是调用过程了。只要我们在activity的onCreate方法中调用pushActivity添加，在onDestroy中调用popActivity移除即可。当然我们不会再每一个activity中都去做这个操作。我们只需要实现一个BaseActivity基类即可。

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    app = (LoveApplication) getApplication();
    //添加
    ActivityQueueManager.getInstance().pushActivity(this);

}

@Override
protected void onDestroy() {
    super.onDestroy();
    //移除
    ActivityQueueManager.getInstance().popActivity(this);
}

到这里我们只说了一个activity的管理，下面我们继续在我们的项目中，我们还在BaseActivity中完成了什么

2.BaseActivity

• 我们在activity中经常打开新的activity（openActivity）
• 我们打开新的activityForResult（openActivityForResult）
• 我们需要的dip、px互换（dip2px、px2dip）
• 我们需要toast打印（showToastSafe）
• 部分需要，在使用sp为字体大小单位时设置字体不随系统变化而变化（重写getResources方法）

public class BaseActivity extends InitActivity {
    /** UI 线程ID */
    private long mUIThreadId;
    protected LoveApplication app;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        app = (LoveApplication) getApplication();
        ActivityQueueManager.getInstance().pushActivity(this);

    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityQueueManager.getInstance().popActivity(this);
    }


    /**
     * 通过类名启动Activity
     * 
     * @param pClass
     */
    protected void openActivity(Class<?> pClass) {
        openActivity(pClass, null);
    }

    protected void openActivity(Class<?> pClass, String key, String value) {
        Intent intent = new Intent(this, pClass);
        intent.putExtra(key, value);
        startActivity(intent);
    }

    /**
     * 通过类名启动Activity，并且含有Bundle数据
     * 
     * @param pClass
     * @param pBundle
     */
    protected void openActivity(Class<?> pClass, Bundle pBundle) {
        Intent intent = new Intent(this, pClass);
        if (pBundle != null) {
            intent.putExtras(pBundle);
        }
        startActivity(intent);
    }

    public void openActivityForResult(Class<?> pClass, String key, String value, int requestCode) {
        Intent intent = new Intent(this, pClass);
        intent.putExtra(key, value);
        openActivityForResult(pClass, null, requestCode);
    }

    public void openActivityForResult(Class<?> pClass, int requestCode) {
        openActivityForResult(pClass, null, requestCode);
    }

    protected void openActivityForResult(Class<?> pClass, Bundle pBundle, int pRrequestCode) {
        Intent intent = new Intent(this, pClass);
        if (pBundle != null) {
            intent.putExtras(pBundle);
        }
        startActivityForResult(intent, pRrequestCode);
    }


    /** dip转换px */
    public int dip2px(int dip) {
        final float scale = getResources().getDisplayMetrics().density;
        return (int) (dip * scale + 0.5f);
    }

    /** pxz转换dip */
    public int px2dip(int px) {
        final float scale = getResources().getDisplayMetrics().density;
        return (int) (px / scale + 0.5f);
    }

    /** 对toast的简易封装。线程安全，可以在非UI线程调用。 */
    public void showToastSafe(final int resId, final int duration) {
        if (Process.myTid() == mUIThreadId) {
            // 调用在UI线程
            Toast.makeText(getBaseContext(), resId, duration).show();
        } else {
            // 调用在非UI线程
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(getBaseContext(), resId, duration).show();
                }
            });
        }
    }

    /** 对toast的简易封装。线程安全，可以在非UI线程调用。 */
    public void showToastSafe(final CharSequence text, final int duration) {
        if (Process.myTid() == mUIThreadId) {
            // 调用在UI线程
            Toast.makeText(getBaseContext(), text, duration).show();
        } else {
            // 调用在非UI线程
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(getBaseContext(), text, duration).show();
                }
            });
        }
    }


    /*
     * 设置字体不随系统变化而变化
     */
    @Override  
    public Resources getResources() {  
        Resources res = super.getResources();    
        Configuration config=new Configuration();    
        config.setToDefaults(); 
        if(res != null){
            res.updateConfiguration(config,res.getDisplayMetrics() );  
        }
        return res;  
    }  

}

3.SharedPreferencesUtil

项目中少不了用sharedPreferences来存储数据，为了新项目方便，我们直接定义出SharedPreferencesUtil

• 单例模式
• 添加（putXX）
• 删除（reomve）
• 获取（getXX）

public class SharedPreferencesUtil {

    private SharedPreferences sp;

    private static SharedPreferencesUtil spUtil;

    private SharedPreferencesUtil(Context context){
        sp = PreferenceManager.getDefaultSharedPreferences(context);
    }

    public static SharedPreferencesUtil getSharedPreferences(Context context){
        if(spUtil == null){
           spUtil = new SharedPreferencesUtil(context);
        }
        return spUtil;
    }

    public void remove(String key){
        if(sp != null){
           sp.edit().remove(key).commit();
        }
    }

    public void putBoolean(String key, boolean value){
        if(sp != null){
           sp.edit().putBoolean(key, value).commit();
        }
    }

    public void putFloat(String key, float value){
        if(sp != null){
           sp.edit().putFloat(key, value).commit();
        }
    }

    public void putInt(String key, int value){
        if(sp != null){
           sp.edit().putInt(key, value).commit();
        }
    }

    public void putLong(String key, long value){
        if(sp != null){
           sp.edit().putLong(key, value).commit();
        }
    }

    public void putString(String key, String value){
        if(sp != null){
           sp.edit().putString(key, value).commit();
        }
    }

    public String getString(String key, String defValue){
        String value = null;
        if(sp != null){
            value = sp.getString(key, defValue);
        }
        return value;
    }

    public boolean getBoolean(String key, boolean defValue){
        boolean value = false;
        if(sp != null){
           value = sp.getBoolean(key, defValue);
        }
        return value;
    }

    public int getInt(String key, int defValue){
        int value = 0;
        if(sp != null){
           value = sp.getInt(key, defValue);
        }
        return value;
    }

    public long getLong(String key, long defValue){
        long value = 0;
        if(sp != null){
           value = sp.getLong(key, defValue);
        }
        return value;
    }

    public void clearAll(){
        if(sp != null){
           sp.edit().clear().commit();
        }
    }
}

当然，如果需要我们同样可以将SharedPreferencesUtil加入到BaseActivity中，方便我们用的时候直接调用，这就看各位了。