HEGII.ft.mes.pda/src/com/jiaju/utils/CommonUtil.java

package com.jiaju.utils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.jiaju.activity.LoginActivity;
import com.jiaju.activity.MakeBilletActivity;
import com.jiaju.activity.R;
import com.jiaju.model.BatchNoModel;
import com.jiaju.model.CartInfo;
import com.jiaju.model.DefectAndDefectDeductionRelation;
import com.jiaju.model.DefectAndDefectFinesRelation;
import com.jiaju.model.DefectDeduction;
import com.jiaju.model.DefectFines;
import com.jiaju.model.DefectLocation;
import com.jiaju.model.DefectNo;
import com.jiaju.model.DutyPerson;
import com.jiaju.model.GlazeModel;
import com.jiaju.model.KilnModel;
import com.jiaju.model.Logo;
import com.jiaju.model.NoGroutingReasonModel;
import com.jiaju.model.PrinterModel;
import com.jiaju.model.ProcedureJobs;
import com.jiaju.model.ProductClassifyInfo;
import com.jiaju.model.ProductDefectInfo;
import com.jiaju.model.ResponsibilityProcedure;
import com.jiaju.model.ReworkProcedureInfo;
import com.jiaju.model.ScrapReason;
import com.jiaju.model.SemiCheckStatus;
import com.jiaju.model.WorkNo;
import com.jiaju.model.WorkType;
import android.annotation.SuppressLint;
import android.annotation.TargetApi;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.Notification;
import android.app.NotificationManager;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.media.AudioFormat;
import android.media.AudioManager;
import android.media.AudioTrack;
import android.media.MediaPlayer;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.net.NetworkInfo.State;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.Environment;
import android.os.IBinder;
 
import android.os.Vibrator;
import android.text.InputFilter;
import android.text.Spanned;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

@SuppressLint("NewApi")
public class CommonUtil {
	static MediaPlayer mp;

	public static boolean isBlank(String str) {
		if (str == null || str.length() == 0
				|| str.toLowerCase().equals("null")) {
			return true;
		}
		return false;
	}

	public static void deleteAllFiles(File root) {  
        File files[] = root.listFiles();  
        if (files != null)  
            for (File f : files) {  
                if (f.isDirectory()) { // 判断是否为文件夹  
                    deleteAllFiles(f);  
                    try {  
                        f.delete();  
                    } catch (Exception e) {  
                    }  
                } else {  
                    if (f.exists()) { // 判断是否存在  
                        deleteAllFiles(f);  
                        try {  
                            f.delete();  
                        } catch (Exception e) {  
                        }  
                    }  
                }  
            }  
    }
	
	
	
	public static String parseMoney(String pattern,BigDecimal bd){
		DecimalFormat df=new DecimalFormat(pattern);
		    return df.format(bd);
		}
	
	public static String isContainsEnterCharacter(String txt){
		String code="";
		if(txt.contains("\n")){
		  code = txt.trim().replaceAll("\\n", "");
		}
		else if(txt.contains("\r\n")){
			  code = txt.trim().replaceAll("\\r\\n", "");	
		}
		else if(txt.endsWith("\t")){
			  code = txt.trim().replaceAll("\\t", "");		
		}
		return code;
	}
	
	public static void hideKeyboard(MotionEvent event, View view,  
	        Activity activity) {  
	    try {  
	        if (view != null && view instanceof EditText) {  
	            int[] location = { 0, 0 };  
	            view.getLocationInWindow(location);  
	            int left = location[0], top = location[1], right = left  
	                    + view.getWidth(), bootom = top + view.getHeight();  
	            // 判断焦点位置坐标是否在空间内，如果位置在控件外，则隐藏键盘  
	            if (event.getRawX() < left || event.getRawX() > right  
	                    || event.getY() < top || event.getRawY() > bootom) {  
	                // 隐藏键盘  
	                IBinder token = view.getWindowToken();  
	                InputMethodManager inputMethodManager = (InputMethodManager) activity  
	                        .getSystemService(Context.INPUT_METHOD_SERVICE);  
	                inputMethodManager.hideSoftInputFromWindow(token,  
	                        InputMethodManager.HIDE_NOT_ALWAYS);  
	            }  
	        }  
	    } catch (Exception e) {  
	        e.printStackTrace();  
	    }  
	} 

	public static ResponsibilityProcedure getResponsibilityProcedureByProcedureId(
			List<ResponsibilityProcedure> procedureList, int procedureId) {
		ResponsibilityProcedure rp = null;
		for (ResponsibilityProcedure procedure : procedureList) {
			if (procedure.getDutyProcedureId() == procedureId) {
				rp = procedure;
				break;
			}
		}
		return rp;
	}

	public static DefectNo CompareDefectNo(List<DefectNo> defectNoList,
			String defectNo) {
		DefectNo localdefect = null;
		for (DefectNo defect : defectNoList) {
			String code = defect.getDefectCode();
			if (code.equals(defectNo)) {
				localdefect = defect;
				break;
			}
		}
		return localdefect;
	}

	public static DefectLocation CompareDefectLocation(
			List<DefectLocation> defectLocationList, String defectLocation) {
		DefectLocation location = null;
		for (DefectLocation defectlocation : defectLocationList) {
			String loccode = defectlocation.getDefectPositionCode();
			if (loccode.equals(defectLocation)) {
				location = defectlocation;
				break;
			}
		}
		return location;
	}
	
	
	public static String addSpecifiedDay(String today,int days){
	     SimpleDateFormat f =  new SimpleDateFormat("yyyy-MM-dd"); 
	     Date d;
		try {
			d = new Date(f.parse(today).getTime()+days*24*3600*1000);
			  return  f.format(d); 
		} catch (ParseException e) {
			e.printStackTrace();
		    return "";     
		}     
        
	}
		

	public static String dateStringConverter(String datestr) {
		Date date = null;
		String dateString = null;
		DateFormat format1 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
		DateFormat format2 = new SimpleDateFormat("yyyy-MM-dd");
		try {
			date = format1.parse(datestr);
			dateString = format2.format(date);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dateString;

	}
	
	public static Date stringDateConverter(String  dateStr) {
		Date date = null;
		
		DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
		try {
			date = format1.parse(dateStr);
			
		} catch (Exception e) {
			e.printStackTrace();
		}
		return date;
	}

	public static String commonDateConverter(String datestr) {
		Date date = null;
		String dateString = null;
		DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		DateFormat format2 = new SimpleDateFormat("yyyy-MM-dd");
		try {
			date = format1.parse(datestr);
			dateString = format2.format(date);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dateString;

	}
	
	public static String dateFormatConverter(String datestr) {
		Date date = null;
		String dateString = null;
		DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
		DateFormat format2 = new SimpleDateFormat("yyyyMMdd");
		try {
			date = format1.parse(datestr);
			dateString = format2.format(date);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dateString;

	}
	
	public static boolean checkDate(String date,String format) {  
        DateFormat df = new SimpleDateFormat(format);  
        Date d = null;  
        try{  
            d = df.parse(date);  
        }catch(Exception e){  
            //如果不能转换,肯定是错误格式  
            return false;  
        }  
        String s1 = df.format(d);  
        
        return date.equals(s1);  
    }  
	

	public static <T> List<T> deepCopy(List<T> src) throws IOException, ClassNotFoundException {  
	    ByteArrayOutputStream byteOut = new ByteArrayOutputStream();  
	    ObjectOutputStream out = new ObjectOutputStream(byteOut);  
	    out.writeObject(src);  

	    ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());  
	    ObjectInputStream in = new ObjectInputStream(byteIn);  
	    @SuppressWarnings("unchecked")  
	    List<T> dest = (List<T>) in.readObject();  
	    return dest;  
	}  
	
	public static KilnModel GetKilncode(String kilncode,
			List<KilnModel> kilncodelist) {
		KilnModel kilnmodel = null;
		for (KilnModel kiln : kilncodelist) {
		String currentKilnCode=	kiln.getKilinCode();
			if (currentKilnCode.equalsIgnoreCase(kilncode)) {
				kilnmodel = kiln;
				break;
			}
		}
		return kilnmodel;
	}

	public static String dateConverter(String datestr) {
		Date date = null;
		String dateString = null;
		DateFormat format1 = new SimpleDateFormat("dd-MMM-yy HH:mm:ss",
				Locale.ENGLISH);
		DateFormat format2 = new SimpleDateFormat("yyyy-MM-dd");
		try {
			date = format1.parse(datestr);
			dateString = format2.format(date);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return dateString;

	}

	public static int getDefectProductionDataIdByUserId(
			List<WorkNo> worknolist, int userId) {
		int defectProductionDataId = 0;
		for (int i = 0; i < worknolist.size(); i++) {
			WorkNo wn = worknolist.get(i);
			if (wn.getUserId() == userId) {
				defectProductionDataId = (int) wn.getProductionDataId();
				break;
			}
		}
		return defectProductionDataId;
	}

	public static boolean compareStaffInfo(List<DutyPerson> dutyPersonList,
			DutyPerson dp) {
		boolean result = false;
		for (int i = 0; i < dutyPersonList.size(); i++) {
			DutyPerson dutyperson = dutyPersonList.get(i);
			if (dp.getuJobsId() == dutyperson.getuJobsId()
					&& dp.getStaffCode().equals(dutyperson.getStaffCode())) {
				result = true;
			}
		}
		return result;
	}

	public static void BarcodeMaxLength(EditText edt, int maxLength) {
		edt.setFilters(new InputFilter[] { new InputFilter.LengthFilter(
				maxLength) });
	}

	public static String getSpecifiedDayAfter(String specifiedDay) {
		Calendar c = Calendar.getInstance();
		Date date = null;
		try {
			date = new SimpleDateFormat("yyyy-MM-dd").parse(specifiedDay);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		c.setTime(date);
		int day = c.get(Calendar.DATE);
		c.set(Calendar.DATE, day + 1);

		String dayAfter = new SimpleDateFormat("yyyy-MM-dd")
				.format(c.getTime());
		return dayAfter;
	}

	public static void removeDuplicateCartList(List<CartInfo> cartlist) {
		for (int i = cartlist.size() - 1; i > 0; i--) {
			CartInfo item = cartlist.get(i);
			for (int j = i - 1; j >= 0; j--) {
				if (cartlist.get(j).getBarcode().equals(item.getBarcode())) {
					cartlist.remove(i);
					break;
				}
			}
		}

	}

	public static boolean CompareDate(String systemDate, String currentDate) {

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date system;
		boolean compareresult = false;
		try {
			system = sdf.parse(systemDate);
			Date current = sdf.parse(currentDate);
			if (current.before(system)) {
				compareresult = false;
			} else {
				compareresult = true;
			}
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return compareresult;

	}

	public static void playSound(Context context) {
		try {
			mp = MediaPlayer.create(context, R.raw.sound);
			final AudioManager audioMgr = (AudioManager) context
					.getSystemService(Context.AUDIO_SERVICE);
			// final int
			// currentVolume=audioMgr.getStreamVolume(AudioManager.STREAM_SYSTEM);
			int maxVolume = audioMgr
					.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
			audioMgr.setStreamVolume(AudioManager.STREAM_MUSIC, maxVolume,
					AudioManager.FLAG_PLAY_SOUND);
			mp.start();
			mp.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
				// @Override
				/* 覆盖文件播出完毕事件 */
				public void onCompletion(MediaPlayer arg0) {
					mp.release();
					// audioMgr.setStreamVolume(AudioManager.STREAM_SYSTEM,currentVolume,AudioManager.FLAG_PLAY_SOUND);
				}
			});

			mp.setOnErrorListener(new MediaPlayer.OnErrorListener() {
				@Override
				/* 覆盖错误处理事件 */
				public boolean onError(MediaPlayer arg0, int arg1, int arg2) {
					/* 发生错误时也解除资源与MediaPlayer的赋值 */
					mp.release();
					return false;
				}
			});

		} catch (Exception e) {
			e.printStackTrace();
		}

	}
	
	public static void playAlertSound(Context context) {
		try {
			mp = MediaPlayer.create(context, R.raw.alert);
			final AudioManager audioMgr = (AudioManager) context
					.getSystemService(Context.AUDIO_SERVICE);
			// final int
			// currentVolume=audioMgr.getStreamVolume(AudioManager.STREAM_SYSTEM);
			int maxVolume = audioMgr
					.getStreamMaxVolume(AudioManager.STREAM_MUSIC);
			audioMgr.setStreamVolume(AudioManager.STREAM_MUSIC, maxVolume,
					AudioManager.FLAG_PLAY_SOUND);
			mp.start();
			mp.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
				// @Override
				/* 覆盖文件播出完毕事件 */
				public void onCompletion(MediaPlayer arg0) {
					mp.release();
					// audioMgr.setStreamVolume(AudioManager.STREAM_SYSTEM,currentVolume,AudioManager.FLAG_PLAY_SOUND);
				}
			});

			mp.setOnErrorListener(new MediaPlayer.OnErrorListener() {
				@Override
				/* 覆盖错误处理事件 */
				public boolean onError(MediaPlayer arg0, int arg1, int arg2) {
					/* 发生错误时也解除资源与MediaPlayer的赋值 */
					mp.release();
					return false;
				}
			});

		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	public static byte[] getFromAssets(Context context, String fileName) {
		byte[] buffer = null;
		try {
			InputStream in = context.getResources().getAssets().open(fileName);
			// 获取文件的字节数
			int lenght = in.available();
			// 创建byte数组
			buffer = new byte[lenght];
			// 将文件中的数据读到byte数组中
			in.read(buffer);

		} catch (Exception e) {
			e.printStackTrace();
		}
		return buffer;
	}

	public static byte[] getFromRaw(Context context, int fileName) {
		byte[] buffer = null;
		try {
			InputStream in = context.getResources().openRawResource(fileName);
			// 获取文件的字节数
			int length = in.available();
			// 创建byte数组
			buffer = new byte[length];
			// 将文件中的数据读到byte数组中
			in.read(buffer);

		} catch (Exception e) {
			e.printStackTrace();
		}
		return buffer;
	}

	public static String getVersionName(Context context) throws Exception {

		// 获取packagemanager的实例
		PackageManager packageManager = context.getPackageManager();
		// getPackageName()是你当前类的包名，0代表是获取版本信息
		PackageInfo packInfo = packageManager.getPackageInfo(
				context.getPackageName(), 0);
		String version = packInfo.versionName;
		return version;
	}

	public static void playSound(Context context, byte[] soundData) {
		int index = 0;
		int offset = 0;
		final int minBufsize = AudioTrack.getMinBufferSize(44100,
				AudioFormat.CHANNEL_OUT_STEREO,// The channel
				AudioFormat.ENCODING_PCM_16BIT);

		AudioTrack aAudioTrack01 = new AudioTrack(AudioManager.STREAM_MUSIC,
				44100, AudioFormat.CHANNEL_OUT_STEREO,
				AudioFormat.ENCODING_PCM_16BIT, minBufsize,
				AudioTrack.MODE_STREAM);
		AudioManager am = (AudioManager) context
				.getSystemService(Context.AUDIO_SERVICE);
		// am.setStreamVolume(AudioManager.STREAM_MUSIC,
		// am.getStreamMaxVolume(AudioManager.STREAM_MUSIC),
		// AudioManager.FLAG_PLAY_SOUND);
		aAudioTrack01.play();
		while (true) {
			try {
				offset = index * minBufsize;
				if (offset >= soundData.length) {
					break;
				}

				aAudioTrack01.write(soundData, offset, minBufsize);
			} catch (Exception e) {

				break;
			}

			index++;
		}

		aAudioTrack01.release();

	}

	public static String getRootFilePath() {
		if (hasSDCard()) {
			return Environment.getExternalStorageDirectory().getAbsolutePath()
					+ "";
		} else {
			return Environment.getDataDirectory().getAbsolutePath() + "/data";
		}
	}

	public static int getTrademarkIndex(String trademarkCode,
			List<Logo> trademarkList) {

		int newposition = -1;
		for (int position = 0; position < trademarkList.size(); position++) {
			if (trademarkCode.equalsIgnoreCase((trademarkList.get(position)
					.getLogoCode()))) {
				newposition = position;
				break;
			}
		}
		return newposition;
	}
	
	public static int getGlazeIndex(String glazeName,
			List<GlazeModel> glazeList) {

		int newposition = -1;
		for (int position = 0; position < glazeList.size(); position++) {
			if (glazeName.equals(glazeList.get(position).getGlazeName())) {
				newposition = position;
				break;
			}
		}
		return newposition;
	}
	
	public static int getPrinterIndex(String printerName,List<PrinterModel>  printerList){
	int newposition=-1;	
	for(int position=0;position<printerList.size();position++)	{
		if(printerName.equalsIgnoreCase(printerList.get(position).getPrinterName())){
			newposition=position;
			break;
		}
	}
		return newposition;
		
	}
	
	public static int getNoGroutingReasonIndex(int noGroutingReasonId,List<NoGroutingReasonModel>  noGroutingReasonList){
	int newposition=-1;	
	for(int position=0;position<noGroutingReasonList.size();position++)	{
		if(noGroutingReasonId==Integer.parseInt(noGroutingReasonList.get(position).getReasonId())){
			newposition=position;
			break;
		}
	}
		return newposition;
		
	}

	public static int getWorkNoIndex(WorkNo updateWorkno,
			List<WorkNo> worknolist) {

		int newposition = 0;
		for (int position = 0; position < worknolist.size(); position++) {
			if (updateWorkno.getUserId() == (worknolist.get(position)
					.getUserId())) {
				newposition = position;
			}
		}
		return newposition;
	}

	public static int getSemiCheckStatusIndex(int semiCheckStatusId,
			List<SemiCheckStatus> semiCheckStatusList) {
		int newposition = 0;
		for (int position = 0; position < semiCheckStatusList.size(); position++) {
			if (semiCheckStatusId == Integer.parseInt(semiCheckStatusList.get(
					position).getSemiCheckTypeId())) {
				newposition = position;
			}
		}
		return newposition;
	}

	public static int getResponsibilityProcedureIndex(
			ResponsibilityProcedure updateProcedure,
			List<ResponsibilityProcedure> procedurelist) {
		int newposition = 0;
		for (int position = 0; position < procedurelist.size(); position++) {
			if (updateProcedure.getDutyProcedureId() == (procedurelist
					.get(position).getDutyProcedureId())) {
				newposition = position;
			}
		}
		return newposition;
	}

	public static int getResponsibilityProcedureIndexById(int procedureId,
			List<ResponsibilityProcedure> procedurelist) {
		int newposition = 0;
		for (int position = 0; position < procedurelist.size(); position++) {
			if (procedureId == (procedurelist.get(position)
					.getDutyProcedureId())) {
				newposition = position;
			}
		}
		return newposition;
	}

	public static ResponsibilityProcedure getResponsibilityProcedureById(
			int procedureId, List<ResponsibilityProcedure> procedurelist) {
		ResponsibilityProcedure rp = null;
		for (int position = 0; position < procedurelist.size(); position++) {
			if (procedureId == (procedurelist.get(position)
					.getDutyProcedureId())) {
				rp = procedurelist.get(position);
				break;
			}
		}
		return rp;
	}

	public static ResponsibilityProcedure getCompleteResonsibilityProcedureById(
			int procedureId, List<ResponsibilityProcedure> procedurelist) {
		ResponsibilityProcedure rp = null;
		for (ResponsibilityProcedure proc : procedurelist) {
			if (procedureId == proc.getDutyProcedureId()) {
				rp = proc;
				break;
			}
		}
		return rp;
	}

	public static String getIpAddress(Context con) {
		// TODO Auto-generated method stub
		// 获取wifi服务
		WifiManager wifiManager = (WifiManager) con
				.getSystemService(Context.WIFI_SERVICE);
		// 判断wifi是否开启
		if (!wifiManager.isWifiEnabled()) {
			wifiManager.setWifiEnabled(true);
		}
		WifiInfo wifiInfo = wifiManager.getConnectionInfo();
		int ipAddress = wifiInfo.getIpAddress();
		String ip = intToIp(ipAddress);
		return ip;
	}

	public static void installApk(String installFilePath, Context context) {
		File apkfile = new File(installFilePath);
		if (!apkfile.exists()) {
			return;
		}
		Intent i = new Intent(Intent.ACTION_VIEW);
		i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
		i.setDataAndType(Uri.parse("file://" + apkfile.toString()),
				"application/vnd.android.package-archive");
		context.startActivity(i);
		android.os.Process.killProcess(android.os.Process.myPid());
	}

	private static String intToIp(int i) {

		return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF)
				+ "." + (i >> 24 & 0xFF);
	}

	public static int getWorktypeIndexByJobsId(int jobsId,
			List<WorkType> worktypeList) {
		int position = 0;
		for (int i = 0; i < worktypeList.size(); i++) {
			if (jobsId == worktypeList.get(i).getJobsID()) {
				position = i;
				break;
			}
		}
		return position;
	}

	public static WorkType getWorktypeByJobsId(int jobsId,
			List<WorkType> worktypeList) {
		WorkType wt = null;
		for (int i = 0; i < worktypeList.size(); i++) {
			if (jobsId == worktypeList.get(i).getJobsID()) {
				wt = worktypeList.get(i);
				break;
			}
		}
		return wt;
	}

	public static ReworkProcedureInfo getReworkProcedureInfoByName(
			String reworkProcedureName,
			List<ReworkProcedureInfo> reworkProcedureList) {
		ReworkProcedureInfo reworkProcedureInfo = null;
		for (int i = 0; i < reworkProcedureList.size(); i++) {
			if (reworkProcedureName.equals(reworkProcedureList.get(i)
					.getReworkProcedureName())) {
				reworkProcedureInfo = reworkProcedureList.get(i);
				break;
			}
		}
		return reworkProcedureInfo;
	}

	public static int getScrapReasonIndex(String sr,
			List<ScrapReason> scrapReasonList) {
		int newposition = 0;
		for (int i = 0; i < scrapReasonList.size(); i++) {
			if (sr.equals(scrapReasonList.get(i).getDictionaryValue())) {
				newposition = i;
			}
		}
		return newposition;
	}

	public static boolean CompareKilncode(String kilncode,
			List<String> kilncodelist) {
		boolean kilnflag = false;
		for (String kiln : kilncodelist) {
			if (kiln.equalsIgnoreCase(kilncode)) {
				kilnflag = true;
			}
		}
		return kilnflag;
	}

	public static List<DefectFines> CompareDefectFinesResult(
			List<DefectFines> orgDefectFinesList,
			List<DefectFines> destDefectFinesList) {
		List<DefectFines> defectFinesResultList = new ArrayList<DefectFines>();
		if (orgDefectFinesList == null) {
			defectFinesResultList.addAll(destDefectFinesList);
		} else {
			for (DefectFines defectFines : orgDefectFinesList) {

				if (destDefectFinesList.contains(defectFines)) {
					defectFinesResultList.add(defectFines);
				}
			}
			if (defectFinesResultList.size() == 0) {
				defectFinesResultList.addAll(destDefectFinesList);

			} else {
				DefectFines df1 = new DefectFines();
				df1.setDefectFinesId(0);
				df1.setDefectFinesName("请选择缺陷扣罚");
				defectFinesResultList.add(0, df1);
			}
		}

		return defectFinesResultList;
	}

	public static List<DefectDeduction> CompareDefectDeductionResult(
			List<DefectDeduction> orgDefectDeductionList,
			List<DefectDeduction> destDefectDeductionList) {
		List<DefectDeduction> defectDeductionResultList = new ArrayList<DefectDeduction>();
		if (orgDefectDeductionList == null) {
			defectDeductionResultList.addAll(destDefectDeductionList);
		} else {
			for (DefectDeduction defectDeduction : orgDefectDeductionList) {
				if (destDefectDeductionList.contains(defectDeduction)) {
					defectDeductionResultList.add(defectDeduction);
				}
			}
			if (defectDeductionResultList.size() == 0) {
				defectDeductionResultList.addAll(destDefectDeductionList);
			} else {
				DefectDeduction df4 = new DefectDeduction();
				df4.setDefectDeductionId(0);
				df4.setDefectDeductionNum("请选择缺陷扣除数");
				defectDeductionResultList.add(0, df4);
			}
		}

		return defectDeductionResultList;
	}

	public static boolean isCurrency(String s) {

		Pattern p = Pattern.compile(
				"^(([1-9]{1}\\d{0,4})|([0]{1}))(\\.(\\d){0,2})?$",
				Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(s);
		return m.matches();

	}
	
	public static boolean isInteger(String s) {

		Pattern p = Pattern.compile(
				"^([1-9]{1}\\d{0,5})?$",
				Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(s);
		return m.matches();

	}

	public static boolean isPositveInteger(String s) {

		Pattern p = Pattern.compile("^([1-9]{1}\\d{0,1})|([0]{1})?$",
				Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(s);
		return m.matches();

	}

	public static String getMacFromWifi(Context context) {
		ConnectivityManager connectivityManager = (ConnectivityManager) context
				.getSystemService(Context.CONNECTIVITY_SERVICE);
		State wifiState = connectivityManager.getNetworkInfo(
				ConnectivityManager.TYPE_WIFI).getState();
		if (wifiState == NetworkInfo.State.CONNECTED) {// 判断当前是否使用wifi连接
			WifiManager wifiManager = (WifiManager) context
					.getSystemService(Context.WIFI_SERVICE);
			if (!wifiManager.isWifiEnabled()) { // 如果当前wifi不可用
				wifiManager.setWifiEnabled(true);
			}
			WifiInfo wifiInfo = wifiManager.getConnectionInfo();
			return wifiInfo.getMacAddress();
		}
		return null;
	}

	public static boolean isNumber(String s) {
		Pattern p = Pattern.compile("[0-9]*");
		Matcher m = p.matcher(s);
		return m.matches();

	}

	public static List<DutyPerson> CompareDutyPersonList(
			List<DutyPerson> originalList, List<DutyPerson> newDutyPersonList) {
		List<DutyPerson> dutyPersonList = null;
		for (int i = 0; i < originalList.size(); i++) {
			int originalstaffId = originalList.get(i).getStaffId();
			for (int j = 0; j < newDutyPersonList.size(); j++) {
				DutyPerson newdp = newDutyPersonList.get(j);
				int newdpId = newdp.getStaffId();
				if (originalstaffId == newdpId) {
					newdp.setCheckStatus(true);
					newDutyPersonList.set(j, newdp);
				}
			}
		}
		dutyPersonList = newDutyPersonList;
		return dutyPersonList;
	}

	public static int getAuditStatusIndexById(int auditStatusId,
			List<DefectFines> auditList) {
		int newposition = 0;
		for (int position = 0; position < auditList.size(); position++) {
			if (auditStatusId == (auditList.get(position).getDefectFinesId())) {
				newposition = position;
			}
		}
		return newposition;
	}

	public static int getJobsIdByProcedureId(int procedureId,
			List<ProcedureJobs> procedureJobList) {
		int jobsId = 0;
		for (ProcedureJobs pj : procedureJobList) {
			if (pj.getProcedureId() == procedureId) {
				jobsId = pj.getJobsId();
				break;
			}
		}
		return jobsId;
	}

	public static int getReworkProcedureId(int reworkProcedureId,
			List<ReworkProcedureInfo> reworkProcedureList) {
		int newposition = 0;

		for (int position = 0; position < reworkProcedureList.size(); position++) {
			if (reworkProcedureId == Integer.parseInt(reworkProcedureList.get(
					position).getReworkProcedureID())) {
				newposition = position;
			}
		}
		return newposition;
	}

	public static void showRepeatDialog(String message, final Context con) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						return;
					}
				}).create();

		alertDialog.show();
	}

	public static int getWorkTypeIndex(WorkType updateWorkType,
			List<WorkType> worktypelist) {
		int newposition = 0;
		for (int position = 0; position < worktypelist.size(); position++) {
			if (updateWorkType.getJobsID() == (worktypelist.get(position)
					.getJobsID())) {
				newposition = position;
			}
		}
		return newposition;
	}
	
	public static int getGroutingBatchNoIndex(String batchNo,List<BatchNoModel> batchNoList)
	{
		int position=-1;
		if(batchNoList!=null&&batchNoList.size()>0)
		{
			for(int i=0;i<batchNoList.size();i++)
			{
				BatchNoModel batchNoModel=batchNoList.get(i);
				if(Double.parseDouble(batchNo)==Double.parseDouble(batchNoModel.getBatchNo()))
						{
					position=i;
					break;
					
						}
			}
		}
		
		return position;
		
	}

	public static int getProductClassifyIndex(int goodsLevelTypeId,
			List<ProductClassifyInfo> productClassifyList) {
		int newposition = 0;
		for (int position = 0; position < productClassifyList.size(); position++) {
			if (goodsLevelTypeId == productClassifyList.get(position)
					.getGoodsLevelTypeID()) {
				newposition = position;
			}
		}
		return newposition;
	}

	public static boolean compareProductDefectInfoList(
			List<ProductDefectInfo> originalProductDefectInfoList,
			ProductDefectInfo newProductDefectInfo) {
		boolean isEquals = false;

		for (ProductDefectInfo original : originalProductDefectInfoList) {
			if (newProductDefectInfo.getDefectNo().getDefectId() == original
					.getDefectNo().getDefectId()
					&& newProductDefectInfo.getDefectLocation()
							.getDefectPositionId() == original
							.getDefectLocation().getDefectPositionId()
					&& newProductDefectInfo.getResponsibilityProcedure()
							.getDutyProcedureId() == original
							.getResponsibilityProcedure().getDutyProcedureId()
					&& newProductDefectInfo.getWorkno().getUserId() == original
							.getWorkno().getUserId()
					&& newProductDefectInfo.getWorkType().getJobsID() == original
							.getWorkType().getJobsID()) {
				isEquals = true;

			}
		}

		return isEquals;

	}

	public static boolean compareCheckCollectDefectInfoList(
			List<ProductDefectInfo> originalProductDefectInfoList,
			ProductDefectInfo newProductDefectInfo) {
		boolean isEquals = false;
		for (ProductDefectInfo original : originalProductDefectInfoList) {
			if (newProductDefectInfo.getDefectNo().getDefectId() == original
					.getDefectNo().getDefectId()
					&& newProductDefectInfo.getDefectLocation()
							.getDefectPositionId() == original
							.getDefectLocation().getDefectPositionId()
					&& newProductDefectInfo.getWorkno().getUserId() == original
							.getWorkno().getUserId()) {
				isEquals = true;

			}
		}

		return isEquals;

	}

	public static boolean hasSDCard() {
		String status = Environment.getExternalStorageState();
		if (!status.equals(Environment.MEDIA_MOUNTED)) {
			return false;
		}
		return true;
	}

	public static boolean CompareServerVersion(String localVersion,
			String ServerVersion) {
		boolean b = false;
		String localVersionNo = localVersion.replace(".", "");
		String serverVersionNo = ServerVersion.replace(".", "");
		if (localVersionNo.startsWith("0")) {
			localVersionNo = localVersionNo.replaceFirst("^0*", "");
		}
		if (serverVersionNo.startsWith("0"))

		{
			serverVersionNo = serverVersionNo.replaceFirst("^0*", "");
		}

		if (Long.parseLong(serverVersionNo) > Long.parseLong(localVersionNo)) {
			b = true;
		}
		return b;

	}

	public static void setDefault(int defaults, Context context) {
		int NOTIFICATIONS_ID = 1;
		NotificationManager mNotificationManager;
		final Notification notification = new Notification();
		notification.defaults = defaults;
		mNotificationManager = (NotificationManager) context
				.getSystemService(context.NOTIFICATION_SERVICE);
		mNotificationManager.notify(NOTIFICATIONS_ID, notification);
	}
	
	
//
//	@SuppressLint("NewApi") 	警告去掉
//	public static void setDefault(int defaults,Context context) {
//	        Vibrator v = (Vibrator) context.getSystemService(Context.VIBRATOR_SERVICE);
//	        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
//	            v.vibrate(VibrationEffect.createOneShot(500, VibrationEffect.DEFAULT_AMPLITUDE));
//	        }
//	        else
//	        {
//	        	
//	    		int NOTIFICATIONS_ID = 1;
//	    		NotificationManager mNotificationManager;
//	    		final Notification notification = new Notification();
//	    		notification.defaults = defaults;
//	    		mNotificationManager = (NotificationManager) context
//	    				.getSystemService(context.NOTIFICATION_SERVICE);
//	    		mNotificationManager.notify(NOTIFICATIONS_ID, notification);
//	            //deprecated in API 26
//	           // v.vibrate(500);
//	        }
//
//	    }


	public static void showAlertDialog(final int status, String message,
			final Context con) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							return;
						} else {
							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);

		alertDialog.show();
	}

	public static void showWorkNoAlertDialog(final int status, String message,
			final Context con, final EditText worknotxt,
			final EditText barcodeEdt, final EditText bugnoEdt,
			final EditText buglocEdt, final int collectType) {
		
		
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							if (collectType == 1) {
								worknotxt.setEnabled(true);
								worknotxt.setText("");
								worknotxt.setFocusable(true);
								worknotxt.setFocusableInTouchMode(true);
								worknotxt.requestFocus();
								worknotxt.findFocus();
								worknotxt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								barcodeEdt.setEnabled(true);
								barcodeEdt.setText("");
								barcodeEdt.setFocusable(true);
								barcodeEdt.setFocusableInTouchMode(true);
								barcodeEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);
								if (bugnoEdt != null) {
									bugnoEdt.setEnabled(true);
									bugnoEdt.setText("");
									bugnoEdt.setFocusable(true);
									bugnoEdt.setFocusableInTouchMode(true);
									bugnoEdt.setFilters(new InputFilter[] { new InputFilter() {
										@Override
										public CharSequence filter(
												CharSequence source, int start,
												int end, Spanned dest,
												int dstart, int dend) {

											return null;
										}
									} });
								}
								if (buglocEdt != null) {
									buglocEdt.setEnabled(true);
									buglocEdt.setText("");
									buglocEdt.setFocusable(true);
									buglocEdt.setFocusableInTouchMode(true);
									buglocEdt
											.setFilters(new InputFilter[] { new InputFilter() {
												@Override
												public CharSequence filter(
														CharSequence source,
														int start, int end,
														Spanned dest,
														int dstart, int dend) {

													return null;
												}
											} });
								}
							} else {
								Activity activity = (Activity) con;
								activity.finish();

							}
							return;
						}

						else {
							if (collectType == 1) {
								worknotxt.setEnabled(true);
								worknotxt.setText("");
								worknotxt.setFocusable(true);
								worknotxt.setFocusableInTouchMode(true);
								worknotxt.requestFocus();
								worknotxt.findFocus();
								worknotxt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								InputMethodManager im = (InputMethodManager) worknotxt
										.getContext().getSystemService(
												Context.INPUT_METHOD_SERVICE);
								im.hideSoftInputFromWindow(
										worknotxt.getWindowToken(),
										InputMethodManager.HIDE_NOT_ALWAYS);

								barcodeEdt.setEnabled(true);
								barcodeEdt.setText("");
								barcodeEdt.setFocusable(true);
								barcodeEdt.setFocusableInTouchMode(true);
								barcodeEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);
								if (bugnoEdt != null) {
									bugnoEdt.setEnabled(true);
									bugnoEdt.setText("");
									bugnoEdt.setFocusable(true);
									bugnoEdt.setFocusableInTouchMode(true);
									bugnoEdt.setFilters(new InputFilter[] { new InputFilter() {
										@Override
										public CharSequence filter(
												CharSequence source, int start,
												int end, Spanned dest,
												int dstart, int dend) {

											return null;
										}
									} });
								}
								if (buglocEdt != null) {

									buglocEdt.setEnabled(true);
									buglocEdt.setText("");
									buglocEdt.setFocusable(true);
									buglocEdt.setFocusableInTouchMode(true);
									buglocEdt
											.setFilters(new InputFilter[] { new InputFilter() {
												@Override
												public CharSequence filter(
														CharSequence source,
														int start, int end,
														Spanned dest,
														int dstart, int dend) {

													return null;
												}
											} });
								}

							} else {
								Activity activity = (Activity) con;
								activity.finish();
							}

							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);
		alertDialog.show();
	}

	public static void showKilncarWorkNoAlertDialog(final int status,
			String message, final Context con, final EditText worknotxt,
			final EditText barcodeEdt, final EditText kilnEdt,
			final EditText kilncarEdt, final int collectType) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							if (collectType == 1) {
								worknotxt.setEnabled(true);
								worknotxt.setText("");
								worknotxt.setFocusable(true);
								worknotxt.setFocusableInTouchMode(true);
								worknotxt.requestFocus();
								worknotxt.findFocus();
								worknotxt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								kilnEdt.setEnabled(true);
								kilnEdt.setFocusable(true);
								kilnEdt.setFocusableInTouchMode(true);

								kilncarEdt.setEnabled(true);
								kilncarEdt.setText("");
								kilncarEdt.setFocusable(true);
								kilncarEdt.setFocusableInTouchMode(true);
								kilncarEdt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
								if (barcodeEdt != null) {
									barcodeEdt.setEnabled(true);
									barcodeEdt.setText("");
									barcodeEdt.setFocusable(true);
									barcodeEdt.setFocusableInTouchMode(true);
								}

							} else {
								Activity activity = (Activity) con;
								activity.finish();
							}
							return;
						} else {
							if (collectType == 1) {
								worknotxt.setEnabled(true);
								worknotxt.setText("");
								worknotxt.setFocusable(true);
								worknotxt.setFocusableInTouchMode(true);
								worknotxt.requestFocus();
								worknotxt.findFocus();
								worknotxt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								InputMethodManager im = (InputMethodManager) worknotxt
										.getContext().getSystemService(
												Context.INPUT_METHOD_SERVICE);
								im.hideSoftInputFromWindow(
										worknotxt.getWindowToken(),
										InputMethodManager.HIDE_NOT_ALWAYS);
								kilnEdt.setEnabled(true);
								kilnEdt.setFocusable(true);
								kilnEdt.setFocusableInTouchMode(true);
								kilncarEdt.setEnabled(true);
								kilncarEdt.setText("");
								kilncarEdt.setFocusable(true);
								kilncarEdt.setFocusableInTouchMode(true);
								kilncarEdt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
								if (barcodeEdt != null) {
									barcodeEdt.setEnabled(true);
									barcodeEdt.setText("");
									barcodeEdt.setFocusable(true);
									barcodeEdt.setFocusableInTouchMode(true);
								}

							} else {
								Activity activity = (Activity) con;
								activity.finish();
							}

							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);
		alertDialog.show();
	}

	public static void showBarCodeAlertDialog(final int status, String message,
			final Context con, final EditText barcodeEdt,
			final EditText bugnoEdt, final EditText buglocEdt) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							if (barcodeEdt != null) {
								barcodeEdt.setEnabled(true);
								barcodeEdt.setText("");
								barcodeEdt.setFocusable(true);
								barcodeEdt.setFocusableInTouchMode(true);
								barcodeEdt.requestFocus();
								barcodeEdt.findFocus();
								barcodeEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);
								InputMethodManager im = (InputMethodManager) barcodeEdt
										.getContext().getSystemService(
												Context.INPUT_METHOD_SERVICE);
								im.hideSoftInputFromWindow(
										barcodeEdt.getWindowToken(),
										InputMethodManager.HIDE_NOT_ALWAYS);
							}
							if (bugnoEdt != null) {
								bugnoEdt.setEnabled(true);
								bugnoEdt.setFocusable(true);
								bugnoEdt.setFocusableInTouchMode(true);
								bugnoEdt.setFilters(new InputFilter[] { new InputFilter() {
									@Override
									public CharSequence filter(
											CharSequence source, int start,
											int end, Spanned dest, int dstart,
											int dend) {

										return null;
									}
								} });
							}

							if (buglocEdt != null) {
								buglocEdt.setEnabled(true);
								buglocEdt.setFocusable(true);
								buglocEdt.setFocusableInTouchMode(true);
								buglocEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
							}

							return;
						}

						else {
							if (barcodeEdt != null) {
								barcodeEdt.setEnabled(true);
								barcodeEdt.setText("");
								barcodeEdt.setFocusable(true);
								barcodeEdt.setFocusableInTouchMode(true);
								barcodeEdt.requestFocus();
								barcodeEdt.findFocus();
								barcodeEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);

								InputMethodManager im = (InputMethodManager) barcodeEdt
										.getContext().getSystemService(
												Context.INPUT_METHOD_SERVICE);
								im.hideSoftInputFromWindow(
										barcodeEdt.getWindowToken(),
										InputMethodManager.HIDE_NOT_ALWAYS);
							}
							if (bugnoEdt != null) {
								bugnoEdt.setEnabled(true);
								bugnoEdt.setFocusable(true);
								bugnoEdt.setFocusableInTouchMode(true);
								bugnoEdt.setFilters(new InputFilter[] { new InputFilter() {
									@Override
									public CharSequence filter(
											CharSequence source, int start,
											int end, Spanned dest, int dstart,
											int dend) {

										return null;
									}
								} });
							}

							if (buglocEdt != null) {
								buglocEdt.setEnabled(true);
								buglocEdt.setFocusable(true);
								buglocEdt.setFocusableInTouchMode(true);
								buglocEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
							}
							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);
		alertDialog.show();
	}

	public static void showScrapBarCodeAlertDialog(final int status,
			String message, final Context con, final EditText barcodeEdt,
			final EditText worknoEdt, final EditText scrapFinesEdt,
			final EditText memoEdt) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							barcodeEdt.setEnabled(true);
							barcodeEdt.setText("");
							barcodeEdt.setFocusable(true);
							barcodeEdt.setFocusableInTouchMode(true);
							barcodeEdt.requestFocus();
							barcodeEdt.findFocus();
							barcodeEdt
									.setFilters(new InputFilter[] { new InputFilter() {
										@Override
										public CharSequence filter(
												CharSequence source, int start,
												int end, Spanned dest,
												int dstart, int dend) {

											return null;
										}
									} });

							//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);
							InputMethodManager im = (InputMethodManager) barcodeEdt
									.getContext().getSystemService(
											Context.INPUT_METHOD_SERVICE);
							im.hideSoftInputFromWindow(
									barcodeEdt.getWindowToken(),
									InputMethodManager.HIDE_NOT_ALWAYS);
							if (scrapFinesEdt != null) {
								scrapFinesEdt.setEnabled(true);
								scrapFinesEdt.setText("");
								scrapFinesEdt.setFocusable(true);
								scrapFinesEdt.setFocusableInTouchMode(true);
								scrapFinesEdt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
							}
							if (worknoEdt != null) {
								worknoEdt.setEnabled(true);
								worknoEdt.setFocusable(true);
								worknoEdt.setFocusableInTouchMode(true);
							}

							if (memoEdt != null) {
								memoEdt.setEnabled(true);
								memoEdt.setFocusable(true);
								memoEdt.setFocusableInTouchMode(true);
							}

							return;
						}

						else {
							barcodeEdt.setEnabled(true);
							barcodeEdt.setText("");
							barcodeEdt.setFocusable(true);
							barcodeEdt.setFocusableInTouchMode(true);
							barcodeEdt.requestFocus();
							barcodeEdt.findFocus();
							barcodeEdt
									.setFilters(new InputFilter[] { new InputFilter() {
										@Override
										public CharSequence filter(
												CharSequence source, int start,
												int end, Spanned dest,
												int dstart, int dend) {

											return null;
										}
									} });

							//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);

							InputMethodManager im = (InputMethodManager) barcodeEdt
									.getContext().getSystemService(
											Context.INPUT_METHOD_SERVICE);
							im.hideSoftInputFromWindow(
									barcodeEdt.getWindowToken(),
									InputMethodManager.HIDE_NOT_ALWAYS);
							if (scrapFinesEdt != null) {
								scrapFinesEdt.setEnabled(true);
								scrapFinesEdt.setText("");
								scrapFinesEdt.setFocusable(true);
								scrapFinesEdt.setFocusableInTouchMode(true);
								scrapFinesEdt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
							}
							if (worknoEdt != null) {
								worknoEdt.setEnabled(true);
								worknoEdt.setFocusable(true);
								worknoEdt.setFocusableInTouchMode(true);
							}
							if (memoEdt != null) {
								memoEdt.setEnabled(true);
								memoEdt.setFocusable(true);
								memoEdt.setFocusableInTouchMode(true);
							}
							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);
		alertDialog.show();
	}

	public static void showSaveAlertDialog(final int status, String message,
			final Context con, final EditText worknoEdt,
			final EditText barcodeEdt, final int collectType) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							if (collectType == 1) {
								worknoEdt.setEnabled(true);
								worknoEdt.setText("");
								worknoEdt.setFocusable(true);
								worknoEdt.setFocusableInTouchMode(true);
								worknoEdt.requestFocus();
								worknoEdt.findFocus();
								worknoEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
							} else {
								barcodeEdt.setEnabled(true);
								barcodeEdt.setText("");
								barcodeEdt.setFocusable(true);
								barcodeEdt.setFocusableInTouchMode(true);
								barcodeEdt.requestFocus();
								barcodeEdt.findFocus();
								barcodeEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
								//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);

							}
							return;
						}

						else {
							if (collectType == 1) {
								worknoEdt.setEnabled(true);
								worknoEdt.setText("");
								worknoEdt.setFocusable(true);
								worknoEdt.setFocusableInTouchMode(true);
								worknoEdt.requestFocus();
								worknoEdt.findFocus();
								worknoEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
							} else {
								barcodeEdt.setEnabled(true);
								barcodeEdt.setText("");
								barcodeEdt.setFocusable(true);
								barcodeEdt.setFocusableInTouchMode(true);
								barcodeEdt.requestFocus();
								barcodeEdt.findFocus();
								barcodeEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
								//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);

							}
							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);

		alertDialog.show();
	}

	public static void showSaveBilletAlertDialog(final int deliveryType,
			final int status, String message, final Context con,
			final EditText worknoEdt, final EditText barcodeEdt,
			final int collectType) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							if (deliveryType == 0) {
								if (collectType == 1) {
									worknoEdt.setEnabled(true);
									worknoEdt.setText("");
									worknoEdt.setFocusable(true);
									worknoEdt.setFocusableInTouchMode(true);
									worknoEdt.requestFocus();
									worknoEdt.findFocus();
									worknoEdt
											.setFilters(new InputFilter[] { new InputFilter() {
												@Override
												public CharSequence filter(
														CharSequence source,
														int start, int end,
														Spanned dest,
														int dstart, int dend) {

													return null;
												}
											} });
								} else {
									barcodeEdt.setEnabled(true);
									barcodeEdt.setText("");
									barcodeEdt.setFocusable(true);
									barcodeEdt.setFocusableInTouchMode(true);
									barcodeEdt.requestFocus();
									barcodeEdt.findFocus();
									barcodeEdt
											.setFilters(new InputFilter[] { new InputFilter() {
												@Override
												public CharSequence filter(
														CharSequence source,
														int start, int end,
														Spanned dest,
														int dstart, int dend) {

													return null;
												}
											} });
									//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);

								}
							}

							else if (deliveryType == 1) {
								barcodeEdt.setEnabled(true);
								barcodeEdt.setText("");
								barcodeEdt.setFocusable(true);
								barcodeEdt.setFocusableInTouchMode(true);
								barcodeEdt.requestFocus();
								barcodeEdt.findFocus();
								barcodeEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
								//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);
							}
							return;
						}

						else {
							if (deliveryType == 0) {
								if (collectType == 1) {
									worknoEdt.setEnabled(true);
									worknoEdt.setText("");
									worknoEdt.setFocusable(true);
									worknoEdt.setFocusableInTouchMode(true);
									worknoEdt.requestFocus();
									worknoEdt.findFocus();
									worknoEdt
											.setFilters(new InputFilter[] { new InputFilter() {
												@Override
												public CharSequence filter(
														CharSequence source,
														int start, int end,
														Spanned dest,
														int dstart, int dend) {

													return null;
												}
											} });
								} else {
									barcodeEdt.setEnabled(true);
									barcodeEdt.setText("");
									barcodeEdt.setFocusable(true);
									barcodeEdt.setFocusableInTouchMode(true);
									barcodeEdt.requestFocus();
									barcodeEdt.findFocus();
									barcodeEdt
											.setFilters(new InputFilter[] { new InputFilter() {
												@Override
												public CharSequence filter(
														CharSequence source,
														int start, int end,
														Spanned dest,
														int dstart, int dend) {

													return null;
												}
											} });
									//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);

								}
							} else if (deliveryType == 1) {
								barcodeEdt.setEnabled(true);
								barcodeEdt.setText("");
								barcodeEdt.setFocusable(true);
								barcodeEdt.setFocusableInTouchMode(true);
								barcodeEdt.requestFocus();
								barcodeEdt.findFocus();
								barcodeEdt
										.setFilters(new InputFilter[] { new InputFilter() {
											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });
								//CommonUtil.BarcodeMaxLength(barcodeEdt, 50);
							}
							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);

		alertDialog.show();
	}

	public static void showSaveKilncarAlertDialog(final int status,
			String message, final Context con, final EditText worknoEdt,
			final EditText kilnEdt, final EditText kilncarnoEdt,
			final int collectType) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							kilnEdt.setEnabled(true);
							kilnEdt.setFocusable(true);
							kilnEdt.setFocusableInTouchMode(true);
							if (collectType == 1) {
								worknoEdt.setEnabled(true);
								worknoEdt.setText("");
								worknoEdt.setFocusable(true);
								worknoEdt.setFocusableInTouchMode(true);
								worknoEdt.requestFocus();
								worknoEdt.findFocus();
								worknoEdt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								kilncarnoEdt.setEnabled(true);
								kilncarnoEdt.setText("");
								kilncarnoEdt.setFocusable(true);
								kilncarnoEdt.setFocusableInTouchMode(true);
							} else {
								kilncarnoEdt.setEnabled(true);
								kilncarnoEdt.setText("");
								kilncarnoEdt.setFocusable(true);
								kilncarnoEdt.setFocusableInTouchMode(true);
								kilncarnoEdt.requestFocus();
								kilncarnoEdt.findFocus();
							}
							return;
						}

						else {
							kilnEdt.setEnabled(true);
							kilnEdt.setFocusable(true);
							kilnEdt.setFocusableInTouchMode(true);
							if (collectType == 1) {
								worknoEdt.setEnabled(true);
								worknoEdt.setText("");
								worknoEdt.setFocusable(true);
								worknoEdt.setFocusableInTouchMode(true);
								worknoEdt.requestFocus();
								worknoEdt.findFocus();
								worknoEdt
										.setFilters(new InputFilter[] { new InputFilter() {

											@Override
											public CharSequence filter(
													CharSequence source,
													int start, int end,
													Spanned dest, int dstart,
													int dend) {

												return null;
											}
										} });

								kilncarnoEdt.setEnabled(true);
								kilncarnoEdt.setText("");
								kilncarnoEdt.setFocusable(true);
								kilncarnoEdt.setFocusableInTouchMode(true);
							} else {
								kilncarnoEdt.setEnabled(true);
								kilncarnoEdt.setText("");
								kilncarnoEdt.setFocusable(true);
								kilncarnoEdt.setFocusableInTouchMode(true);
								kilncarnoEdt.requestFocus();
								kilncarnoEdt.findFocus();
							}
							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);

		alertDialog.show();
	}

	public static void showStaffWorknoAlertDialog(final int status,
			String message, final Context con, final EditText worknoEdt) {
		Dialog alertDialog = new AlertDialog.Builder(con).setMessage(message)
				.setPositiveButton("确定", new DialogInterface.OnClickListener() {

					@Override
					public void onClick(DialogInterface dialog, int which) {
						if (status == -1 || status == -2 || status == -3) {
							ExitUtil eu = new ExitUtil(con);
							eu.exit();
						}

						else if (status == 0) {
							worknoEdt.setEnabled(true);
							worknoEdt.setText("");
							worknoEdt.setFocusable(true);
							worknoEdt.setFocusableInTouchMode(true);
							worknoEdt.requestFocus();
							worknoEdt.findFocus();
							worknoEdt
									.setFilters(new InputFilter[] { new InputFilter() {

										@Override
										public CharSequence filter(
												CharSequence source, int start,
												int end, Spanned dest,
												int dstart, int dend) {

											return null;
										}
									} });

							return;
						}

						else {
							worknoEdt.setEnabled(true);
							worknoEdt.setText("");
							worknoEdt.setFocusable(true);
							worknoEdt.setFocusableInTouchMode(true);
							worknoEdt.requestFocus();
							worknoEdt.findFocus();
							worknoEdt
									.setFilters(new InputFilter[] { new InputFilter() {

										@Override
										public CharSequence filter(
												CharSequence source, int start,
												int end, Spanned dest,
												int dstart, int dend) {

											return null;
										}
									} });

							return;
						}

					}
				}).create();
		alertDialog.setCanceledOnTouchOutside(false);
		alertDialog.show();
	}

	public static String getCurrentDate() {
		Calendar c = Calendar.getInstance();
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
		String formattedDate = df.format(c.getTime());
		return formattedDate;
	}

	public static Date ParseStringToDateTime(String s) {

		Date date = null;
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			date = formatter.parse(s);
		} 
		catch (ParseException e) {
			e.printStackTrace();
		}

		return date;
	}

	public static Date ParseStringToDate(String s) {

		java.sql.Date d = null;
		d = java.sql.Date.valueOf(s);
		return d;
	}

	public static boolean CheckedDutyPersonStatus(
			List<DutyPerson> dutypersonList) {
		boolean checkedStatus = false;
		for (DutyPerson dp : dutypersonList) {
			if (dp.isCheckStatus()) {
				checkedStatus = true;
                break;
			}
		}
		return checkedStatus;
	}

	public static List<DefectFines> getDefectFinesListByDefectId(
			String orgDefectId,
			List<DefectAndDefectFinesRelation> defectFineRelationList) {
		List<DefectFines> tempDefectFinesList = null;
		for (DefectAndDefectFinesRelation relation : defectFineRelationList) {
			String defectId = relation.getDefectId();
			if (defectId.equals(orgDefectId)) {
				tempDefectFinesList = relation.getDefectFinesList();
				break;
			}
		}
		return tempDefectFinesList;
	}

	public static List<DefectDeduction> getDefectDeductionListByDefectId(
			String orgDefectId,
			List<DefectAndDefectDeductionRelation> defectDeductionRelationList) {
		List<DefectDeduction> tempDefectDeductionList = null;
		for (DefectAndDefectDeductionRelation relation : defectDeductionRelationList) {
			String defectId = relation.getDefectId();
			if (defectId.equals(orgDefectId)) {
				tempDefectDeductionList = relation.getDefectDeductionList();
				break;
			}
		}
		return tempDefectDeductionList;
	}

	public static List<DutyPerson> getCheckedDutyPersonList(
			List<DutyPerson> dutypersonList) {
		List<DutyPerson> checkedDutyPersonList = new ArrayList<DutyPerson>();

		for (DutyPerson dp : dutypersonList) {
			if (dp.isCheckStatus()) {
				checkedDutyPersonList.add(dp);
			}
		}
		return checkedDutyPersonList;
	}

	public static boolean IsIntValue(String s) {
		boolean bCheckResult = true;
		try {
			Integer iCheckValue = Integer.parseInt(s);

			if (iCheckValue instanceof Integer == false) {
				bCheckResult = false;
			}
		} catch (NumberFormatException e) {
			bCheckResult = false;
		}

		return bCheckResult;
	}

	public static boolean IsDoubleValue(String s) {
		boolean bCheckResult = true;
		try {
			Double iCheckValue = Double.parseDouble(s);

			if (iCheckValue instanceof Double == false) {
				bCheckResult = false;
			}
		} catch (NumberFormatException e) {
			bCheckResult = false;
		}

		return bCheckResult;
	}

}