mirror of
https://github.com/flying1008/OpenMico.git
synced 2023-05-22 02:45:47 +08:00
Create CheckUpdateActivity.java
This commit is contained in:
Aizawa Hikaru
989
OpenMico-FOTA_resign/CheckUpdateActivity.java
Normal file
989
OpenMico-FOTA_resign/CheckUpdateActivity.java
Normal file
@@ -0,0 +1,989 @@
|
||||
package com.xiaomi.mico.romupdate;
|
||||
|
||||
import android.app.ActivityManager;
|
||||
import android.app.Notification;
|
||||
import android.app.NotificationChannel;
|
||||
import android.app.NotificationManager;
|
||||
import android.app.PendingIntent;
|
||||
import android.app.Service;
|
||||
import android.content.BroadcastReceiver;
|
||||
import android.content.Context;
|
||||
import android.content.Intent;
|
||||
import android.content.IntentFilter;
|
||||
import android.os.Handler;
|
||||
import android.os.HandlerThread;
|
||||
import android.os.IBinder;
|
||||
import android.os.Looper;
|
||||
import android.os.Message;
|
||||
import android.os.PowerManager;
|
||||
import android.os.Process;
|
||||
import android.os.RemoteException;
|
||||
import android.os.ServiceSpecificException;
|
||||
import android.os.SystemProperties;
|
||||
import android.os.UpdateEngine;
|
||||
import android.os.UpdateEngineCallback;
|
||||
import android.text.TextUtils;
|
||||
import com.elvishew.xlog.XLog;
|
||||
import com.google.gson.JsonSyntaxException;
|
||||
import com.xiaomi.mico.romupdate.IRomUpdateService;
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.net.URLDecoder;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Calendar;
|
||||
import java.util.Date;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import org.json.JSONException;
|
||||
import org.json.JSONObject;
|
||||
|
||||
public class RomUpdateService extends Service {
|
||||
public static final String ACTION_ROM_UPDATE_EVENT = "com.xiaomi.mico.romupdate.event";
|
||||
private static final String CHANNEL_ID_FOREGROUND_SERVICE = "com.xiaomi.mico.romupdate.channelId";
|
||||
private static final String CHANNEL_NAME_FOREGROUND_SERVICE = "rom_update_service_notification_channel";
|
||||
private static final int DELAY_AFTER_BOOT_COMPLETED = 180000;
|
||||
private static final int DELAY_AFTER_NETWORK_AVAILABLE = 180000;
|
||||
private static final int DELAY_AFTER_PROCESS_STARTUP = 180000;
|
||||
private static final int DELAY_AFTER_SCREEN_ON = 60000;
|
||||
private static final int DELAY_CHECK_PERIOD = 14400000;
|
||||
private static final int DELAY_FIRST_TRY_SILENT_UPDATE = 60000;
|
||||
private static final int DELAY_NO_DELAY = 0;
|
||||
private static final int DELAY_RETRY_SHOWING_NEW_VERSION = 600000;
|
||||
private static final int DELAY_RETRY_SILENT_UPDATE = 3600000;
|
||||
public static final int ERROR_CHECK_UPDATE_FAILED = -1;
|
||||
public static final int ERROR_INVALID_HTTP_RESPONSE = -2;
|
||||
public static final int ERROR_NETWORK_ERROR = -6;
|
||||
public static final int ERROR_NETWORK_NOT_AVAILABLE = -4;
|
||||
public static final int ERROR_NETWORK_TIMEOUT = -5;
|
||||
public static final int ERROR_NEW_VERSION_UNAVAILABLE = -3;
|
||||
public static final int ERROR_NO_ERROR = 0;
|
||||
public static final int EVENT_CHECK_END = 2;
|
||||
public static final int EVENT_CHECK_START = 1;
|
||||
public static final String EXTRA_NEW_VERSION_NAME = "new_version_name";
|
||||
public static final String EXTRA_ROM_UPDATE_ERROR = "rom_update_error";
|
||||
public static final String EXTRA_ROM_UPDATE_EVENT_TYPE = "rom_update_event_type";
|
||||
public static final String EXTRA_ROM_UPDATE_LOG = "rom_update_log";
|
||||
public static final String EXTRA_ROM_UPDATE_SILENT = "rom_update_silent";
|
||||
public static final String EXTRA_ROM_UPDATE_STATE = "rom_update_state";
|
||||
private static final long HOUR_MILLISECONDS = TimeUnit.SECONDS.toMillis(HOUR_SECONDS);
|
||||
private static final long HOUR_SECONDS = TimeUnit.HOURS.toSeconds(1);
|
||||
private static final int MSG_BOOT_COMPLETED = 2;
|
||||
private static final int MSG_CANCEL_UPDATE = 6;
|
||||
private static final int MSG_CHECK_UPDATE = 4;
|
||||
private static final int MSG_DO_SILENT_UPDATE = 10;
|
||||
private static final int MSG_FORCE_UPDATE = 7;
|
||||
private static final int MSG_NETWORK_AVAILABLE = 3;
|
||||
private static final int MSG_PERFORM_UPDATE = 5;
|
||||
private static final int MSG_PROCESS_STARTUP = 1;
|
||||
private static final int MSG_REBOOT = 8;
|
||||
private static final int MSG_TRY_SHOWING_NEW_VERSION = 11;
|
||||
private static final int MSG_TRY_SILENT_UPDATE = 9;
|
||||
public static final String REASON_BOOT_COMPLETED = "BOOT_COMPLETED";
|
||||
public static final String REASON_FORCE_UPDATE = "FORCE_UPDATE";
|
||||
public static final String REASON_NETWORK_CONNECTED = "NETWORK_CONNECTED";
|
||||
public static final String REASON_PERIODIC_CHECK = "PERIODIC_CHECK";
|
||||
public static final String REASON_PROCESS_STARTUP = "PROCESS_STARTUP";
|
||||
public static final String REASON_SILENT_UPDATE = "SILENT_UPDATE";
|
||||
public static final String REASON_UNKNOWN = "UNKNOWN";
|
||||
public static final String REASON_USER_REQUEST = "USER_REQUEST";
|
||||
private static final int SILENT_UPDATE_BEGIN_HOUR = 3;
|
||||
private static final int SILENT_UPDATE_END_HOUR = 5;
|
||||
private static final String SSE_MSG_ALREADY_PROCESSING_UPDATE = "Already processing an update, cancel it first.";
|
||||
private static final String SSE_MSG_NO_ONGOING_UPDATE_TO_CANCEL = "No ongoing update to cancel.";
|
||||
private static final String SSE_MSG_WAITING_FOR_REBOOT = "An update already applied, waiting for reboot";
|
||||
private static final String TAG = "RomUpdateService: ";
|
||||
private final IRomUpdateService.Stub binder = new IRomUpdateService.Stub() {
|
||||
/* class com.xiaomi.mico.romupdate.RomUpdateService.AnonymousClass1 */
|
||||
|
||||
@Override // com.xiaomi.mico.romupdate.IRomUpdateService
|
||||
public void checkUpdate() {
|
||||
RomUpdateService.this.sendCheckMessage(RomUpdateService.REASON_USER_REQUEST, 0);
|
||||
}
|
||||
|
||||
@Override // com.xiaomi.mico.romupdate.IRomUpdateService
|
||||
public void registerCheckUpdateListener(ICheckUpdateListener iCheckUpdateListener) {
|
||||
XLog.d("RomUpdateService: registerCheckUpdateListener, listener = " + iCheckUpdateListener);
|
||||
synchronized (RomUpdateService.this.checkUpdateListenerList) {
|
||||
if (!RomUpdateService.this.checkUpdateListenerList.contains(iCheckUpdateListener)) {
|
||||
RomUpdateService.this.checkUpdateListenerList.add(iCheckUpdateListener);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override // com.xiaomi.mico.romupdate.IRomUpdateService
|
||||
public void unregisterCheckUpdateListener(ICheckUpdateListener iCheckUpdateListener) {
|
||||
XLog.d("RomUpdateService: unregisterCheckUpdateListener, listener = " + iCheckUpdateListener);
|
||||
synchronized (RomUpdateService.this.checkUpdateListenerList) {
|
||||
if (RomUpdateService.this.checkUpdateListenerList.contains(iCheckUpdateListener)) {
|
||||
RomUpdateService.this.checkUpdateListenerList.remove(iCheckUpdateListener);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override // com.xiaomi.mico.romupdate.IRomUpdateService
|
||||
public void forceUpdate(String str) {
|
||||
Message obtainMessage = RomUpdateService.this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 7;
|
||||
obtainMessage.obj = str;
|
||||
RomUpdateService.this.updateServiceHandler.sendMessage(obtainMessage);
|
||||
}
|
||||
|
||||
@Override // com.xiaomi.mico.romupdate.IRomUpdateService
|
||||
public void performUpdate() {
|
||||
RomUpdateService.this.sendPerformUpdateMessage(RomUpdateService.REASON_USER_REQUEST, 0);
|
||||
}
|
||||
|
||||
@Override // com.xiaomi.mico.romupdate.IRomUpdateService
|
||||
public void cancelUpdate() {
|
||||
Message obtainMessage = RomUpdateService.this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 6;
|
||||
RomUpdateService.this.updateServiceHandler.sendMessage(obtainMessage);
|
||||
}
|
||||
|
||||
@Override // com.xiaomi.mico.romupdate.IRomUpdateService
|
||||
public void registerUpdateListener(IUpdateListener iUpdateListener) {
|
||||
XLog.d("RomUpdateService: registerUpdateListener, listener = " + iUpdateListener);
|
||||
synchronized (RomUpdateService.this.updateListenerList) {
|
||||
if (!RomUpdateService.this.updateListenerList.contains(iUpdateListener)) {
|
||||
RomUpdateService.this.updateListenerList.add(iUpdateListener);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override // com.xiaomi.mico.romupdate.IRomUpdateService
|
||||
public void unregisterUpdateListener(IUpdateListener iUpdateListener) {
|
||||
XLog.d("RomUpdateService: unregisterUpdateListener, listener = " + iUpdateListener);
|
||||
synchronized (RomUpdateService.this.updateListenerList) {
|
||||
if (RomUpdateService.this.updateListenerList.contains(iUpdateListener)) {
|
||||
RomUpdateService.this.updateListenerList.remove(iUpdateListener);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
|
||||
/* class com.xiaomi.mico.romupdate.RomUpdateService.AnonymousClass2 */
|
||||
|
||||
public void onReceive(Context context, Intent intent) {
|
||||
if (intent.getAction() == null) {
|
||||
XLog.e("RomUpdateService: null action is received.");
|
||||
return;
|
||||
}
|
||||
XLog.d(RomUpdateService.TAG + intent.getAction() + " is received by broadcastReceiver in RomUpdateService.");
|
||||
String action = intent.getAction();
|
||||
char c = 65535;
|
||||
int hashCode = action.hashCode();
|
||||
if (hashCode != -2128145023) {
|
||||
if (hashCode != -1454123155) {
|
||||
if (hashCode == -1172645946 && action.equals("android.net.conn.CONNECTIVITY_CHANGE")) {
|
||||
c = 0;
|
||||
}
|
||||
} else if (action.equals("android.intent.action.SCREEN_ON")) {
|
||||
c = 1;
|
||||
}
|
||||
} else if (action.equals("android.intent.action.SCREEN_OFF")) {
|
||||
c = 2;
|
||||
}
|
||||
if (c != 0) {
|
||||
if (c == 1) {
|
||||
RomUpdateService.this.isScreenOn = true;
|
||||
} else if (c == 2) {
|
||||
RomUpdateService.this.isScreenOn = false;
|
||||
}
|
||||
} else if (Utils.isNetworkAvailable()) {
|
||||
XLog.d("RomUpdateService: Network becomes available.");
|
||||
RomUpdateService.this.isNetworkAvailable = true;
|
||||
RomUpdateService.this.updateServiceHandler.sendEmptyMessage(3);
|
||||
} else {
|
||||
RomUpdateService.this.isNetworkAvailable = false;
|
||||
}
|
||||
}
|
||||
};
|
||||
private ArrayList<ICheckUpdateListener> checkUpdateListenerList = new ArrayList<>();
|
||||
private String currentVersionDescription = "";
|
||||
private long downloadBeginTs = 0;
|
||||
private long downloadEndTs = 0;
|
||||
private long downloadSpeed = 0;
|
||||
private long finalizeBeginTs = 0;
|
||||
private long finalizeEndTs = 0;
|
||||
private long finalizeSpeed = 0;
|
||||
private boolean forceUpdate = false;
|
||||
private HandlerThread handlerThread = null;
|
||||
private HttpClient httpClient = new HttpClient();
|
||||
private boolean isNetworkAvailable = true;
|
||||
private boolean isScreenOn = true;
|
||||
private String newVersionDescription = "";
|
||||
private NewVersionInfo newVersionInfo = new NewVersionInfo();
|
||||
private String newVersionName = "";
|
||||
private String newVersionUrl = "";
|
||||
private String[] payloadMetadata = null;
|
||||
private long payloadSize = 0;
|
||||
private RomUpdatePreferences preferences = RomUpdatePreferences.getInstance();
|
||||
private int serviceError = 0;
|
||||
private RomUpdateState serviceState = RomUpdateState.Idle;
|
||||
private boolean silentUpdate = false;
|
||||
private UpdateEngine updateEngine = new UpdateEngine();
|
||||
private RomUpdateEngineCallback updateEngineCallback = new RomUpdateEngineCallback();
|
||||
private int updateEngineStatus = 0;
|
||||
private ArrayList<IUpdateListener> updateListenerList = new ArrayList<>();
|
||||
private UpdateServiceHandler updateServiceHandler = null;
|
||||
private long verifyBeginTs = 0;
|
||||
private long verifyEndTs = 0;
|
||||
private long verifySpeed = 0;
|
||||
|
||||
public enum RomUpdateEventType {
|
||||
CheckingUpdateStarted,
|
||||
CheckingUpdateCompleted,
|
||||
UpdatingStarted,
|
||||
UpdatingStateChanged,
|
||||
UpdatingCompleted,
|
||||
UpdatingFailed,
|
||||
CancellingUpdateStarted,
|
||||
CancellingUpdateCompleted,
|
||||
RebootStarted
|
||||
}
|
||||
|
||||
public enum RomUpdateState {
|
||||
Idle,
|
||||
CheckingUpdate,
|
||||
StartingUpdate,
|
||||
Downloading,
|
||||
Verifying,
|
||||
Finalizing,
|
||||
CancellingUpdate,
|
||||
Rebooting,
|
||||
Disabled
|
||||
}
|
||||
|
||||
private void onStartForeground() {
|
||||
NotificationManager notificationManager = (NotificationManager) getSystemService(NotificationManager.class);
|
||||
if (notificationManager != null) {
|
||||
if (notificationManager.getNotificationChannel(CHANNEL_ID_FOREGROUND_SERVICE) == null) {
|
||||
notificationManager.createNotificationChannel(new NotificationChannel(CHANNEL_ID_FOREGROUND_SERVICE, CHANNEL_NAME_FOREGROUND_SERVICE, 2));
|
||||
}
|
||||
Notification.Builder builder = new Notification.Builder(this, CHANNEL_ID_FOREGROUND_SERVICE);
|
||||
builder.setContentIntent(PendingIntent.getActivity(this, 0, new Intent(this, RomUpdateActivity.class), 0));
|
||||
builder.setContentText("");
|
||||
builder.setContentTitle("");
|
||||
builder.setSmallIcon(R.drawable.ic_launcher_foreground);
|
||||
startForeground(1, builder.build());
|
||||
}
|
||||
}
|
||||
|
||||
public void onCreate() {
|
||||
super.onCreate();
|
||||
this.preferences.load();
|
||||
this.handlerThread = new HandlerThread("MicoRomUpdateServiceHandlerThread");
|
||||
this.handlerThread.start();
|
||||
this.updateServiceHandler = new UpdateServiceHandler(this.handlerThread.getLooper());
|
||||
if (this.updateEngine == null) {
|
||||
XLog.d("RomUpdateService: updateEngine is null, create it.");
|
||||
this.updateEngine = new UpdateEngine();
|
||||
}
|
||||
if (this.updateEngineCallback == null) {
|
||||
XLog.d("RomUpdateService: updateEngineCallback is null, create it.");
|
||||
this.updateEngineCallback = new RomUpdateEngineCallback();
|
||||
}
|
||||
this.updateEngine.bind(this.updateEngineCallback);
|
||||
IntentFilter intentFilter = new IntentFilter();
|
||||
intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
|
||||
intentFilter.addAction("android.intent.action.SCREEN_ON");
|
||||
intentFilter.addAction("android.intent.action.SCREEN_OFF");
|
||||
registerReceiver(this.broadcastReceiver, intentFilter);
|
||||
}
|
||||
|
||||
public void onDestroy() {
|
||||
unregisterReceiver(this.broadcastReceiver);
|
||||
try {
|
||||
this.handlerThread.join();
|
||||
} catch (Exception e) {
|
||||
XLog.e("RomUpdateService: handlerThread.join() throws exception: " + e);
|
||||
}
|
||||
super.onDestroy();
|
||||
}
|
||||
|
||||
public int onStartCommand(Intent intent, int i, int i2) {
|
||||
String action = intent != null ? intent.getAction() : null;
|
||||
XLog.d("RomUpdateService: RomUpdateService is started by action " + action);
|
||||
if (Constants.ACTION_PROCESS_STARTUP.equals(action)) {
|
||||
XLog.d("RomUpdateService: process startup, pid = " + Process.myPid());
|
||||
onProcessStartup();
|
||||
return 1;
|
||||
} else if (Constants.ACTION_OS_BOOT_COMPLETED.equals(action)) {
|
||||
XLog.d("RomUpdateService: OS boot is completed.");
|
||||
onBootCompleted();
|
||||
return 1;
|
||||
} else if (Constants.ACTION_CHECK_UPDATE.equals(action)) {
|
||||
sendCheckMessage(intent.getStringExtra(Constants.EXTRA_CHECK_UPDATE_REASON), 0);
|
||||
return 1;
|
||||
} else if (Constants.ACTION_FORCE_UPDATE.equals(action)) {
|
||||
Message obtainMessage = this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 7;
|
||||
obtainMessage.obj = intent.getStringExtra(Constants.EXTRA_FORCE_UPDATE_INFO);
|
||||
this.updateServiceHandler.sendMessage(obtainMessage);
|
||||
return 1;
|
||||
} else if (!Constants.ACTION_CANCEL_UPDATE.equals(action)) {
|
||||
return 1;
|
||||
} else {
|
||||
Message obtainMessage2 = this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage2.what = 6;
|
||||
this.updateServiceHandler.sendMessage(obtainMessage2);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
private void onProcessStartup() {
|
||||
XLog.d("RomUpdateService: onProcessStartup");
|
||||
this.updateServiceHandler.sendEmptyMessageDelayed(1, 0);
|
||||
}
|
||||
|
||||
private void onBootCompleted() {
|
||||
XLog.d("RomUpdateService: onBootCompleted");
|
||||
this.updateServiceHandler.sendEmptyMessageDelayed(2, 0);
|
||||
}
|
||||
|
||||
public IBinder onBind(Intent intent) {
|
||||
return this.binder;
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void sendCheckMessage(String str, long j) {
|
||||
XLog.d("RomUpdateService: MSG_CHECK_UPDATE will be sent after " + j + " ms, the reason is " + str);
|
||||
Message obtainMessage = this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 4;
|
||||
obtainMessage.obj = str;
|
||||
this.updateServiceHandler.sendMessageDelayed(obtainMessage, j);
|
||||
}
|
||||
|
||||
private void sendTryShowingNewVersion(long j) {
|
||||
XLog.d("RomUpdateService: MSG_TRY_SHOWING_NEW_VERSION will be sent after " + j + " ms.");
|
||||
Message obtainMessage = this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 11;
|
||||
this.updateServiceHandler.sendMessageDelayed(obtainMessage, j);
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void sendTrySilentUpdateMessage(long j) {
|
||||
XLog.d("RomUpdateService: MSG_TRY_SILENT_UPDATE will be sent after " + j + " ms.");
|
||||
Message obtainMessage = this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 9;
|
||||
this.updateServiceHandler.sendMessageDelayed(obtainMessage, j);
|
||||
}
|
||||
|
||||
private void sendDoSilentUpdateMessage(long j) {
|
||||
XLog.d("RomUpdateService: MSG_DO_SILENT_UPDATE will be sent after " + j + " ms.");
|
||||
Message obtainMessage = this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 10;
|
||||
this.updateServiceHandler.sendMessageDelayed(obtainMessage, j);
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void sendPerformUpdateMessage(String str, long j) {
|
||||
Message obtainMessage = this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 5;
|
||||
obtainMessage.obj = str;
|
||||
this.updateServiceHandler.sendMessageDelayed(obtainMessage, j);
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void sendRebootMessage(long j) {
|
||||
Message obtainMessage = this.updateServiceHandler.obtainMessage();
|
||||
obtainMessage.what = 8;
|
||||
this.updateServiceHandler.sendMessageDelayed(obtainMessage, j);
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
public class UpdateServiceHandler extends Handler {
|
||||
public UpdateServiceHandler(Looper looper) {
|
||||
super(looper);
|
||||
}
|
||||
|
||||
public void handleMessage(Message message) {
|
||||
XLog.d("RomUpdateService: UpdateServiceHandler.handleMessage, msg.what = " + message.what);
|
||||
switch (message.what) {
|
||||
case 1:
|
||||
RomUpdateService.this.sendCheckMessage(RomUpdateService.REASON_PROCESS_STARTUP, 180000);
|
||||
RomUpdateService.this.sendTrySilentUpdateMessage(240000);
|
||||
return;
|
||||
case 2:
|
||||
RomUpdateService.this.sendCheckMessage(RomUpdateService.REASON_BOOT_COMPLETED, 180000);
|
||||
RomUpdateService.this.sendTrySilentUpdateMessage(240000);
|
||||
return;
|
||||
case 3:
|
||||
removeMessages(3);
|
||||
RomUpdateService.this.onNetworkAvailable();
|
||||
return;
|
||||
case 4:
|
||||
removeMessages(4);
|
||||
RomUpdateService.this.handCheckUpdate((String) message.obj);
|
||||
RomUpdateService.this.sendCheckMessage(RomUpdateService.REASON_PERIODIC_CHECK, 14400000);
|
||||
return;
|
||||
case 5:
|
||||
removeMessages(5);
|
||||
RomUpdateService.this.handPerformUpdate((String) message.obj);
|
||||
return;
|
||||
case 6:
|
||||
removeMessages(6);
|
||||
RomUpdateService.this.handCancelUpdate();
|
||||
return;
|
||||
case 7:
|
||||
removeMessages(7);
|
||||
RomUpdateService.this.handleForceUpdate((String) message.obj);
|
||||
return;
|
||||
case 8:
|
||||
RomUpdateService.this.handleReboot();
|
||||
return;
|
||||
case 9:
|
||||
removeMessages(9);
|
||||
RomUpdateService.this.handleTrySilentUpdate();
|
||||
return;
|
||||
case 10:
|
||||
removeMessages(10);
|
||||
RomUpdateService.this.sendCheckMessage(RomUpdateService.REASON_SILENT_UPDATE, 0);
|
||||
return;
|
||||
case 11:
|
||||
removeMessages(11);
|
||||
RomUpdateService.this.tryShowingNewVersion();
|
||||
return;
|
||||
default:
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void broadcastRomUpdateEvent(RomUpdateEventType romUpdateEventType, RomUpdateState romUpdateState) {
|
||||
XLog.i("RomUpdateService: broadcastRomUpdateEvent: eventType is " + romUpdateEventType + ", old state is " + this.serviceState + ", new state is " + romUpdateState + ", new error is " + this.serviceError + ", new silent mode is " + this.silentUpdate);
|
||||
this.serviceState = romUpdateState;
|
||||
Intent intent = new Intent(ACTION_ROM_UPDATE_EVENT);
|
||||
intent.putExtra(EXTRA_ROM_UPDATE_EVENT_TYPE, romUpdateEventType.ordinal());
|
||||
intent.putExtra(EXTRA_ROM_UPDATE_STATE, romUpdateState.ordinal());
|
||||
intent.putExtra(EXTRA_ROM_UPDATE_ERROR, this.serviceError);
|
||||
if (romUpdateEventType == RomUpdateEventType.CheckingUpdateCompleted) {
|
||||
intent.putExtra(EXTRA_NEW_VERSION_NAME, this.newVersionInfo.versionName);
|
||||
NewVersionInfo newVersionInfo2 = this.newVersionInfo;
|
||||
if (newVersionInfo2 == null || "".equals(newVersionInfo2.versionName)) {
|
||||
intent.putExtra(EXTRA_ROM_UPDATE_LOG, this.currentVersionDescription);
|
||||
} else {
|
||||
intent.putExtra(EXTRA_ROM_UPDATE_LOG, this.newVersionDescription);
|
||||
}
|
||||
}
|
||||
if (romUpdateEventType == RomUpdateEventType.UpdatingStarted) {
|
||||
intent.putExtra(EXTRA_ROM_UPDATE_SILENT, this.silentUpdate);
|
||||
}
|
||||
sendBroadcast(intent);
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void handCheckUpdate(String str) {
|
||||
CheckResponse checkResponse;
|
||||
XLog.d("RomUpdateService: handleCheckUpdate, reason = " + str);
|
||||
if (this.serviceState != RomUpdateState.Idle) {
|
||||
XLog.i("RomUpdateService: RomUpdateService status is " + this.serviceState + ", ignore checking update");
|
||||
} else if (!Utils.isNetworkAvailable()) {
|
||||
XLog.e("RomUpdateService: Network is not available.");
|
||||
this.isNetworkAvailable = false;
|
||||
this.serviceError = -4;
|
||||
} else {
|
||||
this.serviceError = 0;
|
||||
broadcastRomUpdateEvent(RomUpdateEventType.CheckingUpdateStarted, RomUpdateState.CheckingUpdate);
|
||||
notifyCheckEvent(1, null);
|
||||
String lowerCase = Utils.getBuildModel().toLowerCase();
|
||||
String str2 = SystemProperties.get("ro.mi.sw_ver");
|
||||
this.preferences.setCurrentVersionName(str2);
|
||||
this.preferences.commit();
|
||||
String str3 = SystemProperties.get("ro.mi.sw_channel");
|
||||
String sn = Utils.getSn();
|
||||
String valueOf = String.valueOf(System.currentTimeMillis());
|
||||
String paramHash = Utils.getParamHash(lowerCase, str2, str3, sn, "zh_CN", valueOf);
|
||||
LinkedHashMap linkedHashMap = new LinkedHashMap();
|
||||
linkedHashMap.put(Constants.PRODUCT_MODEL, lowerCase);
|
||||
linkedHashMap.put(Constants.CURRENT_ROM_VERSION, str2);
|
||||
linkedHashMap.put(Constants.CURRENT_ROM_CHANNEL, str3);
|
||||
linkedHashMap.put(Constants.PRODUCT_FILTER_ID, sn);
|
||||
linkedHashMap.put(Constants.LOCALE, "zh_CN");
|
||||
linkedHashMap.put(Constants.TIMESTAMP, valueOf);
|
||||
linkedHashMap.put(Constants.PARAM_HASH, paramHash);
|
||||
String str4 = Constants.CHECK_ROM_UPDATE_URL_COMMON_PART + lowerCase;
|
||||
int i = 0;
|
||||
while (true) {
|
||||
if (i >= 3) {
|
||||
break;
|
||||
}
|
||||
XLog.d("RomUpdateService: checking rom update, retry = %d", Integer.valueOf(i));
|
||||
this.newVersionInfo.reset();
|
||||
String str5 = this.httpClient.get(str4, linkedHashMap);
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
XLog.e("RomUpdateService: InterruptedException: " + e.getMessage());
|
||||
}
|
||||
if (str5 == null) {
|
||||
XLog.e("RomUpdateService: null http response.");
|
||||
this.serviceError = -1;
|
||||
} else {
|
||||
XLog.d("RomUpdateService: check rom update, http response: " + str5);
|
||||
try {
|
||||
checkResponse = (CheckResponse) MicoGson.getGson().fromJson(str5, CheckResponse.class);
|
||||
} catch (JsonSyntaxException e2) {
|
||||
XLog.e(TAG + e2);
|
||||
checkResponse = null;
|
||||
}
|
||||
if (checkResponse == null || checkResponse.data == null) {
|
||||
XLog.e("RomUpdateService: get null json object from invalid http response.");
|
||||
this.serviceError = -2;
|
||||
} else {
|
||||
this.serviceError = 0;
|
||||
checkResponse.dump();
|
||||
if (checkResponse.data.currentInfo != null) {
|
||||
this.currentVersionDescription = checkResponse.data.currentInfo.description;
|
||||
this.preferences.setCurrentVersionName(str2);
|
||||
this.preferences.setCurrentVersionDescription(this.currentVersionDescription);
|
||||
this.preferences.commit();
|
||||
}
|
||||
if (checkResponse.data.updateInfo != null) {
|
||||
this.newVersionName = checkResponse.data.updateInfo.version;
|
||||
this.newVersionDescription = checkResponse.data.updateInfo.description;
|
||||
this.newVersionUrl = checkResponse.data.updateInfo.link;
|
||||
this.payloadSize = (long) checkResponse.data.updateInfo.size;
|
||||
this.payloadMetadata = getPayloadMetadata(checkResponse.data.updateInfo.otherParam);
|
||||
this.preferences.setNewVersionName(this.newVersionName);
|
||||
this.preferences.setNewVersionUrl(this.newVersionUrl);
|
||||
this.preferences.setNewVersionDescription(checkResponse.data.updateInfo.description);
|
||||
this.preferences.setPayloadSize(this.payloadSize);
|
||||
this.preferences.setPayloadMetadata(checkResponse.data.updateInfo.otherParam);
|
||||
this.preferences.commit();
|
||||
this.newVersionInfo.set(checkResponse.data.updateInfo);
|
||||
if (REASON_SILENT_UPDATE.equals(str)) {
|
||||
sendPerformUpdateMessage(REASON_SILENT_UPDATE, 0);
|
||||
} else {
|
||||
sendTryShowingNewVersion(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
if (this.newVersionInfo.versionName == null || this.newVersionInfo.versionName.length() == 0) {
|
||||
notifyCheckEvent(2, null);
|
||||
if (REASON_SILENT_UPDATE.equals(str)) {
|
||||
sendTrySilentUpdateMessage(3600000);
|
||||
}
|
||||
} else {
|
||||
notifyCheckEvent(2, this.newVersionInfo);
|
||||
}
|
||||
broadcastRomUpdateEvent(RomUpdateEventType.CheckingUpdateCompleted, RomUpdateState.Idle);
|
||||
}
|
||||
}
|
||||
|
||||
private long getRandomDelay() {
|
||||
long j = HOUR_SECONDS;
|
||||
long hashCode = ((long) Utils.getSn().hashCode()) % j;
|
||||
if (hashCode < 0) {
|
||||
hashCode += j;
|
||||
}
|
||||
long midnightTimeStamp = ((Utils.getMidnightTimeStamp() + (HOUR_MILLISECONDS * 3)) + TimeUnit.SECONDS.toMillis(hashCode)) - System.currentTimeMillis();
|
||||
return midnightTimeStamp < 0 ? (-midnightTimeStamp) % HOUR_MILLISECONDS : midnightTimeStamp;
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void handleTrySilentUpdate() {
|
||||
Calendar instance = Calendar.getInstance();
|
||||
instance.setTime(new Date());
|
||||
int i = instance.get(11);
|
||||
if (3 > i || i >= 5) {
|
||||
XLog.d("RomUpdateService: Now is not time for silent update. Retry silent update after a delay of 3600000 ms.");
|
||||
sendTrySilentUpdateMessage(3600000);
|
||||
return;
|
||||
}
|
||||
long randomDelay = getRandomDelay();
|
||||
XLog.d("RomUpdateService: Do silent update after a delay of " + randomDelay + " ms.");
|
||||
sendDoSilentUpdateMessage(randomDelay);
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void handPerformUpdate(String str) {
|
||||
XLog.d("RomUpdateService: handPerformUpdate, reason = " + str);
|
||||
if (this.serviceState != RomUpdateState.Idle) {
|
||||
XLog.i("RomUpdateService: RomUpdateService state is " + this.serviceState + ", ignore performing update");
|
||||
} else if ("".equals(this.newVersionName) || "".equals(this.newVersionUrl) || 0 == this.payloadSize || this.payloadMetadata == null) {
|
||||
XLog.e("RomUpdateService: invalid new version information for updating.");
|
||||
this.serviceError = -3;
|
||||
broadcastRomUpdateEvent(RomUpdateEventType.UpdatingFailed, RomUpdateState.Idle);
|
||||
} else {
|
||||
this.updateEngineStatus = 0;
|
||||
resetTimestampAndSpeed();
|
||||
if (REASON_SILENT_UPDATE.equals(str)) {
|
||||
this.silentUpdate = true;
|
||||
} else {
|
||||
this.silentUpdate = false;
|
||||
}
|
||||
if (REASON_FORCE_UPDATE.equals(str)) {
|
||||
this.forceUpdate = true;
|
||||
} else {
|
||||
this.forceUpdate = false;
|
||||
}
|
||||
this.serviceError = 0;
|
||||
broadcastRomUpdateEvent(RomUpdateEventType.UpdatingStarted, RomUpdateState.StartingUpdate);
|
||||
try {
|
||||
this.updateEngine.applyPayload(this.newVersionUrl, 0, this.payloadSize, this.payloadMetadata);
|
||||
} catch (ServiceSpecificException e) {
|
||||
XLog.e("RomUpdateService: UpdateEngine.applyPayload throws android.os.ServiceSpecificException: " + e.getMessage());
|
||||
if (SSE_MSG_WAITING_FOR_REBOOT.equals(e.getMessage())) {
|
||||
XLog.d("RomUpdateService: This device will reboot.");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void handCancelUpdate() {
|
||||
XLog.d("RomUpdateService: handCancelUpdate");
|
||||
if (this.serviceState == RomUpdateState.CancellingUpdate) {
|
||||
XLog.i("RomUpdateService: RomUpdateService state is " + this.serviceState + ", ignore cancelling update");
|
||||
return;
|
||||
}
|
||||
broadcastRomUpdateEvent(RomUpdateEventType.CancellingUpdateStarted, RomUpdateState.CancellingUpdate);
|
||||
try {
|
||||
this.updateEngine.cancel();
|
||||
} catch (ServiceSpecificException e) {
|
||||
XLog.e("RomUpdateService: UpdateEngine.applyPayload throws android.os.ServiceSpecificException: " + e.getMessage());
|
||||
if (SSE_MSG_NO_ONGOING_UPDATE_TO_CANCEL.equals(e.getMessage())) {
|
||||
XLog.d("RomUpdateService: There is no ongoing update to cancel.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void handleForceUpdate(String str) {
|
||||
ForceUpdateInfo forceUpdateInfo;
|
||||
String str2;
|
||||
XLog.d("RomUpdateService: handleForceUpdate, forceUpdateInfoStr = " + str);
|
||||
if (this.serviceState != RomUpdateState.Idle) {
|
||||
XLog.i("RomUpdateService: RomUpdateService state is " + this.serviceState + ", ignore forcing update");
|
||||
} else if (Utils.isEmpty(str)) {
|
||||
XLog.e("RomUpdateService: Force update information is null or empty.");
|
||||
} else {
|
||||
try {
|
||||
String decode = URLDecoder.decode(str, "UTF-8");
|
||||
if (decode != null) {
|
||||
try {
|
||||
forceUpdateInfo = (ForceUpdateInfo) MicoGson.getGson().fromJson(decode, ForceUpdateInfo.class);
|
||||
} catch (JsonSyntaxException e) {
|
||||
XLog.e(TAG + e);
|
||||
forceUpdateInfo = null;
|
||||
}
|
||||
if (forceUpdateInfo == null) {
|
||||
XLog.e("RomUpdateService: Get null json object from URL in forceUpdateInfoStr.");
|
||||
return;
|
||||
}
|
||||
this.newVersionName = forceUpdateInfo.version;
|
||||
this.newVersionUrl = forceUpdateInfo.url;
|
||||
this.payloadSize = getPayloadFileSize(forceUpdateInfo.extra);
|
||||
this.payloadMetadata = getPayloadMetadata(forceUpdateInfo.extra);
|
||||
String str3 = this.newVersionName;
|
||||
if (str3 == null || str3.length() == 0 || (str2 = this.newVersionUrl) == null || str2.length() == 0 || 0 == this.payloadSize || this.payloadMetadata == null) {
|
||||
XLog.e("RomUpdateService: New version information is invalid. Please check new version first, or force update with valid new version information.");
|
||||
return;
|
||||
}
|
||||
this.preferences.setNewVersionName(this.newVersionName);
|
||||
this.preferences.setNewVersionUrl(this.newVersionUrl);
|
||||
this.preferences.setPayloadSize(this.payloadSize);
|
||||
this.preferences.setPayloadMetadata(forceUpdateInfo.extra);
|
||||
this.preferences.commit();
|
||||
sendPerformUpdateMessage(REASON_FORCE_UPDATE, 0);
|
||||
}
|
||||
} catch (UnsupportedEncodingException e2) {
|
||||
XLog.e("RomUpdateService: Failed to decode forceUpdateInfoStr. " + e2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void handleReboot() {
|
||||
broadcastRomUpdateEvent(RomUpdateEventType.RebootStarted, RomUpdateState.Rebooting);
|
||||
try {
|
||||
Thread.sleep(2000);
|
||||
} catch (InterruptedException e) {
|
||||
XLog.e("RomUpdateService: InterruptedException: " + e.getMessage());
|
||||
}
|
||||
this.preferences.reset();
|
||||
((PowerManager) RomUpdateApplication.appContext.getSystemService("power")).reboot(!this.isScreenOn ? "quiescent" : "deviceowner");
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void tryShowingNewVersion() {
|
||||
ActivityManager.RunningAppProcessInfo topProcessInfo = Utils.getTopProcessInfo();
|
||||
if (topProcessInfo == null) {
|
||||
XLog.e("Failed to get top process.");
|
||||
} else if (BuildConfig.APPLICATION_ID.equals(topProcessInfo.processName)) {
|
||||
XLog.d("Top process is com.xiaomi.mico.romupdate, there is no need to show new version.");
|
||||
} else if ("com.xiaomi.micolauncher".equals(topProcessInfo.processName)) {
|
||||
Intent intent = new Intent(RomUpdateApplication.appContext, CheckUpdateActivity.class);
|
||||
intent.setFlags(268435456);
|
||||
startActivity(intent);
|
||||
} else {
|
||||
sendTryShowingNewVersion(600000);
|
||||
}
|
||||
}
|
||||
|
||||
private long getPayloadFileSize(String str) {
|
||||
XLog.d("RomUpdateService: metadataJsonStr = " + str);
|
||||
try {
|
||||
return Long.parseLong(new JSONObject(str).getString("FILE_SIZE"));
|
||||
} catch (JSONException e) {
|
||||
XLog.e("RomUpdateService: JSONException: " + e);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
private String[] getPayloadMetadata(String str) {
|
||||
String str2;
|
||||
String str3;
|
||||
String str4;
|
||||
JSONException e;
|
||||
XLog.d("RomUpdateService: metadataJsonStr = " + str);
|
||||
String str5 = null;
|
||||
try {
|
||||
JSONObject jSONObject = new JSONObject(str);
|
||||
str2 = jSONObject.getString("FILE_HASH");
|
||||
try {
|
||||
str4 = jSONObject.getString("FILE_SIZE");
|
||||
} catch (JSONException e2) {
|
||||
e = e2;
|
||||
str4 = null;
|
||||
str3 = str4;
|
||||
XLog.e("RomUpdateService: JSONException: " + e);
|
||||
return new String[]{"FILE_HASH=" + str2, "FILE_SIZE=" + str4, "METADATA_HASH=" + str3, "METADATA_SIZE=" + str5};
|
||||
}
|
||||
try {
|
||||
str3 = jSONObject.getString("METADATA_HASH");
|
||||
try {
|
||||
str5 = jSONObject.getString("METADATA_SIZE");
|
||||
} catch (JSONException e3) {
|
||||
e = e3;
|
||||
}
|
||||
} catch (JSONException e4) {
|
||||
e = e4;
|
||||
str3 = null;
|
||||
XLog.e("RomUpdateService: JSONException: " + e);
|
||||
return new String[]{"FILE_HASH=" + str2, "FILE_SIZE=" + str4, "METADATA_HASH=" + str3, "METADATA_SIZE=" + str5};
|
||||
}
|
||||
} catch (JSONException e5) {
|
||||
e = e5;
|
||||
str2 = null;
|
||||
str4 = null;
|
||||
str3 = str4;
|
||||
XLog.e("RomUpdateService: JSONException: " + e);
|
||||
return new String[]{"FILE_HASH=" + str2, "FILE_SIZE=" + str4, "METADATA_HASH=" + str3, "METADATA_SIZE=" + str5};
|
||||
}
|
||||
return new String[]{"FILE_HASH=" + str2, "FILE_SIZE=" + str4, "METADATA_HASH=" + str3, "METADATA_SIZE=" + str5};
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void resetDownloadTimestampAndSpeed() {
|
||||
this.downloadBeginTs = 0;
|
||||
this.downloadEndTs = 0;
|
||||
this.downloadSpeed = 0;
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void resetVerifyTimestampAndSpeed() {
|
||||
this.verifyBeginTs = 0;
|
||||
this.verifyEndTs = 0;
|
||||
this.verifySpeed = 0;
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void resetFinalizeTimestampAndSpeed() {
|
||||
this.finalizeBeginTs = 0;
|
||||
this.finalizeEndTs = 0;
|
||||
this.finalizeSpeed = 0;
|
||||
}
|
||||
|
||||
private void resetTimestampAndSpeed() {
|
||||
resetDownloadTimestampAndSpeed();
|
||||
resetVerifyTimestampAndSpeed();
|
||||
resetFinalizeTimestampAndSpeed();
|
||||
}
|
||||
|
||||
private class RomUpdateEngineCallback extends UpdateEngineCallback {
|
||||
private RomUpdateEngineCallback() {
|
||||
}
|
||||
|
||||
public void onStatusUpdate(int i, float f) {
|
||||
XLog.d("RomUpdateService: RomUpdateEngineCallback.onStatusUpdate, status = " + i + ", percent = " + f);
|
||||
RomUpdateService.this.updateEngineStatus = i;
|
||||
if (RomUpdateService.this.serviceState == RomUpdateState.Downloading || RomUpdateService.this.serviceState == RomUpdateState.Verifying || RomUpdateService.this.serviceState == RomUpdateState.Finalizing) {
|
||||
RomUpdateService romUpdateService = RomUpdateService.this;
|
||||
romUpdateService.notifyUpdateEngineStatus(romUpdateService.updateEngineStatus, f);
|
||||
}
|
||||
if (i != 0) {
|
||||
if (i == 2) {
|
||||
XLog.d("RomUpdateService: update engine status: UPDATE_AVAILABLE");
|
||||
} else if (i == 3) {
|
||||
if (RomUpdateService.this.serviceState != RomUpdateState.Downloading) {
|
||||
RomUpdateService.this.broadcastRomUpdateEvent(RomUpdateEventType.UpdatingStateChanged, RomUpdateState.Downloading);
|
||||
}
|
||||
if (RomUpdateService.this.downloadBeginTs == 0) {
|
||||
RomUpdateService.this.resetDownloadTimestampAndSpeed();
|
||||
RomUpdateService.this.downloadBeginTs = System.currentTimeMillis();
|
||||
XLog.d("RomUpdateService: download begin timestamp: " + RomUpdateService.this.downloadBeginTs);
|
||||
} else if (f == 1.0f) {
|
||||
RomUpdateService.this.downloadEndTs = System.currentTimeMillis();
|
||||
long j = RomUpdateService.this.downloadEndTs - RomUpdateService.this.downloadBeginTs;
|
||||
RomUpdateService romUpdateService2 = RomUpdateService.this;
|
||||
romUpdateService2.downloadSpeed = romUpdateService2.payloadSize / (j / 1000);
|
||||
XLog.d("RomUpdateService: download end timestamp: " + RomUpdateService.this.downloadEndTs);
|
||||
XLog.d("RomUpdateService: download stage: payload size = " + RomUpdateService.this.payloadSize + " (bytes), download time = " + j + " (ms), download speed = " + RomUpdateService.this.downloadSpeed + " (bytes/s)");
|
||||
}
|
||||
} else if (i == 4) {
|
||||
if (RomUpdateService.this.serviceState != RomUpdateState.Verifying) {
|
||||
RomUpdateService.this.broadcastRomUpdateEvent(RomUpdateEventType.UpdatingStateChanged, RomUpdateState.Verifying);
|
||||
}
|
||||
if (RomUpdateService.this.verifyBeginTs == 0) {
|
||||
RomUpdateService.this.resetVerifyTimestampAndSpeed();
|
||||
RomUpdateService.this.verifyBeginTs = System.currentTimeMillis();
|
||||
XLog.d("RomUpdateService: verify begin timestamp: " + RomUpdateService.this.verifyBeginTs);
|
||||
} else if (((double) f) == 1.0d) {
|
||||
RomUpdateService.this.verifyEndTs = System.currentTimeMillis();
|
||||
long j2 = RomUpdateService.this.verifyEndTs - RomUpdateService.this.verifyBeginTs;
|
||||
RomUpdateService romUpdateService3 = RomUpdateService.this;
|
||||
romUpdateService3.verifySpeed = romUpdateService3.payloadSize / (j2 / 1000);
|
||||
XLog.d("RomUpdateService: verify end timestamp: " + RomUpdateService.this.verifyEndTs);
|
||||
XLog.d("RomUpdateService: verify stage: payload size = " + RomUpdateService.this.payloadSize + " (bytes), verify time = " + j2 + " (ms), verify speed = " + RomUpdateService.this.verifySpeed + " (bytes/s)");
|
||||
}
|
||||
} else if (i == 5) {
|
||||
if (RomUpdateService.this.serviceState != RomUpdateState.Finalizing) {
|
||||
RomUpdateService.this.broadcastRomUpdateEvent(RomUpdateEventType.UpdatingStateChanged, RomUpdateState.Finalizing);
|
||||
}
|
||||
if (RomUpdateService.this.finalizeBeginTs == 0) {
|
||||
RomUpdateService.this.resetFinalizeTimestampAndSpeed();
|
||||
RomUpdateService.this.finalizeBeginTs = System.currentTimeMillis();
|
||||
XLog.d("RomUpdateService: finalize begin timestamp: " + RomUpdateService.this.finalizeBeginTs);
|
||||
} else if (((double) f) == 1.0d) {
|
||||
RomUpdateService.this.finalizeEndTs = System.currentTimeMillis();
|
||||
long j3 = RomUpdateService.this.finalizeEndTs - RomUpdateService.this.finalizeBeginTs;
|
||||
RomUpdateService romUpdateService4 = RomUpdateService.this;
|
||||
romUpdateService4.finalizeSpeed = romUpdateService4.payloadSize / (j3 / 1000);
|
||||
XLog.d("RomUpdateService: finalize end timestamp: " + RomUpdateService.this.finalizeEndTs);
|
||||
XLog.d("RomUpdateService: finalize stage: payload size = " + RomUpdateService.this.payloadSize + " (bytes), finalize time = " + j3 + " (ms), finalize speed = " + RomUpdateService.this.finalizeSpeed + " (bytes/s)");
|
||||
}
|
||||
} else if (i == 6) {
|
||||
XLog.i("RomUpdateService: update engine status: UPDATED_NEED_REBOOT");
|
||||
}
|
||||
} else if (RomUpdateService.this.serviceState != RomUpdateState.Idle) {
|
||||
RomUpdateService.this.broadcastRomUpdateEvent(RomUpdateEventType.UpdatingStateChanged, RomUpdateState.Idle);
|
||||
}
|
||||
}
|
||||
|
||||
public void onPayloadApplicationComplete(int i) {
|
||||
XLog.d("RomUpdateService: RomUpdateEngineCallback.onPayloadApplicationComplete, errorCode = " + i);
|
||||
RomUpdateService.this.serviceError = i;
|
||||
RomUpdateService.this.notifyUpdateError(i);
|
||||
if (i == 0) {
|
||||
XLog.i("RomUpdateService: Applying payload is finished successfully.");
|
||||
RomUpdateService.this.broadcastRomUpdateEvent(RomUpdateEventType.UpdatingCompleted, RomUpdateState.Idle);
|
||||
RomUpdateService.this.sendRebootMessage(0);
|
||||
} else if (i != 48) {
|
||||
RomUpdateService.this.broadcastRomUpdateEvent(RomUpdateEventType.UpdatingFailed, RomUpdateState.Idle);
|
||||
} else {
|
||||
XLog.i("RomUpdateService: update is cancelled by user.");
|
||||
RomUpdateService.this.broadcastRomUpdateEvent(RomUpdateEventType.CancellingUpdateCompleted, RomUpdateState.Idle);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void notifyCheckEvent(int i, NewVersionInfo newVersionInfo2) {
|
||||
synchronized (this.checkUpdateListenerList) {
|
||||
Iterator<ICheckUpdateListener> it = this.checkUpdateListenerList.iterator();
|
||||
while (it.hasNext()) {
|
||||
try {
|
||||
it.next().onCheckEvent(i, newVersionInfo2);
|
||||
} catch (RemoteException e) {
|
||||
XLog.e("RomUpdateService: notifyCheckEvent RemoteException: " + e);
|
||||
try {
|
||||
it.remove();
|
||||
} catch (Exception e2) {
|
||||
XLog.e("RomUpdateService: Exception is caught when removing exceptional ICheckUpdateListener." + e2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void notifyUpdateEngineStatus(int i, float f) {
|
||||
synchronized (this.updateListenerList) {
|
||||
Iterator<IUpdateListener> it = this.updateListenerList.iterator();
|
||||
while (it.hasNext()) {
|
||||
try {
|
||||
it.next().onUpdateEngineStatusChange(i, f);
|
||||
} catch (RemoteException e) {
|
||||
XLog.e("RomUpdateService: notifyUpdateEngineStatus RemoteException: " + e);
|
||||
try {
|
||||
it.remove();
|
||||
} catch (Exception e2) {
|
||||
XLog.e("RomUpdateService: Exception is caught when removing exceptional IUpdateListener." + e2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void notifyUpdateError(int i) {
|
||||
synchronized (this.updateListenerList) {
|
||||
Iterator<IUpdateListener> it = this.updateListenerList.iterator();
|
||||
while (it.hasNext()) {
|
||||
try {
|
||||
it.next().onUpdateError(i);
|
||||
} catch (RemoteException e) {
|
||||
XLog.e("RomUpdateService: notifyUpdateError RemoteException: " + e);
|
||||
try {
|
||||
it.remove();
|
||||
} catch (Exception e2) {
|
||||
XLog.e("RomUpdateService: Exception is caught when removing exceptional IUpdateListener." + e2);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* access modifiers changed from: private */
|
||||
/* access modifiers changed from: public */
|
||||
private void onNetworkAvailable() {
|
||||
XLog.d("RomUpdateService: Network available: " + this.isNetworkAvailable);
|
||||
if (this.serviceState == RomUpdateState.Idle) {
|
||||
sendCheckMessage(REASON_NETWORK_CONNECTED, 180000);
|
||||
}
|
||||
}
|
||||
|
||||
public static class ForceUpdateInfo {
|
||||
public String checksum;
|
||||
public String extra;
|
||||
public String hardware;
|
||||
public String url;
|
||||
public String version;
|
||||
|
||||
public boolean isValid() {
|
||||
return !TextUtils.isEmpty(this.extra) && !TextUtils.isEmpty(this.checksum) && !TextUtils.isEmpty(this.version) && !TextUtils.isEmpty(this.url) && !TextUtils.isEmpty(this.hardware);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user