android --工具类

监听重力传感器

private SensorManager mSensorManager;
private OrientationListener mOrientationListener;
private OrientationEventListener mScreenOrientationEventListener;

  private void initSensor(){
        mSensorManager = (SensorManager)getSystemService(Context.SENSOR_SERVICE);
        mOrientationListener = new OrientationListener(newOrientation -> {
            //设置屏幕方向
            //setRequestedOrientation(newOrientation);
            if(newOrientation!= ActivityInfo.SCREEN_ORIENTATION_PORTRAIT){
                measureController.onAbnormal("请保持设备竖屏", false);
//                MyLogUtil.e(TAG,"屏幕"+newOrientation);
            }

        });
        mSensorManager.registerListener(mOrientationListener, mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER), SensorManager.SENSOR_DELAY_NORMAL);
    }

 private int mScreenExifOrientation = 6;
    private  void initScreen(){
        mScreenOrientationEventListener = new OrientationEventListener(this) {
            private int mLastKnownRotation = -1;
            @Override
            public void onOrientationChanged(int orientation) {
                // i的范围是0～359
                // 屏幕左边在顶部的时候 i = 90;
                // 屏幕顶部在底部的时候 i = 180;
                // 屏幕右边在底部的时候 i = 270;
                // 正常情况默认i = 0;
                orientation = (orientation + 45) / 90 * 90;
                mScreenExifOrientation = orientation % 360;

//                if(45 <= orientation && orientation < 135) {
//                    mScreenExifOrientation = ExifInterface.ORIENTATION_ROTATE_180;
//                } else if(135 <= orientation && orientation < 225) {
//                    mScreenExifOrientation = ExifInterface.ORIENTATION_ROTATE_270;
//                } else if(225 <= orientation && orientation < 315) {
//                    mScreenExifOrientation = ExifInterface.ORIENTATION_NORMAL;
//                } else {
//                    mScreenExifOrientation = ExifInterface.ORIENTATION_ROTATE_90;
//                }

                if (mLastKnownRotation != mScreenExifOrientation) {
                    mLastKnownRotation = mScreenExifOrientation;
                    if(mScreenExifOrientation !=ExifInterface.ORIENTATION_ROTATE_90){
                        measureController.onAbnormal("请保持设备竖屏", false);
                        MyLogUtil.e(TAG,"onOrientationChanged mScreenExifOrientation "+mScreenExifOrientation);
                    }
                }

            }
        };
        if (mScreenOrientationEventListener.canDetectOrientation()) {
            mScreenOrientationEventListener.enable();   // 开启此监听
        } else {
            mScreenOrientationEventListener.disable();
        }

    }

public static class OrientationListener implements SensorEventListener {
    private int mOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
    private OnOrientationChangeListener mListener;

    public OrientationListener(OnOrientationChangeListener listener) {
        mListener = listener;
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        if (Sensor.TYPE_ACCELEROMETER != event.sensor.getType()) {
            return;
        }

        float[] values = event.values;
        float x = values[0];
        float y = values[1];

        int newOrientation;
        if (x < 4.5 && x >= -4.5 && y >= 4.5) {
            newOrientation = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
        } else if (x >= 4.5 && y < 4.5 && y >= -4.5) {
            newOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
        } else if (x <= -4.5 && y < 4.5 && y >= -4.5) {
            newOrientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
        }else {
            newOrientation = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
        }

        if (mOrientation != newOrientation) {
            if (mListener != null) {
                mListener.orientationChanged(newOrientation);
            }
            mOrientation = newOrientation;
        }
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {

    }

    public interface OnOrientationChangeListener {
        void orientationChanged(int newOrientation);
    }
}

@Override
protected void onDestroy() {
    MyLogUtil.e(TAG,"onDestroy");
    mSensorManager.unregisterListener(mOrientationListener);
    mScreenOrientationEventListener.disable();
    }

获取当前屏幕的旋转角度

int angle = ((WindowManager)getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getRotation();
switch (angle) {
    case Surface.ROTATION_0:
        Log.d(TAG,"Rotation_0");
        break;
    case Surface.ROTATION_90:
        Log.d(TAG,"ROTATION_90");
        break;
    case Surface.ROTATION_180:
        Log.d(TAG,"ROTATION_180");
        break;
    case Surface.ROTATION_270:
        Log.d(TAG,"ROTATION_270");
        break;
    default:
        Log.d(TAG,"Default Rotation!");
         break;

拦截所有异常不让App崩溃的解决方法

public class CrashApp extends Application {

  public static final String TAG = "CrashApp";

  @Override
  protected void attachBaseContext(Context base) {
    super.attachBaseContext(base);
    new Handler(getMainLooper()).post(new Runnable() {
      @Override
      public void run() {
        while (true) {
          try {
            Looper.loop();　　//try-catch主线程的所有异常；Looper.loop()内部是一个死循环，出现异常时才会退出，所以这里使用while(true)。
          } catch (Throwable e) {
            Log.d(TAG, "Looper.loop(): " + e.getMessage());
          }
        }
      }
    });

    Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
      @Override
      public void uncaughtException(Thread t, Throwable e) {　　//try-catch子线程的所有异常。
        Log.d(TAG, "UncaughtExceptionHandler: " + e.getMessage());
      }
    });
  }

  @Override
  public void onCreate() {
    super.onCreate();
  }
}
<application android:name=".CrashApp"></application>

获得时间差

    private var curDate = Date(System.currentTimeMillis())
    private var endDate = Date(System.currentTimeMillis())
    private var diff = 0L
    //开始计时
    curDate = Date(System.currentTimeMillis())
    endDate = Date(System.currentTimeMillis())
    diff = endDate.time - curDate.time
    log.d("分析时间：" + diff)

获取唯一标识

阿里巴巴依赖 DeviceIdUtil.getDeviceId(mContext)

DeviceIdUtil工具类

import android.content.Context;
import android.os.Build;
import android.os.Build.VERSION;
import android.provider.Settings.Secure;
import android.telephony.TelephonyManager;
import androidx.core.app.ActivityCompat;
import java.security.MessageDigest;
import java.util.Locale;
import java.util.UUID;

public class DeviceIdUtil {
    public DeviceIdUtil() {
    }

    public static boolean isApkInDebug(Context context) {
        try {
            return (context.getApplicationInfo().flags & 2) != 0;
        } catch (Exception var1) {
            return false;
        }
    }

    public static String getDeviceId(Context context) {
        StringBuilder var1 = new StringBuilder();
        String var2 = a(context);
        String context1 = b(context);
        String var3 = a();
        String var4 = b().replace("-", "");
        if (var2 != null && var2.length() > 0) {
            var1.append(var2);
            var1.append("|");
        }

        if (context1 != null && context1.length() > 0) {
            var1.append(context1);
            var1.append("|");
        }

        if (var3 != null && var3.length() > 0) {
            var1.append(var3);
            var1.append("|");
        }

        if (var4 != null && var4.length() > 0) {
            var1.append(var4);
        }

        if (var1.length() > 0) {
            try {
                if ((context1 = a(a(var1.toString()))) != null && context1.length() > 0) {
                    return context1;
                }
            } catch (Exception var5) {
                var5.printStackTrace();
            }
        }

        return UUID.randomUUID().toString().replace("-", "");
    }

    private static String a(Context var0) {
        try {
            TelephonyManager var1 = (TelephonyManager)var0.getSystemService("phone");
            return ActivityCompat.checkSelfPermission(var0, "android.permission.READ_PHONE_STATE") != 0 ? null : var1.getDeviceId();
        } catch (Exception var2) {
            var2.printStackTrace();
            return "";
        }
    }

    private static String b(Context var0) {
        try {
            return Secure.getString(var0.getContentResolver(), "android_id");
        } catch (Exception var1) {
            var1.printStackTrace();
            return "";
        }
    }

    private static String a() {
        try {
            return Build.SERIAL;
        } catch (Exception var0) {
            var0.printStackTrace();
            return "";
        }
    }

    private static String b() {
        try {
            String var0 = "3883756" + Build.BOARD.length() % 10 + Build.BRAND.length() % 10 + Build.DEVICE.length() % 10 + Build.HARDWARE.length() % 10 + Build.ID.length() % 10 + Build.MODEL.length() % 10 + Build.PRODUCT.length() % 10 + Build.SERIAL.length() % 10;
            return (new UUID((long)var0.hashCode(), (long)Build.SERIAL.hashCode())).toString();
        } catch (Exception var1) {
            var1.printStackTrace();
            return "";
        }
    }

    private static byte[] a(String var0) {
        try {
            MessageDigest var1;
            (var1 = MessageDigest.getInstance("SHA1")).reset();
            var1.update(var0.getBytes("UTF-8"));
            return var1.digest();
        } catch (Exception var2) {
            return "".getBytes();
        }
    }

    private static String a(byte[] var0) {
        StringBuilder var1 = new StringBuilder();

        for(int var3 = 0; var3 < var0.length; ++var3) {
            String var2;
            if ((var2 = Integer.toHexString(var0[var3] & 255)).length() == 1) {
                var1.append("0");
            }

            var1.append(var2);
        }

        return var1.toString().toUpperCase(Locale.CHINA);
    }

    public static String getSystemVersion() {
        return "" + VERSION.SDK_INT;
    }

    public static String getSystemModel() {
        return Build.MODEL;
    }

    public static String getDeviceBrand() {
        return Build.BRAND;
    }
}

检查网络状态

    protected BroadcastReceiver mNetworkChangeReceiver;
    AlertDialog dialog;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
        mContext = this;
        initDialog();
        //注册广播用于监听网络状态改变
        mNetworkChangeReceiver = new BroadcastReceiver() {
            @Override
            public void onReceive(Context context, Intent intent) {
                detectNetWork();
            }
        };
    }
    private void initDialog() {
        dialog = new AlertDialog.Builder(this).setTitle("网络异常")
                .setPositiveButton("确定", new DialogInterface.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface arg0, int arg1) {

                    }
                }).setMessage("网络发生异常，请检查后重试！").create();
    }

    @Override
    protected void onResume() {
        super.onResume();
        registerReceiver(mNetworkChangeReceiver, new IntentFilter(
                ConnectivityManager.CONNECTIVITY_ACTION));
    }

    @Override
    protected void onPause() {
        super.onPause();
        try {
            unregisterReceiver(mNetworkChangeReceiver);
        } catch (Exception e) {
        }
    }


    protected void detectNetWork() {
        if (!isConnected(this)) {
            dialog.show();
        } else {
            dialog.dismiss();
        }
    }

    //判断网络是否连接
    public boolean isConnected(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        @SuppressLint("MissingPermission") NetworkInfo info = cm.getActiveNetworkInfo();
        return (info != null && info.isConnected());
    }

Android 调起第三方应用

B应用清单文件需要配置： 在启动页（SplashActivity）清单文件增加如下配置：注意：不要在原有的intent-filter中增加代码，而是在原有intent-filter下方再增加一个intent-filter。

<!--URL启动启动配置-->
            <intent-filter>
                <data
                    android:host="pull.csd.demo"
                    android:path="/cyn"
                    android:scheme="csd" />
                <action android:name="android.intent.action.VIEW" />

                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.BROWSABLE" />
            </intent-filter>

注意：这里scheme为必填，host、path为选填。选填内容可以不填，但是一旦填上了就必须全部完全匹配才会成功拉起。

A应用编码方式：

Intent intent = new Intent();
intent.setData(Uri.parse("csd://pull.csd.demo/cyn?type=110"));
intent.putExtra("", "");//这里Intent当然也可传递参数,但是一般情况下都会放到上面的URL中进行传递
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
//接收返回值
int REQUESTCODE = 21900;
String path = "xymind://happycat/detector?workId="+workId;
Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(path));
startActivityForResult(intent,REQUESTCODE);

B应用启动页拉起后可以获取到Uri，你可以选择先存储到SharedPreferences中，在主页或者广播接收者中取出来，然后再对URI进行解析；或者在启动页立刻将Uri解析成bean对象，放到全局的Application中，在主页或者广播接收者中直接使用。

Intent intent = getIntent();
        Uri uri = intent.getData();
        if (uri != null) {
            String scheme = uri.getScheme();//csd
            String uriHost = uri.getHost();//pull.csd.demo
            String uriPath = uri.getPath();///cyn
            String type = uri.getQueryParameter("type");//110
        }

如果存储到SharedPreferences中那么一定是把Uri转换成String类型了，下面是你可能会用到的把String转成Uri类型的方法 Uri uri = Uri.parse(url);

切记：A应用拉起B应用的编码千万不要忘记添加：intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 这种启动模式如果不添加你会发现有时候返回顺序是混乱的

blog.csdn.net/zang_chen/a…