private List <UploadablePart> GetItemParts(UploadableItem item, long isoFileLength, IList <UploadablePart> uploadedParts)
{
const int partSize = 32 * 1024;
foreach (var uploadedPart in uploadedParts)
{
uploadedPart.SetParentItem(item);
}
var parts = new List <UploadablePart>(uploadedParts);
var uploadedLength = uploadedParts.Sum(x => x.Count);
var uploadingLength = item.IsoFileLength - uploadedLength;
if (uploadingLength == 0)
{
return(parts);
}
var partsCount = uploadingLength / partSize + 1;
for (var i = 0; i < partsCount; i++)
{
var partId = i + uploadedParts.Count;
var part = new UploadablePart(item, new TLInt(partId), uploadedLength + i * partSize, Math.Min(partSize, isoFileLength - (uploadedLength + i * partSize)));
parts.Add(part);
}
return(parts);
}
private List <UploadablePart> GetItemParts(UploadableItem item, long isoFileLength)
{
//const int partSize = 32 * 1024; // 32 Kb: êðàòíî 1 Kb è íàöåëî äåëèò 1024 Kb
//var parts = new List<UploadablePart>();
//var partsCount = item.FileLength / partSize + (item.FileLength % partSize > 0 ? 1 : 0);
var partSize = (int)Math.Max(128, (isoFileLength + 1024 * 3000 - 1) / (1024 * 3000));
if (1024 % partSize != 0)
{
int chunkSize = 64;
while (partSize > chunkSize)
{
chunkSize *= 2;
}
partSize = chunkSize;
}
partSize *= 1024;
var parts = new List <UploadablePart>();
var partsCount = (int)(isoFileLength + partSize - 1) / partSize;
for (var i = 0; i < partsCount; i++)
{
var part = new UploadablePart(item, i, i * partSize, Math.Min(partSize, isoFileLength - i * partSize));
parts.Add(part);
}
item.IsSmallFile = item.FileLength < Constants.SmallFileMaxSize;// size < chunkSize;
return(parts);
}
private List <UploadablePart> GetItemParts(UploadableItem item, long isoFileLength)
{
const int partSize = 32 * 1024; // 32 Kb: кратно 1 Kb и нацело делит 1024 Kb
var parts = new List <UploadablePart>();
var partsCount = item.IsoFileLength / partSize + (item.IsoFileLength % partSize > 0 ? 1 : 0);
for (var i = 0; i < partsCount; i++)
{
var part = new UploadablePart(item, new TLInt(i), i * partSize, Math.Min(partSize, isoFileLength - i * partSize));
parts.Add(part);
}
return(parts);
}
private static List <UploadablePart> GetItemParts(UploadableItem item, int size)
{
var chunkSize = FileUtils.GetChunkSize(size);
var partsCount = FileUtils.GetPartsCount(size, chunkSize);
var parts = new List <UploadablePart>(partsCount);
for (var i = 0; i < partsCount; i++)
{
var part = new UploadablePart(item, new TLInt(i), i * chunkSize, Math.Min(chunkSize, (long)size - i * chunkSize));
parts.Add(part);
}
return(parts);
}
private List<UploadablePart> GetItemParts(UploadableItem item, long fileLength)
{
var chunkSize = FileUtils.GetChunkSize(fileLength);
var partsCount = FileUtils.GetPartsCount(fileLength, chunkSize);
var parts = new List<UploadablePart>();
for (var i = 0; i < partsCount; i++)
{
var part = new UploadablePart(item, new TLInt(i), i * chunkSize, Math.Min(chunkSize, fileLength - i * chunkSize));
parts.Add(part);
}
item.IsSmallFile = fileLength < chunkSize;
return parts;
}
private static List <UploadablePart> GetItemParts(UploadableItem item)
{
var size = item.Bytes.Length;
var chunkSize = FileUtils.GetChunkSize(size);
var partsCount = FileUtils.GetPartsCount(size, chunkSize);
var parts = new List <UploadablePart>(partsCount);
for (var i = 0; i < partsCount; i++)
{
var part = new UploadablePart(item, new TLInt(i), item.Bytes.SubArray(i * chunkSize, Math.Min(chunkSize, item.Bytes.Length - i * chunkSize)));
parts.Add(part);
}
return(parts);
}
private static List <UploadablePart> GetItemParts(UploadableItem item)
{
var size = item.Bytes.Length;
var chunkSize = FileUtils.GetChunkSize(size);
var partsCount = FileUtils.GetPartsCount(size, chunkSize);
var parts = new List <UploadablePart>(partsCount);
for (var i = 0; i < partsCount; i++)
{
var part = new UploadablePart(item, i, item.Bytes.SubArray(i * chunkSize, Math.Min(chunkSize, item.Bytes.Length - i * chunkSize)));
parts.Add(part);
}
item.IsSmallFile = size < Constants.SmallFileMaxSize;// size < chunkSize;
return(parts);
}
private List<UploadablePart> GetItemParts(UploadableItem item, long fileLength, IList<UploadablePart> uploadedParts)
{
var chunkSize = FileUtils.GetChunkSize(fileLength);
var parts = new List<UploadablePart>(uploadedParts);
foreach (var uploadedPart in uploadedParts)
{
uploadedPart.SetParentItem(item);
}
var uploadedLength = uploadedParts.Sum(x => x.Count);
var partsCount = FileUtils.GetPartsCount(item.IsoFileLength - uploadedLength, chunkSize);
for (var i = 0; i < partsCount; i++)
{
var partId = i + uploadedParts.Count;
var part = new UploadablePart(item, new TLInt(partId), uploadedLength + i * chunkSize, Math.Min(chunkSize, fileLength - (uploadedLength + i * chunkSize)));
parts.Add(part);
}
item.IsSmallFile = fileLength < chunkSize;
return parts;
}
private void OnUploading(object state)
{
UploadablePart 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 bytes = part.Bytes;
var fileName = part.ParentItem.IsoFileName;
if (!string.IsNullOrEmpty(fileName))
{
bytes = FileUtils.ReadBytes(fileName, part.Position, part.Count);
}
#if WP8
if (bytes == null)
{
var file = part.ParentItem.File;
Tuple<bool, byte[]> result = null;
if (file != null)
{
var task = FileUtils.FillBuffer(file, part);
task.Wait();
result = task.Result;
}
if (result == null)
{
part.Status = PartStatus.Ready;
return;
}
if (!result.Item1)
{
part.ParentItem.FileNotFound = true;
part.Status = PartStatus.Processed;
FileUtils.NotifyProgress(_itemsSyncRoot, _items, part, _eventAggregator);
return;
}
bytes = result.Item2;
}
#endif
if (part.ParentItem.IsSmallFile)
{
var result = PutFile(part.ParentItem.FileId, part.FilePart, bytes);
while (!result)
{
if (part.ParentItem.Canceled)
{
return;
}
result = PutFile(part.ParentItem.FileId, part.FilePart, bytes);
}
}
else
{
var result = PutBigFile(part.ParentItem.FileId, part.FilePart, new TLInt(part.ParentItem.Parts.Count), bytes);
while (!result)
{
if (part.ParentItem.Canceled)
{
return;
}
result = PutBigFile(part.ParentItem.FileId, part.FilePart, new TLInt(part.ParentItem.Parts.Count), bytes);
}
}
part.ClearBuffer();
FileUtils.NotifyProgress(_itemsSyncRoot, _items, part, _eventAggregator);
}
else
{
var currentWorker = (Worker)state;
currentWorker.Stop();
}
}
private void OnUploading(object state)
{
UploadablePart 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 bytes = FileUtils.ReadBytes(part.ParentItem.IsoFileName, 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);
}
part.ClearBuffer();
// indicate progress
// indicate complete
bool isComplete = false;
bool isCanceled;
var progress = 0.0;
lock (_itemsSyncRoot)
{
part.Status = PartStatus.Processed;
isCanceled = part.ParentItem.Canceled;
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)
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(part.ParentItem));
}
else
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(new UploadProgressChangedEventArgs(part.ParentItem, progress)));
}
}
}
else
{
var currentWorker = (Worker)state;
currentWorker.Stop();
}
}
private void OnUploading(object state)
{
UploadablePart 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 bytes = part.Bytes;
#if WP8
if (bytes == null)
{
var file = part.ParentItem.File;
if (file != null)
{
var task = FileUtils.FillBuffer(file, part);
task.Wait();
bytes = task.Result.Item2;
}
if (bytes == null)
{
part.Status = PartStatus.Ready;
return;
}
}
#endif
var result = PutFile(part.ParentItem.FileId, part.FilePart, new TLInt(part.ParentItem.Parts.Count), bytes);
while (!result)
{
if (part.ParentItem.Canceled)
{
return;
}
result = PutFile(part.ParentItem.FileId, part.FilePart, new TLInt(part.ParentItem.Parts.Count), bytes);
}
// indicate progress
// indicate complete
bool isComplete = false;
bool isCanceled;
var progress = 0.0;
lock (_itemsSyncRoot)
{
part.Status = PartStatus.Processed;
isCanceled = part.ParentItem.Canceled;
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)
{
try
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(part.ParentItem));
}
catch (Exception e)
{
TLUtils.WriteLine(e.ToString(), LogSeverity.Error);
}
}
else
{
try
{
Execute.BeginOnThreadPool(() => _eventAggregator.Publish(new UploadProgressChangedEventArgs(part.ParentItem, progress)));
}
catch (Exception e)
{
TLUtils.WriteLine(e.ToString(), LogSeverity.Error);
}
}
}
}
else
{
var currentWorker = (Worker)state;
currentWorker.Stop();
}
}
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();
}
}
