导航菜单
登录 注册

页面标题

页面副标题

Petal Maps v4.7.0.310001 - OfflineDataService.java 源代码

正在查看： Petal Maps v4.7.0.310001 应用的 OfflineDataService.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。 


package com.huawei.maps.offline.service;

import android.app.Notification;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Binder;
import android.os.Build;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import com.huawei.hms.framework.common.NetworkUtil;
import com.huawei.hms.network.file.api.exception.NetworkException;
import com.huawei.maps.app.routeplan.util.WorkerResult;
import com.huawei.maps.businessbase.offline.IOfflineMapDataService;
import com.huawei.maps.businessbase.offline.IOfflineVoiceDataService;
import com.huawei.maps.businessbase.offline.OfflineDataObserver;
import com.huawei.maps.businessbase.offline.bean.OfflineMapsInfo;
import com.huawei.maps.businessbase.offline.bean.OfflineMapsVoiceInfo;
import com.huawei.maps.businessbase.offline.callback.OfflineDataVoiceObserver;
import com.huawei.maps.offline.R$string;
import com.huawei.maps.offline.callback.INetworkCallback;
import com.huawei.maps.offline.service.OfflineDataService;
import com.huawei.secure.android.common.activity.SafeService;
import com.huawei.secure.android.common.intent.SafeBroadcastReceiver;
import defpackage.am6;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;

public class OfflineDataService extends SafeService {
    public NetTypeReceiver b;
    public IOfflineMapDataService c;
    public IOfflineVoiceDataService d;
    public INetworkCallback f;
    public am6 g;
    public boolean h;
    public final d e = new d();
    public final c i = new c(this);
    public OfflineDataObserver j = new a();
    public final OfflineDataVoiceObserver k = new b();

    public class NetTypeReceiver extends SafeBroadcastReceiver {
        public NetTypeReceiver() {
        }

        public void onReceiveMsg(Context context, Intent intent) {
            int networkType = NetworkUtil.getNetworkType(context);
            if (OfflineDataService.this.f != null) {
                OfflineDataService.this.f.onStateChange(networkType);
            }
            hm4.p("OfflineDataService", "onReceiveMsg: " + networkType);
            boolean isVoiceDownloading = OfflineDataService.this.d.isVoiceDownloading();
            boolean isDownloading = OfflineDataService.this.c.isDownloading();
            if (networkType != -1) {
                if (networkType == 1) {
                    if (tg6.b().c().isWifiAutoUpdateOpen()) {
                        OfflineDataService.this.K(false);
                    }
                    OfflineDataService.this.L();
                    return;
                } else if (networkType != 4) {
                    return;
                }
            }
            if (isDownloading) {
                OfflineDataService.this.P();
            }
            if (isVoiceDownloading) {
                OfflineDataService.this.C();
            }
            OfflineDataService.this.i.removeCallbacksAndMessages(null);
            OfflineDataService.this.i.sendEmptyMessageDelayed(networkType, 2500L);
        }
    }

    public class a implements OfflineDataObserver {
        public a() {
        }

        public final List<OfflineMapsInfo> a() {
            ArrayList arrayList = new ArrayList();
            for (OfflineMapsInfo offlineMapsInfo : OfflineDataService.this.c.getDownLoadingList()) {
                if (offlineMapsInfo.getStatus() == 2 || offlineMapsInfo.getStatus() == 1) {
                    arrayList.add(offlineMapsInfo);
                } else {
                    hm4.p("OfflineDataService", "downloading list can not add to notify sum ,name : " + OfflineDataService.this.s(offlineMapsInfo) + " , status: " + offlineMapsInfo.getStatus());
                }
            }
            return arrayList;
        }

        public final void b(String str) {
            hm4.f("OfflineDataService", "startMapNotifyCation , type  :" + str);
            if (o72.f(str, 1000L)) {
                hm4.f("OfflineDataService", "startMapNotifyCation failed, isDoubleClick  return");
                return;
            }
            if (!OfflineDataService.this.g.l()) {
                hm4.p("OfflineDataService", "startMapNotifyCation failed, isNotifyCationEnabled  false.");
                return;
            }
            List<OfflineMapsInfo> a = a();
            if (a.isEmpty()) {
                return;
            }
            OfflineMapsInfo offlineMapsInfo = a.get(0);
            Notification j = OfflineDataService.this.g.j(1002, OfflineDataService.this.s(offlineMapsInfo), offlineMapsInfo.getDownloadProgress(), a.size());
            if (!OfflineDataService.this.h) {
                OfflineDataService.this.y(1002, j);
            }
            OfflineDataService.this.g.m(1002, j);
        }

        public final void c() {
            hm4.p("OfflineDataService", "stopMapNotifyCation...");
            List<OfflineMapsInfo> downLoadingList = OfflineDataService.this.c.getDownLoadingList();
            if (downLoadingList.isEmpty()) {
                hm4.p("OfflineDataService", "downloading is empty ,need cancel notifyCation");
            } else {
                for (OfflineMapsInfo offlineMapsInfo : downLoadingList) {
                    if (offlineMapsInfo.getStatus() == 2 || offlineMapsInfo.getStatus() == 1) {
                        hm4.p("OfflineDataService", "downloadingList is not empty , but exist watting or progress task ,can not cancel notifyCation");
                        return;
                    }
                }
            }
            OfflineDataService.this.p(1002);
        }

        public void onException(OfflineMapsInfo offlineMapsInfo, NetworkException networkException) {
            c();
        }

        public void onFinish(OfflineMapsInfo offlineMapsInfo) {
            hm4.p("OfflineDataService", "onFinish: ");
            c();
        }

        public void onProgress(OfflineMapsInfo offlineMapsInfo) {
            b("onProgress");
        }

        public void onStart(OfflineMapsInfo offlineMapsInfo) {
            hm4.p("OfflineDataService", "onStart: ");
            b("onProgress");
        }

        public void onSuccess(OfflineMapsInfo offlineMapsInfo) {
            hm4.p("OfflineDataService", "onSuccess: ");
            b("onSuccess");
        }
    }

    public class b implements OfflineDataVoiceObserver {
        public b() {
        }

        public final void a(String str) {
            if (!o72.f(str, 1000L) && OfflineDataService.this.g.l()) {
                List u = OfflineDataService.this.u();
                if (u.isEmpty()) {
                    return;
                }
                OfflineMapsVoiceInfo t = OfflineDataService.this.t(u);
                String languageCode = t.getLanguageCode();
                String offlineVoiceGender = t.getOfflineVoiceGender();
                if (TextUtils.isEmpty(languageCode) || TextUtils.isEmpty(offlineVoiceGender)) {
                    hm4.h("OfflineDataService", "languageCode or voiceGender is null when show notification.");
                    return;
                }
                String w = nf4.w(languageCode, offlineVoiceGender);
                if (TextUtils.isEmpty(w)) {
                    hm4.h("OfflineDataService", "voiceName get failed when show notification.");
                    return;
                }
                Notification j = OfflineDataService.this.g.j(1003, w, t.getDownloadProgress(), u.size());
                if (!OfflineDataService.this.h) {
                    OfflineDataService.this.y(1003, j);
                }
                OfflineDataService.this.g.m(1003, j);
            }
        }

        public final void b() {
            hm4.p("OfflineDataService", "stopVoiceMapNotifyCation...");
            List<OfflineMapsVoiceInfo> u = OfflineDataService.this.u();
            if (u.isEmpty()) {
                hm4.p("OfflineDataService", "voice downloading is empty ,need cancel notifyCation");
            } else {
                for (OfflineMapsVoiceInfo offlineMapsVoiceInfo : u) {
                    if (offlineMapsVoiceInfo.getStatus() == 2 || offlineMapsVoiceInfo.getStatus() == 1) {
                        hm4.p("OfflineDataService", "voice downloadingList is not empty , but exist watting or progress task ,can not cancel notifyCation");
                        return;
                    }
                }
            }
            OfflineDataService.this.p(1003);
        }

        public void onException(OfflineMapsVoiceInfo offlineMapsVoiceInfo, NetworkException networkException) {
            b();
        }

        public void onFinish(OfflineMapsVoiceInfo offlineMapsVoiceInfo) {
            b();
        }

        public void onProgress(OfflineMapsVoiceInfo offlineMapsVoiceInfo) {
            a("onProgress");
        }

        public void onStart(OfflineMapsVoiceInfo offlineMapsVoiceInfo) {
            a("onProgress");
        }

        public void onSuccess(OfflineMapsVoiceInfo offlineMapsVoiceInfo) {
            a("onSuccess");
        }
    }

    public static class c extends Handler {
        public final WeakReference<OfflineDataService> a;

        public c(OfflineDataService offlineDataService) {
            this.a = new WeakReference<>(offlineDataService);
        }

        @Override
        public void handleMessage(@NonNull Message message) {
            OfflineDataService offlineDataService = this.a.get();
            if (offlineDataService == null) {
                return;
            }
            boolean isVoiceDownloading = offlineDataService.d.isVoiceDownloading();
            boolean isDownloading = offlineDataService.c.isDownloading();
            int i = message.what;
            if (i == -1) {
                if (c06.b()) {
                    return;
                }
                if (isDownloading || isVoiceDownloading) {
                    cz9.k(o41.f(R$string.no_network));
                    return;
                }
                return;
            }
            if (i == 4 && !c06.b()) {
                if (isDownloading || isVoiceDownloading) {
                    cz9.k(o41.f(R$string.offline_no_wifi));
                }
            }
        }
    }

    public class d extends Binder {
        public d() {
        }

        public OfflineDataService a() {
            return OfflineDataService.this;
        }
    }

    public void A(List<OfflineMapsInfo> list) {
        this.c.pauseAllDownloadTask(list);
    }

    public void B(boolean z) {
        this.c.pauseAllDownloadTask(z);
    }

    public void C() {
        this.d.pauseAllVoiceDownloadTask();
    }

    public void D(boolean z) {
        this.d.pauseAllDownloadedTask(z);
    }

    public void E(OfflineMapsInfo offlineMapsInfo) {
        hm4.f("OfflineDataService", "pauseData: ");
        this.c.pauseData(offlineMapsInfo);
    }

    public void F(OfflineMapsVoiceInfo offlineMapsVoiceInfo) {
        this.d.pauseOfflineVoiceData(offlineMapsVoiceInfo);
    }

    public final void G() {
        if (this.b != null) {
            hm4.p("OfflineDataService", "netTypeReceiver is not null");
            return;
        }
        hm4.p("OfflineDataService", "netTypeReceiver is null and register");
        IntentFilter intentFilter = new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE");
        ?? netTypeReceiver = new NetTypeReceiver();
        this.b = netTypeReceiver;
        registerReceiver(netTypeReceiver, intentFilter, 2);
    }

    public void H(OfflineDataObserver offlineDataObserver) {
        this.c.removeOfflineDataObserver(offlineDataObserver);
    }

    public void I(OfflineDataVoiceObserver offlineDataVoiceObserver) {
        this.d.removeVoiceObservers(offlineDataVoiceObserver);
    }

    public void J(List<OfflineMapsInfo> list) {
        this.c.resumeAllDownloadTask(list);
    }

    public void K(boolean z) {
        this.c.resumeAllDownloadTask(z);
    }

    public void L() {
        this.d.resumeAllVoiceDownloadTask();
    }

    public void M(boolean z) {
        this.d.resumeAllDownloadedTask(z);
    }

    public void N(OfflineMapsVoiceInfo offlineMapsVoiceInfo) {
        this.d.resumeOfflineVoiceData(offlineMapsVoiceInfo);
    }

    public void O(OfflineMapsInfo offlineMapsInfo) {
        this.c.resumeOrdownloadData(offlineMapsInfo);
    }

    public void P() {
        this.c.servicePauseAllUpdateTask();
    }

    public void Q(OfflineMapsInfo offlineMapsInfo) {
        this.c.handleSuccessFile(offlineMapsInfo);
    }

    public void j(INetworkCallback iNetworkCallback) {
        this.f = iNetworkCallback;
    }

    public void k(OfflineDataObserver offlineDataObserver) {
        this.c.addOfflineDataObserver(offlineDataObserver);
    }

    public void l(OfflineDataVoiceObserver offlineDataVoiceObserver) {
        this.d.addVoiceObservers(offlineDataVoiceObserver);
    }

    public void m() {
        this.c.cancelAllDownloadingTask();
    }

    public void n(OfflineMapsVoiceInfo offlineMapsVoiceInfo) {
        this.d.cancelVoiceDataDownload(offlineMapsVoiceInfo);
    }

    public void o(OfflineMapsInfo offlineMapsInfo) {
        hm4.f("OfflineDataService", "cancelData: ");
        this.c.cancleData(offlineMapsInfo);
    }

    @Nullable
    public IBinder onBind(Intent intent) {
        hm4.f("OfflineDataService", "onBind: ");
        return this.e;
    }

    public void onCreate() {
        super.onCreate();
        hm4.f("OfflineDataService", "onCreate: ");
        G();
        this.c = tg6.b().c();
        this.d = tg6.b().f();
        this.g = am6.f();
    }

    public void onDestroy() {
        super.onDestroy();
        hm4.p("OfflineDataService", "offline data service onDestroy");
        this.c.removeOfflineDataObserver(this.j);
        this.d.removeVoiceObservers(this.k);
        SafeBroadcastReceiver safeBroadcastReceiver = this.b;
        if (safeBroadcastReceiver != null) {
            unregisterReceiver(safeBroadcastReceiver);
            this.b = null;
        }
    }

    public int onStartCommand(Intent intent, int i, int i2) {
        this.c.addOfflineDataObserver(this.j);
        this.d.addVoiceObservers(this.k);
        return 2;
    }

    public final void p(int i) {
        this.g.a(i);
        hm4.p("OfflineDataService", "isforeground: id: " + i);
        if (this.h) {
            stopForeground(true);
            hm4.p("OfflineDataService", "stopForeground");
            this.h = false;
        }
    }

    public void q(OfflineMapsVoiceInfo offlineMapsVoiceInfo) {
        this.d.downloadOfflineVoiceData(offlineMapsVoiceInfo);
    }

    public List<OfflineMapsInfo> r() {
        return this.c.getDownLoadingList();
    }

    public final String s(OfflineMapsInfo offlineMapsInfo) {
        if (qc6.b(offlineMapsInfo)) {
            return "";
        }
        String countryId = offlineMapsInfo.getCountryId();
        if (TextUtils.isEmpty(countryId) || !countryId.equals("global")) {
            return !TextUtils.isEmpty(offlineMapsInfo.getCityName()) ? offlineMapsInfo.getCityName() : !TextUtils.isEmpty(offlineMapsInfo.getRegionName()) ? offlineMapsInfo.getRegionName() : !TextUtils.isEmpty(offlineMapsInfo.getCountryName()) ? offlineMapsInfo.getCountryName() : "";
        }
        return new Locale("bo").getLanguage().equals(Locale.getDefault().getLanguage()) ? o41.f(R$string.offline_borcn_world_basic_data) : o41.f(R$string.offline_world_basic_data);
    }

    @NonNull
    public final OfflineMapsVoiceInfo t(List<OfflineMapsVoiceInfo> list) {
        for (OfflineMapsVoiceInfo offlineMapsVoiceInfo : list) {
            if (offlineMapsVoiceInfo.getStatus() == 2) {
                return offlineMapsVoiceInfo;
            }
        }
        return list.get(0);
    }

    public final List<OfflineMapsVoiceInfo> u() {
        ArrayList arrayList = new ArrayList();
        for (OfflineMapsVoiceInfo offlineMapsVoiceInfo : this.d.getVoiceDownLoadingList()) {
            if (offlineMapsVoiceInfo.getStatus() == 2 || offlineMapsVoiceInfo.getStatus() == 1) {
                arrayList.add(offlineMapsVoiceInfo);
            }
        }
        for (OfflineMapsVoiceInfo offlineMapsVoiceInfo2 : this.d.getVoiceUpdatingList()) {
            if (offlineMapsVoiceInfo2.getStatus() == 2 || offlineMapsVoiceInfo2.getStatus() == 1) {
                arrayList.add(offlineMapsVoiceInfo2);
            }
        }
        return arrayList;
    }

    public List<OfflineMapsVoiceInfo> v() {
        return this.d.getVoiceDownLoadingList();
    }

    public List<OfflineMapsVoiceInfo> w() {
        return this.d.getVoiceUpdatingList();
    }

    public final void x(int i, Notification notification) {
        startForeground(i, notification, -1);
    }

    public void y(final int i, final Notification notification) {
        try {
            this.h = true;
            hm4.p("OfflineDataService", "mStartForeground: " + i);
            int i2 = Build.VERSION.SDK_INT;
            if (i2 >= 31) {
                rya.a.b(new WorkerResult() {
                    public final void doWork() {
                        OfflineDataService.this.x(i, notification);
                    }
                });
            } else if (i2 >= 29) {
                startForeground(i, notification, -1);
            } else {
                startForeground(i, notification);
            }
        } catch (Exception e) {
            o05.c(e, true);
            hm4.p("OfflineDataService", "offline onServiceConnected fail");
        }
    }

    public void z(OfflineMapsInfo offlineMapsInfo) {
        this.c.moveFile(offlineMapsInfo);
    }
}