public class ForegroundCallbacks implements Application.ActivityLifecycleCallbacks {
    public static final long CHECK_DELAY = 500;
    public static final String TAG = ForegroundCallbacks.class.getName();
    public interface Listener {
        public void onBecameForeground();
        public void onBecameBackground();
    }
    private static ForegroundCallbacks instance;
    private boolean foreground = false, paused = true;
    private Handler handler = new Handler();
    private List<Listener> listeners = new CopyOnWriteArrayList<Listener>();
    private Runnable check;
    public static ForegroundCallbacks init(Application application){
        if (instance == null) {
            instance = new ForegroundCallbacks();
            application.registerActivityLifecycleCallbacks(instance);
        }
        return instance;
    }
    public static ForegroundCallbacks get(Application application){
        if (instance == null) {
            init(application);
        }
        return instance;
    }
    public static ForegroundCallbacks get(Context ctx){
        if (instance == null) {
            Context appCtx = ctx.getApplicationContext();
            if (appCtx instanceof Application) {
                init((Application)appCtx);
            }
            throw new IllegalStateException(
                    "Foreground is not initialised and " +
                            "cannot obtain the Application object");
        }
        return instance;
    }
    public static ForegroundCallbacks get(){
        if (instance == null) {
            throw new IllegalStateException(
                    "Foreground is not initialised - invoke " +
                            "at least once with parameterised init/get");
        }
        return instance;
    }
    public boolean isForeground(){
        return foreground;
    }
    public boolean isBackground(){
        return !foreground;
    }
    public void addListener(Listener listener){
        listeners.add(listener);
    }
    public void removeListener(Listener listener){
        listeners.remove(listener);
    }
    @Override
    public void onActivityResumed(Activity activity) {
        paused = false;
        boolean wasBackground = !foreground;
        foreground = true;
        if (check != null)
            handler.removeCallbacks(check);
        if (wasBackground){
           L.d ("went foreground");

            for (Listener l : listeners) {
                try {
                    l.onBecameForeground();


                } catch (Exception exc) {
                    L.d ("Listener threw exception!:"+exc.toString());
                }
            }
        } else {
            L.d ("still foreground");
        }
    }
    @Override
    public void onActivityPaused(Activity activity) {
        paused = true;
        if (check != null)
            handler.removeCallbacks(check);
        handler.postDelayed(check = new Runnable(){
            @Override
            public void run() {
                if (foreground && paused) {
                    foreground = false;
                    L.d ("went background");
                    for (Listener l : listeners) {
                        try {
                            l.onBecameBackground();
                        } catch (Exception exc) {
                            L.d ("Listener threw exception!:"+exc.toString());
                        }
                    }
                } else {
                    L.d ("still foreground");
                }
            }
        }, CHECK_DELAY);
    }
    @Override
    public void onActivityCreated(Activity activity, Bundle savedInstanceState) {}
    @Override
    public void onActivityStarted(Activity activity) {}
    @Override
    public void onActivityStopped(Activity activity) {}
    @Override
    public void onActivitySaveInstanceState(Activity activity, Bundle outState) {}
    @Override
    public void onActivityDestroyed(Activity activity) {}
}

public static String getDeviceId(Context context) {
    String deviceId = (String) SharedPreferencesUtil.getParam(SP_NAME_SYSTEM_INFO, SP_KEY_DEVICE_ID, "");
    if (TextUtils.isEmpty(deviceId)) {
        deviceId = getMD5(getDeviceInfo(context));
        SharedPreferencesUtil.setParam(SP_NAME_SYSTEM_INFO, SP_KEY_DEVICE_ID, deviceId);
    }
    return deviceId;
}

/**
     * deviceID的组成为：渠道标志+识别符来源标志+hash后的终端识别符
     * 渠道标志为：
     * andriod（a_）
     * 识别符来源标志：
     * 1， wifi mac地址（wifi_）；
     * 2， IMEI（imei_）；
     * 3， 序列号（sn_）；
     * 4， id：随机码。若前面的都取不到时，则随机生成一个随机码，需要缓存。
     *
     * @param context
     * @return
     */
private static String getDeviceInfo(Context context) {
    StringBuilder deviceId = new StringBuilder();
    // 渠道标志
    deviceId.append("a_");
    try {
        //wifi mac地址
        WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        WifiInfo info = wifi.getConnectionInfo();
        String wifiMac = info.getMacAddress();
        if (!TextUtils.isEmpty(wifiMac)) {
            deviceId.append("wifi");
            deviceId.append(wifiMac);
            return deviceId.toString();
        }
        //IMEI（imei）
        TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
        String imei = tm.getDeviceId();
        if (!TextUtils.isEmpty(imei)) {
            deviceId.append("imei_");
            deviceId.append(imei);
            return deviceId.toString();
        }
        //AndroidID
        if(!TextUtils.isEmpty(Settings.System.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID))) {
            return Settings.System.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
        }
        //序列号（sn）
        String sn = tm.getSimSerialNumber();
        if (!TextUtils.isEmpty(sn)) {
            deviceId.append("sn_");
            deviceId.append(sn);
            return deviceId.toString();
        }
        //如果上面都没有， 则生成一个id：随机码
        String uuid = UUID.randomUUID().toString();
        if (!TextUtils.isEmpty(uuid)) {
            deviceId.append("id_");
            deviceId.append(uuid);
            return deviceId.toString();
        }
    } catch (Exception e) {
        e.printStackTrace();
        deviceId.append("id_").append(UUID.randomUUID().toString());
    }
    return deviceId.toString();
}


/**
     * 获取String的MD5值
     *
     * @param info 字符串
     * @return 该字符串的MD5值 返回值为十六进制的32位长度的字符串
     */
private static String getMD5(String info) {
    try {
        //获取 MessageDigest 对象，参数为 MD5 字符串，表示这是一个 MD5 算法（其他还有 SHA1 算法等）：
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        //update(byte[])方法，输入原数据
        //类似StringBuilder对象的append()方法，追加模式，属于一个累计更改的过程
        md5.update(info.getBytes("UTF-8"));
        //digest()被调用后,MessageDigest对象就被重置，即不能连续再次调用该方法计算原数据的MD5值。可以手动调用reset()方法重置输入源。
        //digest()返回值16位长度的哈希值，由byte[]承接
        byte[] md5Array = md5.digest();
        //byte[]通常我们会转化为十六进制的32位长度的字符串来使用,本文会介绍三种常用的转换方法
        return new BigInteger(1, md5Array).toString(16);
    } catch (NoSuchAlgorithmException e) {
        return "";
    } catch (UnsupportedEncodingException e) {
        return "";
    }
}