6

我有一个应用程序，它有一个在单独的进程中运行的远程服务：

<service android:name=".MyService" android:process=":remote"/>

我也在使用一个应用程序类：

<application android:label="@string/app_name" android:name=".MyApplication" ...

我可以做这样的事情吗？

public class MyApplication extends Application {

    public MyApplication() {
        if (isRemoteService()) {
            setupLog("remoteservice.log");
        } else {
            setupLog("application.log");
        }
    }

我想我可以获取进程名称并使用它来检测我是否在远程服务或主应用程序中，但我还没有找到如何获取进程名称。我可以从中获取 PID android.os.Process.myPID()，但这对我没有多大帮助。

4

4 回答 4

7

例如，如果您想检查您是否在主进程中，您可以在应用程序中编写如下代码：

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        //...code here will be execute in every process...
        if (isMainProcess()) {
            //...code here will be execute only in main process
        }
        super.onCreate();
    }

    // your package name is the same with your main process name
    private boolean isMainProcess() {
        return getPackageName().equals(getProcessName());
    }

    // you can use this method to get current process name, you will get
    // name like "com.package.name"(main process name) or "com.package.name:remote"
    private String getProcessName() {
        int mypid = android.os.Process.myPid();
        ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        List<RunningAppProcessInfo> infos = manager.getRunningAppProcesses();
        for(RunningAppProcessInfo info : infos) {
            if (info.pid == mypid) {
                return info.processName;
            }
        }
        // may never return null
        return null;
    }
}
于 2016-03-28T04:42:18.693 回答
1

我有一个类似的问题，这就是我所做的。

MyService并且MyActivity有一个共同的部分，MyEngine，但是在这两种情况下行为必须有点不同。

不同的一件事是设置，但此设置是在类MyService和MyActivity.

活动和服务的另一点不同是通过侦听器完成的：MyEngine定义接口，MyEngine.Listener同时为引擎提供该接口的不同实现。MyServiceMyActivity

因此，如果要传递布尔值，可以使用两种方法：

// Method 1: different initialization
class MyEngine {
    MyEngine(boolean isService) { ... }
}
class MyActivity extends Activity {
    private MyEngine = new MyEngine(false);
    ...
}
class MyService extends Service {
    private MyEngine = new MyEngine(true);
    ...
}

// Method 2: callbacks
class MyEngine {
    interface Listener {
        boolean isService();
    }
    private Listener mListener;
    MyEngine(Listener listener) { mListener = listener; }
}
class MyActivity extends Activity {
    private mListener = new MyEngine.Listener() {
        boolean isService() { return false; }
    }
    private MyEngine = new MyEngine(mListener);
    ...
}
class MyService extends Service {
    private mListener = new MyEngine.Listener() {
        boolean isService() { return true; }
    }
    private MyEngine = new MyEngine(mListener);
    ...
}

笔记。

  1. 上面示例中使用的布尔值在现实世界中是没有用的：如果你想使用不同的日志文件名，最好传递文件名而不是布尔值。如果要执行两种不同的操作，最好有一个具有两种实现的侦听器函数。

  2. 当然，可以通过 aContext并检查它是否是 a 的子进程，Activity或者Service获取当前进程的名称，但这些都是 Android 特定的实现细节，除非绝对必要，否则最好不要依赖它们。

于 2013-05-28T11:50:27.593 回答
1

我可以提供一个间接的解决方案：

在每个相应的 StartUp 方法中，设置一个系统属性：

System.setProperty("PROCESS_TYPE","SERVICE");
System.setProperty("PROCESS_TYPE","RECEIVER");
System.setProperty("PROCESS_TYPE","ACTIVITY");

属性是静态的，与进程隔离，并且可以从任何地方访问。额外的好处是它们可以被 Logback 等日志框架直接使用。

于 2013-04-06T19:03:29.620 回答
1

我正在使用一段代码，它取自 Google 的WorkManager库。在撰写本文时，它位于GreedyScheduler.java. 已经定义getProcessName()了这样的方法：

    @Nullable
    private String getProcessName() {
        if (SDK_INT >= 28) {
            return Application.getProcessName();
        }

        // Try using ActivityThread to determine the current process name.
        try {
            Class<?> activityThread = Class.forName(
                    "android.app.ActivityThread",
                    false,
                    GreedyScheduler.class.getClassLoader());
            final Object packageName;
            if (SDK_INT >= 18) {
                Method currentProcessName = activityThread.getDeclaredMethod("currentProcessName");
                currentProcessName.setAccessible(true);
                packageName = currentProcessName.invoke(null);
            } else {
                Method getActivityThread = activityThread.getDeclaredMethod(
                        "currentActivityThread");
                getActivityThread.setAccessible(true);
                Method getProcessName = activityThread.getDeclaredMethod("getProcessName");
                getProcessName.setAccessible(true);
                packageName = getProcessName.invoke(getActivityThread.invoke(null));
            }
            if (packageName instanceof String) {
                return (String) packageName;
            }
        } catch (Throwable exception) {
            Log.d("TAG", "Unable to check ActivityThread for processName", exception);
        }

        // Fallback to the most expensive way
        int pid = Process.myPid();
        ActivityManager am =
                (ActivityManager) mContext.getSystemService(ACTIVITY_SERVICE);

        if (am != null) {
            List<ActivityManager.RunningAppProcessInfo> processes = am.getRunningAppProcesses();
            if (processes != null && !processes.isEmpty()) {
                for (ActivityManager.RunningAppProcessInfo process : processes) {
                    if (process.pid == pid) {
                        return process.processName;
                    }
                }
            }
        }

        return null;
    }

然后在调用方：

    boolean isMainProcess() {
        return TextUtils.equals(mContext.getPackageName(), getProcessName());
    }
于 2020-10-12T15:33:26.820 回答