private void PreloadMangas()
{
var preloadables = _scrapers.OfType <IPreload>();
// if there are no preloadables skip the execution
if (!preloadables.Any())
{
return;
}
if (!OperationInProgress)
{
CurrentActionText = "Preloading manga directories ...";
OperationInProgress = true;
}
AsyncWrapper.Call <object>(() =>
{
System.Threading.Tasks.Parallel.ForEach(preloadables, (x) => x.PreloadDirectory());
return(null);
},
(x, y) =>
{
// don't care about errors...
OperationInProgress = false;
CurrentActionText = "";
}
);
}
/// <summary>
/// Gets the request stream
/// </summary>
/// <returns>The request stream</returns>
/// <param name="contentlength">The content length to use</param>
public Stream GetRequestStream(long contentlength = -1)
{
// Prevent in-memory buffering causing out-of-memory issues
if (this.m_request is HttpWebRequest request)
{
if (contentlength >= 0)
{
request.ContentLength = contentlength;
}
if (request.ContentLength >= 0)
{
request.AllowWriteStreamBuffering = false;
}
}
if (m_state == RequestStates.GetRequest)
{
return((Stream)m_asyncRequest.GetResponseOrStream());
}
if (m_state != RequestStates.Created)
{
throw new InvalidOperationException();
}
m_asyncRequest = new AsyncWrapper(this, true);
m_state = RequestStates.GetRequest;
return(TrySetTimeout((Stream)m_asyncRequest.GetResponseOrStream(), m_activity_timeout));
}
public override IAsyncOperation <LaunchResult> HandleAsync(UriHandlerData data)
{
var category = categoryDic[data.Path0];
var keyword = GetKeyword(data);
var advanced = GetAdvancedSearchOptions(data);
return(AsyncWrapper.CreateCompleted <LaunchResult>(new SearchLaunchResult(Client.Current.Search(keyword, category, advanced))));
}
public override IAsyncOperation <LaunchResult> HandleAsync(UriHandlerData data)
{
var sr = data.Queries.ContainsKey("f_shash")
? handleFileSearch(data)
: handleSearch(data);
return(AsyncWrapper.CreateCompleted <LaunchResult>(new SearchLaunchResult(sr)));
}
public IAsyncAction AddToCategoryAsync(IReadOnlyList <ItemIndexRange> items, FavoriteCategory categoty)
{
if (categoty == null)
{
throw new ArgumentNullException(nameof(categoty));
}
if (items == null || items.Count == 0)
{
return(AsyncWrapper.CreateCompleted());
}
return(AsyncInfo.Run(async token =>
{
var ddact = default(string);
if (categoty.Index < 0)
{
ddact = "delete";
}
else
{
ddact = $"fav{categoty.Index}";
}
var post = Client.Current.HttpClient.PostAsync(this.SearchUri, new HttpFormUrlEncodedContent(getParameters()));
token.Register(post.Cancel);
var r = await post;
if (categoty.Index < 0)
{
this.Reset();
}
else
{
foreach (var range in items)
{
for (var i = range.FirstIndex; i <= range.LastIndex; i++)
{
this[i].FavoriteCategory = categoty;
}
}
}
IEnumerable <KeyValuePair <string, string> > getParameters()
{
yield return new KeyValuePair <string, string>("apply", "Apply");
yield return new KeyValuePair <string, string>("ddact", ddact);
foreach (var range in items)
{
for (var i = range.FirstIndex; i <= range.LastIndex; i++)
{
yield return new KeyValuePair <string, string>("modifygids[]", this[i].ID.ToString());
}
}
}
}));
}
public override IAsyncOperation <LaunchResult> HandleAsync(UriHandlerData data)
{
var v = data.Paths[1].Unescape2().Trim();
var category = GetCategory(data);
var advanced = GetAdvancedSearchOptions(data);
switch (data.Path0)
{
case "tag":
return(AsyncWrapper.CreateCompleted <LaunchResult>(new SearchLaunchResult(Tag.Parse(v.TrimEnd(trim)).Search(category, advanced))));
case "uploader":
return(AsyncWrapper.CreateCompleted <LaunchResult>(new SearchLaunchResult(Client.Current.Search(v, null, category, advanced))));
}
return(AsyncWrapper.CreateError <LaunchResult>(new NotSupportedException("Unsupported uri.")));
}
public static IAsyncOperation <Record> GetAsync(string title)
{
using (var db = new WikiDb())
{
var record = db.Table.AsNoTracking().SingleOrDefault(r => r.Title == title);
if (record != null && record.IsValid)
{
return(AsyncWrapper.CreateCompleted(record));
}
if (record == null || record.LastUpdate.AddDays(7) < DateTimeOffset.Now)
{
return(FetchAsync(title));
}
return(AsyncWrapper.CreateCompleted(default(Record)));
}
}
public IAsyncResult BeginRead(AsyncCallback cb, object state)
{
if (m_buffers == null)
m_buffers = new Dictionary<int, byte[]>();
int length = m_core.BitRead();
var buffer = new byte[length];
var wrapper = new AsyncWrapper(Interlocked.Increment(ref m_readId));
m_buffers.Add(wrapper.Id, buffer);
var ret = m_core.BeginRead(buffer, 0, length, ar => {
wrapper.Core = ar;
cb(wrapper);
}, state);
return ret;
}
/// <summary>
/// Gets the request stream
/// </summary>
/// <returns>The request stream</returns>
public Stream GetRequestStream()
{
if (m_state == RequestStates.GetRequest)
{
return((Stream)m_asyncRequest.GetResponseOrStream());
}
if (m_state != RequestStates.Created)
{
throw new InvalidOperationException();
}
m_asyncRequest = new AsyncWrapper(this, true);
m_state = RequestStates.GetRequest;
return(TrySetTimeout((Stream)m_asyncRequest.GetResponseOrStream(), m_activity_timeout));
}
/// <summary>
/// Gets the response object
/// </summary>
/// <returns>The web response</returns>
public WebResponse GetResponse()
{
if (m_state == RequestStates.GetResponse)
{
return((WebResponse)m_asyncResponse.GetResponseOrStream());
}
if (m_state == RequestStates.Done)
{
throw new InvalidOperationException();
}
m_asyncRequest = null;
m_asyncResponse = new AsyncWrapper(this, false);
m_state = RequestStates.GetResponse;
return((WebResponse)m_asyncResponse.GetResponseOrStream());
}
public static IAsyncOperation <string> GetDisplayContentAsync(this Tag tag)
{
var settings = SettingCollection.Current;
if (settings.UseChineseTagTranslation)
{
var r = tag.GetEhTagTranslatorRecord();
if (r != null)
{
return(AsyncWrapper.CreateCompleted(r.Translated.Text));
}
}
if (settings.UseJapaneseTagTranslation)
{
var t = tag.GetEhWikiRecordAsync();
if (t.Status == AsyncStatus.Completed)
{
var r = t.GetResults();
if (!match(tag, r))
{
return(AsyncWrapper.CreateCompleted(tag.Content));
}
return(AsyncWrapper.CreateCompleted(r.Japanese ?? tag.Content));
}
return(Run(async token =>
{
try
{
var r = await t;
if (!match(tag, r))
{
return tag.Content;
}
return r.Japanese ?? tag.Content;
}
catch (Exception)
{
return tag.Content;
}
}));
}
return(AsyncWrapper.CreateCompleted(tag.Content));
}
protected internal static IAsyncOperation <StorageFolder> GetImageFolderAsync()
{
var temp = ImageFolder;
if (temp != null)
{
return(AsyncWrapper.CreateCompleted(temp));
}
return(Run(async token =>
{
var temp2 = ImageFolder;
if (temp2 == null)
{
temp2 = await ApplicationData.Current.LocalCacheFolder.CreateFolderAsync("Images", CreationCollisionOption.OpenIfExists);
ImageFolder = temp2;
}
return temp2;
}));
}
public static IAsyncOperation <IList <Gallery> > FetchGalleriesAsync(IReadOnlyList <GalleryInfo> galleryInfo)
{
if (galleryInfo == null)
{
throw new ArgumentNullException(nameof(galleryInfo));
}
if (galleryInfo.Count <= 0)
{
return(AsyncWrapper.CreateCompleted((IList <Gallery>)Array.Empty <Gallery>()));
}
if (galleryInfo.Count <= 25)
{
return(Run <IList <Gallery> >(async token =>
{
var re = await new GalleryDataRequest(galleryInfo, 0, galleryInfo.Count).GetResponseAsync();
var data = re.GalleryMetaData;
data.ForEach(async g => await g.InitAsync());
return data;
}));
}
else
{
return(Run <IList <Gallery> >(async token =>
{
var result = new Gallery[galleryInfo.Count];
var pageCount = MathHelper.GetPageCount(galleryInfo.Count, 25);
for (var i = 0; i < pageCount; i++)
{
var pageSize = MathHelper.GetSizeOfPage(galleryInfo.Count, 25, i);
var startIndex = MathHelper.GetStartIndexOfPage(25, i);
var re = await new GalleryDataRequest(galleryInfo, startIndex, pageSize).GetResponseAsync();
var data = re.GalleryMetaData;
data.ForEach(async g => await g.InitAsync());
data.CopyTo(result, startIndex);
}
return result;
}));
}
}
/// <summary>
/// Gets the request stream
/// </summary>
/// <returns>The request stream</returns>
public Stream GetRequestStream()
{
if (m_state == RequestStates.GetRequest)
{
return((Stream)m_asyncRequest.GetResponseOrStream());
}
if (m_state != RequestStates.Created)
{
throw new InvalidOperationException();
}
m_asyncRequest = new AsyncWrapper(this, true);
m_state = RequestStates.GetRequest;
var s = (Stream)m_asyncRequest.GetResponseOrStream();
try { s.WriteTimeout = m_activity_timeout; }
catch { }
return(s);
}
public override IAsyncOperation <LaunchResult> HandleAsync(UriHandlerData data)
{
var keyword = "";
var category = (FavoriteCategory)null;
var ap = false;
foreach (var item in data.Queries)
{
switch (item.Key)
{
case "f_apply":
ap = item.Value.QueryValueAsBoolean();
break;
case "favcat":
if (item.Value != "all")
{
var index = item.Value.QueryValueAsInt32();
index = Math.Max(0, index);
index = Math.Min(9, index);
category = Client.Current.Favorites[index];
}
break;
case "f_search":
keyword = UnescapeKeyword(item.Value);
break;
}
}
if (!ap)
{
return(AsyncWrapper.CreateCompleted <LaunchResult>(new SearchLaunchResult(Client.Current.Favorites.Search("", category))));
}
else
{
return(AsyncWrapper.CreateCompleted <LaunchResult>(new SearchLaunchResult(Client.Current.Favorites.Search(keyword, category))));
}
}
protected override IAsyncAction InitOverrideAsync()
{
return(AsyncWrapper.CreateCompleted());
}
private void PreloadMangas()
{
var preloadables = _scrapers.Where(s => s is IPreload).Select(s => s as IPreload);
// if there are no preloadables skip the execution
if (!preloadables.Any())
return;
if (!ProgressIndeterminate)
{
CurrentActionText = "Preloading manga directories ...";
ProgressIndeterminate = true;
InvokePropertyChanged("ProgressIndeterminate");
InvokePropertyChanged("CurrentActionText");
}
var async = new AsyncWrapper();
async.Call<object>(() =>
{
System.Threading.Tasks.Parallel.ForEach(preloadables, (x) => { x.PreloadDirectory(); });
return null;
},
(x, y) =>
{
// don't care about errors...
ProgressIndeterminate = false;
InvokePropertyChanged("ProgressIndeterminate");
CurrentActionText = "";
InvokePropertyChanged("CurrentActionText");
}
);
}
public override IAsyncOperation <LaunchResult> HandleAsync(UriHandlerData data)
{
GalleryInfo.TryParseGallery(data, out var info);
return(AsyncWrapper.CreateCompleted((LaunchResult) new GalleryLaunchResult(info, -1, GalleryLaunchStatus.Default)));
}
/// <summary>
/// Gets the request stream
/// </summary>
/// <returns>The request stream</returns>
public Stream GetRequestStream()
{
if (m_state == RequestStates.GetRequest)
return (Stream)m_asyncRequest.GetResponseOrStream();
if (m_state != RequestStates.Created)
throw new InvalidOperationException();
m_asyncRequest = new AsyncWrapper(this, true);
m_state = RequestStates.GetRequest;
var s = (Stream)m_asyncRequest.GetResponseOrStream();
try { s.WriteTimeout = m_activity_timeout; }
catch { }
return s;
}
/// <summary>
/// Gets the response object
/// </summary>
/// <returns>The web response</returns>
public WebResponse GetResponse()
{
if (m_state == RequestStates.GetResponse)
return (WebResponse)m_asyncResponse.GetResponseOrStream();
if (m_state == RequestStates.Done)
throw new InvalidOperationException();
m_asyncRequest = null;
m_asyncResponse = new AsyncWrapper(this, false);
m_state = RequestStates.GetResponse;
return (WebResponse)m_asyncResponse.GetResponseOrStream();
}
/// <summary>
/// Gets the request stream
/// </summary>
/// <returns>The request stream</returns>
public Stream GetRequestStream()
{
if (m_state == RequestStates.GetRequest)
return (Stream)m_asyncRequest.GetResponseOrStream();
if (m_state != RequestStates.Created)
throw new InvalidOperationException();
m_asyncRequest = new AsyncWrapper(this, true);
m_state = RequestStates.GetRequest;
return TrySetTimeout((Stream)m_asyncRequest.GetResponseOrStream(), m_activity_timeout);
}
