Android monitors mobile app usage

brief introduction

In this article, Android is used to obtain the Activity on the top of the mobile phone to monitor the usage of mobile applications

Technical background

In my daily study, I want to automatically collect the use time of various applications of mobile phone software, such as get, geek time, Keep, wechat reading, etc

However, after searching, it was not found that they had the corresponding API development interface, so there was no way to obtain it

Xiaomi's mobile phone has the usage of mobile applications. In the screen usage time, the data looks very good and suitable, but I don't know how to obtain it

Finally, you can only write a native Android application by yourself, report to the server every 10 seconds by obtaining the top-level Activity of the mobile phone, and set the mapping between the Activity and the application name to achieve the purpose of your own mobile application usage statistics

Code details

The complete code is on GitHub:

Only for code reference. At present, data monitoring and uploading are available, but these interfaces are still very rough and not perfect

You should pay attention to the following points when using this function:

  • 1. It is necessary to set monitoring as a background service to avoid being frequently kill ed after switching to other applications
  • 2. It is necessary to call relevant permission settings to enable users to open relevant applications and obtain permissions
  • 3. The rest is the preparation of application monitoring code

The specific codes are as follows:

Application monitoring - get top-level Activity of mobile phone

We need to create a new background Service, inherit the Service, and then start a timer to obtain the top-level Activity every ten seconds. The data upload part can be ignored

The code is as follows:

public class MonitorActivityService extends Service {

    private String beforeActivity;
    private final ActivityRequest activityRequest = new ActivityRequest();

     * @param intent
     * @param flags
     * @param startId
     * @return
    public int onStartCommand(Intent intent, int flags, int startId) {
        //Processing tasks
        return START_STICKY;

    public IBinder onBind(Intent intent) {
        return null;

    public void onCreate() {
        Log.d("foreground", "onCreate");
        //If the API is above 26, that is, the version is O, call the startforeround () method to start the service
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {

     * Start service by notification
     * 10 Get once per second
    @androidx.annotation.RequiresApi(api = Build.VERSION_CODES.O)
    public void  setForegroundService()
        //Set notification channel name
        String channelName = "test";
        //Set the importance of notifications
        int importance = NotificationManager.IMPORTANCE_LOW;
        //Build notification channels
        NotificationChannel channel = new NotificationChannel("232", channelName, importance);
        //Send notifications on created notification channels
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this, "232");
        builder.setSmallIcon(R.drawable.ic_launcher_foreground) //Set notification icon
                .setContentTitle("Monitoring mobile activity and reporting")//Set notification title
                .setContentText("Monitoring mobile activity and reporting")//Set notification content
                .setAutoCancel(true) //Automatically turns off when touched by the user
                .setOngoing(true);//Settings are running
        //Register the notification channel with the system. After registration, the importance and other notification behaviors cannot be changed
        NotificationManager notificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
        //Place service in startup state NOTIFICATION_ID refers to the ID of the notification created

        Handler handler=new Handler();
        Runnable runnable=new Runnable(){
            public void run() {
                Log.d("Monitor Detect", "Timed detection top-level application");
                handler.postDelayed(this, 10000);
        handler.postDelayed(runnable, 10000);//Run every two seconds

     * Get mobile top-level Activity
    public void getTopActivity()
        long endTime = System.currentTimeMillis();
        long beginTime = endTime - 10000;
        UsageStatsManager sUsageStatsManager = (UsageStatsManager) this.getSystemService(Context.USAGE_STATS_SERVICE);
        String result = "";
        UsageEvents.Event event = new UsageEvents.Event();
        UsageEvents usageEvents = sUsageStatsManager.queryEvents(beginTime, endTime);
        while (usageEvents.hasNextEvent()) {
            if (event.getEventType() == UsageEvents.Event.MOVE_TO_FOREGROUND) {
                result = event.getPackageName()+"/"+event.getClassName();
        if (!android.text.TextUtils.isEmpty(result)) {
            Log.d("Service", result);
            beforeActivity = result;
        } else {
            Log.d("Before Service", beforeActivity == null ? "null" : beforeActivity);

        if (beforeActivity == null) {
            Toast.makeText(MonitorActivityService.this.getApplicationContext(),"Activity is empty",Toast.LENGTH_SHORT).show();

        activityRequest.uploadRecord(beforeActivity, success -> {

        }, failed -> {
            Toast.makeText(MonitorActivityService.this.getApplicationContext(),"Upload failed",Toast.LENGTH_SHORT).show();
            Log.w("Activity", "Upload failed:" + failed);

Related permission settings

Relevant permissions need to be enabled in the configuration

At androidmanifest Add to the XML file:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=""

    // Application usage permissions
    <permission android:name="android.permission.PACKAGE_USAGE_STATS"/>




Application startup

Add startup logic to MainActivity

public class MainActivity extends AppCompatActivity {

    private AppBarConfiguration mAppBarConfiguration;
    private ActivityMainBinding binding;

    @RequiresApi(api = Build.VERSION_CODES.O)
    protected void onCreate(Bundle savedInstanceState) {

        // Access to mobile phone usage
        if (!isStatAccessPermissionSet()) {
            Intent intent = new Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS);

        // Android 8.0 uses startforeroundservice to start a new service in the foreground
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
            this.startForegroundService(new Intent(MainActivity.this, MonitorActivityService.class));
            this.startService(new Intent(MainActivity.this, MonitorActivityService.class));

        if (!isNotificationEnabled()) {

     * Judge whether the permission notice has been authorized
     * When the return value is true, the notification bar is opened and false is not opened.
    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
    private boolean isNotificationEnabled() {

        String CHECK_OP_NO_THROW = "checkOpNoThrow";

        AppOpsManager mAppOps = (AppOpsManager) this.getSystemService(Context.APP_OPS_SERVICE);
        ApplicationInfo appInfo = this.getApplicationInfo();
        String pkg = this.getApplicationContext().getPackageName();
        int uid = appInfo.uid;

        Class appOpsClass = null;
        /* Context.APP_OPS_MANAGER */
        try {
            appOpsClass = Class.forName(AppOpsManager.class.getName());
            Method checkOpNoThrowMethod = appOpsClass.getMethod(CHECK_OP_NO_THROW, Integer.TYPE, Integer.TYPE,
            Field opPostNotificationValue = appOpsClass.getDeclaredField(OP_POST_NOTIFICATION);

            int value = (Integer) opPostNotificationValue.get(Integer.class);
            return ((Integer) checkOpNoThrowMethod.invoke(mAppOps, value, uid, pkg) == AppOpsManager.MODE_ALLOWED);

        } catch (ClassNotFoundException | NoSuchMethodException | NoSuchFieldException | InvocationTargetException | IllegalAccessException e) {
        return false;

     * Jump to the setting interface of app -- start notification
    private void goToNotificationSetting() {
        Intent intent = new Intent();
        if (Build.VERSION.SDK_INT >= 26) {
            // android 8.0 boot
            intent.putExtra("android.provider.extra.APP_PACKAGE", this.getPackageName());
        } else if (Build.VERSION.SDK_INT >= 21) {
            // android 5.0-7.0
            intent.putExtra("app_package", this.getPackageName());
            intent.putExtra("app_uid", this.getApplicationInfo().uid);
        } else {
            // other
            intent.setData(Uri.fromParts("package", this.getPackageName(), null));

     * Determine whether the application permission with permission to view usage has been obtained
    public boolean isStatAccessPermissionSet() {
        try {
            PackageManager packageManager = this.getPackageManager();
            ApplicationInfo info = packageManager.getApplicationInfo(this.getPackageName(), 0);
            AppOpsManager appOpsManager = (AppOpsManager) this.getSystemService(APP_OPS_SERVICE);
            return appOpsManager.checkOpNoThrow(AppOpsManager.OPSTR_GET_USAGE_STATS, info.uid, info.packageName) == AppOpsManager.MODE_ALLOWED;
        } catch (Exception e) {
            return false;

After you start Android Studio, you can see the relevant output log

Keywords: Java Android Apache

Added by lorne17 on Wed, 16 Feb 2022 22:43:07 +0200