NIMUtil.java

浏览该文件的文档.

package com.netease.nimlib.sdk.util;

import android.app.Application;
import android.content.Context;
import android.os.Build;
import android.os.Environment;
import android.os.Looper;
import android.text.TextUtils;
import android.util.Log;
import com.netease.nimlib.biz.constant.IAuthService;
import com.netease.nimlib.log.NimLog;
import com.netease.nimlib.log.model.LogDesensitizationConfigHelper;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.util.Collection;

/**
 * 云信SDK工具类
 */

public final class NIMUtil {

    private static final String TAG = "NIMUtil";
    private static String currentProcessName = null;

    private NIMUtil() {
    }

    /**
     * 判断当前进程是否是主进程（纯净版本），不会有隐私不合规风险，但是不保证100%判断正确
     * @param context
     * @return >0 表示返回主进程，=0 表示不是进程，<0 表示无法判断
     */
    public static int isMainProcessPure(Context context) {
        if (context == null) {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, " isMainProcessPure context == null");
            }
            return -1;
        }

        String packageName = context.getApplicationContext().getPackageName();
        String processName = NIMUtil.getProcessNamePure(context);
        //无法获取当前进程名，无法判断
        if(TextUtils.isEmpty(processName))
        {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, " isMainProcessPure can not get processName");
            }
            return -1;
        }
        if (LogDesensitizationConfigHelper.printToLogcat()) {
            Log.d(TAG, " isMainProcessPure packageName = " + packageName + ",processName = " + processName);
        }
        return packageName.equals(processName) ? 1 : 0;
    }

    /**
     * 获取当前进程名（纯净版本），不会有隐私不合规风险，但是不保证100%获取到
     * @param context
     * @return
     */
    public static String getProcessNamePure(Context context) {
        if(!TextUtils.isEmpty(currentProcessName))
        {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, "get processName from Cache = " + currentProcessName);
            }
            return currentProcessName;
        }
        currentProcessName = getCurrentProcessNameByApplication();
        if(!TextUtils.isEmpty(currentProcessName))
        {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, "get processName from Application = " + currentProcessName);
            }
            return currentProcessName;
        }

        currentProcessName = getCurrentProcessNameByActivityThread();

        if(!TextUtils.isEmpty(currentProcessName))
        {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, "get processName from ActivityThread = " + currentProcessName);
            }
            return currentProcessName;
        }

        return currentProcessName;
    }

    public static boolean isMainProcess(Context context) {
        if (context == null) {
            return false;
        }

        String packageName = context.getApplicationContext().getPackageName();
        String processName = NIMUtil.getProcessName(context);
        return packageName.equals(processName);
    }

    public static String getProcessName(Context context) {
        if(!TextUtils.isEmpty(currentProcessName))
        {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, "get processName from Cache = " + currentProcessName);
            }
            NimLog.i(TAG, "get processName from Cache = " + currentProcessName);
            return currentProcessName;
        }
        currentProcessName = getCurrentProcessNameByApplication();
        if(!TextUtils.isEmpty(currentProcessName))
        {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, "get processName from Application = " + currentProcessName);
            }
            return currentProcessName;
        }

        currentProcessName = getCurrentProcessNameByActivityThread();

        if(!TextUtils.isEmpty(currentProcessName))
        {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, "get processName from ActivityThread = " + currentProcessName);
            }
            return currentProcessName;
        }

        currentProcessName = getProcessFromFile();

        if(!TextUtils.isEmpty(currentProcessName))
        {
            if (LogDesensitizationConfigHelper.printToLogcat()) {
                Log.d(TAG, "get processName from File = " + currentProcessName);
            }
            return currentProcessName;
        }

//        // 如果装了xposed一类的框架，上面可能会拿不到，回到遍历迭代的方式
//        currentProcessName = getProcessNameByAM(context);
        if (LogDesensitizationConfigHelper.printToLogcat()) {
            Log.d(TAG, "get processName from ActivityManager = " + currentProcessName);
        }
        return currentProcessName;
    }

    private static String getProcessFromFile() {
        BufferedReader reader = null;
        try {
            int pid = android.os.Process.myPid();
            String file = "/proc/" + pid + "/cmdline";
            reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "iso-8859-1"));
            int c;
            StringBuilder processName = new StringBuilder();
            while ((c = reader.read()) > 0) {
                processName.append((char) c);
            }
            return processName.toString();
        } catch (Exception e) {
            return null;
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

//    private static String getProcessNameByAM(Context context) {
//        String processName = null;
//
//        ActivityManager am = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE));
//        if (am == null) {
//            return null;
//        }
//
//        while (true) {
//            List<ActivityManager.RunningAppProcessInfo> plist = am.getRunningAppProcesses();
//            if (plist != null) {
//                for (ActivityManager.RunningAppProcessInfo info : plist) {
//                    if (info.pid == android.os.Process.myPid()) {
//                        processName = info.processName;
//
//                        break;
//                    }
//                }
//            }
//
//            if (!TextUtils.isEmpty(processName)) {
//                return processName;
//            }
//
//            try {
//                Thread.sleep(100L); // take a rest and again
//            } catch (InterruptedException ex) {
//                ex.printStackTrace();
//            }
//        }
//    }

//    public static boolean isMainProcessLive(Context context) {
//        if (context == null) {
//            return false;
//        }
//
//        final String processName = context.getPackageName();
//        ActivityManager am = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE));
//        if (am != null) {
//            List<ActivityManager.RunningAppProcessInfo> plist = am.getRunningAppProcesses();
//            if (plist != null) {
//                for (ActivityManager.RunningAppProcessInfo info : plist) {
//                    if (info.processName.equals(processName)) {
//                        return true;
//                    }
//                }
//            }
//        }
//
//        return false;
//    }

    public static String getNimDefaultCacheDir(Context context) {
        String sdkStorageRoot = "";

        if (context.getCacheDir() != null) {
            sdkStorageRoot = context.getCacheDir().getAbsolutePath();
        } else {
            NimLog.e(TAG, "loadStorageState context.getCacheDir() == null");
        }

        if (TextUtils.isEmpty(sdkStorageRoot)) {
            if (Environment.getExternalStorageDirectory() != null) {
                String externalPath = Environment.getExternalStorageDirectory().getPath();
                sdkStorageRoot = externalPath + "/" + context.getPackageName();
            } else {
                NimLog.e(TAG, "loadStorageState Environment.getExternalStorageDirectory() == null");
            }
        }

        if (!TextUtils.isEmpty(sdkStorageRoot)) {
            sdkStorageRoot = sdkStorageRoot + "/nim/";
        }

        return sdkStorageRoot;
    }

    public static boolean isEmpty(Collection collection) {
        return collection == null || collection.isEmpty();
    }

    /**
     * 通过Application新的API获取进程名，无需反射，无需IPC，效率最高。
     */
    private static String getCurrentProcessNameByApplication() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            return Application.getProcessName();
        }
        return null;
    }

    /**
     * 通过反射ActivityThread获取进程名，避免了ipc
     */
    private static String getCurrentProcessNameByActivityThread() {
        String processName = null;
        try {
            final Method declaredMethod = Class.forName("android.app.ActivityThread", false, Application.class.getClassLoader())
                .getDeclaredMethod("currentProcessName", (Class<?>[]) new Class[0]);
            declaredMethod.setAccessible(true);
            final Object invoke = declaredMethod.invoke(null, new Object[0]);
            if (invoke instanceof String) {
                processName = (String) invoke;
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return processName;
    }

    public static boolean isEnableDynamicLoginToken(int loginType) {
        return loginType == IAuthService.AuthType.DYNAMIC || loginType == IAuthService.AuthType.THIRDPARTY;
    }

    public static boolean isMainThread() {
        return Looper.myLooper() == Looper.getMainLooper();
    }
}