Android开发常用工具方法（CommonTools）

在发开Android应用过程中，我们往往添加一个Utils包放置一些帮助方法类（这也是很好的Android开发习惯），这样大大方便了开发时的调取操作、也使得软件维护、更新更为便捷，以下就是我常用的几个util类：有关于网络的、文件操作的等等！ 

转载自：http://blog.csdn.net/zhangtengyuan23/article/details/19295055

public class CommonTools {

	
	
	/**
	 * 短暂显示Toast消息
	 * 
	 * @param context
	 * @param message
	 */
	public static void showShortToast(Context context, String message) {
		LayoutInflater inflater = (LayoutInflater) context
				.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
		View view = inflater.inflate(R.layout.custom_toast, null);
		TextView text = (TextView) view.findViewById(R.id.toast_message);
		text.setText(message);
		Toast toast = new Toast(context);
		toast.setDuration(Toast.LENGTH_SHORT);
		toast.setGravity(Gravity.BOTTOM, 0, 300);
		toast.setView(view);
		toast.show();
	}

	/**
	 * 根据手机分辨率从dp转成px
	 * 
	 * @param context
	 * @param dpValue
	 * @return
	 */
	public static int dip2px(Context context, float dpValue) {
		final float scale = context.getResources().getDisplayMetrics().density;
		return (int) (dpValue * scale + 0.5f);
	}

	/**
	 * 根据手机的分辨率从 px(像素) 的单位 转成为 dp
	 */
	public static int px2dip(Context context, float pxValue) {
		final float scale = context.getResources().getDisplayMetrics().density;
		return (int) (pxValue / scale + 0.5f) - 15;
	}

	/**
	 * 获取手机状态栏高度
	 * 
	 * @param context
	 * @return
	 */
	public static int getStatusBarHeight(Context context) {
		Class<?> c = null;
		Object obj = null;
		java.lang.reflect.Field field = null;
		int x = 0;
		int statusBarHeight = 0;
		try {
			c = Class.forName("com.android.internal.R$dimen");
			obj = c.newInstance();
			field = c.getField("status_bar_height");
			x = Integer.parseInt(field.get(obj).toString());
			statusBarHeight = context.getResources().getDimensionPixelSize(x);
			return statusBarHeight;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return statusBarHeight;
	}

	
	/**
	 * 判断手机号码*/
	public static boolean isMobileNO(String mobiles){
		
		Pattern pattern = Pattern.compile("^((13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$");  
		Matcher matcher = pattern.matcher(mobiles);  
		
		return matcher.matches();
		
	}
	
	
}

关于网络判断的类NetworkUtils

public class NetworkUtils {

	/**
	 * 网络是否可用
	 * 
	 * @param activity
	 * @return
	 */
	public static boolean isNetworkAvailable(Context context) {
		ConnectivityManager connectivity = (ConnectivityManager) context
				.getSystemService(Context.CONNECTIVITY_SERVICE);
		if (connectivity == null) {
		} else {
			NetworkInfo[] info = connectivity.getAllNetworkInfo();
			if (info != null) {
				for (int i = 0; i < info.length; i++) {
					if (info[i].getState() == NetworkInfo.State.CONNECTED) {
						return true;
					}
				}
			}
		}
		return false;
	}

	/**
	 * 网络连接提示
	 * 
	 * @param context
	 * @return
	 */
	public static void networkStateTips(Context context) {
		if (!isNetworkAvailable(context)) {
			CommonTools.showShortToast(context, "网络故障，请先检查网络连接");
		}
	}

	/**
	 * Gps是否打开
	 * 
	 * @param context
	 * @return
	 */
	public static boolean isGpsEnabled(Context context) {
		LocationManager locationManager = ((LocationManager) context
				.getSystemService(Context.LOCATION_SERVICE));
		List<String> accessibleProviders = locationManager.getProviders(true);
		return accessibleProviders != null && accessibleProviders.size() > 0;
	}

	/**
	 * wifi是否打开
	 */
	public static boolean isWifiEnabled(Context context) {
		ConnectivityManager mgrConn = (ConnectivityManager) context
				.getSystemService(Context.CONNECTIVITY_SERVICE);
		TelephonyManager mgrTel = (TelephonyManager) context
				.getSystemService(Context.TELEPHONY_SERVICE);
		return ((mgrConn.getActiveNetworkInfo() != null && mgrConn
				.getActiveNetworkInfo().getState() == NetworkInfo.State.CONNECTED) || mgrTel
				.getNetworkType() == TelephonyManager.NETWORK_TYPE_UMTS);
	}

	/**
	 * 判断当前网络是否是wifi网络
	 * if(activeNetInfo.getType()==ConnectivityManager.TYPE_MOBILE) { //判断3G网
	 * 
	 * @param context
	 * @return boolean
	 */
	public static boolean isWifi(Context context) {
		ConnectivityManager connectivityManager = (ConnectivityManager) context
				.getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
		if (activeNetInfo != null
				&& activeNetInfo.getType() == ConnectivityManager.TYPE_WIFI) {
			return true;
		}
		return false;
	}

	/**
	 * 判断当前网络是否是3G网络
	 * 
	 * @param context
	 * @return boolean
	 */
	public static boolean is3G(Context context) {
		ConnectivityManager connectivityManager = (ConnectivityManager) context
				.getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
		if (activeNetInfo != null
				&& activeNetInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
			return true;
		}
		return false;
	}
}

文件操作类FileUtils

public class FileUtils {
    private final static String t = "FileUtils";

    // Used to validate and display valid form names.
    public static final String VALID_FILENAME = "[ _\\-A-Za-z0-9]*.x[ht]*ml";

    // Storage paths
    public static final String FORMS_PATH = Environment.getExternalStorageDirectory() + "/odk/forms/";
    public static final String INSTANCES_PATH = Environment.getExternalStorageDirectory() + "/odk/instances/";
    public static final String CACHE_PATH = Environment.getExternalStorageDirectory() + "/odk/.cache/";
    public static final String TMPFILE_PATH = CACHE_PATH + "tmp.jpg";

    
    public static ArrayList<String> getValidFormsAsArrayList(String path) {
        ArrayList<String> formPaths = new ArrayList<String>();
        File dir = new File(path);

        if (!storageReady()) {
            return null;
        }
        if (!dir.exists()) {
            if (!createFolder(path)) {
                return null;
            }
        }
        File[] dirs = dir.listFiles();
        for (int i = 0; i < dirs.length; i++) {
          // skip all the directories
          if (dirs[i].isDirectory())
            continue;
          
            String formName = dirs[i].getName();

          formPaths.add(dirs[i].getAbsolutePath());
        }
        return formPaths;
    }

    public static ArrayList<String> getFoldersAsArrayList(String path) {
        ArrayList<String> mFolderList = new ArrayList<String>();
        File root = new File(path);

        if (!storageReady()) {
            return null;
        }
        if (!root.exists()) {
            if (!createFolder(path)) {
                return null;
            }
        }
        if (root.isDirectory()) {
            File[] children = root.listFiles();
            for (File child : children) {
                boolean directory = child.isDirectory();
                if (directory) {
                    mFolderList.add(child.getAbsolutePath());
                }
            }
        }
        return mFolderList;
    }


    public static boolean deleteFolder(String path) {
        // not recursive
        if (path != null && storageReady()) {
            File dir = new File(path);
            if (dir.exists() && dir.isDirectory()) {
                File[] files = dir.listFiles();
                for (File file : files) {
                    if (!file.delete()) {
                        Log.i(t, "Failed to delete " + file);
                    }
                }
            }
            return dir.delete();
        } else {
            return false;
        }
    }


    public static boolean createFolder(String path) {
        if (storageReady()) {
            boolean made = true;
            File dir = new File(path);
            if (!dir.exists()) {
                made = dir.mkdirs();
            }
            return made;
        } else {
            return false;
        }
    }


    public static boolean deleteFile(String path) {
        if (storageReady()) {
            File f = new File(path);
            return f.delete();
        } else {
            return false;
        }
    }


    public static byte[] getFileAsBytes(File file) {
        byte[] bytes = null;
        InputStream is = null;
        try {
            is = new FileInputStream(file);

            // Get the size of the file
            long length = file.length();
            if (length > Integer.MAX_VALUE) {
                Log.e(t, "File " + file.getName() + "is too large");
                return null;
            }

            // Create the byte array to hold the data
            bytes = new byte[(int) length];

            // Read in the bytes
            int offset = 0;
            int read = 0;
            try {
                while (offset < bytes.length && read >= 0) {
                    read = is.read(bytes, offset, bytes.length - offset);
                    offset += read;
                }
            } catch (IOException e) {
                Log.e(t, "Cannot read " + file.getName());
                e.printStackTrace();
                return null;
            }

            // Ensure all the bytes have been read in
            if (offset < bytes.length) {
                try {
                    throw new IOException("Could not completely read file " + file.getName());
                } catch (IOException e) {
                    e.printStackTrace();
                    return null;
                }
            }

            return bytes;

        } catch (FileNotFoundException e) {
            Log.e(t, "Cannot find " + file.getName());
            e.printStackTrace();
            return null;

        } finally {
            // Close the input stream
            try {
                is.close();
            } catch (IOException e) {
                Log.e(t, "Cannot close input stream for " + file.getName());
                e.printStackTrace();
                return null;
            }
        }
    }


    public static boolean storageReady() {
        String cardstatus = Environment.getExternalStorageState();
        if (cardstatus.equals(Environment.MEDIA_REMOVED)
                || cardstatus.equals(Environment.MEDIA_UNMOUNTABLE)
                || cardstatus.equals(Environment.MEDIA_UNMOUNTED)
                || cardstatus.equals(Environment.MEDIA_MOUNTED_READ_ONLY)) {
            return false;
        } else {
            return true;
        }
    }


    public static String getMd5Hash(File file) {
        try {
            // CTS (6/15/2010) : stream file through digest instead of handing it the byte[]
            MessageDigest md = MessageDigest.getInstance("MD5");
            int chunkSize = 256;

            byte[] chunk = new byte[chunkSize];

            // Get the size of the file
            long lLength = file.length();

            if (lLength > Integer.MAX_VALUE) {
                Log.e(t, "File " + file.getName() + "is too large");
                return null;
            }

            int length = (int) lLength;

            InputStream is = null;
            is = new FileInputStream(file);

            int l = 0;
            for (l = 0; l + chunkSize < length; l += chunkSize) {
                is.read(chunk, 0, chunkSize);
                md.update(chunk, 0, chunkSize);
            }

            int remaining = length - l;
            if (remaining > 0) {
                is.read(chunk, 0, remaining);
                md.update(chunk, 0, remaining);
            }
            byte[] messageDigest = md.digest();

            BigInteger number = new BigInteger(1, messageDigest);
            String md5 = number.toString(16);
            while (md5.length() < 32)
                md5 = "0" + md5;
            is.close();
            return md5;

        } catch (NoSuchAlgorithmException e) {
            Log.e("MD5", e.getMessage());
            return null;

        } catch (FileNotFoundException e) {
            Log.e("No Cache File", e.getMessage());
            return null;
        } catch (IOException e) {
            Log.e("Problem reading from file", e.getMessage());
            return null;
        } 
        

    }

}

数据库操作

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.zz.zzdbase;

import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;

@SuppressWarnings({"unused" })
public class citybase {

	private SQLiteDatabase dbase;
	private Cursor cursor;
	private Cursor exeCheckCursor;
	private Cursor _cursor;

	public boolean open(String dbPath) {
		
		
		if(dbase!=null)
			return true;
		
		try
		{
			dbase = SQLiteDatabase.openDatabase(dbPath, null,
			SQLiteDatabase.OPEN_READWRITE);
            if(dbase==null)
            {
            	 dbase = SQLiteDatabase.openOrCreateDatabase(dbPath, null);
            }
            return true;
		}catch (Exception e) {
			
			 return false;
		}
		    
               
	}

	public void close() {
		if(cursor!=null)
			cursor.close();
		if(_cursor!=null)
			_cursor.close();
		if(dbase!=null)
			dbase.close();
		dbase = null;
	}
     
	
	public Cursor GetCursor()
	{
		return cursor;
	}
	
	public void cursorClose()
    {
		cursor.close();
    }

	public boolean exeNoQuery(String sql) 
	{
		Boolean b = true;
		try 
		{
			dbase.execSQL(sql);
		} catch (Exception e) {
			b = false;
		}
		return b;
	}

	public boolean exeQuery(String sql) 
    {
		Boolean b = true;
		try 
		{
			cursor = dbase.rawQuery(sql, null);
            if(cursor==null)
               return false;
		} catch (Exception e)
        {
            String s=e.getMessage();
            b = false;
		}
		return b;
	}
	
	
	public SQLiteDatabase GetDB()
	{
		return dbase;
	}
	
	
	public boolean exeCheckQuery(String sql) 
    {
		Boolean b = true;
		try 
		{
			exeCheckCursor = dbase.rawQuery(sql, null);
            if(exeCheckCursor==null)
               return false;
		} catch (Exception e)
        {
            String s=e.getMessage();
            b = false;
		}
		return b;
	}
	
	public Boolean nextExeRecorCheck()
	{
		return exeCheckCursor.moveToNext();
	} 
	
	public void cursorExeCloseCheck()
    {
		exeCheckCursor.close();
    }
	
	
	public Boolean exeQueryTemp(String sql)
	{
		Boolean b = true;
		try 
		{
			_cursor = dbase.rawQuery(sql, null);
            if(_cursor==null)
               return false;
		} catch (Exception e)
        {
            String s=e.getMessage();
            b = false;
		}
		return b;
	}
	
	private Cursor checkCursor;
	public Boolean exeQueryCheck(String sql)
	{
		Boolean b = true;
		try 
		{
			checkCursor = dbase.rawQuery(sql, null);
            if(checkCursor==null)
               return false;
		} catch (Exception e)
        {
            String s=e.getMessage();
            b = false;
		}
		return b;
	}
	
	public Boolean eQueryCheck(String sql)
	{
		Boolean b = true;
		try 
		{
			checkCursor = dbase.rawQuery(sql, null);
            if(checkCursor==null)
               return false;
		} catch (Exception e)
        {
            String s=e.getMessage();
            b = false;
		}
		return b;
	}
	
	
	public Boolean nextRecorCheck()
	{
		return checkCursor.moveToNext();
	} 
	
	public void cursorCloseCheck()
    {
		checkCursor.close();
    }

	
	
	public Boolean nextRecordTemp()
	{
		Boolean flag = _cursor.moveToNext();
		return flag;
	}
	
	public void cursorCloseTemp()
    {
		_cursor.close();
    }

	
	
	public boolean nextRecord() 
	{
		if(cursor==null)
			return false;
		
		return cursor.moveToNext();
    }
	
	
	
	
    public boolean moveToFirst()
    {
        return cursor.moveToFirst();
    }

	public int GetInteger(int colm) {
		return cursor.getInt(colm);
	}

	public String GetString(int colm) {
		return cursor.getString(colm);
	}
	
	public String GetCheckString(int colm)
	{
		return checkCursor.getString(colm);
	}
	
	public String GetStringTmp(int colm) {
		return _cursor.getString(colm);
	}
	
	public double GetDouble(int colm) {
		return cursor.getDouble(colm);
	}

	public int GetColumnType(int colm) 
    {
		//return cursor.getType(colm);
            return 1;
	}

	public int GetColumnCount() {
		return cursor.getColumnCount();
	}

	public String GetFieldName(int colm) {
		return cursor.getColumnName(colm);
	}

	public int GetRecordNum() {
		
		
		return cursor.getCount();
	}

	public byte[] GetBolb(int colm) {
		return cursor.getBlob(colm);
	}
        
        public boolean checkDataBase(String databaseFilename) 
        {

            SQLiteDatabase checkDB = null;

            try
            {

			//String databaseFilename = DATABASE_PATH + DATABASE_FILENAME;

			checkDB = SQLiteDatabase.openDatabase(databaseFilename, null,
					SQLiteDatabase.OPEN_READONLY);

            } 
            catch (SQLiteException e)
            {
			// database does't exist yet.
            }

            if (checkDB != null)
            {
			checkDB.close();
            }
            return checkDB != null ? true : false;
	}
}