/// <summary>
/// Does the update.
/// </summary>
public void Update()
{
InProgress = true;
var i = 0d;
var cnt = Database.TVShows.Values.Count(s => s.Airing);
var ids = Database.TVShows.Values.Where(s => s.Airing).OrderBy(s => s.Title).Select(s => s.ID).ToList();
foreach (var id in ids)
{
UpdateProgressChanged.Fire(this, Database.TVShows[id].Title, ++i / cnt * 100);
var tv = Database.Update(Database.TVShows[id], (e, s) =>
{
if (e == -1)
{
UpdateError.Fire(this, s, null, true, false);
}
});
if (tv != null && tv.Language == "en")
{
UpdateRemoteCache(tv);
}
}
Database.Setting("update", DateTime.Now.ToUnixTimestamp().ToString());
MainWindow.Active.DataChanged();
UpdateDone.Fire(this);
InProgress = false;
}
private void OnSearchingFilesProgressChanged()
{
UpdateProgressChanged?.Invoke(this, new DBUpdateProgressChangedEventArgs
{
Step = DatabaseUpdateStepType.SearchingFiles,
TotalItems = _total,
CurrentItem = _current
});
}
private void OnDownloadProgressChanged(Object sender, DownloadProgressChangedEventArgs e)
{
UpdateProgressChanged.Invoke(this, new UpdateProgressChangedEventArgs()
{
Message = "Downlouding updates...",
BytesReceived = e.BytesReceived,
TotalBytesToReceive = e.TotalBytesToReceive,
ProgressPercentage = e.ProgressPercentage
});
}
/// <summary>
/// Gathers a list of files to download for the update.
/// </summary>
private List <RemoteFileInfo> GatherFilesToDownload(string buildPath,
string downloadDirectory)
{
List <RemoteFileInfo> filesToDownload = new List <RemoteFileInfo>();
// This could be multithreaded later on for faster processing,
// calculating the SHA1 hashes can take a lot of time
for (int i = 0; i < remoteBuildInfo.FileInfos.Count; i++)
{
var remoteFileInfo = remoteBuildInfo.FileInfos[i];
UpdateProgressChanged?.Invoke(this, new UpdateProgressEventArgs(
UpdateProgressState.PREPARING, 0,
(int)(i / (double)remoteBuildInfo.FileInfos.Count * 100.0), string.Empty));
if (!File.Exists(buildPath + remoteFileInfo.FilePath))
{
if (!File.Exists(downloadDirectory + remoteFileInfo.FilePath))
{
UpdaterLogger.Log("File " + remoteFileInfo.FilePath + " doesn't exist, adding it to the download queue.");
filesToDownload.Add(remoteFileInfo);
}
else if (!HashHelper.FileHashMatches(downloadDirectory + remoteFileInfo.FilePath,
remoteFileInfo.UncompressedHash))
{
UpdaterLogger.Log("File " + remoteFileInfo.FilePath + " exists in the " +
"temporary directory, but it's different from the remote version. Adding it to the download queue.");
filesToDownload.Add(remoteFileInfo);
}
}
else
{
if (!HashHelper.FileHashMatches(buildPath + remoteFileInfo.FilePath, remoteFileInfo.UncompressedHash))
{
UpdaterLogger.Log("File " + remoteFileInfo.FilePath + " is different from the " +
"remote version, adding it to the download queue.");
filesToDownload.Add(remoteFileInfo);
}
else
{
UpdaterLogger.Log("File " + remoteFileInfo.FilePath + " is up to date.");
}
}
}
return(filesToDownload);
}
public async void Update()
{
try
{
lock (_lockObject)
{
if (_isUpdating)
{
return;
}
_isUpdating = true;
}
UpdateProgressChanged?.Invoke(this, new DBUpdateProgressChangedEventArgs {
Step = DatabaseUpdateStepType.Started
});
_database.SetMaxVariablesLimit();
await _database.ClearDatabase();
await _database.Initialize();
await LoadFiles();
await UpdateDatabase();
}
catch (Exception ex)
{
_logService.LogException(ex);
_database.CloseConnection();
//var dbFile = await ApplicationData.Current.LocalFolder.GetFileAsync(LibraryDatabase.DATABASE_FILE_NAME);
//await dbFile.DeleteAsync(StorageDeleteOption.PermanentDelete);
}
finally
{
ClearUpdateTemp();
UpdateProgressChanged?.Invoke(this, new DBUpdateProgressChangedEventArgs {
Step = DatabaseUpdateStepType.Completed
});
lock (_lockObject)
{
_isUpdating = false;
}
}
}
private void ParsePacket(UsbPacket pk)
{
Cmd cmd = (Cmd)pk.Cmd;
//System.Diagnostics.Debug.WriteLine( "Cmd : {0}", cmd.ToString() );
switch (cmd)
{
case Cmd.START:
{
isFirstStatus = true;
int protocolVersion = pk.GetInt();
bool available = pk.GetByte() == 0x01;
if (available)
{
GetDeviceInfoRequest();
}
else
{
ConnectionRefused?.Invoke(this, null);
}
}
break;
case Cmd.GETDEVINFO:
{
DeviceName = pk.GetString(16);
FirmwareVersion = pk.GetString(16);
BluetoothProtocolVersion = pk.GetString(8);
SubName = pk.GetString(16);
MacAddress = BitConverter.ToString(pk.GetBytes(6)).Replace("-", ":");
BluetoothModelName = pk.GetString(32);
GetConfigRequest(ConfigType.AutoPowerOffTime, ConfigType.AutoPowerOn, ConfigType.Beep, ConfigType.DownSampling, ConfigType.PenCapOff, ConfigType.SaveOfflineData);
}
break;
case Cmd.GETDISKINFO:
{
pk.Move(1);
var total = pk.GetInt();
var free = pk.GetInt();
StorageStatusReceived?.Invoke(this, new StorageStatusReceivedEventArgs(total, free));
}
break;
case Cmd.GETCONFIG:
{
int typeCount = pk.GetByteToInt();
for (int i = 0; i < typeCount; i++)
{
int type = pk.GetByteToInt();
switch ((ConfigType)type)
{
case ConfigType.DateTime:
long timestamp = pk.GetLong();
DateTimeReceived?.Invoke(this, new DateTimeReceivedEventArgs(timestamp));
break;
case ConfigType.AutoPowerOffTime:
//AutoPowerOffTime = new TimeSpan( 0, pk.GetShort(), 0);
AutoPowerOffTime = TimeSpan.FromMinutes(pk.GetShort());
if (!isFirstStatus)
{
ConfigSetupResultReceived?.Invoke(this, new ConfigSetupResultReceivedEventArgs(ConfigType.AutoPowerOffTime, true));
}
break;
case ConfigType.AutoPowerOn:
IsAutoPowerOnEnabled = pk.GetByteToInt() == 0x01;
if (!isFirstStatus)
{
ConfigSetupResultReceived?.Invoke(this, new ConfigSetupResultReceivedEventArgs(ConfigType.AutoPowerOn, true));
}
break;
case ConfigType.PenCapOff:
IsPenCapOffEnabled = pk.GetByteToInt() == 0x01;
if (!isFirstStatus)
{
ConfigSetupResultReceived?.Invoke(this, new ConfigSetupResultReceivedEventArgs(ConfigType.PenCapOff, true));
}
break;
case ConfigType.Beep:
IsBeepEnabled = pk.GetByteToInt() == 0x01;
if (!isFirstStatus)
{
ConfigSetupResultReceived?.Invoke(this, new ConfigSetupResultReceivedEventArgs(ConfigType.Beep, true));
}
break;
case ConfigType.SaveOfflineData:
CanSaveOfflineData = pk.GetByteToInt() == 0x01;
if (!isFirstStatus)
{
ConfigSetupResultReceived?.Invoke(this, new ConfigSetupResultReceivedEventArgs(ConfigType.SaveOfflineData, true));
}
break;
case ConfigType.DownSampling:
IsDownsamplingEnabled = pk.GetByteToInt() == 0x01;
if (!isFirstStatus)
{
ConfigSetupResultReceived?.Invoke(this, new ConfigSetupResultReceivedEventArgs(ConfigType.DownSampling, true));
}
break;
case ConfigType.Battery:
var battery = pk.GetByteToInt();
BatteryStatusReceived?.Invoke(this, new BatteryStatusReceivedEventArgs(battery));
break;
}
}
if (isFirstStatus)
{
IsActive = true;
Authenticated?.Invoke(this, null);
isFirstStatus = false;
}
}
break;
case Cmd.SETCONFIG:
{
int typeCount = pk.GetByteToInt();
for (int i = 0; i < typeCount; i++)
{
int type = pk.GetByteToInt();
bool result = pk.GetByteToInt() == 0x00;
if (result)
{
if ((ConfigType)type == ConfigType.DateTime)
{
ConfigSetupResultReceived?.Invoke(this, new ConfigSetupResultReceivedEventArgs(ConfigType.DateTime, true));
}
else
{
GetConfigRequest((ConfigType)type);
}
}
else
{
ConfigSetupResultReceived?.Invoke(this, new ConfigSetupResultReceivedEventArgs((ConfigType)type, false));
}
}
}
break;
case Cmd.FORMAT:
{
bool result = pk.GetByteToInt() == 0x00;
FormatResultReceived?.Invoke(this, new ResultReceivedEventArgs(result ? ResultReceivedEventArgs.ResultType.Success : ResultReceivedEventArgs.ResultType.Failed));
}
break;
case Cmd.GETOFFLINEDATALIST:
case Cmd.GETLOGFILELIST:
{
int result = pk.GetByteToInt();
int fileCount = pk.GetInt();
var resultList = new List <string>();
for (int i = 0; i < fileCount; i++)
{
string fileName = pk.GetString(16);
resultList.Add(fileName);
}
FileListReceivedEventArgs.ResultType resultType;
if (result == 0)
{
resultType = FileListReceivedEventArgs.ResultType.Success;
}
else if (result == 1)
{
resultType = FileListReceivedEventArgs.ResultType.Failed;
}
else if (result == 2)
{
resultType = FileListReceivedEventArgs.ResultType.TooManyFileExists;
}
else
{
resultType = FileListReceivedEventArgs.ResultType.UnknownError;
}
if (pk.Cmd == Cmd.GETOFFLINEDATALIST)
{
OfflineFileListReceived?.Invoke(this, new FileListReceivedEventArgs(resultType, resultList.ToArray()));
}
else
{
LogFileListReceived?.Invoke(this, new FileListReceivedEventArgs(resultType, resultList.ToArray()));
}
}
break;
case Cmd.GETFILE_H:
{
bool result = pk.GetByteToInt() == 0x00;
int fileSize = pk.GetInt();
int packetSize = pk.GetInt() - 8;
if (fileRequestInfo)
{
FileInfoReceived?.Invoke(this, new FileInfoReceivedEventArgs(result ? FileInfoReceivedEventArgs.ResultType.Success : FileInfoReceivedEventArgs.ResultType.FileNotExists, requestFileName, fileSize));
}
else
{
if (!result)
{
FileDownloadResultReceived?.Invoke(this, new FileDownloadResultReceivedEventArgs(FileDownloadResultReceivedEventArgs.ResultType.FileNotExists));
}
else
{
fileSerializer = new FileBuilder(targetFilePath, fileSize, packetSize);
downloadRetryCount = 0;
FileDownloadProgressChanged?.Invoke(this, new ProgressChangedEventArgs(0));
GetFilePacketRequest(0);
}
}
}
break;
case Cmd.GETFILE_D:
{
int result = pk.GetByteToInt();
int offset = pk.GetInt();
int dataLength = pk.GetInt();
byte[] data = pk.GetBytes(dataLength);
if (result == 0x00)
{
fileSerializer.Put(data, offset);
int progress = (int)((double)offset / (double)(fileSerializer.FileSize - 1));
if (fileSerializer.GetNextOffset() < fileSerializer.FileSize)
{
FileDownloadProgressChanged?.Invoke(this, new ProgressChangedEventArgs(progress));
GetFilePacketRequest(fileSerializer.GetNextOffset());
}
else
{
bool fileCreated = fileSerializer.MakeFile();
if (fileCreated)
{
FileDownloadProgressChanged?.Invoke(this, new ProgressChangedEventArgs(100));
}
FileDownloadResultReceived?.Invoke(this, new FileDownloadResultReceivedEventArgs(fileCreated ? FileDownloadResultReceivedEventArgs.ResultType.Success : FileDownloadResultReceivedEventArgs.ResultType.Failed));
}
}
else
{
if (downloadRetryCount++ > 3)
{
FileDownloadResultReceivedEventArgs.ResultType resultType;
if (result == 0x1)
{
resultType = FileDownloadResultReceivedEventArgs.ResultType.Failed;
}
else if (result == 0x10)
{
resultType = FileDownloadResultReceivedEventArgs.ResultType.OffsetInvalid;
}
else if (result == 0x11)
{
resultType = FileDownloadResultReceivedEventArgs.ResultType.CannotOpenFile;
}
else
{
resultType = FileDownloadResultReceivedEventArgs.ResultType.UnknownError;
}
FileDownloadResultReceived?.Invoke(this, new FileDownloadResultReceivedEventArgs(resultType));
}
else
{
GetFilePacketRequest(offset);
}
}
}
break;
case Cmd.DELETEFILE:
{
bool result = pk.GetByteToInt() == 0x00;
DeleteFileResultReceived?.Invoke(this, new ResultReceivedEventArgs(result ? ResultReceivedEventArgs.ResultType.Success : ResultReceivedEventArgs.ResultType.Failed));
}
break;
case Cmd.POWEROFF:
{
bool result = pk.GetByteToInt() == 0x00;
PowerOffResultReceived?.Invoke(this, new ResultReceivedEventArgs(result ? ResultReceivedEventArgs.ResultType.Success : ResultReceivedEventArgs.ResultType.Failed));
}
break;
case Cmd.UPDATE_START:
{
int result = pk.GetByteToInt();
int packetSize = pk.GetInt() - 8;
if (result == 0x00 && fileSplitter != null)
{
updateRetryCount = 0;
if (fileSplitter.Split(packetSize) && fileSplitter.PacketCount > 0)
{
UpdateProgressChanged?.Invoke(this, new ProgressChangedEventArgs(0));
UpdatePacketUploadRequest(0, fileSplitter.GetBytes(0));
}
else
{
isUpdating = false;
UpdateResultReceived?.Invoke(this, new UpdateResultReceivedEventArgs(UpdateResultReceivedEventArgs.ResultType.DeviceIsNotCorrect));
}
}
else
{
isUpdating = false;
UpdateResultReceived?.Invoke(this, new UpdateResultReceivedEventArgs(result == 1 ? UpdateResultReceivedEventArgs.ResultType.DeviceIsNotCorrect : UpdateResultReceivedEventArgs.ResultType.FirmwareVersionIsNotCorrect));
}
}
break;
case Cmd.UPDATE_DO:
{
if (!isUpdating)
{
return;
}
int result = pk.GetByteToInt();
int offset = pk.GetInt();
if (result == 0x00)
{
updateRetryCount = 0;
if (offset + fileSplitter.PacketSize >= fileSplitter.FileSize - 1)
{
UpdateProgressChanged?.Invoke(this, new ProgressChangedEventArgs(100));
UpdateResultReceived?.Invoke(this, new UpdateResultReceivedEventArgs(UpdateResultReceivedEventArgs.ResultType.Complete));
}
else
{
int progress = (int)((double)offset / (double)(fileSplitter.FileSize - 1) * 100);
UpdateProgressChanged?.Invoke(this, new ProgressChangedEventArgs(progress));
UpdatePacketUploadRequest(offset + fileSplitter.PacketSize, fileSplitter.GetBytes(offset + fileSplitter.PacketSize));
}
}
else
{
System.Diagnostics.Debug.WriteLine("UPDATE_DO : {0} {1}", offset, result);
if (updateRetryCount++ > 3)
{
UpdateResultReceived?.Invoke(this, new UpdateResultReceivedEventArgs(UpdateResultReceivedEventArgs.ResultType.UnknownError));
}
else
{
UpdatePacketUploadRequest(offset, fileSplitter.GetBytes(offset));
}
}
}
break;
}
}
public void OnUpdateProgressChanged(UpdateProgressChangedEventArgs args)
{
UpdateProgressChanged?.Invoke(this, args);
}
private void Downloader_DownloadProgress(object sender, DownloadProgressEventArgs e)
{
UpdateProgressChanged?.Invoke(this, new UpdateProgressEventArgs(UpdateProgressState.DOWNLOADING,
(int)(e.TotalBytesReceived / (double)e.TotalBytesToDownload * 100.0),
(int)(e.BytesReceivedFromFile / (double)e.CurrentFileSize * 100.0), e.CurrentFilePath));
}
private void OnUpdateProgressChanged(int FilesUpdated, int FilesToUpdate)
{
UpdateProgressChanged?.Invoke(this, new UpdateProgressChangedEventArgs(FilesUpdated, FilesToUpdate));
}
