Android中一些自己使用的小軲轆

1.BaseFragment

package com.example.administrator.smartbj.fragment;

import android.app.Activity;
import android.os.Bundle;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import com.example.administrator.smartbj.activity.MainActivity;

/**
 * 作者：Created by Kevin on 2016/1/13.
 * 郵箱：[email protected]
 * 描述：fragment的基類
 */
public abstract class BaseFragment extends Fragment {

    public Activity mActivity;

    //fragment被創建
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mActivity = getActivity();
    }

    //處理fragment的佈局
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return initView();
    }


    //依附的Activity被創建完成
    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        initData();
        initListener();
    }

    //子類必須實現
    public abstract View initView();

    public void initData(){

    }
    public void initListener() {

    }

}

2.日誌輸出工具類LogUtil

import android.util.Log;

public class LogUtils {
    /** 日誌輸出級別NONE */

    public static final int LEVEL_NONE = 0;

    /** 日誌輸出級別V */

    public static final int LEVEL_VERBOSE = 1;

    /** 日誌輸出級別D */

    public static final int LEVEL_DEBUG = 2;

    /** 日誌輸出級別I */

    public static final int LEVEL_INFO = 3;

    /** 日誌輸出級別W */

    public static final int LEVEL_WARN = 4;

    /** 日誌輸出級別E */

    public static final int LEVEL_ERROR = 5;


    /** 日誌輸出時的TAG */

    private static String mTag = "googleplay";

    /** 是否允許輸出log */

    private static int mDebuggable = LEVEL_ERROR;


    /** 用於記時的變量 */

    private static long mTimestamp = 0;


    /** 以級別爲 d 的形式輸出LOG */

    public static void v(String msg) {

        if (mDebuggable >= LEVEL_VERBOSE) {

            Log.v(mTag, msg);

        }

    }

    /** 以級別爲 d 的形式輸出LOG */

    public static void d(String msg) {

        if (mDebuggable >= LEVEL_DEBUG) {

            Log.d(mTag, msg);

        }

    }

    /** 以級別爲 i 的形式輸出LOG */

    public static void i(String msg) {

        if (mDebuggable >= LEVEL_INFO) {

            Log.i(mTag, msg);

        }

    }

    /** 以級別爲 w 的形式輸出LOG */

    public static void w(String msg) {

        if (mDebuggable >= LEVEL_WARN) {

            Log.w(mTag, msg);

        }

    }

    /** 以級別爲 w 的形式輸出Throwable */

    public static void w(Throwable tr) {

        if (mDebuggable >= LEVEL_WARN) {

            Log.w(mTag, "", tr);

        }

    }

    /** 以級別爲 w 的形式輸出LOG信息和Throwable */

    public static void w(String msg, Throwable tr) {

        if (mDebuggable >= LEVEL_WARN && null != msg) {

            Log.w(mTag, msg, tr);

        }

    }

    /** 以級別爲 e 的形式輸出LOG */

    public static void e(String msg) {

        if (mDebuggable >= LEVEL_ERROR) {

            Log.e(mTag, msg);

        }

    }

    /** 以級別爲 e 的形式輸出Throwable */

    public static void e(Throwable tr) {

        if (mDebuggable >= LEVEL_ERROR) {

            Log.e(mTag, "", tr);

        }

    }

    /** 以級別爲 e 的形式輸出LOG信息和Throwable */

    public static void e(String msg, Throwable tr) {

        if (mDebuggable >= LEVEL_ERROR && null != msg) {

            Log.e(mTag, msg, tr);

        }

    }

    /** 以級別爲 e 的形式輸出msg信息,附帶時間戳，用於輸出一個時間段結束點* @param msg 需要輸出的msg */

    public static void elapsed(String msg) {

        long currentTime = System.currentTimeMillis();

        long elapsedTime = currentTime - mTimestamp;

        mTimestamp = currentTime;

        e("[Elapsed：" + elapsedTime + "]" + msg);

    }

}

3.UIUtils

import android.content.Context;
import android.content.res.Resources;
import android.os.*;

import com.example.administrator.googleplay.base.BaseApplication;

/**
 * 作者：Created by Kevin on 2016/1/24.
 * 郵箱：[email protected]
 * 描述：UI相關的工具類
 */
public class UIUtils {

    public static String getPackageName() {
        return getContext().getPackageName();
    }

    /**
     * 得到上下文
     * @return
     */
    public static Context getContext() {
        return BaseApplication.getContext();
    }

    /**
     * 得到Resources對象
     * @return
     */
    public static Resources getResoure(){
        return getContext().getResources();
    }

    /**
     * 得到String.xml中的字符串
     * @param resId
     * @return
     */
    public static String getString(int resId) {
        return getResoure().getString(resId);
    }

    /**
     * 得到String.xml中的字符串數組
     * @param resId
     * @return
     */
    public static String[] getStringArr(int resId) {
        return getResoure().getStringArray(resId);
    }

    /**
     * 得到Color.xml中的顏色
     * @param colorId
     * @return
     */
    public static int getColor(int colorId) {
        return getResoure().getColor(colorId);
    }

    /**
     * 得到當前主線程ID
     * @return
     */
    public static long getMainThreadId(){
        return BaseApplication.getMainThreadId();
    }

    /**
     * 得到主線程的Handler
     * @return
     */
    public static Handler getMainThreadHandler(){
        return BaseApplication.getHandler();
    }

    /**
     * 安全的執行一個任務
     * @param task
     */
    public static void postSafely(Runnable task){
        //得到當前線程的id
        int curThreadId = android.os.Process.myTid();
        //如果當前線程爲主線程
        if (curThreadId == getMainThreadId()){
            task.run();
        }else {//如果當前線程不是主線程
            getMainThreadHandler().post(task);
        }

    }
}

4.線程池

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 作者：Created by Kevin on 2016/1/27.
 * 郵箱：[email protected]
 * 描述：創建線程，執行任務，提交任務
 */
public class ThreadPoolProxy {
    ThreadPoolExecutor mExecutor;

    int mCorePoolSize;
    int mMaximumPoolSize;
    long mKeepAliveTime;

    public ThreadPoolProxy(int CorePoolSize, int MaximumPoolSize, long KeepAliveTime) {
        this.mCorePoolSize = CorePoolSize;
        this.mMaximumPoolSize = MaximumPoolSize;
        this.mKeepAliveTime = KeepAliveTime;
    }


    private ThreadPoolExecutor initThreadPoolExecutor() {
        //使用單列設計模式,雙重檢查加鎖
        if (mExecutor == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mExecutor == null) {
                    TimeUnit unit = TimeUnit.MILLISECONDS;
                    BlockingQueue<Runnable> workQueue = new LinkedBlockingDeque<>();//無界隊列
                    ThreadFactory threadFactory = Executors.defaultThreadFactory();
                    RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();//丟棄任務並拋出異常

                    mExecutor = new ThreadPoolExecutor(mCorePoolSize, mMaximumPoolSize, mKeepAliveTime, unit, workQueue, threadFactory, handler);
                }
            }
        }


        return mExecutor;
    }

    /**
     * 執行任務
     */
    public void execute(Runnable task) {
        initThreadPoolExecutor();
        mExecutor.execute(task);
    }


    /**
     * 提交任務
     */
    public Future<?> submit(Runnable task) {
        initThreadPoolExecutor();
        return mExecutor.submit(task);
    }

    /**
     * 移除任務
     */
    public void removeTask(Runnable task) {
        initThreadPoolExecutor();
        mExecutor.remove(task);
    }
}

5.線程池工廠

import com.example.administrator.googleplay.manager.ThreadPoolProxy;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 作者：Created by Kevin on 2016/1/27.
 * 郵箱：[email protected]
 * 描述：線程池的工廠
 */
public class ThreadPoolFactory {

    static ThreadPoolProxy mNormalPool;
    static ThreadPoolProxy mDownloadPool;

    //普通線程池
    public static ThreadPoolProxy getNormalPool() {
        //使用單列設計模式,雙重檢查加鎖
        if (mNormalPool == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mNormalPool == null) {
                    mNormalPool = new ThreadPoolProxy(5, 5, 3000);
                }
            }
        }


        return mNormalPool;
    }

    //下載線程池
    public static ThreadPoolProxy getDownloadPool() {
        //使用單列設計模式,雙重檢查加鎖
        if (mDownloadPool == null) {
            synchronized (ThreadPoolProxy.class) {
                if (mDownloadPool == null) {
                    mDownloadPool = new ThreadPoolProxy(3, 3, 3000);
                }
            }
        }

        return mDownloadPool;
    }

}

6.BaseAdapter的封裝

import java.util.List;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
/**
 * BaseAdapter的封裝
 * @param <T>
 */
public abstract class CommonAdapter<T>  extends BaseAdapter {
  protected List<T> mDatas;
  protected LayoutInflater mInflater;  
  protected Context mContext; 
  protected int layoutId;
  public CommonAdapter(Context ctx,List<T> lists,int layoutId){
    this.mDatas=lists;
    mInflater=(LayoutInflater)   ctx.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    this.mContext=ctx;
    this.layoutId=layoutId;
  }
  @Override
  public int getCount() {
    return mDatas.size();
  }
  @Override
  public Object getItem(int position) {
    return mDatas.get(position);
  }
  @Override
  public long getItemId(int position) {
    return position;
  }
  @Override
  public View getView(int position, View convertView, ViewGroup parent) {
    ViewHolder vh=ViewHolder.getViewHolder(convertView, mContext, parent, layoutId, position);
    convert(vh, mDatas.get(position));
    return vh.getConvertView();
  }
  abstract protected void convert(ViewHolder vh,T item);
}       

7.ViewHolder

import android.content.Context;
import android.util.SparseArray;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
/**
 * ViewHolder的封裝 
 */
public class ViewHolder {
   private final SparseArray<View> mView;   
   private View mConvertView;
   public ViewHolder(Context context, ViewGroup parent, int layoutId, int position){
     this.mView=new SparseArray<View>();
     mConvertView = LayoutInflater.from(context).inflate(layoutId, parent, false);  
     mConvertView.setTag(this);
   };
   /**
  * 獲得viewholder
  * @param convertView
  * @param context
  * @param parent
  * @param layoutId
  * @param position
  * @return
  */
   public static ViewHolder getViewHolder(View convertView,Context context,ViewGroup parent, int layoutId, int position){
     if(null==convertView){
       return new ViewHolder(context, parent, layoutId, position);
     }
     return (ViewHolder) convertView.getTag();
   }
   /**
  * @param id
  * @return
  */
   public  <T extends View> T getView(int id){
     View view=mView.get(id);
     if(null==view){
       view=mConvertView.findViewById(id);
       mView.put(id,view);
     }
     return (T)view;
   }
   public View getConvertView(){
     return mConvertView;
   }
}