package com.brytonsport.active.service;

import android.app.ActivityManager;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.res.Resources;
import android.database.Cursor;
import android.graphics.BitmapFactory;
import android.location.Criteria;
import android.location.Location;
import android.location.LocationManager;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.provider.ContactsContract;
import android.util.ArrayMap;
import android.util.Base64;
import android.util.Log;
import androidx.constraintlayout.core.motion.utils.TypedValues;
import androidx.core.app.NotificationCompat;
import androidx.core.content.ContextCompat;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import com.android.volley.AuthFailureError;
import com.android.volley.DefaultRetryPolicy;
import com.android.volley.NetworkResponse;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.ServerError;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.HttpHeaderParser;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;
import com.brytonsport.active.BuildConfig;
import com.brytonsport.active.R;
import com.brytonsport.active.base.App;
import com.brytonsport.active.base.EasyBaseFragmentActivity;
import com.brytonsport.active.bleplugin.ConstSettingChannel;
import com.brytonsport.active.bleplugin.DataUtil;
import com.brytonsport.active.bleplugin.DeviceInfo;
import com.brytonsport.active.bleplugin.DeviceSupportFeature;
import com.brytonsport.active.bleplugin.FileSummary;
import com.brytonsport.active.bleplugin.ParserUtil;
import com.brytonsport.active.bleplugin.SampleGattAttributes;
import com.brytonsport.active.db.course.entity.FileIdHistoryEntity;
import com.brytonsport.active.db.notification.entity.NotificationEntity;
import com.brytonsport.active.db.setting.entity.DeviceManagerEntity;
import com.brytonsport.active.fit.BrytonActivity;
import com.brytonsport.active.fit.BrytonPlanTrip;
import com.brytonsport.active.fwupdate.FirmwareUtil;
import com.brytonsport.active.fwupdate.FwPackageInfo;
import com.brytonsport.active.fwupdate.UpdateFW;
import com.brytonsport.active.repo.BleRepoImpl;
import com.brytonsport.active.repo.course.FileIdHistoryRepository;
import com.brytonsport.active.repo.course.GroupRideRepository;
import com.brytonsport.active.repo.course.PlanTripRepository;
import com.brytonsport.active.repo.notification.NotificationRepository;
import com.brytonsport.active.repo.profile.Connect3rdPartyRepository;
import com.brytonsport.active.repo.result.ActivityRepository;
import com.brytonsport.active.repo.setting.DeviceRepository;
import com.brytonsport.active.service.BleService;
import com.brytonsport.active.service.VolleyMultipartRequest;
import com.brytonsport.active.ui.account.SplashActivity;
import com.brytonsport.active.ui.photo.PhotoActivity;
import com.brytonsport.active.ui.result.ResultShareActivity;
import com.brytonsport.active.utils.ActivityFileUtil;
import com.brytonsport.active.utils.ApiUtil;
import com.brytonsport.active.utils.BleUtil;
import com.brytonsport.active.utils.BrytonErrorCodeUtil;
import com.brytonsport.active.utils.ClimbApiActionListener;
import com.brytonsport.active.utils.ClimbProUtil;
import com.brytonsport.active.utils.ClimbResponseData;
import com.brytonsport.active.utils.ConnectTaskObject;
import com.brytonsport.active.utils.Constants;
import com.brytonsport.active.utils.DeviceBusyStatusUtil;
import com.brytonsport.active.utils.DeviceImageUtil;
import com.brytonsport.active.utils.DistanceUtil;
import com.brytonsport.active.utils.FeatureUtil;
import com.brytonsport.active.utils.FileIdHistoryUtil;
import com.brytonsport.active.utils.FileUtil;
import com.brytonsport.active.utils.FirebaseCustomUtil;
import com.brytonsport.active.utils.GZipUtils;
import com.brytonsport.active.utils.JsonUtil;
import com.brytonsport.active.utils.LiveTrackUtil;
import com.brytonsport.active.utils.NetworkUtil;
import com.brytonsport.active.utils.NotificationConstantsUtil;
import com.brytonsport.active.utils.Profile3rdPartySyncConst;
import com.brytonsport.active.utils.ProfileUtil;
import com.brytonsport.active.utils.ServerEeUtil;
import com.brytonsport.active.utils.SettingLanguageUtil;
import com.brytonsport.active.utils.SignTableUtil;
import com.brytonsport.active.utils.TimeUtilByLee;
import com.brytonsport.active.utils.WavUtil;
import com.brytonsport.active.utils.i18N;
import com.brytonsport.active.vm.base.ClimbGrade;
import com.brytonsport.active.vm.base.DevLatLng;
import com.brytonsport.active.vm.base.Device;
import com.brytonsport.active.vm.base.GroupRideInfoResponseData;
import com.brytonsport.active.vm.base.GroupRideMemberResponseData;
import com.brytonsport.active.vm.base.GroupTrack;
import com.brytonsport.active.vm.base.GroupTrackMemberInfo;
import com.brytonsport.active.vm.base.Message;
import com.brytonsport.active.vm.base.QuickReply;
import com.brytonsport.active.vm.base.RouteClimb;
import com.brytonsport.active.vm.base.analysis.Altitude;
import com.github.mjdev.libaums.fs.UsbFile;
import com.gogolook.developmode.BasicDevelopMode;
import com.google.firebase.analytics.FirebaseAnalytics;
import com.graphhopper.routing.util.FlagEncoderFactory;
import com.graphhopper.util.Parameters;
import com.mapbox.api.directions.v5.DirectionsCriteria;
import com.mapbox.api.directions.v5.models.BannerComponents;
import com.quickblox.auth.Consts;
import com.quickblox.core.ConstsInternal;
import com.quickblox.core.helper.ToStringHelper;
import com.welie.blessed.BluetoothPeripheral;
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.SecureRandom;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import java.util.concurrent.ConcurrentLinkedQueue;
import javax.inject.Inject;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import org.apache.xerces.impl.xs.SchemaSymbols;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.oscim.renderer.bucket.VertexData;
import pub.devrel.easypermissions.EasyPermissions;

/* loaded from: classes.dex */
public class BleService extends Hilt_BleService {
    public static final String GR_ACTION_GROUP_TRACK_START_POST = "cmd 2 - GROUP_TRACK_START_POST";
    public static final String GR_ACTION_RECEIVE_GROUP_TRACK_MSG = "RECEIVE_GROUP_TRACK_MSG";
    public static final String GR_ACTION_REQUEST_GROUP_TRACK_MSG = "cmd 8 - REQUEST_GROUP_TRACK_MSG";
    public static final String GR_ACTION_SEND_GROUP_RIDE_ACTIVE_MESSAGE_CAN = "cmd 9 - SEND_GROUP_RIDE_ACTIVE_MESSAGE_CAN";
    public static final String GR_ACTION_SEND_GROUP_RIDE_INFO_FINISH = "cmd 10 - SEND_GROUP_RIDE_INFO_FINISH";
    public static final String GR_ACTION_SEND_GROUP_TRACK_FIT = "cmd 3 - SEND_GROUP_TRACK_FIT";
    public static final String GR_ACTION_SEND_GROUP_TRACK_PLANTRIP_NAME = "cmd 5 - SEND_GROUP_TRACK_PLANTRIP_NAME";
    public static final String GR_ACTION_SEND_INACTIVE_MEMBER_LIST = "dev 75 update cmd 2 - SEND_INACTIVE_MEMBER_LIST";
    public static final String GR_ACTION_SEND_MEMBER_LIST = "cmd 6 - SEND_MEMBER_LIST";
    public static final String GR_ACTION_SEND_MEMBER_MESSAGE_DATA = "dev 75 update cmd 4 - GR_ACTION_SEND_MEMBER_MESSAGE_DATA";
    public static final String GR_ACTION_SEND_MEMBER_UPDATE = "dev 75 update cmd 3 - GR_ACTION_SEND_MEMBER_UPDATE";
    public static final String GR_PLANTRIP_NAME = "groupride";
    static String LIVE_TRACK_OP_CLEAR = "clear";
    static String LIVE_TRACK_OP_DELETE_GROUP = "delete_group";
    static int LIVE_TRACK_STATE_PAUSE = 8;
    static int LIVE_TRACK_STATE_START = 1;
    static int LIVE_TRACK_STATE_STOP = 0;
    private static final float LOCATION_DISTANCE = 10.0f;
    private static final int LOCATION_INTERVAL = 1000;
    public static final String NOTIFY_APPLICATION_CONTENT = "com.brytonsport.active.NOTIFY_APPLICATION_CONTENT";
    public static final String NOTIFY_APPLICATION_NAME = "com.brytonsport.active.NOTIFY_APPLICATION_NAME";
    public static final String NOTIFY_APPLICATION_TITLE = "com.brytonsport.active.NOTIFY_APPLICATION_TITLE";
    public static final String NOTIFY_CALL_NAME = "com.brytonsport.active.NOTIFY_CALL_NAME";
    public static final String NOTIFY_CALL_NUMBER = "com.brytonsport.active.NOTIFY_CALL_NUMBER";
    static final int NOTIFY_ID = 11;
    public static final String POST_DATA_CONTENT_BYTE_ARRAY = "com.brytonsport.active.POST_DATA_CONTENT_BYTE_ARRAY";
    public static final String POST_DATA_CONTENT_TYPE = "com.brytonsport.active.POST_DATA_CONTENT_TYPE";
    public static final String POST_DATA_FW_PACKAGE_INFO = "com.brytonsport.active.POST_DATA_FW_PACKAGE_INFO";
    public static final String REQUEST_DATA_REQUEST_TYPE = "com.brytonsport.active.REQUEST_DATA_REQUEST_TYPE";
    public static final String SERVICE_ACTIVITY_UPLOAD_COMPLETE = "com.brytonsport.active.SERVICE_ACTIVITY_UPLOAD_COMPLETE";
    public static final String SERVICE_ACTIVITY_UPLOAD_PROGRESS = "com.brytonsport.active.SERVICE_ACTIVITY_UPLOAD_PROGRESS";
    public static final String SERVICE_ACTIVITY_UPLOAD_PROGRESS_NOW_INDEX = "com.brytonsport.active.SERVICE_ACTIVITY_UPLOAD_PROGRESS_NOW_INDEX";
    public static final String SERVICE_ACTIVITY_UPLOAD_PROGRESS_TOTAL_COUNT = "com.brytonsport.active.SERVICE_ACTIVITY_UPLOAD_PROGRESS_TOTAL_COUNT";
    public static final String SERVICE_ACTIVITY_UPLOAD_PROGRESS_VALUE = "com.brytonsport.active.SERVICE_ACTIVITY_UPLOAD_PROGRESS_VALUE";
    public static final int SERVICE_BLE_STATE_CONNECT = 1;
    public static final int SERVICE_BLE_STATE_DISCONNECT = 0;
    public static final String SERVICE_BOOLEAN_EXTRA_DATA = "com.brytonsport.active.SERVICE_BOOLEAN_EXTRA_DATA";
    public static final String SERVICE_BYTE_ARRAY_EXTRA_DATA = "com.brytonsport.active.SERVICE_BYTE_ARRAY_EXTRA_DATA";
    public static final String SERVICE_CMD_LAT_LNG_NEED_PERMISSION = "com.brytonsport.active.SERVICE_CMD_LAT_LNG_NEED_PERMISSION";
    public static final String SERVICE_DEVICE_BATTERY = "com.brytonsport.active.SERVICE_DEVICE_BATTERY";
    public static final String SERVICE_DEVICE_CONNECT_CHECK_SPT_GROUP_RIDE_STATE = "com.brytonsport.active.SERVICE_DEVICE_CONNECT_CHECK_SPT_GROUP_RIDE_STATE";
    public static final String SERVICE_DEVICE_CONNECT_OR_DISCONNECT = "com.brytonsport.active.SERVICE_DEVICE_CONNECT_OR_DISCONNECT";
    public static final String SERVICE_DEVICE_CONNECT_OR_DISCONNECT_FOR_GROUP_RIDE = "com.brytonsport.active.SERVICE_DEVICE_CONNECT_OR_DISCONNECT_FOR_GROUP_RIDE";
    public static final String SERVICE_DEVICE_HANDSHAKE_TIMEOUT = "com.brytonsport.active.SERVICE_DEVICE_HANDSHAKE_TIMEOUT";
    public static final String SERVICE_DEV_HAS_NEW_FW_UPDATE = "com.brytonsport.active.SERVICE_DEV_HAS_NEW_FW_UPDATE";
    public static final String SERVICE_DOUBLE_EXTRA_DATA = "com.brytonsport.active.SERVICE_DOUBLE_EXTRA_DATA";
    public static final String SERVICE_FILE_LIST = "com.brytonsport.active.SERVICE_FILE_LIST";
    public static final String SERVICE_FIRMWARE_UPDATE_PROGRESS = "com.brytonsport.active.SERVICE_FIRMWARE_UPDATE_PROGRESS";
    public static final String SERVICE_FIRMWARE_UPDATE_PROGRESS_NOW_INDEX = "com.brytonsport.active.SERVICE_FIRMWARE_UPDATE_PROGRESS_NOW_INDEX";
    public static final String SERVICE_FIRMWARE_UPDATE_PROGRESS_TOTAL_COUNT = "com.brytonsport.active.SERVICE_FIRMWARE_UPDATE_PROGRESS_TOTAL_COUNT";
    public static final String SERVICE_FIRMWARE_UPDATE_PROGRESS_VALUE = "com.brytonsport.active.SERVICE_FIRMWARE_UPDATE_PROGRESS_VALUE";
    public static final String SERVICE_GET_FILE = "com.brytonsport.active.SERVICE_GET_FILE";
    public static final String SERVICE_GET_FILE_LIST_OVER_5_SECS = "com.brytonsport.active.SERVICE_GET_FILE_LIST_OVER_5_SECS";
    public static final String SERVICE_GET_FILE_LIST_OVER_5_SECS_SHOW_HINT = "com.brytonsport.active.SERVICE_GET_FILE_LIST_OVER_5_SECS_SHOW_HINT";
    public static final String SERVICE_GET_FILE_RANGE = "com.brytonsport.active.SERVICE_GET_FILE_RANGE";
    public static final String SERVICE_GROUP_RIDE_DOWNLOAD_HISTORY_RESULT = "com.brytonsport.active.GROUP_RIDE_DOWNLOAD_HISTORY_RESULT";
    public static final String SERVICE_GROUP_RIDE_DOWNLOAD_INFO_ERROR = "com.brytonsport.active.GROUP_RIDE_DOWNLOAD_INFO_ERROR";
    public static final String SERVICE_GROUP_RIDE_DOWNLOAD_INFO_SUCCESS = "com.brytonsport.active.GROUP_RIDE_DOWNLOAD_INFO_SUCCESS";
    public static final String SERVICE_GROUP_RIDE_DOWNLOAD_LOCATION_ERROR = "com.brytonsport.active.GROUP_RIDE_DOWNLOAD_LOCATION_ERROR";
    public static final String SERVICE_GROUP_RIDE_DOWNLOAD_LOCATION_SUCCESS = "com.brytonsport.active.GROUP_RIDE_DOWNLOAD_LOCATION_SUCCESS";
    public static final String SERVICE_GROUP_RIDE_INTERRUPT = "com.brytonsport.active.SERVICE_GROUP_RIDE_INTERRUPT";
    public static final String SERVICE_GROUP_RIDE_IS_END = "com.brytonsport.active.GROUP_RIDE_IS_END";
    public static final String SERVICE_GROUP_RIDE_IS_NOT_END = "com.brytonsport.active.GROUP_RIDE_IS_NOT_END";
    public static final String SERVICE_GR_FIT_DECODE_ERROR = "com.brytonsport.active.SERVICE_GR_FIT_DECODE_ERROR";
    public static final String SERVICE_HANDSHAKE_RECEIVE_TIME = "com.brytonsport.active.HANDSHAKE_RECEIVE_TIME";
    public static final String SERVICE_INT_EXTRA_DATA = "com.brytonsport.active.SERVICE_INT_EXTRA_DATA";
    public static final String SERVICE_IS_DEVICE_SUPPORT_GROUP_RIDE = "com.brytonsport.active.SERVICE_IS_DEVICE_SUPPORT_GROUP_RIDE";
    public static final String SERVICE_LIVE_TRACK_MANUAL_STATE = "com.brytonsport.active.SERVICE_LIVE_TRACK_MANUAL_START_STATE";
    public static final String SERVICE_LIVE_TRACK_MANUAL_STATE_DATA = "com.brytonsport.active.SERVICE_LIVE_TRACK_MANUAL_STATE_DATA";
    public static final String SERVICE_LIVE_TRACK_SHARE_BTN_VISIBLE = "com.brytonsport.active.SERVICE_LIVE_TRACK_SHARE_BTN_VISIBLE";
    public static final String SERVICE_LIVE_TRACK_SHARE_BTN_VISIBLE_DATA = "com.brytonsport.active.SERVICE_LIVE_TRACK_SHARE_BTN_VISIBLE_DATA";
    public static final String SERVICE_NEED_SHOW_REVIEW_DIALOG = "com.brytonsport.active.SERVICE_NEED_SHOW_REVIEW_DIALOG";
    public static final String SERVICE_NOTIFICATION_POST = "com.brytonsport.active.SERVICE_NOTIFICATION_POST";
    public static final String SERVICE_ONLOCATION_CHANGE = "com.brytonsport.active.SERVICE_ONLOCATION_CHANGE";
    public static final String SERVICE_POST_DATA = "com.brytonsport.active.SERVICE_POST_DATA";
    public static final String SERVICE_POST_FILE_TYPE = "com.brytonsport.active.SERVICE_POST_FILE_TYPE";
    public static final String SERVICE_READ_DEVICE_INFO = "com.brytonsport.active.SERVICE_READ_DEVICE_INFO";
    public static final String SERVICE_READ_DEVICE_INFO_EXTRA_DATA = "com.brytonsport.active.SERVICE_READ_DEVICE_INFO_EXTRA_DATA";
    public static final String SERVICE_REQUEST_DATA = "com.brytonsport.active.SERVICE_REQUEST_DATA";
    public static final String SERVICE_REQUEST_FILE_TYPE = "com.brytonsport.active.SERVICE_REQUEST_FILE_TYPE";
    public static final String SERVICE_SCAN_CONNECT_MODE = "com.brytonsport.active.SERVICE_SCAN_CONNECT_MODE";
    public static final String SERVICE_SETTING_COMMAND_PARAM_ARRAY = "com.brytonsport.active.SERVICE_SETTING_COMMAND_PARAM_ARRAY";
    public static final String SERVICE_SETTING_COMMAND_RETURN = "com.brytonsport.active.SERVICE_SETTING_COMMAND_RETURN";
    public static final String SERVICE_STRING_EXTRA_DATA = "com.brytonsport.active.SERVICE_STRING_EXTRA_DATA";
    public static final String SERVICE_UPLOAD_ACTIVITIES_ALL_SUCCESS = "com.brytonsport.active.SERVICE_UPLOAD_ACTIVITIES_ALL_SUCCESS";
    public static final String SERVICE_UPLOAD_ACTIVITIES_HAS_BEFORE_2016 = "com.brytonsport.active.SERVICE_UPLOAD_ACTIVITIES_HAS_BEFORE_2016";
    public static final String SERVICE_VOICE_TO_TEXT_RESULT = "com.brytonsport.active.SERVICE_VOICE_TO_TEXT_RESULT";
    static final String TAG = "BleService";
    public static boolean devSptGroupRide = false;
    public static boolean devStartGroupRide = false;
    private static boolean isGetWavFile = false;
    public static Context mContext;
    @Inject
    ActivityRepository activityRepository;
    Runnable checkUnSaveRunnable;
    private ArrayList<ClimbGrade> climbGradeList;
    @Inject
    Connect3rdPartyRepository connect3rdPartyRepository;
    @Inject
    DeviceRepository deviceRepository;
    @Inject
    FileIdHistoryRepository fileIdHistoryRepository;
    private List<FileSummary> fileSummaryList;
    Date getFileListStartTime;
    byte[] getFileRangeTotalArray;
    private String lastNotificationAppName;
    private String lastNotificationText;
    private String lastNotificationTitle;
    private Location mLastLocation;
    @Inject
    NotificationRepository notificationRepository;
    @Inject
    PlanTripRepository planTripRepository;
    Runnable processActivityRunnable;
    byte[] readDeviceInfoArray;
    Set<String> uploadingFileIdSet;
    public static GroupRideInfoResponseData moGroupRideInfoResponseData = new GroupRideInfoResponseData();
    public static ArrayMap<String, GroupTrackMemberInfo> aryGroupTrackMember = new ArrayMap<>();
    public static int mnStartTimeUTC = 0;
    public static int mnDuration = 0;
    public static String msEndTime = "";
    public static ArrayList<Message> aryMessagesToSend = new ArrayList<>();
    public static ArrayList<DevLatLng> aryDevLatLngsToSend = new ArrayList<>();
    public static Boolean mbDevExist = false;
    public static boolean isOpeningInfo = false;
    public static boolean isSearchingVoice = false;
    public static int mnPreMessagesSize = 0;
    public static String quickReplieVoiceText = null;
    public static ArrayList<QuickReply> quickReplies = new ArrayList<>();
    private static boolean isRunningGrIgnoreAction = false;
    public static String msCurpassSettingCmd = "";
    public static StringBuilder msbLogText = new StringBuilder(8192);
    public static BleRepoImpl bleRepo = new BleRepoImpl();
    public static byte mnCurpassSettingCmdGroupAction = 0;
    public static String sGroupId = "";
    public static boolean isSendingCmd = false;
    public static int groupRideMaxMsg = 100;
    public static boolean isClickGrMenuOrConfirmDialogFromCoursePage = false;
    public static boolean isStartFromDevCmd75 = false;
    public static int lastCmd75State = -1;
    public static int nowCmdGrBaseSubType = -1;
    public static boolean isRunningRequestGrMsgCan = false;
    public static int serverEeCompress = 0;
    public static int serverEePostDataIndex = 0;
    private static int dlServerEeOkCount = 0;
    private static int dlServerEeErrorCount = 0;
    private static int dlServerEeTimeoutCount = 0;
    public static int dlServerEeTotalNum = 0;
    private static List<String> dlServerEeFileNameList = new ArrayList();
    String notificationTxtDataSync = "同步處理服務";
    String notificationCloseBtnTxt = "關閉服務";
    String backgroundLocationHintMsg = "需要存取您的位置權限，請選擇「一律允許」以確保您在各種情況下與裝置連線功能保持正常。";
    String fineLocationHintMsg = "需要存取您的位置權限，請開啟位置權限以確保您在各種情況下與裝置連線功能保持正常。";
    String notifyOpenSettingBtnTxt = "管理權限";
    String notifyOpenGpsSettingBtnTxt = "開啟定位服務";
    Thread mHandshake = null;
    boolean isCancelPostData = false;
    int processActivityTotalCount = 0;
    int processActivityNowIndex = 0;
    Handler processActivityHandler = new Handler();
    int processActivityDelay = 50;
    boolean isProcessActivityComplete = false;
    boolean hasBefore2016Fit = false;
    int cmd16ContentType = 0;
    int cmd16ContentSize = 0;
    int sendFileCrcCount = 0;
    int sendFileOriginDataSize = 0;
    int sendPlanTripIndex = 0;
    byte[] sendFileByteArray = null;
    boolean devSptLiveTrack = false;
    boolean devSptLogCompress = false;
    boolean devSptNotification = false;
    boolean appSptLogCompress = false;
    boolean appSptLiveTrack = false;
    JSONObject appSupFeatureObj = null;
    JSONObject handshakePayloadObj = null;
    int DEFAULT_CHUNK_SIZE_TX = 990;
    int postDataChunkSizeTx = 990;
    long handshakeStartTime = 0;
    int appUnit = 0;
    boolean fitAutoSync = true;
    String fitUploadNotifyContent = "新活動紀錄已完成上傳Active";
    File[] unsaveFiles = new File[0];
    int uploadUnSaveIndex = 0;
    int countUnsaveUploadSuccess = 0;
    boolean cmd17FirstGetFileSize = true;
    int getFileRangeIndex = 0;
    int getFileRangeOffset = 0;
    int getFileRangeChunkSize = 0;
    int fileRangeCount = 0;
    int fileRangeLastChunkSize = 0;
    int choiceFileId = 0;
    int choiceFileType = 0;
    int choiceFileListIndex = 0;
    private String graphHopperKey = BuildConfig.GRAPH_HOPPER_KEY;
    private String graphHopperBaseUrl = "https://graphhopper.com/api/1/";
    private String no_U_Turn = "pass_through=true&";
    private String avoidRoadClass = "&ch.disable=true&avoid=ferry";
    private String noAvoidRoadClass = "&ch.disable=true";
    private String routeMode = FlagEncoderFactory.RACINGBIKE;
    private String testReturnJson = "{\"cmd\":60,\"heading\":380,\"startPos\":{\"lat\":23.643844604492188,\"lng\":120.88317108154297},\"endPos\":{\"lat\":24.755292892456055,\"lng\":121.75831604003906}}";
    int DOWNLOAD_SIZE = SampleGattAttributes.DOWNLOAD_SIZE;
    List<byte[]> sendFileList = null;
    int sendFileCount = 0;
    int cmdSpeech2TextType = -1;
    String speech2textUrl = "https://27qsup8wp3.execute-api.us-east-1.amazonaws.com/dev/speech2text";
    private boolean voiceDone = false;
    int voiceGetFileRangeOffset = 0;
    int voiceGetFileRangeChunkSize = 0;
    JSONObject speech2TextObj = new JSONObject();
    double searchPlaceLat = 0.0d;
    double searchPlaceLng = 0.0d;
    String placeNearbySearchBaseUrl = "https://maps.googleapis.com/maps/api/place/nearbysearch/json?";
    String placeFindPlaceBaseUrl = "https://maps.googleapis.com/maps/api/place/findplacefromtext/json?";
    String placeApiKey = "";
    String voiceFileName = "bryton_voice.wav";
    String searchFileName = "search.txt";
    String transcript = "";
    String devVoiceLanguage = "國語 (台灣)";
    String speech2textLangCode = "";
    String nearByPlaceLangCode = "";
    String voiceSendPlanTripName = "voiceTrip";
    private int surpriseMeIndex = 0;
    private int surpriseMeTotalCount = 0;
    private JSONArray surpriseMePointArray = null;
    private JSONArray surpriseMeSurpriseData = null;
    private JSONArray surpriseMeSendFileData = null;
    private String surpriseMeRouteLangName = "路線";
    private String mWoSurpriseMeFileName = "surpriseMe.txt";
    private String nowSentPlanTripName = null;
    private int devSendSurpriseMeDistance = -1;
    private JSONObject nowPosForSurpriseMeDistance = null;
    boolean liveTrackManualStart = false;
    boolean liveTrackAutoShare = false;
    boolean liveTrackAutoSendMail = false;
    boolean liveTrackExtend24Hour = false;
    boolean liveTrack24HourNeedClear = false;
    int liveTrackInterval = LiveTrackUtil.liveTrackInterval;
    String liveTrackBaseUrl = "https://z8bsz5p8ph.execute-api.ap-northeast-1.amazonaws.com/prod/api/v2/";
    String liveTrackUserId = "";
    String liveTrackUserNickName = "";
    String liveTrackUserIcon = "";
    String liveTrackGroupId = "";
    String liveTrackGroupCred = "";
    long liveTrack24HourTimeStamp = 0;
    long allowableTimeDifference = 300000;
    boolean isClearHistory = false;
    JSONArray liveTrackHistoryQueue = new JSONArray();
    boolean liveTrackHasMailToSend = false;
    String sendMailUrl = "https://api.sendgrid.com/v3/mail/send";
    String sendMailAuthorization = "Bearer %s";
    String sendMailContentType = "application/json";
    String sendMailPostBody = "{\"personalizations\":[{\"to\":%s}],\"from\":{\"email\":\"no-reply@brytonsport.com\",\"name\":\"Bryton\"},\"subject\":\"%s\",\"content\":[{\"type\":\"text/html\",\"value\":\"%s\"}]}";
    String sendMailSubject = "Bryton Sport";
    String sendMailContent = "";
    String sendMailReceiver = "";
    private SyncFitFileInfo syncFitFileInfo = null;
    private final int SERVICE_IDLE = 0;
    private ServiceState serviceState = new ServiceState();
    private LocationManager mLocationManager = null;
    private String locationProvider = "";
    private LocationListener[] mLocationListeners = null;
    private LocationListener mLocListener = null;
    boolean isGPSEnabled = false;
    boolean isNetworkEnabled = false;
    Handler checkUnSaveHandler = new Handler();
    int checkUnSaveDelay = 10000;
    boolean reRouteTurnByTurnSuccess = false;
    Thread mGetFileListWatchDog = null;
    long processGetFileListDelay = 5000;
    RequestQueue mQueue = null;
    public boolean isScanConnectMode = false;
    public boolean isFirstCallCmdLatLon = true;
    private Notification appFgNotification = null;
    private boolean isCallStartForeground = false;
    private final BroadcastReceiver mGattUpdateReceiver = new AnonymousClass1();
    private BroadcastReceiver gpsSwitchReceiver = new BroadcastReceiver() { // from class: com.brytonsport.active.service.BleService.41
        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, Intent intent) {
            if ("android.location.PROVIDERS_CHANGED".equals(intent.getAction())) {
                BleService.this.gpsSwitchHandler.removeMessages(1);
                BleService.this.gpsSwitchHandler.sendEmptyMessageDelayed(1, 1000L);
            }
        }
    };
    private Handler gpsSwitchHandler = new Handler(new Handler.Callback() { // from class: com.brytonsport.active.service.BleService.42
        @Override // android.os.Handler.Callback
        public boolean handleMessage(android.os.Message message) {
            if (message.what == 1) {
                BleService.this.gpsSwitchHandler.removeMessages(1);
                if (BleService.this.mLocationManager == null) {
                    BleService bleService = BleService.this;
                    bleService.mLocationManager = (LocationManager) bleService.getSystemService(FirebaseAnalytics.Param.LOCATION);
                }
                boolean isProviderEnabled = BleService.this.mLocationManager.isProviderEnabled(ConstSettingChannel.DEVICE_CAPABILITY_GPS);
                boolean isProviderEnabled2 = BleService.this.mLocationManager.isProviderEnabled("network");
                String str = BleService.TAG;
                Log.d(str, "gpsSwitchHandler: location isGpsEnabled = " + isProviderEnabled + ", isNetworkEnabled = " + isProviderEnabled2);
                if (isProviderEnabled || isProviderEnabled2) {
                    BleService.this.initializeLocationManager();
                }
            }
            return true;
        }
    });
    private Handler notificationSameHandler = new Handler(new Handler.Callback() { // from class: com.brytonsport.active.service.BleService.43
        @Override // android.os.Handler.Callback
        public boolean handleMessage(android.os.Message message) {
            if (message.what == 1) {
                BleService.this.notificationSameHandler.removeMessages(1);
                String str = BleService.TAG;
                Log.d(str, "通知 經由Handler 過濾後要發出: " + BleService.this.lastNotificationAppName + ", " + BleService.this.lastNotificationTitle + ", " + BleService.this.lastNotificationText);
                BleService bleService = BleService.this;
                bleService.notifyAppCombine(bleService.lastNotificationAppName, BleService.this.lastNotificationTitle, BleService.this.lastNotificationText);
            }
            return true;
        }
    });
    public File[] serverEeFiles = new File[0];
    private boolean connectActionQueueProcessing = false;
    private ConcurrentLinkedQueue<ConnectTaskObject> connectActionQueue = new ConcurrentLinkedQueue<>();

    @Override // android.app.Service
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override // com.brytonsport.active.service.Hilt_BleService, android.app.Service
    public void onCreate() {
        super.onCreate();
        this.notificationTxtDataSync = i18N.get("DataSyncService");
        this.notificationCloseBtnTxt = i18N.get("DataSyncStop");
        this.surpriseMeRouteLangName = i18N.get("Route");
        if (Build.VERSION.SDK_INT >= 26) {
            Notification notification = this.appFgNotification;
            if (notification == null) {
                notification = createNotification("");
            }
            startForeground(11, notification);
        }
        registerGattReceiver();
        initializeLocationManager();
        this.mQueue = Volley.newRequestQueue(this);
        SampleGattAttributes.isGetFileRangePhase2 = true;
        startCheckUnSaveAction();
        ProfileUtil.getInstance().set(ProfileUtil.CONNECT_READY_TO_SEND_GET_USER_NAME, false);
        registerGpsSwitchReceiver();
        this.isFirstCallCmdLatLon = true;
        this.uploadingFileIdSet = new HashSet();
        this.lastNotificationAppName = "";
    }

    @Override // android.app.Service
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
        startForegroundService();
    }

    @Override // android.app.Service
    public void onDestroy() {
        super.onDestroy();
        unregisterGattReceiver();
        removeLocationListener();
        this.processActivityHandler.removeCallbacks(this.processActivityRunnable);
        stopCheckUnSaveAction();
        ProfileUtil.getInstance().set(ProfileUtil.CONNECT_READY_TO_SEND_GET_USER_NAME, false);
        BleUtil.getInstance().resetBleUtil();
        unregisterGpsSwitchReceiver();
        stopForeground(true);
        this.handshakeStartTime = 0L;
        App.getInstance().isNeedCheckFwUpdate = true;
        setServerEeCompress(0);
        setServerEePostDataIndex(0);
        resetServerEeCountData();
        connectActionQueueCleanup();
        App.getInstance().devHasNewFwUpdate = false;
        App.getInstance().nowSendServerEeDataState = false;
    }

    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
    @Override // android.app.Service
    public int onStartCommand(Intent intent, int flags, int startId) {
        startForegroundService();
        String str = TAG;
        Log.d(str, "onStartCommand executed with startId: " + startId);
        if (intent != null) {
            String action = intent.getAction();
            action.hashCode();
            char c = 65535;
            switch (action.hashCode()) {
                case -2031075644:
                    if (action.equals(Constants.ACTION_NOTIFY_POST)) {
                        c = 0;
                        break;
                    }
                    break;
                case -1812145176:
                    if (action.equals(Constants.START_SCAN)) {
                        c = 1;
                        break;
                    }
                    break;
                case -1598845487:
                    if (action.equals(Constants.INIT_LOCATION_MANAGER)) {
                        c = 2;
                        break;
                    }
                    break;
                case -1491633524:
                    if (action.equals(Constants.ACTION_NOTIFY_APPLICATION)) {
                        c = 3;
                        break;
                    }
                    break;
                case -1320218309:
                    if (action.equals(Constants.ACTION_CANCEL_SEND_FILE_TO_DEVICE)) {
                        c = 4;
                        break;
                    }
                    break;
                case -985426999:
                    if (action.equals(Constants.DISCONNECT_DEVICE)) {
                        c = 5;
                        break;
                    }
                    break;
                case -947893897:
                    if (action.equals(Constants.ACTION_SETTING_COMMAND)) {
                        c = 6;
                        break;
                    }
                    break;
                case -911537402:
                    if (action.equals(Constants.ACTION_NOTIFY_INCOMING_CALL_CANCEL)) {
                        c = 7;
                        break;
                    }
                    break;
                case -517258898:
                    if (action.equals(Constants.RE_BOOT_AND_START_SERVICE)) {
                        c = '\b';
                        break;
                    }
                    break;
                case -442137100:
                    if (action.equals(Constants.ACTION_DISCONNECT_DEVICE)) {
                        c = '\t';
                        break;
                    }
                    break;
                case -344153060:
                    if (action.equals(Constants.STOP_SERVICE)) {
                        c = '\n';
                        break;
                    }
                    break;
                case 25533155:
                    if (action.equals(Constants.ACTION_START_AUTO_ALTITUDE)) {
                        c = 11;
                        break;
                    }
                    break;
                case 46337131:
                    if (action.equals(Constants.ACTION_GET_RX_PROGRESS)) {
                        c = '\f';
                        break;
                    }
                    break;
                case 67785292:
                    if (action.equals(Constants.ACTION_REQUEST_DATA)) {
                        c = '\r';
                        break;
                    }
                    break;
                case 409395093:
                    if (action.equals(Constants.ACTION_GET_FILE_RANGE)) {
                        c = 14;
                        break;
                    }
                    break;
                case 454805920:
                    if (action.equals(Constants.ACTION_GET_FIT_FILE_FROM_DEVICE_BY_SPT_FTP)) {
                        c = 15;
                        break;
                    }
                    break;
                case 560658028:
                    if (action.equals(Constants.ACTION_CREATE_BOND_OR_CONNECT)) {
                        c = 16;
                        break;
                    }
                    break;
                case 664055278:
                    if (action.equals(Constants.ACTION_IS_DEVICE_SUPPORT_GROUP_RIDE)) {
                        c = 17;
                        break;
                    }
                    break;
                case 777797395:
                    if (action.equals(Constants.ACTION_CANCEL_RX_PROGRESS)) {
                        c = 18;
                        break;
                    }
                    break;
                case 944487239:
                    if (action.equals(Constants.ACTION_NOTIFY_INCOMING_EMAIL)) {
                        c = 19;
                        break;
                    }
                    break;
                case 954610263:
                    if (action.equals(Constants.ACTION_POST_DATA)) {
                        c = 20;
                        break;
                    }
                    break;
                case 1064850783:
                    if (action.equals(Constants.ACTION_POST_FW_UPDATE_DATA)) {
                        c = 21;
                        break;
                    }
                    break;
                case 1277322547:
                    if (action.equals(Constants.ACTION_NOTIFY_INCOMING_CALL)) {
                        c = 22;
                        break;
                    }
                    break;
                case 1277833218:
                    if (action.equals(Constants.ACTION_NOTIFY_INCOMING_TEXT)) {
                        c = 23;
                        break;
                    }
                    break;
                case 1669452192:
                    if (action.equals(Constants.ACTION_READ_DEVICE_INFO)) {
                        c = 24;
                        break;
                    }
                    break;
                case 1699528500:
                    if (action.equals(Constants.ACTION_UNBOND_DEVICE)) {
                        c = 25;
                        break;
                    }
                    break;
                case 1930575855:
                    if (action.equals(Constants.ACTION_FILE_LIST)) {
                        c = 26;
                        break;
                    }
                    break;
                case 1971052727:
                    if (action.equals(Constants.ACTION_GET_FILE)) {
                        c = 27;
                        break;
                    }
                    break;
                case 2003027542:
                    if (action.equals(Constants.STOP_SCAN)) {
                        c = 28;
                        break;
                    }
                    break;
                case 2024513947:
                    if (action.equals(Constants.RUN_CONNECT_TASK)) {
                        c = 29;
                        break;
                    }
                    break;
            }
            switch (c) {
                case 0:
                    try {
                        JSONObject jSONObject = new JSONObject(intent.getStringExtra(SERVICE_NOTIFICATION_POST));
                        Log.d(str, "收到發送通知: " + jSONObject.toString());
                        sendNotify(jSONObject);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                    checkAutoAltitude();
                    break;
                case 1:
                    startScan();
                    break;
                case 2:
                    initializeLocationManager();
                    break;
                case 3:
                    notifyApplication(intent.getStringExtra(NOTIFY_APPLICATION_NAME), intent.getStringExtra(NOTIFY_APPLICATION_TITLE), intent.getStringExtra(NOTIFY_APPLICATION_CONTENT));
                    break;
                case 4:
                    this.isCancelPostData = true;
                    break;
                case 5:
                    intent.getStringExtra("disConnectDevice");
                    break;
                case 6:
                    try {
                        JSONArray jSONArray = new JSONArray(intent.getStringExtra(SERVICE_SETTING_COMMAND_PARAM_ARRAY));
                        checkGroupRideCommand(jSONArray);
                        passSettingCommand(jSONArray);
                        break;
                    } catch (JSONException e2) {
                        e2.printStackTrace();
                        break;
                    }
                case 7:
                    notifyIncomingCallCancel();
                    break;
                case '\b':
                    reBootAndCheckHasDeviceConnect();
                    break;
                case '\t':
                    disConnect(intent.getStringExtra("disConnectDev"));
                    break;
                case '\n':
                    stopForeground(true);
                    stopSelf();
                    LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(Constants.CLOSE_APP));
                    break;
                case 11:
                    checkAutoAltitude();
                    break;
                case '\f':
                    getRxProgress();
                    break;
                case '\r':
                    requestData(intent.getIntExtra(REQUEST_DATA_REQUEST_TYPE, 0));
                    break;
                case 14:
                    int intExtra = intent.getIntExtra("idOfGetFileRange", 0);
                    byte byteExtra = intent.getByteExtra("typeOfGetFileRange", (byte) 0);
                    int intExtra2 = intent.getIntExtra(TypedValues.CycleType.S_WAVE_OFFSET, 0);
                    int intExtra3 = intent.getIntExtra("chunkSize", 0);
                    this.choiceFileId = intExtra;
                    Log.d(str, "onStartCommand ACTION_GET_FILE_RANGE choiceFileId: " + this.choiceFileId);
                    getFileRange(intExtra, byteExtra, intExtra2, intExtra3);
                    break;
                case 15:
                    int intExtra4 = intent.getIntExtra("idOfGetFile", 0);
                    byte byteExtra2 = intent.getByteExtra("typeOfGetFile", (byte) 0);
                    this.choiceFileId = intExtra4;
                    Log.d(str, "ACTION_GET_FIT_FILE_FROM_DEVICE_BY_SPT_FTP choiceFileId: " + this.choiceFileId);
                    getFitFileFromDeviceBySptFtp(intExtra4, byteExtra2);
                    this.isCancelPostData = true;
                    break;
                case 16:
                    this.isScanConnectMode = intent.getBooleanExtra(SERVICE_SCAN_CONNECT_MODE, false);
                    Device device = new Device();
                    device.macAddress = intent.getStringExtra("deviceMac");
                    device.deviceName = intent.getStringExtra("deviceName");
                    device.uuid = intent.getStringExtra("deviceUuid");
                    device.firmware = intent.getStringExtra("deviceVer");
                    checkHasDeviceConnect(device);
                    break;
                case 17:
                    broadcastBooleanData(SERVICE_IS_DEVICE_SUPPORT_GROUP_RIDE, Boolean.valueOf(devSptGroupRide));
                    break;
                case 18:
                    cancelRxProgress();
                    break;
                case 19:
                    notifyIncomingEmail();
                    break;
                case 20:
                    postDataPrepare(intent.getIntExtra(POST_DATA_CONTENT_TYPE, 0), intent.getByteArrayExtra(POST_DATA_CONTENT_BYTE_ARRAY));
                    break;
                case 21:
                    int intExtra5 = intent.getIntExtra(POST_DATA_CONTENT_TYPE, 0);
                    FwPackageInfo fwPackageInfo = (FwPackageInfo) intent.getSerializableExtra(POST_DATA_FW_PACKAGE_INFO);
                    postDataPrepare(intExtra5, FileUtil.getFileByteArrayByFile(App.nowFwUpdateFile));
                    break;
                case 22:
                    notifyIncomingCall(intent.getStringExtra(NOTIFY_CALL_NAME), intent.getStringExtra(NOTIFY_CALL_NUMBER));
                    break;
                case 23:
                    notifyIncomingText();
                    break;
                case 24:
                    readDeviceInfo();
                    break;
                case 25:
                    unBondDevice(intent.getStringExtra("disConnectDev"));
                    break;
                case 26:
                    getFileList();
                    break;
                case 27:
                    int intExtra6 = intent.getIntExtra("idOfGetFile", 0);
                    byte byteExtra3 = intent.getByteExtra("typeOfGetFile", (byte) 0);
                    this.choiceFileId = intExtra6;
                    Log.d(str, "onStartCommand ACTION_GET_FILE choiceFileId: " + this.choiceFileId);
                    getFile(intExtra6, byteExtra3);
                    break;
                case 28:
                    stopScan();
                    break;
                case 29:
                    this.isScanConnectMode = false;
                    checkDecideRunConnectTask();
                    break;
            }
        } else {
            Log.d(str, "with a null intent. It has been probably restarted by the system.");
        }
        return 1;
    }

    public void registerGattReceiver() {
        Log.d(TAG, "registerGattReceiver: ");
        registerReceiver(this.mGattUpdateReceiver, makeGattUpdateIntentFilter());
    }

    public void unregisterGattReceiver() {
        Log.d(TAG, "unregisterGattReceiver: ");
        unregisterReceiver(this.mGattUpdateReceiver);
    }

    public void bluetoothOnToCheckConnect() {
        new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda1
            @Override // java.lang.Runnable
            public final void run() {
                BleService.this.m127x5d085c3f();
            }
        }).start();
    }

    /* renamed from: lambda$bluetoothOnToCheckConnect$0$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m127x5d085c3f() {
        DeviceManagerEntity loadDeviceIsChoice = this.deviceRepository.loadDeviceIsChoice();
        if (loadDeviceIsChoice != null) {
            checkHasDeviceConnect(loadDeviceIsChoice);
        }
    }

    public void bluetoothOffToDisConnect() {
        new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda0
            @Override // java.lang.Runnable
            public final void run() {
                BleService.this.m126xf6074048();
            }
        }).start();
    }

    /* renamed from: lambda$bluetoothOffToDisConnect$1$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m126xf6074048() {
        DeviceManagerEntity loadDeviceIsChoice = this.deviceRepository.loadDeviceIsChoice();
        if (loadDeviceIsChoice != null) {
            disConnect(loadDeviceIsChoice.getMacAddress());
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public boolean isAutoConnectToChoiceDevice() {
        if (BleUtil.getInstance().central.isBluetoothEnabled()) {
            App.getInstance();
            return !App.currentPageName.equals("SettingPairNewDeviceActivity") && App.getInstance().isAppExist();
        }
        return false;
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: com.brytonsport.active.service.BleService$1  reason: invalid class name */
    /* loaded from: classes.dex */
    public class AnonymousClass1 extends BroadcastReceiver {
        AnonymousClass1() {
        }

        /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
        @Override // android.content.BroadcastReceiver
        public void onReceive(Context context, Intent intent) {
            char c;
            String str;
            String action = intent.getAction();
            action.hashCode();
            boolean z = true;
            switch (action.hashCode()) {
                case -1446348801:
                    if (action.equals(SampleGattAttributes.ACTION_REQUEST_DATA)) {
                        c = 0;
                        break;
                    }
                    c = 65535;
                    break;
                case -1166133972:
                    if (action.equals(BleUtil.ACTION_CONNECTION_FAILED)) {
                        c = 1;
                        break;
                    }
                    c = 65535;
                    break;
                case -302905929:
                    if (action.equals(SampleGattAttributes.ACTION_GET_FILE_RANGE_PART_TWO)) {
                        c = 2;
                        break;
                    }
                    c = 65535;
                    break;
                case -180346492:
                    if (action.equals(SampleGattAttributes.ACTION_POST_DATA)) {
                        c = 3;
                        break;
                    }
                    c = 65535;
                    break;
                case -138053570:
                    if (action.equals(BleService.SERVICE_GROUP_RIDE_DOWNLOAD_INFO_ERROR)) {
                        c = 4;
                        break;
                    }
                    c = 65535;
                    break;
                case 187774391:
                    if (action.equals(BleUtil.ACTION_SERVICES_DISCOVERED)) {
                        c = 5;
                        break;
                    }
                    c = 65535;
                    break;
                case 209779887:
                    if (action.equals(BleUtil.ACTION_BONDING_FAILED)) {
                        c = 6;
                        break;
                    }
                    c = 65535;
                    break;
                case 591024900:
                    if (action.equals(BleUtil.ACTION_NOTIFICATION_STATE_SETTING_CHANNEL)) {
                        c = 7;
                        break;
                    }
                    c = 65535;
                    break;
                case 626108438:
                    if (action.equals(BleUtil.ACTION_BONDING_LOST)) {
                        c = '\b';
                        break;
                    }
                    c = 65535;
                    break;
                case 1015145939:
                    if (action.equals(SampleGattAttributes.ACTION_READ_DEVICE_INFO)) {
                        c = '\t';
                        break;
                    }
                    c = 65535;
                    break;
                case 1103157226:
                    if (action.equals(SampleGattAttributes.ACTION_GET_FILE)) {
                        c = '\n';
                        break;
                    }
                    c = 65535;
                    break;
                case 1104189796:
                    if (action.equals(BleUtil.ACTION_CONNECTED_PERIPHERAL)) {
                        c = 11;
                        break;
                    }
                    c = 65535;
                    break;
                case 1289350099:
                    if (action.equals(SampleGattAttributes.ACTION_GET_FILE_LIST)) {
                        c = '\f';
                        break;
                    }
                    c = 65535;
                    break;
                case 1320445064:
                    if (action.equals(SampleGattAttributes.ACTION_GET_FILE_RANGE)) {
                        c = '\r';
                        break;
                    }
                    c = 65535;
                    break;
                case 1397614127:
                    if (action.equals(BleUtil.ACTION_BONDING_STARTED)) {
                        c = 14;
                        break;
                    }
                    c = 65535;
                    break;
                case 1598518254:
                    if (action.equals(BleUtil.ACTION_DISCONNECTED_PERIPHERAL)) {
                        c = 15;
                        break;
                    }
                    c = 65535;
                    break;
                case 1681075210:
                    if (action.equals(BleService.SERVICE_GROUP_RIDE_IS_NOT_END)) {
                        c = 16;
                        break;
                    }
                    c = 65535;
                    break;
                case 1751374136:
                    if (action.equals(SampleGattAttributes.ACTION_CRC_ERROR)) {
                        c = 17;
                        break;
                    }
                    c = 65535;
                    break;
                case 1791089057:
                    if (action.equals(BleUtil.ACTION_BLUETOOTH_STATE_CHANGE)) {
                        c = 18;
                        break;
                    }
                    c = 65535;
                    break;
                case 1856942223:
                    if (action.equals(BleUtil.ACTION_BONDING_SUCCEEDED)) {
                        c = 19;
                        break;
                    }
                    c = 65535;
                    break;
                case 2034802936:
                    if (action.equals(ConstSettingChannel.ACTION_SETTING_COMMAND_RETURN)) {
                        c = 20;
                        break;
                    }
                    c = 65535;
                    break;
                default:
                    c = 65535;
                    break;
            }
            switch (c) {
                case 0:
                    BleService.this.setServiceState(0);
                    byte[] byteArrayExtra = intent.getByteArrayExtra("com.example.bluetooth.le.EXTRA_DATA");
                    BleService.this.broadcastByteArrayData(BleService.SERVICE_REQUEST_DATA, byteArrayExtra);
                    if (BleService.isRunningRequestGrMsgCan) {
                        BleService.this.passGroupRideAction(BleService.GR_ACTION_RECEIVE_GROUP_TRACK_MSG, byteArrayExtra);
                        return;
                    }
                    return;
                case 1:
                    Log.d(BleService.TAG, "裝置連線失敗: ");
                    return;
                case 2:
                    BleService.this.setServiceState(0);
                    int intExtra = intent.getIntExtra(SampleGattAttributes.GET_FILE_RANGE_PARA_FILE_ID, 0);
                    byte byteExtra = intent.getByteExtra(SampleGattAttributes.GET_FILE_RANGE_PARA_FILE_TYPE, (byte) 0);
                    int intExtra2 = intent.getIntExtra(SampleGattAttributes.GET_FILE_RANGE_PARA_OFFSET, 0);
                    int intExtra3 = intent.getIntExtra(SampleGattAttributes.GET_FILE_RANGE_PARA_CHUNK_SIZE, 0);
                    BleService.this.choiceFileId = intExtra;
                    Log.d(BleService.TAG, "ACTION_GET_FILE_RANGE_PART_TWO choiceFileId: " + BleService.this.choiceFileId);
                    BleService.this.getFileRange(intExtra, byteExtra, intExtra2, intExtra3);
                    return;
                case 3:
                    BleService.this.setServiceState(0);
                    Log.d(BleService.TAG, "onReceive: ACTION_POST_DATA 要回啥");
                    intent.getStringExtra("com.example.bluetooth.le.EXTRA_DATA");
                    int intExtra4 = intent.getIntExtra(SampleGattAttributes.EXTRA_DATA_CMD_ID, 0);
                    if (intExtra4 != 2 && intExtra4 != 3 && intExtra4 != 4 && intExtra4 != 5 && intExtra4 != 6 && intExtra4 != 7 && intExtra4 != 8 && intExtra4 != 11) {
                        BleService.this.broadcastPostFileType(BleService.SERVICE_POST_DATA, intExtra4);
                    }
                    if (intExtra4 == 2 || intExtra4 == 9 || intExtra4 == 15 || intExtra4 == 11 || intExtra4 == 14 || intExtra4 == 3 || intExtra4 == 4 || intExtra4 == 5 || intExtra4 == 6 || intExtra4 == 7 || intExtra4 == 8 || intExtra4 == 21 || intExtra4 == 17 || intExtra4 == 18 || intExtra4 == 20 || intExtra4 == 19) {
                        if (BleService.this.isCancelPostData) {
                            BleService.this.resetIsCancelPostDataState();
                            return;
                        }
                        BleService.this.nowSendFileToDeviceProgress();
                        if (BleService.this.sendFileList == null || BleService.this.sendFileCount >= BleService.this.sendFileList.size()) {
                            if (intExtra4 == 3 || intExtra4 == 4 || intExtra4 == 5 || intExtra4 == 6 || intExtra4 == 7 || intExtra4 == 8 || intExtra4 == 11) {
                                BleService.this.broadcastPostFileType(BleService.SERVICE_POST_DATA, intExtra4);
                                if (intExtra4 == 11) {
                                    Log.d(BleService.TAG, "0612 連線動作: 傳完 PLAN_TRIP-> nowSentPlanTripName: " + BleService.this.nowSentPlanTripName + ", 時間: " + new Date());
                                }
                            } else if (intExtra4 == 21 || intExtra4 == 17 || intExtra4 == 18 || intExtra4 == 20 || intExtra4 == 19) {
                                switch (intExtra4) {
                                    case 17:
                                        if (BleService.isStartFromDevCmd75) {
                                            BleService.this.passGroupRideAction(BleService.GR_ACTION_SEND_INACTIVE_MEMBER_LIST);
                                            break;
                                        } else {
                                            BleService.this.passGroupRideAction(BleService.GR_ACTION_REQUEST_GROUP_TRACK_MSG);
                                            break;
                                        }
                                    case 18:
                                        BleService.this.passGroupRideAction(BleService.GR_ACTION_SEND_MEMBER_MESSAGE_DATA);
                                        break;
                                    case 20:
                                        BleService.this.passGroupRideAction(BleService.GR_ACTION_SEND_GROUP_RIDE_ACTIVE_MESSAGE_CAN);
                                        break;
                                    case 21:
                                        BleService.this.passGroupRideAction(BleService.GR_ACTION_SEND_MEMBER_UPDATE);
                                        break;
                                }
                            } else if (intExtra4 == 2) {
                                Log.d(BleService.TAG, "0612 連線動作: 傳完 SERVER_EE-> nowSentPlanTripName: " + BleService.this.nowSentPlanTripName + ", 時間: " + new Date());
                                BleService.serverEePostDataIndex = BleService.serverEePostDataIndex + 1;
                                BleService.this.prepareServerEeFile(BleService.serverEePostDataIndex);
                            }
                            if (BleService.this.nowSentPlanTripName != null && !BleService.this.nowSentPlanTripName.isEmpty()) {
                                Log.d(BleService.TAG, "現在路線名稱: nowSentPlanTripName -> " + BleService.this.nowSentPlanTripName);
                                if (BleService.this.nowSentPlanTripName.equals(BleService.GR_PLANTRIP_NAME)) {
                                    BleService.this.passGroupRideAction(BleService.GR_ACTION_SEND_GROUP_TRACK_PLANTRIP_NAME);
                                } else {
                                    BleService bleService = BleService.this;
                                    bleService.setPlanTripName(bleService.nowSentPlanTripName);
                                }
                                BleService.this.nowSentPlanTripName = "";
                            }
                            if (!DeviceInfo.setting || intExtra4 == 3 || intExtra4 == 4 || intExtra4 == 5 || intExtra4 == 6 || intExtra4 == 7 || intExtra4 == 8 || intExtra4 == 11 || intExtra4 == 21 || intExtra4 == 17 || intExtra4 == 18 || intExtra4 == 20 || intExtra4 == 19) {
                                return;
                            }
                            BleUtil.getInstance().setDevNotify(0);
                            return;
                        }
                        BleService bleService2 = BleService.this;
                        bleService2.sendFileToDevice(intExtra4, bleService2.sendFileList.get(BleService.this.sendFileCount));
                        BleService.this.sendFileCount++;
                        return;
                    } else if (intExtra4 == 12 && DeviceInfo.setting) {
                        BleUtil.getInstance().setDevNotify(0);
                        return;
                    } else {
                        return;
                    }
                case 4:
                case 16:
                    Log.d(BleService.TAG, "processConnectAction: Priority 6-Group track 完成- " + action);
                    BleService.this.checkGroupRideCompleted();
                    return;
                case 5:
                    Log.d(BleService.TAG, "裝置SERVICES_DISCOVERED 成功: ");
                    return;
                case 6:
                    Log.d(BleService.TAG, "裝置綁定失敗: ");
                    return;
                case 7:
                    BleUtil.getInstance().setNewApp();
                    return;
                case '\b':
                    Log.d(BleService.TAG, "裝置移除綁定成功: ");
                    return;
                case '\t':
                    BleService.this.setServiceState(0);
                    BleService.this.processDeviceInfo(intent.getStringExtra(SampleGattAttributes.EXTRA_DATA_MAC_ADDRESS), DataUtil.readDeviceInfoFormat(intent.getByteArrayExtra("com.example.bluetooth.le.EXTRA_DATA")));
                    return;
                case '\n':
                    BleService.this.setServiceState(0);
                    byte[] byteArrayExtra2 = intent.getByteArrayExtra("com.example.bluetooth.le.EXTRA_DATA");
                    String jSONObject = DataUtil.requestDataResult(byteArrayExtra2).toString();
                    BleService.this.processGetFileReturn(byteArrayExtra2, jSONObject);
                    BleService.this.broadcastByteArrayData(BleService.SERVICE_GET_FILE, jSONObject.getBytes());
                    return;
                case 11:
                    Log.d(BleService.TAG, "裝置連線 CONNECTED_PERIPHERAL 成功: ");
                    BleService.this.deviceRepository.updateDeviceConnectState(intent.getStringExtra(BleUtil.ACTION_DISCONNECTED_PERIPHERAL_EXTRA_DATA), true);
                    BleService.this.deviceConnectOrDisconnectForGR(1);
                    BleService.this.broadcastIntData(BleService.SERVICE_DEVICE_CONNECT_OR_DISCONNECT, 1);
                    return;
                case '\f':
                    BleService.this.setServiceState(0);
                    BleService.this.stopCountDownGetFileList();
                    byte[] byteArrayExtra3 = intent.getByteArrayExtra("com.example.bluetooth.le.EXTRA_DATA");
                    if (byteArrayExtra3 == null || byteArrayExtra3.length <= 0) {
                        BleService.this.setFitSyncingState(false);
                        BleService.this.setRunningAllSyncFlow(false);
                        str = "{\"extra\":null,\"result\":[]}";
                    } else {
                        str = DataUtil.getFileListResult(byteArrayExtra3);
                    }
                    BleService.this.broadcastStringData(BleService.SERVICE_FILE_LIST, str);
                    BleService.this.processGetFileListReturn(byteArrayExtra3);
                    return;
                case '\r':
                    BleService.this.setServiceState(0);
                    byte[] bArr = App.fitUploadByteArray;
                    BleService.this.processGetFileRangeReturn(bArr, DataUtil.requestDataResult(bArr).toString());
                    return;
                case 14:
                    Log.d(BleService.TAG, "開始綁定裝置: ");
                    return;
                case 15:
                    Log.d(BleService.TAG, "裝置斷線: ");
                    BleService.this.setServiceState(0);
                    if (BleService.this.mHandshake != null) {
                        BleService.this.mHandshake.interrupt();
                    }
                    BleService bleService3 = BleService.this;
                    bleService3.postDataChunkSizeTx = bleService3.DEFAULT_CHUNK_SIZE_TX;
                    BleService.this.nowSentPlanTripName = "";
                    BleService.this.transcript = "";
                    if (BleService.this.mGetFileListWatchDog != null) {
                        BleService.this.mGetFileListWatchDog.interrupt();
                    }
                    BleUtil.getInstance().resetBleUtil();
                    BleService.bleRepo.resetDeviceInfo();
                    BleService.this.deviceConnectOrDisconnectForGR(0);
                    BleService.this.broadcastIntData(BleService.SERVICE_DEVICE_CONNECT_OR_DISCONNECT, 0);
                    BleService.this.deviceRepository.updateDeviceConnectState(intent.getStringExtra(BleUtil.ACTION_DISCONNECTED_PERIPHERAL_EXTRA_DATA));
                    if (BleService.this.isAutoConnectToChoiceDevice()) {
                        BleService.this.bluetoothOnToCheckConnect();
                    }
                    String str2 = (String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID);
                    if (BleService.this.isNetworkConnect() && !str2.isEmpty()) {
                        Log.d(BleService.TAG, " 裝置斷線 -> 檢查unsave 上傳: 有網路 ");
                        BleService.this.uploadFileToServer();
                    } else {
                        Log.d(BleService.TAG, " 裝置斷線 -> 檢查unsave 上傳: 網路未連接 ");
                    }
                    ProfileUtil.getInstance().set(ProfileUtil.SETTING_BIKE_NAME_1, "");
                    ProfileUtil.getInstance().set(ProfileUtil.SETTING_BIKE_NAME_2, "");
                    ProfileUtil.getInstance().set(ProfileUtil.SETTING_BIKE_NAME_3, "");
                    ProfileUtil.getInstance().removeKey("batteryIconId");
                    ProfileUtil.getInstance().set(ProfileUtil.CONNECT_READY_TO_SEND_GET_USER_NAME, false);
                    BleService.initGrSendingParam();
                    BleService.this.removeFromIgnoreAction();
                    boolean unused = BleService.isGetWavFile = false;
                    BleService.this.setFitSyncingState(false);
                    BleService.this.syncFitFileInfo = null;
                    BleService.this.handshakeStartTime = 0L;
                    App.getInstance().isNeedCheckFwUpdate = true;
                    BleService.setServerEeCompress(0);
                    BleService.setServerEePostDataIndex(0);
                    BleService.resetServerEeCountData();
                    BleService.this.connectActionQueueCleanup();
                    App.getInstance().devHasNewFwUpdate = false;
                    App.getInstance().nowSendServerEeDataState = false;
                    return;
                case 17:
                    int intExtra5 = intent.getIntExtra(SampleGattAttributes.EXTRA_DATA_CMD_ID, -1);
                    if (intExtra5 == 12 || (intExtra5 == 17 && !BleService.isGetWavFile)) {
                        BleService.this.setServiceState(0);
                        if (BleService.this.syncFitFileInfo != null) {
                            final String str3 = "CMD(" + intExtra5 + ")";
                            SyncFitFileInfo syncFitFileInfo = BleService.this.syncFitFileInfo;
                            int i = syncFitFileInfo.retryCnt;
                            syncFitFileInfo.retryCnt = i + 1;
                            if (i <= 2) {
                                Log.d(BleService.TAG, str3 + " CRC ERROR file id ->" + BleService.this.syncFitFileInfo.fileIdToTimestamp + " retry:" + BleService.this.syncFitFileInfo.retryCnt);
                                BleService.this.checkFileListToGeFile(z);
                                return;
                            }
                            BleService.this.choiceFileListIndex++;
                            new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$1$$ExternalSyntheticLambda0
                                @Override // java.lang.Runnable
                                public final void run() {
                                    BleService.AnonymousClass1.this.m135lambda$onReceive$0$combrytonsportactiveserviceBleService$1(str3);
                                }
                            }).start();
                        }
                        z = false;
                        BleService.this.checkFileListToGeFile(z);
                        return;
                    }
                    return;
                case 18:
                    int intExtra6 = intent.getIntExtra(BleUtil.ACTION_BLUETOOTH_STATE_CHANGE_EXTRA_DATA, 0);
                    Log.d(BleService.TAG, "ACTION_BLUETOOTH_STATE_CHANGE: state = " + intExtra6);
                    if (intExtra6 == 12) {
                        BleService.this.bluetoothOnToCheckConnect();
                        return;
                    } else if (intExtra6 == 10) {
                        BleService.this.bluetoothOffToDisConnect();
                        return;
                    } else {
                        return;
                    }
                case 19:
                    Log.d(BleService.TAG, "裝置綁定成功: ");
                    return;
                case 20:
                    JSONObject jSONObject2 = null;
                    try {
                        jSONObject2 = new JSONObject(intent.getStringExtra("com.example.bluetooth.le.EXTRA_DATA"));
                    } catch (JSONException e) {
                        Log.e(BleService.TAG, "onReceive: broadcast settingCommand json result error ", e);
                    }
                    Log.d(BleService.TAG, "onReceive settingCommand -> settingJsonObject = " + jSONObject2.toString());
                    BleService.this.broadcastStringData(BleService.SERVICE_SETTING_COMMAND_RETURN, jSONObject2.toString());
                    BleService.this.processSettingCmdReturn(jSONObject2);
                    return;
                default:
                    return;
            }
        }

        /* renamed from: lambda$onReceive$0$com-brytonsport-active-service-BleService$1  reason: not valid java name */
        public /* synthetic */ void m135lambda$onReceive$0$combrytonsportactiveserviceBleService$1(String str) {
            DeviceManagerEntity loadDeviceIsChoice;
            if (BleService.this.deviceRepository.loadDeviceIsChoice() != null) {
                String str2 = str + " CRC ERROR  uuid(" + loadDeviceIsChoice.getDevUuid() + ") fileId(" + BleService.this.syncFitFileInfo.fileIdToTimestamp + ") ver:(" + loadDeviceIsChoice.getDevVersion() + ")";
                Log.d(BleService.TAG, str2);
                FirebaseCustomUtil.getInstance().setBleLogMessage(str2);
            }
        }
    }

    private void newAppCheckFeatureAction() {
        checkDevSptFeature();
        if (!devSptGroupRide) {
            Log.d(TAG, "團騎流程0426 收到CMD52 檢查連線裝置不支援 GroupRide");
        }
        JSONObject appSupportFeature = BleUtil.getInstance().getAppSupportFeature();
        this.appSupFeatureObj = appSupportFeature;
        if (appSupportFeature != null) {
            try {
                this.appSptLiveTrack = appSupportFeature.getBoolean("live_tracking");
                this.appSptLogCompress = this.appSupFeatureObj.getBoolean("log_compress");
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
        if (DeviceInfo.cmd == null || DeviceInfo.cmd.size() <= 0 || !DeviceInfo.cmd.containsKey(ConstSettingChannel.DEVICE_CAPABILITY_NEW_APP) || DeviceInfo.cmd.get(ConstSettingChannel.DEVICE_CAPABILITY_NEW_APP).intValue() < 2) {
            return;
        }
        Log.d(TAG, "processConnectAction: [放進Queue] Priority 1-Device能力判斷 (下CMD71)");
        queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_1_SET_APP_SUPPORT_FUN));
    }

    public void connectTask() {
        if (DeviceInfo.setting) {
            new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda3
                @Override // java.lang.Runnable
                public final void run() {
                    BleService.this.m129lambda$connectTask$2$combrytonsportactiveserviceBleService();
                }
            }).start();
        }
    }

    /* renamed from: lambda$connectTask$2$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m129lambda$connectTask$2$combrytonsportactiveserviceBleService() {
        int deviceFeatureSupportSync = DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.Navigation);
        int deviceFeatureSupportSync2 = DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.LiveTrack);
        int deviceFeatureSupportSync3 = DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.GroupRide);
        int deviceFeatureSupportSync4 = DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.ServerEE);
        int deviceFeatureSupportSync5 = DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.FwUpdate);
        groupRideMaxMsg = DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.GroupRideMaxMsg);
        DeviceManagerEntity loadDeviceIsChoice = DeviceRepository.getInstance().loadDeviceIsChoice();
        String str = TAG;
        Log.d(str, "processConnectAction: [放進Queue] Priority 2-公英制");
        queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_2_SET_UNIT));
        if (deviceFeatureSupportSync > 0) {
            Log.d(str, "processConnectAction: [放進Queue] Priority 3-設定語音語言");
            queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_3_SET_VOICE_LANG));
        } else {
            Log.d(str, "processConnectAction: [不放進Queue] Priority 3-設定語音語言 - 不支援");
        }
        Log.d(str, "processConnectAction: [放進Queue] Priority 4-確認碼錶錄製狀態");
        queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_4_CHECK_DEV_LOG_STATE));
        boolean booleanValue = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_AUTO_START)).booleanValue();
        this.liveTrackAutoShare = booleanValue;
        if (deviceFeatureSupportSync2 > 0 && booleanValue) {
            Log.d(str, "processConnectAction: [放進Queue] Priority 5-設定Live track Interval");
            queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_5_CHECK_LIVE_TRACK));
        } else {
            Log.d(str, "processConnectAction: [不放進Queue] Priority 5-設定Live track Interval - 不支援或未開啟分享位置");
        }
        String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.GROUP_RIDE_ID);
        if (deviceFeatureSupportSync3 > 0 && prefString != null && !prefString.isEmpty()) {
            Log.d(str, "processConnectAction: [放進Queue] Priority 6-Group track 檢查流程");
            queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_6_CHECK_GROUP_RIDE));
        } else {
            Log.d(str, "processConnectAction: [不放進Queue] Priority 6-Group track 檢查流程 - 不支援或沒有groupRideId");
        }
        if (deviceFeatureSupportSync4 > 0) {
            Log.d(str, "processConnectAction: [放進Queue] Priority 7-取得裝置ServerEE 狀態");
            queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_7_CHECK_SERVER_EE_STATE));
        } else {
            Log.d(str, "processConnectAction: [不放進Queue] Priority 7-取得裝置ServerEE 狀態 - 不支援ServerEE");
        }
        if (deviceFeatureSupportSync5 > 0) {
            Log.d(str, "processConnectAction: [放進Queue] Priority 10-Fw Update 檢查");
            queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_10_CHECK_FW_UPDATE, loadDeviceIsChoice));
            return;
        }
        Log.d(str, "processConnectAction: [不放進Queue] Priority 10-Fw Update 檢查 - 不支援Fw Update");
    }

    private void checkDecideRunConnectTask() {
        if (this.isScanConnectMode) {
            return;
        }
        connectTask();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void processSettingCmdReturn(JSONObject jsonObject) {
        try {
        } catch (JSONException e) {
            Log.e(TAG, "processSettingCmdReturn: ", e);
            return;
        }
        if (jsonObject.has("cmd")) {
            int i = jsonObject.getInt("cmd");
            if (i == 24) {
                broadcastStringData(SERVICE_DEVICE_BATTERY, jsonObject.toString());
                return;
            } else if (i == 29) {
                if (jsonObject.has("ack") && jsonObject.getInt("ack") == 10) {
                    connectActionCompleted();
                    return;
                }
                return;
            } else if (i == 37) {
                if (jsonObject.has("compress") && jsonObject.has("download") && jsonObject.has("serverEeType")) {
                    serverEeCompress = jsonObject.getInt("compress");
                    int i2 = jsonObject.getInt("download");
                    int i3 = jsonObject.getInt("serverEeType");
                    String str = TAG;
                    Log.d(str, "0612 連線動作: 跟機器取得完Server EE 狀態，決定是否要下載Server EE data: , 時間: " + new Date());
                    if (i2 == 0) {
                        Log.d(str, "CMD_SERVEREE: 不需下載server ee to device");
                        Log.d(str, "processConnectAction: [不放進Queue] Priority 9-傳送Server EE data 給機器 - CMD 37 回 不需下載");
                    } else {
                        Log.d(str, "CMD_SERVEREE: 需下載server ee");
                        decideDownLoadServerEe(i3);
                    }
                    connectActionCompleted();
                    return;
                }
                return;
            } else if (i == 41) {
                if (jsonObject.has("item")) {
                    App.getInstance().nowDevLogState = jsonObject.getInt("item");
                    if (jsonObject.getInt("item") != 1 && jsonObject.getInt("item") != 2) {
                        jsonObject.getInt("item");
                    }
                    connectActionCompleted();
                    DeviceBusyStatusUtil.DeviceStatus nowDeviceStatus = DeviceBusyStatusUtil.getNowDeviceStatus();
                    if (!nowDeviceStatus.equals(DeviceBusyStatusUtil.DeviceStatus.Recording) && !nowDeviceStatus.equals(DeviceBusyStatusUtil.DeviceStatus.RunningGroupRide) && !nowDeviceStatus.equals(DeviceBusyStatusUtil.DeviceStatus.SendServerEeToDev)) {
                        Log.d(TAG, "processConnectAction: [放進Queue] Priority 8-同步騎乘紀錄");
                        queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_8_SYNC_ACTIVITY));
                        return;
                    }
                    Log.d(TAG, "processConnectAction: [不放進Queue] Priority 8-同步騎乘紀錄 - 錄製中或是GR中");
                    return;
                }
                return;
            } else if (i == 47) {
                String str2 = TAG;
                Log.d(str2, "機器給的 processSettingCmdReturn CMD_NEW_APP: " + jsonObject.toString());
                if (jsonObject.has("devSptFeature") && jsonObject.getBoolean("devSptFeature")) {
                    Log.d(str2, "表示 new app version is 2 ，要下 CMD 71 告訴機器 app 支援的 feature: ");
                    return;
                }
                Log.d(str2, "表示 new app version 是 1 進行UUID檢查: ");
                ProfileUtil.getInstance().set(ProfileUtil.CONNECT_READY_TO_SEND_GET_USER_NAME, true);
                return;
            } else if (i == 49) {
                if (jsonObject.has("ack") && jsonObject.getInt("ack") == 10 && msCurpassSettingCmd.equals(ConstSettingChannel.DEVICE_CMD_SET_PLAN_TRIP_NAME)) {
                    msCurpassSettingCmd = "";
                    passGroupRideAction(GR_ACTION_SEND_MEMBER_LIST);
                    return;
                }
                return;
            } else if (i == 52) {
                long time = new Date().getTime();
                long j = this.handshakeStartTime;
                if (j != 0) {
                    double d = ((float) (time - j)) / 1000.0f;
                    Log.d(TAG, "Handshake 秒數: " + time + " - " + this.handshakeStartTime + " = " + d);
                    broadcastDoubleData(SERVICE_HANDSHAKE_RECEIVE_TIME, d);
                }
                Thread thread = this.mHandshake;
                if (thread != null) {
                    thread.interrupt();
                }
                this.handshakePayloadObj = jsonObject;
                Log.d(TAG, "機器給的 handshakePayload(CMD 52): " + this.handshakePayloadObj.toString());
                setBbcpRxTx(jsonObject);
                newAppCheckFeatureAction();
                checkDecideRunConnectTask();
                return;
            } else if (i == 63) {
                processDevEnterLeaveWifiPage(jsonObject);
                return;
            } else if (i == 65) {
                if (jsonObject.has("ack") && jsonObject.getInt("ack") == 10) {
                    connectActionCompleted();
                    return;
                }
                return;
            } else if (i == 68) {
                Log.d(TAG, "onReceive: SURPRISE_ME_DISTANCE -> " + jsonObject.toString());
                if (jsonObject.has("value")) {
                    processSurpriseMeDistance(jsonObject);
                    return;
                }
                return;
            } else if (i != 69) {
                switch (i) {
                    case 58:
                        if (jsonObject.has("type") && jsonObject.getInt("type") == 2) {
                            if (EasyPermissions.hasPermissions(this, "android.permission.ACCESS_COARSE_LOCATION", EasyBaseFragmentActivity.PERMISSION_ACCESS_FINE_LOCATION)) {
                                Log.d(TAG, "device 跟app要定位點，有權限給定位: ");
                                App.getInstance().nowAskingLocPermissionState = false;
                                passLocationToDevice();
                                return;
                            }
                            if (!App.getInstance().nowAskingLocPermissionState) {
                                Log.d(TAG, "device 跟app要定位點，沒有權限: ");
                                App.getInstance().nowAskingLocPermissionState = true;
                                broadcastBooleanData(SERVICE_CMD_LAT_LNG_NEED_PERMISSION, true);
                            }
                            BleUtil.getInstance().setLatLon(7, 0.0d, 0.0d);
                            return;
                        }
                        return;
                    case 59:
                        if (jsonObject.has("type")) {
                            this.cmdSpeech2TextType = jsonObject.getInt("type");
                        }
                        if (jsonObject.has("ack")) {
                            File filesDir = getFilesDir();
                            if (Build.VERSION.SDK_INT >= 26) {
                                try {
                                    byte[] readAllBytes = Files.readAllBytes(Paths.get(filesDir + UsbFile.separator + this.searchFileName, new String[0]));
                                    BleUtil.getInstance().postData(12, ParserUtil.joinByteArray(ParserUtil.joinByteArray(ByteBuffer.allocate(4).putInt(0).array(), ByteBuffer.allocate(4).putInt(readAllBytes.length).array()), readAllBytes));
                                    return;
                                } catch (IOException e2) {
                                    e2.printStackTrace();
                                    return;
                                }
                            }
                            return;
                        }
                        this.speech2TextObj = jsonObject;
                        addToIgnoreAction();
                        try {
                            Thread.sleep(4000L);
                        } catch (InterruptedException e3) {
                            e3.printStackTrace();
                        }
                        receiveVoiceFile();
                        return;
                        Log.e(TAG, "processSettingCmdReturn: ", e);
                        return;
                    case 60:
                        if (jsonObject.has("ack") && this.reRouteTurnByTurnSuccess) {
                            sendVoiceTrip();
                            return;
                        } else if (isNetworkConnect()) {
                            initReRouteTurnByTurnState();
                            processReRoute(jsonObject);
                            return;
                        } else {
                            reRouteTurnByTurnNoNetworkAction();
                            return;
                        }
                    default:
                        switch (i) {
                            case 71:
                                if (jsonObject.has("ack") && jsonObject.getInt("ack") == 10) {
                                    Log.d(TAG, "告訴 app 支援的 feature 給機器成功: ");
                                    ProfileUtil.getInstance().set(ProfileUtil.CONNECT_READY_TO_SEND_GET_USER_NAME, true);
                                    connectActionCompleted();
                                    return;
                                }
                                return;
                            case 72:
                                if (jsonObject.has("ack") && jsonObject.getInt("ack") == 10) {
                                    connectActionCompleted();
                                    return;
                                }
                                return;
                            case 73:
                                Log.d(TAG, "onReceive: LIVE_TRACKING_INFO -> " + jsonObject.toString());
                                liveTrack(jsonObject);
                                return;
                            case 74:
                                if (jsonObject.has("ack")) {
                                    if (jsonObject.getInt("ack") == 10) {
                                        int i4 = nowCmdGrBaseSubType;
                                        if (i4 != 0) {
                                            if (i4 != 1 && i4 != 2) {
                                                if (i4 == 3) {
                                                    checkGroupRideCompleted();
                                                } else if (i4 == 5) {
                                                    Log.d(TAG, "0612 連線動作: [放進Queue]下載GR fit 給機器: , 時間: " + new Date());
                                                    passGroupRideAction(GR_ACTION_SEND_GROUP_TRACK_FIT);
                                                }
                                            }
                                            isSendingCmd = false;
                                            devStartGroupRide = true;
                                            lastCmd75State = -1;
                                            checkGroupRideCompleted();
                                        }
                                        nowCmdGrBaseSubType = -1;
                                        return;
                                    }
                                    return;
                                }
                                passGroupRideAction(GR_ACTION_GROUP_TRACK_START_POST);
                                return;
                            case 75:
                                if (!isRunningGrIgnoreAction() && jsonObject.has("lat") && jsonObject.has("lon") && jsonObject.has("dist") && jsonObject.has("spd") && jsonObject.has("state")) {
                                    double d2 = jsonObject.getDouble("lat");
                                    double d3 = jsonObject.getDouble("lon");
                                    double d4 = jsonObject.getDouble("dist");
                                    double d5 = jsonObject.getDouble("spd");
                                    int i5 = jsonObject.getInt("state");
                                    lastCmd75State = i5;
                                    if (i5 == 2) {
                                        Log.d(TAG, "團騎流程0426 收到機器傳來的CMD75 機器按XX state = 2: 傳送broadcast GR INTERRUPT");
                                        isClickGrMenuOrConfirmDialogFromCoursePage = false;
                                        devStartGroupRide = false;
                                        isSendingCmd = false;
                                        isStartFromDevCmd75 = false;
                                        mnPreMessagesSize = 0;
                                        lastCmd75State = -1;
                                        broadcastGroupRideInterrupt(SERVICE_GROUP_RIDE_INTERRUPT);
                                    } else {
                                        Log.d(TAG, "團騎流程0426 收到機器傳來的CMD75 state = " + i5);
                                        isStartFromDevCmd75 = true;
                                        if (!devStartGroupRide) {
                                            devStartGroupRide = true;
                                        }
                                    }
                                    if (isGetWavFile) {
                                        return;
                                    }
                                    Log.d(TAG, "團騎流程0426 收到機器傳來的CMD75 沒有再處理語音訊息 -> 傳送機器位置資訊給server ");
                                    addLngLatToSend(String.valueOf(d2), String.valueOf(d3), String.valueOf(d4), String.valueOf(d5), String.valueOf(i5));
                                    moPollingDevLatLngsToSend(i5);
                                    return;
                                }
                                return;
                            case 76:
                                if (jsonObject.has("value")) {
                                    onAddDevMessagesToSend(String.valueOf(jsonObject.getInt("value")));
                                    moPollingMessagesToSend();
                                    return;
                                }
                                return;
                            default:
                                return;
                        }
                }
            } else {
                Log.d(TAG, "onReceive: SURPRISE_ME_SELECT_ID -> " + jsonObject.toString());
                if (jsonObject.has("value")) {
                    processSurpriseMeSelectId(jsonObject);
                    return;
                }
                return;
            }
        }
        Log.d(TAG, "onReceive: setting cmd return -> " + jsonObject.toString());
    }

    private void checkDevSptFeature() {
        JSONObject newAppSupportForService = BleUtil.getInstance().getNewAppSupportForService("all");
        if (newAppSupportForService != null) {
            try {
                this.devSptLiveTrack = newAppSupportForService.getBoolean("live_tracking");
                this.devSptLogCompress = newAppSupportForService.getBoolean("log_compress");
                devSptGroupRide = newAppSupportForService.getBoolean("group_ride");
                this.devSptNotification = newAppSupportForService.getBoolean("android_notification");
                String str = TAG;
                Log.d(str, "checkDevSptFeature: liveTrack = " + this.devSptLiveTrack);
                Log.d(str, "checkDevSptFeature: logCompress = " + this.devSptLogCompress);
                DeviceSupportFeature.SURPRISE_ME = newAppSupportForService.getBoolean("surprise_me");
                DeviceSupportFeature.LIVE_TRACKING = newAppSupportForService.getBoolean("live_tracking");
                DeviceSupportFeature.LOG_COMPRESS = newAppSupportForService.getBoolean("log_compress");
                DeviceSupportFeature.GROUP_RIDE = newAppSupportForService.getBoolean("group_ride");
                DeviceSupportFeature.ANDROID_NOTIFICATION = newAppSupportForService.getBoolean("android_notification");
                this.deviceRepository.updateLtGrFeature(DeviceSupportFeature.LIVE_TRACKING, DeviceSupportFeature.GROUP_RIDE);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
    }

    private void passLocationToDevice() {
        if (this.mLastLocation != null) {
            String str = TAG;
            Log.d(str, "passLocationToDevice 經緯度: " + this.mLastLocation.getLatitude() + ", " + this.mLastLocation.getLongitude());
            BleUtil.getInstance().setLatLon(1, this.mLastLocation.getLatitude(), this.mLastLocation.getLongitude());
        } else if (this.isFirstCallCmdLatLon) {
            Log.d(TAG, "passLocationToDevice 第一次呼叫 初始化: ");
            this.isFirstCallCmdLatLon = false;
            initializeLocationManager();
        } else {
            Log.d(TAG, "passLocationToDevice 取不到經緯度: ");
            BleUtil.getInstance().setLatLon(7, 0.0d, 0.0d);
        }
    }

    public static void cleanData() {
        String str = TAG;
        Log.d(str, "團騎流程 -> cleanData lastCmd75State: " + lastCmd75State);
        moGroupRideInfoResponseData = new GroupRideInfoResponseData();
        aryGroupTrackMember = new ArrayMap<>();
        mnStartTimeUTC = 0;
        mnDuration = 0;
        msEndTime = "";
        aryMessagesToSend = new ArrayList<>();
        aryDevLatLngsToSend = new ArrayList<>();
        mbDevExist = false;
        isOpeningInfo = false;
        isSendingCmd = false;
        devStartGroupRide = false;
        mnPreMessagesSize = 0;
        quickReplieVoiceText = null;
        quickReplies = new ArrayList<>();
        isSearchingVoice = false;
        isRunningGrIgnoreAction = false;
        lastCmd75State = -1;
    }

    public static void cleanGroupRideStorageData() {
        File file = new File(App.getInstance().getFilesDir() + File.separator + String.format(ClimbProUtil.GR_FIT_BASE_ROOT_FOLDER, (String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID)));
        if (file.isDirectory()) {
            try {
                FileUtil.deleteDirectory(file);
            } catch (Exception unused) {
            }
        }
    }

    public static void getGroupRideInfo(String sGroupId2, Context mContext2, File file) {
        getGroupRideInfo(sGroupId2, mContext2, file, false);
    }

    public static void getGroupRideInfo(final String sGroupId2, final Context mContext2, final File file, final boolean onlyCheckIsActivityEnd) {
        if (sGroupId2 == null || sGroupId2.isEmpty()) {
            sendGroupRideErrorBroadcast(mContext2, " 沒有團騎id");
            return;
        }
        String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID);
        String prefString2 = ProfileUtil.getInstance().getPrefString(ProfileUtil.LOGIN_TOKEN);
        ProfileUtil.getInstance().putPrefString(ProfileUtil.GROUP_RIDE_SEARCH_ID, sGroupId2);
        GroupRideRepository.getInstance().getGroupRideInfo(prefString, prefString2, sGroupId2).observeForever(new Observer<GroupRideInfoResponseData>() { // from class: com.brytonsport.active.service.BleService.2
            @Override // androidx.lifecycle.Observer
            public void onChanged(GroupRideInfoResponseData groupRideInfoResponseData) {
                if (groupRideInfoResponseData != null) {
                    String str = BleService.TAG;
                    Log.d(str, "團騎流程0612: 1.查詢最新團騎資訊_Success, onlyCheckIsActivityEnd: " + onlyCheckIsActivityEnd);
                    if (BleService.checkIsActivityEnd(groupRideInfoResponseData)) {
                        Log.d(BleService.TAG, "團騎流程0612: 1.查詢最新團騎資訊_Success, 團騎時間已結束: ");
                        ProfileUtil.getInstance().putPrefString(ProfileUtil.GROUP_RIDE_ID, "");
                        BleService.cleanGroupRideStorageData();
                        BleService.sendGroupRideEndBroadcast(mContext2);
                        BleService.passSettingCmdByDEVICE_CMD_SET_GROUP_RIDE_BASE(sGroupId2, (byte) 3);
                        return;
                    } else if (onlyCheckIsActivityEnd) {
                        Log.d(BleService.TAG, "團騎流程0612: 1.查詢最新團騎資訊_Success, 只檢查團騎時間沒有過期: (6/6改成要下載Fit)");
                        BleService.createGroupData(groupRideInfoResponseData);
                        BleService.sendGroupRideCheckNotEndBroadcast(mContext2);
                        return;
                    } else {
                        Log.d(BleService.TAG, "團騎流程0612: 1.查詢最新團騎資訊_Success, 繼續建立創群者資料、下載Fit等步驟: ");
                        BleService.createGroupData(groupRideInfoResponseData);
                        BleService.downLoadFitFile(mContext2, file);
                        ProfileUtil.getInstance().putPrefString(ProfileUtil.GROUP_RIDE_ID, sGroupId2);
                        return;
                    }
                }
                Log.d(BleService.TAG, "團騎流程0426: 1.查詢最新團騎資訊_Error (groupRideInfoResponseData == null)");
                BleService.sendGroupRideErrorBroadcast(mContext2, " 1.查詢最新團騎資訊_Error");
            }
        });
    }

    public static void sendGroupRideCheckNotEndBroadcast(Context mContext2) {
        if (mContext2 != null) {
            Intent intent = new Intent(SERVICE_GROUP_RIDE_IS_NOT_END);
            intent.putExtra("com.example.bluetooth.le.EXTRA_DATA", "團騎沒有過期");
            mContext2.sendBroadcast(intent);
        }
    }

    public static void sendGroupRideEndBroadcast(Context mContext2) {
        if (mContext2 != null) {
            Intent intent = new Intent(SERVICE_GROUP_RIDE_IS_END);
            intent.putExtra("com.example.bluetooth.le.EXTRA_DATA", "團騎時間已結束");
            mContext2.sendBroadcast(intent);
        }
    }

    public static void sendGroupRideErrorBroadcast(Context mContext2, String errorStr) {
        if (mContext2 != null) {
            Intent intent = new Intent(SERVICE_GROUP_RIDE_DOWNLOAD_INFO_ERROR);
            intent.putExtra("com.example.bluetooth.le.EXTRA_DATA", errorStr);
            mContext2.sendBroadcast(intent);
        }
    }

    public static void sendGroupRideSuccessBroadcast(Context mContext2) {
        if (isAnyActivityRunning(mContext2) && App.getInstance().isActive()) {
            mContext2.sendBroadcast(new Intent(SERVICE_GROUP_RIDE_DOWNLOAD_INFO_SUCCESS));
        }
        String str = TAG;
        Log.d(str, "團騎流程0612: 4.跑迴圈處理團騎成員名單 -> 完成 做下一步動作 mContext: " + mContext2);
        sendGroupRideCmd(mContext2);
    }

    public static void sendGroupRideLocationSuccessBroadcast(Context mContext2) {
        if (mContext2 != null) {
            mContext2.sendBroadcast(new Intent(SERVICE_GROUP_RIDE_DOWNLOAD_LOCATION_SUCCESS));
        }
    }

    public static void sendGroupRideLocationErrorBroadcast(Context mContext2) {
        if (mContext2 != null) {
            mContext2.sendBroadcast(new Intent(SERVICE_GROUP_RIDE_DOWNLOAD_LOCATION_ERROR));
        }
    }

    public static void sendGroupRideHistoryResult(Context mContext2, String resultStr) {
        String str = TAG;
        Log.d(str, "團騎流程0426: 7.取得團騎聊天紀錄 -> 發送通知給UI");
        Intent intent = new Intent(SERVICE_GROUP_RIDE_DOWNLOAD_HISTORY_RESULT);
        intent.putExtra("com.example.bluetooth.le.EXTRA_DATA", resultStr);
        mContext2.sendBroadcast(intent);
        if (!isStartFromDevCmd75 || isGetWavFile) {
            return;
        }
        Log.d(str, "團騎流程0426: 7.取得團騎聊天紀錄 ->  若機器有發送過CMD75 且現在沒有在執行語音，就下入群清單CMD 給裝置---");
        postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MEMBER_LIST();
    }

    public static boolean checkIsActivityEnd(GroupRideInfoResponseData groupRideInfoResponseData) {
        Date date;
        new SimpleDateFormat("yyyy/MM/dd HH:mm");
        try {
            Date date2 = new Date();
            try {
                try {
                    date = new Date(Long.parseLong(groupRideInfoResponseData.getInfo().getStartTime()) * 1000);
                } catch (Exception unused) {
                    date = new Date(Long.parseLong(groupRideInfoResponseData.getMeta().create_at) * 1000);
                }
                date2 = date;
            } catch (Exception unused2) {
            }
            int parseInt = Integer.parseInt(groupRideInfoResponseData.getInfo().getDuration());
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date2);
            calendar.add(10, parseInt);
            Date time = calendar.getTime();
            mnStartTimeUTC = (int) (date2.getTime() / 1000);
            mnDuration = parseInt;
            msEndTime = new SimpleDateFormat("yyyy/MM/dd HH:mm").format(time);
            return !time.after(new Date());
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    public static GroupTrack getGroupTrack() {
        GroupRideInfoResponseData groupRideInfoResponseData = moGroupRideInfoResponseData;
        if (groupRideInfoResponseData == null || groupRideInfoResponseData.info == null) {
            return null;
        }
        return moGroupRideInfoResponseData.info;
    }

    public static void createGroupData(GroupRideInfoResponseData responseData) {
        Log.d(TAG, "團騎流程0612: 1.查詢最新團騎資訊_Success, 建立主揪資料: ");
        moGroupRideInfoResponseData = responseData;
        aryGroupTrackMember.clear();
        GroupTrack groupTrack = responseData.info;
        if (groupTrack == null) {
            return;
        }
        GroupTrackMemberInfo groupTrackMemberInfo = new GroupTrackMemberInfo();
        groupTrackMemberInfo.setUserid(groupTrack.getId());
        groupTrackMemberInfo.setIcon(groupTrack.getIcon());
        if (groupTrack.getIcon().length() > 22) {
            byte[] decode = Base64.decode(groupTrack.getIcon().substring(22), 0);
            groupTrackMemberInfo.setBmp(BitmapFactory.decodeByteArray(decode, 0, decode.length));
        }
        groupTrackMemberInfo.setNickname(groupTrack.getNickname());
        groupTrackMemberInfo.setJoin(true);
        groupTrackMemberInfo.setId(0);
        groupTrackMemberInfo.setColorid(0);
        aryGroupTrackMember.put(groupTrackMemberInfo.getUserid(), groupTrackMemberInfo);
    }

    public static void downLoadFitFile(final Context mContext2, File fileDir) {
        Log.d(TAG, "團騎流程0612: 1.查詢最新團騎資訊_Success, 準備下載路線fit檔: ");
        if (fileDir == null) {
            sendGroupRideErrorBroadcast(mContext2, " 2.下載fit檔_Error");
        }
        downLoadFit(fileDir).observeForever(new Observer<Boolean>() { // from class: com.brytonsport.active.service.BleService.3
            @Override // androidx.lifecycle.Observer
            public void onChanged(Boolean aBoolean) {
                if (aBoolean.booleanValue()) {
                    Log.d(BleService.TAG, "團騎流程0612: 2.下載團騎fit檔_Success, 準備取得目前團騎名單");
                    String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.GROUP_RIDE_SEARCH_ID);
                    GroupTrack groupTrack = BleService.moGroupRideInfoResponseData.info;
                    if (groupTrack != null) {
                        BleService.moGroupRideInfoResponseData.info.groupid = prefString;
                        BleService.moGroupRideInfoResponseData.info.mnDuration = BleService.mnDuration;
                        BleService.moGroupRideInfoResponseData.info.msEndTime = BleService.msEndTime;
                        BleService.moGroupRideInfoResponseData.info.moaryGroupTrackMember = BleService.aryGroupTrackMember;
                        App.groupTrack = groupTrack;
                        BleService.getGroupTrackMember(prefString, mContext2);
                        return;
                    }
                    BleService.sendGroupRideErrorBroadcast(mContext2, " 2.下載fit檔_取得 groupTrack(moGroupRideInfoResponseData.info) is null");
                    return;
                }
                Log.d(BleService.TAG, "團騎流程0612: 2.下載團騎fit檔_Error");
                BleService.sendGroupRideErrorBroadcast(mContext2, " 2.下載團騎fit檔_Error");
            }
        });
    }

    public static void getGroupTrackMember(final String sGroupId2, final Context mContext2) {
        if (isSearchingVoice) {
            Log.d(TAG, "團騎流程0612: 3.查詢目前團騎成員紀錄，但正在查詢語音，跳過此步驟");
        } else {
            GroupRideRepository.getInstance().getGroupTrackMember(sGroupId2, 0, 100).observeForever(new Observer<ArrayList<GroupRideMemberResponseData>>() { // from class: com.brytonsport.active.service.BleService.4
                @Override // androidx.lifecycle.Observer
                public void onChanged(ArrayList<GroupRideMemberResponseData> groupRideMemberResponseData) {
                    if (groupRideMemberResponseData != null) {
                        Log.d(BleService.TAG, "團騎流程0612: 3.查詢目前團騎成員紀錄_Success");
                        BleService.setMemberList(groupRideMemberResponseData, mContext2, sGroupId2);
                        return;
                    }
                    Log.d(BleService.TAG, "團騎流程0612: 3.查詢目前團騎成員紀錄_Error");
                    BleService.sendGroupRideErrorBroadcast(mContext2, " 3.查詢目前團騎成員紀錄_Error");
                }
            });
        }
    }

    public static void setMemberList(ArrayList<GroupRideMemberResponseData> aryResult, Context mContext2, String sGroupId2) {
        GroupTrackMemberInfo groupTrackMemberInfo;
        Log.d(TAG, "團騎流程0612: 3.查詢目前團騎成員紀錄_Success -> 執行 4.跑迴圈處理團騎成員名單");
        for (int i = 0; i < aryResult.size(); i++) {
            GroupRideMemberResponseData groupRideMemberResponseData = aryResult.get(i);
            String action = groupRideMemberResponseData.getAction();
            GroupRideMemberResponseData.GroupMemberData payload = groupRideMemberResponseData.getPayload();
            String str = groupRideMemberResponseData.getPayload().id;
            if (action.equals("join")) {
                if (groupRideMemberResponseData.getPayload().id != null) {
                    if (aryGroupTrackMember.containsKey(str)) {
                        GroupTrackMemberInfo groupTrackMemberInfo2 = aryGroupTrackMember.get(str);
                        if (groupTrackMemberInfo2 != null) {
                            groupTrackMemberInfo2.join = true;
                            groupTrackMemberInfo2.icon = payload.icon;
                            if (groupTrackMemberInfo2.icon.length() > 22) {
                                byte[] decode = Base64.decode(groupTrackMemberInfo2.icon.substring(22, groupTrackMemberInfo2.icon.length()), 0);
                                groupTrackMemberInfo2.bmp = BitmapFactory.decodeByteArray(decode, 0, decode.length);
                            }
                            groupTrackMemberInfo2.nickname = payload.nickname;
                        }
                    } else {
                        GroupTrackMemberInfo groupTrackMemberInfo3 = new GroupTrackMemberInfo();
                        groupTrackMemberInfo3.userid = payload.id;
                        groupTrackMemberInfo3.icon = payload.icon;
                        if (groupTrackMemberInfo3.icon.length() > 22) {
                            byte[] decode2 = Base64.decode(groupTrackMemberInfo3.icon.substring(22, groupTrackMemberInfo3.icon.length()), 0);
                            groupTrackMemberInfo3.bmp = BitmapFactory.decodeByteArray(decode2, 0, decode2.length);
                        }
                        groupTrackMemberInfo3.nickname = payload.nickname;
                        groupTrackMemberInfo3.join = true;
                        groupTrackMemberInfo3.id = aryGroupTrackMember.size();
                        groupTrackMemberInfo3.colorid = aryGroupTrackMember.size() % 8;
                        aryGroupTrackMember.put(groupTrackMemberInfo3.userid, groupTrackMemberInfo3);
                    }
                }
            } else if (aryGroupTrackMember.containsKey(str) && (groupTrackMemberInfo = aryGroupTrackMember.get(str)) != null) {
                groupTrackMemberInfo.join = false;
            }
        }
        sendGroupRideSuccessBroadcast(mContext2);
        Log.d(TAG, "團騎流程0612: 4.跑迴圈處理團騎成員名單 -> 準備執行 5.取得目前所有成員位置");
        getMemberCurrent(mContext2, sGroupId2);
    }

    public static void getMemberCurrent(final Context mContext2, final String sGroupId2) {
        GroupRideRepository.getInstance().getMemberCurrent(sGroupId2).observeForever(new Observer<Boolean>() { // from class: com.brytonsport.active.service.BleService.5
            @Override // androidx.lifecycle.Observer
            public void onChanged(Boolean aBoolean) {
                if (aBoolean.booleanValue()) {
                    Log.d(BleService.TAG, "團騎流程0426: 5.取得團騎目前所有成員位置_Success -> 發送Broadcast 通知 更新成員列表和地圖");
                    BleService.sendGroupRideLocationSuccessBroadcast(mContext2);
                    Log.d(BleService.TAG, "團騎流程0426: 5.取得團騎目前所有成員位置_Success -> 準備執行 7.取得聊天紀錄");
                    BleService.getGroupTrackLatLngHistory(mContext2, sGroupId2);
                    return;
                }
                Log.d(BleService.TAG, "團騎流程0426: 5.取得團騎目前所有成員位置_Error  -> 發送Broadcast 通知 更新成員列表和地圖");
                BleService.sendGroupRideLocationErrorBroadcast(mContext2);
            }
        });
    }

    public static void getGroupTrackLatLngHistory(final Context context, String sGroupId2) {
        mContext = context;
        GroupRideRepository.getInstance().getGroupTrackLatLngHistory(sGroupId2).observeForever(new Observer<String>() { // from class: com.brytonsport.active.service.BleService.6
            @Override // androidx.lifecycle.Observer
            public void onChanged(String s) {
                Log.d(BleService.TAG, "團騎流程0426: 7.取得團騎聊天紀錄");
                BleService.sendGroupRideHistoryResult(context, s);
            }
        });
    }

    public static MutableLiveData<Boolean> downLoadFit(File fileDir) {
        final MutableLiveData<Boolean> mutableLiveData = new MutableLiveData<>();
        final String str = fileDir + File.separator + "GroupTrack.fit";
        File file = new File(str);
        if (file.exists()) {
            file.delete();
        }
        new OkHttpClient().newCall(new Request.Builder().url("https://active.brytonsport.com/" + moGroupRideInfoResponseData.info.url).build()).enqueue(new Callback() { // from class: com.brytonsport.active.service.BleService.7
            @Override // okhttp3.Callback
            public void onResponse(Call call, Response response) {
                if (response.isSuccessful()) {
                    try {
                        BufferedInputStream bufferedInputStream = new BufferedInputStream(response.body().byteStream());
                        FileOutputStream fileOutputStream = new FileOutputStream(str);
                        byte[] bArr = new byte[1024];
                        while (true) {
                            int read = bufferedInputStream.read(bArr);
                            if (read != -1) {
                                fileOutputStream.write(bArr, 0, read);
                            } else {
                                fileOutputStream.flush();
                                fileOutputStream.close();
                                bufferedInputStream.close();
                                mutableLiveData.postValue(true);
                                return;
                            }
                        }
                    } catch (Exception e) {
                        mutableLiveData.postValue(false);
                        Log.d(toString(), e.toString());
                    }
                } else {
                    mutableLiveData.postValue(false);
                    String str2 = BleService.TAG;
                    Log.d(str2, "團騎流程0426: 下載GR Fit檔 response.code() -> " + response.code());
                }
            }

            @Override // okhttp3.Callback
            public void onFailure(Call call, IOException e) {
                mutableLiveData.postValue(false);
                String str2 = BleService.TAG;
                Log.d(str2, "團騎流程0426: 下載GR Fit檔 onFailure() -> " + e.toString());
            }
        });
        return mutableLiveData;
    }

    public static void sendGroupRideCmd(Context context) {
        String str = TAG;
        Log.d(str, "團騎流程0426 -> 藍芽連線成功後傳送團騎資訊給機器: sendGroupRideCmd 狀態 devStartGroupRide: " + devStartGroupRide + ", isSendingCmd: " + isSendingCmd);
        mbDevExist = true;
        if (isSendingCmd || isStartFromDevCmd75) {
            Log.d(str, "團騎流程0426 -> return");
            return;
        }
        isSendingCmd = true;
        msCurpassSettingCmd = ConstSettingChannel.DEVICE_CMD_GET_GROUP_RIDE_BASE;
        GroupRideInfoResponseData groupRideInfoResponseData = moGroupRideInfoResponseData;
        if (groupRideInfoResponseData == null || groupRideInfoResponseData.getInfo() == null) {
            Log.d(str, "團騎流程0426 -> return moGroupRideInfoResponseData: " + moGroupRideInfoResponseData + ", moGroupRideInfoResponseData.getInfo(): " + moGroupRideInfoResponseData.getInfo());
            return;
        }
        passSettingCmdByDEVICE_CMD_GET_GROUP_RIDE_BASE(context, moGroupRideInfoResponseData.getInfo().mnStartTimeUTC, moGroupRideInfoResponseData.getInfo().mnDuration);
    }

    public static void passSettingCmdByDEVICE_CMD_GET_GROUP_RIDE_BASE(Context context, int timestamp, int duration) {
        Date date;
        Log.d(TAG, "團騎流程0426: CMD1 get GROUP_RIDE_BASE 告知機器開始時間與小時(cmd 74): ");
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
        simpleDateFormat.setTimeZone(TimeZone.getTimeZone("Asia/Taipei"));
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy/MM/dd HH:mm");
        simpleDateFormat2.setTimeZone(TimeZone.getTimeZone("GMT"));
        long j = 0;
        try {
            Date date2 = new Date();
            try {
                try {
                    date = new Date(Long.parseLong(moGroupRideInfoResponseData.getInfo().startTime) * 1000);
                } catch (Exception unused) {
                    date = new Date(Long.parseLong(moGroupRideInfoResponseData.getMeta().create_at) * 1000);
                }
                date2 = date;
            } catch (Exception unused2) {
            }
            Date parse = simpleDateFormat2.parse(simpleDateFormat.format(date2));
            if (parse != null) {
                j = parse.getTime() / 1000;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(ConstSettingChannel.DEVICE_CMD_GET_GROUP_RIDE_BASE);
        jSONArray.put(j);
        jSONArray.put(duration);
        bleRepo.passSettingCommand(jSONArray);
        Log.e(TAG, "團騎流程 -> 下: Cmd 1 告知機器開始時間與小時 DEVICE_CMD_GET_GROUP_RIDE_BASE");
    }

    public static void passSettingCmdByDEVICE_CMD_SET_GROUP_RIDE_BASE(String sGroupId2, byte nGroupAction) {
        String str = TAG;
        Log.d(str, "團騎流程0426: CMD2 / CMD10 set GROUP_RIDE_BASE 告知機器(cmd 74): ");
        if (sGroupId2 == null && ((sGroupId2 = ProfileUtil.getInstance().getPrefString(ProfileUtil.GROUP_RIDE_ID)) == null || sGroupId2.isEmpty())) {
            Log.d(str, "團騎流程0426: CMD2 / CMD10 sGroupId == null");
            return;
        }
        if (nGroupAction == 0) {
            sGroupId2 = "";
        } else {
            sGroupId2.getBytes();
        }
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(ConstSettingChannel.DEVICE_CMD_SET_GROUP_RIDE_BASE);
        jSONArray.put((int) nGroupAction);
        jSONArray.put(sGroupId2);
        jSONArray.put(5);
        bleRepo.passSettingCommand(jSONArray);
    }

    public static Boolean postDataBySEND_FILE_TYPE_PLAN_TRIP(String sFile) {
        String str = TAG;
        Log.d(str, "團騎流程0426: CMD3-4 傳送GR路線到機器: ");
        Log.d(str, "0612 連線動作: CMD3-4 傳送GR路線到機器 開始: , 時間: " + new Date());
        File file = new File(sFile);
        if (file.exists()) {
            byte[] bArr = new byte[(int) file.length()];
            FileInputStream fileInputStream = null;
            try {
                try {
                    FileInputStream fileInputStream2 = new FileInputStream(file);
                    try {
                        if (fileInputStream2.read(bArr) == -1) {
                            fileInputStream2.close();
                            try {
                                fileInputStream2.close();
                            } catch (IOException unused) {
                            }
                            return false;
                        }
                        try {
                            fileInputStream2.close();
                        } catch (IOException unused2) {
                        }
                        bleRepo.postData(11, bArr);
                        return true;
                    } catch (FileNotFoundException unused3) {
                        fileInputStream = fileInputStream2;
                        if (fileInputStream != null) {
                            try {
                                fileInputStream.close();
                            } catch (IOException unused4) {
                            }
                        }
                        if (fileInputStream != null) {
                            try {
                                fileInputStream.close();
                            } catch (IOException unused5) {
                            }
                        }
                        return false;
                    } catch (IOException unused6) {
                        fileInputStream = fileInputStream2;
                        if (fileInputStream != null) {
                            try {
                                fileInputStream.close();
                            } catch (IOException unused7) {
                            }
                        }
                        if (fileInputStream != null) {
                            try {
                                fileInputStream.close();
                            } catch (IOException unused8) {
                            }
                        }
                        return false;
                    } catch (Throwable th) {
                        th = th;
                        fileInputStream = fileInputStream2;
                        if (fileInputStream != null) {
                            try {
                                fileInputStream.close();
                            } catch (IOException unused9) {
                            }
                        }
                        throw th;
                    }
                } catch (FileNotFoundException unused10) {
                } catch (IOException unused11) {
                }
            } catch (Throwable th2) {
                th = th2;
            }
        }
        return false;
    }

    public static void passSettingCmdByDEVICE_CMD_SET_PLAN_TRIP_NAME(String sGroupName) {
        Log.d(TAG, "團騎流程0426: CMD5 傳送GR路線名稱到機器: ");
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(ConstSettingChannel.DEVICE_CMD_SET_PLAN_TRIP_NAME);
        jSONArray.put(sGroupName);
        bleRepo.passSettingCommand(jSONArray);
    }

    public static int postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MEMBER_LIST() {
        String str = TAG;
        Log.d(str, "團騎流程0426: CMD6-7 傳送成員(入群者)清單到機器: ");
        if (getGroupTrack() == null) {
            Log.d(str, "團騎流程0426: CMD6-7 傳送成員(入群者)清單到機器: BleService.getGroupTrack() == null");
            return -1;
        }
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bArr = {(byte) getGroupTrack().groupName.getBytes().length};
            byteArrayOutputStream.write(bArr, 0, 1);
            byte[] bytes = getGroupTrack().groupName.getBytes();
            byteArrayOutputStream.write(bytes, 0, bytes.length);
            int i = 0;
            for (int i2 = 0; i2 < getGroupTrack().moaryGroupTrackMember.size(); i2++) {
                if (getGroupTrack().moaryGroupTrackMember.valueAt(i2).join.booleanValue()) {
                    i++;
                }
            }
            bArr[0] = (byte) i;
            byteArrayOutputStream.write(bArr, 0, 1);
            String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID);
            if (getGroupTrack().moaryGroupTrackMember.containsKey(prefString)) {
                bArr[0] = (byte) getGroupTrack().moaryGroupTrackMember.get(prefString).id;
                byteArrayOutputStream.write(bArr, 0, 1);
                for (int i3 = 0; i3 < getGroupTrack().moaryGroupTrackMember.size(); i3++) {
                    GroupTrackMemberInfo valueAt = getGroupTrack().moaryGroupTrackMember.valueAt(i3);
                    if (valueAt.join.booleanValue()) {
                        bArr[0] = (byte) valueAt.id;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        bArr[0] = 1;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        bArr[0] = (byte) valueAt.colorid;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        bArr[0] = (byte) valueAt.nickname.getBytes().length;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        byte[] bytes2 = valueAt.nickname.getBytes();
                        byteArrayOutputStream.write(bytes2, 0, bytes2.length);
                    }
                }
                byteArrayOutputStream.flush();
                bleRepo.postData(17, byteArrayOutputStream.toByteArray());
                byteArrayOutputStream.close();
                return 0;
            }
            Log.d(TAG, "團騎流程0426: CMD6-7 傳送成員(入群者)清單到機器: !BleService.getGroupTrack().moaryGroupTrackMember.containsKey(sUserID)");
            return -1;
        } catch (Exception unused) {
            isSendingCmd = false;
            Log.d(TAG, "團騎流程0426: CMD6-7 傳送成員(入群者)清單到機器: isSendingCmd = false");
            return -2;
        }
    }

    public static Boolean requestDataByREQUEST_FILE_TYPE_GROUP_TRACK_MSG() {
        Log.d(TAG, "團騎流程0426: CMD8 從機器取得罐頭訊息清單: ");
        bleRepo.requestData(2);
        return true;
    }

    public static ArrayList<QuickReply> processRequestByREQUEST_FILE_TYPE_GROUP_TRACK_MSG(byte[] requestDataReturn) {
        ArrayList<QuickReply> arrayList = new ArrayList<>();
        if (requestDataReturn.length == 0) {
            return arrayList;
        }
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(requestDataReturn);
        byte[] bArr = new byte[1];
        byte[] bArr2 = new byte[256];
        try {
            byteArrayInputStream.read(bArr);
            byte b = bArr[0];
            for (int i = 0; i < b; i++) {
                byteArrayInputStream.read(bArr);
                byte b2 = bArr[0];
                byteArrayInputStream.read(bArr);
                byte b3 = bArr[0];
                byteArrayInputStream.read(bArr2, 0, b3);
                String str = new String(bArr2, 0, (int) b3);
                if (b2 != 1 && b2 != 2) {
                    arrayList.add(new QuickReply(false, b2, str));
                }
                arrayList.add(new QuickReply(true, b2, str));
            }
            return arrayList;
        } catch (Exception unused) {
            isSendingCmd = false;
            return null;
        }
    }

    public static Boolean postDataBypostDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MESSAGE_CAN(ArrayList<QuickReply> quickReplies2) {
        Log.d(TAG, "團騎流程0426: CMD9 傳送罐頭訊息給機器: ");
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte size = (byte) quickReplies2.size();
            byte[] bArr = {size};
            byteArrayOutputStream.write(bArr, 0, 1);
            for (int i = 0; i < size; i++) {
                QuickReply quickReply = quickReplies2.get(i);
                bArr[0] = (byte) quickReply.id;
                byteArrayOutputStream.write(bArr, 0, 1);
                byte length = (byte) quickReply.message.getBytes().length;
                bArr[0] = length;
                byteArrayOutputStream.write(bArr, 0, 1);
                byteArrayOutputStream.write(quickReply.message.getBytes(), 0, length);
            }
            byteArrayOutputStream.flush();
            bleRepo.postData(20, byteArrayOutputStream.toByteArray());
            byteArrayOutputStream.close();
            return true;
        } catch (Exception unused) {
            isSendingCmd = false;
            return false;
        }
    }

    public static void sendCommendTen() {
        if (isStartFromDevCmd75 || lastCmd75State == 2) {
            if (lastCmd75State == 2) {
                Log.d(TAG, "團騎流程0426: CMD10 傳送檔案給機器完成，告知機器可以啟動Group Ride，但機器已經手動結束GR，不用再次下給機器");
                return;
            } else {
                Log.d(TAG, "團騎流程0426: CMD10 傳送檔案給機器完成，告知機器可以啟動Group Ride，但機器已經啟動GR，不用再次下給機器");
                return;
            }
        }
        String str = TAG;
        Log.d(str, "團騎流程0426: CMD10 傳送檔案給機器完成，告知機器可以啟動Group Ride: ");
        msCurpassSettingCmd = ConstSettingChannel.DEVICE_CMD_SET_GROUP_RIDE_BASE;
        if (System.currentTimeMillis() / 1000 < mnStartTimeUTC) {
            mnCurpassSettingCmdGroupAction = (byte) 1;
        } else {
            mnCurpassSettingCmdGroupAction = (byte) 2;
        }
        if (getGroupTrack() != null) {
            passSettingCmdByDEVICE_CMD_SET_GROUP_RIDE_BASE(getGroupTrack().groupid, mnCurpassSettingCmdGroupAction);
            Log.e(str, "團騎流程 -> 下: Cmd 10 DEVICE_CMD_SET_GROUP_RIDE_BASE 開始時間狀態: " + ((int) mnCurpassSettingCmdGroupAction));
            return;
        }
        Log.e(str, "團騎流程 -> 下: Cmd 10 DEVICE_CMD_SET_GROUP_RIDE_BASE Error 開始時間狀態: " + ((int) mnCurpassSettingCmdGroupAction));
    }

    public Boolean postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_INACTIVE_MEMBER_LIST() {
        Log.d(TAG, "團騎流程0426: CMD2 傳送成員(離群者)清單到機器(Detail頁): ");
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bArr = {(byte) getGroupTrack().groupName.getBytes().length};
            byteArrayOutputStream.write(bArr, 0, 1);
            byte[] bytes = getGroupTrack().groupName.getBytes();
            byteArrayOutputStream.write(bytes, 0, bytes.length);
            int i = 0;
            for (int i2 = 0; i2 < getGroupTrack().moaryGroupTrackMember.size(); i2++) {
                if (!getGroupTrack().moaryGroupTrackMember.valueAt(i2).join.booleanValue()) {
                    i++;
                }
            }
            bArr[0] = (byte) i;
            byteArrayOutputStream.write(bArr, 0, 1);
            String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID);
            if (getGroupTrack().moaryGroupTrackMember.containsKey(prefString)) {
                bArr[0] = (byte) getGroupTrack().moaryGroupTrackMember.get(prefString).id;
                byteArrayOutputStream.write(bArr, 0, 1);
                for (int i3 = 0; i3 < getGroupTrack().moaryGroupTrackMember.size(); i3++) {
                    GroupTrackMemberInfo valueAt = getGroupTrack().moaryGroupTrackMember.valueAt(i3);
                    if (!valueAt.join.booleanValue()) {
                        bArr[0] = (byte) valueAt.id;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        bArr[0] = 0;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        bArr[0] = (byte) valueAt.colorid;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        bArr[0] = (byte) valueAt.nickname.getBytes().length;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        byte[] bytes2 = valueAt.nickname.getBytes();
                        byteArrayOutputStream.write(bytes2, 0, bytes2.length);
                    }
                }
                byteArrayOutputStream.flush();
                bleRepo.postData(21, byteArrayOutputStream.toByteArray());
                byteArrayOutputStream.close();
                return true;
            }
            return false;
        } catch (Exception unused) {
            return false;
        }
    }

    public Boolean postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MEMBER_UPDATE() {
        short s;
        Log.d(TAG, "團騎流程0426: CMD3 傳送成員的位置速度等資訊到機器上(Detail頁): ");
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bArr = new byte[1];
            int i = 0;
            for (int i2 = 0; i2 < getGroupTrack().moaryGroupTrackMember.size(); i2++) {
                if (getGroupTrack().moaryGroupTrackMember.valueAt(i2).join.booleanValue()) {
                    i++;
                }
            }
            bArr[0] = (byte) i;
            byteArrayOutputStream.write(bArr, 0, 1);
            long longValue = TimeUtilByLee.getTimeStampPlusZoneBySec(System.currentTimeMillis()).longValue();
            byteArrayOutputStream.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt((int) longValue).array(), 0, 4);
            for (int i3 = 0; i3 < getGroupTrack().moaryGroupTrackMember.size(); i3++) {
                GroupTrackMemberInfo valueAt = getGroupTrack().moaryGroupTrackMember.valueAt(i3);
                if (valueAt.join.booleanValue()) {
                    bArr[0] = (byte) valueAt.id;
                    byteArrayOutputStream.write(bArr, 0, 1);
                    byteArrayOutputStream.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putFloat((float) valueAt.lat).array(), 0, 4);
                    byteArrayOutputStream.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putFloat((float) valueAt.lng).array(), 0, 4);
                    byteArrayOutputStream.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putFloat((float) valueAt.distance).array(), 0, 4);
                    if (valueAt.speed > 0.0d && valueAt.speed < 150.0d) {
                        s = (short) (valueAt.speed * 10.0d);
                        byteArrayOutputStream.write(ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort(s).array(), 0, 2);
                        bArr[0] = (byte) valueAt.devGroupRideState;
                        byteArrayOutputStream.write(bArr, 0, 1);
                        long j = valueAt.timestamp / 1000;
                        String str = TAG;
                        Log.d(str, "團騎流程 postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MEMBER_UPDATE timestamp: " + j + ", nutc: " + longValue);
                        byteArrayOutputStream.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt((int) j).array(), 0, 4);
                    }
                    s = 0;
                    byteArrayOutputStream.write(ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort(s).array(), 0, 2);
                    bArr[0] = (byte) valueAt.devGroupRideState;
                    byteArrayOutputStream.write(bArr, 0, 1);
                    long j2 = valueAt.timestamp / 1000;
                    String str2 = TAG;
                    Log.d(str2, "團騎流程 postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MEMBER_UPDATE timestamp: " + j2 + ", nutc: " + longValue);
                    byteArrayOutputStream.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt((int) j2).array(), 0, 4);
                }
            }
            byteArrayOutputStream.flush();
            bleRepo.postData(18, byteArrayOutputStream.toByteArray());
            byteArrayOutputStream.close();
            return true;
        } catch (Exception unused) {
            return false;
        }
    }

    public Boolean postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MESSAGE_DATA() {
        String str = TAG;
        Log.d(str, "團騎流程0426: CMD4 傳送成員的聊天紀錄到機器上(Detail頁): ");
        try {
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            byte[] bArr = new byte[1];
            int size = GroupRideRepository.getInstance().messages.size() - mnPreMessagesSize;
            int i = groupRideMaxMsg;
            if (size <= i) {
                i = GroupRideRepository.getInstance().messages.size() - mnPreMessagesSize;
            }
            Log.d(str, "團騎流程 postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MESSAGE_DATA mnPreMessagesSize: " + mnPreMessagesSize + ", messagescnt: " + i + ", messages.size(): " + GroupRideRepository.getInstance().messages.size());
            bArr[0] = (byte) i;
            byteArrayOutputStream.write(bArr, 0, 1);
            int size2 = GroupRideRepository.getInstance().messages.size() - i;
            for (int size3 = GroupRideRepository.getInstance().messages.size() - 1; size3 >= size2; size3--) {
                Message message = GroupRideRepository.getInstance().messages.get(size3);
                GroupTrackMemberInfo groupTrackMemberInfo = getGroupTrack().moaryGroupTrackMember.get(message.userid);
                if (groupTrackMemberInfo != null) {
                    bArr[0] = (byte) groupTrackMemberInfo.id;
                    byteArrayOutputStream.write(bArr, 0, 1);
                    bArr[0] = (byte) message.message.getBytes().length;
                    byteArrayOutputStream.write(bArr, 0, 1);
                    byte[] bytes = message.message.getBytes();
                    byteArrayOutputStream.write(bytes, 0, bytes.length);
                    byteArrayOutputStream.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt((int) TimeUtilByLee.getTimeStampPlusZoneBySec(message.timestamp).longValue()).array(), 0, 4);
                }
            }
            byteArrayOutputStream.flush();
            bleRepo.postData(19, byteArrayOutputStream.toByteArray());
            byteArrayOutputStream.close();
            mnPreMessagesSize = GroupRideRepository.getInstance().messages.size();
            return true;
        } catch (Exception unused) {
            return false;
        }
    }

    private static IntentFilter makeGattUpdateIntentFilter() {
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(BleUtil.ACTION_BLUETOOTH_STATE_CHANGE);
        intentFilter.addAction(BleUtil.ACTION_CONNECTED_PERIPHERAL);
        intentFilter.addAction(BleUtil.ACTION_CONNECTION_FAILED);
        intentFilter.addAction(BleUtil.ACTION_DISCONNECTED_PERIPHERAL);
        intentFilter.addAction(BleUtil.ACTION_NOTIFICATION_STATE_SETTING_CHANNEL);
        intentFilter.addAction(BleUtil.ACTION_BONDING_STARTED);
        intentFilter.addAction(BleUtil.ACTION_BONDING_SUCCEEDED);
        intentFilter.addAction(BleUtil.ACTION_BONDING_FAILED);
        intentFilter.addAction(BleUtil.ACTION_BONDING_LOST);
        intentFilter.addAction(BleUtil.ACTION_SERVICES_DISCOVERED);
        intentFilter.addAction(SampleGattAttributes.ACTION_READ_DEVICE_INFO);
        intentFilter.addAction(SampleGattAttributes.ACTION_GET_FILE_LIST);
        intentFilter.addAction(SampleGattAttributes.ACTION_GET_FILE);
        intentFilter.addAction(SampleGattAttributes.ACTION_GET_FILE_RANGE);
        intentFilter.addAction(SampleGattAttributes.ACTION_GET_FILE_RANGE_PART_TWO);
        intentFilter.addAction(SampleGattAttributes.ACTION_REQUEST_DATA);
        intentFilter.addAction(SampleGattAttributes.ACTION_POST_DATA);
        intentFilter.addAction(SampleGattAttributes.ACTION_CRC_ERROR);
        intentFilter.addAction(ConstSettingChannel.ACTION_SETTING_COMMAND_RETURN);
        intentFilter.addAction(SampleGattAttributes.ACTION_GET_FILE_RANGE_START_TIME);
        intentFilter.addAction(SampleGattAttributes.ACTION_GET_FILE_RANGE_DATA_SIZE);
        intentFilter.addAction(SERVICE_GROUP_RIDE_IS_END);
        intentFilter.addAction(SERVICE_GROUP_RIDE_IS_NOT_END);
        intentFilter.addAction(SERVICE_GROUP_RIDE_DOWNLOAD_INFO_ERROR);
        intentFilter.addAction(SERVICE_GROUP_RIDE_DOWNLOAD_INFO_SUCCESS);
        return intentFilter;
    }

    public void processDeviceInfo(String macAddress, JSONObject resultJsonObj) {
        if (resultJsonObj != null) {
            try {
                Device device = new Device();
                JSONArray jSONArray = resultJsonObj.getJSONArray("result");
                for (int i = 0; i < jSONArray.length(); i++) {
                    JSONArray jSONArray2 = jSONArray.getJSONArray(i);
                    String string = jSONArray2.getString(0);
                    boolean z = true;
                    if (string.equals("CP")) {
                        String string2 = jSONArray2.getString(1);
                        device.capability = string2;
                        int parseInt = Integer.parseInt(string2.split(ToStringHelper.COMMA_SEPARATOR)[0], 16);
                        boolean z2 = (parseInt & 2048) > 0;
                        DeviceInfo.ftp = z2 && (parseInt & 1) > 0;
                        DeviceInfo.workout = z2 && (parseInt & 2) > 0;
                        DeviceInfo.plantrip = z2 && (parseInt & 4) > 0;
                        DeviceInfo.setting = z2 && (parseInt & 8) > 0;
                        DeviceInfo.fwUpt = z2 && (parseInt & 16) > 0;
                        DeviceInfo.alt = z2 && (parseInt & 32) > 0;
                        DeviceInfo.wifi = z2 && (parseInt & 64) > 0;
                        DeviceInfo.fastBt = z2 && (parseInt & 128) > 0;
                        DeviceInfo.grid = z2 && (parseInt & 256) > 0;
                        if (!z2 || (parseInt & 512) <= 0) {
                            z = false;
                        }
                        DeviceInfo.cap = z;
                        DeviceInfo.chgRxTx = false;
                        DeviceInfo.cmd = new HashMap();
                    } else if (string.equals("UD")) {
                        device.uuid = jSONArray2.getString(1);
                    } else if (string.equals("IV")) {
                        device.firmware = jSONArray2.getString(1);
                    } else if (string.equals("MN")) {
                        String string3 = jSONArray2.getString(1);
                        String str = TAG;
                        Log.d(str, "processDeviceInfo MN 裝置名稱: " + string3);
                        if (!string3.toLowerCase().contains("s=")) {
                            device.deviceName = string3;
                        }
                    }
                }
                device.macAddress = macAddress;
                updateDeviceInfoToDb(device);
                broadcastUpdate(SERVICE_READ_DEVICE_INFO, device);
                checkNotifySettingChannel(macAddress);
                runHandshakeWatchDog(device.uuid, device.firmware);
            } catch (JSONException e) {
                Log.d(TAG, e.toString());
            }
        }
    }

    private void runHandshakeWatchDog(final String uuid, final String ver) {
        this.handshakeStartTime = new Date().getTime();
        if (FeatureUtil.isSupport(FeatureUtil.FeatureType.Handshake, uuid, true) > 0) {
            Thread thread = this.mHandshake;
            if (thread != null) {
                thread.interrupt();
            }
            Thread thread2 = new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService.8
                @Override // java.lang.Runnable
                public void run() {
                    try {
                        Thread.sleep(30000L);
                        Log.d(BleService.TAG, "Handshake 設定超時");
                        BleService.this.broadcastBooleanData(BleService.SERVICE_DEVICE_HANDSHAKE_TIMEOUT, true);
                        FirebaseCustomUtil firebaseCustomUtil = FirebaseCustomUtil.getInstance();
                        firebaseCustomUtil.setBleLogMessage("userId(" + ((String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID)) + ") - uuid(" + uuid + ") ver(" + ver + ") Handshake 設定超時(30秒)");
                    } catch (Exception unused) {
                    }
                }
            });
            this.mHandshake = thread2;
            thread2.start();
        }
    }

    private void updateDeviceInfoToDb(Device connectDevice) {
        this.deviceRepository.updateDeviceInfo(connectDevice);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void processGetFileListReturn(byte[] fileList) {
        final ArrayList arrayList = new ArrayList();
        try {
            JSONArray jSONArray = new JSONObject(DataUtil.getFileListResult(fileList)).getJSONArray("result");
            for (int i = 0; i < jSONArray.length(); i++) {
                JSONObject jSONObject = (JSONObject) jSONArray.get(i);
                FileSummary fileSummary = new FileSummary();
                fileSummary.setFileId(jSONObject.getInt("fileId"));
                fileSummary.setRunTime(jSONObject.getInt("activityTime"));
                fileSummary.setRunDistance(jSONObject.getInt("activityDist"));
                fileSummary.setWorkout(jSONObject.getInt("isWorkout"));
                fileSummary.setWorkoutId(jSONObject.getInt("workoutId"));
                fileSummary.setSportType(jSONObject.getInt("sportType"));
                fileSummary.setFileIdToTimeStamp(jSONObject.getString("fileIdToTimeStamp"));
                fileSummary.setPayloadSize(jSONObject.getInt("payloadSize"));
                arrayList.add(fileSummary);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        Log.d("Leigh1111", "processGetFileListReturn getFitFileList: " + arrayList.size());
        new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda7
            @Override // java.lang.Runnable
            public final void run() {
                BleService.this.m131x4b8444c3(arrayList);
            }
        }).start();
    }

    /* renamed from: lambda$processGetFileListReturn$3$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m131x4b8444c3(List list) {
        boolean z;
        this.fileSummaryList = new ArrayList();
        List<FileIdHistoryEntity> loadFileIdHistoryListByType = this.fileIdHistoryRepository.loadFileIdHistoryListByType(FileIdHistoryUtil.TYPE_GET_FIT_FILE);
        for (int i = 0; i < list.size(); i++) {
            FileSummary fileSummary = (FileSummary) list.get(i);
            Iterator<FileIdHistoryEntity> it = loadFileIdHistoryListByType.iterator();
            while (true) {
                if (it.hasNext()) {
                    if (String.valueOf(fileSummary.getFileId()).equals(it.next().getFileId())) {
                        z = true;
                        break;
                    }
                } else {
                    z = false;
                    break;
                }
            }
            List<FileSummary> list2 = this.fileSummaryList;
            if (list2 != null && !z) {
                list2.add(fileSummary);
            }
        }
        this.processActivityTotalCount = this.fileSummaryList.size();
        this.choiceFileListIndex = 0;
        this.isProcessActivityComplete = false;
        this.hasBefore2016Fit = false;
        checkFileListToGeFile();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void processGetFileReturn(byte[] fileData, String jsonStr) {
        createFileWithByte(fileData, UsbFile.separator + ((String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID)) + "/fit/unsave", this.choiceFileId + ".fit");
        Log.d("Leigh1111", "processGetFileReturn: 第" + this.choiceFileListIndex + "筆 fit 存到unsave 資料夾");
        int i = this.choiceFileId;
        Log.d("Leigh1111", "processGetFileReturn choiceFileId: " + this.choiceFileId);
        processFitDecodeOkAndAddNotification(i);
        this.choiceFileListIndex = this.choiceFileListIndex + 1;
        checkFileListToGeFile();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void processGetFileRangeReturn(byte[] fileData, String jsonStr) {
        byte[] bArr;
        if (!SampleGattAttributes.isGetFileRangePhase2) {
            try {
                this.readDeviceInfoArray = Base64.decode(new JSONObject(jsonStr).getString("result"), 10);
            } catch (JSONException e) {
                e.printStackTrace();
            }
            if (this.cmd17FirstGetFileSize) {
                byte[] bArr2 = this.readDeviceInfoArray;
                int intValue = new BigInteger(new byte[]{bArr2[0], bArr2[1], bArr2[2], bArr2[3]}).intValue();
                String str = TAG;
                Log.d(str, "onCharacteristicChanged (data channel) CommandId == 17 Total dataSize = " + intValue + "[" + (((int) bArr[0]) + ", " + ((int) bArr[1]) + ", " + ((int) bArr[2]) + ", " + ((int) bArr[3])) + "]");
                this.readDeviceInfoArray = new byte[intValue];
                this.getFileRangeTotalArray = new byte[0];
                this.cmd17FirstGetFileSize = false;
                if (isGetWavFile) {
                    this.voiceGetFileRangeOffset = 0;
                    this.voiceGetFileRangeChunkSize = 3700;
                    getFileRange(0, (byte) 1, 0, 3700);
                    return;
                }
                return;
            }
            this.voiceDone = false;
            if (isGetWavFile) {
                byte[] bArr3 = this.readDeviceInfoArray;
                String str2 = new String(Arrays.copyOfRange(bArr3, 3689, bArr3.length));
                if (str2.trim().equals("BRYTONSLEEP")) {
                    int i = this.voiceGetFileRangeOffset + 3700;
                    this.voiceGetFileRangeOffset = i;
                    getFileRange(0, (byte) 1, i, this.voiceGetFileRangeChunkSize);
                } else if (str2.trim().equals("BRYTONVOICE")) {
                    this.voiceDone = true;
                    isGetWavFile = false;
                } else {
                    int i2 = this.voiceGetFileRangeOffset + 3700;
                    this.voiceGetFileRangeOffset = i2;
                    getFileRange(0, (byte) 1, i2, this.voiceGetFileRangeChunkSize);
                }
            }
            this.getFileRangeOffset += this.getFileRangeChunkSize;
            this.getFileRangeTotalArray = ParserUtil.joinByteArray(this.getFileRangeTotalArray, this.readDeviceInfoArray);
            if (this.voiceDone) {
                SampleGattAttributes.isGetFileRangePhase2 = true;
                JSONObject jSONObject = this.handshakePayloadObj;
                if (jSONObject != null) {
                    setBbcpRxTx(jSONObject);
                }
                WavUtil wavUtil = new WavUtil();
                byte[] create = wavUtil.create(wavUtil.decode(this.getFileRangeTotalArray));
                String str3 = TAG;
                Log.d(str3, "團騎流程 語音檔收完 大小: " + this.getFileRangeTotalArray.length);
                createFileWithByte(create, UsbFile.separator, this.voiceFileName);
                BleUtil.getInstance().setDevNotify(0);
                File filesDir = getFilesDir();
                if (!new File(filesDir + UsbFile.separator + this.voiceFileName).exists() || Build.VERSION.SDK_INT < 26) {
                    return;
                }
                try {
                    String replaceAll = Base64.encodeToString(Files.readAllBytes(Paths.get(filesDir + UsbFile.separator + this.voiceFileName, new String[0])), 0).replaceAll("\n", "");
                    this.speech2textLangCode = SettingLanguageUtil.getVoiceLanguageId();
                    Log.d(str3, "團騎流程 語音轉文字: speech2textLangCode = " + this.speech2textLangCode);
                    if (isNetworkConnect()) {
                        speech2text(this.speech2textLangCode, replaceAll);
                    } else {
                        speech2textNoNetworkAction();
                    }
                    return;
                } catch (IOException e2) {
                    e2.printStackTrace();
                    return;
                }
            }
            return;
        }
        try {
            if (this.devSptLogCompress && this.appSptLogCompress) {
                String str4 = TAG;
                Log.d(str4, "onReceive: 解壓縮前 size -> " + fileData.length);
                fileData = GZipUtils.uncompress(fileData);
                Log.d(str4, "onReceive: 解壓縮後 size -> " + fileData.length);
            }
        } catch (IOException e3) {
            e3.printStackTrace();
        }
        createFileWithByte(fileData, UsbFile.separator + ((String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID)) + "/fit/unsave", this.choiceFileId + ".fit");
        Log.d(TAG, "注意看 processGetFileRangeReturn: 第" + this.choiceFileListIndex + "筆 fit 存到unsave 資料夾 檔名: " + this.choiceFileId + ".fit");
        BleUtil.getInstance().setBtNotifyDev(this.choiceFileId);
        processFitDecodeOkAndAddNotification(this.choiceFileId);
        this.choiceFileListIndex = this.choiceFileListIndex + 1;
        checkFileListToGeFile();
    }

    private void processFitDecodeOkAndAddNotification(final int fileId) {
        final String str = (String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID);
        this.fileIdHistoryRepository.addNewHistory(FileIdHistoryUtil.TYPE_GET_FIT_FILE, String.valueOf(fileId));
        Log.d("Leigh1111", "驚嘆號 processFitDecodeOkAndAddNotification fileId: " + fileId);
        App.actFitDecodeHistory.add(String.valueOf(fileId));
        runOnBgThread(new Runnable() { // from class: com.brytonsport.active.service.BleService.9
            @Override // java.lang.Runnable
            public void run() {
                String str2;
                Log.d("Leigh1111", "驚嘆號 decode fit 看看  fileId: " + fileId);
                Log.d(BleService.TAG, "同步活動紀錄 decode fileId: " + fileId);
                BrytonActivity.DecodeResult decodeActivityFitForService = BleService.this.activityRepository.decodeActivityFitForService(UsbFile.separator + str + "/fit/unsave", String.valueOf(fileId));
                if (decodeActivityFitForService == BrytonActivity.DecodeResult.SUCCESS) {
                    Log.d("Leigh1111", "驚嘆號 活動紀錄" + fileId + "上傳decode fit 成功: ");
                    ActivityFileUtil.removeDecodeFailedHistory2Pref(String.valueOf(fileId));
                    if (BleService.this.choiceFileId < 1451606400) {
                        str2 = "(" + TimeUtilByLee.getDateFormatForResultList(fileId) + ")";
                        BleService.this.hasBefore2016Fit = true;
                    } else {
                        str2 = "";
                    }
                    String str3 = str2;
                    BleService.this.notificationRepository.insertForFitSync(new NotificationEntity(NotificationConstantsUtil.CATEGORY_UPLOAD_FIT_NOT_UPLOAD_TO_SERVER, ParserUtil.fileIdToFormatString(fileId) + ".fit", str3, new Date().getTime(), NotificationConstantsUtil.NOTIFICATION_EXPIRE_FIT, fileId));
                } else if (decodeActivityFitForService == BrytonActivity.DecodeResult.OUT_OF_MEMERY) {
                    Log.d("Leigh1111", "驚嘆號 活動紀錄choiceFileId: " + BleService.this.choiceFileId + " 遇到OOM 則下次再試 fileId: " + fileId);
                    App.actFitDecodeHistory.remove(String.valueOf(fileId));
                } else {
                    Log.d("Leigh1111", "驚嘆號 活動紀錄choiceFileId: " + BleService.this.choiceFileId + " 上傳decode fit 失敗 fileId: " + fileId);
                    BleService.this.notificationRepository.insertForFitSync(new NotificationEntity(NotificationConstantsUtil.CATEGORY_UPLOAD_FIT_BAD_TRACK, ParserUtil.fileIdToFormatString(fileId) + ".fit", i18N.get("M_UploadFail"), new Date().getTime(), NotificationConstantsUtil.NOTIFICATION_EXPIRE_FIT, fileId));
                    ActivityFileUtil.writeDecodeFailedHistory2Pref(String.valueOf(fileId), true);
                    App.actFitDecodeHistory.remove(String.valueOf(fileId));
                }
            }
        });
    }

    private void checkNotifySettingChannel(String macAddress) {
        if (macAddress == null || macAddress.isEmpty()) {
            return;
        }
        BluetoothPeripheral peripheral = BleUtil.getInstance().central.getPeripheral(macAddress);
        if (DeviceInfo.setting) {
            BleUtil.getInstance().setNotifyNewChannel(peripheral);
        }
    }

    private void startScan() {
        Log.d(TAG, "startScan: ");
        if (BleUtil.getInstance().central.isScanning()) {
            return;
        }
        BleUtil.getInstance().startScan();
    }

    private void stopScan() {
        Log.d(TAG, "stopScan: ");
    }

    public void checkHasDeviceConnect(Device device) {
        String str = TAG;
        Log.d(str, "checkHasDeviceConnect: macAddress - > " + device.macAddress);
        if (device.macAddress.isEmpty()) {
            return;
        }
        if (BleUtil.getInstance().isDeviceAlreadyConnected(device.macAddress)) {
            if (getServiceState().state == 0) {
                BleUtil.getInstance().readDeviceInfo();
                return;
            }
            return;
        }
        BleUtil.getInstance().createBondOrConnect(device.macAddress, FeatureUtil.isSptBleBinding(device));
    }

    public void checkHasDeviceConnect(DeviceManagerEntity d) {
        Device device = new Device();
        device.macAddress = d.getMacAddress();
        device.deviceName = d.getDevName();
        device.uuid = d.getDevUuid();
        device.firmware = d.getDevVersion();
        checkHasDeviceConnect(device);
    }

    public void unBondDevice(String macAddress) {
        String str = TAG;
        Log.d(str, "unBondDevice: macAddress -> " + macAddress);
        if (macAddress.isEmpty()) {
            return;
        }
        BleUtil.getInstance().unBondDevice(macAddress);
    }

    public void disConnect(String macAddress) {
        String str = TAG;
        Log.d(str, "disConnect: macAddress -> " + macAddress);
        if (macAddress.isEmpty()) {
            return;
        }
        BleUtil.getInstance().disConnect(macAddress);
    }

    public void readDeviceInfo() {
        setServiceState(6);
        BleUtil.getInstance().readDeviceInfo();
    }

    public void getFileList() {
        setServiceState(11);
        stopCountDownGetFileList();
        startCountDownGetFileList();
        setFitSyncingState(true);
        setRunningAllSyncFlow(true);
        BleUtil.getInstance().getFileList();
    }

    public void startCountDownGetFileList() {
        if (!DeviceInfo.setting) {
            Log.d(TAG, "不支援新通道的機種不用GetFileList 計時");
            return;
        }
        Thread thread = this.mGetFileListWatchDog;
        if (thread != null) {
            thread.interrupt();
        }
        Thread thread2 = new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService.10
            @Override // java.lang.Runnable
            public void run() {
                try {
                    Thread.sleep(BleService.this.processGetFileListDelay);
                    BleService.this.broadcastGetFileListOver5Secs(BleService.SERVICE_GET_FILE_LIST_OVER_5_SECS, true);
                } catch (Exception unused) {
                }
            }
        });
        this.mGetFileListWatchDog = thread2;
        thread2.start();
    }

    public void stopCountDownGetFileList() {
        Thread thread = this.mGetFileListWatchDog;
        if (thread != null) {
            thread.interrupt();
        }
    }

    public void getFile(int fileId, byte fileType) {
        setServiceState(12);
        BleUtil.getInstance().getFile(fileId, fileType);
    }

    public void getFileRange(int fileId, byte fileType, int offset, int chunkSize) {
        setServiceState(17);
        BleUtil.getInstance().getFileRange(fileId, fileType, offset, chunkSize);
    }

    public void requestData(int requestType) {
        setServiceState(15);
        BleUtil.getInstance().requestData(requestType);
    }

    public void postData(int contentType, byte[] content) {
        setServiceState(16);
        BleUtil.getInstance().postData(contentType, content);
    }

    public void postDataPrepare(final int contentType, final byte[] fileData) {
        if (SampleGattAttributes.isPostDataPhase2 || !(contentType == 2 || contentType == 9 || contentType == 15 || contentType == 11 || contentType == 14 || contentType == 3 || contentType == 4 || contentType == 5 || contentType == 6 || contentType == 7 || contentType == 8 || contentType == 21 || contentType == 17 || contentType == 18 || contentType == 20 || contentType == 19)) {
            if (fileData == null || fileData.length <= 0) {
                return;
            }
            this.cmd16ContentSize = fileData.length;
            postData(contentType, fileData);
        } else if (contentType == 11) {
            new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda8
                @Override // java.lang.Runnable
                public final void run() {
                    BleService.this.m130x88541c56(fileData, contentType);
                }
            }).start();
        } else if (contentType == 2) {
            if (serverEeCompress == 0) {
                preparePlanTripOrWorkout(contentType, fileData, 0);
                return;
            }
            try {
                preparePlanTripOrWorkout(contentType, GZipUtils.compress(fileData), 0);
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            preparePlanTripOrWorkout(contentType, fileData, 0);
        }
    }

    /* renamed from: lambda$postDataPrepare$4$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m130x88541c56(byte[] bArr, int i) {
        if (DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.CompressPlantrip) > 0) {
            try {
                preparePlanTripOrWorkout(i, GZipUtils.compress(bArr), 0);
                return;
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }
        }
        preparePlanTripOrWorkout(i, bArr, 0);
    }

    private void preparePlanTripOrWorkout(int contentType, byte[] content, int seqNo) {
        this.sendFileCount = 0;
        this.sendFileList = new ArrayList();
        if (this.sendFileCount == 0) {
            this.sendFileByteArray = content;
            this.cmd16ContentType = contentType;
            int length = content.length;
            this.sendFileOriginDataSize = length;
            int i = this.postDataChunkSizeTx - 8;
            int i2 = length % i > 0 ? length % i : i;
            int i3 = (length / i) + 1;
            int i4 = 0;
            for (int i5 = 0; i5 < i3 - 1; i5++) {
                this.sendFileList.add(ParserUtil.bufToDataPkg(this.sendFileByteArray, i4, i));
                i4 += i;
            }
            this.sendFileList.add(ParserUtil.bufToDataPkg(this.sendFileByteArray, i4, i2));
            if (this.sendFileList.size() > 0) {
                sendFileToDevice(contentType, this.sendFileList.get(0));
                this.sendFileCount++;
            }
            broadcastFirmwareUploadProgress(SERVICE_FIRMWARE_UPDATE_PROGRESS, 0);
        }
    }

    public void nowSendFileToDeviceProgress() {
        List<byte[]> list = this.sendFileList;
        if (list == null) {
            return;
        }
        int size = (int) ((this.sendFileCount / list.size()) * 100.0d);
        String str = TAG;
        Log.d(str, "nowSendFileToDeviceProgress: " + size + " %");
        broadcastFirmwareUploadProgress(SERVICE_FIRMWARE_UPDATE_PROGRESS, size);
    }

    public void cancelRxProgress() {
        Log.d(TAG, "呼叫 cancelRxProgress: ");
        this.processActivityHandler.removeCallbacks(this.processActivityRunnable);
    }

    public void getRxProgress() {
        this.processActivityHandler.removeCallbacks(this.processActivityRunnable);
        Log.d(TAG, "呼叫 getRxProgress: ");
        Handler handler = this.processActivityHandler;
        Runnable runnable = new Runnable() { // from class: com.brytonsport.active.service.BleService.11
            @Override // java.lang.Runnable
            public void run() {
                Log.d(BleService.TAG, "呼叫 getRxProgress: run() ");
                BleService.this.processActivityHandler.postDelayed(BleService.this.processActivityRunnable, BleService.this.processActivityDelay);
                BleService.this.broadcastActivityUploadProgress(BleService.SERVICE_ACTIVITY_UPLOAD_PROGRESS, BleUtil.getInstance().getRxProgress());
            }
        };
        this.processActivityRunnable = runnable;
        handler.postDelayed(runnable, this.processActivityDelay);
    }

    public void notifyIncomingText() {
        BleUtil.getInstance().notifyIncomingText();
    }

    public void notifyIncomingEmail() {
        BleUtil.getInstance().notifyIncomingEmail();
    }

    public void notifyIncomingCall(String name, String number) {
        BleUtil.getInstance().notifyIncomingCall(name, number);
    }

    public void notifyIncomingCallCancel() {
        BleUtil.getInstance().notifyIncomingCallCancel();
    }

    public void notifyApplication(String name, String title, String content) {
        BleUtil.getInstance().notifyApplication(name, title, content);
    }

    public void passSettingCommand(JSONArray paramArray) {
        BleUtil.getInstance().passSettingCommand(paramArray);
    }

    /* JADX WARN: Removed duplicated region for block: B:33:0x004e  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    public void sendNotify(org.json.JSONObject r7) {
        /*
            r6 = this;
            java.lang.String r0 = "textLines"
            java.lang.String r1 = "text"
            java.lang.String r2 = "package"
            java.lang.String r3 = "title"
            java.lang.String r4 = ""
            boolean r5 = r7.has(r3)     // Catch: org.json.JSONException -> L41
            if (r5 == 0) goto L15
            java.lang.String r3 = r7.getString(r3)     // Catch: org.json.JSONException -> L41
            goto L16
        L15:
            r3 = r4
        L16:
            boolean r5 = r7.has(r2)     // Catch: org.json.JSONException -> L3d
            if (r5 == 0) goto L21
            java.lang.String r2 = r7.getString(r2)     // Catch: org.json.JSONException -> L3d
            goto L22
        L21:
            r2 = r4
        L22:
            boolean r5 = r7.has(r1)     // Catch: org.json.JSONException -> L3a
            if (r5 == 0) goto L2d
            java.lang.String r1 = r7.getString(r1)     // Catch: org.json.JSONException -> L3a
            goto L2e
        L2d:
            r1 = r4
        L2e:
            boolean r5 = r7.has(r0)     // Catch: org.json.JSONException -> L38
            if (r5 == 0) goto L48
            r7.getString(r0)     // Catch: org.json.JSONException -> L38
            goto L48
        L38:
            r7 = move-exception
            goto L45
        L3a:
            r7 = move-exception
            r1 = r4
            goto L45
        L3d:
            r7 = move-exception
            r1 = r4
            r2 = r1
            goto L45
        L41:
            r7 = move-exception
            r1 = r4
            r2 = r1
            r3 = r2
        L45:
            r7.printStackTrace()
        L48:
            boolean r7 = r2.isEmpty()
            if (r7 != 0) goto Lb0
            java.lang.String r7 = "_*phone_call*_"
            boolean r7 = r2.equals(r7)
            if (r7 == 0) goto L83
            if (r3 == 0) goto Lb0
            java.lang.String r7 = "0"
            boolean r7 = r3.equals(r7)
            if (r7 != 0) goto L7f
            java.lang.String r7 = "2"
            boolean r7 = r3.equals(r7)
            if (r7 == 0) goto L69
            goto L7f
        L69:
            java.lang.String r7 = "1"
            boolean r7 = r3.equals(r7)
            if (r7 == 0) goto Lb0
            java.lang.String r3 = r6.getContactName(r6, r1)
            r6.notifyIncomingCall(r3, r1)
            java.lang.String r7 = "F_NotifyPhone"
            java.lang.String r4 = com.brytonsport.active.utils.i18N.get(r7)
            goto Lb0
        L7f:
            r6.notifyIncomingCallCancel()
            return
        L83:
            java.lang.String r7 = "_*sms*_"
            boolean r7 = r2.equals(r7)
            if (r7 == 0) goto L95
            r6.notifyIncomingText()
            java.lang.String r7 = "F_NotifySms"
            java.lang.String r4 = com.brytonsport.active.utils.i18N.get(r7)
            goto Lb0
        L95:
            android.content.Context r7 = r6.getApplicationContext()
            android.content.pm.PackageManager r7 = r7.getPackageManager()
            r0 = 0
            android.content.pm.ApplicationInfo r0 = r7.getApplicationInfo(r2, r0)     // Catch: android.content.pm.PackageManager.NameNotFoundException -> La3
            goto La4
        La3:
            r0 = 0
        La4:
            if (r0 == 0) goto Lab
            java.lang.CharSequence r7 = r7.getApplicationLabel(r0)
            goto Lad
        Lab:
            java.lang.String r7 = "(unknown)"
        Lad:
            r4 = r7
            java.lang.String r4 = (java.lang.String) r4
        Lb0:
            r6.lastNotificationAppName = r4
            r6.lastNotificationTitle = r3
            r6.lastNotificationText = r1
            android.os.Handler r7 = r6.notificationSameHandler
            r0 = 1
            r7.removeMessages(r0)
            android.os.Handler r7 = r6.notificationSameHandler
            r1 = 800(0x320, double:3.953E-321)
            r7.sendEmptyMessageDelayed(r0, r1)
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: com.brytonsport.active.service.BleService.sendNotify(org.json.JSONObject):void");
    }

    private String getContactName(Context context, String number) {
        if (number == null || number.isEmpty()) {
            return "";
        }
        Uri withAppendedPath = Uri.withAppendedPath(ContactsContract.PhoneLookup.CONTENT_FILTER_URI, Uri.encode(number));
        Cursor query = context.getContentResolver().query(withAppendedPath, new String[]{"display_name", "_id"}, null, null, null);
        if (query.moveToFirst()) {
            query.getString(query.getColumnIndex("_id"));
            return query.getString(query.getColumnIndex("display_name"));
        }
        return "";
    }

    private void startForegroundService() {
        if (Build.VERSION.SDK_INT < 26 || this.isCallStartForeground) {
            return;
        }
        this.isCallStartForeground = true;
        Notification notification = this.appFgNotification;
        if (notification == null) {
            notification = createNotification("");
        }
        startForeground(11, notification);
    }

    private final Notification createNotification(String text) {
        return createNotification(text, false);
    }

    private final Notification createNotification(String text, boolean hasSettingBtn) {
        return createNotification(text, false, false);
    }

    private final Notification createNotification(String text, boolean hasSettingBtn, boolean hasGpsSetting) {
        if (Build.VERSION.SDK_INT >= 26) {
            NotificationChannel notificationChannel = new NotificationChannel("BLE SERVICE CHANNEL", "BLE Service notifications channel", 2);
            notificationChannel.setDescription("BLE Service channel");
            notificationChannel.enableLights(false);
            notificationChannel.enableVibration(false);
            notificationChannel.setVibrationPattern(new long[]{0});
            notificationChannel.setSound(null, null);
            ((NotificationManager) getSystemService("notification")).createNotificationChannel(notificationChannel);
        }
        PendingIntent activity = PendingIntent.getActivity(this, 0, new Intent(this, SplashActivity.class), 67108864);
        Intent intent = new Intent(this, StartReceiver.class);
        intent.setAction(StartReceiver.ACTION_STOP_SERVICE);
        intent.putExtra("BLE SERVICE CHANNEL", 0);
        PendingIntent broadcast = PendingIntent.getBroadcast(this, 0, intent, 67108864);
        Notification.Builder builder = Build.VERSION.SDK_INT >= 26 ? new Notification.Builder(this, "BLE SERVICE CHANNEL") : new Notification.Builder(this);
        if (text.isEmpty()) {
            text = this.notificationTxtDataSync;
        }
        builder.setContentText(text).setContentIntent(activity).setSmallIcon(getIconResId("icon_system_notification", "drawable")).setColor(ContextCompat.getColor(this, R.color.main_green)).setTicker("Ticker text").setPriority(-1).addAction(getIconResId("ic_launcher", "mipmap"), this.notificationCloseBtnTxt, broadcast).setShowWhen(true).setVibrate(new long[]{0});
        Notification build = builder.build();
        this.appFgNotification = build;
        return build;
    }

    private int getIconResId(String icon, String type) {
        Resources resources = getResources();
        String packageName = getPackageName();
        int identifier = resources.getIdentifier(icon, type, packageName);
        return identifier == 0 ? resources.getIdentifier(BannerComponents.ICON, type, packageName) : identifier;
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* loaded from: classes.dex */
    public class SyncFitFileInfo {
        int fileId;
        String fileIdToTimestamp;
        int retryCnt;

        public SyncFitFileInfo(int fileId) {
            this.fileId = 0;
            this.fileIdToTimestamp = SchemaSymbols.ATTVAL_FALSE_0;
            this.retryCnt = 0;
            this.fileId = fileId;
            this.fileIdToTimestamp = ParserUtil.fileIdToFormatString(fileId);
            this.retryCnt = 0;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* loaded from: classes.dex */
    public class LocationListener implements android.location.LocationListener {
        public LocationListener(String provider) {
            String str = BleService.TAG;
            Log.e(str, "01 LocationListener " + provider + ", mLastLocation = " + BleService.this.mLastLocation);
            if (BleService.this.mLastLocation == null) {
                BleService.this.mLastLocation = new Location(provider);
            }
        }

        @Override // android.location.LocationListener
        public void onLocationChanged(Location location) {
            if (location != null) {
                String str = BleService.TAG;
                Log.d(str, "05 onLocationChanged 定位改變 : (" + location.getLatitude() + ", " + location.getLongitude() + ")");
                if (App.recentGetLatLngInfoObj != null) {
                    try {
                        App.recentGetLatLngInfoObj.put("lat", location.getLatitude());
                        App.recentGetLatLngInfoObj.put("lng", location.getLongitude());
                        App.recentGetLatLngInfoObj.put("alt", location.getAltitude());
                        App.recentGetLatLngInfoObj.put("updateTime", new Date());
                        BleService.this.broadcastOnLocationChange(BleService.SERVICE_ONLOCATION_CHANGE);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
                if (BleService.this.mLastLocation == null) {
                    Log.d(BleService.TAG, "05 onLocationChanged: mLastLocation == null");
                    BleService.this.mLastLocation = new Location(BleService.this.locationProvider);
                } else {
                    Log.d(BleService.TAG, "05 onLocationChanged: mLastLocation != null");
                }
                BleService.this.mLastLocation.set(location);
            }
        }

        @Override // android.location.LocationListener
        public void onProviderDisabled(String provider) {
            String str = BleService.TAG;
            Log.e(str, "onProviderDisabled: " + provider);
        }

        @Override // android.location.LocationListener
        public void onProviderEnabled(String provider) {
            String str = BleService.TAG;
            Log.e(str, "onProviderEnabled: " + provider);
        }

        @Override // android.location.LocationListener
        public void onStatusChanged(String provider, int status, Bundle extras) {
            String str = BleService.TAG;
            Log.e(str, "onStatusChanged: " + provider);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void initializeLocationManager() {
        String str = TAG;
        Log.e(str, "initializeLocationManager - LOCATION_INTERVAL: 1000 LOCATION_DISTANCE: 10.0");
        if (this.mLocationManager == null) {
            this.mLocationManager = (LocationManager) getApplicationContext().getSystemService(FirebaseAnalytics.Param.LOCATION);
        }
        this.isGPSEnabled = this.mLocationManager.isProviderEnabled(ConstSettingChannel.DEVICE_CAPABILITY_GPS);
        this.isNetworkEnabled = this.mLocationManager.isProviderEnabled("network");
        Log.d(str, "initializeLocationManager: isGPSEnabled = " + this.isGPSEnabled + ", isNetworkEnabled = " + this.isNetworkEnabled);
        Criteria criteria = new Criteria();
        String str2 = this.locationProvider;
        if (str2 == null || str2.isEmpty()) {
            this.locationProvider = this.mLocationManager.getBestProvider(criteria, true);
        }
        Log.d(str, "initializeLocationManager: getBestProvider locationProvider = " + this.locationProvider);
        String str3 = this.locationProvider;
        if (str3 == null || str3.isEmpty()) {
            Log.d(str, "initializeLocationManager: locationProvider == null");
            return;
        }
        if (this.mLocListener == null) {
            this.mLocListener = new LocationListener(this.locationProvider);
            Log.d(str, "02 initializeLocationManager: mLocListener -> " + this.mLocListener);
        }
        LocationListener locationListener = this.mLocListener;
        if (locationListener == null) {
            return;
        }
        if (this.isNetworkEnabled) {
            this.locationProvider = "network";
            try {
                this.mLocationManager.removeUpdates(locationListener);
                this.mLocationManager.requestLocationUpdates(this.locationProvider, 1000L, LOCATION_DISTANCE, this.mLocListener);
                Location lastKnownLocation = this.mLocationManager.getLastKnownLocation(this.locationProvider);
                this.mLastLocation = lastKnownLocation;
                if (lastKnownLocation != null) {
                    Log.d(str, "03 有定位 initializeLocationManager getLastKnownLocation: locationProvider = " + this.locationProvider + ", mLastLocation(" + this.mLastLocation.getLatitude() + ", " + this.mLastLocation.getLongitude() + ")");
                    this.mLocListener.onLocationChanged(this.mLastLocation);
                } else {
                    Log.d(str, "03 沒有定位 initializeLocationManager getLastKnownLocation: locationProvider = " + this.locationProvider + ", mLastLocation = " + this.mLastLocation);
                }
            } catch (IllegalArgumentException e) {
                String str4 = TAG;
                Log.d(str4, "network provider does not exist, " + e.getMessage());
            } catch (SecurityException e2) {
                Log.i(TAG, "fail to request location update, ignore", e2);
            }
        }
        if (this.isGPSEnabled && this.mLastLocation == null) {
            this.locationProvider = ConstSettingChannel.DEVICE_CAPABILITY_GPS;
            try {
                this.mLocationManager.requestLocationUpdates(ConstSettingChannel.DEVICE_CAPABILITY_GPS, 1000L, LOCATION_DISTANCE, this.mLocListener);
                String str5 = TAG;
                Log.d(str5, "initializeLocationManager getLastKnownLocation: locationProvider = " + this.locationProvider);
                Location lastKnownLocation2 = this.mLocationManager.getLastKnownLocation(this.locationProvider);
                this.mLastLocation = lastKnownLocation2;
                if (lastKnownLocation2 != null) {
                    Log.d(str5, "04 有定位 initializeLocationManager getLastKnownLocation: locationProvider = " + this.locationProvider + ", mLastLocation(" + this.mLastLocation.getLatitude() + ", " + this.mLastLocation.getLongitude() + ")");
                    this.mLocListener.onLocationChanged(this.mLastLocation);
                } else {
                    Log.d(str5, "04 沒有定位 initializeLocationManager getLastKnownLocation: locationProvider = " + this.locationProvider + ", mLastLocation = " + this.mLastLocation);
                }
            } catch (IllegalArgumentException e3) {
                String str6 = TAG;
                Log.d(str6, "network provider does not exist, " + e3.getMessage());
            } catch (SecurityException e4) {
                Log.i(TAG, "fail to request location update, ignore", e4);
            }
        }
    }

    private void removeLocationListener() {
        if (this.mLocationManager == null || this.mLocListener == null) {
            return;
        }
        String str = TAG;
        Log.d(str, "onDestroy: 移除 mLocListener -> " + this.mLocListener);
        this.mLocationManager.removeUpdates(this.mLocListener);
        this.mLocListener = null;
        this.mLocationManager = null;
    }

    private void broadcastUpdate(final String action, Device deviceVo) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_READ_DEVICE_INFO_EXTRA_DATA, deviceVo);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastByteArrayData(String action, byte[] data) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_BYTE_ARRAY_EXTRA_DATA, data);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastStringData(String action, String data) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_STRING_EXTRA_DATA, data);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastPostFileType(String action, int fileType) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_POST_FILE_TYPE, fileType);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastBooleanData(String action, Boolean data) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_BOOLEAN_EXTRA_DATA, data);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastIntData(String action, int data) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_INT_EXTRA_DATA, data);
        App.getInstance().sendBroadcast(intent);
    }

    private void broadcastDoubleData(String action, double data) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_DOUBLE_EXTRA_DATA, data);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastLiveTrackManualStartState(String action, boolean stateStart) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_LIVE_TRACK_MANUAL_STATE_DATA, stateStart);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastLiveTrackShareBtnVisible(String action, boolean isVisible) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_LIVE_TRACK_SHARE_BTN_VISIBLE_DATA, isVisible);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastActivityUploadProgress(String action, float progress) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_ACTIVITY_UPLOAD_PROGRESS_VALUE, progress);
        intent.putExtra(SERVICE_ACTIVITY_UPLOAD_PROGRESS_NOW_INDEX, this.processActivityNowIndex);
        intent.putExtra(SERVICE_ACTIVITY_UPLOAD_PROGRESS_TOTAL_COUNT, this.processActivityTotalCount);
        intent.putExtra(SERVICE_ACTIVITY_UPLOAD_COMPLETE, this.isProcessActivityComplete);
        String str = TAG;
        Log.d(str, "舊機種同步 broadcast Progress : 第" + this.processActivityNowIndex + "筆，總共: " + this.processActivityTotalCount + ", 是否完成: " + this.isProcessActivityComplete);
        App.getInstance().sendBroadcast(intent);
    }

    private void broadcastFirmwareUploadProgress(String action, int progress) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_FIRMWARE_UPDATE_PROGRESS_VALUE, progress);
        App.getInstance().sendBroadcast(intent);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastGetFileListOver5Secs(String action, boolean isShowHint) {
        Intent intent = new Intent(action);
        intent.putExtra(SERVICE_GET_FILE_LIST_OVER_5_SECS_SHOW_HINT, isShowHint);
        App.getInstance().sendBroadcast(intent);
    }

    private void setLiveTrackSwitch() {
        boolean booleanValue = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_AUTO_START)).booleanValue();
        this.liveTrackAutoShare = booleanValue;
        if (this.devSptLiveTrack && booleanValue) {
            BleUtil.getInstance().setLiveTrackingSwitch(this.liveTrackInterval);
        }
    }

    private void setBbcpRxTx(JSONObject jsonObject) {
        this.postDataChunkSizeTx = 6930;
        String str = TAG;
        Log.d(str, "setBbcpRxTx: chunkSizeRx = 39600, chunkSizeTx = 6930");
        try {
            BleUtil.getInstance().config(jsonObject.getInt("payloadSize"), jsonObject.getInt("handShakeSize"), 39600, 6930);
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void setPlanTripName(String name) {
        String str = TAG;
        Log.d(str, "setPlanTripName name: " + name);
        BleUtil.getInstance().setPlantripName(name);
    }

    private void checkAutoAltitude() {
        if (!((Boolean) ProfileUtil.getInstance().get(ProfileUtil.SETTING_AUTO_ALTITUDE)).booleanValue() || this.mLastLocation == null) {
            return;
        }
        BleUtil.getInstance().postAltitudeValue((int) this.mLastLocation.getAltitude());
    }

    private void checkFitAutoUpload() {
        SampleGattAttributes.isGetFileRangePhase2 = true;
        JSONObject jSONObject = this.handshakePayloadObj;
        if (jSONObject != null) {
            setBbcpRxTx(jSONObject);
        }
        this.fitAutoSync = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.SETTING_AUTO_SYNC_ACTIVITY)).booleanValue();
        if (DeviceInfo.ftp && this.fitAutoSync) {
            Log.d(TAG, "processConnectAction -> checkFitAutoUpload: 執行 Priority 8-同步騎乘紀錄 (有開自動上傳且DeviceInfo.ftp = true)");
            getFileList();
            return;
        }
        Log.d(TAG, "processConnectAction -> checkFitAutoUpload: 不執行 Priority 8-同步騎乘紀錄 (沒開自動上傳 或 DeviceInfo.ftp = false)");
        connectActionCompleted();
    }

    private void checkFileListToGeFile() {
        checkFileListToGeFile(false);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void checkFileListToGeFile(boolean retry) {
        List<FileSummary> list = this.fileSummaryList;
        if (list != null && list.size() > 0) {
            String str = TAG;
            Log.d(str, "processConnectAction -> checkFileListToGeFile: 執行 Priority 8-同步騎乘紀錄 - 有 " + this.fileSummaryList.size() + "筆Fit 要上傳, 傳到第" + this.choiceFileListIndex + "筆");
            if (this.choiceFileListIndex < this.fileSummaryList.size()) {
                int i = this.choiceFileListIndex;
                this.processActivityNowIndex = i;
                decideGetFileMode(this.fileSummaryList.get(i), retry);
                return;
            }
            this.choiceFileListIndex = 0;
            this.fileSummaryList = null;
            this.isProcessActivityComplete = true;
            Log.d(str, "processConnectAction -> checkFileListToGeFile: 執行 Priority 8-同步騎乘紀錄 - 活動紀錄已全數從裝置傳到APP中");
            syncActivityFitCompleted();
            if (isNetworkConnect()) {
                uploadFileToServer();
                return;
            }
            setFitSyncingState(false);
            broadcastActivityUploadProgress(SERVICE_ACTIVITY_UPLOAD_PROGRESS, 0.0f);
            Log.d(str, "checkFileListToGeFile: 網路未連接 ");
            return;
        }
        Log.d(TAG, "processConnectAction -> checkFileListToGeFile: 執行 Priority 8-同步騎乘紀錄 - 沒有Fit 需要上傳");
        this.processActivityNowIndex = 0;
        this.processActivityTotalCount = 0;
        setFitSyncingState(false);
        setRunningAllSyncFlow(false);
        syncActivityFitCompleted();
    }

    private void decideGetFileMode(FileSummary fileSummary, boolean retry) {
        int fileId = fileSummary.getFileId();
        if (!retry) {
            this.syncFitFileInfo = new SyncFitFileInfo(fileId);
        }
        getFitFileFromDeviceBySptFtp(fileId, (byte) 1);
    }

    public void getFitFileFromDeviceBySptFtp(int fileId, byte fileType) {
        this.choiceFileId = fileId;
        this.choiceFileType = fileType;
        String str = TAG;
        Log.d(str, "getFitFileFromDeviceBySptFtp choiceFileId: " + this.choiceFileId);
        if (DeviceInfo.ftp) {
            getFileRange(fileId, fileType, 0, 4);
        } else {
            getFile(fileId, fileType);
        }
    }

    public void decideGetFileRange() {
        int i = this.getFileRangeIndex;
        int i2 = this.fileRangeCount;
        if (i < i2) {
            int i3 = i == i2 + (-1) ? this.fileRangeLastChunkSize : 39600;
            this.getFileRangeChunkSize = i3;
            getFileRange(this.choiceFileId, (byte) this.choiceFileType, this.getFileRangeOffset, i3);
            this.getFileRangeIndex++;
            return;
        }
        createFileWithByte(this.getFileRangeTotalArray, UsbFile.separator + ((String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID)) + "/fit/unsave", SampleGattAttributes.saveGetFileRangeName);
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Removed duplicated region for block: B:45:0x00c2 A[LOOP:0: B:44:0x00c0->B:45:0x00c2, LOOP_END] */
    /* JADX WARN: Removed duplicated region for block: B:61:0x00d5 A[EXC_TOP_SPLITTER, SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:65:0x00cb A[EXC_TOP_SPLITTER, SYNTHETIC] */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:42:0x00b7 -> B:67:0x00ba). Please submit an issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    public void createFileWithByte(byte[] r5, java.lang.String r6, java.lang.String r7) {
        /*
            Method dump skipped, instructions count: 222
            To view this dump change 'Code comments level' option to 'DEBUG'
        */
        throw new UnsupportedOperationException("Method not decompiled: com.brytonsport.active.service.BleService.createFileWithByte(byte[], java.lang.String, java.lang.String):void");
    }

    public boolean isNetworkConnect() {
        NetworkInfo activeNetworkInfo = ((ConnectivityManager) getSystemService("connectivity")).getActiveNetworkInfo();
        return activeNetworkInfo != null && activeNetworkInfo.isConnectedOrConnecting();
    }

    public boolean checkUnSaveFiles() {
        File filesDir = getFilesDir();
        File file = new File(filesDir + (UsbFile.separator + ((String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID)) + "/fit/unsave"));
        return file.exists() && file.listFiles().length > 0;
    }

    public void uploadFileToServer() {
        boolean checkUnSaveFiles = checkUnSaveFiles();
        Log.d("Leigh1111", "uploadFileToServer: hasUnsaveToUpload -> " + checkUnSaveFiles);
        if (checkUnSaveFiles) {
            File filesDir = getFilesDir();
            File file = new File(filesDir + (UsbFile.separator + ((String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID)) + "/fit/unsave"));
            this.unsaveFiles = new File[0];
            if (file.exists()) {
                this.unsaveFiles = file.listFiles();
            }
            Log.d("Leigh1111", "uploadFileToServer: 有" + this.unsaveFiles.length + "筆要上傳到server");
            this.countUnsaveUploadSuccess = 0;
            this.uploadUnSaveIndex = 0;
            prepareUploadFile(0);
        }
    }

    private void prepareUploadFile(int index) {
        File[] fileArr = this.unsaveFiles;
        if (fileArr.length > 0 && index < fileArr.length) {
            File file = fileArr[index];
            String name = file.getName();
            String path = file.getPath();
            String str = name.split("\\.")[0];
            if (Boolean.TRUE.equals(ActivityFileUtil.readDecodeFailedHistoryFromPref(str))) {
                Log.d("Leigh1111", "prepareUploadFile: 之前 decode failed 被記下來，不用上傳 -> " + str);
                runNextUploadFile();
                return;
            } else if (!App.actFitDecodeHistory.contains(str)) {
                Log.e("Leigh1111", "prepareUploadFile fit檔還沒decode:" + str);
                processFitDecodeOkAndAddNotification(Integer.parseInt(str));
                runNextUploadFile();
                return;
            } else {
                Log.d("Leigh1111", "prepareUploadFile: 準備上傳 -> " + str);
                if (this.uploadingFileIdSet.contains(str)) {
                    Log.d("Leigh1111", "prepareUploadFile: 此筆fileId 已在正在上傳清單中，不用再次上傳");
                    runNextUploadFile();
                    return;
                }
                Log.d("Leigh1111", "prepareUploadFile: 把此筆fileId 加入正在上傳清單中，呼叫上傳");
                this.uploadingFileIdSet.add(str);
                uploadToServer(name, path);
                return;
            }
        }
        setFitSyncingState(false);
        if (this.unsaveFiles.length > 0 && this.countUnsaveUploadSuccess > 0) {
            String str2 = TAG;
            Log.d(str2, "0317看這 如果目前畫面在Result首頁，則收到通知後，重新向Server取得更新 timeStamp: " + new Date().getTime() + ", format: " + new Date() + ", 更新比數: " + this.countUnsaveUploadSuccess);
            loadResultList();
            StringBuilder sb = new StringBuilder();
            sb.append("prepareUploadFile: 全部上傳server完畢 index = ");
            sb.append(index);
            Log.d("Leigh1111", sb.toString());
            sendNotification(i18N.get("app_name"), i18N.get("M_hasNewActivity"));
            if (this.hasBefore2016Fit) {
                this.hasBefore2016Fit = false;
                broadcastBooleanData(SERVICE_UPLOAD_ACTIVITIES_HAS_BEFORE_2016, true);
            }
            broadcastActivityUploadProgress(SERVICE_ACTIVITY_UPLOAD_PROGRESS, 0.0f);
            if (App.isRunningAllSyncFlow) {
                setRunningAllSyncFlow(false);
                int intValue = ((Integer) ProfileUtil.getInstance().get(ProfileUtil.RUN_SYNC_FIT_FLOW_COUNT)).intValue() + 1;
                ProfileUtil.getInstance().set(ProfileUtil.RUN_SYNC_FIT_FLOW_COUNT, Integer.valueOf(intValue));
                boolean booleanValue = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.IS_REVIEW_FLOW_COMPLETE)).booleanValue();
                Log.d(str2, "執行完整上傳流程的次數: isReviewFlowComplete = " + booleanValue + ", syncCount = " + intValue);
                if (booleanValue) {
                    Log.d(str2, "執行完整上傳流程的次數: 使用者在評分視窗有進行過操作，就不用在跳出評分視窗 syncCount = " + intValue);
                    return;
                } else if (intValue >= 5) {
                    Log.d(str2, "執行完整上傳流程的次數: 同步次數超過5次 打broadcast 通知可評分 syncCount = " + intValue);
                    broadcastBooleanData(SERVICE_NEED_SHOW_REVIEW_DIALOG, true);
                    return;
                } else {
                    return;
                }
            }
            return;
        }
        Log.d("Leigh1111", "unsaveFiles小於0 ");
    }

    private void uploadToServer(final String fileName, final String filePath) {
        String str = "https://active.brytonsport.com/user/upload/" + ((String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID));
        Log.d("Leigh1111", "uploadToServer url -> " + str);
        VolleyMultipartRequest volleyMultipartRequest = new VolleyMultipartRequest(1, str, new Response.Listener<NetworkResponse>() { // from class: com.brytonsport.active.service.BleService.12
            @Override // com.android.volley.Response.Listener
            public void onResponse(NetworkResponse response) {
                String str2;
                String str3 = "";
                try {
                    String str4 = BleService.TAG;
                    Log.d(str4, "uploadToServer response.statusCode -> " + response.statusCode);
                    try {
                        str2 = response.data != null ? new String(response.data, HttpHeaderParser.parseCharset(response.headers)) : "";
                    } catch (Exception unused) {
                        str2 = "";
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {
                    String str5 = BleService.TAG;
                    Log.d(str5, "uploadToServer onResponse json -> " + str2);
                } catch (Exception unused2) {
                    String str6 = fileName.split("\\.")[0];
                    if (response.statusCode == 200) {
                        BleService.this.notificationRepository.updateNotification(Integer.valueOf(str6).intValue(), NotificationConstantsUtil.CATEGORY_UPLOAD_FIT_SUCCESS, i18N.get("FitToServer"));
                        String str7 = BleService.TAG;
                        Log.d(str7, "onResponse: 上傳" + fileName + "到server成功");
                        FileUtil.moveUploadToSave(BleService.this, fileName);
                        BleService bleService = BleService.this;
                        bleService.countUnsaveUploadSuccess = bleService.countUnsaveUploadSuccess + 1;
                        if (!str2.isEmpty()) {
                            JSONObject jSONObject = new JSONObject(str2);
                            if (jSONObject.has("strava")) {
                                String string = jSONObject.getString("strava");
                                if (!string.equals("ok")) {
                                    FirebaseCustomUtil.getInstance().setActivityLogMessage("活動紀錄 Server 自動上傳失敗[strava]，msg[" + string + "]");
                                }
                            }
                        }
                    } else {
                        try {
                            str3 = ParserUtil.fileIdToFormatString(Integer.valueOf(str6).intValue());
                        } catch (Exception unused3) {
                        }
                        Log.d(BleService.TAG, "[saveFitToServer]upload [" + fileName + "] " + str3 + " responceCode[" + response.statusCode + "] " + str2);
                        BleService.this.notificationRepository.updateNotification(Integer.valueOf(str6).intValue(), NotificationConstantsUtil.CATEGORY_UPLOAD_FIT_NOT_UPLOAD_TO_SERVER, "Activity uploaded to server failed!");
                    }
                    String str8 = fileName.split("\\.")[0];
                    if (BleService.this.uploadingFileIdSet.contains(str8)) {
                        BleService.this.uploadingFileIdSet.remove(str8);
                        String str9 = BleService.TAG;
                        Log.d(str9, "onResponse: 從正在上傳清單中移除 -> " + str8);
                    }
                    BleService.this.runNextUploadFile();
                }
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.13
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                Log.d("Error.Response", error.toString());
                NetworkResponse networkResponse = error.networkResponse;
                if ((error instanceof ServerError) && networkResponse != null) {
                    try {
                        JSONObject jSONObject = new JSONObject(new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers, "utf-8")));
                        String str2 = BleService.TAG;
                        Log.d(str2, "onErrorResponse: " + jSONObject.toString());
                        try {
                            ParserUtil.fileIdToFormatString(Integer.valueOf(fileName.split(".")[0]).intValue());
                        } catch (Exception unused) {
                        }
                        int i = networkResponse.statusCode;
                        jSONObject.toString();
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    } catch (JSONException e2) {
                        e2.printStackTrace();
                    }
                }
                String str3 = fileName.split("\\.")[0];
                if (BleService.this.uploadingFileIdSet.contains(str3)) {
                    BleService.this.uploadingFileIdSet.remove(str3);
                    String str4 = BleService.TAG;
                    Log.d(str4, "onErrorResponse: 從正在上傳清單中移除 -> " + str3);
                }
                BleService.this.runNextUploadFile();
            }
        }) { // from class: com.brytonsport.active.service.BleService.14
            @Override // com.brytonsport.active.service.VolleyMultipartRequest
            protected Map<String, VolleyMultipartRequest.DataPart> getByteData() {
                HashMap hashMap = new HashMap();
                hashMap.put("track", new VolleyMultipartRequest.DataPart(fileName, FileUtil.getFileByteArray(filePath)));
                return hashMap;
            }
        };
        volleyMultipartRequest.setRetryPolicy(new DefaultRetryPolicy(0, 1, 1.0f));
        this.mQueue.add(volleyMultipartRequest);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void runNextUploadFile() {
        int i = this.uploadUnSaveIndex + 1;
        this.uploadUnSaveIndex = i;
        prepareUploadFile(i);
    }

    private void processReRoute(JSONObject resultObj) {
        try {
            int i = resultObj.has("heading") ? resultObj.getInt("heading") : -1;
            new JSONObject();
            new JSONObject();
            JSONObject jSONObject = resultObj.getJSONObject("startPos");
            JSONObject jSONObject2 = resultObj.getJSONObject("endPos");
            getTurnByTurn(i, (float) jSONObject.getDouble("lat"), (float) jSONObject.getDouble("lng"), (float) jSONObject2.getDouble("lat"), (float) jSONObject2.getDouble("lng"));
        } catch (JSONException unused) {
            reRouteTurnByTurnNoResultAction();
        }
    }

    private void initReRouteTurnByTurnState() {
        this.reRouteTurnByTurnSuccess = false;
    }

    private void reRouteTurnByTurnNoNetworkAction() {
        this.reRouteTurnByTurnSuccess = false;
        BleUtil.getInstance().setPlantrip(3);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void reRouteTurnByTurnNoResultAction() {
        this.reRouteTurnByTurnSuccess = false;
        BleUtil.getInstance().setPlantrip(6);
    }

    private void reRouteTurnByTurnSuccessAction() {
        this.reRouteTurnByTurnSuccess = true;
        BleUtil.getInstance().setPlantrip(1);
    }

    private void getTurnByTurn(int heading, float startLat, float startLng, float endLat, float endLng) {
        String str = "heading=" + (heading % VertexData.SIZE) + "&";
        this.routeMode = (String) ProfileUtil.getInstance().get(ProfileUtil.SETTING_VOICE_PLAN_MODE);
        String str2 = this.graphHopperBaseUrl + "route?point=" + startLat + ToStringHelper.COMMA_SEPARATOR + startLng + "&point=" + endLat + ToStringHelper.COMMA_SEPARATOR + endLng + (((Boolean) ProfileUtil.getInstance().get(ProfileUtil.SETTING_VOICE_AVOID_FERRY)).booleanValue() ? this.avoidRoadClass : this.noAvoidRoadClass) + "&elevation=true&vehicle=" + this.routeMode + "&calc_points=true&" + str + this.no_U_Turn + "key=" + this.graphHopperKey;
        Log.d(TAG, "getTurnByTurn: url -> " + str2);
        this.mQueue.add(new JsonObjectRequest(str2, new Response.Listener<JSONObject>() { // from class: com.brytonsport.active.service.BleService.15
            @Override // com.android.volley.Response.Listener
            public void onResponse(JSONObject response) {
                String str3 = BleService.TAG;
                Log.d(str3, "getTurnByTurn -> " + response.toString());
                try {
                    final JSONObject jSONObject = (JSONObject) response.getJSONArray("paths").get(0);
                    String str4 = BleService.TAG;
                    Log.d(str4, "onResponse: pathObj -> " + jSONObject);
                    final String string = jSONObject.getString(ResultShareActivity.POINTS);
                    String str5 = BleService.TAG;
                    Log.d(str5, "onResponse: pointsEncodeStr -> " + string);
                    BleService.this.runOnBgThread(new Runnable() { // from class: com.brytonsport.active.service.BleService.15.1
                        @Override // java.lang.Runnable
                        public void run() {
                            Log.d(BleService.TAG, "開始解密 -> ");
                            JSONArray decodePolyline = ApiUtil.decodePolyline(string, 1, true);
                            Log.d(BleService.TAG, "解密完成 -> ");
                            try {
                                jSONObject.put(ResultShareActivity.POINTS, decodePolyline);
                            } catch (JSONException e) {
                                e.printStackTrace();
                            }
                            String str6 = BleService.TAG;
                            Log.d(str6, "onResponse: pathObj 解密完 -> " + jSONObject);
                            BleService.this.prepareEncodeRoute(jSONObject);
                        }
                    });
                } catch (JSONException e) {
                    e.printStackTrace();
                    BleService.this.reRouteTurnByTurnNoResultAction();
                } catch (Exception unused) {
                    BleService.this.reRouteTurnByTurnNoResultAction();
                }
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.16
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                Log.d("Error.Response", error.toString());
                BleService.this.reRouteTurnByTurnNoResultAction();
            }
        }));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void prepareEncodeRoute(JSONObject jsonObject) {
        JSONArray jSONArray = new JSONArray();
        JSONObject jSONObject = new JSONObject();
        JSONArray jSONArray2 = new JSONArray();
        JSONObject jSONObject2 = new JSONObject();
        try {
            jSONObject2.put("distance", jsonObject.getDouble("distance"));
            jSONObject2.put("gain", jsonObject.getDouble("ascend"));
            jSONObject2.put("loss", jsonObject.getDouble("descend"));
            jSONObject2.put(Parameters.Routing.INSTRUCTIONS, jsonObject.getJSONArray(Parameters.Routing.INSTRUCTIONS));
            jSONObject2.put(ResultShareActivity.POINTS, jsonObject.getJSONArray(ResultShareActivity.POINTS));
            jSONArray2.put(jSONObject2);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        JSONObject jSONObject3 = new JSONObject();
        try {
            jSONObject3.put("major", 0);
            jSONObject3.put("minor", 1);
        } catch (JSONException e2) {
            e2.printStackTrace();
        }
        try {
            jSONObject.put("paths", jSONArray2);
            jSONObject.put("version", jSONObject3);
        } catch (JSONException e3) {
            e3.printStackTrace();
        }
        jSONArray.put(jSONObject);
        createFileWithByte(jSONArray.toString().getBytes(), "brytonPlanTrip.json");
        String str = TAG;
        Log.d(str, "prepareEncodeRoute: brytonPlanTrip -> " + jSONObject);
        parseNavigation(jSONArray);
    }

    private void parseNavigation(JSONArray jsonArray) {
        String str;
        String str2;
        String str3;
        BleService bleService = this;
        String str4 = "loss";
        String str5 = "gain";
        String str6 = "version";
        String str7 = ResultShareActivity.POINTS;
        String str8 = "distance";
        try {
            JSONObject jSONObject = jsonArray.getJSONObject(0);
            JSONObject jSONObject2 = jSONObject.getJSONArray("paths").getJSONObject(0);
            JSONArray jSONArray = jSONObject2.getJSONArray(ResultShareActivity.POINTS);
            double d = jSONObject2.getDouble("distance");
            JSONArray jSONArray2 = new JSONArray();
            JSONArray jSONArray3 = jSONObject2.getJSONArray(Parameters.Routing.INSTRUCTIONS);
            int i = 0;
            while (i < jSONArray3.length()) {
                try {
                    JSONArray jSONArray4 = new JSONArray();
                    String string = jSONArray3.getJSONObject(i).getString(Parameters.DETAILS.STREET_NAME);
                    string.getBytes("UTF-8");
                    String str9 = str4;
                    int i2 = jSONArray3.getJSONObject(i).getInt("sign");
                    if (i2 == 6) {
                        i2 = SignTableUtil.getRoundaboutMappingId(jSONArray3.getJSONObject(i), i2);
                    } else if (i2 < 100) {
                        i2 = SignTableUtil.SignTable(i2 + "");
                    }
                    String str10 = str5;
                    jSONArray4.put(jSONArray3.getJSONObject(i).getJSONArray("interval").getInt(0));
                    jSONArray4.put(i2);
                    double d2 = d;
                    jSONArray4.put(jSONArray3.getJSONObject(i).getDouble("distance"));
                    try {
                        jSONArray4.put(jSONArray3.getJSONObject(i).getLong("time"));
                    } catch (Exception unused) {
                        jSONArray4.put((Object) null);
                    }
                    jSONArray4.put(string);
                    jSONArray2.put(jSONArray4);
                    i++;
                    bleService = this;
                    str4 = str9;
                    str5 = str10;
                    d = d2;
                } catch (UnsupportedEncodingException e) {
                    e = e;
                    e.printStackTrace();
                    reRouteTurnByTurnNoResultAction();
                } catch (JSONException e2) {
                    e = e2;
                    e.printStackTrace();
                    reRouteTurnByTurnNoResultAction();
                } catch (Exception unused2) {
                    reRouteTurnByTurnNoResultAction();
                }
            }
            String str11 = str4;
            String str12 = str5;
            double d3 = d;
            JSONArray jSONArray5 = new JSONArray();
            int i3 = 0;
            while (i3 < jSONArray.length()) {
                JSONObject jSONObject3 = new JSONObject();
                if (jSONArray.getJSONArray(i3).length() == 3) {
                    str = str7;
                    str2 = str8;
                    jSONObject3.put("position_lat", jSONArray.getJSONArray(i3).getDouble(1));
                    jSONObject3.put("position_long", jSONArray.getJSONArray(i3).getDouble(0));
                    jSONObject3.put("altitude", jSONArray.getJSONArray(i3).getInt(2));
                } else {
                    str = str7;
                    str2 = str8;
                    if (jSONArray.getJSONArray(i3).length() == 4) {
                        jSONObject3.put("position_lat", jSONArray.getJSONArray(i3).getDouble(1));
                        str3 = str6;
                        jSONObject3.put("position_long", jSONArray.getJSONArray(i3).getDouble(0));
                        jSONObject3.put("altitude", jSONArray.getJSONArray(i3).getInt(2));
                        jSONObject3.put("grade", jSONArray.getJSONArray(i3).getDouble(3));
                        jSONArray5.put(jSONObject3);
                        i3++;
                        str6 = str3;
                        str7 = str;
                        str8 = str2;
                    }
                }
                str3 = str6;
                jSONArray5.put(jSONObject3);
                i3++;
                str6 = str3;
                str7 = str;
                str8 = str2;
            }
            String str13 = str8;
            String str14 = str6;
            JSONObject jSONObject4 = new JSONObject();
            jSONObject4.put(str14, jSONObject.getJSONObject(str14));
            jSONObject4.put(str7, jSONArray5);
            jSONObject4.put(str13, d3);
            jSONObject4.put("steps", jSONArray2);
            jSONObject4.put(str12, jSONObject2.getDouble(str12));
            jSONObject4.put(str11, jSONObject2.getDouble(str11));
            try {
                createFileWithByte(jSONObject4.toString().getBytes(), "parseNavigation.json");
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e3) {
                    e3.printStackTrace();
                }
                fitEncode(null);
                reRouteTurnByTurnSuccessAction();
                Log.d(TAG, "parseNavigation: 流程結束");
            } catch (UnsupportedEncodingException e4) {
                e = e4;
                e.printStackTrace();
                reRouteTurnByTurnNoResultAction();
            } catch (JSONException e5) {
                e = e5;
                e.printStackTrace();
                reRouteTurnByTurnNoResultAction();
            } catch (Exception unused3) {
                reRouteTurnByTurnNoResultAction();
            }
        } catch (UnsupportedEncodingException e6) {
            e = e6;
            e.printStackTrace();
            reRouteTurnByTurnNoResultAction();
        } catch (JSONException e7) {
            e = e7;
            e.printStackTrace();
            reRouteTurnByTurnNoResultAction();
        } catch (Exception unused4) {
        }
    }

    private void fitEncode(JSONObject data) {
        Log.d(TAG, "執行 fitEncode: ");
        File filesDir = getFilesDir();
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject = new JSONObject(JsonUtil.readJsonFile(filesDir + "/parseNavigation.json"));
        } catch (JSONException e) {
            e.printStackTrace();
        }
        BrytonPlanTrip brytonPlanTrip = new BrytonPlanTrip();
        brytonPlanTrip.encodeFileSet(filesDir + File.separator + "voice.fit");
        brytonPlanTrip.encode(jSONObject);
    }

    /* JADX WARN: Removed duplicated region for block: B:45:0x00ac A[LOOP:0: B:44:0x00aa->B:45:0x00ac, LOOP_END] */
    /* JADX WARN: Removed duplicated region for block: B:59:0x00b5 A[EXC_TOP_SPLITTER, SYNTHETIC] */
    /* JADX WARN: Removed duplicated region for block: B:70:0x00bf A[EXC_TOP_SPLITTER, SYNTHETIC] */
    /* JADX WARN: Unsupported multi-entry loop pattern (BACK_EDGE: B:42:0x00a1 -> B:61:0x00a4). Please submit an issue!!! */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    private void createFileWithByte(byte[] r4, java.lang.String r5) {
        /*
            r3 = this;
            java.lang.String r0 = com.brytonsport.active.service.BleService.TAG
            java.lang.StringBuilder r1 = new java.lang.StringBuilder
            r1.<init>()
            java.lang.String r2 = "createFileWithByte: bytes size = "
            r1.append(r2)
            int r2 = r4.length
            r1.append(r2)
            java.lang.String r1 = r1.toString()
            android.util.Log.d(r0, r1)
            java.io.File r0 = r3.getFilesDir()
            java.io.File r1 = new java.io.File
            java.lang.StringBuilder r2 = new java.lang.StringBuilder
            r2.<init>()
            r2.append(r0)
            java.lang.String r0 = ""
            r2.append(r0)
            java.lang.String r0 = r2.toString()
            r1.<init>(r0)
            boolean r0 = r1.exists()
            if (r0 != 0) goto L3a
            r1.mkdirs()
        L3a:
            java.io.File r0 = new java.io.File
            java.lang.StringBuilder r2 = new java.lang.StringBuilder
            r2.<init>()
            r2.append(r1)
            java.lang.String r1 = "/"
            r2.append(r1)
            r2.append(r5)
            java.lang.String r5 = r2.toString()
            r0.<init>(r5)
            r5 = 0
            boolean r1 = r0.exists()     // Catch: java.lang.Throwable -> L88 java.lang.Exception -> L8b
            if (r1 == 0) goto L5d
            r0.delete()     // Catch: java.lang.Throwable -> L88 java.lang.Exception -> L8b
        L5d:
            r0.createNewFile()     // Catch: java.lang.Throwable -> L88 java.lang.Exception -> L8b
            java.io.FileOutputStream r1 = new java.io.FileOutputStream     // Catch: java.lang.Throwable -> L88 java.lang.Exception -> L8b
            r1.<init>(r0)     // Catch: java.lang.Throwable -> L88 java.lang.Exception -> L8b
            java.io.BufferedOutputStream r0 = new java.io.BufferedOutputStream     // Catch: java.lang.Throwable -> L80 java.lang.Exception -> L84
            r0.<init>(r1)     // Catch: java.lang.Throwable -> L80 java.lang.Exception -> L84
            r0.write(r4)     // Catch: java.lang.Throwable -> L7c java.lang.Exception -> L7e
            r0.flush()     // Catch: java.lang.Throwable -> L7c java.lang.Exception -> L7e
            r1.close()     // Catch: java.io.IOException -> L74
            goto L78
        L74:
            r4 = move-exception
            r4.printStackTrace()
        L78:
            r0.close()     // Catch: java.lang.Exception -> La0
            goto La4
        L7c:
            r4 = move-exception
            goto L82
        L7e:
            r4 = move-exception
            goto L86
        L80:
            r4 = move-exception
            r0 = r5
        L82:
            r5 = r1
            goto Lb3
        L84:
            r4 = move-exception
            r0 = r5
        L86:
            r5 = r1
            goto L8d
        L88:
            r4 = move-exception
            r0 = r5
            goto Lb3
        L8b:
            r4 = move-exception
            r0 = r5
        L8d:
            r4.printStackTrace()     // Catch: java.lang.Throwable -> Lb2
            if (r5 == 0) goto L9a
            r5.close()     // Catch: java.io.IOException -> L96
            goto L9a
        L96:
            r4 = move-exception
            r4.printStackTrace()
        L9a:
            if (r0 == 0) goto La4
            r0.close()     // Catch: java.lang.Exception -> La0
            goto La4
        La0:
            r4 = move-exception
            r4.printStackTrace()
        La4:
            java.lang.String[] r4 = r3.fileList()
            int r5 = r4.length
            r0 = 0
        Laa:
            if (r0 >= r5) goto Lb1
            r1 = r4[r0]
            int r0 = r0 + 1
            goto Laa
        Lb1:
            return
        Lb2:
            r4 = move-exception
        Lb3:
            if (r5 == 0) goto Lbd
            r5.close()     // Catch: java.io.IOException -> Lb9
            goto Lbd
        Lb9:
            r5 = move-exception
            r5.printStackTrace()
        Lbd:
            if (r0 == 0) goto Lc7
            r0.close()     // Catch: java.lang.Exception -> Lc3
            goto Lc7
        Lc3:
            r5 = move-exception
            r5.printStackTrace()
        Lc7:
            throw r4
        */
        throw new UnsupportedOperationException("Method not decompiled: com.brytonsport.active.service.BleService.createFileWithByte(byte[], java.lang.String):void");
    }

    private void receiveVoiceFile() {
        if (this.cmdSpeech2TextType != 0) {
            this.nowSentPlanTripName = this.voiceSendPlanTripName;
        }
        isGetWavFile = true;
        this.cmd17FirstGetFileSize = true;
        SampleGattAttributes.isGetFileRangePhase2 = false;
        this.postDataChunkSizeTx = 6930;
        if (this.handshakePayloadObj != null) {
            try {
                BleUtil.getInstance().config(this.handshakePayloadObj.getInt("payloadSize"), this.handshakePayloadObj.getInt("handShakeSize"), 3700, 6930);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
        BleUtil.getInstance().getFileRange(0, (byte) 1, 0, 4);
    }

    private void sendVoiceTrip() {
        this.nowSentPlanTripName = this.voiceSendPlanTripName;
        new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda5
            @Override // java.lang.Runnable
            public final void run() {
                BleService.this.m133lambda$sendVoiceTrip$5$combrytonsportactiveserviceBleService();
            }
        }).start();
    }

    /* renamed from: lambda$sendVoiceTrip$5$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m133lambda$sendVoiceTrip$5$combrytonsportactiveserviceBleService() {
        byte[] bufToDataPkg;
        byte[] bArr = new byte[0];
        File filesDir = getFilesDir();
        try {
            if (Build.VERSION.SDK_INT >= 26) {
                bArr = Files.readAllBytes(Paths.get(filesDir + "/voice.fit", new String[0]));
            } else {
                File file = new File(filesDir + File.separator + "voice.fit");
                int length = (int) file.length();
                bArr = new byte[length];
                BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(file));
                bufferedInputStream.read(bArr, 0, length);
                bufferedInputStream.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.CompressPlantrip) > 0) {
            try {
                bArr = GZipUtils.compress(bArr);
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }
        int length2 = bArr.length;
        int i = this.DOWNLOAD_SIZE;
        int length3 = length2 % i == 0 ? bArr.length / i : (bArr.length / i) + 1;
        if (bArr.length % i != 0) {
            i = bArr.length % i;
        }
        this.sendFileList = new ArrayList();
        this.sendFileCount = 0;
        int i2 = 0;
        for (int i3 = 0; i3 < length3; i3++) {
            if (i3 == length3 - 1) {
                bufToDataPkg = ParserUtil.bufToDataPkg(bArr, i2, i);
            } else {
                bufToDataPkg = ParserUtil.bufToDataPkg(bArr, i2, this.DOWNLOAD_SIZE);
                i2 += this.DOWNLOAD_SIZE;
            }
            this.sendFileList.add(bufToDataPkg);
        }
        if (this.sendFileList.size() > 0) {
            sendFileToDevice(11, this.sendFileList.get(0));
            this.sendFileCount++;
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendFileToDevice(int sendFileType, byte[] data) {
        setServiceState(16);
        BleUtil.getInstance().postData(sendFileType, data);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void speech2textNoNetworkAction() {
        removeFromIgnoreAction();
        BleUtil.getInstance().setSpeechToText(3);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void speech2textNoResultAction() {
        BleUtil.getInstance().setSpeechToText(6);
    }

    private void speech2text(String lang, String wavBinary) {
        JSONObject jSONObject = new JSONObject();
        try {
            jSONObject.put("encoding", "LINEAR16");
            jSONObject.put(SettingLanguageUtil.DEVICE_MODEL, BasicDevelopMode.DEFAULT);
            jSONObject.put("languageCode", lang);
            jSONObject.put("audioContent", wavBinary);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        final String jSONObject2 = jSONObject.toString();
        this.mQueue.add(new StringRequest(1, this.speech2textUrl, new Response.Listener<String>() { // from class: com.brytonsport.active.service.BleService.17
            @Override // com.android.volley.Response.Listener
            public void onResponse(String response) {
                BleService.this.removeFromIgnoreAction();
                if (response != null) {
                    String str = BleService.TAG;
                    Log.d(str, "speech2text -> " + response.toString());
                    try {
                        JSONArray jSONArray = new JSONArray(response).getJSONObject(0).getJSONArray("results");
                        if (jSONArray.length() == 0) {
                            BleService.this.transcript = "";
                        } else {
                            BleService.this.transcript = jSONArray.getJSONObject(0).getJSONArray("alternatives").getJSONObject(0).getString("transcript");
                        }
                        String str2 = BleService.TAG;
                        Log.d(str2, "transcript -> " + BleService.this.transcript);
                        if (!BleService.this.transcript.isEmpty()) {
                            BleUtil.getInstance().setVoiceResult(BleService.this.transcript);
                            BleService bleService = BleService.this;
                            bleService.broadcastStringData(BleService.SERVICE_VOICE_TO_TEXT_RESULT, bleService.transcript);
                            if (BleService.this.cmdSpeech2TextType == 1) {
                                if (!BleService.this.isNetworkConnect()) {
                                    BleService.this.speech2textNoNetworkAction();
                                    return;
                                }
                                BleService bleService2 = BleService.this;
                                bleService2.searchPoi(bleService2.transcript);
                                return;
                            }
                            return;
                        }
                        String str3 = BleService.TAG;
                        Log.d(str3, "語音轉文字查不到 transcript -> " + BleService.this.transcript);
                        BleService.this.speech2textNoResultAction();
                    } catch (JSONException e2) {
                        e2.printStackTrace();
                    }
                }
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.18
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                BleService.this.removeFromIgnoreAction();
                Log.d("Error.Response", error.toString());
                NetworkResponse networkResponse = error.networkResponse;
                if (!(error instanceof ServerError) || networkResponse == null) {
                    return;
                }
                try {
                    JSONObject jSONObject3 = new JSONObject(new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers, "utf-8")));
                    String str = BleService.TAG;
                    Log.d(str, "onErrorResponse: " + jSONObject3.toString());
                } catch (UnsupportedEncodingException e2) {
                    e2.printStackTrace();
                } catch (JSONException e3) {
                    e3.printStackTrace();
                }
            }
        }) { // from class: com.brytonsport.active.service.BleService.19
            @Override // com.android.volley.Request
            public Map<String, String> getHeaders() throws AuthFailureError {
                HashMap hashMap = new HashMap();
                hashMap.put("content-type", "application/json; charset=UTF-8");
                hashMap.put("timeout", "30000");
                return hashMap;
            }

            @Override // com.android.volley.Request
            public byte[] getBody() throws AuthFailureError {
                String str = jSONObject2;
                if (str == null) {
                    return null;
                }
                return str.getBytes();
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    /* JADX WARN: Removed duplicated region for block: B:13:0x0053  */
    /* JADX WARN: Removed duplicated region for block: B:16:0x005f  */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    public void searchPoi(final java.lang.String r16) {
        /*
            Method dump skipped, instructions count: 241
            To view this dump change 'Code comments level' option to 'DEBUG'
        */
        throw new UnsupportedOperationException("Method not decompiled: com.brytonsport.active.service.BleService.searchPoi(java.lang.String):void");
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void findPlaceFromQuery(String keyword) {
        String str = this.placeFindPlaceBaseUrl + "&input=" + keyword + "&inputtype=textquery&fields=name%2Cgeometry&key=" + BuildConfig.PLACE_API_KEY;
        Log.d(TAG, "findPlaceFromQuery: " + str);
        this.mQueue.add(new StringRequest(0, str, new Response.Listener<String>() { // from class: com.brytonsport.active.service.BleService.23
            @Override // com.android.volley.Response.Listener
            public void onResponse(String response) {
                String str2 = BleService.TAG;
                Log.d(str2, "findPlaceFromQuery -> " + response);
                if (response != null) {
                    try {
                        JSONObject jSONObject = new JSONObject(response).getJSONArray("candidates").getJSONObject(0);
                        BleService.this.searchPlaceLat = jSONObject.getJSONObject("geometry").getJSONObject(FirebaseAnalytics.Param.LOCATION).getDouble("lat");
                        BleService.this.searchPlaceLng = jSONObject.getJSONObject("geometry").getJSONObject(FirebaseAnalytics.Param.LOCATION).getDouble("lng");
                        BleService bleService = BleService.this;
                        bleService.searchPoi(bleService.transcript);
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                    new JSONObject();
                }
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.24
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                Log.d("Error.Response", error.toString());
                NetworkResponse networkResponse = error.networkResponse;
                if (!(error instanceof ServerError) || networkResponse == null) {
                    return;
                }
                try {
                    JSONObject jSONObject = new JSONObject(new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers, "utf-8")));
                    String str2 = BleService.TAG;
                    Log.d(str2, "onErrorResponse: " + jSONObject.toString());
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                } catch (JSONException e2) {
                    e2.printStackTrace();
                }
            }
        }) { // from class: com.brytonsport.active.service.BleService.25
            @Override // com.android.volley.Request
            public Map<String, String> getHeaders() throws AuthFailureError {
                return new HashMap();
            }
        });
    }

    private void processSurpriseMeDistance(JSONObject jsonObject) {
        if (!isNetworkConnect()) {
            BleUtil.getInstance().setSurpriseMeDistance(3);
            return;
        }
        this.devSendSurpriseMeDistance = -1;
        try {
            this.devSendSurpriseMeDistance = jsonObject.getInt("value");
        } catch (JSONException e) {
            e.printStackTrace();
        }
        if (this.devSendSurpriseMeDistance > -1) {
            if (this.mLastLocation == null) {
                BleUtil.getInstance().setSurpriseMeDistance(7);
                return;
            }
            JSONObject jSONObject = new JSONObject();
            this.nowPosForSurpriseMeDistance = jSONObject;
            try {
                jSONObject.put("lat", this.mLastLocation.getLatitude());
                this.nowPosForSurpriseMeDistance.put("lng", this.mLastLocation.getLongitude());
            } catch (JSONException e2) {
                e2.printStackTrace();
            }
            JSONObject jSONObject2 = new JSONObject();
            try {
                jSONObject2.put("type", "distance_limit");
                jSONObject2.put("data", this.devSendSurpriseMeDistance * 1000);
            } catch (JSONException e3) {
                e3.printStackTrace();
            }
            JSONArray surpriseMePoints = getSurpriseMePoints(this.nowPosForSurpriseMeDistance, jSONObject2);
            this.surpriseMePointArray = surpriseMePoints;
            this.surpriseMeIndex = 0;
            this.surpriseMeTotalCount = surpriseMePoints.length();
            this.surpriseMeSurpriseData = new JSONArray();
            this.surpriseMeSendFileData = new JSONArray();
            checkCallGraphHopperRoute();
            return;
        }
        BleUtil.getInstance().setSurpriseMeDistance(6);
    }

    private void checkCallGraphHopperRoute() {
        int i = this.surpriseMeIndex;
        if (i < this.surpriseMeTotalCount) {
            try {
                getGraphHopperRoute(this.surpriseMePointArray.getJSONObject(i));
                return;
            } catch (JSONException e) {
                e.printStackTrace();
                return;
            }
        }
        BleUtil.getInstance().setSurpriseMeDistance(1);
        saveSurpriseMeToFile();
        sendSurpriseMeFileToDev();
    }

    private void saveSurpriseMeToFile() {
        JSONArray jSONArray = this.surpriseMeSendFileData;
        if (jSONArray != null) {
            createFileWithByte(jSONArray.toString().getBytes(), this.mWoSurpriseMeFileName);
        }
    }

    private void sendSurpriseMeFileToDev() {
        byte[] bufToDataPkg;
        byte[] fileByteArray = FileUtil.getFileByteArray(getFilesDir() + UsbFile.separator + this.mWoSurpriseMeFileName);
        int length = fileByteArray.length;
        int i = this.DOWNLOAD_SIZE;
        int length2 = length % i == 0 ? fileByteArray.length / i : (fileByteArray.length / i) + 1;
        if (fileByteArray.length % i != 0) {
            i = fileByteArray.length % i;
        }
        this.sendFileList = new ArrayList();
        this.sendFileCount = 0;
        int i2 = 0;
        for (int i3 = 0; i3 < length2; i3++) {
            if (i3 == length2 - 1) {
                bufToDataPkg = ParserUtil.bufToDataPkg(fileByteArray, i2, i);
            } else {
                bufToDataPkg = ParserUtil.bufToDataPkg(fileByteArray, i2, this.DOWNLOAD_SIZE);
                i2 += this.DOWNLOAD_SIZE;
            }
            this.sendFileList.add(bufToDataPkg);
        }
        if (this.sendFileList.size() > 0) {
            sendFileToDevice(16, this.sendFileList.get(0));
            this.sendFileCount++;
        }
    }

    private JSONArray getSurpriseMePoints(JSONObject pos, JSONObject opt) {
        JSONArray jSONArray = new JSONArray();
        for (int i = 0; i < 3; i++) {
            try {
                JSONObject jSONObject = new JSONObject();
                jSONObject.put("seed", i);
                jSONObject.put("pos", pos);
                jSONObject.put("dist", opt.getInt("data"));
                jSONArray.put(jSONObject);
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
        return jSONArray;
    }

    /* JADX WARN: Can't wrap try/catch for region: R(10:1|(2:2|3)|4|(2:5|6)|(2:7|8)|10|11|12|13|(1:(0))) */
    /* JADX WARN: Code restructure failed: missing block: B:18:0x0030, code lost:
        r9 = move-exception;
     */
    /* JADX WARN: Code restructure failed: missing block: B:19:0x0031, code lost:
        r9.printStackTrace();
     */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
        To view partially-correct code enable 'Show inconsistent code' option in preferences
    */
    private void getGraphHopperRoute(org.json.JSONObject r9) {
        /*
            r8 = this;
            r0 = -1
            java.lang.String r1 = "seed"
            int r1 = r9.getInt(r1)     // Catch: org.json.JSONException -> L8
            goto Ld
        L8:
            r1 = move-exception
            r1.printStackTrace()
            r1 = -1
        Ld:
            r2 = 0
            java.lang.String r4 = "pos"
            org.json.JSONObject r4 = r9.getJSONObject(r4)     // Catch: org.json.JSONException -> L24
            java.lang.String r5 = "lat"
            double r5 = r4.getDouble(r5)     // Catch: org.json.JSONException -> L24
            java.lang.String r7 = "lng"
            double r2 = r4.getDouble(r7)     // Catch: org.json.JSONException -> L22
            goto L29
        L22:
            r4 = move-exception
            goto L26
        L24:
            r4 = move-exception
            r5 = r2
        L26:
            r4.printStackTrace()
        L29:
            java.lang.String r4 = "dist"
            int r0 = r9.getInt(r4)     // Catch: org.json.JSONException -> L30
            goto L34
        L30:
            r9 = move-exception
            r9.printStackTrace()
        L34:
            com.brytonsport.active.utils.ProfileUtil r9 = com.brytonsport.active.utils.ProfileUtil.getInstance()
            java.lang.String r4 = "setting_voice_plan_mode"
            java.lang.Object r9 = r9.get(r4)
            java.lang.String r9 = (java.lang.String) r9
            java.lang.StringBuilder r4 = new java.lang.StringBuilder
            r4.<init>()
            java.lang.String r7 = r8.graphHopperBaseUrl
            r4.append(r7)
            java.lang.String r7 = "route?point="
            r4.append(r7)
            r4.append(r5)
            java.lang.String r5 = ","
            r4.append(r5)
            r4.append(r2)
            java.lang.String r2 = "&ch.disable=true&algorithm=round_trip&round_trip.distance="
            r4.append(r2)
            r4.append(r0)
            java.lang.String r0 = "&round_trip.seed="
            r4.append(r0)
            r4.append(r1)
            java.lang.String r0 = "&elevation=true&vehicle="
            r4.append(r0)
            r4.append(r9)
            java.lang.String r9 = "&key="
            r4.append(r9)
            java.lang.String r9 = r8.graphHopperKey
            r4.append(r9)
            java.lang.String r9 = r4.toString()
            java.lang.String r0 = com.brytonsport.active.service.BleService.TAG
            java.lang.StringBuilder r1 = new java.lang.StringBuilder
            r1.<init>()
            java.lang.String r2 = "getGraphHopperRoute: url -> "
            r1.append(r2)
            r1.append(r9)
            java.lang.String r1 = r1.toString()
            android.util.Log.d(r0, r1)
            com.android.volley.toolbox.JsonObjectRequest r0 = new com.android.volley.toolbox.JsonObjectRequest
            com.brytonsport.active.service.BleService$26 r1 = new com.brytonsport.active.service.BleService$26
            r1.<init>()
            com.brytonsport.active.service.BleService$27 r2 = new com.brytonsport.active.service.BleService$27
            r2.<init>()
            r0.<init>(r9, r1, r2)
            com.android.volley.RequestQueue r9 = r8.mQueue
            r9.add(r0)
            return
        */
        throw new UnsupportedOperationException("Method not decompiled: com.brytonsport.active.service.BleService.getGraphHopperRoute(org.json.JSONObject):void");
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void surpriseEncodeRoute(JSONObject jsonObject) {
        JSONArray jSONArray = new JSONArray();
        JSONObject jSONObject = new JSONObject();
        JSONArray jSONArray2 = new JSONArray();
        JSONObject jSONObject2 = new JSONObject();
        try {
            jSONObject2.put("distance", jsonObject.getDouble("distance"));
            jSONObject2.put("gain", jsonObject.getDouble("ascend"));
            jSONObject2.put("loss", jsonObject.getDouble("descend"));
            jSONObject2.put(Parameters.Routing.INSTRUCTIONS, jsonObject.getJSONArray(Parameters.Routing.INSTRUCTIONS));
            jSONObject2.put(ResultShareActivity.POINTS, jsonObject.getJSONArray(ResultShareActivity.POINTS));
            jSONArray2.put(jSONObject2);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        JSONObject jSONObject3 = new JSONObject();
        try {
            jSONObject3.put("major", 0);
            jSONObject3.put("minor", 1);
        } catch (JSONException e2) {
            e2.printStackTrace();
        }
        try {
            jSONObject.put("paths", jSONArray2);
            jSONObject.put("version", jSONObject3);
        } catch (JSONException e3) {
            e3.printStackTrace();
        }
        jSONArray.put(jSONObject);
        Log.d(TAG, "surpriseEncodeRoute: " + jSONArray.toString());
        this.surpriseMeRouteLangName = i18N.get("Route");
        if (this.surpriseMeSurpriseData != null) {
            JSONObject jSONObject4 = new JSONObject();
            try {
                jSONObject4.put("idx", this.surpriseMeIndex);
                jSONObject4.put("name", this.surpriseMeRouteLangName + (this.surpriseMeIndex + 1));
                jSONObject4.put("route", jSONObject);
                this.surpriseMeSurpriseData.put(jSONObject4);
            } catch (JSONException e4) {
                e4.printStackTrace();
            }
        }
        if (this.surpriseMeSendFileData != null) {
            JSONObject jSONObject5 = new JSONObject();
            try {
                JSONObject jSONObject6 = jSONObject.getJSONArray("paths").getJSONObject(0);
                jSONObject5.put("idx", this.surpriseMeIndex);
                jSONObject5.put("name", this.surpriseMeRouteLangName + (this.surpriseMeIndex + 1));
                jSONObject5.put("distance", jSONObject6.getDouble("distance"));
                jSONObject5.put("latlng", this.nowPosForSurpriseMeDistance);
                jSONObject5.put("gain", jSONObject6.getDouble("gain"));
                this.surpriseMeSendFileData.put(jSONObject5);
            } catch (JSONException e5) {
                e5.printStackTrace();
            }
        }
        this.surpriseMeIndex++;
        checkCallGraphHopperRoute();
    }

    private void processSurpriseMeSelectId(JSONObject jsonObject) {
        int i;
        try {
            i = jsonObject.getInt("value");
        } catch (JSONException e) {
            e.printStackTrace();
            i = -1;
        }
        if (this.surpriseMeSurpriseData != null) {
            for (int i2 = 0; i2 < this.surpriseMeSurpriseData.length(); i2++) {
                try {
                    JSONObject jSONObject = this.surpriseMeSurpriseData.getJSONObject(i2);
                    if (jSONObject.getInt("idx") == i) {
                        this.nowSentPlanTripName = this.voiceSendPlanTripName;
                        prepareSurpriseMeRoute(jSONObject.getJSONObject("route"));
                        return;
                    }
                } catch (JSONException e2) {
                    e2.printStackTrace();
                    return;
                }
            }
        }
    }

    private void prepareSurpriseMeRoute(JSONObject jsonData) {
        JSONArray jSONArray = new JSONArray();
        jSONArray.put(jsonData);
        try {
            parseNavigation(jSONArray);
        } catch (Exception unused) {
            BleUtil.getInstance().setSurpriseMeDistance(6);
        }
    }

    private void reportData(JSONObject resultObj) {
        JSONObject jSONObject;
        this.liveTrackUserId = (String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID);
        String str = this.liveTrackBaseUrl + "report/" + this.liveTrackGroupId;
        JSONObject jSONObject2 = new JSONObject();
        JSONObject jSONObject3 = new JSONObject();
        JSONObject jSONObject4 = new JSONObject();
        JSONObject jSONObject5 = new JSONObject();
        try {
            jSONObject2.put("playerId", this.liveTrackUserId);
            jSONObject5.put("lat", resultObj.get("lat"));
            jSONObject5.put("lng", resultObj.get("lon"));
            jSONObject3.put("id", this.liveTrackUserId);
            try {
                jSONObject3.put(Consts.TIMESTAMP, new Date().getTime());
                jSONObject3.put(FirebaseAnalytics.Param.LOCATION, jSONObject5);
                jSONObject3.put(DirectionsCriteria.ANNOTATION_SPEED, resultObj.get("spd"));
                jSONObject3.put("ridetime", resultObj.get("rideTime"));
                jSONObject3.put("triptime", resultObj.get("tripTime"));
                jSONObject3.put("distance", resultObj.get("distance"));
                try {
                    jSONObject3.put("state", resultObj.get("state"));
                    jSONObject4.put("id", this.liveTrackUserId);
                    jSONObject4.put(Consts.TIMESTAMP, new Date().getTime());
                    jSONObject4.put(FirebaseAnalytics.Param.LOCATION, jSONObject5);
                    jSONObject4.put(DirectionsCriteria.ANNOTATION_SPEED, resultObj.get("spd"));
                    jSONObject4.put("ridetime", resultObj.get("rideTime"));
                    jSONObject4.put("triptime", resultObj.get("tripTime"));
                    jSONObject4.put("distance", resultObj.get("distance"));
                    jSONObject4.put("state", resultObj.get("state"));
                    this.liveTrackHistoryQueue.put(jSONObject4);
                    jSONObject = jSONObject2;
                } catch (JSONException e) {
                    e = e;
                    jSONObject = jSONObject2;
                }
            } catch (JSONException e2) {
                e = e2;
                jSONObject = jSONObject2;
            }
            try {
                jSONObject.put("current", jSONObject3);
                jSONObject.put("history", this.liveTrackHistoryQueue);
            } catch (JSONException e3) {
                e = e3;
                e.printStackTrace();
                this.mQueue.add(new JsonObjectRequest(2, str, jSONObject, new Response.Listener<JSONObject>() { // from class: com.brytonsport.active.service.BleService.28
                    @Override // com.android.volley.Response.Listener
                    public void onResponse(JSONObject response) {
                        Log.d("reportData -> ", response.toString());
                        BleService.this.liveTrackHistoryQueue = null;
                        BleService.this.liveTrackHistoryQueue = new JSONArray();
                    }
                }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.29
                    @Override // com.android.volley.Response.ErrorListener
                    public void onErrorResponse(VolleyError error) {
                        Log.d("Error.Response", error.toString());
                    }
                }));
            }
        } catch (JSONException e4) {
            e = e4;
            jSONObject = jSONObject2;
        }
        this.mQueue.add(new JsonObjectRequest(2, str, jSONObject, new Response.Listener<JSONObject>() { // from class: com.brytonsport.active.service.BleService.28
            @Override // com.android.volley.Response.Listener
            public void onResponse(JSONObject response) {
                Log.d("reportData -> ", response.toString());
                BleService.this.liveTrackHistoryQueue = null;
                BleService.this.liveTrackHistoryQueue = new JSONArray();
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.29
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                Log.d("Error.Response", error.toString());
            }
        }));
    }

    private void createGroup() {
        this.liveTrackUserId = (String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID);
        this.liveTrackUserNickName = (String) ProfileUtil.getInstance().get(ProfileUtil.NICK_NAME);
        this.liveTrackUserIcon = (String) ProfileUtil.getInstance().get(ProfileUtil.AVATAR_IMG);
        String str = this.liveTrackBaseUrl + "groups";
        JSONObject jSONObject = new JSONObject();
        JSONObject jSONObject2 = new JSONObject();
        try {
            jSONObject.put("cred", this.liveTrackGroupCred);
            jSONObject.put("expiration", 0);
            jSONObject2.put("id", this.liveTrackUserId);
            jSONObject2.put("nickname", this.liveTrackUserNickName);
            jSONObject2.put(BannerComponents.ICON, this.liveTrackUserIcon);
            jSONObject.put("info", jSONObject2);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        this.mQueue.add(new JsonObjectRequest(1, str, jSONObject, new Response.Listener<JSONObject>() { // from class: com.brytonsport.active.service.BleService.30
            @Override // com.android.volley.Response.Listener
            public void onResponse(JSONObject response) {
                Log.d(BleService.TAG, "createGroup -> " + response.toString());
                if (response != null) {
                    try {
                        BleService.this.liveTrackGroupId = response.getString("result");
                    } catch (JSONException e2) {
                        e2.printStackTrace();
                    }
                }
                Log.d(BleService.TAG, "onResponse: createGroup liveTrackGroupId = " + BleService.this.liveTrackGroupId);
                ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_GROUP_ID, BleService.this.liveTrackGroupId);
                ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_GROUP_CRED, BleService.this.liveTrackGroupCred);
                boolean z = true;
                BleService.this.broadcastLiveTrackManualStartState(BleService.SERVICE_LIVE_TRACK_MANUAL_STATE, true);
                ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_MANUAL_STATE, true);
                BleService.this.broadcastLiveTrackShareBtnVisible(BleService.SERVICE_LIVE_TRACK_SHARE_BTN_VISIBLE, true);
                ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_SHARE_BTN_VISIBLE, true);
                BleService.this.liveTrackAutoSendMail = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_AUTO_SEND_MAIL)).booleanValue();
                String str2 = (String) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_EMAIL_LIST);
                if (!str2.isEmpty()) {
                    try {
                        JSONArray jSONArray = new JSONArray(str2);
                        String str3 = "";
                        for (int i = 0; i < jSONArray.length(); i++) {
                            str3 = str3 + "{\"email\":\"" + jSONArray.getString(i) + "\"}";
                            if (i < jSONArray.length() - 1) {
                                str3 = str3 + ToStringHelper.COMMA_SEPARATOR;
                            }
                        }
                        BleService.this.sendMailReceiver = "[" + str3 + "]";
                        BleService bleService = BleService.this;
                        if (str3.isEmpty()) {
                            z = false;
                        }
                        bleService.liveTrackHasMailToSend = z;
                    } catch (JSONException e3) {
                        e3.printStackTrace();
                    }
                }
                if (BleService.this.liveTrackAutoSendMail && BleService.this.liveTrackHasMailToSend) {
                    BleService.this.sendmail();
                }
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.31
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                Log.d("Error.Response", error.toString());
            }
        }));
    }

    private void addOperation(String action) {
        addOperation(action, null);
    }

    private void addOperation(final String action, final JSONObject deviceSendObj) {
        Log.d(TAG, "addOperation: 執行 " + action);
        this.liveTrackGroupId = (String) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_GROUP_ID);
        this.liveTrackGroupCred = (String) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_GROUP_CRED);
        String str = this.liveTrackBaseUrl + "groups/" + this.liveTrackGroupId + "/operation";
        JSONObject jSONObject = new JSONObject();
        JSONObject jSONObject2 = new JSONObject();
        try {
            jSONObject.put(PhotoActivity.EXTRAS_ACTION, action);
            if (action.equals(LIVE_TRACK_OP_DELETE_GROUP)) {
                jSONObject2.put("cred", this.liveTrackGroupCred);
                jSONObject.put("payload", jSONObject2);
            }
        } catch (JSONException e) {
            e.printStackTrace();
        }
        this.mQueue.add(new JsonObjectRequest(2, str, jSONObject, new Response.Listener<JSONObject>() { // from class: com.brytonsport.active.service.BleService.32
            @Override // com.android.volley.Response.Listener
            public void onResponse(JSONObject response) {
                String str2 = BleService.TAG;
                Log.d(str2, "addOperation -> " + response.toString());
                if (action.equals(BleService.LIVE_TRACK_OP_DELETE_GROUP)) {
                    BleService.this.liveTrackGroupId = "";
                    BleService.this.liveTrackGroupCred = "";
                    ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_GROUP_ID, "");
                    ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_GROUP_CRED, "");
                    ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_EXTEND_24_TIME_STAMP, 0L);
                } else if (action.equals(BleService.LIVE_TRACK_OP_CLEAR)) {
                    BleService.this.isClearHistory = true;
                    if (deviceSendObj != null) {
                        Log.d(BleService.TAG, "onResponse: 清完歷史紀錄 走原本檢查流程");
                        BleService.this.checkExtend24AndReportDta(deviceSendObj);
                    }
                }
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.33
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                Log.d("Error.Response", error.toString());
            }
        }));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void checkClearHistory(JSONObject deviceSendObj, JSONObject serverCurrentObj) {
        int i;
        try {
            i = deviceSendObj.getInt("tripTime");
        } catch (JSONException e) {
            e.printStackTrace();
            i = 0;
        }
        String str = (String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID);
        this.liveTrackUserId = str;
        if (serverCurrentObj != null) {
            try {
                if (serverCurrentObj.has(str)) {
                    JSONObject jSONObject = serverCurrentObj.getJSONObject(this.liveTrackUserId);
                    int i2 = jSONObject.getInt("triptime");
                    long j = jSONObject.getLong(Consts.TIMESTAMP);
                    String str2 = TAG;
                    Log.d(str2, "checkClearHistory: currentTripTime (" + i2 + "), currentTimeStamp (" + j + "), deviceNowTripTime (" + i + ")");
                    if (i2 > i) {
                        Log.d(str2, "checkClearHistory: current.triptime > tripTime => 清除歷史資料");
                        addOperation(LIVE_TRACK_OP_CLEAR, deviceSendObj);
                    } else {
                        long j2 = ((i - i2) * 1000) + j;
                        if (this.allowableTimeDifference + j2 >= new Date().getTime()) {
                            Log.d(str2, "checkClearHistory: 現在時間" + new Date().getTime() + " 小於trip相減加上server timestamp（多加上緩衝） " + j2 + "=> 不清除歷史資料");
                            this.isClearHistory = true;
                            checkExtend24AndReportDta(deviceSendObj);
                        } else {
                            Log.d(str2, "checkClearHistory: 現在時間" + new Date().getTime() + " 大於trip相減加上server timestamp（多加上緩衝） " + j2 + "=> 清除歷史資料");
                            addOperation(LIVE_TRACK_OP_CLEAR, deviceSendObj);
                        }
                    }
                }
            } catch (Exception unused) {
                return;
            }
        }
        Log.d(TAG, "checkClearHistory: 還沒有紀錄，表示是新創的，直接繼續");
        this.isClearHistory = true;
        checkExtend24AndReportDta(deviceSendObj);
    }

    private void getReportCurrent(final JSONObject resultObj) {
        this.liveTrackGroupId = (String) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_GROUP_ID);
        this.mQueue.add(new StringRequest(0, this.liveTrackBaseUrl + "report/" + this.liveTrackGroupId + "/current", new Response.Listener<String>() { // from class: com.brytonsport.active.service.BleService.34
            @Override // com.android.volley.Response.Listener
            public void onResponse(String response) {
                String str = BleService.TAG;
                Log.d(str, "getReportCurrent -> " + response);
                if (response != null) {
                    try {
                        BleService.this.checkClearHistory(resultObj, new JSONObject(response));
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.35
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                Log.d("Error.Response", error.toString());
                NetworkResponse networkResponse = error.networkResponse;
                if (!(error instanceof ServerError) || networkResponse == null) {
                    return;
                }
                try {
                    JSONObject jSONObject = new JSONObject(new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers, "utf-8")));
                    String str = BleService.TAG;
                    Log.d(str, "onErrorResponse: " + jSONObject.toString());
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                } catch (JSONException e2) {
                    e2.printStackTrace();
                }
            }
        }) { // from class: com.brytonsport.active.service.BleService.36
            @Override // com.android.volley.Request
            public Map<String, String> getHeaders() throws AuthFailureError {
                HashMap hashMap = new HashMap();
                hashMap.put("timeout", "30000");
                return hashMap;
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void checkExtend24AndReportDta(JSONObject resultObj) {
        int i;
        try {
            i = resultObj.getInt("state");
        } catch (JSONException e) {
            e.printStackTrace();
            i = -1;
        }
        boolean booleanValue = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_EXTEND_24_HOUR)).booleanValue();
        this.liveTrackExtend24Hour = booleanValue;
        if (i == LIVE_TRACK_STATE_START && booleanValue && this.liveTrack24HourNeedClear) {
            this.liveTrack24HourNeedClear = false;
            addOperation(LIVE_TRACK_OP_CLEAR);
            return;
        }
        reportData(resultObj);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void sendmail() {
        this.liveTrackGroupId = (String) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_GROUP_ID);
        this.sendMailContent = LiveTrackUtil.emailContent((String) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_EMAIL_MESSAGE), this.liveTrackGroupId, (String) ProfileUtil.getInstance().get(ProfileUtil.NICK_NAME));
        this.mQueue.add(new StringRequest(1, this.sendMailUrl, new Response.Listener<String>() { // from class: com.brytonsport.active.service.BleService.37
            @Override // com.android.volley.Response.Listener
            public void onResponse(String response) {
                Log.d("sendmail -> Response", response.toString());
            }
        }, new Response.ErrorListener() { // from class: com.brytonsport.active.service.BleService.38
            @Override // com.android.volley.Response.ErrorListener
            public void onErrorResponse(VolleyError error) {
                Log.d("Error.Response", error.toString());
                NetworkResponse networkResponse = error.networkResponse;
                if (!(error instanceof ServerError) || networkResponse == null) {
                    return;
                }
                try {
                    JSONObject jSONObject = new JSONObject(new String(networkResponse.data, HttpHeaderParser.parseCharset(networkResponse.headers, "utf-8")));
                    String str = BleService.TAG;
                    Log.d(str, "onErrorResponse: " + jSONObject.toString());
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                } catch (JSONException e2) {
                    e2.printStackTrace();
                }
            }
        }) { // from class: com.brytonsport.active.service.BleService.39
            @Override // com.android.volley.Request
            public Map<String, String> getHeaders() throws AuthFailureError {
                HashMap hashMap = new HashMap();
                hashMap.put("authorization", String.format(BleService.this.sendMailAuthorization, BuildConfig.SEND_GRID_TOKEN));
                hashMap.put("content-type", BleService.this.sendMailContentType);
                return hashMap;
            }

            @Override // com.android.volley.Request
            public byte[] getBody() throws AuthFailureError {
                if (!BleService.this.sendMailContent.isEmpty()) {
                    BleService bleService = BleService.this;
                    bleService.sendMailContent = bleService.sendMailContent.replace("undefined", BleService.this.liveTrackGroupId);
                }
                String str = BleService.TAG;
                Log.d(str, "sendmail getBody: " + String.format(BleService.this.sendMailPostBody, BleService.this.sendMailReceiver, BleService.this.sendMailSubject, BleService.this.sendMailContent));
                return String.format(BleService.this.sendMailPostBody, BleService.this.sendMailReceiver, BleService.this.sendMailSubject, BleService.this.sendMailContent).getBytes();
            }
        });
    }

    private void liveTrack(JSONObject resultObj) {
        this.liveTrackManualStart = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_MANUAL_START)).booleanValue();
        this.liveTrackAutoShare = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_AUTO_START)).booleanValue();
        this.liveTrackExtend24Hour = ((Boolean) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_EXTEND_24_HOUR)).booleanValue();
        this.liveTrackGroupId = (String) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_GROUP_ID);
        this.liveTrackGroupCred = (String) ProfileUtil.getInstance().get(ProfileUtil.LIVE_TRACK_GROUP_CRED);
        if (this.liveTrackAutoShare || this.liveTrackManualStart) {
            int i = -1;
            try {
                i = resultObj.getInt("state");
            } catch (JSONException e) {
                e.printStackTrace();
            }
            if (this.liveTrackGroupId.isEmpty() && this.liveTrackGroupCred.isEmpty()) {
                this.liveTrackGroupCred = LiveTrackUtil.generateString(new SecureRandom(), LiveTrackUtil.alphanum, 20);
                createGroup();
            } else if (i == LIVE_TRACK_STATE_START && this.liveTrackExtend24Hour && this.liveTrack24HourNeedClear) {
                this.liveTrack24HourNeedClear = false;
                Log.d(TAG, "執行 LIVE_TRACK_OP_CLEAR ");
                addOperation(LIVE_TRACK_OP_CLEAR);
            } else if (!this.isClearHistory) {
                getReportCurrent(resultObj);
            } else {
                checkExtend24AndReportDta(resultObj);
            }
            if (i == LIVE_TRACK_STATE_STOP) {
                broadcastLiveTrackManualStartState(SERVICE_LIVE_TRACK_MANUAL_STATE, false);
                ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_MANUAL_STATE, false);
                if (this.liveTrackExtend24Hour) {
                    this.liveTrack24HourTimeStamp = new Timestamp(System.currentTimeMillis()).getTime();
                    this.liveTrack24HourNeedClear = true;
                    String str = TAG;
                    Log.d(str, "liveTrack24HourTimeStamp = " + this.liveTrack24HourTimeStamp);
                    ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_EXTEND_24_TIME_STAMP, Long.valueOf(this.liveTrack24HourTimeStamp));
                    broadcastLiveTrackShareBtnVisible(SERVICE_LIVE_TRACK_SHARE_BTN_VISIBLE, true);
                    ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_SHARE_BTN_VISIBLE, true);
                    return;
                }
                addOperation(LIVE_TRACK_OP_DELETE_GROUP);
                broadcastLiveTrackShareBtnVisible(SERVICE_LIVE_TRACK_SHARE_BTN_VISIBLE, false);
                ProfileUtil.getInstance().set(ProfileUtil.LIVE_TRACK_SHARE_BTN_VISIBLE, false);
            }
        }
    }

    public void notifyAppCombine(String name, String title, String content) {
        if (name.equals(title)) {
            title = "";
        }
        if (this.devSptNotification) {
            JSONArray jSONArray = new JSONArray();
            jSONArray.put(ConstSettingChannel.DEVICE_CMD_SET_NOTIFICATION);
            jSONArray.put(name);
            jSONArray.put(title);
            jSONArray.put(content);
            passSettingCommand(jSONArray);
            return;
        }
        notifyApplication(name, title, content);
    }

    private void processDevEnterLeaveWifiPage(JSONObject jsonObject) {
        int i;
        try {
            i = jsonObject.getInt("state");
        } catch (JSONException e) {
            e.printStackTrace();
            i = -1;
        }
        ProfileUtil.getInstance().set(ProfileUtil.DEV_ENTER_LEAVE_WIFI_PAGE_STATE, Integer.valueOf(i));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void resetIsCancelPostDataState() {
        this.isCancelPostData = false;
    }

    private void sendNotification(String title, String message) {
        Intent intent = new Intent(this, SplashActivity.class);
        intent.addFlags(67108864);
        NotificationCompat.Builder contentIntent = new NotificationCompat.Builder(this, "Activity Upload Channel").setSmallIcon(R.drawable.icon_system_notification).setColor(ContextCompat.getColor(this, R.color.main_green)).setContentTitle(title).setContentText(message).setAutoCancel(true).setContentIntent(PendingIntent.getActivity(this, 0, intent, 67108864));
        NotificationManager notificationManager = (NotificationManager) getSystemService("notification");
        if (Build.VERSION.SDK_INT >= 26) {
            notificationManager.createNotificationChannel(new NotificationChannel("Activity Upload Channel", "Activity Upload Channel", 3));
        }
        notificationManager.notify(0, contentIntent.build());
    }

    public void reBootAndCheckHasDeviceConnect() {
        new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda4
            @Override // java.lang.Runnable
            public final void run() {
                BleService.this.m132x3367ba25();
            }
        }).start();
    }

    /* renamed from: lambda$reBootAndCheckHasDeviceConnect$6$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m132x3367ba25() {
        DeviceManagerEntity loadDeviceIsChoice = this.deviceRepository.loadDeviceIsChoice();
        if (loadDeviceIsChoice != null) {
            checkHasDeviceConnect(loadDeviceIsChoice);
        }
    }

    public void startCheckUnSaveAction() {
        this.checkUnSaveHandler.removeCallbacks(this.checkUnSaveRunnable);
        Handler handler = this.checkUnSaveHandler;
        Runnable runnable = new Runnable() { // from class: com.brytonsport.active.service.BleService.40
            @Override // java.lang.Runnable
            public void run() {
                Log.d("Leigh1111", "執行 startCheckUnSaveAction: Runnable() ");
                BleService.this.checkUnSaveFolderNeedUpload();
                BleService.this.checkUnSaveHandler.postDelayed(BleService.this.checkUnSaveRunnable, BleService.this.checkUnSaveDelay);
            }
        };
        this.checkUnSaveRunnable = runnable;
        handler.postDelayed(runnable, this.checkUnSaveDelay);
    }

    public void stopCheckUnSaveAction() {
        this.checkUnSaveHandler.removeCallbacks(this.checkUnSaveRunnable);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void checkUnSaveFolderNeedUpload() {
        if (((String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID)).isEmpty()) {
            return;
        }
        boolean checkUnSaveFiles = checkUnSaveFiles();
        if (App.getInstance().nowSyncingFitUploadState) {
            Log.d("Leigh1111", "checkUnSaveFolderNeedUpload: 正在同步中，不做上傳");
        } else if (isNetworkConnect() && checkUnSaveFiles && !App.getInstance().nowSyncingFitUploadState) {
            Log.d("Leigh1111", "checkUnSaveFolderNeedUpload ->  有網路 & unsave 有檔案 且非同步中");
            uploadFileToServer();
        } else {
            Log.d("Leigh1111", "checkUnSaveFolderNeedUpload ->   unsave 沒檔案 ");
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void setFitSyncingState(boolean state) {
        App.getInstance().nowSyncingFitUploadState = state;
        String str = TAG;
        Log.d(str, "預設同步Fit 狀態 nowSyncingFitUploadState: " + App.getInstance().nowSyncingFitUploadState);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void setRunningAllSyncFlow(boolean state) {
        App.getInstance();
        App.isRunningAllSyncFlow = state;
        String str = TAG;
        StringBuilder sb = new StringBuilder();
        sb.append("是否執行完整同步流程的狀態 isRunningAllSyncFlow: ");
        App.getInstance();
        sb.append(App.isRunningAllSyncFlow);
        Log.d(str, sb.toString());
    }

    public void runOnBgThread(Runnable r) {
        new Thread(r).start();
    }

    public void registerGpsSwitchReceiver() {
        registerReceiver(this.gpsSwitchReceiver, makeGpsSwitchIntentFilter());
    }

    public void unregisterGpsSwitchReceiver() {
        unregisterReceiver(this.gpsSwitchReceiver);
    }

    private static IntentFilter makeGpsSwitchIntentFilter() {
        IntentFilter intentFilter = new IntentFilter("android.location.PROVIDERS_CHANGED");
        intentFilter.addAction("android.intent.action.PROVIDER_CHANGED");
        return intentFilter;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void broadcastOnLocationChange(String action) {
        sendBroadcast(new Intent(action));
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void passGroupRideAction(String action) {
        passGroupRideAction(action, new byte[0]);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void passGroupRideAction(String action, byte[] requestData) {
        String str = TAG;
        Log.d(str, "團騎流程 -> 下: " + action);
        if (isGetWavFile) {
            return;
        }
        action.hashCode();
        char c = 65535;
        switch (action.hashCode()) {
            case -1827357185:
                if (action.equals(GR_ACTION_SEND_INACTIVE_MEMBER_LIST)) {
                    c = 0;
                    break;
                }
                break;
            case -1783491633:
                if (action.equals(GR_ACTION_SEND_MEMBER_LIST)) {
                    c = 1;
                    break;
                }
                break;
            case -1264175258:
                if (action.equals(GR_ACTION_SEND_GROUP_RIDE_INFO_FINISH)) {
                    c = 2;
                    break;
                }
                break;
            case -903878446:
                if (action.equals(GR_ACTION_SEND_MEMBER_UPDATE)) {
                    c = 3;
                    break;
                }
                break;
            case -833499172:
                if (action.equals(GR_ACTION_REQUEST_GROUP_TRACK_MSG)) {
                    c = 4;
                    break;
                }
                break;
            case -665703400:
                if (action.equals(GR_ACTION_GROUP_TRACK_START_POST)) {
                    c = 5;
                    break;
                }
                break;
            case 732748522:
                if (action.equals(GR_ACTION_SEND_MEMBER_MESSAGE_DATA)) {
                    c = 6;
                    break;
                }
                break;
            case 1145550831:
                if (action.equals(GR_ACTION_SEND_GROUP_RIDE_ACTIVE_MESSAGE_CAN)) {
                    c = 7;
                    break;
                }
                break;
            case 1338770161:
                if (action.equals(GR_ACTION_RECEIVE_GROUP_TRACK_MSG)) {
                    c = '\b';
                    break;
                }
                break;
            case 1760547573:
                if (action.equals(GR_ACTION_SEND_GROUP_TRACK_PLANTRIP_NAME)) {
                    c = '\t';
                    break;
                }
                break;
            case 2000140044:
                if (action.equals(GR_ACTION_SEND_GROUP_TRACK_FIT)) {
                    c = '\n';
                    break;
                }
                break;
        }
        switch (c) {
            case 0:
                postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_INACTIVE_MEMBER_LIST();
                return;
            case 1:
                postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MEMBER_LIST();
                return;
            case 2:
                sendCommendTen();
                return;
            case 3:
                postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MEMBER_UPDATE();
                return;
            case 4:
                setRunningRequestGrMsgCan(true);
                requestDataByREQUEST_FILE_TYPE_GROUP_TRACK_MSG();
                return;
            case 5:
                sendGrCommendTwo();
                return;
            case 6:
                postDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MESSAGE_DATA();
                return;
            case 7:
                passGroupRideAction(GR_ACTION_SEND_GROUP_RIDE_INFO_FINISH);
                return;
            case '\b':
                setRunningRequestGrMsgCan(false);
                ArrayList<QuickReply> processRequestByREQUEST_FILE_TYPE_GROUP_TRACK_MSG = processRequestByREQUEST_FILE_TYPE_GROUP_TRACK_MSG(requestData);
                if (processRequestByREQUEST_FILE_TYPE_GROUP_TRACK_MSG != null && processRequestByREQUEST_FILE_TYPE_GROUP_TRACK_MSG.size() < 2) {
                    Log.d(str, "團騎流程 -> 裝置罐頭訊息數量小於2，將APP 的罐頭訊息下給裝置下: Cmd 9 SEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MESSAGE_CAN\r\n");
                    postDataBypostDataBySEND_FILE_TYPE_GROUP_RIDE_ACTIVE_MESSAGE_CAN(QuickReply.loadMockData());
                    return;
                }
                Log.d(str, "團騎流程 -> 裝置罐頭訊息數量大於等於2，不用傳給裝置，下一步");
                App.quickReplies = processRequestByREQUEST_FILE_TYPE_GROUP_TRACK_MSG;
                Log.d(str, "團騎流程 -> 裝置罐頭訊息數量大於等於2，App.quickReplies size = " + App.quickReplies.size());
                passGroupRideAction(GR_ACTION_SEND_GROUP_RIDE_INFO_FINISH);
                return;
            case '\t':
                msCurpassSettingCmd = ConstSettingChannel.DEVICE_CMD_SET_PLAN_TRIP_NAME;
                passSettingCmdByDEVICE_CMD_SET_PLAN_TRIP_NAME(GR_PLANTRIP_NAME);
                return;
            case '\n':
                checkSptClimbPro();
                return;
            default:
                return;
        }
    }

    public void checkGroupRideCommand(JSONArray paramArray) {
        if (paramArray == null || paramArray.length() <= 0) {
            return;
        }
        try {
            if (!paramArray.getString(0).equals(ConstSettingChannel.DEVICE_CMD_SET_GROUP_RIDE_BASE) || paramArray.length() <= 1) {
                return;
            }
            nowCmdGrBaseSubType = paramArray.getInt(1);
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    public static void sendGrCommendTwo() {
        if (isStartFromDevCmd75) {
            return;
        }
        msCurpassSettingCmd = ConstSettingChannel.DEVICE_CMD_SET_GROUP_RIDE_BASE;
        mnCurpassSettingCmdGroupAction = (byte) 5;
        if (getGroupTrack() != null) {
            passSettingCmdByDEVICE_CMD_SET_GROUP_RIDE_BASE(getGroupTrack().groupid, mnCurpassSettingCmdGroupAction);
            Log.e(TAG, "團騎流程 -> 下: Cmd 2 告知機器要開始傳資料 DEVICE_CMD_SET_GROUP_RIDE_BASE\r\n");
            return;
        }
        Log.e(TAG, "團騎流程 -> 下: Cmd 2 告知機器要開始傳資料 DEVICE_CMD_SET_GROUP_RIDE_BASE Error\r\n");
    }

    public static void initGrSendingParam() {
        setRunningRequestGrMsgCan(false);
        nowCmdGrBaseSubType = -1;
    }

    public static void setRunningRequestGrMsgCan(boolean runningRequestGrMsgCan) {
        isRunningRequestGrMsgCan = runningRequestGrMsgCan;
    }

    public static boolean isAnyActivityRunning(Context ctx) {
        List<ActivityManager.RunningTaskInfo> runningTasks;
        return (ctx == null || (runningTasks = ((ActivityManager) ctx.getSystemService(Profile3rdPartySyncConst.PAGE_FROM_ACTIVITY)).getRunningTasks(Integer.MAX_VALUE)) == null || runningTasks.size() <= 0) ? false : true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void deviceConnectOrDisconnectForGR(int connectState) {
        if (connectState == 0) {
            Log.d(TAG, "團騎流程0426 機器斷線， reset Group Ride 相關參數,  ");
            mbDevExist = false;
            devStartGroupRide = false;
            cleanData();
            isSendingCmd = false;
            isStartFromDevCmd75 = false;
            mnPreMessagesSize = 0;
            isClickGrMenuOrConfirmDialogFromCoursePage = false;
            broadcastGroupRideInterrupt(SERVICE_GROUP_RIDE_INTERRUPT);
            return;
        }
        Log.d(TAG, "團騎流程0426 機器連線， 將 Group Ride mbDevExist參數改為true,  ");
        mbDevExist = true;
    }

    public void onAddDevMessagesToSend(String messageId) {
        addDevMessagesToSend(ProfileUtil.getInstance().getPrefString(ProfileUtil.NICK_NAME), messageId);
    }

    public void addDevMessagesToSend(String nickname, String messageId) {
        int i;
        Log.d(TAG, "團騎流程: 收到裝置發送罐頭訊息，加入清單待發送清單");
        try {
            i = (int) Long.parseLong(messageId);
        } catch (NumberFormatException unused) {
            i = -1;
        }
        if (i == 0) {
            String str = this.transcript;
            quickReplieVoiceText = str;
            if (str != null) {
                aryMessagesToSend.add(new Message(true, ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID), nickname, quickReplieVoiceText, System.currentTimeMillis(), null));
                return;
            }
        } else if (App.quickReplies != null && i >= 1 && i <= App.quickReplies.size()) {
            String str2 = App.quickReplies.get(i - 1).message;
            String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID);
            aryMessagesToSend.add(new Message(true, prefString, nickname, str2, System.currentTimeMillis(), aryGroupTrackMember.get(prefString)));
            return;
        }
        String prefString2 = ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID);
        aryMessagesToSend.add(new Message(true, prefString2, nickname, "N/A", System.currentTimeMillis(), aryGroupTrackMember.get(prefString2)));
    }

    public void moPollingMessagesToSend() {
        int size = aryMessagesToSend.size();
        if (size == 0) {
            return;
        }
        try {
            String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID);
            long time = new Date().getTime();
            JSONArray jSONArray = new JSONArray();
            int i = 0;
            while (i < size) {
                Message message = aryMessagesToSend.get(i);
                JSONObject jSONObject = new JSONObject();
                jSONObject.put("id", prefString);
                jSONObject.put(Consts.TIMESTAMP, message.timestamp);
                jSONObject.put(NotificationCompat.CATEGORY_MESSAGE, message.message);
                long j = message.timestamp;
                jSONArray.put(jSONObject);
                i++;
                time = j;
            }
            GroupRideInfoResponseData groupRideInfoResponseData = moGroupRideInfoResponseData;
            if (groupRideInfoResponseData == null || groupRideInfoResponseData.getInfo() == null) {
                return;
            }
            GroupRideRepository.getInstance().putGroupMemberReport(moGroupRideInfoResponseData.getInfo().groupid, "{\"playerId\": \"" + prefString + "\", \"history\": {\"id\": \"" + prefString + "\", \"timestamp\": " + time + ", \"message\": " + jSONArray.toString() + "}}").observeForever(new Observer<Boolean>() { // from class: com.brytonsport.active.service.BleService.44
                @Override // androidx.lifecycle.Observer
                public void onChanged(Boolean aBoolean) {
                    String str = BleService.TAG;
                    StringBuilder sb = new StringBuilder();
                    sb.append("團騎流程: 裝置發送罐頭訊息送給server ，狀態 -> ");
                    sb.append(aBoolean.booleanValue() ? "成功" : "失敗");
                    Log.d(str, sb.toString());
                }
            });
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }

    public void addLngLatToSend(String lat, String lng, String dist, String spd, String state) {
        aryDevLatLngsToSend.add(new DevLatLng(lat, lng, dist, spd, state));
    }

    public void moPollingDevLatLngsToSend(int cmd75State) {
        if (mbDevExist.booleanValue()) {
            if (aryDevLatLngsToSend.size() == 0) {
                aryDevLatLngsToSend.clear();
                return;
            }
            String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID);
            long currentTimeMillis = System.currentTimeMillis();
            DevLatLng devLatLng = aryDevLatLngsToSend.get(0);
            String str = "{\"playerId\": \"" + prefString + "\", \"current\": {\"id\": \"" + prefString + "\", \"timestamp\": " + currentTimeMillis + ", \"speed\": " + devLatLng.spd + ", \"devGroupRideState\": " + devLatLng.state + ", \"location\": {\"lat\":" + devLatLng.lat + ", \"lng\":" + devLatLng.lng + "}, \"distance\": " + devLatLng.dist + " }}";
            GroupRideInfoResponseData groupRideInfoResponseData = moGroupRideInfoResponseData;
            if (groupRideInfoResponseData != null && groupRideInfoResponseData.getInfo() != null) {
                GroupRideRepository.getInstance().putGroupDevLatLng(moGroupRideInfoResponseData.getInfo().groupid, str.trim()).observeForever(new Observer<Boolean>() { // from class: com.brytonsport.active.service.BleService.45
                    @Override // androidx.lifecycle.Observer
                    public void onChanged(Boolean aBoolean) {
                    }
                });
            }
            aryDevLatLngsToSend.clear();
        }
        if (cmd75State == 2) {
            Log.d(TAG, "團騎流程0426 收到機器傳來的CMD75 傳送機器位置資訊給server -> cmd75State = 2代表機器按XX，結束Group Ride，不用再取得團騎成員資訊");
            return;
        }
        GroupRideInfoResponseData groupRideInfoResponseData2 = moGroupRideInfoResponseData;
        if (groupRideInfoResponseData2 == null || groupRideInfoResponseData2.getInfo() == null) {
            return;
        }
        String str2 = moGroupRideInfoResponseData.getInfo().groupid;
        Log.d(TAG, "團騎流程0426 收到機器傳來的CMD75 傳送機器位置資訊給server -> 準備取得 3.查詢目前團騎成員紀錄");
        getGroupTrackMember(str2, mContext);
    }

    private void addToIgnoreAction() {
        isRunningGrIgnoreAction = true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void removeFromIgnoreAction() {
        isRunningGrIgnoreAction = false;
        this.nowSentPlanTripName = "";
    }

    public boolean isRunningGrIgnoreAction() {
        return isRunningGrIgnoreAction;
    }

    private void broadcastGroupRideInterrupt(String action) {
        App.getInstance().sendBroadcast(new Intent(action));
    }

    /* loaded from: classes.dex */
    public class ServiceState {
        int state = 0;
        int timestamp = 0;

        public ServiceState() {
        }
    }

    public ServiceState getServiceState() {
        return this.serviceState;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void setServiceState(int state) {
        String str = TAG;
        Log.d(str, "setServiceState->" + state);
        int currentUtcTime = TimeUtilByLee.getCurrentUtcTime();
        if (this.serviceState.state != 0) {
            final int i = currentUtcTime - this.serviceState.timestamp;
            Log.d(str, "Service執行CMD(" + this.serviceState.state + ")花了" + i + "秒");
            if (i > 300) {
                Log.e(str, "Service執行CMD(" + this.serviceState.state + ")+長時間沒回應(" + i + "秒)");
                new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda6
                    @Override // java.lang.Runnable
                    public final void run() {
                        BleService.this.m134x9f99723a(i);
                    }
                }).start();
            }
        }
        this.serviceState.state = state;
        this.serviceState.timestamp = currentUtcTime;
    }

    /* renamed from: lambda$setServiceState$7$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m134x9f99723a(int i) {
        DeviceManagerEntity loadDeviceIsChoice = this.deviceRepository.loadDeviceIsChoice();
        if (loadDeviceIsChoice == null || this.serviceState.state == 0) {
            return;
        }
        FirebaseCustomUtil firebaseCustomUtil = FirebaseCustomUtil.getInstance();
        firebaseCustomUtil.setBleLogMessage("Service執行CMD(" + this.serviceState.state + ")+長時間沒回應(" + i + "秒) uuid(" + loadDeviceIsChoice.getDevUuid() + ") ver:(" + loadDeviceIsChoice.getDevVersion() + ")");
    }

    public void postDataServerEeToDevice() {
        Log.d(TAG, "postDataServerEeToDevice: 下載 server ee 給機器開始");
        File file = new File(ServerEeUtil.getServerEeFileDir(this));
        this.serverEeFiles = new File[0];
        if (file.exists()) {
            this.serverEeFiles = file.listFiles();
        }
        File[] fileArr = this.serverEeFiles;
        if (fileArr == null || fileArr.length <= 0) {
            return;
        }
        serverEePostDataIndex = 0;
        prepareServerEeFile(0);
    }

    public void prepareServerEeFile(int index) {
        File[] fileArr = this.serverEeFiles;
        if (index < fileArr.length) {
            File file = fileArr[index];
            String name = file.getName();
            if (dlServerEeFileNameList.contains(name)) {
                String str = TAG;
                Log.d(str, "processConnectAction 執行 Priority 9-傳送Server EE data 給機器，傳送: " + name);
                postDataPrepare(2, FileUtil.getFileByteArrayByFile(file));
                return;
            }
            int i = serverEePostDataIndex + 1;
            serverEePostDataIndex = i;
            prepareServerEeFile(i);
            return;
        }
        Log.d(TAG, "prepareServerEeFile: 傳送ServerEe File 完成");
        App.getInstance().nowSendServerEeDataState = false;
        broadcastPostFileType(SERVICE_POST_DATA, 2);
        connectActionCompleted();
    }

    public void downLoadServerEeFile(int serverEeType, ServerEeUtil.ServerEeTypeMtkFile mtkFile) {
        File file = new File(ServerEeUtil.getServerEeFileDir(this));
        String serverEeDownloadUrlByType = ServerEeUtil.getServerEeDownloadUrlByType(serverEeType, mtkFile);
        String serverEeDownloadFileNameByType = ServerEeUtil.getServerEeDownloadFileNameByType(serverEeType, mtkFile);
        String str = TAG;
        Log.d(str, "downLoadServerEeFile: 準備下載server ee downloadUrl -> " + serverEeDownloadUrlByType + ", fileName -> " + serverEeDownloadFileNameByType);
        ServerEeUtil.downLoadFile(serverEeDownloadUrlByType, file, serverEeDownloadFileNameByType).observeForever(new Observer<Boolean>() { // from class: com.brytonsport.active.service.BleService.46
            @Override // androidx.lifecycle.Observer
            public void onChanged(Boolean aBoolean) {
                if (aBoolean.booleanValue()) {
                    Log.d(BleService.TAG, "downLoadServerEeFile: 下載server ee Success");
                    BleService.this.downLoadServerEeFinish(NetworkUtil.ApiResultState.SUCCESS);
                    return;
                }
                Log.d(BleService.TAG, "downLoadServerEeFile: 下載server ee Error");
                BleService.this.downLoadServerEeFinish(NetworkUtil.ApiResultState.FAILURE);
            }
        });
    }

    public void decideDownLoadServerEe(int serverEeType) {
        resetServerEeCountData();
        if (serverEeType == 0) {
            dlServerEeTotalNum = 1;
            dlServerEeFileNameList.add(ServerEeUtil.serverEeType0FileName);
            downLoadServerEeFile(serverEeType, null);
            return;
        }
        dlServerEeTotalNum = 2;
        dlServerEeFileNameList.add(ServerEeUtil.serverEeType1FileName1);
        dlServerEeFileNameList.add(ServerEeUtil.serverEeType1FileName2);
        downLoadServerEeFile(serverEeType, ServerEeUtil.ServerEeTypeMtkFile.gr_dat);
        downLoadServerEeFile(serverEeType, ServerEeUtil.ServerEeTypeMtkFile.bds_dat);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    /* renamed from: com.brytonsport.active.service.BleService$49  reason: invalid class name */
    /* loaded from: classes.dex */
    public static /* synthetic */ class AnonymousClass49 {
        static final /* synthetic */ int[] $SwitchMap$com$brytonsport$active$utils$NetworkUtil$ApiResultState;

        static {
            int[] iArr = new int[NetworkUtil.ApiResultState.values().length];
            $SwitchMap$com$brytonsport$active$utils$NetworkUtil$ApiResultState = iArr;
            try {
                iArr[NetworkUtil.ApiResultState.SUCCESS.ordinal()] = 1;
            } catch (NoSuchFieldError unused) {
            }
            try {
                $SwitchMap$com$brytonsport$active$utils$NetworkUtil$ApiResultState[NetworkUtil.ApiResultState.FAILURE.ordinal()] = 2;
            } catch (NoSuchFieldError unused2) {
            }
            try {
                $SwitchMap$com$brytonsport$active$utils$NetworkUtil$ApiResultState[NetworkUtil.ApiResultState.TIMEOUT.ordinal()] = 3;
            } catch (NoSuchFieldError unused3) {
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public synchronized void downLoadServerEeFinish(NetworkUtil.ApiResultState apiResultState) {
        int i = AnonymousClass49.$SwitchMap$com$brytonsport$active$utils$NetworkUtil$ApiResultState[apiResultState.ordinal()];
        if (i == 1) {
            dlServerEeOkCount++;
        } else if (i == 2) {
            dlServerEeErrorCount++;
        } else if (i == 3) {
            dlServerEeTimeoutCount++;
        }
        String format = String.format("downLoadServerEeFinish: 下載成功 %d筆，失敗 %d筆，Timeout %d筆總筆數: %d", Integer.valueOf(dlServerEeOkCount), Integer.valueOf(dlServerEeErrorCount), Integer.valueOf(dlServerEeTimeoutCount), Integer.valueOf(dlServerEeTotalNum));
        String str = TAG;
        Log.d(str, format);
        int i2 = dlServerEeOkCount;
        int i3 = dlServerEeTotalNum;
        if (i2 == i3) {
            Log.d(str, "0612 連線動作: [放進Queue] Priority 9-傳送Server EE data 給機器: , 時間: " + new Date());
            Log.d(str, "processConnectAction: [放進Queue] Priority 9-傳送Server EE data 給機器");
            queueConnectAction(new ConnectTaskObject(ConnectTaskObject.ACTION_9_POST_SERVER_EE_DATA));
        } else if (i2 + dlServerEeErrorCount + dlServerEeTimeoutCount == i3) {
            Log.d(str, "processConnectAction: [不放進Queue] Priority 9-傳送Server EE data 給機器 - 需下載" + dlServerEeTotalNum + "檔案，但下載成功" + dlServerEeOkCount + "筆");
            connectActionCompleted();
        }
    }

    public static void setServerEeCompress(int serverEeCompress2) {
        serverEeCompress = serverEeCompress2;
    }

    public static void setServerEePostDataIndex(int serverEePostDataIndex2) {
        serverEePostDataIndex = serverEePostDataIndex2;
    }

    public static void resetServerEeCountData() {
        dlServerEeOkCount = 0;
        dlServerEeErrorCount = 0;
        dlServerEeTimeoutCount = 0;
        dlServerEeTotalNum = 0;
        dlServerEeFileNameList = new ArrayList();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void connectActionQueueCleanup() {
        this.connectActionQueueProcessing = false;
        do {
        } while (this.connectActionQueue.poll() != null);
    }

    private void queueConnectAction(ConnectTaskObject command) {
        this.connectActionQueue.add(command);
        if (this.connectActionQueueProcessing) {
            return;
        }
        processConnectAction();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void connectActionCompleted() {
        Log.d(TAG, "Connect Action Complete");
        this.connectActionQueueProcessing = false;
        processConnectAction();
    }

    private void processConnectAction() {
        if (this.connectActionQueueProcessing) {
            return;
        }
        ConnectTaskObject poll = this.connectActionQueue.poll();
        if (poll != null && poll.getAction() != null && !poll.getAction().isEmpty()) {
            this.connectActionQueueProcessing = true;
            String action = poll.getAction();
            action.hashCode();
            char c = 65535;
            switch (action.hashCode()) {
                case -841155862:
                    if (action.equals(ConnectTaskObject.ACTION_8_SYNC_ACTIVITY)) {
                        c = 0;
                        break;
                    }
                    break;
                case -645291802:
                    if (action.equals(ConnectTaskObject.ACTION_2_SET_UNIT)) {
                        c = 1;
                        break;
                    }
                    break;
                case -645092337:
                    if (action.equals(ConnectTaskObject.ACTION_6_CHECK_GROUP_RIDE)) {
                        c = 2;
                        break;
                    }
                    break;
                case -617041702:
                    if (action.equals(ConnectTaskObject.ACTION_4_CHECK_DEV_LOG_STATE)) {
                        c = 3;
                        break;
                    }
                    break;
                case 684426270:
                    if (action.equals(ConnectTaskObject.ACTION_3_SET_VOICE_LANG)) {
                        c = 4;
                        break;
                    }
                    break;
                case 1369478927:
                    if (action.equals(ConnectTaskObject.ACTION_1_SET_APP_SUPPORT_FUN)) {
                        c = 5;
                        break;
                    }
                    break;
                case 1370391042:
                    if (action.equals(ConnectTaskObject.ACTION_10_CHECK_FW_UPDATE)) {
                        c = 6;
                        break;
                    }
                    break;
                case 1459775238:
                    if (action.equals(ConnectTaskObject.ACTION_7_CHECK_SERVER_EE_STATE)) {
                        c = 7;
                        break;
                    }
                    break;
                case 1620491885:
                    if (action.equals(ConnectTaskObject.ACTION_9_POST_SERVER_EE_DATA)) {
                        c = '\b';
                        break;
                    }
                    break;
                case 1836725175:
                    if (action.equals(ConnectTaskObject.ACTION_5_CHECK_LIVE_TRACK)) {
                        c = '\t';
                        break;
                    }
                    break;
            }
            switch (c) {
                case 0:
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 8-同步騎乘紀錄");
                    checkFitAutoUpload();
                    return;
                case 1:
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 2-設公英制");
                    this.appUnit = ((Integer) ProfileUtil.getInstance().get(ProfileUtil.APP_UNIT_ID)).intValue();
                    BleUtil.getInstance().setUnit(this.appUnit);
                    return;
                case 2:
                    String str = TAG;
                    Log.d(str, "processConnectAction: [開始執行] Priority 6-Group track 檢查流程");
                    String prefString = ProfileUtil.getInstance().getPrefString(ProfileUtil.GROUP_RIDE_ID);
                    if (prefString != null && !prefString.isEmpty()) {
                        Log.d(str, "團騎流程0612 收到CMD52 檢查連線裝置支援 GroupRide，全自動執行流程，向server 查詢最新團騎資訊，檢查GR是否過期、下載Fit 、成員清單");
                        getGroupRideInfo(prefString, this, getFilesDir());
                        return;
                    }
                    connectActionCompleted();
                    return;
                case 3:
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 4-確認碼錶錄製狀態");
                    BleUtil.getInstance().getLogState();
                    return;
                case 4:
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 3-設語音語言");
                    this.devVoiceLanguage = SettingLanguageUtil.getVoiceLanguageKey();
                    BleUtil.getInstance().setDevVoiceLang(this.devVoiceLanguage);
                    return;
                case 5:
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 1-Device能力判斷 (下CMD71)");
                    BleUtil.getInstance().setAppSupportFun(this.appSupFeatureObj);
                    return;
                case 6:
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 10-Fw Update 檢查");
                    if (poll.getData() == null || !(poll.getData() instanceof DeviceManagerEntity)) {
                        return;
                    }
                    DeviceManagerEntity deviceManagerEntity = (DeviceManagerEntity) poll.getData();
                    Device device = new Device();
                    device.macAddress = deviceManagerEntity.getMacAddress();
                    device.deviceName = deviceManagerEntity.getDevName();
                    device.firmware = deviceManagerEntity.getDevVersion();
                    device.uuid = deviceManagerEntity.getDevUuid();
                    device.capability = deviceManagerEntity.getCapability();
                    device.isChosen = deviceManagerEntity.isChoices();
                    device.isConnected = BleUtil.getInstance().isDeviceAlreadyConnected(device.macAddress);
                    device.deviceImage = DeviceImageUtil.getDeviceImage(deviceManagerEntity.getDevName());
                    checkFirmwareUpdate(device);
                    return;
                case 7:
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 7-取得裝置ServerEE 狀態");
                    BleUtil.getInstance().getServerEE();
                    return;
                case '\b':
                    DeviceBusyStatusUtil.DeviceStatus nowDeviceStatus = DeviceBusyStatusUtil.getNowDeviceStatus();
                    if (nowDeviceStatus.equals(DeviceBusyStatusUtil.DeviceStatus.SyncActivity) || nowDeviceStatus.equals(DeviceBusyStatusUtil.DeviceStatus.RunningGroupRide)) {
                        Log.d(TAG, "processConnectAction: [不執行] Priority 9-傳送Server EE data 給機器 - 因機器在同步活動紀錄中或是GR中");
                        connectActionCompleted();
                        return;
                    }
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 9-傳送Server EE data 給機器");
                    App.getInstance().nowSendServerEeDataState = true;
                    postDataServerEeToDevice();
                    return;
                case '\t':
                    Log.d(TAG, "processConnectAction: [開始執行] Priority 5-設定Live track Interval");
                    BleUtil.getInstance().setLiveTrackingSwitch(this.liveTrackInterval);
                    return;
                default:
                    return;
            }
        }
        Log.d(TAG, "processConnectAction: [執行完畢] - 連線任務Queue 中動作皆已執行 (Connect Action Queue is empty)");
    }

    private void checkFirmwareUpdate(Device deviceInfo) {
        String format = String.format("UD%s.IV%s.MN%s.CP%s.", deviceInfo.uuid, deviceInfo.firmware, deviceInfo.deviceName, deviceInfo.capability);
        UpdateFW.OnUpdateStateListener onUpdateStateListener = new UpdateFW.OnUpdateStateListener() { // from class: com.brytonsport.active.service.BleService.47
            @Override // com.brytonsport.active.fwupdate.UpdateFW.OnUpdateStateListener
            public void fwUpdateState(UpdateFW.UPDATEFW state) {
                if (state == UpdateFW.UPDATEFW.No_Files_Update) {
                    Log.d(BleService.TAG, "processConnectAction: 執行 Priority 10-Fw Update 檢查 -> 沒有需要更新的版本");
                    App.getInstance().devHasNewFwUpdate = false;
                    BleService.this.broadcastBooleanData(BleService.SERVICE_DEV_HAS_NEW_FW_UPDATE, false);
                } else if (state == UpdateFW.UPDATEFW.Download_Files_Finished && BleService.mbDevExist.booleanValue()) {
                    Log.d("DickDebug", "processConnectAction: 執行 Priority 10-Fw Update 檢查 -> 有更新並且下載好檔案");
                    App.getInstance().devHasNewFwUpdate = true;
                    BleService.this.broadcastBooleanData(BleService.SERVICE_DEV_HAS_NEW_FW_UPDATE, true);
                }
                BleService.this.connectActionCompleted();
            }

            @Override // com.brytonsport.active.fwupdate.UpdateFW.OnUpdateStateListener
            public void latestVersion(String serverVersion) {
                App.serverLatestVersion = serverVersion;
                String str = BleService.TAG;
                Log.d(str, "processConnectAction: 執行 Priority 10-Fw Update 檢查 -> latestVersion: " + serverVersion);
            }
        };
        String CreateFirmwareFolder = FirmwareUtil.CreateFirmwareFolder(this);
        UpdateFW updateFW = new UpdateFW(onUpdateStateListener);
        updateFW.dirPath = CreateFirmwareFolder;
        updateFW.setDeviceInfoString(format);
    }

    private boolean isConnectTaskCheckSyncingFit() {
        return App.getInstance().nowDevLogState == 1;
    }

    private boolean isConnectTaskCheckGroupRiding() {
        return devStartGroupRide;
    }

    private void syncActivityFitCompleted() {
        connectActionCompleted();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void checkGroupRideCompleted() {
        connectActionCompleted();
    }

    public static boolean isDevStartGroupRiding() {
        int i = lastCmd75State;
        return (i == -1 || i == 2) ? false : true;
    }

    public void loadResultList() {
        Log.d(TAG, "縮圖流程: 從機器同步Fit 到app 完成: 呼叫loadResultList()");
        this.activityRepository.getActivityListFromServer();
    }

    private void checkSptClimbPro() {
        new Thread(new Runnable() { // from class: com.brytonsport.active.service.BleService$$ExternalSyntheticLambda2
            @Override // java.lang.Runnable
            public final void run() {
                BleService.this.m128xcebd2a9e();
            }
        }).start();
    }

    /* renamed from: lambda$checkSptClimbPro$8$com-brytonsport-active-service-BleService  reason: not valid java name */
    public /* synthetic */ void m128xcebd2a9e() {
        String str = (String) ProfileUtil.getInstance().get(ProfileUtil.USER_ID);
        String connectedDeviceUuid = DeviceRepository.getInstance().getConnectedDeviceUuid();
        int deviceFeatureSupportSync = DeviceRepository.getInstance().deviceFeatureSupportSync(FeatureUtil.FeatureType.ClimbPro);
        String format = String.format(ClimbProUtil.GR_FIT_BASE_FILE_PATH_WITH_NAME, str, connectedDeviceUuid);
        if (new File(format).exists()) {
            String str2 = TAG;
            Log.d(str2, "團騎流程 -> 下: Cmd 3-4 SEND_FILE_TYPE_PLAN_TRIP\r\n");
            Log.d(str2, "checkSptClimbPro: 檔案存在，直接下給機器 -> " + format);
            postDataBySEND_FILE_TYPE_PLAN_TRIP(format);
            this.nowSentPlanTripName = GR_PLANTRIP_NAME;
            return;
        }
        String str3 = TAG;
        Log.d(str3, "checkSptClimbPro: 檔案不存在，先decode，並拿掉climbpro");
        JSONObject decodePlantripFitForGr = this.planTripRepository.decodePlantripFitForGr(null, "GroupTrack");
        if (decodePlantripFitForGr != null) {
            if (decodePlantripFitForGr.has("data")) {
                try {
                    JSONObject jSONObject = decodePlantripFitForGr.getJSONObject("data");
                    if (deviceFeatureSupportSync == 0) {
                        this.planTripRepository.encodePlanTripToFitWithPath(jSONObject, "groupTrack.fit", String.format(ClimbProUtil.GR_FIT_BASE_FILE_PATH, str, connectedDeviceUuid));
                        Log.d(str3, "checkSptClimbPro: decode，並拿掉climbpro完成，機器不支援ClimbPro，encode 後下給機器");
                        Log.d(str3, "團騎流程 -> 下: Cmd 3-4 SEND_FILE_TYPE_PLAN_TRIP\r\n");
                        postDataBySEND_FILE_TYPE_PLAN_TRIP(format);
                        this.nowSentPlanTripName = GR_PLANTRIP_NAME;
                    } else if (deviceFeatureSupportSync == 1) {
                        Log.d(str3, "checkSptClimbPro: decode，並拿掉climbpro完成，機器支援ClimbPro，要自動運算ClimbPro");
                        getRouteClimbs(jSONObject, format, connectedDeviceUuid);
                    }
                    return;
                } catch (JSONException e) {
                    e.printStackTrace();
                    JSONObject jSONObject2 = new JSONObject();
                    try {
                        jSONObject2.put(ConstsInternal.ERROR_CODE_MSG, BrytonErrorCodeUtil.JSON_PARSE_ERROR);
                        jSONObject2.put("message", e.getMessage());
                        broadcastGrFitDecodeError(App.getInstance(), jSONObject2.toString());
                        return;
                    } catch (JSONException e2) {
                        e2.printStackTrace();
                        return;
                    }
                }
            } else if (decodePlantripFitForGr.has("message")) {
                JSONObject jSONObject3 = new JSONObject();
                try {
                    jSONObject3.put(ConstsInternal.ERROR_CODE_MSG, BrytonErrorCodeUtil.PLANTRIP_DECODE_FAILED);
                    jSONObject3.put("message", decodePlantripFitForGr.getString("message"));
                    broadcastGrFitDecodeError(App.getInstance(), jSONObject3.toString());
                    return;
                } catch (JSONException e3) {
                    e3.printStackTrace();
                    return;
                }
            } else {
                return;
            }
        }
        JSONObject jSONObject4 = new JSONObject();
        try {
            jSONObject4.put(ConstsInternal.ERROR_CODE_MSG, BrytonErrorCodeUtil.PLANTRIP_DECODE_FAILED);
            jSONObject4.put("message", "decode obj is null");
            broadcastGrFitDecodeError(App.getInstance(), jSONObject4.toString());
        } catch (JSONException e4) {
            e4.printStackTrace();
        }
    }

    private void getRouteClimbs(final JSONObject decodeObj, final String postGrFilePath, final String connectedDeviceUuid) {
        JSONArray jSONArray;
        try {
            jSONArray = decodeObj.getJSONArray(ResultShareActivity.POINTS);
        } catch (JSONException e) {
            e.printStackTrace();
            jSONArray = null;
        }
        final ArrayList<Altitude> prepareAltitudeList = prepareAltitudeList(jSONArray);
        this.connect3rdPartyRepository.climbApi(ClimbProUtil.pointsToClimbIndex(prepareAltitudeList), new ClimbApiActionListener() { // from class: com.brytonsport.active.service.BleService.48
            @Override // com.brytonsport.active.utils.ClimbApiActionListener
            public void onError(JSONObject e2) {
            }

            @Override // com.brytonsport.active.utils.ClimbApiActionListener
            public void onSuccess(ClimbResponseData climbResponseData) {
                String format = String.format(ClimbProUtil.GR_FIT_BASE_FILE_PATH, ProfileUtil.getInstance().getPrefString(ProfileUtil.USER_ID), connectedDeviceUuid);
                if (climbResponseData != null && climbResponseData.climb_indexes.size() != 0) {
                    ArrayList<RouteClimb> climbsData = ClimbProUtil.setClimbsData(climbResponseData.climb_indexes, prepareAltitudeList);
                    String str = BleService.TAG;
                    Log.d(str, "checkSptClimbPro: 取得波段index size: " + climbsData.size());
                    if (climbResponseData.slope_indexes != null) {
                        BleService.this.countClimbGrade(climbResponseData.slope_indexes, prepareAltitudeList);
                    }
                    JSONObject stepsReplacedFit = BleService.this.getStepsReplacedFit(decodeObj, ClimbProUtil.getMergedStepsJsonArray(ClimbProUtil.getMergedStepsJsonArray(ClimbProUtil.getSteps(decodeObj, 2), ClimbProUtil.getSteps(decodeObj, 1)), ClimbProUtil.getClimbJsonArray(climbsData)), climbsData);
                    Log.d(BleService.TAG, "checkSptClimbPro: MergedStepsJson: ");
                    BleService.this.planTripRepository.encodePlanTripToFitWithPath(stepsReplacedFit, "groupTrack.fit", format);
                    Log.d(BleService.TAG, "checkSptClimbPro: encode (自動產生ClimbPro) 後下給機器");
                } else {
                    BleService.this.planTripRepository.encodePlanTripToFitWithPath(decodeObj, "groupTrack.fit", format);
                    Log.d(BleService.TAG, "checkSptClimbPro: encode (此路線沒有ClimbPro) 後下給機器");
                }
                Log.d(BleService.TAG, "團騎流程 -> 下: Cmd 3-4 SEND_FILE_TYPE_PLAN_TRIP\r\n");
                BleService.postDataBySEND_FILE_TYPE_PLAN_TRIP(postGrFilePath);
                BleService.this.nowSentPlanTripName = BleService.GR_PLANTRIP_NAME;
            }
        });
    }

    private ArrayList<Altitude> prepareAltitudeList(JSONArray pointsArray) {
        int i;
        ArrayList<Altitude> arrayList = new ArrayList<>();
        this.climbGradeList = new ArrayList<>();
        for (int i2 = 0; i2 < pointsArray.length(); i2++) {
            try {
                JSONObject jSONObject = pointsArray.getJSONObject(i2);
                double d = jSONObject.getDouble("altitude");
                double d2 = 0.0d;
                double d3 = jSONObject.getDouble("position_lat");
                double d4 = jSONObject.getDouble("position_long");
                if (i2 > 0) {
                    JSONObject jSONObject2 = pointsArray.getJSONObject(i2 - 1);
                    d2 = DistanceUtil.distance(jSONObject2.getDouble("position_lat"), jSONObject2.getDouble("position_long"), d3, d4) + arrayList.get(i).distance;
                }
                arrayList.add(new Altitude((float) d, (float) d2));
                this.climbGradeList.add(new ClimbGrade(i2, Double.valueOf(d4), Double.valueOf(d3), Double.valueOf(d)));
            } catch (JSONException e) {
                e.printStackTrace();
            }
        }
        return arrayList;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public JSONObject getStepsReplacedFit(JSONObject jsonObjectBase, JSONArray jsonArraySteps, ArrayList<RouteClimb> routeClimbs) {
        if (jsonObjectBase == null || jsonArraySteps == null) {
            return null;
        }
        try {
            JSONObject jSONObject = new JSONObject(jsonObjectBase.toString());
            jSONObject.put("steps", jsonArraySteps);
            JSONArray jSONArray = (JSONArray) jsonObjectBase.get(ResultShareActivity.POINTS);
            new JSONArray();
            if (routeClimbs != null && this.climbGradeList != null) {
                Iterator<RouteClimb> it = routeClimbs.iterator();
                while (it.hasNext()) {
                    RouteClimb next = it.next();
                    if (next != null) {
                        int x = (int) next.endEntry.getX();
                        for (int x2 = (int) next.startEntry.getX(); x2 < x + 1; x2++) {
                            JSONObject jSONObject2 = jSONArray.getJSONObject(x2);
                            if (jSONObject2 != null && this.climbGradeList.get(x2).grade != null) {
                                jSONObject2.put("grade", this.climbGradeList.get(x2).grade.doubleValue() * 100.0d);
                            }
                        }
                    }
                }
            }
            jSONObject.put(ResultShareActivity.POINTS, jSONArray);
            return jSONObject;
        } catch (JSONException e) {
            e.printStackTrace();
            return null;
        }
    }

    public void countClimbGrade(int[] slopeIndexAry, ArrayList<Altitude> altitudeList) {
        ArrayList arrayList = new ArrayList();
        for (int i : slopeIndexAry) {
            arrayList.add(new ClimbGrade(i, this.climbGradeList.get(i).lng, this.climbGradeList.get(i).lat, this.climbGradeList.get(i).alt));
        }
        for (int i2 = 1; i2 < arrayList.size(); i2++) {
            int i3 = i2 - 1;
            int i4 = ((ClimbGrade) arrayList.get(i2)).trackIndex;
            int i5 = ((ClimbGrade) arrayList.get(i3)).trackIndex;
            double abs = (Math.abs(((ClimbGrade) arrayList.get(i2)).alt.doubleValue() - ((ClimbGrade) arrayList.get(i3)).alt.doubleValue()) * 100.0d) / (altitudeList.get(i4).distance - altitudeList.get(i5).distance);
            while (i5 < i4) {
                this.climbGradeList.get(i5).grade = Double.valueOf(abs);
                i5++;
            }
            if (i2 == arrayList.size() - 1) {
                this.climbGradeList.get(i2).grade = Double.valueOf(abs);
            }
        }
    }

    public static void broadcastGrFitDecodeError(Context mContext2, String jsonString) {
        if (isAnyActivityRunning(mContext2)) {
            Intent intent = new Intent(SERVICE_GR_FIT_DECODE_ERROR);
            intent.putExtra(SERVICE_STRING_EXTRA_DATA, jsonString);
            mContext2.sendBroadcast(intent);
        }
    }
}