Android开发框架搭建——BaseActivity的抽取（二）

 在日常的开发中，我们都会不断地抽取基类让自己的代码看起来更加简洁易懂，这样我们就要抽取我们自己的基类，让后面的类都继承这个Base基类，这样我们可以少写一些代码，可以增加复用性，降低耦合
 今天我们就抽取了所有的应用程序都需要的BaseActivity，这个大家在开发过程中都需要用到的类，那么废话不说，看看我们的BaseActivity的源码：

1. 初始化布局initLayout(savedInstanceState);
2. 初始化View 主要是使用findviewbyid的 如果你用的是ButterKnife 这个方法可以忽略
3. 所有监听的方法都在该类中实现
4. 添加activity 控制activity的关闭addActivity()
5. 移除当前的页面管理器的页面 removeActivity()
6. 销毁当前的activity destroyActivity()
7. 界面销毁 (1)关闭所有activity finishAll()
8. 界面销毁 (2)退出整个程序exit()
9. 页面跳转 activityPageChange
10. 获取页面传输过程传输的非基本类型数据getMapData(String key)
11. 判断内存卡是否存在isSDCardExist()
12. 获取sd卡剩余的空间大小 单位是byte getSDFreeSize()
13. 关于数据存储的方法
14. 吐司
15. log日志打印

package ledon.com.retrofitdemo.base;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.Window;
import android.widget.Toast;

import java.util.Map;

import ledon.com.retrofitdemo.application.MyAppliaction;
import ledon.com.retrofitdemo.utils.DataStorageUtils;
import ledon.com.retrofitdemo.utils.LogUtils;

/**
 * Created by Administrator on 2017/3/16.
 */

public abstract class BaseActivity extends AppCompatActivity {

    private MyAppliaction appliaction;
    private DataStorageUtils dataStorageUtils;
    private String tag = this.getClass().getName();
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        //全局没有标题栏
        initLayout(savedInstanceState);
        initView();
        initListener();
        appliaction = MyAppliaction.getMyAppliaction();
        dataStorageUtils = new DataStorageUtils(this);
    }

    /**
     * 所有监听的方法都在该类中实现
     */
    protected abstract void initListener();

    /**
     * 初始化布局
     * @param savedInstanceState
     */
    protected abstract void initLayout(Bundle savedInstanceState);

    /**
     * 初始化View 主要是使用findviewbyid的 如果你用的是ButterKnife 这个方法可以忽略
     */
    protected abstract void initView() ;

    /**
     * 添加activity 控制activity的关闭
     */
    public void addActivity(){
        appliaction.addActivity(this);
    }

    /**
     * 移除当前的页面管理器的页面
     */
    public void removeActivity(){
        appliaction.removeActivity(this);
    }
    /**
     * 销毁当前的activity
     */
    public void destroyActivity(){
        appliaction.destroyActivity(this);
    }
    /**
     * 界面销毁 (1)关闭所有activity
     */
    public void finishAll() {
        appliaction.finishAll();
    }
    /**
     * 界面销毁 (2)退出整个程序
     */
    public void exit() {
        appliaction.exit();
    }
    /**
     * 不设置flags,不需要返回值的页面跳转
     *
     *
     *            当前Activity
     * @param c
     *            要跳转的class
     * @param map
     *            传输数据的键值对 没有时为null
     * @param b
     *            是否关闭当前页面 为true时关闭,false时保留
     */
    public void activityPageChange(Class<?> c, Map<String, Object> map,
                                   boolean b) {
        // 这里的页面关闭可控制
        appliaction.activityPageChange(this, c, map, -1, false, 0, b);
    }

    /**
     * 设置flags,不需要返回值的页面跳转
     *
     *
     *            当前Activity
     * @param c
     *            要跳转的class
     * @param map
     *            传输数据的键值对 没有时为null
     * @param flags
     *            为要跳转的页面设置的flags 没有时为-1
     * @param b
     *            是否关闭当前页面 为true时关闭,false时保留
     */
    public void activityPageChange(Class<?> c, Map<String, Object> map,
                                   int flags, boolean b) {
        // 这里的页面关闭可控制
        appliaction.activityPageChange(this, c, map, flags, false, 0, b);
    }

    /**
     * 设置flags,需要返回值的页面跳转
     *
     *
     *            当前Activity
     * @param c
     *            要跳转的class
     * @param map
     *            传输数据的键值对 没有时为null
     * @param flags
     *            为要跳转的页面设置的flags 没有时为-1
     * @param requestCode
     *            跳转页面调用startActivityForResult() 对应的请求码
     * @param b
     *            是否关闭当前页面 为true时关闭,false时保留
     */
    public void activityPageChange(Class<?> c, Map<String, Object> map,
                                   int flags, int requestCode, boolean b) {
        // 这里的页面关闭可控制
        appliaction.activityPageChange(this, c, map, flags, true,
                requestCode, b);
    }

    /**
     * 获取页面传输过程传输的非基本类型数据
     *
     * @param key
     * @return
     */
    public Object getMapData(String key) {
        return appliaction.getMapData(key);
    }

    /**
     * 判断内存卡是否存在
     * @return
     */
    public static boolean isSDCardExist(){
        return DataStorageUtils.isSDCardExist();
    }

    /**
     * 获取sd卡剩余的空间大小 单位是byte
     * @return
     */
    public static long getSDFreeSize(){
        return DataStorageUtils.getSDFreeSize();
    }
    /**
     * 根据键字符串，存储一个字符串值
     *
     * @param key
     * @param value
     * @return 返回提交是否成功
     */
    public boolean putString(String key, String value) {
        return dataStorageUtils.putString(key, value);
    }

    /**
     * 根据key值得到存储结果，如果没有找到value就返回null
     *
     * @param key
     * @return
     */
    public String getString(String key) {
        return dataStorageUtils.getString(key);
    }

    /**
     * 根据键字符串，存储一个整型值, 值不能为-1
     *
     * @param key
     * @param value
     *            不能为-1
     * @return 返回提交是否成功
     */
    public boolean putInt(String key, int value) {
        return dataStorageUtils.putInt(key, value);
    }

    /**
     * 根据key值得到存储结果，如果没有找到value就返回-1
     *
     * @param key
     * @return
     */
    public int getInt(String key) {
        return dataStorageUtils.getInt(key);
    }

    /**
     * 根据key值移除对应的数据
     *
     * @param key
     * @return
     */
    public boolean remove(String key) {
        return dataStorageUtils.remove(key);
    }

    /**
     * 吐司
     * @param message
     */
    public void toast(String message){
        Toast.makeText(this,message,Toast.LENGTH_SHORT).show();
    }
    public void log(String s){
        LogUtils.i(tag,s);
    }
    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        appliaction = null;
        dataStorageUtils = null;
    }

    @Override
    protected void onStart() {
        super.onStart();
    }

    @Override
    protected void onResume() {
        super.onResume();
    }

    @Override
    protected void onPause() {
        super.onPause();
    }

    @Override
    protected void onStop() {
        super.onStop();
    }
}

目前更新的BaseActivity就是这样抽取的，其中有一些方法可以参考上一篇文章，这里还有一些用到的工具类，下面就把需要的工具类的源码给大家粘贴出来：
DataStorageUtils：

package ledon.com.retrofitdemo.utils;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.content.SharedPreferences;
import android.os.Environment;
import android.os.StatFs;
import android.text.TextUtils;
import android.util.Log;



import ledon.com.retrofitdemo.application.MyAppliaction;

/**
 * 数据存储工具包
 * 
 * @author Alba
 * 
 */
public class DataStorageUtils {

    private final static String TAG = "SharedPreferencesHelper";
    private SharedPreferences prefs;
    private SharedPreferences.Editor editor;
    /** 当存在SD时，且空间足够时，app文件下载存放的目录 */
    public final static String SDCARD_STORAGE = Environment
            .getExternalStorageDirectory() + File.separator + "Ilodo";
    /** 当不存在SD时，app文件下载存放的目录 */
    public final static String INNER_STORAGE = MyAppliaction
            .getMyAppliaction().getFilesDir() + File.separator;

    public DataStorageUtils(Context context) {
        // 貌似都是同一文件名存储，只是访问权限不同
        prefs = context.getSharedPreferences(TAG, Context.MODE_PRIVATE);
        editor = prefs.edit();
    }

    /**
     * 判断SD卡是否存在
     * 
     * @return
     */
    public static boolean isSDCardExist() {
        if (Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED)) {
            Log.w("isSDCardExist", "isSDCardExist:" + true);
            return true;
        }
        Log.w("isSDCardExist", "isSDCardExist:" + false);
        return false;
    }

    /**
     * 获取存储目录的剩余空间 返回值单位 Byte
     * 
     * @return
     */
    public static long getSDFreeSize() {
        File path;
        if (isSDCardExist()) {
            // 取得SD卡文件路径
            path = Environment.getExternalStorageDirectory();
        } else {
            path = MyAppliaction.getMyAppliaction().getFilesDir();
        }
        StatFs sf = new StatFs(path.getPath());
        // 获取单个数据块的大小(Byte)
        long blockSize = sf.getBlockSize();
        // 空闲的数据块的数量
        long freeBlocks = sf.getAvailableBlocks();
        // 返回SD卡空闲大小
        long size = freeBlocks * blockSize;
        Log.w("isSDCardExist", "剩余空间大小:" + size);
        return size; // 单位Byte
        // return (freeBlocks * blockSize)/1024; //单位KB
        // return (freeBlocks * blockSize)/1024 /1024; //单位MB

    }

    /**
     * 根据键字符串，存储一个字符串值
     * 
     * @param key
     * @param value
     * @return 返回提交是否成功
     */
    public boolean putString(String key, String value) {
        if (TextUtils.isEmpty(key)) {
            return false;
        }

        editor.putString(key, value);
        return editor.commit();
    }

    /**
     * 根据key值得到存储结果，如果没有找到value就返回null
     * 
     * @param key
     * @return
     */
    public String getString(String key) {
        return prefs.getString(key, null);
    }

    /**
     * 根据键字符串，存储一个整型值, 值不能为-1
     * 
     * @param key
     * @param value
     *            不能为-1
     * @return 返回提交是否成功
     */
    public boolean putInt(String key, int value) {
        if (TextUtils.isEmpty(key) || value == -1) {
            return false;
        }
        editor.putInt(key, value);
        return editor.commit();
    }

    /**
     * 根据key值得到存储结果，如果没有找到value就返回-1
     * 
     * @param key
     * @return
     */
    public int getInt(String key) {
        return prefs.getInt(key, -1);
    }

    /**
     * 根据键字符串，存储一个布尔值
     * 
     * @param key
     * @param value
     * @return 返回提交是否成功
     */
    public boolean putBoolean(String key, boolean value) {
        if (TextUtils.isEmpty(key)) {
            return false;
        }
        editor.putBoolean(key, value);
        return editor.commit();
    }

    /**
     * 根据key值得到存储结果，如果没有找到value就返回false
     * 
     * @param key
     * @return
     */
    public boolean getBoolean(String key) {
        return prefs.getBoolean(key, false);
    }

    /**
     * 根据key值移除对应的数据
     * 
     * @param key
     * @return
     */
    public boolean remove(String key) {
        editor.remove(key);
        return editor.commit();
    }

    /**
     * 清空少量的数据
     * 
     * @return
     */
    public boolean clearLittleData() {
        editor.clear();
        return editor.commit();
    }

    // 注意拓展多用户登录
    /**
     * 存储登录时 的个人信息，以实现记住最后一次登录用户的效果
     * 
     * @param context
     *            上下文对象
     * @param headMsg
     *            头部信息，区分是账号登录还是第三方登录
     * @param accountInforma
     *            这里包含账号登录时,存储账号名和密码;第三方登录时,存储thirdIdentify和openId
     * @param imgUrl
     *            头像url
     * @param username
     *            用户名
     * @return
     */
    public static boolean savePersonData(Context context, String headMsg,
            String accountInforma, String imgUrl, String username) {
        // 考虑到注册账号的特殊性，除了登陆是必要的账号密码，其他信息都可为空，但是也需要做相关处理
        // || imgUrl == null || username == null || headMsg == null
        if (context == null || accountInforma == null) {
            Log.i("savePersonData", "message is null");
            return false;
        }

        File file = new File(context.getFilesDir(), "ledonPerson.txt");
        if (!file.exists()) {
            try {
                file.createNewFile();
            } catch (IOException ioException) {
                ioException.printStackTrace();
                Log.i("savePersonData", "error in file");
                return false;
            }
        }

        if (!file.exists()) {
            return false;
        } else {
            try {
                // 如果存在之前的账户信息,应该删除掉
                clearData(file.getAbsolutePath());
                /** 以读写方式建立一个RandomAccessFile对象 */
                RandomAccessFile raf = new RandomAccessFile(file, "rws");
                Log.i("savePersonData",
                        "RandomAccessFile文件指针的初始位置:" + raf.getFilePointer());
                // 将记录指针移动到文件最前
                raf.seek(0);// 确保是最后一次登录用户 如果是多用户登录，此处应去掉
                raf.write((headMsg + "\r\n").getBytes("utf-8"));// 头部信息，区分是账号登录还是第三方登录
                                                                // 注意会出现乱码
                raf.write((accountInforma + "\r\n").getBytes("utf-8")); // 这里包含账号登录时,存储账号名和密码;第三方登录时,存储thirdIdentify和openId
                                                                        // 注意会出现乱码
                raf.write((imgUrl + "\r\n").getBytes("utf-8")); // 注意会出现乱码
                if (!TextUtils.isEmpty(username)) {
                    raf.write((username + "\r\n").getBytes("utf-8")); // 注意会出现乱码
                } else {
                    raf.write(("上一次登录用户" + "\r\n").getBytes("utf-8")); // 注意会出现乱码
                }
                raf.close();
            } catch (Exception e) {
                e.printStackTrace();
                Log.i("savePersonData", "error in write");
                return false;
            }
            Log.i("savePersonData", "Success");
            return true;
        }
    }

    /**
     * 更新用户信息
     * 
     * @param context
     * @param imgUrl
     * @param username
     * @return
     */
    public static boolean updatePersonData(Context context, String imgUrl,
            String username) {
        if (context == null || TextUtils.isEmpty(imgUrl)) {
            Log.i("updatePersonData", "message is null");
            return false;
        }

        File file = new File(context.getFilesDir(), "ledonPerson.txt");
        List<String> personMsg = new ArrayList<String>();
        if (file.exists()) {
            /** 以读写方式建立一个RandomAccessFile对象 */
            try {
                RandomAccessFile raf = new RandomAccessFile(file, "rws");
                Log.i("updatePersonData",
                        "RandomAccessFile文件指针的初始位置:" + raf.getFilePointer());
                // 将记录指针移动到文件最前
                raf.seek(0);

                byte[] buff = new byte[1024];
                int hasRead = 0;
                String data = null;
                while ((hasRead = raf.read(buff)) > 0) {
                    // 打印读取的内容，并将字节转为字符串输入 存在乱码问题
                    String str = new String(buff, 0, hasRead);
                    Log.i("updatePersonData", "personData:" + str);
                    data = str;// 如果是多用户登录,此处得加信息判断
                }

                Log.i("updatePersonData",
                        "RandomAccessFile文件指针的位置:" + raf.getFilePointer());

                String[] strArray = data.split("\r\n");
                for (int i = 0; i < strArray.length; i++) {
                    personMsg.add(strArray[i]);
                }
                strArray = null;
                Log.i("updatePersonData", "msg length:" + personMsg.size());
                personMsg.set(personMsg.size() - 2, imgUrl);
                personMsg.set(personMsg.size() - 1, username);

                clearData(file.getAbsolutePath());
                // 将记录指针移动到文件最前
                raf.seek(0);// 确保是最后一次登录用户 如果是多用户登录，此处应去掉

                for (int i = 0; i < personMsg.size(); i++) {
                    if (i != personMsg.size() - 1) {
                        raf.write((personMsg.get(i) + "\r\n").getBytes("utf-8"));
                    } else {
                        if (!TextUtils.isEmpty(personMsg.get(i))) {
                            raf.write((personMsg.get(i) + "\r\n")
                                    .getBytes("utf-8")); // 注意会出现乱码
                        } else {
                            raf.write(("上一次登录用户" + "\r\n").getBytes("utf-8")); // 注意会出现乱码
                        }
                    }
                }
                /*
                 * raf.write((headMsg + "\r\n").getBytes("utf-8"));//
                 * 头部信息，区分是账号登录还是第三方登录 // 注意会出现乱码 raf.write((accountInforma +
                 * "\r\n").getBytes("utf-8")); //
                 * 这里包含账号登录时,存储账号名和密码;第三方登录时,存储thirdIdentify和openId // 注意会出现乱码
                 * raf.write((imgUrl + "\r\n").getBytes("utf-8")); // 注意会出现乱码 if
                 * (!TextUtils.isEmpty(username)) { raf.write((username +
                 * "\r\n").getBytes("utf-8")); // 注意会出现乱码 } else {
                 * raf.write(("上一次登录用户" + "\r\n").getBytes("utf-8")); // 注意会出现乱码
                 * }
                 */

                raf.close();

            } catch (Exception e) {
                e.printStackTrace();
                Log.i("updatePersonData", "error in write");
                return false;
            }

        }
        Log.i("updatePersonData", "Success");
        return true;
    }

    /**
     * 清空数据
     * 
     * @param path
     */
    public static void clearData(String path) {
        try {
            BufferedWriter bw = new BufferedWriter(new FileWriter(
                    new File(path)));

            bw.write("");
            bw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            Log.i("savePersonData", "clearData error");
            e.printStackTrace();
        }

    }

    /**
     * 获取最后一次登录账户的信息
     * 
     * @param context
     *            上下文对象
     * @return
     */
    public static List<String> getPersonData(Context context) {
        File file = new File(context.getFilesDir(), "ledonPerson.txt");
        List<String> personMsg = new ArrayList<String>();
        if (file.exists()) {

            try {
                /** 以读写方式建立一个RandomAccessFile对象 */
                RandomAccessFile raf = new RandomAccessFile(file, "rws");
                Log.i("getPersonData",
                        "RandomAccessFile文件指针的初始位置:" + raf.getFilePointer());
                // 将记录指针移动到文件最前
                raf.seek(0);

                byte[] buff = new byte[1024];
                int hasRead = 0;
                String data = null;
                while ((hasRead = raf.read(buff)) > 0) {
                    // 打印读取的内容，并将字节转为字符串输入 存在乱码问题
                    String str = new String(buff, 0, hasRead);
                    Log.i("getPersonData", "personData:" + str);
                    data = str;// 如果是多用户登录,此处得加信息判断
                }
                raf.close();

                String[] strArray = data.split("\r\n");
                for (int i = 0; i < strArray.length; i++) {
                    // Log.i("getPersonData", "strArray :" + strArray[i]);
                    personMsg.add(strArray[i]);
                }
                strArray = null;
                Log.i("getPersonData", "msg length:" + personMsg.size());
                return personMsg;
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
                Log.i("getPersonData", "error");
                return null;
            }

        }

        Log.i("getPersonData", "file isn't exist");
        return null;

    }

    // 大文件存储，只适应从网络download数据下来，但是网络请求封装已经借由第三方框架实现了

    /**
     * 清除文件 这里只会删除某个文件夹下的文件，如果传入的directory是个文件，将不做处理
     * 
     * @param directory
     *            对应文件夹
     */
    private static void deleteFilesByDirectory(File directory) {
        if (directory != null && directory.exists() && directory.isDirectory()) {
            for (File item : directory.listFiles()) {
                item.delete();
            }
        }
    }

    /**
     * 清除Cache
     * 
     * @param context
     *            上下文对象
     */
    public static void clearCache(Context context) {
        // 内部缓存
        deleteFilesByDirectory(context.getCacheDir());
        if (isSDCardExist()) {
            // 外部cache
            deleteFilesByDirectory(context.getExternalCacheDir());
        }
    }

}

LogUtils：
package ledon.com.retrofitdemo.utils;

import android.util.Log;

/**
* 封装打印工具类 添加控制开启日志的配置:OPENLOG
* 当开发的时候设为true,线上版本设为false
* @author Alba
*
*/
public class LogUtils {

private final static boolean OPENLOG = true;

public static void i(String tag, String content) {
    if (OPENLOG) {
        Log.i(tag, content);
    }

}

public static void v(String tag, String content) {
    if (OPENLOG) {
        Log.v(tag, content);
    }

}

public static void d(String tag, String content) {
    if (OPENLOG) {
        Log.d(tag, content);
    }

}

public static void w(String tag, String content) {
    if (OPENLOG) {
        Log.w(tag, content);
    }

}

public static void e(String tag, String content) {
    if (OPENLOG) {
        Log.e(tag, content);
    }

}

}