文章结构: 按照逆向过程中的可疑类作为单元

RunTrackManager.writeRunInfo.1

略

RunTrackManager

包路径: com.tanma.unirun.service.RunTrackManager

来自: RunningServiceImpl类中跟观察者有关的lambda1$run()​方法 (也跟lambda2$run()​方法有关)

作用: 就像名字一样, 跑步足迹管理器. 后面发现了其中的start() 方法, 非常重要, 对地图进行了一些初始化的操作(包括设置了足迹监听器RunTrackManager.locationListener.1​)

方法

start()

注意13-15行, 设置了RunTrackManager.locationListener.1​

    public final void start() {
        if(this.mAMapLocationClient == null) {
            this.mAMapLocationClient = new AMapLocationClient(StubApp.getOrigApplicationContext(this.context.getApplicationContext()));
        }

        this.mAMapLocationOption = this.getDefaultOption();
        AMapLocationClient aMapLocationClient0 = this.mAMapLocationClient;
        if(aMapLocationClient0 != null) {
            aMapLocationClient0.setLocationOption(this.mAMapLocationOption);
        }

        AMapLocationClient aMapLocationClient1 = this.mAMapLocationClient;
        if(aMapLocationClient1 != null) {
            aMapLocationClient1.setLocationListener(this.locationListener);
        }

        AMapLocationClient aMapLocationClient2 = this.mAMapLocationClient;
        if(aMapLocationClient2 != null) {
            aMapLocationClient2.startLocation();
        }

        this.enableBackgroundLocation();
    }

getInstance()

获取实例???

但是是通过类中的静态变量来获取, 应该是某种特殊的模式(还没学过), 但是可以知道的是获取了RunTrackManager的实例

    public static final class Companion {
        private Companion() {
        }

        public Companion(DefaultConstructorMarker $constructor_marker) {
        }

        public final RunTrackManager getInstance() {
            return RunTrackManager.instance;
        }

        public final RunTrackManager getInstance(Context context) {
            Intrinsics.checkParameterIsNotNull(context, "context");
            if(this.getInstance() == null) {
                KClass kClass0 = Reflection.getOrCreateKotlinClass(RunTrackManager.class);
                synchronized(kClass0) {
                    if(RunTrackManager.Companion.getInstance() == null) {
                        RunTrackManager runTrackManager0 = new RunTrackManager(context);
                        RunTrackManager.Companion.setInstance(runTrackManager0);
                    }
                }
            }

            RunTrackManager runTrackManager1 = this.getInstance();
            if(runTrackManager1 == null) {
                Intrinsics.throwNpe();
            }

            return runTrackManager1;
        }

        public final void setInstance(RunTrackManager <set-?>) {
            RunTrackManager.instance = <set-?>;
        }
    }

    private static volatile RunTrackManager instance;

writeRunInfo(String comtent)

来自: lambda2$run()​中定义了一个Date对象, 记录当前时间, 然后将date转化成固定格式的字符串传入到该方法中

描述:

  • 检查字符串是否为空
  • 创建了一个新线程, 并调用了RunTrackManager.writeRunInfo.1​(Runnable子类)的start()方法, 启动了子线程
    public final void writeRunInfo(String content) {
        synchronized(this) {
            if((TextUtils.isEmpty(((CharSequence)content))) && (BuildConfig.DEBUG)) {
                return;
            }

            goto label_10;
        }

        return;
        try {
        label_10:
            new Thread(((Runnable)new RunTrackManager.writeRunInfo.1(content))).start();
        }
        catch(Throwable throwable0) {
            throw throwable0;
        }
    }
}

StudentRunRecordRequestBody

包路径: com.tanma.unirun.network.body.StudentRunRecordRequestBody

来自: RunningServiceImpl​类的commitRunRecord()​中创建了该对象的实例

作用: 应该就是最终的上传报文了

数据域字段名(无则使用系统函数)(空白需要注意)含义是否完成
againRunStatussp_run_again_runstatus
againRunTimesp_run_again_runtime
appVersionsAPKVersionUtils.INSTANCE.getVersionName(this)
brandAPKVersionUtils.INSTANCE.getDeviceBrand()
distanceTimeStatussp_run_distance_time
innerSchool
mobileTypeAPKVersionUtils.INSTANCE.getSystemModel()
realityTrackPoints
recordDatesp_start_run_time
runDistance
runTime
sysVersionsAPKVersionUtils.INSTANCE.getSystemVersion()
trackPoints
userIdInteger.valueOf(this.mUser.getUserId()) 注意: mUser是RunningServiceImpl的数据域
vocalStatus​VocalVerifyPresenterImpl.resolveStopRecord.4.callback.1.onSuccess.1​
this.runSharedPre.getString("sp_run_vocalverify_status", "0")​这个就是从前面的修改的数据库中取出状态, 默认0是未验证的状态
yearSemesterthis.mRunStandard.getSemesterYear()

‍

Track

包路径: com.tanma.unirun.data.Track

来自: 在RunningServiceImpl类中的onLocationSuccess()方法中有创建该类的实例

作用: 描述一个足迹

TrackDao

包路径: com.tanma.unirun.greendao.TrackDao

来自: TrackUtils中的getAMapLatLng()​获取了TrackDao, 并调用了queryBuilder()​方法

是一个表的抽象

内部类

就是对数据库中一条记录定义

其中的属性是其字段

    public static class Properties {
        public static final Property Accuracy;
        public static final Property Bearing;
        public static final Property Effective;
        public static final Property Id;
        public static final Property Latitude;
        public static final Property LocationType;
        public static final Property Longitude;
        public static final Property Original;
        public static final Property Speed;
        public static final Property Time;

        static {
            Properties.Id = new Property(0, Long.class, "id", true, "_id");
            Properties.Latitude = new Property(1, Double.TYPE, "latitude", false, "LATITUDE");
            Properties.Longitude = new Property(2, Double.TYPE, "longitude", false, "LONGITUDE");
            Properties.LocationType = new Property(3, Integer.TYPE, "locationType", false, "LOCATION_TYPE");
            Properties.Accuracy = new Property(4, Float.TYPE, "accuracy", false, "ACCURACY");
            Properties.Speed = new Property(5, Float.TYPE, "speed", false, "SPEED");
            Properties.Bearing = new Property(6, Float.TYPE, "bearing", false, "BEARING");
            Properties.Time = new Property(7, Long.TYPE, "time", false, "TIME");
            Properties.Original = new Property(8, Integer.TYPE, "original", false, "ORIGINAL");
            Properties.Effective = new Property(9, Integer.TYPE, "effective", false, "EFFECTIVE");
        }
    }

RunningModelImpl

包路径: com.tanma.unirun.ui.activity.running.RunningModelImpl

从RunningPresenterImpl找到的

功能: 其实例方法可以提交跑步数据, 这里感觉主要还是整理数据

public void commitRunRecord(String mKm) {
        Intrinsics.checkParameterIsNotNull(mKm, "mKm");
        BaseActivityExtKt.createWaitDialog(((Context)this.context()));
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String s1 = null;
        RunStandard mRunStandard = (RunStandard)new PreUtil("sp_name_app").getValue("sp_app_runstandard", Reflection.getOrCreateKotlinClass(RunStandard.class), null);
        StudentRunRecordRequestBody body = new StudentRunRecordRequestBody(null,         // s:java.lang.String
                                                                           null,         // integer0:java.lang.Integer
                                                                           null,         // s1:java.lang.String
                                                                           null,         // s2:java.lang.String
                                                                           null,         // s3:java.lang.String
                                                                           null,         // s4:java.lang.String
                                                                           null,         // s5:java.lang.String
                                                                           null,         // s6:java.lang.String
                                                                           null,         // s7:java.lang.String
                                                                           null,         // integer1:java.lang.Integer
                                                                           null,         // integer2:java.lang.Integer
                                                                           null,         // integer3:java.lang.Integer
                                                                           null,         // s8:java.lang.String
                                                                           null,         // s9:java.lang.String
                                                                           null,         // s10:java.lang.String
                                                                           null,         // s11:java.lang.String
                                                                           0xFFFF,       // v:int
                                                                           null          // defaultConstructorMarker0:kotlin.jvm.internal.DefaultConstructorMarker
                                                                           );
        Integer integer0 = (int)0;
        Long startTime = (Long)new PreUtil("rundata").getValue("sp_start_run_time", Reflection.getOrCreateKotlinClass(Long.TYPE), integer0);
        String againRunStatus = (String)new PreUtil("rundata").getValue("sp_run_again_runstatus", Reflection.getOrCreateKotlinClass(String.class), "0");
        body.setAgainRunStatus(againRunStatus);
        body.setAgainRunTime(((Integer)new PreUtil("rundata").getValue("sp_run_again_runtime", Reflection.getOrCreateKotlinClass(Integer.TYPE), integer0)));
        Context context0 = (Context)this.context();
        body.setAppVersions(APKVersionUtils.INSTANCE.getVersionName(context0));
        body.setBrand(APKVersionUtils.INSTANCE.getDeviceBrand());
        body.setMobileType(APKVersionUtils.INSTANCE.getSystemModel());
        body.setSysVersions(APKVersionUtils.INSTANCE.getSystemVersion());
        body.setTrackPoints(new TrackUtils(((Context)this.context())).getTrackToString(1));
        body.setDistanceTimeStatus(((String)new PreUtil("rundata").getValue("sp_run_distance_time", Reflection.getOrCreateKotlinClass(String.class), "1")));
        Collection collection0 = (Collection)AreaData.Companion.getSchoolBoundList();
        if(collection0 == null || (collection0.isEmpty())) {
            body.setInnerSchool("1");
            body.setRealityTrackPoints("");
        }
        else {
            body.setInnerSchool(new TrackUtils(((Context)this.context())).pointsIsInArea(1));
            body.setRealityTrackPoints(AreaData.Companion.getAreaBody());
        }

        boolean z = UnirunApplication.Companion.instance().getSharedPreferences("rundata", 0).getBoolean("sp_run_have_step", false);
        int v = new TrackUtils(((Context)this.context())).getDistance();
        if(((TextUtils.isEmpty(((CharSequence)againRunStatus))) || !StringsKt.equals$default(againRunStatus, "1", false, 2, null)) && (z) && !TextUtils.isEmpty(((CharSequence)mKm))) {
            float f = Float.parseFloat(mKm);
            if(((double)f) > 0.0 && f > ((float)new TrackUtils(((Context)this.context())).getDistance())) {
                v = (int)f;
            }
        }

        body.setRunDistance(Integer.valueOf(v));
        body.setRunTime(Integer.valueOf(RunningServiceImpl.getRunTime() / 60));
        User user0 = UnirunApplication.Companion.instance().getUser();
        Integer integer1 = user0 == null ? null : ((int)user0.getUserId());
        body.setUserId(integer1);
        body.setVocalStatus(((String)new PreUtil("rundata").getValue("sp_run_vocalverify_status", Reflection.getOrCreateKotlinClass(String.class), "0")));
        if(mRunStandard != null) {
            s1 = mRunStandard.getSemesterYear();
        }

        body.setYearSemester(s1);
        if(startTime == null) {
            Intrinsics.throwNpe();
        }

        body.setRecordDate(dateFormat.format(new Date(((long)startTime))));
        ApiClient.Companion.getInstance().getSchoolApi().saveRunRecordV2(body).compose(((ObservableTransformer)this.context().bindToLifecycle())).compose(ResponseTransformer.Companion.handleResult()).compose(SchedulerProvider.Companion.getInstance().applySchedulers()).subscribe(((Consumer)new RunningModelImpl.commitRunRecord.1(this)), ((Consumer)new RunningModelImpl.commitRunRecord.2(this)));
    }

RunningPresenterImpl

包路径: com.tanma.unirun.ui.activity.running.RunningPresenterImpl

查找途径: 通过在RunningServiceImpl类​中使用键值对查找字符串sp_app_runstandard找到的

看起来应该是跑步界面的逻辑实现部分

checkRunRecord()

非常粗略的看了以下这个方法(看这个函数是因为它的字符串全是"继续跑步", "放弃成绩", 可以确定是一个关键方法), 找到了其中调用的关键方法

倒数9行this.getModelImpl().commitRunRecord(this.countTotalKM(this.totalStepNumber)); // 提交跑步记录​ 是关键调用

private final boolean checkRunRecord() {
        Integer integer2;
        Integer integer1;
        if(this.util.getNetworkConnectionType(((Context)this.getContext())) == -1) {
            this.showAlertNetError();
            return false;
        }

        CircleProgress circleProgress0 = (CircleProgress)((FragmentActivity)this.getContext()).findViewById(id.progress_circular_info);
        Intrinsics.checkExpressionValueIsNotNull(circleProgress0, "context.progress_circular_info");
        circleProgress0.setValue(100.0f);
        CircleProgress circleProgress1 = (CircleProgress)((FragmentActivity)this.getContext()).findViewById(id.progress_circular);
        Intrinsics.checkExpressionValueIsNotNull(circleProgress1, "context.progress_circular");
        circleProgress1.setValue(100.0f);
        User user0 = UnirunApplication.Companion.instance().getUser();
        Integer integer0 = null;
        if(TextUtils.equals("1", ((CharSequence)(user0 == null ? null : user0.getGender())))) {
            RunStandard runStandard0 = this.mRunStandard;
            integer1 = runStandard0 == null ? null : ((int)runStandard0.getBoyOnceTimeMin());
        }
        else {
            integer1 = this.mRunStandard == null ? null : ((int)this.mRunStandard.getGirlOnceTimeMin());
        }

        int v = integer1 == null ? 0 : ((int)integer1);
        User user1 = UnirunApplication.Companion.instance().getUser();
        if(TextUtils.equals("1", ((CharSequence)(user1 == null ? null : user1.getGender())))) {
            RunStandard runStandard1 = this.mRunStandard;
            integer2 = runStandard1 == null ? null : ((int)runStandard1.getBoyOnceDistanceMin());
        }
        else {
            integer2 = this.mRunStandard == null ? null : ((int)this.mRunStandard.getGirlOnceDistanceMin());
        }

        int v1 = integer2 == null ? 0 : ((int)integer2);
        int v2 = RunningServiceImpl.getRunTime();
        Log.e("infos", "checkRunRecord runTime=" + v2);
        if(v2 < v * 60) {
            Log.e("infos", "checkRunRecord 时间没够");
            Context context0 = (Context)this.getContext();
            String s = this.runErrorTime;
            if(s == null) {
                Intrinsics.throwUninitializedPropertyAccessException("runErrorTime");
            }

            BaseActivityExtKt.showPermissionDialog(context0, s, true, "继续跑步", "放弃成绩", ((CallBack)new RunningPresenterImpl.checkRunRecord.1(this)));
            return false;
        }

        if(RunningServiceImpl.getRunDistance() < v1) {
            Log.e("infos", "checkRunRecord 距离不够");
            Context context1 = (Context)this.getContext();
            String s1 = this.runErrorDistance;
            if(s1 == null) {
                Intrinsics.throwUninitializedPropertyAccessException("runErrorDistance");
            }

            BaseActivityExtKt.showPermissionDialog(context1, s1, true, "继续跑步", "放弃成绩", ((CallBack)new RunningPresenterImpl.checkRunRecord.2(this)));
            return false;
        }

        if(this.mVerify != 1) {
            RunStandard runStandard2 = this.mRunStandard;
            if(runStandard2 != null) {
                integer0 = (int)runStandard2.getVocalVerifyTime();
            }

            if(integer0 == null) {
                Intrinsics.throwNpe();
            }

            if(v2 >= 0 && (((int)integer0) + 2) * 60 >= v2) {
                Log.e("infos", "checkRunRecord 没有声纹认证");
                Context context2 = (Context)this.getContext();
                String s2 = this.runErrorVolid;
                if(s2 == null) {
                    Intrinsics.throwUninitializedPropertyAccessException("runErrorVolid");
                }

                BaseActivityExtKt.createAlertView(context2, s2, "放弃成绩", "继续跑步", ((CallBack)new RunningPresenterImpl.checkRunRecord.3(this)));
                return false;
            }
        }

        Log.e("infos", "checkRunRecord 提交");
        this.stopRun();
        this.getModelImpl().commitRunRecord(this.countTotalKM(this.totalStepNumber));  // 提交跑步记录
        CircleProgress circleProgress2 = (CircleProgress)((FragmentActivity)this.getContext()).findViewById(id.progress_circular_info);
        Intrinsics.checkExpressionValueIsNotNull(circleProgress2, "context.progress_circular_info");
        circleProgress2.setValue(0.0f);
        CircleProgress circleProgress3 = (CircleProgress)((FragmentActivity)this.getContext()).findViewById(id.progress_circular);
        Intrinsics.checkExpressionValueIsNotNull(circleProgress3, "context.progress_circular");
        circleProgress3.setValue(0.0f);
        return false;
    }

UnirunApplication

包路径: com.tanma.unirun.UnirunApplication

该类是通过前面的RunningServiceImpl​ 交叉引用看到的, 其中比较重要的点

  • saveUser()方法中带有"https://run-lb.tanmasports.com/ "字符串, 这个很可能是发包的地址!!
  • 里面对”sp_user”

RunningServiceImpl (关键类)

包路径: com.tanma.unirun.service.RunningServiceImpl

跑步逻辑的主要实现, 其他的类看看这个类引用了哪些资源再做分析即可

数据域

静态数据runningTime

    private static int runningTime

用于记录跑步的时长, 参考方法lambda​$startWork$​1$RunningServiceImpl()​

里面对该数据进行了初始化

可知是已跑时长, 且单位是秒

RunningServiceImpl.runningTime = (int)((System.currentTimeMillis() - RunningServiceImpl.mStartTimeMillis) / 1000L);

mTrackLatLngList

用于记录足迹的列表

在startRunRecord()​中讲该类的mTrackLatLngList​数据域设置到了runningLocationEvent​对象中

静态块

static {
        StubApp.interface11(7293);
        RunningServiceImpl.mTrackLatLngList = new ArrayList();
        RunningServiceImpl.mStartTimeMillis = 0L;
        Boolean boolean0 = Boolean.valueOf(false);
        RunningServiceImpl.runningTime = 0;
        RunningServiceImpl.mDistance = 0;
        RunningServiceImpl.isRunning = false;
        RunningServiceImpl.mRemindTime = -1;
        RunningServiceImpl.mCenterBdLocation = null;
        RunningServiceImpl.isVibrator = boolean0;
        RunningServiceImpl.isOutSchoolVibrator = boolean0;
        RunningServiceImpl.hasShowDialog = false;
        RunningServiceImpl.showDialogNumber = 0;
        RunningServiceImpl.startOutSchoolTime = 0L;
    }
  • StubApp.interface11(7293): 壳中的native函数, 还不知道360对so加固的方法是什么

主方法

RunningServiceImpl()构造方法

  • 创建三个不同的SimpleDateFormat时间格式对象

  • 创建一个新的WakeUpReceiver广播接收器对象

    • onReceive(): DaemonEnv类(守护进程环境)是否是初始化, 若已初始化则调用DaemonEnv.startServiceMayBind(DaemonEnv.sServiceClass);​静态方法

      • balabalabala有点看不懂, 应该是开启了一项服务, 具体是什么后面再说

  • mUser获取到了用户的实例, 对发包应该起到标识用户的作用

  • alarmIntent: 闹钟意图

  • 创建一个Alarm广播接收器: 接收running_keep_location意图, 作用可以根据字符串"跑步时第" + RunningServiceImpl.runningTime + "秒执行钟唤醒广播”​看出来应该是唤醒广播, 提示用户语言识别(猜测)

public RunningServiceImpl() {
        this.mSimpleFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        this.mTimeFormat = new SimpleDateFormat("ddHHmmss");
        this.mDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        this.mWakeReceiver = new WakeUpReceiver();
        this.isFirstLocation = false;
        this.mUser = UnirunApplication.Companion.instance().getUser();
        this.mLocationList = new ArrayList();
        this.alarmIntent = null;
        this.alarmPi = null;
        this.KeepAlarmReceiver = new BroadcastReceiver() {
            @Override  // android.content.BroadcastReceiver
            public void onReceive(Context context, Intent intent) {
                if(TextUtils.equals("running_keep_location", intent.getAction())) {
                    RunTrackManager.Companion.getInstance(context).start();
                    RunningServiceImpl.this.keepAliveTask();
                    RunningServiceImpl.this.trackManager.writeRunInfo("跑步时第" + RunningServiceImpl.runningTime + "秒执行钟唤醒广播");
                }
            }
        };
    }

onCreate()

该类继承自AbsWorkService​ 本质上是一个服务, 创建后会执行该方法

JEB也给出了注释: // android.app.Service​, 说明这个方法继承自Service

@Override  // android.app.Service
    public void onCreate() {
        super.onCreate();
        RunningServiceImpl.mVibrator = (Vibrator)this.getSystemService("vibrator");  // 震动器
        RunningServiceImpl.mOutSchoolVibrator = (Vibrator)this.getSystemService("vibrator");  // 出校提示的震动
        this.appSharedPre = this.getSharedPreferences("sp_name_app", 0);  // 一个键值对文件
        this.runSharedPre = this.getSharedPreferences("rundata", 0);  // 一个键值对文件
    }

‍

lambda$startWork$RunningServiceImpl()

在静态数据runningTime​查看中感觉这个方法应该是先于或者在startwork()中被调用

startWork()

开始执行跑步的记录等操作:

  • 添加action, 创建mWakeReceiver广播接收器
public void startWork(Intent intent, int flags, int startId) {
				//创建广播接收器
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction("android.intent.action.USER_PRESENT");
        intentFilter.addAction("android.intent.action.ACTION_POWER_CONNECTED");
        intentFilter.addAction("android.intent.action.ACTION_POWER_DISCONNECTED");
        intentFilter.addAction("unirun.intent.action.CANCEL_JOB_ALARM_SUB");
        intentFilter.addAction("android.intent.action.BOOT_COMPLETED");
        intentFilter.addAction("android.intent.action.SCREEN_OFF");
        intentFilter.addAction("android.intent.action.SCREEN_ON");
        this.registerReceiver(this.mWakeReceiver, intentFilter);

				//使手机保持唤醒(weak)状态
        PowerManager pm = (PowerManager)this.getSystemService("power");
        if(this.mWakeLock == null) {
            this.mWakeLock = pm.newWakeLock(1, RunningServiceImpl.class.getName());
            this.mWakeLock.setReferenceCounted(false);
        }
        this.mWakeLock.acquire();

				// 通过SharedPreference读取rundata文件中的键值对
				// mStartTimeMillis默认值是0, 就当是第一次, 所以全部取0即可
        this.runSharedPre = this.getSharedPreferences("rundata", 0);
        RunningServiceImpl.mStartTimeMillis = this.runSharedPre.getLong("sp_start_run_time", 0L);
        String s = this.appSharedPre.getString("sp_app_runstandard", "");


        if(!TextUtils.isEmpty(s)) {
            ObjectMapper mapper = new ObjectMapper();
            try {
                this.mRunStandard = (RunStandard)mapper.readValue(s, RunStandard.class);
            }
            catch(IOException e) {
                e.printStackTrace();
            }
        }

        if(RunningServiceImpl.mNoVoiceMediaPlayer == null) {
            RunningServiceImpl.mNoVoiceMediaPlayer = MediaPlayer.create(this, 0x7F0F0001);
            RunningServiceImpl.mNoVoiceMediaPlayer.setLooping(true);
            RunningServiceImpl.mNoVoiceMediaPlayer.start();
        }

        this.startRunRecord();
        if(this.trackManager == null) {
            Context context0 = StubApp.getOrigApplicationContext(this.getApplicationContext());
            this.trackManager = RunTrackManager.Companion.getInstance(context0);
            this.trackManager.registerOnLocationCallback(this);
            this.trackManager.start();
        }

        this.keepAliveTask();
        SharedPreferences.Editor sharedPreferences$Editor0 = this.runSharedPre.edit();
        RunningServiceImpl.sDisposable = Observable.interval(1L, TimeUnit.SECONDS).doOnDispose(new -..Lambda.RunningServiceImpl.UAPFXct7LjOk_b4QQ0C5ynlot5I(this, sharedPreferences$Editor0)).subscribe(new -..Lambda.RunningServiceImpl.jPJYp7FmXfaXWXAKe9Yz847Nkcs(this, sharedPreferences$Editor0));
    }

这段代码是在一个Android应用程序中的服务类中的startWork方法中，主要做了以下操作：

  1. 注册广播接收器，监听一些系统事件。
  2. 获取PowerManager实例，创建一个WakeLock，保证设备不会在运行过程中进入休眠状态。
  3. 读取SharedPreferences中存储的数据，包括运动标准和启动时间等。
  4. 创建MediaPlayer实例，播放音乐。
  5. 启动运动记录，获取GPS位置信息。
  6. 保持服务运行的心跳任务。
  7. 使用RxJava创建一个周期性任务，每秒钟更新一次SharedPreferences中的数据。
public void startWork(Intent intent, int flags, int startId) {
    IntentFilter intentFilter = new IntentFilter();
    // 注册需要监听的广播
    intentFilter.addAction("android.intent.action.USER_PRESENT");
    intentFilter.addAction("android.intent.action.ACTION_POWER_CONNECTED");
    intentFilter.addAction("android.intent.action.ACTION_POWER_DISCONNECTED");
    intentFilter.addAction("unirun.intent.action.CANCEL_JOB_ALARM_SUB");
    intentFilter.addAction("android.intent.action.BOOT_COMPLETED");
    intentFilter.addAction("android.intent.action.SCREEN_OFF");
    intentFilter.addAction("android.intent.action.SCREEN_ON");
    // 注册广播接收器
    this.registerReceiver(this.mWakeReceiver, intentFilter);
    PowerManager pm = (PowerManager)this.getSystemService("power");
    if(this.mWakeLock == null) {
        // 创建唤醒锁
        this.mWakeLock = pm.newWakeLock(1, RunningServiceImpl.class.getName());
        this.mWakeLock.setReferenceCounted(false);
    }
    // 获得唤醒锁
    this.mWakeLock.acquire();
    this.runSharedPre = this.getSharedPreferences("rundata", 0);
    // 从SharedPreferences中获取运动开始时间
    RunningServiceImpl.mStartTimeMillis = this.runSharedPre.getLong("sp_start_run_time", 0L);
    String s = this.appSharedPre.getString("sp_app_runstandard", "");
    if(!TextUtils.isEmpty(s)) {
        ObjectMapper mapper = new ObjectMapper();
        try {
            // 将字符串转为RunStandard对象
            this.mRunStandard = (RunStandard)mapper.readValue(s, RunStandard.class);
        }
        catch(IOException e) {
            e.printStackTrace();
        }
    }
    // 如果没有声音播放器对象，则创建对象并开始播放
    if(RunningServiceImpl.mNoVoiceMediaPlayer == null) {
        RunningServiceImpl.mNoVoiceMediaPlayer = MediaPlayer.create(this, 0x7F0F0001);
        RunningServiceImpl.mNoVoiceMediaPlayer.setLooping(true);
        RunningServiceImpl.mNoVoiceMediaPlayer.start();
    }
    // 开始记录跑步数据
    this.startRunRecord();
    // 如果跑步轨迹管理对象为空，则创建对象并注册回调，开始定位
    if(this.trackManager == null) {
        Context context0 = StubApp.getOrigApplicationContext(this.getApplicationContext());
        this.trackManager = RunTrackManager.Companion.getInstance(context0);
        this.trackManager.registerOnLocationCallback(this);
        this.trackManager.start();
    }
    // 启动保活任务
    this.keepAliveTask();
    SharedPreferences.Editor sharedPreferences$Editor0 = this.runSharedPre.edit();
    // 每秒执行一次的定时任务，用于更新跑步时间等数据
    RunningServiceImpl.sDisposable = Observable.interval(1L, TimeUnit.SECONDS)
        // 在任务取消时执行的逻辑
        .doOnDispose(new -..Lambda.RunningServiceImpl.UAPFXct7LjOk_b4QQ0C5ynlot5I(this, sharedPreferences$Editor0))
        // 订阅任务，更新SharedPreferences中的跑步数据
        .subscribe(new -..Lambda.RunningServiceImpl.jPJYp7FmXfaXWXAKe9Yz847Nkcs(this, sharedPreferences$Editor0));
}

lambda1

该类并不属于RunningServiceImpl类中, 但是其run()方法调用的其实还是RunningServiceImpl的lambda1run().

实现了reactivex的Action接口(还不知道什么用), 但是有一个run()方法, 猜测可能是回调, 具体的作用看其中的逻辑

package com.tanma.unirun.service;

import android.content.SharedPreferences.Editor;
import io.reactivex.functions.Action;

public final class lambda1 implements Action {
    private final RunningServiceImpl f$0;
    private final SharedPreferences.Editor f$1;

    public lambda1(RunningServiceImpl runningServiceImpl0, SharedPreferences.Editor sharedPreferences$Editor0) {
        this.f$0 = runningServiceImpl0;
        this.f$1 = sharedPreferences$Editor0;
    }

    public final void run() {
        this.f$0.lambda1$run(this.f$1);
    }
}

lambda1$run()

该方法位于RunningServiceImpl类中, 看了以下应该是取消闹钟:

  • 取消了一个通知
  • 取消了音乐(可能是闹铃)

最容易看到的是下面的处理异常字符串"取消闹钟时异常"

感觉这个方法的作用不大

    public void lambda1$run(SharedPreferences.Editor editor) throws Exception {
        try {
            RunningServiceImpl.mDistance = 0;
            Context context0 = StubApp.getOrigApplicationContext(this.getApplicationContext());  // 获取上下文
            RunTrackManager.Companion.getInstance(context0).end();
            if(this.mNotificationManager == null) {
                this.mNotificationManager = (NotificationManager)this.getSystemService("notification");  // 通知管理器
            }

            this.mNotificationManager.cancel(20001);  // 取消之前发送的通知, 20001是通知id
            editor.putBoolean("sp_start_run_status", RunningServiceImpl.isRunning);  // 设置跑步的状态
            editor.apply();  // 上传
            if(RunningServiceImpl.mNoVoiceMediaPlayer != null && (RunningServiceImpl.mNoVoiceMediaPlayer.isPlaying())) {
                RunningServiceImpl.mNoVoiceMediaPlayer.stop();  // 如果voiceMedia正在播放, 则停止
                RunningServiceImpl.mNoVoiceMediaPlayer.reset();
                RunningServiceImpl.mNoVoiceMediaPlayer.release();
                RunningServiceImpl.mNoVoiceMediaPlayer = null;
            }

            AlarmManager alarmManager = (AlarmManager)this.getSystemService("alarm");
            if(alarmManager != null && this.alarmPi != null) {
                alarmManager.cancel(this.alarmPi);
            }

            if(this.KeepAlarmReceiver != null) {
                this.unregisterReceiver(this.KeepAlarmReceiver);
                return;
            }
        }
        catch(Exception e) {
            Logger.e("取消闹钟时异常" + e.getMessage(), new Object[0]);  // 根据这个字符串可以知道功能是取消闹钟
            return;
        }
    }

lambda2

跟lambda1一样, 不属于RunningServiceImpl, 但是跟该类高度相关

package com.tanma.unirun.service;

import android.content.SharedPreferences.Editor;
import io.reactivex.functions.Consumer;

public final class lambda2 implements Consumer {
    private final RunningServiceImpl f$0;
    private final SharedPreferences.Editor f$1;

    public lambda2(RunningServiceImpl runningServiceImpl0, SharedPreferences.Editor editor) {
        this.f$0 = runningServiceImpl0;
        this.f$1 = editor;
    }

    public final void accept(Object object0) {
        this.f$0.lambda2$run(this.f$1, ((Long)object0));
    }
}

lambda2$run()

用于提示声纹验证的方法.......

    public void lambda2$run(SharedPreferences.Editor editor, Long count) throws Exception {
        if(RunningServiceImpl.runningTime % 3 == 0) {  // 计时, 每三秒执行一次
            this.trackManager.start();
        }

        if(this.trackManager != null) {
            Date date = new Date(System.currentTimeMillis());
            this.trackManager.writeRunInfo(this.mSimpleFormat.format(date));  // 写入了一行date字符串
        }

        editor.putBoolean("sp_start_run_status", true);  // 表示在跑步
        editor.apply();  // 提交修改
        RunningServiceImpl.runningTime = (int)((System.currentTimeMillis() - RunningServiceImpl.mStartTimeMillis) / 1000L);  // 跑步时间(秒)
        RunningServiceImpl.isRunning = true;
        int runningTime = RunningServiceImpl.runningTime;
        int RemindTime = RunningServiceImpl.mRemindTime;
        if(runningTime == RemindTime) {
            String openStatus = (String)new PreUtil("sp_name_user").getObj("sp_user_open_status", String.class);  // 从数据库中获取"sp_user_open_status"对应的value
            Log.i("showVerify", " showVerify openStatus=${openStatus}");
            if(!TextUtils.isEmpty(openStatus) && (openStatus.equals("1"))) {
                Uri uri0 = RingtoneManager.getDefaultUri(1);
                try {
                    if(RunningServiceImpl.mVibrator == null) {
                        RunningServiceImpl.mVibrator = (Vibrator)this.getSystemService("vibrator");
                    }

                    if(RunningServiceImpl.mVibrator != null && (RunningServiceImpl.mVibrator.hasVibrator())) {
                        RunningServiceImpl.mVibrator.vibrate(new long[]{1000L, 1000L}, 0);
                        RunningServiceImpl.isVibrator = Boolean.valueOf(true);
                    }

                    if(RunningServiceImpl.mMediaPlayer == null) {
                        RunningServiceImpl.mMediaPlayer = new MediaPlayer();
                    }

                    RunningServiceImpl.mMediaPlayer.setDataSource(this, uri0);
                    RunningServiceImpl.mMediaPlayer.setAudioStreamType(2);
                    RunningServiceImpl.mMediaPlayer.setLooping(true);
                    RunningServiceImpl.mMediaPlayer.prepare();
                    RunningServiceImpl.mMediaPlayer.start();
                    goto label_118;
                }
                catch(IOException ex) {
                }
                catch(Exception ex) {
                    goto label_100;
                }
                catch(Throwable throwable0) {
                    this.startService(new Intent(this, NotificationService.class));
                    throw throwable0;
                }

                try {
                    ex.printStackTrace();
                }
                catch(Throwable throwable0) {
                    this.startService(new Intent(this, NotificationService.class));
                    throw throwable0;
                }

                this.startService(new Intent(this, NotificationService.class));
                goto label_128;
                try {
                label_100:
                    ex.printStackTrace();
                }
                catch(Throwable throwable0) {
                    this.startService(new Intent(this, NotificationService.class));
                    throw throwable0;
                }

                this.startService(new Intent(this, NotificationService.class));
                goto label_128;
                this.startService(new Intent(this, NotificationService.class));
                throw throwable0;
            label_118:
                this.startService(new Intent(this, NotificationService.class));
            }
        }
        else if(runningTime >= RemindTime + 120) {
            RunningServiceImpl.closeRemind();
            this.stopService(new Intent(this, NotificationService.class));
        }

    label_128:
        String s1 = UnirunApplication.Companion.instance().getSharedPreferences("rundata", 0).getString("sp_run_aggin_status", "0");
        if(!TextUtils.isEmpty(s1) && (s1.equals("1"))) {
            if(RunningServiceImpl.runningTime > RunningServiceImpl.mRemindTime && RunningServiceImpl.runningTime < RunningServiceImpl.mRemindTime + 120) {
                EventBus.getDefault().post(new RunningEvent(14, RunningServiceImpl.runningTime, null));
                return;
            }

            EventBus.getDefault().post(new RunningEvent(this.timerEvent(), RunningServiceImpl.runningTime, null));
            return;
        }

        EventBus.getDefault().post(new RunningEvent(this.timerEvent(), RunningServiceImpl.runningTime, null));
    }

startRunRecord()

看起来是记录跑步数据的方法

  • 初始化数据域,

    • ​isRunning = true​表示开始跑步
    • ​hasShowDiaLog = false​还不知道是啥, 应该是什么提示的弹窗
    • ​showDialogNumber = 0​, 跟上面的有关

  • 查询器构建

    • ​QueryBuilder queryBuilder0 = UnirunApplication.Companion.instance().getDataBase().getTrackDao().queryBuilder();​是GreenDao数据的API, 跟那个有关, 先不管是啥

  • 设置事件监听

    • ​EventBus.getDefault().post(new RunningEvent(this.timerEvent(), RunningServiceImpl.runningTime, null));​
    • EventBus也是GreenDao的API, 应该使用于事件监听之类的
    • 主要分析RunningEvent, 设置了各种跑步时的事件: 超出校区, 声纹验证, 开始结束

  • 获取跑步定位事件(重点关注!), 是一个对象

    • ​RunningLocationEvent runningLocationEvent = new RunningLocationEvent();​
    • 调用setTrack()方法, 设置了足迹, 这个track是一个List!!
    • 调用setDistance()方法, 设置了跑步距离
    private void startRunRecord() {
        RunningServiceImpl.isRunning = true;
        RunningServiceImpl.hasShowDialog = false;
        RunningServiceImpl.showDialogNumber = 0;
        QueryBuilder queryBuilder0 = UnirunApplication.Companion.instance().getDataBase().getTrackDao().queryBuilder();  // TrackDao就是一个数据库, 里面存的是踪迹(Track?)
        EventBus.getDefault().post(new RunningEvent(this.timerEvent(), RunningServiceImpl.runningTime, null));
        RunningLocationEvent runningLocationEvent = new RunningLocationEvent();
        runningLocationEvent.setTrack(RunningServiceImpl.mTrackLatLngList);
        runningLocationEvent.setDistance(Integer.valueOf(RunningServiceImpl.mDistance));
        if(queryBuilder0.where(Properties.Effective.eq(Integer.valueOf(1)), new WhereCondition[0]).count() > 0L) {
            RunningServiceImpl.mTrackLatLngList.clear();
            RunningServiceImpl.mDistance = new TrackUtils(this).getDistance();
            List list0 = DaoManager.Companion.getInstance().getDaoSession().getTrackDao().queryBuilder().list();
            if(list0.size() <= 0) {
                RunningServiceImpl.mTrackLatLngList.addAll(new TrackUtils(this).getAMapLatLng());
            }
            else if((System.currentTimeMillis() / 1000L - ((Track)list0.get(list0.size() - 1)).getTime() / 1000L) / 60L > 99L) {
                EventBus.getDefault().post(new RunningEvent(10, 0, null));
            }
            else {
                RunningServiceImpl.mTrackLatLngList.addAll(new TrackUtils(this).getAMapLatLng());
            }

            this.isFirstLocation = false;
            return;
        }

        this.isFirstLocation = true;
    }

onEvent()

来自: 对RunningEvent​类的交叉引用得到的, 看到了对event数据域的switch, 猜测很可能跟最终的结果有关

重点关注: 6(跑步完成)

    @Subscribe(threadMode = ThreadMode.MAIN)
    public final void onEvent(RunningEvent runningEvent) {
        Intrinsics.checkParameterIsNotNull(runningEvent, "runningEvent");
        TextView textView0 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_time);
        Intrinsics.checkExpressionValueIsNotNull(textView0, "context.tv_time");
        int v = runningEvent.getRunTtime();
        TextView textView1 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_time);
        Intrinsics.checkExpressionValueIsNotNull(textView1, "context.tv_time");
        textView0.setText(((CharSequence)this.showTimeCountMin(v, textView1)));
        TextView textView2 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_run_time_info);
        Intrinsics.checkExpressionValueIsNotNull(textView2, "context.tv_run_time_info");
        int v1 = runningEvent.getRunTtime();
        TextView textView3 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_run_time_info);
        Intrinsics.checkExpressionValueIsNotNull(textView3, "context.tv_run_time_info");
        textView2.setText(((CharSequence)this.showTimeCountMin(v1, textView3)));
        int event = runningEvent.getEvent();
        int v3 = 10;
        int v4 = 0;
        if(event == 14) {
            Object object2 = new PreUtil("rundata").getValue("sp_run_aggin_vocalverify_status", Reflection.getOrCreateKotlinClass(Integer.TYPE), Integer.valueOf(0));
            if(object2 == null) {
                Intrinsics.throwNpe();
            }

            if(((Number)object2).intValue() == 1) {
                TextView textView8 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_verify);
                Intrinsics.checkExpressionValueIsNotNull(textView8, "context.tv_verify");
                textView8.setVisibility(8);
                return;
            }

            if(BuildConfig.DEBUG) {
                RunStandard runStandard2 = this.mRunStandard;
                if(runStandard2 != null) {
                    v3 = runStandard2.getVocalVerifyTime();
                }
            }
            else {
                RunStandard runStandard3 = this.mRunStandard;
                if(runStandard3 != null) {
                    v3 = runStandard3.getVocalVerifyTime();
                }
            }

            int x = (v3 + 2) * 60 - runningEvent.getRunTtime();
            String s2 = this.runningVerify;
            if(s2 == null) {
                Intrinsics.throwUninitializedPropertyAccessException("runningVerify");
            }

            Object[] arr_object1 = {x};
            String s3 = String.format(s2, Arrays.copyOf(arr_object1, arr_object1.length));
            Intrinsics.checkExpressionValueIsNotNull(s3, "java.lang.String.format(format, *args)");
            SpannableStringBuilder spannableStringBuilder1 = new SpannableStringBuilder(((CharSequence)s3));
            spannableStringBuilder1.setSpan(new AbsoluteSizeSpan(ScreenUtil.INSTANCE.sp2px(12.0f)), s3.length() - (String.valueOf(x).length() + 1), s3.length(), 34);
            TextView textView9 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_verify);
            Intrinsics.checkExpressionValueIsNotNull(textView9, "context.tv_verify");
            textView9.setText(((CharSequence)spannableStringBuilder1));
            TextView textView10 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_verify);
            Intrinsics.checkExpressionValueIsNotNull(textView10, "context.tv_verify");
            textView10.setVisibility(0);
        }
        else {
            switch(event) {
                case 3: {
                    this.showVerify();
                    return;
                }
                case 4: {
                    if(this.mVerify == 1) {
                        TextView textView4 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_verify);
                        Intrinsics.checkExpressionValueIsNotNull(textView4, "context.tv_verify");
                        textView4.setVisibility(8);
                        return;
                    }

                    if(BuildConfig.DEBUG) {
                        RunStandard runStandard0 = this.mRunStandard;
                        if(runStandard0 != null) {
                            v3 = runStandard0.getVocalVerifyTime();
                        }
                    }
                    else {
                        RunStandard runStandard1 = this.mRunStandard;
                        if(runStandard1 != null) {
                            v3 = runStandard1.getVocalVerifyTime();
                        }
                    }

                    int verifyTime = v3;
                    if(this.mVerify == 2 || this.mVerify == 0) {
                        int x = (verifyTime + 2) * 60 - runningEvent.getRunTtime();
                        String s = this.runningVerify;
                        if(s == null) {
                            Intrinsics.throwUninitializedPropertyAccessException("runningVerify");
                        }

                        Object[] arr_object = {x};
                        String s1 = String.format(s, Arrays.copyOf(arr_object, arr_object.length));
                        Intrinsics.checkExpressionValueIsNotNull(s1, "java.lang.String.format(format, *args)");
                        SpannableStringBuilder builder = new SpannableStringBuilder(((CharSequence)s1));
                        builder.setSpan(new AbsoluteSizeSpan(ScreenUtil.INSTANCE.sp2px(12.0f)), s1.length() - (String.valueOf(x).length() + 1), s1.length(), 34);
                        TextView textView5 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_verify);
                        Intrinsics.checkExpressionValueIsNotNull(textView5, "context.tv_verify");
                        textView5.setText(((CharSequence)builder));
                        TextView textView6 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_verify);
                        Intrinsics.checkExpressionValueIsNotNull(textView6, "context.tv_verify");
                        textView6.setVisibility(0);
                        return;
                    }

                    return;
                }
                case 5: {
                    TextView textView7 = (TextView)((FragmentActivity)this.getContext()).findViewById(id.tv_verify);
                    Intrinsics.checkExpressionValueIsNotNull(textView7, "context.tv_verify");
                    textView7.setVisibility(8);
                    AlertDialog alertDialog0 = this.mAlertDialog;
                    if(alertDialog0 != null) {
                        alertDialog0.dismiss();
                        return;
                    }

                    return;
                }
                case 6: {
                    if((runningEvent.getExtra() instanceof RunResult)) {
                        Object object0 = runningEvent.getExtra();
                        if(object0 != null) {
                            Intent intent = new Intent();
                            Integer integer0 = ((RunResult)object0).getRecordId();
                            intent.putExtra("recordid", ((Serializable)(integer0 == null ? null : ((long)(((int)integer0))))));
                            intent.putExtra("state", "");
                            intent.setClass(((Context)this.getContext()), RunResultActivity.class);
                            this.getContext().startActivity(intent);
                            return;
                        }

                        throw new TypeCastException("null cannot be cast to non-null type com.tanma.unirun.entities.RunResult");
                    }

                    return;
                }
                case 7: {
                    this.arraySchoolArea = (SchoolBound[])runningEvent.getExtra();
                    if(this.arraySchoolArea == null || this.arraySchoolArea.length == 0) {
                        v4 = 1;
                    }

                    if(v4 == 0) {
                        this.schoolAreaDataTemp(this.arraySchoolArea);
                        return;
                    }

                    return;
                }
                case 10: {
                    this.stopRun();
                    this.getModelImpl().commitRunRecord(this.countTotalKM(this.totalStepNumber));
                    CircleProgress circleProgress0 = (CircleProgress)((FragmentActivity)this.getContext()).findViewById(id.progress_circular_info);
                    Intrinsics.checkExpressionValueIsNotNull(circleProgress0, "context.progress_circular_info");
                    circleProgress0.setValue(0.0f);
                    CircleProgress circleProgress1 = (CircleProgress)((FragmentActivity)this.getContext()).findViewById(id.progress_circular);
                    Intrinsics.checkExpressionValueIsNotNull(circleProgress1, "context.progress_circular");
                    circleProgress1.setValue(0.0f);
                    Object object1 = this.getContext().getSystemService("notification");
                    if(object1 != null) {
                        ((NotificationManager)object1).cancel(20001);
                        return;
                    }

                    throw new TypeCastException("null cannot be cast to non-null type android.app.NotificationManager");
                }
                case 11: {
                    AlertDialog alertDialog1 = this.mOutAlertDialog;
                    if(alertDialog1 != null) {
                        alertDialog1.dismiss();
                        return;
                    }

                    return;
                }
                default: {
                    return;
                }
            }
        }
    }