private void OnDownloading(object state)
{
DownloadablePart part = null;
lock (_itemsSyncRoot)
{
for (var i = 0; i < _items.Count; i++)
{
var item = _items[i];
if (item.Canceled)
{
_items.RemoveAt(i--);
try
{
//_eventAggregator.Publish(new UploadingCanceledEventArgs(item));
}
catch (Exception e)
{
TLUtils.WriteException(e);
}
}
}
foreach (var item in _items)
{
part = item.Parts.FirstOrDefault(x => x.Status == PartStatus.Ready);
if (part != null)
{
part.Status = PartStatus.Processing;
break;
}
}
}
if (part == null)
{
var currentWorker = (Worker)state;
currentWorker.Stop();
return;
}
var partName = part.ParentItem.InputLocation.GetPartFileName(part.Number, "audio");
var isLastPart = part.Number + 1 == part.ParentItem.Parts.Count;
var partLength = FileUtils.GetLocalFileLength(partName);
var partExists = partLength > 0;
var isCorrectPartLength = isLastPart || partLength == part.Limit.Value;
if (!partExists || !isCorrectPartLength)
{
bool canceled;
ProcessFilePart(part, part.ParentItem.DCId, part.ParentItem.InputLocation, out canceled);
if (canceled)
{
lock (_itemsSyncRoot)
{
part.ParentItem.Canceled = true;
part.Status = PartStatus.Processed;
_items.Remove(part.ParentItem);
}
return;
}
//part.File = GetFile(part.ParentItem.DCId, (TLInputFileLocationBase) part.ParentItem.InputAudioLocation, part.Offset, part.Limit, out error, out canceled);
//while (part.File == null)
//{
// part.File = GetFile(part.ParentItem.DCId, (TLInputFileLocationBase) part.ParentItem.InputAudioLocation, part.Offset, part.Limit, out error, out canceled);
//}
}
// indicate progress
// indicate complete
bool isComplete;
bool isCanceled;
var progress = 0.0;
lock (_itemsSyncRoot)
{
part.Status = PartStatus.Processed;
FileUtils.CheckMissingPart(_itemsSyncRoot, part, partName);
isCanceled = part.ParentItem.Canceled;
isComplete = part.ParentItem.Parts.All(x => x.Status == PartStatus.Processed);
if (!isComplete)
{
var downloadedCount = part.ParentItem.Parts.Count(x => x.Status == PartStatus.Processed);
var count = part.ParentItem.Parts.Count;
progress = downloadedCount / (double)count;
}
else
{
_items.Remove(part.ParentItem);
}
}
if (!isCanceled)
{
if (isComplete)
{
var fileName = part.ParentItem.InputLocation.GetFileName("audio", ".mp3");
var getPartName = new Func <DownloadablePart, string>(x => x.ParentItem.InputLocation.GetPartFileName(x.Number, "audio"));
FileUtils.MergePartsToFile(getPartName, part.ParentItem.Parts, fileName);
part.ParentItem.IsoFileName = fileName;
if (part.ParentItem.Callback != null)
{
Execute.BeginOnThreadPool(() => part.ParentItem.Callback(part.ParentItem));
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(part.ParentItem));
}
}
else
{
//Execute.BeginOnThreadPool(() => _eventAggregator.Publish(new ProgressChangedEventArgs(part.ParentItem, progress)));
}
}
}
private TLUploadFileBase GetCdnFile(TLUploadFileCdnRedirect redirect, int dcId, TLInputDocumentFileLocation location, int offset, int limit, out TLRPCError er, out bool isCanceled)
{
var manualResetEvent = new ManualResetEvent(false);
TLUploadFileBase result = null;
TLRPCError outError = null;
var outIsCanceled = false;
var req = new TLUploadGetCdnFile();
req.FileToken = redirect.FileToken;
req.Limit = limit;
req.Offset = offset;
_mtProtoService.SendRequestAsync <TLUploadCdnFileBase>("upload.getCdnFile", req, redirect.DCId, true, callback =>
{
if (callback is TLUploadCdnFile file)
{
var iv = redirect.EncryptionIV;
var counter = offset / 16;
iv[15] = (byte)(counter & 0xFF);
iv[14] = (byte)((counter >> 8) & 0xFF);
iv[13] = (byte)((counter >> 16) & 0xFF);
iv[12] = (byte)((counter >> 24) & 0xFF);
var key = CryptographicBuffer.CreateFromByteArray(redirect.EncryptionKey);
var ecount_buf = new byte[0];
var num = 0u;
var bytes = Utils.AES_ctr128_encrypt(file.Bytes, key, ref iv, ref ecount_buf, ref num);
result = new TLUploadFile {
Bytes = bytes
};
manualResetEvent.Set();
_statsService.IncrementReceivedBytesCount(_mtProtoService.NetworkType, _dataType, file.Bytes.Length + 4);
}
else if (callback is TLUploadCdnFileReuploadNeeded reupload)
{
result = ReuploadFile(redirect, reupload.RequestToken, dcId, location, offset, limit, out outError, out outIsCanceled);
while (result == null)
{
result = ReuploadFile(redirect, reupload.RequestToken, dcId, location, offset, limit, out outError, out outIsCanceled);
if (outIsCanceled)
{
break;
}
}
manualResetEvent.Set();
}
},
error =>
{
outError = error;
if (error.CodeEquals(TLErrorCode.INTERNAL) ||
(error.CodeEquals(TLErrorCode.BAD_REQUEST) && (error.TypeEquals(TLErrorType.LOCATION_INVALID) || error.TypeEquals(TLErrorType.VOLUME_LOC_NOT_FOUND))) ||
(error.CodeEquals(TLErrorCode.NOT_FOUND) && error.ErrorMessage != null && error.ErrorMessage.ToString().StartsWith("Incorrect dhGen")))
{
outIsCanceled = true;
manualResetEvent.Set();
return;
}
int delay;
lock (_randomRoot)
{
delay = _random.Next(1000, 3000);
}
Execute.BeginOnThreadPool(TimeSpan.FromMilliseconds(delay), () => manualResetEvent.Set());
});
manualResetEvent.WaitOne(20 * 1000);
er = outError;
isCanceled = outIsCanceled;
return(result);
}
private void OnDownloading(object state)
{
DownloadablePart part = null;
lock (_itemsSyncRoot)
{
for (var i = 0; i < _items.Count; i++)
{
var item = _items[i];
if (item.IsCancelled)
{
_items.RemoveAt(i--);
try
{
//_eventAggregator.Publish(new UploadingCanceledEventArgs(item));
}
catch (Exception e)
{
TLUtils.WriteException(e);
}
}
}
foreach (var item in _items)
{
part = item.Parts.FirstOrDefault(x => x.Status == PartStatus.Ready);
if (part != null)
{
part.Status = PartStatus.Processing;
break;
}
}
}
if (part == null)
{
var currentWorker = (Worker)state;
currentWorker.Stop();
return;
}
var partName = part.ParentItem.InputDocumentLocation.GetPartFileName(part.Number);//string.Format("document{0}_{1}_{2}.dat", part.ParentItem.InputDocumentLocation.Id, part.ParentItem.InputDocumentLocation.AccessHash, part.Number);
TLRPCError error;
bool canceled;
do
{
TLUploadFileBase result;
if (part.ParentItem.CdnRedirect != null)
{
result = GetCdnFile(part.ParentItem.CdnRedirect, part.ParentItem.DCId, part.ParentItem.InputDocumentLocation, part.Offset, part.Limit, out error, out canceled);
}
else
{
result = GetFile(part.ParentItem.DCId, part.ParentItem.InputDocumentLocation, part.Offset, part.Limit, out error, out canceled);
}
if (result is TLUploadFileCdnRedirect redirect)
{
part.ParentItem.CdnRedirect = redirect;
continue;
}
else
{
part.File = result as TLUploadFile;
}
if (canceled)
{
lock (_itemsSyncRoot)
{
part.ParentItem.IsCancelled = true;
part.Status = PartStatus.Processed;
_items.Remove(part.ParentItem);
}
return;
}
} while (part.File == null);
// indicate progress
// indicate complete
bool isComplete;
bool isCanceled;
var progress = 0.0;
lock (_itemsSyncRoot)
{
part.Status = PartStatus.Processed;
if (!part.ParentItem.SuppressMerge)
{
FileUtils.CheckMissingPart(_itemsSyncRoot, part, partName);
}
isCanceled = part.ParentItem.IsCancelled;
isComplete = part.ParentItem.Parts.All(x => x.Status == PartStatus.Processed);
if (!isComplete)
{
var downloadedCount = part.ParentItem.Parts.Count(x => x.Status == PartStatus.Processed);
var count = part.ParentItem.Parts.Count;
progress = downloadedCount / (double)count;
}
else
{
//var id = part.ParentItem.InputDocumentLocation.Id;
//var accessHash = part.ParentItem.InputDocumentLocation.AccessHash;
//var fileExtension = Path.GetExtension(part.ParentItem.FileName.ToString());
//var fileName = string.Format("document{0}_{1}{2}", id, accessHash, fileExtension);
//if (fileName.EndsWith(".mp4"))
//{
// Logs.Log.SyncWrite("FileManager.IsComplete " + fileName + " hash=" + part.ParentItem.GetHashCode());
//}
_items.Remove(part.ParentItem);
}
}
if (!isCanceled)
{
if (isComplete)
{
//var id = part.ParentItem.InputDocumentLocation.Id;
//var accessHash = part.ParentItem.InputDocumentLocation.AccessHash;
//var version = part.ParentItem.InputDocumentLocation.Version;
var fileExtension = Path.GetExtension(part.ParentItem.FileName.ToString());
var fileName = GetFileName(part.ParentItem.InputDocumentLocation, fileExtension);
Func <DownloadablePart, string> getPartName = x => part.ParentItem.InputDocumentLocation.GetPartFileName(x.Number);
if (!part.ParentItem.SuppressMerge)
{
FileUtils.MergePartsToFile(getPartName, part.ParentItem.Parts, fileName);
}
part.ParentItem.IsoFileName = fileName;
if (part.ParentItem.Callback != null)
{
//Execute.BeginOnThreadPool(() =>
//{
// part.ParentItem.Callback(part.ParentItem);
// if (part.ParentItem.Callbacks != null)
// {
// foreach (var callback in part.ParentItem.Callbacks)
// {
// callback?.Invoke(part.ParentItem);
// }
// }
//});
part.ParentItem.Progress.Report(1.0);
part.ParentItem.Callback.TrySetResult(part.ParentItem);
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(part.ParentItem));
}
_statsService.IncrementReceivedItemsCount(_mtProtoService.NetworkType, _dataType, 1);
}
else
{
if (part.ParentItem.Callback != null)
{
part.ParentItem.Progress.Report(progress);
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(new DownloadProgressChangedEventArgs(part.ParentItem, progress)));
}
}
}
}
public void SyncStickers()
{
Execute.BeginOnThreadPool(() =>
{
_stickersService.LoadRecents(StickerType.Image, false, true);
var stickers = _stickersService.CheckStickers(StickerType.Image);
var featured = _stickersService.CheckFeaturedStickers();
ProcessRecentStickers();
if (stickers && !_stickers)
{
ProcessStickers();
}
if (featured && !_featured)
{
ProcessFeaturedStickers();
}
#region Old
//var watch = Stopwatch.StartNew();
//var response = await ProtoService.GetAllStickersAsync(0);
//if (response.IsSucceeded)
//{
// var old = DatabaseContext.Current.SelectStickerSets();
// var allStickers = response.Result as TLMessagesAllStickers;
// if (allStickers != null)
// {
// var needData = new Dictionary<long, TLStickerSet>();
// var ready = new Dictionary<long, TLStickerSet>();
// var removed = new List<TLStickerSet>();
// foreach (var set in allStickers.Sets)
// {
// var cached = old.FirstOrDefault(x => x.Id == set.Id);
// if (cached != null)
// {
// if (cached.Hash == set.Hash)
// {
// ready[set.Id] = cached;
// }
// else
// {
// needData[set.Id] = set;
// }
// }
// else
// {
// needData[set.Id] = set;
// }
// }
// foreach (var set in old)
// {
// if (needData.ContainsKey(set.Id) || ready.ContainsKey(set.Id)) { }
// else
// {
// removed.Add(set);
// }
// }
// if (removed.Count > 0)
// {
// DatabaseContext.Current.RemoveStickerSets(removed);
// }
// if (needData.Count > 0)
// {
// var results = new List<TLMessagesStickerSet>();
// var resultsSyncRoot = new object();
// ProtoService.GetStickerSetsAsync(new TLMessagesAllStickers { Sets = new TLVector<TLStickerSet>(needData.Values) },
// result =>
// {
// Debugger.Break();
// //DatabaseContext.Current.InsertStickerSets(needData.Values);
// },
// stickerSetResult =>
// {
// var messagesStickerSet = stickerSetResult as TLMessagesStickerSet;
// if (messagesStickerSet != null)
// {
// bool processStickerSets;
// lock (resultsSyncRoot)
// {
// results.Add(messagesStickerSet);
// processStickerSets = results.Count == needData.Values.Count;
// }
// if (processStickerSets)
// {
// DatabaseContext.Current.InsertStickerSets(results);
// DatabaseContext.Current.UpdateStickerSetsOrder(allStickers.Sets);
// //foreach (var item in ready)
// //{
// // var items = DatabaseContext.Current.SelectDocuments("Stickers", item.Key);
// //}
// watch.Stop();
// Execute.BeginOnUIThread(async () =>
// {
// await new MessageDialog(watch.Elapsed.ToString()).ShowQueuedAsync();
// });
// }
// }
// },
// failure =>
// {
// Debugger.Break();
// });
// }
// else
// {
// DatabaseContext.Current.UpdateStickerSetsOrder(allStickers.Sets);
// }
// }
//}
#endregion
});
}
public void SyncGifs()
{
Execute.BeginOnThreadPool(() =>
{
_stickersService.LoadRecents(StickerType.Image, true, true);
ProcessRecentGifs();
#region Old
//var gifs = await _gifsService.GetSavedGifs();
//if (gifs.Key != SavedGifsHash || SavedGifs.Count == 0)
//{
// Execute.BeginOnUIThread(() =>
// {
// SavedGifsHash = gifs.Key;
// //SavedGifs.Clear();
// //SavedGifs.AddRange(gifs);
// if (SavedGifs.Count > 0)
// {
// for (int i = 0; i < gifs.Count; i++)
// {
// var user = gifs[i];
// var index = -1;
// for (int j = 0; j < SavedGifs.Count; j++)
// {
// if (SavedGifs[j].Id == user.Id)
// {
// index = j;
// break;
// }
// }
// if (index > -1 && index != i)
// {
// SavedGifs.RemoveAt(index);
// SavedGifs.Insert(Math.Min(i, SavedGifs.Count), user);
// }
// else if (index == -1)
// {
// SavedGifs.Insert(Math.Min(i, SavedGifs.Count), user);
// }
// }
// for (int i = 0; i < SavedGifs.Count; i++)
// {
// var user = SavedGifs[i];
// var index = -1;
// for (int j = 0; j < gifs.Count; j++)
// {
// if (gifs[j].Id == user.Id)
// {
// index = j;
// break;
// }
// }
// if (index == -1)
// {
// SavedGifs.Remove(user);
// i--;
// }
// }
// }
// else
// {
// SavedGifs.Clear();
// SavedGifs.AddRange(gifs);
// }
// //var old = SavedGifs.ToArray();
// //if (old.Length > 0)
// //{
// // var order = new Dictionary<int, int>();
// // for (int i = 0; i < old.Length; i++)
// // {
// // order[i] = -1;
// // for (int j = 0; j < gifs.Count; j++)
// // {
// // if (old[i].Id == gifs[j].Id)
// // {
// // order[i] = j;
// // break;
// // }
// // }
// // }
// // //for (int j = 0; j < order.First().Value; j++)
// // //{
// // // if (order.ContainsKey(j) == false)
// // // {
// // // order[j] = j;
// // // }
// // //}
// // foreach (var item in order)
// // {
// // if (item.Key != item.Value)
// // {
// // SavedGifs.RemoveAt(item.Key);
// // SavedGifs.Insert(item.Value, gifs[item.Value]);
// // }
// // }
// // //Debugger.Break();
// //}
// //else
// //{
// // SavedGifs.Clear();
// // SavedGifs.AddRange(gifs);
// //}
// });
//}
#endregion
});
}
public override void SendPacketAsync(string caption, byte[] data, Action <bool> callback, Action <TcpTransportResult> faultCallback = null)
{
var now = DateTime.Now;
if (!FirstSendTime.HasValue)
{
FirstSendTime = now;
}
LastSendTime = now;
Execute.BeginOnThreadPool(() =>
{
TLUtils.WriteLine(" TCP: Send " + caption);
var args = CreateArgs(data, callback);
lock (_isConnectedSocketRoot)
{
var manualResetEvent = new ManualResetEvent(false);
if (!_socket.Connected)
{
if (caption.StartsWith("msgs_ack"))
{
TLUtils.WriteLine("!!!!!!MSGS_ACK FAULT!!!!!!!", LogSeverity.Error);
faultCallback.SafeInvoke(new TcpTransportResult(SocketAsyncOperation.Send, new Exception("MSGS_ACK_FAULT")));
return;
}
ConnectAsync(() =>
{
manualResetEvent.Set();
try
{
_socket.SendAsync(args);
}
catch (Exception ex)
{
faultCallback.SafeInvoke(new TcpTransportResult(SocketAsyncOperation.Send, ex));
WRITE_LOG("Socket.ConnectAsync SendAsync[1]", ex);
}
},
error =>
{
manualResetEvent.Set();
faultCallback.SafeInvoke(error);
});
var connected = manualResetEvent.WaitOne(25000);
if (!connected)
{
faultCallback.SafeInvoke(new TcpTransportResult(SocketAsyncOperation.Connect, new Exception("Connect timeout exception 25s")));
}
}
else
{
try
{
_socket.SendAsync(args);
}
catch (Exception ex)
{
faultCallback.SafeInvoke(new TcpTransportResult(SocketAsyncOperation.Send, ex));
WRITE_LOG("Socket.SendAsync[1]", ex);
}
}
}
});
}
private void OnFileChangedInternal(StorageFile storageFile)
{
Photos.Children.Clear();
LeftTransform.X = -MaxTranslateX;
LeftOpacityBorderTransform.X = -468;
Left.IsHitTestVisible = false;
RightTransform.X = MaxTranslateX;
RightOpacityBorderTransform.X = 468;
Right.IsHitTestVisible = false;
_videoProperties = null;
_composition = null;
TrimRight = null;
TrimLeft = null;
_lastPosition = null;
_isManipulating = false;
if (storageFile != null)
{
Execute.BeginOnThreadPool(TimeSpan.FromSeconds(1.0), async() =>
{
_videoProperties = storageFile.Properties.GetVideoPropertiesAsync().AsTask().Result;
if (_videoProperties == null)
{
return;
}
Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Left.IsHitTestVisible = true;
Right.IsHitTestVisible = true;
});
_composition = new MediaComposition();
var clip = await MediaClip.CreateFromFileAsync(storageFile);
_composition.Clips.Add(clip);
var scaleFactor = 100.0 / Math.Min(_videoProperties.Width, _videoProperties.Height);
var thumbnailWidth = _videoProperties.Orientation == VideoOrientation.Normal || _videoProperties.Orientation == VideoOrientation.Rotate180 ? (int)(_videoProperties.Width * scaleFactor) : (int)(_videoProperties.Height * scaleFactor);
var thumbnailHeight = _videoProperties.Orientation == VideoOrientation.Normal || _videoProperties.Orientation == VideoOrientation.Rotate180 ? (int)(_videoProperties.Height * scaleFactor) : (int)(_videoProperties.Width * scaleFactor);
for (var i = 0; i < 9; i++)
{
var timeStamp = new TimeSpan(_videoProperties.Duration.Ticks / 9 * i);
var photo = await _composition.GetThumbnailAsync(timeStamp, thumbnailWidth, thumbnailHeight, VideoFramePrecision.NearestKeyFrame);
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var bitmapImage = new BitmapImage();
bitmapImage.SetSource(photo);
var image = new Image
{
Source = bitmapImage,
Stretch = Stretch.UniformToFill,
Width = 50,
Height = 48
};
Photos.Children.Add(image);
});
}
});
}
}
public async void SendBotInlineResult(TLBotInlineResultBase result)
{
var currentInlineBot = CurrentInlineBot;
if (currentInlineBot == null)
{
return;
}
var channel = With as TLChannel;
if (channel != null && channel.HasBannedRights && channel.BannedRights.IsSendGames && result.Type.Equals("game", StringComparison.OrdinalIgnoreCase))
{
await TLMessageDialog.ShowAsync("The admins of this group restricted you from posting media content here.", "Warning", "OK");
return;
}
//var inlineBots = DialogDetailsViewModel.GetInlineBots();
//if (!inlineBots.Contains(currentInlineBot))
//{
// inlineBots.Insert(0, currentInlineBot);
// this._cachedUsernameResults.Clear();
//}
//else
//{
// inlineBots.Remove(currentInlineBot);
// inlineBots.Insert(0, currentInlineBot);
// this._cachedUsernameResults.Clear();
//}
//DialogDetailsViewModel.SaveInlineBotsAsync();
//if (_inlineBotResults == null)
//{
// return;
//}
//TLLong arg_74_0 = this._currentInlineBotResults.QueryId;
var date = TLUtils.DateToUniversalTimeTLInt(ProtoService.ClientTicksDelta, DateTime.Now);
var message = TLUtils.GetMessage(SettingsHelper.UserId, Peer.ToPeer(), TLMessageState.Sending, true, true, date, string.Empty, new TLMessageMediaEmpty(), TLLong.Random(), null);
if (message == null)
{
return;
}
ProcessBotInlineResult(ref message, result, currentInlineBot.Id);
//if (this.Reply != null && DialogDetailsViewModel.IsWebPagePreview(this.Reply))
//{
// message._media = ((TLMessagesContainter)this.Reply).WebPageMedia;
// this.Reply = this._previousReply;
//}
if (Reply != null)
{
message.HasReplyToMsgId = true;
message.ReplyToMsgId = Reply.Id;
message.Reply = Reply;
Reply = null;
}
SetText(string.Empty);
//this.Text = string.Empty;
var previousMessage = InsertSendingMessage(message, false);
//this.IsEmptyDialog = (base.Items.get_Count() == 0 && this.LazyItems.get_Count() == 0);
var user = With as TLUser;
if (user != null && user.IsBot && Messages.Count == 1)
{
RaisePropertyChanged(() => With);
}
CurrentInlineBot = null;
InlineBotResults = null;
Execute.BeginOnThreadPool(() =>
{
CacheService.SyncSendingMessage(message, previousMessage, async(m) =>
{
var response = await ProtoService.SendInlineBotResultAsync(message, () =>
{
message.State = TLMessageState.Confirmed;
});
if (response.IsSucceeded)
{
message.RaisePropertyChanged(() => message.Media);
}
});
});
//base.BeginOnUIThread(delegate
//{
// this.ProcessScroll();
// this.RaiseStartGifPlayer(new StartGifPlayerEventArgs(message));
//});
//base.BeginOnUIThread(delegate
//{
// this.ClearInlineBotResults();
// this.CurrentInlineBot = null;
// base.NotifyOfPropertyChange<string>(() => this.BotInlinePlaceholder);
//});
//this._debugNotifyOfPropertyChanged = false;
//base.BeginOnThreadPool(delegate
//{
// this.CacheService.SyncSendingMessage(message, previousMessage, delegate (TLMessageCommon m)
// {
// DialogDetailsViewModel.SendInternal(message, this.MTProtoService, delegate
// {
// }, delegate
// {
// this.Status = string.Empty;
// });
// });
//});
}
public override void SendPacketAsync(string caption, byte[] data, Action <bool> callback, Action <TcpTransportResult> faultCallback = null)
{
var now = DateTime.Now;
if (!FirstSendTime.HasValue)
{
FirstSendTime = now;
}
Execute.BeginOnThreadPool(async() =>
{
bool connect = false;
bool isConnected;
lock (_isConnectedSyncRoot)
{
isConnected = _isConnected;
if (!_isConnected && !_isConnecting)
{
_isConnecting = true;
connect = true;
}
if (connect &&
caption.StartsWith("msgs_ack"))
{
Execute.ShowDebugMessage("TCPTransportWinRT connect on msgs_ack");
connect = false;
}
}
if (!isConnected)
{
if (connect)
{
var connectResult = await ConnectAsync(_timeout, faultCallback);
if (!connectResult)
{
return;
}
//var buffer = GetInitBuffer();
//var sendResult = await SendAsync(_timeout, buffer, faultCallback);
//if (!sendResult) return;
ReceiveAsync(_timeout);
SendQueue(_timeout);
}
else
{
Enqueue(caption, data, faultCallback);
return;
}
}
var sendPacketResult = await SendAsync(_timeout, CreatePacket(data), faultCallback);
if (!sendPacketResult)
{
return;
}
callback?.Invoke(true);
});
}
private void OnUploading(object state)
{
UploadablePart part = null;
lock (_itemsSyncRoot)
{
for (var i = 0; i < _items.Count; i++)
{
var item = _items[i];
if (item.IsCancelled)
{
_items.RemoveAt(i--);
try
{
// TODO: verify
if (item.Callback != null)
{
item.Callback.TrySetResult(null);
}
else
{
_eventAggregator.Publish(new UploadingCanceledEventArgs(item));
}
}
catch (Exception e)
{
TLUtils.WriteException(e);
}
}
}
foreach (var item in _items)
{
part = item.Parts.FirstOrDefault(x => x.Status == PartStatus.Ready);
if (part != null)
{
part.Status = PartStatus.Processing;
break;
}
}
}
if (part != null)
{
var bytes = FileUtils.ReadTemporaryBytes(part.ParentItem.FileName, part.Position, part.Count);
part.SetBuffer(bytes);
//bool result = PutFile(part.ParentItem.FileId, part.FilePart, part.Bytes);
//while (!result)
//{
// if (part.ParentItem.Canceled)
// {
// return;
// }
// result = PutFile(part.ParentItem.FileId, part.FilePart, part.Bytes);
//}
if (part.ParentItem.IsSmallFile)
{
bool result = PutFile(part.ParentItem.FileId, part.FilePart, bytes);
while (!result)
{
if (part.ParentItem.IsCancelled)
{
return;
}
result = PutFile(part.ParentItem.FileId, part.FilePart, bytes);
}
}
else
{
bool result = PutBigFile(part.ParentItem.FileId, part.FilePart, part.ParentItem.Parts.Count, bytes);
while (!result)
{
if (part.ParentItem.IsCancelled)
{
return;
}
result = PutBigFile(part.ParentItem.FileId, part.FilePart, part.ParentItem.Parts.Count, bytes);
}
}
part.ClearBuffer();
// indicate progress
// indicate complete
bool isComplete = false;
bool isCanceled;
var progress = 0.0;
lock (_itemsSyncRoot)
{
part.Status = PartStatus.Processed;
isCanceled = part.ParentItem.IsCancelled;
if (!isCanceled)
{
isComplete = part.ParentItem.Parts.All(x => x.Status == PartStatus.Processed);
if (!isComplete)
{
double uploadedCount = part.ParentItem.Parts.Count(x => x.Status == PartStatus.Processed);
double totalCount = part.ParentItem.Parts.Count;
progress = uploadedCount / totalCount;
}
else
{
_items.Remove(part.ParentItem);
}
}
}
if (!isCanceled)
{
if (isComplete)
{
if (part.ParentItem.Callback != null)
{
part.ParentItem.Progress.Report(1.0);
part.ParentItem.Callback.TrySetResult(part.ParentItem);
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(part.ParentItem));
}
_statsService.IncrementSentItemsCount(_mtProtoService.NetworkType, _dataType, 1);
}
else
{
if (part.ParentItem.Callback != null)
{
part.ParentItem.Progress.Report(progress);
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(new UploadProgressChangedEventArgs(part.ParentItem, progress)));
}
}
}
}
else
{
var currentWorker = (Worker)state;
currentWorker.Stop();
}
}
private void OnDownloading(object state)
{
DownloadablePart part = null;
lock (_itemsSyncRoot)
{
for (var i = 0; i < _items.Count; i++)
{
var item = _items[i];
if (item.IsCancelled)
{
_items.RemoveAt(i--);
try
{
//_eventAggregator.Publish(new UploadingCanceledEventArgs(item));
}
catch (Exception e)
{
TLUtils.WriteException(e);
}
}
}
foreach (var item in _items)
{
part = item.Parts.FirstOrDefault(x => x.Status == PartStatus.Ready);
if (part != null)
{
part.Status = PartStatus.Processing;
break;
}
}
}
if (part == null)
{
var currentWorker = (Worker)state;
currentWorker.Stop();
return;
}
var partName = part.ParentItem.InputEncryptedFileLocation.GetPartFileName(part.Number);
var partLength = FileUtils.GetLocalFileLength(partName);
var partExists = partLength > 0;
var isLastPart = part.Number + 1 == part.ParentItem.Parts.Count;
var isCorrectPartLength = isLastPart || partLength == part.Limit;
if (!partExists || !isCorrectPartLength)
{
part.File = GetFile(part.ParentItem.DCId, part.ParentItem.InputEncryptedFileLocation, part.Offset, part.Limit) as TLUploadFile;
while (part.File == null)
{
part.File = GetFile(part.ParentItem.DCId, part.ParentItem.InputEncryptedFileLocation, part.Offset, part.Limit) as TLUploadFile;
}
}
// indicate progress
// indicate complete
bool isComplete;
bool isCanceled;
var progress = 0.0;
lock (_itemsSyncRoot)
{
part.Status = PartStatus.Processed;
FileUtils.CheckMissingPart(_itemsSyncRoot, part, partName);
isCanceled = part.ParentItem.IsCancelled;
isComplete = part.ParentItem.Parts.All(x => x.Status == PartStatus.Processed);
if (!isComplete)
{
var downloadedCount = part.ParentItem.Parts.Count(x => x.Status == PartStatus.Processed);
var count = part.ParentItem.Parts.Count;
progress = downloadedCount / (double)count;
}
else
{
_items.Remove(part.ParentItem);
}
}
if (!isCanceled)
{
if (isComplete)
{
var fileName = part.ParentItem.InputEncryptedFileLocation.GetFileName();
var getPartFileName = new Func <DownloadablePart, string>(p => p.ParentItem.InputEncryptedFileLocation.GetPartFileName(p.Number));
FileUtils.MergePartsToFile(getPartFileName, part.ParentItem.Parts, fileName);
part.ParentItem.IsoFileName = fileName;
if (part.ParentItem.Callback != null)
{
part.ParentItem.Progress.Report(1.0);
part.ParentItem.Callback.TrySetResult(part.ParentItem);
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(part.ParentItem));
}
_statsService.IncrementReceivedItemsCount(_protoService.NetworkType, _dataType, 1);
}
else
{
if (part.ParentItem.Callback != null)
{
part.ParentItem.Progress.Report(progress);
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(new DownloadProgressChangedEventArgs(part.ParentItem, progress)));
}
}
}
}
private void OnDownloading(object state)
{
DownloadablePart part = null;
lock (_itemsSyncRoot)
{
for (var i = 0; i < _items.Count; i++)
{
var item = _items[i];
if (item.Canceled)
{
_items.RemoveAt(i--);
}
}
foreach (var item in _items)
{
part = item.Parts.FirstOrDefault(x => x.Status == PartStatus.Ready);
if (part != null)
{
part.Status = PartStatus.Processing;
break;
}
}
}
if (part == null)
{
var currentWorker = (Worker)state;
currentWorker.Stop();
return;
}
var fileName = part.ParentItem.DestFileName;
var manualResetEvent = new ManualResetEvent(false);
long?length = null;
var webClient = new WebClient();
webClient.OpenReadAsync(new Uri(part.ParentItem.SourceUri, UriKind.Absolute));
webClient.OpenReadCompleted += (sender, args) =>
{
if (args.Cancelled)
{
Thread.Sleep(TimeSpan.FromSeconds(part.ParentItem.Timeout));
part.ParentItem.IncreaseTimeout();
part.Status = PartStatus.Ready;
manualResetEvent.Set();
return;
}
if (args.Error != null)
{
var webException = args.Error as WebException;
if (webException != null)
{
var response = webException.Response as HttpWebResponse;
if (response != null)
{
if (response.StatusCode == HttpStatusCode.Forbidden ||
response.StatusCode == HttpStatusCode.NotFound)
{
part.HttpErrorsCount++;
if (part.HttpErrorsCount >= 5)
{
lock (_itemsSyncRoot)
{
part.ParentItem.Canceled = true;
}
}
else
{
Thread.Sleep(TimeSpan.FromSeconds(part.ParentItem.Timeout));
part.ParentItem.IncreaseTimeout();
part.Status = PartStatus.Ready;
}
}
else
{
lock (_itemsSyncRoot)
{
part.ParentItem.Canceled = true;
}
}
}
}
manualResetEvent.Set();
return;
}
try
{
length = args.Result.Length;
using (var stream = args.Result)
{
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
using (var file = store.OpenFile(fileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
{
if (store.FileExists(fileName))
{
//if (file.Position > file.Position)
//{
// stream.Seek(file.Position, SeekOrigin.Begin);
//}
//else
{
file.Seek(0, SeekOrigin.Begin);
stream.Seek(0, SeekOrigin.Begin);
}
}
const int BUFFER_SIZE = 128 * 1024;
var buf = new byte[BUFFER_SIZE];
int bytesRead;
while ((bytesRead = stream.Read(buf, 0, BUFFER_SIZE)) > 0)
{
file.Seek(0, SeekOrigin.End);
file.Write(buf, 0, bytesRead);
lock (_itemsSyncRoot)
{
if (part.ParentItem.Canceled)
{
break;
}
}
}
}
}
}
manualResetEvent.Set();
}
catch (Exception ex)
{
manualResetEvent.Set();
}
};
manualResetEvent.WaitOne();
// indicate progress
// indicate complete
bool isComplete;
bool isCanceled;
lock (_itemsSyncRoot)
{
long?fileLength = null;
using (var store = IsolatedStorageFile.GetUserStoreForApplication())
{
if (store.FileExists(fileName))
{
using (var file = store.OpenFile(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
fileLength = file.Length;
}
}
}
isCanceled = part.ParentItem.Canceled;
isComplete = length.HasValue && fileLength.HasValue && fileLength == length;
if (isComplete)
{
part.Status = PartStatus.Processed;
_items.Remove(part.ParentItem);
}
}
if (!isCanceled)
{
if (isComplete)
{
part.ParentItem.IsoFileName = fileName;
if (part.ParentItem.Callback != null)
{
Execute.BeginOnThreadPool(() =>
{
part.ParentItem.Callback(part.ParentItem);
if (part.ParentItem.Callbacks != null)
{
foreach (var callback in part.ParentItem.Callbacks)
{
callback.SafeInvoke(part.ParentItem);
}
}
});
}
}
}
else
{
if (part.ParentItem.FaultCallback != null)
{
Execute.BeginOnThreadPool(() =>
{
part.ParentItem.FaultCallback(part.ParentItem);
if (part.ParentItem.FaultCallbacks != null)
{
foreach (var callback in part.ParentItem.FaultCallbacks)
{
callback.SafeInvoke(part.ParentItem);
}
}
});
}
}
}
private TLUploadFileBase GetCdnFile(TLUploadFileCdnRedirect redirect, int dcId, TLInputDocumentFileLocation location, int offset, int limit, out TLRPCError er, out bool isCanceled)
{
var manualResetEvent = new ManualResetEvent(false);
TLUploadFileBase result = null;
TLRPCError outError = null;
var outIsCanceled = false;
_protoService.GetCdnFileAsync(redirect.DCId, redirect.FileToken, offset, limit, callback =>
{
if (callback is TLUploadCdnFile file)
{
result = new TLUploadFile {
Bytes = file.Bytes
};
manualResetEvent.Set();
_statsService.IncrementReceivedBytesCount(_protoService.NetworkType, _dataType, file.Bytes.Length + 4);
}
else if (callback is TLUploadCdnFileReuploadNeeded reupload)
{
result = ReuploadFile(redirect, reupload.RequestToken, dcId, location, offset, limit, out outError, out outIsCanceled);
while (result == null)
{
result = ReuploadFile(redirect, reupload.RequestToken, dcId, location, offset, limit, out outError, out outIsCanceled);
if (outIsCanceled)
{
break;
}
}
manualResetEvent.Set();
}
},
error =>
{
outError = error;
if (error.CodeEquals(TLErrorCode.INTERNAL) ||
(error.CodeEquals(TLErrorCode.BAD_REQUEST) && (error.TypeEquals(TLErrorType.LOCATION_INVALID) || error.TypeEquals(TLErrorType.VOLUME_LOC_NOT_FOUND))) ||
(error.CodeEquals(TLErrorCode.NOT_FOUND) && error.ErrorMessage != null && error.ErrorMessage.StartsWith("Incorrect dhGen")))
{
outIsCanceled = true;
manualResetEvent.Set();
return;
}
int delay;
lock (_randomRoot)
{
delay = _random.Next(1000, 3000);
}
Execute.BeginOnThreadPool(TimeSpan.FromMilliseconds(delay), () => manualResetEvent.Set());
});
manualResetEvent.WaitOne(20 * 1000);
er = outError;
isCanceled = outIsCanceled;
return(result);
}
private void OnDownloading(object state)
{
DownloadablePart part = null;
lock (_itemsSyncRoot)
{
for (var i = 0; i < _items.Count; i++)
{
var item = _items[i];
if (item.IsCancelled)
{
_items.RemoveAt(i--);
try
{
_eventAggregator.Publish(new DownloadingCanceledEventArgs(item));
}
catch (Exception e)
{
TLUtils.WriteException(e);
}
}
}
foreach (var item in _items)
{
part = item.Parts.FirstOrDefault(x => x.Status == PartStatus.Ready);
if (part != null)
{
part.Status = PartStatus.Processing;
break;
}
}
}
if (part == null)
{
var currentWorker = (Worker)state;
currentWorker.Stop();
return;
}
TLRPCError error;
bool canceled;
do
{
TLUploadFileBase result;
if (part.ParentItem.CdnRedirect != null)
{
result = GetCdnFile(part.ParentItem.CdnRedirect, part.ParentItem.Location, part.Offset, part.Limit, out error, out canceled);
}
else
{
result = GetFile(part.ParentItem.Location, part.Offset, part.Limit, out error, out canceled);
}
if (result is TLUploadFileCdnRedirect redirect)
{
part.ParentItem.CdnRedirect = redirect;
part.ParentItem.CdnHashes = redirect.CdnFileHashes.ToDictionary(x => x.Offset, x => x);
continue;
}
else
{
part.File = result as TLUploadFile;
}
if (canceled)
{
lock (_itemsSyncRoot)
{
part.ParentItem.IsCancelled = true;
part.Status = PartStatus.Processed;
_items.Remove(part.ParentItem);
}
return;
}
} while (part.File == null);
// indicate progress
// indicate complete
bool isComplete;
bool isCanceled;
var progress = 0.0;
lock (_itemsSyncRoot)
{
part.Status = PartStatus.Processed;
var data = part.File.Bytes;
if (data.Length < part.Limit && (part.Number + 1) != part.ParentItem.Parts.Count)
{
var complete = part.ParentItem.Parts.All(x => x.Status == PartStatus.Processed);
if (!complete)
{
var emptyBufferSize = part.Limit - data.Length;
var position = data.Length;
var missingPart = new DownloadablePart(part.ParentItem, position, emptyBufferSize, -part.Number);
var currentItemIndex = part.ParentItem.Parts.IndexOf(part);
part.ParentItem.Parts.Insert(currentItemIndex + 1, missingPart);
}
}
else if (data.Length == part.Limit && (part.Number + 1) == part.ParentItem.Parts.Count)
{
var currentItemIndex = part.ParentItem.Parts.IndexOf(part);
var missingPart = new DownloadablePart(part.ParentItem, part.Offset + part.Limit, part.Limit, currentItemIndex + 1);
part.ParentItem.Parts.Insert(currentItemIndex + 1, missingPart);
}
isCanceled = part.ParentItem.IsCancelled;
isComplete = part.ParentItem.Parts.All(x => x.Status == PartStatus.Processed);
if (!isComplete)
{
var downloadedCount = part.ParentItem.Parts.Count(x => x.Status == PartStatus.Processed);
var count = part.ParentItem.Parts.Count;
progress = (double)downloadedCount / count;
}
else
{
_items.Remove(part.ParentItem);
}
}
if (!isCanceled)
{
if (isComplete)
{
byte[] bytes = { };
foreach (var p in part.ParentItem.Parts)
{
var partBytes = p.File.Bytes;
var redirect = part.ParentItem.CdnRedirect;
if (redirect != null)
{
var iv = redirect.EncryptionIV;
var counter = p.Offset / 16;
iv[15] = (byte)(counter & 0xFF);
iv[14] = (byte)((counter >> 8) & 0xFF);
iv[13] = (byte)((counter >> 16) & 0xFF);
iv[12] = (byte)((counter >> 24) & 0xFF);
var key = CryptographicBuffer.CreateFromByteArray(redirect.EncryptionKey);
var ecount_buf = new byte[0];
var num = 0u;
partBytes = Utils.AES_ctr128_encrypt(partBytes, key, ref iv, ref ecount_buf, ref num);
redirect.EncryptionIV = iv;
//TLCdnFileHash hash;
//if (!part.ParentItem.CdnHashes.TryGetValue(p.Offset, out hash))
//{
// var hashes = GetCdnFileHashes(redirect, part.ParentItem.Location, p.Offset, out TLRPCError er, out bool yolo);
// if (hashes != null)
// {
// foreach (var item in hashes)
// {
// part.ParentItem.CdnHashes[item.Offset] = item;
// }
// part.ParentItem.CdnHashes.TryGetValue(p.Offset, out hash);
// }
//}
//if (hash != null)
//{
// var sha256 = Utils.ComputeSHA256(partBytes);
// if (!sha256.SequenceEqual(hash.Hash))
// {
// lock (_itemsSyncRoot)
// {
// part.ParentItem.IsCancelled = true;
// part.Status = PartStatus.Processed;
// _items.Remove(part.ParentItem);
// }
// Debug.WriteLine("HASH DOESN'T MATCH");
// return;
// }
//}
}
bytes = TLUtils.Combine(bytes, partBytes);
}
//part.ParentItem.Location.Buffer = bytes;
var fileName = String.Format("{0}_{1}_{2}.jpg",
part.ParentItem.Location.VolumeId,
part.ParentItem.Location.LocalId,
part.ParentItem.Location.Secret);
FileUtils.WriteTemporaryBites(fileName, bytes);
if (part.ParentItem.Callback != null)
{
part.ParentItem.Progress.Report(1.0);
part.ParentItem.Callback.TrySetResult(part.ParentItem);
}
else
{
part.ParentItem.Action?.Invoke(part.ParentItem);
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(part.ParentItem));
}
_statsService.IncrementReceivedItemsCount(_mtProtoService.NetworkType, _dataType, 1);
}
else
{
if (part.ParentItem.Callback != null)
{
part.ParentItem.Progress.Report(progress);
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(new DownloadProgressChangedEventArgs(part.ParentItem, progress)));
}
}
}
}