Oppo手机的WM坑

2022-07-05

本文基于WorkManager的版本是2.5.0

我在Oppo的6.0一下手机(<23)，使用WM，会发现偶尔有这样的一个错误：

1
2
3

ava.lang.SecurityException

Unable to start service Intent { act=ACTION_STOP_WORK cmp=xxxx/androidx.work.impl.background.systemalarm.SystemAlarmService (has extras) }: Unable to launch app xxxx for service Intent { act=ACTION_STOP_WORK，xxxxx)，: user 0 is restricted

通过搜索我们知道了是oppo手机的电源管理导致的问题，可以看Service在OPPO系列手机下无法启动。我的日志目前都是发生在WorkManager的SystemAlarmScheduler的cancel方法，我们的目的就是给这个方法增加一个try/catch来避免后台崩溃。

实现

我们看代码，是知道SystemAlarmScheduler是在Schedulers被调用并被实例化，如下：

static Scheduler createBestAvailableBackgroundScheduler(
            @NonNull Context context,
            @NonNull WorkManagerImpl workManager) {

        Scheduler scheduler;

        if (Build.VERSION.SDK_INT >= WorkManagerImpl.MIN_JOB_SCHEDULER_API_LEVEL) {
            scheduler = new SystemJobScheduler(context, workManager);
            setComponentEnabled(context, SystemJobService.class, true);
            Logger.get().debug(TAG, "Created SystemJobScheduler and enabled SystemJobService");
        } else {
            scheduler = tryCreateGcmBasedScheduler(context);
            if (scheduler == null) {
                scheduler = new SystemAlarmScheduler(context);
                setComponentEnabled(context, SystemAlarmService.class, true);
                Logger.get().debug(TAG, "Created SystemAlarmScheduler");
            }
        }
        return scheduler;
    }

我们可以知道，假如在api23以下，他会先走tryCreateGcmBasedScheduler，假如不存在才回去创建一个SystemAlarmScheduler对象，tryCreateGcmBasedScheduler方法如下

@Nullable
   private static Scheduler tryCreateGcmBasedScheduler(@NonNull Context context) {
       try {
           Class<?> klass = Class.forName(GCM_SCHEDULER);
           Scheduler scheduler =
                   (Scheduler) klass.getConstructor(Context.class).newInstance(context);
           Logger.get().debug(TAG, String.format("Created %s", GCM_SCHEDULER));
           return scheduler;
       } catch (Throwable throwable) {
           Logger.get().debug(TAG, "Unable to create GCM Scheduler", throwable);
           return null;
       }
   }

可以看到他通过反射生成GCM_SCHEDULER这个类，该类有一个构造函数的参数是Context。看到是通过GCM_SCHEDULER来生成一个类，那我们能否替换GCM_SCHEDULER来换成自己的路径，然后对新类的cancel方法进行替换呢？然后我们看了下GCM_SCHEDULER的类型，他是public static final String类型的，无法通过发射修改，因此，我们就无法更改tryCreateGcmBasedScheduler的返回了。

然后我们继续重头捋一下，看到：
createBestAvailableBackgroundScheduler是被WorkManagerImpl.createSchedulers调用的，createSchedulers得到的schedulers会传递给WorkManagerImpl的构造器，最终到了成员变量mSchedulers中，也到了Processor的变量mSchedulers中，那么我们就可以换一种方式，即在WorkManagerImpl完成初始化之后，通过发射修改成员变量schedulers，从而达到替换SystemAlarmScheduler的目的。具体的代码如下：

package androidx.work.impl

import android.annotation.SuppressLint
import android.content.Context
import android.util.Log
import androidx.annotation.Keep
import androidx.work.Configuration
import androidx.work.WorkManager
import androidx.work.impl.background.systemalarm.OppoAlarmScheduler
import androidx.work.impl.background.systemalarm.SystemAlarmScheduler
import androidx.work.impl.utils.PackageManagerHelper

@Keep
class MyWorkManagerInitializer : WorkManagerInitializer() {
    override fun onCreate(): Boolean {
        // Initialize WorkManager with the default configuration.
        val config =
            Configuration.Builder()
                .setMinimumLoggingLevel(Log.INFO)
                .setInitializationExceptionHandler {
                    //...打印log，另外一个问题
                }
                .build()
        context?.let { WorkManager.initialize(context!!, config) }
        reflectOppo(context)
        return true
    }
}

/** 
oppo问题bugfix
*/
fun reflectOppo(context: Context?) {
    // 6.0以上不处理
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        return
    }
    // 非oppo不处理
    if (!RomUtils.isOppo()) {
        return
    }
    context?.let {
        try {
            val impl = WorkManager.getInstance(it) as? WorkManagerImpl ?: return@let
            for (item in impl.schedulers) {
                if (item is OppoAlarmScheduler) {
                    // 添加过 不需要继续往下了
                    return@let
                }
            }
            var found = false
            val newList = impl.schedulers.toMutableList()
            for (i in 0 until newList.size) {
                if (newList[i] is SystemAlarmScheduler) {
                    newList.removeAt(i)
                    found = true
                    break
                }
            }
            // 如果没有SystemAlarmScheduler那也不用替换
            if (!found) {
                return@let
            }
            val oppo = OppoAlarmScheduler(context)
            PackageManagerHelper.setComponentEnabled(context, OppoAlarmScheduler::class.java, true)
            newList.add(oppo)

            // 修改mSchedulers为新的列表值
            val field = WorkManagerImpl::class.java.getDeclaredField("mSchedulers")
            field.isAccessible = true
            field.set(impl, newList)
             // 替换processor的
            val process = impl.processor
            val processorField = Processor::class.java.getDeclaredField("mSchedulers")
            processorField.isAccessible=true
            processorField.set(process,newList)
        } catch (ignore: Exception) {}
    }
}

OppoAlarmScheduler的代码如下：

package androidx.work.impl.background.systemalarm

import android.annotation.SuppressLint
import android.content.Context

@Keep
class OppoAlarmScheduler(ctx: Context) : SystemAlarmScheduler(ctx) {
    override fun cancel(workSpecId: String) {
        try {
            super.cancel(workSpecId)
        } catch (ignore: Exception) {
        }
    }
}

这样就可以在WorkManager初始化之后通过反射去掉SystemAlarmScheduler并更换自定义的

可以看到他通过反射生成GCM_SCHEDULER这个类，该类有一个构造函数的参数是Context。

看到了这里，我们就看到了曙光，我们可以通过反射修改GCM_SCHEDULER的值，使得他指向我们自定义的类，我们自定义一个继承自SystemAlarmScheduler的类，然后把它的cancel方法try/catch主即可，这里建议新建的类需要与SystemAlarmScheduler路径保持一致。

@Keep
class OppoAlarmScheduler(ctx: Context) : SystemAlarmScheduler(ctx) {
    override fun cancel(workSpecId: String) {
        try {
            super.cancel(workSpecId)
        } catch (e: Exception) {
            DevLog.logE(e)
            commonOffLog("OppoAlarmScheduler", Log.getStackTraceString(e))
        }
    }
}

然后我们再自定义WorkManaer的初始化或者是Configuration.Provider调用之前发射设置GCM_SCHEDULER值，初始化的问题看orkManager的坑

//在WorkManager.initialize(context!!, config)之前调用
//和在getWorkManagerConfiguration()的返回值之前调用
fun reflectOppo() {
    // 6.0以上不处理
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        return
    }
    // 非oppo不处理
    if (!RomUtils.isOppo()) {
        return
    }
    try {
        val clazz = Class.forName("androidx.work.impl.Schedulers")
        ReflectUtils.reflect("androidx.work.impl.Schedulers")
        val field = clazz.getField("GCM_SCHEDULER")
        field.isAccessible = true
        field.set(clazz, OPPO_CLASS)
    } catch (e: Exception) {
        DevLog.logE(e)
        commonOffLog("reflectOppo", Log.getStackTraceString(e))
    }
}

这样就fix这个oppo问题了。