Detecting if you're in the main process or the remote service process in Application

Question

I have an application which has a remote service running in a separate process:

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

I'm also using an Application class:

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

Can I do something like this?

public class MyApplication extends Application {

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

I'm thinking I could get the process name and use that to detect if I'm in the remote service or the main app, but I haven't found out how to get the process name. I can get the PID from android.os.Process.myPID(), but that doesn't help me much.

Niobium

Answer 1

For example, if you want to check whether you are in main process, you can write code in your application like this:

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;
    }
}

Papeterie

Unfortunately your assumption that main process must have the same name as your package is only right unless you use process attribute in your application. – Regenerate

Answer 2

I can offer an indirect solution:

Within each of the respective StartUp methods, set a System Property:

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

The Properties are static, isolated to the process, and can be reached from everywhere. Added benefit is they can be directly used by logging frameworks like Logback.

Kopeck

Answer 3

I had a similar issue and this is what I did.

MyService and MyActivity have a common part, MyEngine, but the behaviour must be a bit different in these two cases.

One thing that is different is setup, but this setup is done in the classes MyService and MyActivity.

Another thing that is different for the activity and the service is done via a listener: MyEngine defines the interface MyEngine.Listener while MyService and MyActivity provide the engine with different implementations of that interface.

So, if you want to pass a boolean value, two methods are possible:

// 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);
    ...
}

Notes.

1. The boolean value used in the above example is useless in the real world: if you want to use, say, different log file names, it is better to pass the file name rather than the boolean. If you want to perform two different actions, it's better to have one listener function with two implementations.

2. Of course, one could pass a Context and check if it is a child of Activity or a Service, or get the name of the current process, but these things are Android-specific implementation details, and it's better not to depend on them unless absolutely necessary.

Fool

Answer 4

I'm using a piece of code, which is taken from Google's WorkManager lib. As of writing this it's located in GreedyScheduler.java. Having defined method getProcessName() as such:

    @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;
    }

Then on the calling side:

    boolean isMainProcess() {
        return TextUtils.equals(mContext.getPackageName(), getProcessName());
    }

Depersonalization